VMM: Removes the epte_t from pte_t
authorBarret Rhoden <brho@cs.berkeley.edu>
Thu, 2 Apr 2015 12:24:08 +0000 (08:24 -0400)
committerBarret Rhoden <brho@cs.berkeley.edu>
Tue, 7 Apr 2015 19:06:59 +0000 (15:06 -0400)
A pte is just a kpte_t* - still different than a month ago, where pte ==
kpte.  Now pte == kpte*.  But we don't need to track the epte with the
kpte, since we can find the epte from the kpte.

I kept the eptp as part of the pgdir.  Arguably, the cr3 belongs there
too.  Often the cr3 and eptp have extra bits in them, other than just
the PADDR of the PML4, so it's handy to keep them around.

kern/arch/x86/pmap64.c
kern/arch/x86/pmap_ops.h
kern/arch/x86/ros/mmu64.h

index d9a2dd8..66e7129 100644 (file)
@@ -379,10 +379,7 @@ pte_t pgdir_walk(pgdir_t pgdir, const void *va, int create)
        int flags = PML1_SHIFT;
        if (create == 1)
                flags |= PG_WALK_CREATE;
-       ret.kpte = pml_walk(pgdir_get_kpt(pgdir), (uintptr_t)va, flags);
-       /* TODO: (EPT) walk the EPT */
-       ret.epte = 0;
-       return ret;
+       return pml_walk(pgdir_get_kpt(pgdir), (uintptr_t)va, flags);
 }
 
 static int pml_perm_walk(kpte_t *pml, const void *va, int pml_shift)
@@ -444,7 +441,7 @@ void vm_init(void)
 
        boot_cr3 = get_boot_pml4();
        boot_pgdir.kpte = boot_kpt;
-       boot_pgdir.epte = 0;
+       boot_pgdir.eptp = 0;
        gdt = KADDR(get_gdt64());
 
        /* We need to limit our mappings on machines that don't support 1GB pages */
@@ -505,12 +502,11 @@ int env_user_mem_walk(struct proc *p, void *start, size_t len,
                          void *data)
        {
                struct tramp_package *tp = (struct tramp_package*)data;
-               pte_t half_pte = {.kpte = kpte, .epte = 0};
                assert(tp->cb);
                /* memwalk CBs don't know how to handle intermediates or jumbos */
                if (shift != PML1_SHIFT)
                        return 0;
-               return tp->cb(tp->p, half_pte, (void*)kva, tp->cb_arg);
+               return tp->cb(tp->p, kpte, (void*)kva, tp->cb_arg);
        }
 
        int ret;
@@ -608,8 +604,6 @@ int arch_pgdir_setup(pgdir_t boot_copy, pgdir_t *new_pd)
        kpt[PML4(UVPT)] = PTE(LA2PPN(PADDR(kpt)), PTE_USER_RO);
 
        new_pd->kpte = kpt;
-       /* Processes do not have EPTs by default, only once they are VMMs */
-       new_pd->epte = ept;     /* TODO: remove this soon */
        new_pd->eptp = construct_eptp(PADDR(ept));
        return 0;
 }
@@ -622,7 +616,7 @@ physaddr_t arch_pgdir_get_cr3(pgdir_t pd)
 void arch_pgdir_clear(pgdir_t *pd)
 {
        pd->kpte = 0;
-       pd->epte = 0;
+       pd->eptp = 0;
 }
 
 /* Returns the page shift of the largest jumbo supported */
index 8e7e574..19a0fec 100644 (file)
@@ -20,7 +20,7 @@
 
 static inline bool pte_walk_okay(pte_t pte)
 {
-       return pte.kpte ? TRUE : FALSE;
+       return pte ? TRUE : FALSE;
 }
 
 /* PTE states:
@@ -43,69 +43,69 @@ static inline bool pte_walk_okay(pte_t pte)
  *     - unmapped: completely unused. (0 value) */
 static inline bool pte_is_present(pte_t pte)
 {
-       return kpte_is_present(pte.kpte);
+       return kpte_is_present(pte);
 }
 
 static inline bool pte_is_unmapped(pte_t pte)
 {
-       return kpte_is_unmapped(pte.kpte);
+       return kpte_is_unmapped(pte);
 }
 
 static inline bool pte_is_mapped(pte_t pte)
 {
-       return kpte_is_mapped(pte.kpte);
+       return kpte_is_mapped(pte);
 }
 
 static inline bool pte_is_paged_out(pte_t pte)
 {
-       return kpte_is_paged_out(pte.kpte);
+       return kpte_is_paged_out(pte);
 }
 
 static inline bool pte_is_dirty(pte_t pte)
 {
-       return kpte_is_dirty(pte.kpte) ||
-              epte_is_dirty(kpte_to_epte(pte.kpte));
+       return kpte_is_dirty(pte) ||
+              epte_is_dirty(kpte_to_epte(pte));
 }
 
 static inline bool pte_is_accessed(pte_t pte)
 {
-       return kpte_is_accessed(pte.kpte) ||
-              epte_is_accessed(kpte_to_epte(pte.kpte));
+       return kpte_is_accessed(pte) ||
+              epte_is_accessed(kpte_to_epte(pte));
 }
 
 /* Used in debugging code - want something better involving the walk */
 static inline bool pte_is_jumbo(pte_t pte)
 {
-       return kpte_is_jumbo(pte.kpte);
+       return kpte_is_jumbo(pte);
 }
 
 static inline physaddr_t pte_get_paddr(pte_t pte)
 {
-       return kpte_get_paddr(pte.kpte);
+       return kpte_get_paddr(pte);
 }
 
 /* Returns the PTE in an unsigned long, for debugging mostly. */
 static inline unsigned long pte_print(pte_t pte)
 {
-       return kpte_print(pte.kpte);
+       return kpte_print(pte);
 }
 
 static inline void pte_write(pte_t pte, physaddr_t pa, int perm)
 {
-       kpte_write(pte.kpte, pa, perm);
-       epte_write(kpte_to_epte(pte.kpte), pa, perm);
+       kpte_write(pte, pa, perm);
+       epte_write(kpte_to_epte(pte), pa, perm);
 }
 
 static inline void pte_clear_present(pte_t pte)
 {
-       kpte_clear_present(pte.kpte);
-       epte_clear_present(kpte_to_epte(pte.kpte));
+       kpte_clear_present(pte);
+       epte_clear_present(kpte_to_epte(pte));
 }
 
 static inline void pte_clear(pte_t pte)
 {
-       kpte_clear(pte.kpte);
-       epte_clear(kpte_to_epte(pte.kpte));
+       kpte_clear(pte);
+       epte_clear(kpte_to_epte(pte));
 }
 
 /* These are used by memcpy_*_user, but are very dangerous (and possibly used
@@ -116,25 +116,25 @@ static inline void pte_clear(pte_t pte)
  * to an intermediate PTE, we'd miss that. */
 static inline bool pte_has_perm_ur(pte_t pte)
 {
-       return kpte_has_perm_ur(pte.kpte);
+       return kpte_has_perm_ur(pte);
 }
 
 static inline bool pte_has_perm_urw(pte_t pte)
 {
-       return kpte_has_perm_urw(pte.kpte);
+       return kpte_has_perm_urw(pte);
 }
 
 /* return the arch-independent format for prots - whatever you'd expect to
  * receive for pte_write.  Careful with the ret, since a valid type is 0. */
 static inline int pte_get_perm(pte_t pte)
 {
-       return kpte_get_perm(pte.kpte);
+       return kpte_get_perm(pte);
 }
 
 static inline void pte_replace_perm(pte_t pte, int perm)
 {
-       kpte_replace_perm(pte.kpte, perm);
-       epte_replace_perm(kpte_to_epte(pte.kpte), perm);
+       kpte_replace_perm(pte, perm);
+       epte_replace_perm(kpte_to_epte(pte), perm);
 }
 
 #endif /* ROS_ARCH_PMAPS_OPS_H */
index 38b8361..be2058e 100644 (file)
 typedef unsigned long kpte_t;
 typedef unsigned long epte_t;
 
-typedef struct x86_pte {
-       kpte_t  *kpte;
-       epte_t  *epte;
-} pte_t;
+typedef kpte_t* pte_t;
 
 typedef struct x86_pgdir {
        kpte_t  *kpte;
-       epte_t  *epte;
        uint64_t eptp;
 } pgdir_t;
 #endif