optimize(mm): rename pptr_t, make funcs constexpr

include/asm/sys.h

@@ -10,14 +10,14 @@ extern "C" {
 void asm_switch_pd(pd_t pd_addr);
 void asm_enable_paging(pd_t pd_addr);
 
-phys_ptr_t current_pd(void);
+pptr_t current_pd(void);
 
 // the limit should be set on the higher 16bit
 // e.g. (n * sizeof(segment_descriptor) - 1) << 16
 // the lower bit off the limit is either 0 or 1
 // indicating whether or not to enable interrupt
 // after loading gdt
-void asm_load_gdt(uint32_t limit, phys_ptr_t addr);
+void asm_load_gdt(uint32_t limit, pptr_t addr);
 
 void asm_load_tr(uint16_t index);
 

include/kernel/mm.hpp

@@ -52,113 +52,90 @@ extern mm_list* kernel_mms;
 extern page empty_page;
 
 // translate physical address to virtual(mapped) address
-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, void* v_ptr);
-
-// translate virtual(mapped) address to physical address
-phys_ptr_t v_ptr_to_p_ptr(void* v_ptr);
+void* ptovp(pptr_t p_ptr);
 
 // @return the pointer to the mm_area containing l_ptr
 //         nullptr if not
 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, void* l_ptr);
-
-inline size_t vptrdiff(void* p1, void* p2)
+inline constexpr size_t vptrdiff(void* p1, void* p2)
 {
     return (uint8_t*)p1 - (uint8_t*)p2;
 }
-
-inline page_t phys_addr_to_page(phys_ptr_t ptr)
+inline constexpr page* lto_page(const mm* mm_area, void* l_ptr)
+{
+    size_t offset = vptrdiff(l_ptr, mm_area->start);
+    return &mm_area->pgs->at(offset / PAGE_SIZE);
+}
+inline constexpr page_t to_page(pptr_t ptr)
 {
     return ptr >> 12;
 }
-
-inline pd_i_t page_to_pd_i(page_t p)
+inline constexpr size_t to_pdi(page_t pg)
 {
-    return p >> 10;
+    return pg >> 10;
 }
-
-inline constexpr pt_i_t page_to_pt_i(page_t p)
+inline constexpr size_t to_pti(page_t pg)
 {
-    return p & (1024 - 1);
+    return pg & (1024 - 1);
 }
-
-inline phys_ptr_t page_to_phys_addr(page_t p)
+inline constexpr pptr_t to_pp(page_t p)
 {
     return p << 12;
 }
-
-inline pd_i_t linr_addr_to_pd_i(void* ptr)
+inline constexpr size_t lto_pdi(pptr_t ptr)
 {
-    return page_to_pd_i(phys_addr_to_page((phys_ptr_t)ptr));
+    return to_pdi(to_page(ptr));
 }
-
-inline pd_i_t linr_addr_to_pt_i(void* ptr)
+inline constexpr size_t lto_pti(pptr_t ptr)
 {
-    return page_to_pt_i(phys_addr_to_page((phys_ptr_t)ptr));
+    return to_pti(to_page(ptr));
+}
+inline constexpr pte_t* to_pte(pt_t pt, page_t pg)
+{
+    return *pt + to_pti(pg);
 }
-
 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));
+    return ptovp(to_pp(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);
+    return *pd + lto_pdi((pptr_t)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);
+    return *pt + lto_pti((pptr_t)addr);
 }
-
-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)
+inline pte_t* to_pte(pde_t* pde, page_t pg)
+{
+    return to_pte(to_pt(pde), pg);
+}
+inline constexpr void* mmend(const mm* mm_area)
 {
     return (char*)mm_area->start + mm_area->pgs->size() * PAGE_SIZE;
 }

include/types/size.h

@@ -18,8 +18,5 @@ typedef uint64_t ptr_t;
 typedef int64_t diff_t;
 #endif
 
-typedef ptr_t phys_ptr_t;
-typedef ptr_t linr_ptr_t;
+typedef ptr_t pptr_t;
 typedef size_t page_t;
-typedef size_t pd_i_t;
-typedef size_t pt_i_t;

include/types/vector.hpp

@@ -223,13 +223,13 @@ public:
         return m_arr;
     }
 
-    value_type& at(index_type i) noexcept
+    constexpr value_type& at(index_type i) noexcept
     {
         // TODO: boundary check
         return _at(i);
     }
 
-    const value_type& at(index_type i) const noexcept
+    constexpr const value_type& at(index_type i) const noexcept
     {
         // TODO: boundary check
         return _at(i);
@@ -274,12 +274,12 @@ public:
         --m_size;
     }
 
-    size_type size(void) const noexcept
+    constexpr size_type size(void) const noexcept
     {
         return m_size;
     }
 
-    size_type capacity(void) const noexcept
+    constexpr size_type capacity(void) const noexcept
     {
         return m_capacity;
     }

src/kernel/interrupt.cpp

@@ -175,7 +175,7 @@ extern "C" void int14_handler(int14_data* d)
         _int14_panic(d->v_eip, d->l_addr, d->error_code);
 
     pte_t* pte = to_pte(mms_get_pd(mms), d->l_addr);
-    page* page = find_page_by_l_ptr(mms, d->l_addr);
+    page* page = lto_page(mm_area, d->l_addr);
 
     if (d->error_code.present == 0 && !mm_area->mapped_file)
         _int14_panic(d->v_eip, d->l_addr, d->error_code);

src/kernel/mem.cpp

@@ -20,8 +20,8 @@ mm_list* kernel_mms;
 
 // constant values
 
-#define EMPTY_PAGE_ADDR ((phys_ptr_t)0x5000)
-#define EMPTY_PAGE_END ((phys_ptr_t)0x6000)
+#define EMPTY_PAGE_ADDR ((pptr_t)0x5000)
+#define EMPTY_PAGE_END ((pptr_t)0x6000)
 
 #define IDENTICALLY_MAPPED_HEAP_SIZE ((size_t)0x400000)
 
@@ -222,7 +222,7 @@ void ki_free(void* ptr)
     kernel_ident_mapped_allocator.free(ptr);
 }
 
-void* p_ptr_to_v_ptr(phys_ptr_t p_ptr)
+void* ptovp(pptr_t p_ptr)
 {
     if (p_ptr <= 0x30000000) {
         // memory below 768MiB is identically mapped
@@ -234,28 +234,6 @@ void* p_ptr_to_v_ptr(phys_ptr_t p_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 >= mmend(&item))
-            continue;
-        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);
-    }
-
-    // TODO: handle error
-    return 0xffffffff;
-}
-
-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, v_ptr);
-}
-
 static inline void mark_page(page_t n)
 {
     bm_set(mem_bitmap, n);
@@ -266,32 +244,32 @@ static inline void free_page(page_t n)
     bm_clear(mem_bitmap, n);
 }
 
-static void mark_addr_len(phys_ptr_t start, size_t n)
+static void mark_addr_len(pptr_t start, size_t n)
 {
     if (n == 0)
         return;
-    page_t start_page = phys_addr_to_page(start);
-    page_t end_page = phys_addr_to_page(start + n + 4095);
+    page_t start_page = to_page(start);
+    page_t end_page = to_page(start + n + 4095);
     for (page_t i = start_page; i < end_page; ++i)
         mark_page(i);
 }
 
-static void free_addr_len(phys_ptr_t start, size_t n)
+static void free_addr_len(pptr_t start, size_t n)
 {
     if (n == 0)
         return;
-    page_t start_page = phys_addr_to_page(start);
-    page_t end_page = phys_addr_to_page(start + n + 4095);
+    page_t start_page = to_page(start);
+    page_t end_page = to_page(start + n + 4095);
     for (page_t i = start_page; i < end_page; ++i)
         free_page(i);
 }
 
-static inline void mark_addr_range(phys_ptr_t start, phys_ptr_t end)
+static inline void mark_addr_range(pptr_t start, pptr_t end)
 {
     mark_addr_len(start, end - start);
 }
 
-static inline void free_addr_range(phys_ptr_t start, phys_ptr_t end)
+static inline void free_addr_range(pptr_t start, pptr_t end)
 {
     free_addr_len(start, end - start);
 }
@@ -397,19 +375,6 @@ mm* find_mm_area(mm_list* mms, void* l_ptr)
     return nullptr;
 }
 
-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 < mmend(&item)) {
-            size_t offset = vptrdiff(l_ptr, item.start);
-            return &item.pgs->at(offset / PAGE_SIZE);
-        }
-    }
-
-    // TODO: error handling
-    return nullptr;
-}
-
 static inline void map_raw_page_to_pte(
     pte_t* pte,
     page_t page,
@@ -523,7 +488,7 @@ int mmap(
 // to avoid dead loops
 static inline void _init_map_page_identically(page_t page)
 {
-    pde_t* pde = *KERNEL_PAGE_DIRECTORY_ADDR + page_to_pd_i(page);
+    pde_t* pde = *KERNEL_PAGE_DIRECTORY_ADDR + to_pdi(page);
     // page table not exist
     if (!pde->in.p) {
         // allocate a page for the page table
@@ -544,11 +509,11 @@ static inline void _init_map_page_identically(page_t page)
 
 static inline void init_paging_map_low_mem_identically(void)
 {
-    for (phys_ptr_t addr = 0x01000000; addr < 0x30000000; addr += 0x1000) {
+    for (pptr_t addr = 0x01000000; addr < 0x30000000; addr += 0x1000) {
         // check if the address is valid and not mapped
-        if (bm_test(mem_bitmap, phys_addr_to_page(addr)))
+        if (bm_test(mem_bitmap, to_page(addr)))
             continue;
-        _init_map_page_identically(phys_addr_to_page(addr));
+        _init_map_page_identically(to_page(addr));
     }
 }
 
@@ -578,7 +543,7 @@ void init_mem(void)
 
     // create empty_page struct
     empty_page.attr.in.cow = 0;
-    empty_page.phys_page_id = phys_addr_to_page(EMPTY_PAGE_ADDR);
+    empty_page.phys_page_id = to_page(EMPTY_PAGE_ADDR);
     empty_page.ref_count = types::kernel_ident_allocator_new<size_t>(1);
     empty_page.pte = to_pte(*KERNEL_PAGE_DIRECTORY_ADDR, empty_page.phys_page_id);
 

src/kernel/process.cpp

@@ -59,7 +59,7 @@ process::process(const process& val, const thread& main_thd)
 
     if (!val.attr.system) {
         // TODO: allocate low mem
-        k_esp = (void*)page_to_phys_addr(alloc_n_raw_pages(2));
+        k_esp = (void*)to_pp(alloc_n_raw_pages(2));
         memset((char*)k_esp, 0x00, THREAD_KERNEL_STACK_SIZE);
         k_esp = (char*)k_esp + THREAD_KERNEL_STACK_SIZE;
 
@@ -81,7 +81,7 @@ process::process(const process& val, const thread& main_thd)
         }
     } else {
         // TODO: allocate low mem
-        k_esp = (void*)page_to_phys_addr(alloc_n_raw_pages(2));
+        k_esp = (void*)to_pp(alloc_n_raw_pages(2));
         memcpy(k_esp, main_thd.owner->k_esp, THREAD_KERNEL_STACK_SIZE);
         k_esp = (char*)k_esp + THREAD_KERNEL_STACK_SIZE;
 
@@ -102,7 +102,7 @@ process::process(void* start_eip)
     , pid { max_pid++ }
 {
     // TODO: allocate low mem
-    k_esp = (void*)page_to_phys_addr(alloc_n_raw_pages(2));
+    k_esp = (void*)to_pp(alloc_n_raw_pages(2));
     memset((char*)k_esp, 0x00, THREAD_KERNEL_STACK_SIZE);
     k_esp = (char*)k_esp + THREAD_KERNEL_STACK_SIZE;
 

src/kernel_main.c

@@ -128,7 +128,7 @@ void load_new_gdt(void)
     create_segment_descriptor(new_gdt + 4, 0, ~0, 0b1100, SD_TYPE_DATA_USER);
     create_segment_descriptor(new_gdt + 5, (uint32_t)&tss, sizeof(tss), 0b0000, SD_TYPE_TSS);
 
-    asm_load_gdt((6 * 8 - 1) << 16, (phys_ptr_t)new_gdt);
+    asm_load_gdt((6 * 8 - 1) << 16, (pptr_t)new_gdt);
     asm_load_tr((6 - 1) * 8);
 
     asm_cli();