style(mm): simplify code

include/asm/sys.h

@@ -7,8 +7,8 @@
 extern "C" {
 #endif
 
-void asm_switch_pd(page_directory_entry* pd_addr);
-void asm_enable_paging(page_directory_entry* pd_addr);
+void asm_switch_pd(pd_t pd_addr);
+void asm_enable_paging(pd_t pd_addr);
 
 phys_ptr_t current_pd(void);
 

include/kernel/mem.h

@@ -40,23 +40,22 @@ struct e820_mem_map_entry_24 {
  * ps  : use 4MiB pages (ignored)
  * addr: page table address
  */
-struct page_directory_entry_in {
-    uint32_t p : 1;
-    uint32_t rw : 1;
-    uint32_t us : 1;
-    uint32_t pwt : 1;
-    uint32_t pcd : 1;
-    uint32_t a : 1;
-    uint32_t d : 1;
-    uint32_t ps : 1;
-    uint32_t ignored : 4;
-    page_t pt_page : 20;
-};
-
-typedef union page_directory_entry {
+typedef union pde_t {
     uint32_t v;
-    struct page_directory_entry_in in;
-} page_directory_entry;
+    struct {
+        uint32_t p : 1;
+        uint32_t rw : 1;
+        uint32_t us : 1;
+        uint32_t pwt : 1;
+        uint32_t pcd : 1;
+        uint32_t a : 1;
+        uint32_t d : 1;
+        uint32_t ps : 1;
+        uint32_t ignored : 4;
+        page_t pt_page : 20;
+    } in;
+} pde_t;
+typedef pde_t (*pd_t)[1024];
 
 /*
  * page table entry
@@ -72,24 +71,23 @@ typedef union page_directory_entry {
  * g   : used in cr4 mode (ignored)
  * addr: physical memory address
  */
-struct page_table_entry_in {
-    uint32_t p : 1;
-    uint32_t rw : 1;
-    uint32_t us : 1;
-    uint32_t pwt : 1;
-    uint32_t pcd : 1;
-    uint32_t a : 1;
-    uint32_t d : 1;
-    uint32_t pat : 1;
-    uint32_t g : 1;
-    uint32_t ignored : 3;
-    page_t page : 20;
-};
-
-typedef union page_table_entry {
+typedef union pte_t {
     uint32_t v;
-    struct page_table_entry_in in;
-} page_table_entry;
+    struct {
+        uint32_t p : 1;
+        uint32_t rw : 1;
+        uint32_t us : 1;
+        uint32_t pwt : 1;
+        uint32_t pcd : 1;
+        uint32_t a : 1;
+        uint32_t d : 1;
+        uint32_t pat : 1;
+        uint32_t g : 1;
+        uint32_t ignored : 3;
+        page_t page : 20;
+    } in;
+} pte_t;
+typedef pte_t (*pt_t)[1024];
 
 // in kernel_main.c
 extern uint8_t e820_mem_map[1024];
@@ -109,7 +107,7 @@ void* ki_malloc(size_t size);
 
 void ki_free(void* ptr);
 
-#define KERNEL_PAGE_DIRECTORY_ADDR ((page_directory_entry*)0x00000000)
+#define KERNEL_PAGE_DIRECTORY_ADDR ((pd_t)0x00000000)
 
 void init_mem(void);
 

include/kernel/mm.hpp

@@ -1,5 +1,6 @@
 #pragma once
 
+#include "types/size.h"
 #include <kernel/mem.h>
 #include <kernel/vfs.hpp>
 #include <types/allocator.hpp>
@@ -9,37 +10,39 @@
 
 constexpr size_t THREAD_KERNEL_STACK_SIZE = 2 * PAGE_SIZE;
 
-struct page_attr {
-    uint32_t cow : 1;
-};
-
 struct page {
     page_t phys_page_id;
-    page_table_entry* pte;
+    pte_t* pte;
     size_t* ref_count;
-    struct page_attr attr;
+    union {
+        uint32_t v;
+        struct {
+            uint32_t cow : 1;
+        } in;
+    } attr;
 };
 
 using page_arr = types::vector<page, types::kernel_ident_allocator>;
 
-struct mm_attr {
-    uint32_t read : 1;
-    uint32_t write : 1;
-    uint32_t system : 1;
-};
-
 class mm {
 public:
-    linr_ptr_t start;
-    struct mm_attr attr;
-    page_directory_entry* pd;
+    void* start;
+    union {
+        uint32_t v;
+        struct {
+            uint32_t read : 1;
+            uint32_t write : 1;
+            uint32_t system : 1;
+        } in;
+    } attr;
+    pd_t pd;
     page_arr* pgs;
     fs::inode* mapped_file;
     size_t file_offset;
 
 public:
     mm(const mm& val);
-    mm(linr_ptr_t start, page_directory_entry* pd, bool write, bool system);
+    mm(void* start, pd_t pd, bool write, bool system);
 };
 
 using mm_list = types::list<mm, types::kernel_ident_allocator>;
@@ -52,54 +55,114 @@ extern page empty_page;
 void* p_ptr_to_v_ptr(phys_ptr_t p_ptr);
 
 // translate linear address to physical address
-phys_ptr_t l_ptr_to_p_ptr(const mm_list* mms, linr_ptr_t v_ptr);
+phys_ptr_t l_ptr_to_p_ptr(const mm_list* mms, void* v_ptr);
 
 // translate virtual(mapped) address to physical address
 phys_ptr_t v_ptr_to_p_ptr(void* v_ptr);
 
 // @return the pointer to the mm_area containing l_ptr
 //         nullptr if not
-mm* find_mm_area(mm_list* mms, linr_ptr_t l_ptr);
+mm* find_mm_area(mm_list* mms, void* l_ptr);
 
 // find the corresponding page the l_ptr pointing to
 // @return the pointer to the struct if found, NULL if not found
-struct page* find_page_by_l_ptr(const mm_list* mms, linr_ptr_t l_ptr);
+struct page* find_page_by_l_ptr(const mm_list* mms, void* l_ptr);
+
+inline size_t vptrdiff(void* p1, void* p2)
+{
+    return (uint8_t*)p1 - (uint8_t*)p2;
+}
 
-static inline page_t phys_addr_to_page(phys_ptr_t ptr)
+inline page_t phys_addr_to_page(phys_ptr_t ptr)
 {
     return ptr >> 12;
 }
 
-static inline pd_i_t page_to_pd_i(page_t p)
+inline pd_i_t page_to_pd_i(page_t p)
 {
     return p >> 10;
 }
 
-static inline pt_i_t page_to_pt_i(page_t p)
+inline constexpr pt_i_t page_to_pt_i(page_t p)
 {
     return p & (1024 - 1);
 }
 
-static inline phys_ptr_t page_to_phys_addr(page_t p)
+inline phys_ptr_t page_to_phys_addr(page_t p)
 {
     return p << 12;
 }
 
-static inline pd_i_t linr_addr_to_pd_i(linr_ptr_t ptr)
+inline pd_i_t linr_addr_to_pd_i(void* ptr)
 {
-    return page_to_pd_i(phys_addr_to_page(ptr));
+    return page_to_pd_i(phys_addr_to_page((phys_ptr_t)ptr));
 }
 
-static inline pd_i_t linr_addr_to_pt_i(linr_ptr_t ptr)
+inline pd_i_t linr_addr_to_pt_i(void* ptr)
 {
-    return page_to_pt_i(phys_addr_to_page(ptr));
+    return page_to_pt_i(phys_addr_to_page((phys_ptr_t)ptr));
 }
 
-static inline page_directory_entry* mms_get_pd(const mm_list* mms)
+inline pd_t mms_get_pd(const mm_list* mms)
 {
     return mms->begin()->pd;
 }
 
+inline void* to_vp(page_t pg)
+{
+    return p_ptr_to_v_ptr(page_to_phys_addr(pg));
+}
+
+inline pd_t to_pd(page_t pg)
+{
+    return reinterpret_cast<pd_t>(to_vp(pg));
+}
+
+inline pt_t to_pt(page_t pg)
+{
+    return reinterpret_cast<pt_t>(to_vp(pg));
+}
+
+inline pt_t to_pt(pde_t* pde)
+{
+    return to_pt(pde->in.pt_page);
+}
+
+inline pde_t* to_pde(pd_t pd, void* addr)
+{
+    return *pd + linr_addr_to_pd_i(addr);
+}
+
+inline pte_t* to_pte(pt_t pt, void* addr)
+{
+    return *pt + linr_addr_to_pt_i(addr);
+}
+
+inline pte_t* to_pte(pt_t pt, page_t pg)
+{
+    return *pt + page_to_pt_i(pg);
+}
+
+inline pte_t* to_pte(pde_t* pde, page_t pg)
+{
+    return to_pte(to_pt(pde), pg);
+}
+
+inline pte_t* to_pte(pde_t* pde, void* addr)
+{
+    return to_pte(to_pt(pde), addr);
+}
+
+inline pte_t* to_pte(pd_t pd, void* addr)
+{
+    return to_pte(to_pde(pd, addr), addr);
+}
+
+inline void* mmend(const mm* mm_area)
+{
+    return (char*)mm_area->start + mm_area->pgs->size() * PAGE_SIZE;
+}
+
 // map the page to the end of the mm_area in pd
 int k_map(
     mm* mm_area,
@@ -129,5 +192,5 @@ page_t alloc_n_raw_pages(size_t n);
 // allocate a struct page together with the raw page
 struct page allocate_page(void);
 
-page_directory_entry* alloc_pd(void);
-page_table_entry* alloc_pt(void);
+pd_t alloc_pd(void);
+pt_t alloc_pt(void);

src/kernel/interrupt.cpp

@@ -141,7 +141,7 @@ extern "C" void int13_handler(
 }
 
 struct PACKED int14_data {
-    linr_ptr_t l_addr;
+    void* l_addr;
     struct regs_32 s_regs;
     struct page_fault_error_code error_code;
     void* v_eip;
@@ -149,7 +149,7 @@ struct PACKED int14_data {
     uint32_t eflags;
 };
 
-static inline void _int14_panic(void* eip, linr_ptr_t cr2, struct page_fault_error_code error_code)
+static inline void _int14_panic(void* eip, void* cr2, struct page_fault_error_code error_code)
 {
     char buf[256] {};
     snprintf(
@@ -174,21 +174,19 @@ extern "C" void int14_handler(int14_data* d)
     if (!mm_area)
         _int14_panic(d->v_eip, d->l_addr, d->error_code);
 
-    page_directory_entry* pde = mms_get_pd(mms) + linr_addr_to_pd_i(d->l_addr);
-    page_table_entry* pte = (page_table_entry*)p_ptr_to_v_ptr(page_to_phys_addr(pde->in.pt_page));
-    pte += linr_addr_to_pt_i(d->l_addr);
-    struct page* page = find_page_by_l_ptr(mms, d->l_addr);
+    pte_t* pte = to_pte(mms_get_pd(mms), d->l_addr);
+    page* page = find_page_by_l_ptr(mms, d->l_addr);
 
     if (d->error_code.present == 0 && !mm_area->mapped_file)
         _int14_panic(d->v_eip, d->l_addr, d->error_code);
 
     // copy on write
-    if (page->attr.cow == 1) {
+    if (page->attr.in.cow == 1) {
         // if it is a dying page
         if (*page->ref_count == 1) {
-            page->attr.cow = 0;
+            page->attr.in.cow = 0;
             pte->in.a = 0;
-            pte->in.rw = mm_area->attr.write;
+            pte->in.rw = mm_area->attr.in.write;
             return;
         }
         // duplicate the page
@@ -198,23 +196,23 @@ extern "C" void int14_handler(int14_data* d)
         if (d->error_code.present == 0)
             pte->in.p = 1;
 
-        char* new_page_data = (char*)p_ptr_to_v_ptr(page_to_phys_addr(new_page));
-        memcpy(new_page_data, p_ptr_to_v_ptr(page_to_phys_addr(page->phys_page_id)), PAGE_SIZE);
+        char* new_page_data = (char*)to_vp(new_page);
+        memcpy(new_page_data, to_vp(page->phys_page_id), PAGE_SIZE);
 
         pte->in.page = new_page;
-        pte->in.rw = mm_area->attr.write;
+        pte->in.rw = mm_area->attr.in.write;
         pte->in.a = 0;
 
         --*page->ref_count;
 
         page->ref_count = (size_t*)k_malloc(sizeof(size_t));
         *page->ref_count = 1;
-        page->attr.cow = 0;
+        page->attr.in.cow = 0;
         page->phys_page_id = new_page;
 
         // memory mapped
         if (d->error_code.present == 0) {
-            size_t offset = (d->l_addr - mm_area->start) & 0xfffff000;
+            size_t offset = vptrdiff(d->l_addr, mm_area->start) & 0xfffff000;
             vfs_read(mm_area->mapped_file, new_page_data, PAGE_SIZE, mm_area->file_offset + offset, PAGE_SIZE);
         }
     }

src/kernel/mem.cpp

@@ -234,12 +234,12 @@ void* p_ptr_to_v_ptr(phys_ptr_t p_ptr)
     }
 }
 
-phys_ptr_t l_ptr_to_p_ptr(const mm_list* mms, linr_ptr_t v_ptr)
+phys_ptr_t l_ptr_to_p_ptr(const mm_list* mms, void* v_ptr)
 {
     for (const mm& item : *mms) {
-        if (v_ptr < item.start || v_ptr >= item.start + item.pgs->size() * PAGE_SIZE)
+        if (v_ptr < item.start || v_ptr >= mmend(&item))
             continue;
-        size_t offset = (size_t)(v_ptr - item.start);
+        size_t offset = vptrdiff(v_ptr, item.start);
         const page& p = item.pgs->at(offset / PAGE_SIZE);
         return page_to_phys_addr(p.phys_page_id) + (offset % PAGE_SIZE);
     }
@@ -248,12 +248,12 @@ phys_ptr_t l_ptr_to_p_ptr(const mm_list* mms, linr_ptr_t v_ptr)
     return 0xffffffff;
 }
 
-phys_ptr_t v_ptr_to_p_ptr(const void* v_ptr)
+phys_ptr_t v_ptr_to_p_ptr(void* v_ptr)
 {
     if (v_ptr < KERNEL_IDENTICALLY_MAPPED_AREA_LIMIT) {
         return (phys_ptr_t)v_ptr;
     }
-    return l_ptr_to_p_ptr(kernel_mms, (linr_ptr_t)v_ptr);
+    return l_ptr_to_p_ptr(kernel_mms, v_ptr);
 }
 
 static inline void mark_page(page_t n)
@@ -334,30 +334,25 @@ struct page allocate_page(void)
         .phys_page_id = alloc_raw_page(),
         .pte = nullptr,
         .ref_count = types::kernel_ident_allocator_new<size_t>(0),
-        .attr {},
+        .attr { 0 },
     };
 }
 
-static inline void make_page_table(page_table_entry* pt)
-{
-    memset(pt, 0x00, sizeof(page_table_entry) * 1024);
-}
-
-page_directory_entry* alloc_pd(void)
+pd_t alloc_pd(void)
 {
     // TODO: alloc page in low mem and gen struct page for it
     page_t pd_page = alloc_raw_page();
-    page_directory_entry* pd = (page_directory_entry*)p_ptr_to_v_ptr(page_to_phys_addr(pd_page));
+    pd_t pd = to_pd(pd_page);
     memset(pd, 0x00, PAGE_SIZE);
     return pd;
 }
 
-page_table_entry* alloc_pt(void)
+pt_t alloc_pt(void)
 {
     // TODO: alloc page in low mem and gen struct page for it
     page_t pt_page = alloc_raw_page();
-    page_table_entry* pt = (page_table_entry*)p_ptr_to_v_ptr(page_to_phys_addr(pt_page));
-    make_page_table(pt);
+    pt_t pt = to_pt(pt_page);
+    memset(pt, 0x00, PAGE_SIZE);
     return pt;
 }
 
@@ -394,19 +389,19 @@ static inline void init_mem_layout(void)
     }
 }
 
-mm* find_mm_area(mm_list* mms, linr_ptr_t l_ptr)
+mm* find_mm_area(mm_list* mms, void* l_ptr)
 {
     for (auto iter = mms->begin(); iter != mms->end(); ++iter)
-        if (l_ptr >= iter->start && l_ptr < iter->start + iter->pgs->size() * PAGE_SIZE)
+        if (l_ptr >= iter->start && l_ptr < mmend(iter.ptr()))
             return iter.ptr();
     return nullptr;
 }
 
-struct page* find_page_by_l_ptr(const mm_list* mms, linr_ptr_t l_ptr)
+page* find_page_by_l_ptr(const mm_list* mms, void* l_ptr)
 {
     for (const mm& item : *mms) {
-        if (l_ptr >= item.start && l_ptr < item.start + item.pgs->size() * PAGE_SIZE) {
-            size_t offset = (size_t)(l_ptr - item.start);
+        if (l_ptr >= item.start && l_ptr < mmend(&item)) {
+            size_t offset = vptrdiff(l_ptr, item.start);
             return &item.pgs->at(offset / PAGE_SIZE);
         }
     }
@@ -416,7 +411,7 @@ struct page* find_page_by_l_ptr(const mm_list* mms, linr_ptr_t l_ptr)
 }
 
 static inline void map_raw_page_to_pte(
-    page_table_entry* pte,
+    pte_t* pte,
     page_t page,
     int present,
     int rw,
@@ -439,8 +434,8 @@ int k_map(
     int priv,
     int cow)
 {
-    linr_ptr_t addr = (linr_ptr_t)mm_area->start + mm_area->pgs->size() * PAGE_SIZE;
-    page_directory_entry* pde = mm_area->pd + linr_addr_to_pd_i(addr);
+    void* addr = mmend(mm_area);
+    pde_t* pde = to_pde(mm_area->pd, addr);
     // page table not exist
     if (!pde->in.p) {
         // allocate a page for the page table
@@ -449,16 +444,15 @@ int k_map(
         pde->in.us = (priv == 0);
         pde->in.pt_page = alloc_raw_page();
 
-        make_page_table((page_table_entry*)p_ptr_to_v_ptr(page_to_phys_addr(pde->in.pt_page)));
+        memset(to_pt(pde), 0x00, PAGE_SIZE);
     }
 
     // map the page in the page table
-    page_table_entry* pte = (page_table_entry*)p_ptr_to_v_ptr(page_to_phys_addr(pde->in.pt_page));
-    pte += linr_addr_to_pt_i(addr);
+    pte_t* pte = to_pte(pde, addr);
     map_raw_page_to_pte(pte, page->phys_page_id, read, (write && !cow), priv);
 
-    if (cow && !page->attr.cow) {
-        page->attr.cow = 1;
+    if (cow && !page->attr.in.cow) {
+        page->attr.in.cow = 1;
         page->pte->in.rw = 0;
     }
     ++*page->ref_count;
@@ -470,8 +464,8 @@ int k_map(
 
 bool check_addr_range_avail(const mm* mm_area, void* start, void* end)
 {
-    void* m_start = (void*)mm_area->start;
-    void* m_end = (void*)(mm_area->start + PAGE_SIZE * mm_area->pgs->size());
+    void* m_start = mm_area->start;
+    void* m_end = mmend(mm_area);
 
     if (start >= m_end || end <= m_start)
         return true;
@@ -502,7 +496,7 @@ static inline int _mmap(
             return GB_FAILED;
         }
 
-    auto iter_mm = mms->emplace_back((linr_ptr_t)hint, mms_get_pd(&current_process->mms), write, priv);
+    auto iter_mm = mms->emplace_back(hint, mms_get_pd(&current_process->mms), write, priv);
     iter_mm->mapped_file = file;
     iter_mm->file_offset = offset;
 
@@ -529,7 +523,7 @@ int mmap(
 // to avoid dead loops
 static inline void _init_map_page_identically(page_t page)
 {
-    page_directory_entry* pde = KERNEL_PAGE_DIRECTORY_ADDR + page_to_pd_i(page);
+    pde_t* pde = *KERNEL_PAGE_DIRECTORY_ADDR + page_to_pd_i(page);
     // page table not exist
     if (!pde->in.p) {
         // allocate a page for the page table
@@ -539,13 +533,11 @@ static inline void _init_map_page_identically(page_t page)
         pde->in.us = 0;
         pde->in.pt_page = alloc_raw_page();
         _init_map_page_identically(pde->in.pt_page);
-
-        make_page_table((page_table_entry*)p_ptr_to_v_ptr(page_to_phys_addr(pde->in.pt_page)));
+        memset(to_pt(pde), 0x00, PAGE_SIZE);
     }
 
     // map the page in the page table
-    page_table_entry* pt = (page_table_entry*)p_ptr_to_v_ptr(page_to_phys_addr(pde->in.pt_page));
-    pt += page_to_pt_i(page);
+    pte_t* pt = to_pte(pde, page);
     pt->v = 0x00000003;
     pt->in.page = page;
 }
@@ -570,29 +562,25 @@ void init_mem(void)
     init_paging_map_low_mem_identically();
 
     kernel_mms = types::kernel_ident_allocator_new<mm_list>();
-    auto heap_mm = kernel_mms->emplace_back((linr_ptr_t)KERNEL_HEAP_START, KERNEL_PAGE_DIRECTORY_ADDR, 1, 1);
+    auto heap_mm = kernel_mms->emplace_back(KERNEL_HEAP_START, KERNEL_PAGE_DIRECTORY_ADDR, 1, 1);
 
     page heap_first_page {
         .phys_page_id = alloc_raw_page(),
         .pte = nullptr,
         .ref_count = types::kernel_ident_allocator_new<size_t>(0),
-        .attr = {
-            .cow = 0,
-        },
+        .attr = { 0 },
     };
 
     k_map(heap_mm.ptr(), &heap_first_page, 1, 1, 1, 0);
     memset(KERNEL_HEAP_START, 0x00, PAGE_SIZE);
     kernel_heap_allocator = types::kernel_ident_allocator_new<brk_memory_allocator>(KERNEL_HEAP_START,
-        (uint32_t)KERNEL_HEAP_LIMIT - (uint32_t)KERNEL_HEAP_START);
+        vptrdiff(KERNEL_HEAP_LIMIT, KERNEL_HEAP_START));
 
     // create empty_page struct
-    empty_page.attr.cow = 0;
+    empty_page.attr.in.cow = 0;
     empty_page.phys_page_id = phys_addr_to_page(EMPTY_PAGE_ADDR);
     empty_page.ref_count = types::kernel_ident_allocator_new<size_t>(1);
-    empty_page.pte = ((page_table_entry*)p_ptr_to_v_ptr(
-                         page_to_phys_addr(KERNEL_PAGE_DIRECTORY_ADDR->in.pt_page)))
-        + page_to_pt_i(empty_page.phys_page_id);
+    empty_page.pte = to_pte(*KERNEL_PAGE_DIRECTORY_ADDR, empty_page.phys_page_id);
 
     // TODO: improve the algorithm SO FREAKING SLOW
     // while (kernel_mm_head->len < 256 * 1024 * 1024 / PAGE_SIZE) {
@@ -619,13 +607,13 @@ void create_segment_descriptor(
     sd->flags = flags;
 }
 
-mm::mm(linr_ptr_t start, page_directory_entry* pd, bool write, bool system)
+mm::mm(void* start, pd_t pd, bool write, bool system)
     : start(start)
-    , attr({
-          .read { 1 },
-          .write { write },
-          .system { system },
-      })
+    , attr { .in {
+          .read = 1,
+          .write = write,
+          .system = system,
+      } }
     , pd(pd)
     , pgs(types::kernel_ident_allocator_new<page_arr>())
     , mapped_file(nullptr)
@@ -635,11 +623,7 @@ mm::mm(linr_ptr_t start, page_directory_entry* pd, bool write, bool system)
 
 mm::mm(const mm& val)
     : start(val.start)
-    , attr({
-          .read { val.attr.read },
-          .write { val.attr.write },
-          .system { val.attr.system },
-      })
+    , attr { .v = val.attr.v }
     , pd(val.pd)
     , pgs(val.pgs)
     , mapped_file(nullptr)

src/kernel/process.cpp

@@ -63,20 +63,20 @@ process::process(const process& val, const thread& main_thd)
         memset((char*)k_esp, 0x00, THREAD_KERNEL_STACK_SIZE);
         k_esp = (char*)k_esp + THREAD_KERNEL_STACK_SIZE;
 
-        page_directory_entry* pd = alloc_pd();
+        pd_t pd = alloc_pd();
         memcpy(pd, mms_get_pd(kernel_mms), PAGE_SIZE);
 
         mms.begin()->pd = pd;
         // skip kernel heap
         for (auto iter_src = ++val.mms.cbegin(); iter_src != val.mms.cend(); ++iter_src) {
-            auto iter_dst = mms.emplace_back(iter_src->start, pd, iter_src->attr.write, iter_src->attr.system);
+            auto iter_dst = mms.emplace_back(iter_src->start, pd, iter_src->attr.in.write, iter_src->attr.in.system);
             iter_dst->pd = pd;
             for (auto pg = iter_src->pgs->begin(); pg != iter_src->pgs->end(); ++pg)
                 k_map(iter_dst.ptr(),
                     &*pg,
-                    iter_src->attr.read,
-                    iter_src->attr.write,
-                    iter_src->attr.system,
+                    iter_src->attr.in.read,
+                    iter_src->attr.in.write,
+                    iter_src->attr.in.system,
                     1);
         }
     } else {
@@ -137,7 +137,7 @@ void NORETURN _kernel_init(void)
     if (ret != GB_OK)
         syscall(0x03);
 
-    page_directory_entry* new_pd = alloc_pd();
+    pd_t new_pd = alloc_pd();
     memcpy(new_pd, mms_get_pd(kernel_mms), PAGE_SIZE);
 
     asm_cli();