Unifying the Lunaix's Physical Memory Model (#28)

[lunaix-os.git] / lunaix-os / includes / lunaix / mm / page.h

diff --git a/lunaix-os/includes/lunaix/mm/page.h b/lunaix-os/includes/lunaix/mm/page.h
index 29232580b6afeca0fb4e8a45da68f1bc1ace96cc..23d5c646dd5e13b6da907e45c8a1b00d90a82ca1 100644 (file)
--- a/lunaix-os/includes/lunaix/mm/page.h
+++ b/lunaix-os/includes/lunaix/mm/page.h
@@ -1,62 +1,299 @@
 #ifndef __LUNAIX_PAGE_H
 #define __LUNAIX_PAGE_H
 #ifndef __LUNAIX_PAGE_H
 #define __LUNAIX_PAGE_H

-#include <stdint.h>
-#include <lunaix/constants.h>

 
 

-#define PG_MAX_ENTRIES              1024U
-#define PG_LAST_TABLE               PG_MAX_ENTRIES - 1
-#define PG_FIRST_TABLE              0
+#include <lunaix/mm/pmm.h>
+#include <lunaix/mm/vmm.h>
+#include <lunaix/mm/vmtlb.h>

 
 

-#define P2V(paddr)          ((uintptr_t)(paddr)  +  HIGHER_HLF_BASE)
-#define V2P(vaddr)          ((uintptr_t)(vaddr)  -  HIGHER_HLF_BASE)
+#include <klibc/string.h>

 
 

-#define PG_ALIGN(addr)      ((uintptr_t)(addr)   & 0xFFFFF000UL)
+/**
+ * @brief A leaflet represent a bunch 4k ppage
+ *        as single multi-ordered page, as such
+ *        big page can seen as an unfolded version
+ *        of these small 4k ppages hence the name.
+ *        It is introduced to solve the issue that
+ *        is discovered during refactoring - It is 
+ *        jolly unclear whether the ppage is a head, 
+ *        tail, or even worse, the middle one, when
+ *        passing around between functions.
+ *        This concept is surprisingly similar to
+ *        Linux's struct folio (I swear to the 
+ *        Almighty Princess of the Sun, Celestia, 
+ *        that I don't quite understand what folio 
+ *        is until I've wrote the conceptually same 
+ *        thing)
+ * 
+ */
+struct leaflet
+{
+    struct ppage lead_page;
+};

 
 

-#define PD_INDEX(vaddr)     (((uintptr_t)(vaddr) & 0xFFC00000UL) >> 22)
-#define PT_INDEX(vaddr)     (((uintptr_t)(vaddr) & 0x003FF000UL) >> 12)
-#define PG_OFFSET(vaddr)    ((uintptr_t)(vaddr)  & 0x00000FFFUL)
+static inline struct leaflet*
+get_leaflet(struct ppage* page)
+{
+    return (struct leaflet*)leading_page(page);
+}

 
 

-#define GET_PT_ADDR(pde)    PG_ALIGN(pde)
-#define GET_PG_ADDR(pte)    PG_ALIGN(pte)
+static inline struct ppage*
+get_ppage(struct leaflet* leaflet)
+{
+    return (struct ppage*)leaflet;
+}

 
 

-#define PG_DIRTY(pte)           ((pte & (1 << 6)) >> 6)
-#define PG_ACCESSED(pte)        ((pte & (1 << 5)) >> 5)
+static inline struct leaflet*
+alloc_leaflet(int order)
+{
+    return (struct leaflet*)pmm_alloc_napot_type(POOL_UNIFIED, order, 0);
+}

 
 

-#define IS_CACHED(entry)    ((entry & 0x1))
+static inline struct leaflet*
+alloc_leaflet_pinned(int order)
+{
+    return (struct leaflet*)pmm_alloc_napot_type(POOL_UNIFIED, order, PP_FGLOCKED);
+}

 
 

-#define PG_PRESENT              (0x1)
-#define PG_WRITE                (0x1 << 1)
-#define PG_ALLOW_USER           (0x1 << 2)
-#define PG_WRITE_THROUGHT       (1 << 3)
-#define PG_DISABLE_CACHE        (1 << 4)
-#define PG_PDE_4MB              (1 << 7)
+static inline void
+leaflet_borrow(struct leaflet* leaflet)
+{
+    struct ppage* const page = get_ppage(leaflet);
+    assert(page->refs);
+    if (reserved_page(page)) {
+        return;
+    }
+    
+    page->refs++;
+}

 
 

-#define PDE(flags, pt_addr)     (PG_ALIGN(pt_addr) | ((flags) & 0xfff))
-#define PTE(flags, pg_addr)     (PG_ALIGN(pg_addr) | ((flags) & 0xfff))
+static inline void
+leaflet_return(struct leaflet* leaflet)
+{
+    struct ppage* const page = get_ppage(leaflet);
+    assert(page->refs);
+    pmm_free_one(page, 0);
+}

 
 

-#define V_ADDR(pd, pt, offset)  ((pd) << 22 | (pt) << 12 | (offset))
-#define P_ADDR(ppn, offset)     ((ppn << 12) | (offset))
+static inline unsigned int
+leaflet_refcount(struct leaflet* leaflet)
+{
+    return get_ppage(leaflet)->refs;
+}

 
 

-// 用于对PD进行循环映射，因为我们可能需要对PD进行频繁操作，我们在这里禁用TLB缓存
-#define PG_PREM_R              PG_PRESENT
-#define PG_PREM_RW             PG_PRESENT | PG_WRITE
-#define PG_PREM_UR             PG_PRESENT | PG_ALLOW_USER
-#define PG_PREM_URW            PG_PRESENT | PG_WRITE | PG_ALLOW_USER
-#define T_SELF_REF_PERM        PG_PREM_RW | PG_DISABLE_CACHE
+static inline int
+leaflet_order(struct leaflet* leaflet)
+{
+    return ppage_order(get_ppage(leaflet));
+}

 
 

+static inline int
+leaflet_size(struct leaflet* leaflet)
+{
+    return PAGE_SIZE << leaflet_order(leaflet);
+}

 
 

-// 页目录的虚拟基地址，可以用来访问到各个PDE
-#define PTD_BASE_VADDR                0xFFFFF000U
+static inline int
+leaflet_nfold(struct leaflet* leaflet)
+{
+    return 1 << leaflet_order(leaflet);
+}

 
 

-// 页表的虚拟基地址，可以用来访问到各个PTE
-#define PT_BASE_VADDR                 0xFFC00000U
+static inline struct leaflet*
+ppfn_leaflet(pfn_t ppfn)
+{
+    return get_leaflet(ppage(ppfn));
+}

 
 

-// 用来获取特定的页表的虚拟地址
-#define PT_VADDR(pd_offset)           (PT_BASE_VADDR | (pd_offset << 12))
+static inline struct leaflet*
+pte_leaflet(pte_t pte)
+{
+    struct ppage* ppfn = ppage(pfn(pte_paddr(pte)));
+    return get_leaflet(ppfn);
+}

 
 

-typedef unsigned long ptd_t;
-typedef unsigned long pt_t;
-typedef unsigned int pt_attr;
+static inline struct leaflet*
+pte_leaflet_aligned(pte_t pte)
+{
+    struct ppage* ppfn = ppage(pfn(pte_paddr(pte)));
+    struct leaflet* _l = get_leaflet(ppfn);

 
 

+    assert((ptr_t)_l == (ptr_t)ppfn);
+    return _l;
+}
+
+static inline pfn_t
+leaflet_ppfn(struct leaflet* leaflet)
+{
+    return ppfn(get_ppage(leaflet));
+}
+
+static inline ptr_t
+leaflet_addr(struct leaflet* leaflet)
+{
+    return page_addr(ppfn(get_ppage(leaflet)));
+}
+
+static inline void
+unpin_leaflet(struct leaflet* leaflet)
+{
+    change_page_type(get_ppage(leaflet), 0);
+}
+
+static inline void
+pin_leaflet(struct leaflet* leaflet)
+{
+    change_page_type(get_ppage(leaflet), PP_FGLOCKED);
+}
+
+/**
+ * @brief Map a leaflet
+ * 
+ * @param ptep 
+ * @param leaflet 
+ * @return pages folded into that leaflet
+ */
+static inline size_t
+ptep_map_leaflet(pte_t* ptep, pte_t pte, struct leaflet* leaflet)
+{
+    // We do not support huge leaflet yet
+    assert(leaflet_order(leaflet) < LEVEL_SHIFT);
+
+    pte = pte_setppfn(pte, leaflet_ppfn(leaflet));
+    pte = pte_mkloaded(pte);
+
+    int n = leaflet_nfold(leaflet);
+    vmm_set_ptes_contig(ptep, pte, LFT_SIZE, n);
+
+    return n;
+}
+
+/**
+ * @brief Unmap a leaflet
+ * 
+ * @param ptep 
+ * @param leaflet 
+ * @return pages folded into that leaflet
+ */
+static inline size_t
+ptep_unmap_leaflet(pte_t* ptep, struct leaflet* leaflet)
+{
+    // We do not support huge leaflet yet
+    assert(leaflet_order(leaflet) < LEVEL_SHIFT);
+
+    int n = leaflet_nfold(leaflet);
+    vmm_unset_ptes(ptep, n);
+
+    return n;
+}
+
+static inline ptr_t
+leaflet_mount(struct leaflet* leaflet)
+{
+    pte_t* ptep = mkptep_va(VMS_SELF, PG_MOUNT_VAR);    
+    ptep_map_leaflet(ptep, mkpte_prot(KERNEL_DATA), leaflet);
+
+    tlb_flush_kernel_ranged(PG_MOUNT_VAR, leaflet_nfold(leaflet));
+
+    return PG_MOUNT_VAR;
+}
+
+static inline void
+leaflet_unmount(struct leaflet* leaflet)
+{
+    pte_t* ptep = mkptep_va(VMS_SELF, PG_MOUNT_VAR);    
+    vmm_unset_ptes(ptep, leaflet_nfold(leaflet));
+
+    tlb_flush_kernel_ranged(PG_MOUNT_VAR, leaflet_nfold(leaflet));
+}
+
+static inline void
+leaflet_fill(struct leaflet* leaflet, unsigned int val)
+{
+    ptr_t mnt;
+    
+    mnt = leaflet_mount(leaflet);
+    memset((void*)mnt, val, leaflet_size(leaflet));
+    leaflet_unmount(leaflet);
+}
+
+static inline void
+leaflet_wipe(struct leaflet* leaflet)
+{
+    leaflet_fill(leaflet, 0);
+}
+
+/**
+ * @brief Duplicate the leaflet
+ *
+ * @return Duplication of given leaflet
+ *
+ */
+struct leaflet*
+dup_leaflet(struct leaflet* leaflet);
+
+
+/**
+ * @brief Maps a number of contiguous ptes in kernel 
+ *        address space
+ * 
+ * @param pte the pte to be mapped
+ * @param lvl_size size of the page pointed by the given pte
+ * @param n number of ptes
+ * @return ptr_t 
+ */
+ptr_t
+vmap_ptes_at(pte_t pte, size_t lvl_size, int n);
+
+/**
+ * @brief Maps a number of contiguous ptes in kernel 
+ *        address space (leaf page size)
+ * 
+ * @param pte the pte to be mapped
+ * @param n number of ptes
+ * @return ptr_t 
+ */
+static inline ptr_t
+vmap_leaf_ptes(pte_t pte, int n)
+{
+    return vmap_ptes_at(pte, LFT_SIZE, n);
+}
+
+/**
+ * @brief Maps a contiguous range of physical address 
+ *        into kernel address space (leaf page size)
+ * 
+ * @param paddr start of the physical address range
+ * @param size size of the physical range
+ * @param prot default protection to be applied
+ * @return ptr_t 
+ */
+static inline ptr_t
+vmap(struct leaflet* leaflet, pte_attr_t prot)
+{
+    pte_t _pte = mkpte(page_addr(leaflet_ppfn(leaflet)), prot);
+    return vmap_ptes_at(_pte, LFT_SIZE, leaflet_nfold(leaflet));
+}
+
+void
+vunmap(ptr_t ptr, struct leaflet* leaflet);
+
+static inline ptr_t
+vmap_range(pfn_t start, size_t npages, pte_attr_t prot)
+{
+    pte_t _pte = mkpte(page_addr(start), prot);
+    return vmap_ptes_at(_pte, LFT_SIZE, npages);
+}
+
+
+/**
+ * @brief Allocate a page in kernel space.
+ * 
+ * @param ptep 
+ * @param pte 
+ * @param order 
+ * @return pte_t 
+ */
+pte_t 
+alloc_kpage_at(pte_t* ptep, pte_t pte, int order);

 
 #endif /* __LUNAIX_PAGE_H */
 
 #endif /* __LUNAIX_PAGE_H */