paging.h

Go to the documentation of this file.

 
#pragma once
 
#include "mem/zone_allocator.h"
#include "proc_access.h"
#include "kernel.h"
#include "stddef.h"
#include "boot.h"
#include "stdint.h"
 
#define PAGE_SHIFT 12
#define PAGE_SIZE (1 << PAGE_SHIFT)
#define MAX_PHY_PFN (1UL << (32 - PAGE_SHIFT))
 
#define PROCAREA_START_ADDR 0x00000000
#define PROCAREA_END_ADDR 0xC0000000
 
#define MAX_PAGE_TABLE_ENTRIES 1024
#define MAX_PAGE_DIR_ENTRIES 1024
 
typedef struct page_dir_entry_t {
    unsigned int present : 1;   
    unsigned int rw : 1;        
    unsigned int user : 1;      
    unsigned int w_through : 1; 
    unsigned int cache : 1;     
    unsigned int accessed : 1;  
    unsigned int reserved : 1;  
    unsigned int page_size : 1; 
    unsigned int global : 1;    
    unsigned int available : 3; 
    unsigned int frame : 20;    
} page_dir_entry_t;
 
typedef struct page_table_entry_t {
    unsigned int present : 1;    
    unsigned int rw : 1;         
    unsigned int user : 1;       
    unsigned int w_through : 1;  
    unsigned int cache : 1;      
    unsigned int accessed : 1;   
    unsigned int dirty : 1;      
    unsigned int zero : 1;       
    unsigned int global : 1;     
    unsigned int kernel_cow : 1; 
    unsigned int available : 2;  
    unsigned int frame : 20;     
} page_table_entry_t;
 
enum MEMMAP_FLAGS {
    MM_USER    = 0x1, 
    MM_GLOBAL  = 0x2, 
    MM_RW      = 0x4, 
    MM_PRESENT = 0x8, 
    // Kernel flags
    MM_COW     = 0x10, 
    MM_UPDADDR = 0x20, 
};
 
typedef struct page_table_t {
    page_table_entry_t pages[MAX_PAGE_TABLE_ENTRIES];
} __attribute__((aligned(PAGE_SIZE))) page_table_t;
 
typedef struct page_directory_t {
    page_dir_entry_t entries[MAX_PAGE_DIR_ENTRIES];
} __attribute__((aligned(PAGE_SIZE))) page_directory_t;
 
typedef struct vm_area_struct_t {
    struct mm_struct_t *vm_mm;
    uint32_t vm_start;
    uint32_t vm_end;
    list_head vm_list;
    pgprot_t vm_page_prot;
    unsigned short vm_flags;
} vm_area_struct_t;
 
typedef struct mm_struct_t {
    list_head mmap_list;
    vm_area_struct_t *mmap_cache;
    page_directory_t *pgd;
    int map_count;
    list_head mm_list;
    uint32_t start_code;
    uint32_t end_code;
    uint32_t start_data;
    uint32_t end_data;
    uint32_t start_brk;
    uint32_t brk;
    uint32_t start_stack;
    uint32_t arg_start;
    uint32_t arg_end;
    uint32_t env_start;
    uint32_t env_end;
    unsigned int total_vm;
} mm_struct_t;
 
extern kmem_cache_t *pgtbl_cache;
 
static inline int vm_area_compare(const list_head *vma0, const list_head *vma1)
{
    // Retrieve the vm_area_struct from the list_head for vma0.
    vm_area_struct_t *_vma0 = list_entry(vma0, vm_area_struct_t, vm_list);
    // Retrieve the vm_area_struct from the list_head for vma1.
    vm_area_struct_t *_vma1 = list_entry(vma1, vm_area_struct_t, vm_list);
    // Compare the start address of vma0 with the end address of vma1.
    return _vma0->vm_start > _vma1->vm_end;
}
 
int paging_init(boot_info_t *info);
 
page_directory_t *paging_get_main_directory(void);
 
static inline page_directory_t *paging_get_current_directory(void)
{
    return (page_directory_t *)get_cr3();
}
 
static inline void paging_switch_directory(page_directory_t *dir)
{
    set_cr3((uintptr_t)dir);
}
 
int is_current_pgd(page_directory_t *pgd);
 
int paging_switch_directory_va(page_directory_t *dir);
 
void paging_flush_tlb_single(unsigned long addr);
 
static inline void paging_enable(void)
{
    // Clear the PSE bit from cr4.
    set_cr4(bitmask_clear(get_cr4(), CR4_PSE));
    // Set the PG bit in cr0.
    set_cr0(bitmask_set(get_cr0(), CR0_PG));
}
 
static inline int paging_is_enabled(void)
{
    return bitmask_check(get_cr0(), CR0_PG);
}
 
void page_fault_handler(pt_regs *f);
 
page_t *mem_virtual_to_page(page_directory_t *pgdir, uint32_t virt_start, size_t *size);
 
int mem_upd_vm_area(page_directory_t *pgd, uint32_t virt_start, uint32_t phy_start, size_t size, uint32_t flags);
 
int mem_clone_vm_area(page_directory_t *src_pgd,
                      page_directory_t *dst_pgd,
                      uint32_t src_start,
                      uint32_t dst_start,
                      size_t size,
                      uint32_t flags);
 
vm_area_struct_t *create_vm_area(mm_struct_t *mm,
                                 uint32_t virt_start,
                                 size_t size,
                                 uint32_t pgflags,
                                 uint32_t gfpflags);
 
uint32_t clone_vm_area(mm_struct_t *mm,
                       vm_area_struct_t *area,
                       int cow,
                       uint32_t gfpflags);
 
int destroy_vm_area(mm_struct_t *mm, vm_area_struct_t *area);
 
vm_area_struct_t *find_vm_area(mm_struct_t *mm, uint32_t vm_start);
 
int is_valid_vm_area(mm_struct_t *mm, uintptr_t vm_start, uintptr_t vm_end);
 
int find_free_vm_area(mm_struct_t *mm, size_t length, uintptr_t *vm_start);
 
mm_struct_t *create_blank_process_image(size_t stack_size);
 
mm_struct_t *clone_process_image(mm_struct_t *mmp);
 
int destroy_process_image(mm_struct_t *mm);