Update names

4 files changed, 46 insertions, 44 deletions

diff --git a/arch/arm/machine/boot.h b/arch/arm/machine/boot.h
index 4d3d95e3..e7c3c8f2 100644
--- a/arch/arm/machine/boot.h
+++ b/arch/arm/machine/boot.h
@@ -49,6 +49,13 @@
 
 #include <kern/init.h>
 
+/*
+ * Macros for boot code and data, respectively.
+ *
+ * Note that all boot data end up in the same section, which means they
+ * can't have conflicting qualifiers. As a result, boot data may not be
+ * declared const.
+ */
 #define __boot     __section(QUOTE(BOOT_TEXT_SECTION))
 #define __bootdata __section(QUOTE(BOOT_DATA_SECTION)) __attribute__((used))
 
diff --git a/arch/arm/machine/pmap.c b/arch/arm/machine/pmap.c
index ad077f64..9b864e6d 100644
--- a/arch/arm/machine/pmap.c
+++ b/arch/arm/machine/pmap.c
@@ -52,22 +52,17 @@
 
 #define PMAP_PTE_B              0x00000004
 #define PMAP_PTE_C              0x00000008
-
 #define PMAP_PTE_L0_RW          0x000000f0
 #define PMAP_PTE_L1_RW          0x00000c00
 
-/*
- * Page table level properties.
- */
-
 #define PMAP_NR_LEVELS          2
 #define PMAP_L0_BITS            8
 #define PMAP_L1_BITS            12
 
 #define PMAP_VA_MASK            0xffffffff
 
-#define PMAP_PA_L0_MASK         0xfffff000
-#define PMAP_PA_L1_MASK         0xfffffc00
+#define PMAP_L0_PA_MASK         0xfffff000
+#define PMAP_L1_PA_MASK         0xfffffc00
 
 #define PMAP_L0_SKIP            12
 #define PMAP_L1_SKIP            (PMAP_L0_SKIP + PMAP_L0_BITS)
@@ -80,7 +75,7 @@ pmap_make_coarse_pte(phys_addr_t pa, int prot)
 {
     (void)prot;
 
-    assert((pa & PMAP_PA_L1_MASK) == pa);
+    assert((pa & PMAP_L1_PA_MASK) == pa);
     return pa | PMAP_PTE_TYPE_COARSE;
 }
 
@@ -89,7 +84,7 @@ pmap_make_small_page_pte(phys_addr_t pa, int prot)
 {
     (void)prot;
 
-    assert((pa & PMAP_PA_L0_MASK) == pa);
+    assert((pa & PMAP_L0_PA_MASK) == pa);
     return pa | PMAP_PTE_L0_RW | PMAP_PTE_C | PMAP_PTE_B | PMAP_PTE_TYPE_SMALL;
 }
 
@@ -103,9 +98,9 @@ pmap_make_section_pte(phys_addr_t pa, int prot)
 }
 
 /*
- * Table of properties per page table level.
+ * Physical translation level properties.
  */
-static struct vm_ptable_level pmap_boot_pt_levels[] __bootdata = {
+static struct vm_ptable_tlp pmap_boot_tlps[] __bootdata = {
     {
         PMAP_L0_SKIP,
         PMAP_L0_BITS,
@@ -177,7 +172,7 @@ pmap_setup_paging(void)
 
     /* TODO LPAE */
 
-    vm_ptable_bootstrap(pmap_boot_pt_levels, ARRAY_SIZE(pmap_boot_pt_levels));
+    vm_ptable_bootstrap(pmap_boot_tlps, ARRAY_SIZE(pmap_boot_tlps));
 
     ptable = &kernel_pmap->ptable;
     vm_ptable_boot_build(ptable);
diff --git a/vm/vm_ptable.c b/vm/vm_ptable.c
index f5b02e98..70c6a505 100644
--- a/vm/vm_ptable.c
+++ b/vm/vm_ptable.c
@@ -51,8 +51,8 @@
 #include <vm/vm_ptable.h>
 #include <vm/vm_prot.h>
 
-static const struct vm_ptable_level *vm_ptable_boot_pt_levels __bootdata;
-static unsigned int vm_ptable_boot_nr_levels __bootdata;
+static const struct vm_ptable_tlp *vm_ptable_boot_tlps __bootdata;
+static size_t vm_ptable_boot_nr_levels __bootdata;
 
 static struct vm_ptable_cpu_pt vm_ptable_boot_cpu_pt __bootdata;
 
@@ -200,39 +200,37 @@ static char vm_ptable_panic_inval_msg[] __bootdata
     = "vm_ptable: invalid physical address";
 
 void __boot
-vm_ptable_bootstrap(const struct vm_ptable_level *pt_levels,
-                    unsigned int nr_levels)
+vm_ptable_bootstrap(const struct vm_ptable_tlp *tlps, size_t nr_levels)
 {
-    assert(pt_levels);
+    assert(tlps);
     assert(nr_levels != 0);
 
-    vm_ptable_boot_pt_levels = pt_levels;
+    vm_ptable_boot_tlps = tlps;
     vm_ptable_boot_nr_levels = nr_levels;
 }
 
-static const struct vm_ptable_level * __boot
-vm_ptable_boot_get_pt_level(unsigned int level)
+static const struct vm_ptable_tlp * __boot
+vm_ptable_boot_get_tlp(unsigned int level)
 {
     assert(level < vm_ptable_boot_nr_levels);
-    return &vm_ptable_boot_pt_levels[level];
+    return &vm_ptable_boot_tlps[level];
 }
 
 static __always_inline unsigned long
-vm_ptable_level_pte_index(const struct vm_ptable_level *pt_level, uintptr_t va)
+vm_ptable_tlp_pte_index(const struct vm_ptable_tlp *tlp, uintptr_t va)
 {
-    return ((va >> pt_level->skip) & ((1UL << pt_level->bits) - 1));
+    return ((va >> tlp->skip) & ((1UL << tlp->bits) - 1));
 }
 
 static __always_inline phys_addr_t
-vm_ptable_level_pa_mask(const struct vm_ptable_level *pt_level)
+vm_ptable_tlp_pa_mask(const struct vm_ptable_tlp *tlp)
 {
     phys_addr_t size;
 
-    if (pt_level == vm_ptable_boot_pt_levels) {
+    if (tlp == vm_ptable_boot_tlps) {
         return ~PAGE_MASK;
     } else {
-        pt_level--;
-        size = ((phys_addr_t)1 << pt_level->bits) * sizeof(pmap_pte_t);
+        size = ((phys_addr_t)1 << tlp[-1].bits) * sizeof(pmap_pte_t);
         return ~(size - 1);
     }
 }
@@ -242,20 +240,20 @@ vm_ptable_pa_aligned(phys_addr_t pa)
 {
     phys_addr_t mask;
 
-    mask = vm_ptable_level_pa_mask(vm_ptable_boot_get_pt_level(0));
+    mask = vm_ptable_tlp_pa_mask(vm_ptable_boot_get_tlp(0));
     return pa == (pa & mask);
 }
 
 void __boot
 vm_ptable_boot_build(struct vm_ptable *ptable)
 {
-    const struct vm_ptable_level *pt_level;
+    const struct vm_ptable_tlp *tlp;
     struct vm_ptable_cpu_pt *pt;
     void *ptr;
 
-    pt_level = vm_ptable_boot_get_pt_level(vm_ptable_boot_nr_levels - 1);
+    tlp = vm_ptable_boot_get_tlp(vm_ptable_boot_nr_levels - 1);
     pt = &vm_ptable_boot_cpu_pt;
-    ptr = bootmem_alloc(pt_level->ptes_per_pt * sizeof(pmap_pte_t));
+    ptr = bootmem_alloc(tlp->ptes_per_pt * sizeof(pmap_pte_t));
     pt->root = (void *)BOOT_PTOV((uintptr_t)ptr);
     ptable->cpu_pts[0] = pt;
 
@@ -268,7 +266,7 @@ void __boot
 vm_ptable_boot_enter(struct vm_ptable *ptable, uintptr_t va,
                      phys_addr_t pa, size_t page_size)
 {
-    const struct vm_ptable_level *pt_level;
+    const struct vm_ptable_tlp *tlp;
     unsigned int level, last_level;
     pmap_pte_t *pt, *next_pt, *pte;
     phys_addr_t mask;
@@ -281,23 +279,23 @@ vm_ptable_boot_enter(struct vm_ptable *ptable, uintptr_t va,
     pt = (void *)BOOT_VTOP((uintptr_t)ptable->cpu_pts[0]->root);
 
     for (level = vm_ptable_boot_nr_levels - 1; level != last_level; level--) {
-        pt_level = vm_ptable_boot_get_pt_level(level);
-        pte = &pt[vm_ptable_level_pte_index(pt_level, va)];
+        tlp = vm_ptable_boot_get_tlp(level);
+        pte = &pt[vm_ptable_tlp_pte_index(tlp, va)];
 
         if (pmap_pte_valid(*pte)) {
-            mask = vm_ptable_level_pa_mask(pt_level);
+            mask = vm_ptable_tlp_pa_mask(tlp);
             next_pt = (void *)(uintptr_t)(*pte & mask);
         } else {
-            next_pt = bootmem_alloc(pt_level[-1].ptes_per_pt * sizeof(pmap_pte_t));
-            *pte = pt_level->make_pte_fn((uintptr_t)next_pt, VM_PROT_ALL);
+            next_pt = bootmem_alloc(tlp[-1].ptes_per_pt * sizeof(pmap_pte_t));
+            *pte = tlp->make_pte_fn((uintptr_t)next_pt, VM_PROT_ALL);
         }
 
         pt = next_pt;
     }
 
-    pt_level = vm_ptable_boot_get_pt_level(last_level);
-    pte = &pt[vm_ptable_level_pte_index(pt_level, va)];
-    *pte = pt_level->make_ll_pte_fn(pa, VM_PROT_ALL);
+    tlp = vm_ptable_boot_get_tlp(last_level);
+    pte = &pt[vm_ptable_tlp_pte_index(tlp, va)];
+    *pte = tlp->make_ll_pte_fn(pa, VM_PROT_ALL);
 }
 
 pmap_pte_t * __boot
diff --git a/vm/vm_ptable.h b/vm/vm_ptable.h
index 748b1b61..6967595c 100644
--- a/vm/vm_ptable.h
+++ b/vm/vm_ptable.h
@@ -33,7 +33,10 @@ struct vm_ptable_cpu_pt {
 
 typedef pmap_pte_t (*vm_ptable_make_pte_fn)(phys_addr_t pa, int prot);
 
-struct vm_ptable_level {
+/*
+ * Translation level properties.
+ */
+struct vm_ptable_tlp {
     unsigned int skip;
     unsigned int bits;
     unsigned int ptes_per_pt;
@@ -45,13 +48,12 @@ struct vm_ptable {
     struct vm_ptable_cpu_pt *cpu_pts[CONFIG_MAX_CPUS];
 };
 
-void vm_ptable_bootstrap(const struct vm_ptable_level *pt_levels,
-                         unsigned int nr_levels);
+void vm_ptable_bootstrap(const struct vm_ptable_tlp *tlps, size_t nr_levels);
 
 void vm_ptable_boot_build(struct vm_ptable *ptable);
 
 void vm_ptable_boot_enter(struct vm_ptable *ptable, uintptr_t va,
-                          phys_addr_t pa, size_t pgsize);
+                          phys_addr_t pa, size_t page_size);
 
 pmap_pte_t * vm_ptable_boot_root(const struct vm_ptable *ptable);