vm: rename min/max macros to start/end variants

The real problem actually only applies to "max" names, for which the
value is ambiguous, as "max" usually implies the value is included in
the associated range, which is not the case for these macros.

6 files changed, 43 insertions, 44 deletions

diff --git a/arch/x86/machine/pmap.c b/arch/x86/machine/pmap.c
index f8c6d03..fb251b0 100644
--- a/arch/x86/machine/pmap.c
+++ b/arch/x86/machine/pmap.c
@@ -447,12 +447,12 @@ pmap_setup_paging(void)
 
     directmap_end = biosmem_directmap_end();
 
-    if (directmap_end > (PMAP_MAX_DIRECTMAP_ADDRESS
-                         - PMAP_MIN_DIRECTMAP_ADDRESS)) {
+    if (directmap_end > (PMAP_END_DIRECTMAP_ADDRESS
+                         - PMAP_START_DIRECTMAP_ADDRESS)) {
         boot_panic(pmap_panic_directmap_msg);
     }
 
-    va = PMAP_MIN_DIRECTMAP_ADDRESS;
+    va = PMAP_START_DIRECTMAP_ADDRESS;
     pa = 0;
 
     for (i = 0; i < directmap_end; i += pgsize) {
@@ -510,14 +510,14 @@ pmap_ap_setup_paging(void)
 #define pmap_assert_range(pmap, start, end)             \
 MACRO_BEGIN                                             \
     assert((start) < (end));                            \
-    assert(((end) <= PMAP_MIN_DIRECTMAP_ADDRESS)        \
-           || ((start) >= PMAP_MAX_DIRECTMAP_ADDRESS)); \
+    assert(((end) <= PMAP_START_DIRECTMAP_ADDRESS)      \
+           || ((start) >= PMAP_END_DIRECTMAP_ADDRESS)); \
                                                         \
     if ((pmap) == kernel_pmap) {                        \
-        assert(((start) >= PMAP_MIN_KMEM_ADDRESS)       \
-               && ((end) <= PMAP_MAX_KMEM_ADDRESS));    \
+        assert(((start) >= PMAP_START_KMEM_ADDRESS)     \
+               && ((end) <= PMAP_END_KMEM_ADDRESS));    \
     } else {                                            \
-        assert((end) <= PMAP_MAX_ADDRESS);              \
+        assert((end) <= PMAP_END_ADDRESS);              \
     }                                                   \
 MACRO_END
 
@@ -584,7 +584,7 @@ pmap_walk_vas(uintptr_t start, uintptr_t end, pmap_walk_fn_t walk_fn)
     assert(vm_page_aligned(start));
     assert(start < end);
 #ifdef __LP64__
-    assert((start < PMAP_MAX_ADDRESS) || (start >= PMAP_MIN_KERNEL_ADDRESS));
+    assert((start < PMAP_END_ADDRESS) || (start >= PMAP_START_KERNEL_ADDRESS));
 #endif /* __LP64__ */
 
     va = start;
@@ -593,8 +593,8 @@ pmap_walk_vas(uintptr_t start, uintptr_t end, pmap_walk_fn_t walk_fn)
     do {
 #ifdef __LP64__
         /* Handle long mode canonical form */
-        if (va == PMAP_MAX_ADDRESS) {
-            va = PMAP_MIN_KERNEL_ADDRESS;
+        if (va == PMAP_END_ADDRESS) {
+            va = PMAP_START_KERNEL_ADDRESS;
         }
 #endif /* __LP64__ */
 
@@ -642,7 +642,7 @@ pmap_setup_global_page(phys_addr_t ptp_pa, unsigned int index,
 static void __init
 pmap_setup_global_pages(void)
 {
-    pmap_walk_vas(PMAP_MIN_KERNEL_ADDRESS, PMAP_MAX_KERNEL_ADDRESS,
+    pmap_walk_vas(PMAP_START_KERNEL_ADDRESS, PMAP_END_KERNEL_ADDRESS,
                   pmap_setup_global_page);
     pmap_pt_levels[0].mask |= PMAP_PTE_G;
     cpu_enable_global_pages();
@@ -894,7 +894,7 @@ pmap_setup_set_ptp_type(phys_addr_t ptp_pa, unsigned int index,
 static void __init
 pmap_setup_fix_ptps(void)
 {
-    pmap_walk_vas(PMAP_MIN_ADDRESS, PMAP_MAX_KERNEL_ADDRESS,
+    pmap_walk_vas(PMAP_START_ADDRESS, PMAP_END_KERNEL_ADDRESS,
                   pmap_setup_set_ptp_type);
 }
 
@@ -959,8 +959,8 @@ pmap_copy_cpu_table_recursive(const pmap_pte_t *sptp, unsigned int level,
          i++, va = P2END(va, 1UL << pt_level->skip)) {
 #ifdef __LP64__
         /* Handle long mode canonical form */
-        if (va == PMAP_MAX_ADDRESS) {
-            va = PMAP_MIN_KERNEL_ADDRESS;
+        if (va == PMAP_END_ADDRESS) {
+            va = PMAP_START_KERNEL_ADDRESS;
         }
 #endif /* __LP64__ */
 
@@ -1019,7 +1019,7 @@ pmap_copy_cpu_table(unsigned int cpu)
     dptp = vm_page_direct_ptr(page);
 #endif /* X15_X86_PAE */
 
-    pmap_copy_cpu_table_recursive(sptp, level, dptp, PMAP_MIN_ADDRESS);
+    pmap_copy_cpu_table_recursive(sptp, level, dptp, PMAP_START_ADDRESS);
 }
 
 void __init
diff --git a/arch/x86/machine/pmap.h b/arch/x86/machine/pmap.h
index 8ef28c7..96fc21e 100644
--- a/arch/x86/machine/pmap.h
+++ b/arch/x86/machine/pmap.h
@@ -16,7 +16,6 @@
  *
  *
  * TODO Comment.
- * TODO Rename MIN/MAX to START/END.
  */
 
 #ifndef _X86_PMAP_H
@@ -31,34 +30,34 @@
 /*
  * User space boundaries.
  */
-#define PMAP_MIN_ADDRESS            DECL_CONST(0, UL)
+#define PMAP_START_ADDRESS              DECL_CONST(0, UL)
 
 #ifdef __LP64__
-#define PMAP_MAX_ADDRESS            DECL_CONST(0x800000000000, UL)
+#define PMAP_END_ADDRESS                DECL_CONST(0x800000000000, UL)
 #else /* __LP64__ */
-#define PMAP_MAX_ADDRESS            DECL_CONST(0xc0000000, UL)
+#define PMAP_END_ADDRESS                DECL_CONST(0xc0000000, UL)
 #endif/* __LP64__ */
 
 /*
  * Kernel space boundaries.
  */
 #ifdef __LP64__
-#define PMAP_MIN_KERNEL_ADDRESS     DECL_CONST(0xffff800000000000, UL)
-#define PMAP_MAX_KERNEL_ADDRESS     DECL_CONST(0xfffffffffffff000, UL)
+#define PMAP_START_KERNEL_ADDRESS       DECL_CONST(0xffff800000000000, UL)
+#define PMAP_END_KERNEL_ADDRESS         DECL_CONST(0xfffffffffffff000, UL)
 #else /* __LP64__ */
-#define PMAP_MIN_KERNEL_ADDRESS     PMAP_MAX_ADDRESS
-#define PMAP_MAX_KERNEL_ADDRESS     DECL_CONST(0xfffff000, UL)
+#define PMAP_START_KERNEL_ADDRESS       PMAP_END_ADDRESS
+#define PMAP_END_KERNEL_ADDRESS         DECL_CONST(0xfffff000, UL)
 #endif /* __LP64__ */
 
 /*
  * Direct physical mapping boundaries.
  */
 #ifdef __LP64__
-#define PMAP_MIN_DIRECTMAP_ADDRESS  PMAP_MIN_KERNEL_ADDRESS
-#define PMAP_MAX_DIRECTMAP_ADDRESS  DECL_CONST(0xffffc00000000000, UL)
+#define PMAP_START_DIRECTMAP_ADDRESS    PMAP_START_KERNEL_ADDRESS
+#define PMAP_END_DIRECTMAP_ADDRESS      DECL_CONST(0xffffc00000000000, UL)
 #else /* __LP64__ */
-#define PMAP_MIN_DIRECTMAP_ADDRESS  PMAP_MAX_ADDRESS
-#define PMAP_MAX_DIRECTMAP_ADDRESS  DECL_CONST(0xf8000000, UL)
+#define PMAP_START_DIRECTMAP_ADDRESS    PMAP_END_ADDRESS
+#define PMAP_END_DIRECTMAP_ADDRESS      DECL_CONST(0xf8000000, UL)
 #endif /* __LP64__ */
 
 /*
@@ -70,9 +69,9 @@
  * the -mcmodel=kernel gcc option).
  */
 #ifdef __LP64__
-#define PMAP_KERNEL_OFFSET          DECL_CONST(0xffffffff80000000, UL)
+#define PMAP_KERNEL_OFFSET              DECL_CONST(0xffffffff80000000, UL)
 #else /* __LP64__ */
-#define PMAP_KERNEL_OFFSET          PMAP_MIN_DIRECTMAP_ADDRESS
+#define PMAP_KERNEL_OFFSET              PMAP_START_DIRECTMAP_ADDRESS
 #endif /* __LP64__ */
 
 /*
@@ -81,12 +80,12 @@
  * In addition to the direct physical mapping, the kernel has its own virtual
  * memory space.
  */
-#define PMAP_MIN_KMEM_ADDRESS       PMAP_MAX_DIRECTMAP_ADDRESS
+#define PMAP_START_KMEM_ADDRESS         PMAP_END_DIRECTMAP_ADDRESS
 
 #ifdef __LP64__
-#define PMAP_MAX_KMEM_ADDRESS       PMAP_KERNEL_OFFSET
+#define PMAP_END_KMEM_ADDRESS           PMAP_KERNEL_OFFSET
 #else /* __LP64__ */
-#define PMAP_MAX_KMEM_ADDRESS       PMAP_MAX_KERNEL_ADDRESS
+#define PMAP_END_KMEM_ADDRESS           PMAP_END_KERNEL_ADDRESS
 #endif /* __LP64__ */
 
 /*
diff --git a/vm/vm_kmem.c b/vm/vm_kmem.c
index d526804..0583bb9 100644
--- a/vm/vm_kmem.c
+++ b/vm/vm_kmem.c
@@ -44,8 +44,8 @@ static struct vm_object vm_kmem_kernel_object;
 static uint64_t
 vm_kmem_offset(uintptr_t va)
 {
-    assert(va >= PMAP_MIN_KMEM_ADDRESS);
-    return va - PMAP_MIN_KMEM_ADDRESS;
+    assert(va >= PMAP_START_KMEM_ADDRESS);
+    return va - PMAP_START_KMEM_ADDRESS;
 }
 
 static int __init
@@ -53,7 +53,7 @@ vm_kmem_setup(void)
 {
     uint64_t size;
 
-    size = vm_kmem_offset(PMAP_MAX_KMEM_ADDRESS);
+    size = vm_kmem_offset(PMAP_END_KMEM_ADDRESS);
     vm_object_init(&vm_kmem_kernel_object, size);
     return 0;
 }
diff --git a/vm/vm_kmem.h b/vm/vm_kmem.h
index e10c220..9bb90dc 100644
--- a/vm/vm_kmem.h
+++ b/vm/vm_kmem.h
@@ -28,9 +28,9 @@
  * The kernel space is required not to start at address 0, which is used to
  * report allocation errors.
  */
-#if PMAP_MIN_KMEM_ADDRESS == 0
+#if PMAP_START_KMEM_ADDRESS == 0
 #error "kernel space must not start at address 0"
-#endif /* PMAP_MIN_KMEM_ADDRESS == 0 */
+#endif /* PMAP_START_KMEM_ADDRESS == 0 */
 
 /*
  * Special kernel addresses.
diff --git a/vm/vm_map.c b/vm/vm_map.c
index da0b2cf..180419a 100644
--- a/vm/vm_map.c
+++ b/vm/vm_map.c
@@ -748,7 +748,7 @@ static int __init
 vm_map_bootstrap(void)
 {
     vm_map_init(kernel_map, kernel_pmap,
-                PMAP_MIN_KMEM_ADDRESS, PMAP_MAX_KMEM_ADDRESS);
+                PMAP_START_KMEM_ADDRESS, PMAP_END_KMEM_ADDRESS);
     kmem_cache_init(&vm_map_entry_cache, "vm_map_entry",
                     sizeof(struct vm_map_entry), 0, NULL,
                     KMEM_CACHE_PAGE_ONLY);
@@ -792,7 +792,7 @@ vm_map_create(struct vm_map **mapp)
         goto error_pmap;
     }
 
-    vm_map_init(map, pmap, PMAP_MIN_ADDRESS, PMAP_MAX_ADDRESS);
+    vm_map_init(map, pmap, PMAP_START_ADDRESS, PMAP_END_ADDRESS);
     *mapp = map;
     return 0;
 
diff --git a/vm/vm_page.h b/vm/vm_page.h
index e9ca321..844ad06 100644
--- a/vm/vm_page.h
+++ b/vm/vm_page.h
@@ -120,15 +120,15 @@ static inline uintptr_t
 vm_page_direct_va(phys_addr_t pa)
 {
     assert(pa < PMEM_DIRECTMAP_LIMIT);
-    return ((uintptr_t)pa + PMAP_MIN_DIRECTMAP_ADDRESS);
+    return ((uintptr_t)pa + PMAP_START_DIRECTMAP_ADDRESS);
 }
 
 static inline phys_addr_t
 vm_page_direct_pa(uintptr_t va)
 {
-    assert(va >= PMAP_MIN_DIRECTMAP_ADDRESS);
-    assert(va < PMAP_MAX_DIRECTMAP_ADDRESS);
-    return (va - PMAP_MIN_DIRECTMAP_ADDRESS);
+    assert(va >= PMAP_START_DIRECTMAP_ADDRESS);
+    assert(va < PMAP_END_DIRECTMAP_ADDRESS);
+    return (va - PMAP_START_DIRECTMAP_ADDRESS);
 }
 
 static inline void *