xnu-2782.10.72.tar.gz

[apple/xnu.git] / osfmk / i386 / i386_vm_init.c

diff --git a/osfmk/i386/i386_vm_init.c b/osfmk/i386/i386_vm_init.c
index 866dfa1fb1ace6562e2f4af626756c4199a74145..8a1d753b588ff8fbf8d5474f1c4d5a806f680133 100644 (file)
--- a/osfmk/i386/i386_vm_init.c
+++ b/osfmk/i386/i386_vm_init.c
@@ -1,5 +1,5 @@
 /*
 /*

- * Copyright (c) 2003-2008 Apple Computer, Inc. All rights reserved.
+ * Copyright (c) 2003-2012 Apple Inc. All rights reserved.

  *
  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
  * 
  *
  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
  * 


@@ -54,8 +54,6 @@
  * the rights to redistribute these changes.
  */
 
  * the rights to redistribute these changes.
  */
 

-#include <platforms.h>
-#include <mach_kdb.h>

 
 #include <mach/i386/vm_param.h>
 
 
 #include <mach/i386/vm_param.h>
 


@@ -79,18 +77,39 @@
 #include <mach/thread_status.h>
 #include <pexpert/i386/efi.h>
 #include <i386/i386_lowmem.h>
 #include <mach/thread_status.h>
 #include <pexpert/i386/efi.h>
 #include <i386/i386_lowmem.h>

-#include <i386/lowglobals.h>
+#include <x86_64/lowglobals.h>

 #include <i386/pal_routines.h>
 
 #include <mach-o/loader.h>
 #include <libkern/kernel_mach_header.h>
 
 #include <i386/pal_routines.h>
 
 #include <mach-o/loader.h>
 #include <libkern/kernel_mach_header.h>
 

+

 vm_size_t      mem_size = 0; 
 pmap_paddr_t   first_avail = 0;/* first after page tables */
 
 uint64_t       max_mem;        /* Size of physical memory (bytes), adjusted by maxmem */
 uint64_t        mem_actual;
 vm_size_t      mem_size = 0; 
 pmap_paddr_t   first_avail = 0;/* first after page tables */
 
 uint64_t       max_mem;        /* Size of physical memory (bytes), adjusted by maxmem */
 uint64_t        mem_actual;

-uint64_t       sane_size = 0;  /* Memory size to use for defaults calculations */
+uint64_t       sane_size = 0;  /* Memory size for defaults calculations */
+
+/*
+ * KASLR parameters
+ */
+ppnum_t                vm_kernel_base_page;
+vm_offset_t    vm_kernel_base;
+vm_offset_t    vm_kernel_top;
+vm_offset_t    vm_kernel_stext;
+vm_offset_t    vm_kernel_etext;
+vm_offset_t    vm_kernel_slide;
+vm_offset_t vm_hib_base;
+vm_offset_t    vm_kext_base = VM_MIN_KERNEL_AND_KEXT_ADDRESS;
+vm_offset_t    vm_kext_top = VM_MIN_KERNEL_ADDRESS;
+
+vm_offset_t vm_prelink_stext;
+vm_offset_t vm_prelink_etext;
+vm_offset_t vm_prelink_sinfo;
+vm_offset_t vm_prelink_einfo;
+vm_offset_t vm_slinkedit;
+vm_offset_t vm_elinkedit;

 
 #define MAXLORESERVE   (32 * 1024 * 1024)
 
 
 #define MAXLORESERVE   (32 * 1024 * 1024)
 


@@ -112,21 +131,24 @@ vm_offset_t       virtual_avail, virtual_end;
 static pmap_paddr_t    avail_remaining;
 vm_offset_t     static_memory_end = 0;
 
 static pmap_paddr_t    avail_remaining;
 vm_offset_t     static_memory_end = 0;
 

-vm_offset_t    sHIB, eHIB, stext, etext, sdata, edata, end;
+vm_offset_t    sHIB, eHIB, stext, etext, sdata, edata, sconstdata, econstdata, end;

 
 /*
  * _mh_execute_header is the mach_header for the currently executing kernel
  */
 
 /*
  * _mh_execute_header is the mach_header for the currently executing kernel
  */

-void *sectTEXTB; unsigned long sectSizeTEXT;
-void *sectDATAB; unsigned long sectSizeDATA;
-void *sectOBJCB; unsigned long sectSizeOBJC;
-void *sectLINKB; unsigned long sectSizeLINK;
-void *sectPRELINKB; unsigned long sectSizePRELINK;
-void *sectHIBB; unsigned long sectSizeHIB;
-void *sectINITPTB; unsigned long sectSizeINITPT;
+vm_offset_t segTEXTB; unsigned long segSizeTEXT;
+vm_offset_t segDATAB; unsigned long segSizeDATA;
+vm_offset_t segLINKB; unsigned long segSizeLINK;
+vm_offset_t segPRELINKB; unsigned long segSizePRELINK;
+vm_offset_t segPRELINKINFOB; unsigned long segSizePRELINKINFO;
+vm_offset_t segHIBB; unsigned long segSizeHIB;
+vm_offset_t sectCONSTB; unsigned long sectSizeConst;
+
+boolean_t doconstro_override = FALSE;

 
 

-kernel_segment_command_t *segTEXT;
-kernel_section_t *cursectTEXT, *lastsectTEXT;
+static kernel_segment_command_t *segTEXT, *segDATA;
+static kernel_section_t *cursectTEXT, *lastsectTEXT;
+static kernel_section_t *sectDCONST;

 
 extern uint64_t firmware_Conventional_bytes;
 extern uint64_t firmware_RuntimeServices_bytes;
 
 extern uint64_t firmware_Conventional_bytes;
 extern uint64_t firmware_RuntimeServices_bytes;


@@ -138,8 +160,16 @@ extern uint64_t firmware_Unusable_bytes;
 extern uint64_t firmware_other_bytes;
 uint64_t firmware_MMIO_bytes;
 
 extern uint64_t firmware_other_bytes;
 uint64_t firmware_MMIO_bytes;
 

+/*
+ * Linker magic to establish the highest address in the kernel.
+ */
+extern void    *last_kernel_symbol;
+

 #if    DEBUG
 #define        PRINT_PMAP_MEMORY_TABLE
 #if    DEBUG
 #define        PRINT_PMAP_MEMORY_TABLE

+#define DBG(x...)       kprintf(x)
+#else
+#define DBG(x...)

 #endif /* DEBUG */
 /*
  * Basic VM initialization.
 #endif /* DEBUG */
 /*
  * Basic VM initialization.


@@ -156,7 +186,6 @@ i386_vm_init(uint64_t       maxmem,
         unsigned int msize;
        ppnum_t fap;
        unsigned int i;
         unsigned int msize;
        ppnum_t fap;
        unsigned int i;

-       unsigned int safeboot;

        ppnum_t maxpg = 0;
         uint32_t pmap_type;
        uint32_t maxloreserve;
        ppnum_t maxpg = 0;
         uint32_t pmap_type;
        uint32_t maxloreserve;


@@ -164,64 +193,129 @@ i386_vm_init(uint64_t    maxmem,
        uint32_t  mbuf_reserve = 0;
        boolean_t mbuf_override = FALSE;
        boolean_t coalescing_permitted;
        uint32_t  mbuf_reserve = 0;
        boolean_t mbuf_override = FALSE;
        boolean_t coalescing_permitted;

-#if DEBUG
-       kprintf("Boot args revision: %d version: %d",
-               args->Revision, args->Version);
-       kprintf("  commandline: \"");
-       for(i=0; i<BOOT_LINE_LENGTH; i++)
-               kprintf("%c", args->CommandLine[i]);
-       kprintf("\"\n");
-#endif
+       vm_kernel_base_page = i386_btop(args->kaddr);
+       vm_offset_t base_address;
+       vm_offset_t static_base_address;
+
+       /*
+        * Establish the KASLR parameters.
+        */
+       static_base_address = ml_static_ptovirt(KERNEL_BASE_OFFSET);
+       base_address        = ml_static_ptovirt(args->kaddr);
+       vm_kernel_slide     = base_address - static_base_address;
+       if (args->kslide) {
+               kprintf("KASLR slide: 0x%016lx dynamic\n", vm_kernel_slide);
+               if (vm_kernel_slide != ((vm_offset_t)args->kslide))
+                       panic("Kernel base inconsistent with slide - rebased?");
+       } else {
+               /* No slide relative to on-disk symbols */
+               kprintf("KASLR slide: 0x%016lx static and ignored\n",
+                       vm_kernel_slide);
+               vm_kernel_slide = 0;
+       }
+
+       /*
+        * Zero out local relocations to avoid confusing kxld.
+        * TODO: might be better to move this code to OSKext::initialize
+        */
+       if (_mh_execute_header.flags & MH_PIE) {
+               struct load_command *loadcmd;
+               uint32_t cmd;
+
+               loadcmd = (struct load_command *)((uintptr_t)&_mh_execute_header +
+                                                 sizeof (_mh_execute_header));
+
+               for (cmd = 0; cmd < _mh_execute_header.ncmds; cmd++) {
+                       if (loadcmd->cmd == LC_DYSYMTAB) {
+                               struct dysymtab_command *dysymtab;
+
+                               dysymtab = (struct dysymtab_command *)loadcmd;
+                               dysymtab->nlocrel = 0;
+                               dysymtab->locreloff = 0;
+                               kprintf("Hiding local relocations\n");
+                               break;
+                       }
+                       loadcmd = (struct load_command *)((uintptr_t)loadcmd + loadcmd->cmdsize);
+               }
+       }

 
        /*
         * Now retrieve addresses for end, edata, and etext 
         * from MACH-O headers.
         */
 
        /*
         * Now retrieve addresses for end, edata, and etext 
         * from MACH-O headers.
         */

-
-       sectTEXTB = (void *) getsegdatafromheader(
-               &_mh_execute_header, "__TEXT", &sectSizeTEXT);
-       sectDATAB = (void *) getsegdatafromheader(
-               &_mh_execute_header, "__DATA", &sectSizeDATA);
-       sectOBJCB = (void *) getsegdatafromheader(
-               &_mh_execute_header, "__OBJC", &sectSizeOBJC);
-       sectLINKB = (void *) getsegdatafromheader(
-               &_mh_execute_header, "__LINKEDIT", &sectSizeLINK);
-       sectHIBB = (void *)getsegdatafromheader(
-               &_mh_execute_header, "__HIB", &sectSizeHIB);
-       sectINITPTB = (void *)getsegdatafromheader(
-               &_mh_execute_header, "__INITPT", &sectSizeINITPT);
-       sectPRELINKB = (void *) getsegdatafromheader(
-               &_mh_execute_header, "__PRELINK_TEXT", &sectSizePRELINK);
-
-       segTEXT = getsegbynamefromheader(&_mh_execute_header, "__TEXT");
+       segTEXTB = (vm_offset_t) getsegdatafromheader(&_mh_execute_header,
+                                       "__TEXT", &segSizeTEXT);
+       segDATAB = (vm_offset_t) getsegdatafromheader(&_mh_execute_header,
+                                       "__DATA", &segSizeDATA);
+       segLINKB = (vm_offset_t) getsegdatafromheader(&_mh_execute_header,
+                                       "__LINKEDIT", &segSizeLINK);
+       segHIBB  = (vm_offset_t) getsegdatafromheader(&_mh_execute_header,
+                                       "__HIB", &segSizeHIB);
+       segPRELINKB = (vm_offset_t) getsegdatafromheader(&_mh_execute_header,
+                                       "__PRELINK_TEXT", &segSizePRELINK);
+    segPRELINKINFOB = (vm_offset_t) getsegdatafromheader(&_mh_execute_header,
+                    "__PRELINK_INFO", &segSizePRELINKINFO);
+       segTEXT = getsegbynamefromheader(&_mh_execute_header,
+                                       "__TEXT");
+       segDATA = getsegbynamefromheader(&_mh_execute_header,
+                                       "__DATA");
+       sectDCONST = getsectbynamefromheader(&_mh_execute_header,
+                                       "__DATA", "__const");

        cursectTEXT = lastsectTEXT = firstsect(segTEXT);
        /* Discover the last TEXT section within the TEXT segment */
        while ((cursectTEXT = nextsect(segTEXT, cursectTEXT)) != NULL) {
                lastsectTEXT = cursectTEXT;
        }
 
        cursectTEXT = lastsectTEXT = firstsect(segTEXT);
        /* Discover the last TEXT section within the TEXT segment */
        while ((cursectTEXT = nextsect(segTEXT, cursectTEXT)) != NULL) {
                lastsectTEXT = cursectTEXT;
        }
 

-       sHIB  = (vm_offset_t) sectHIBB;
-       eHIB  = (vm_offset_t) sectHIBB + sectSizeHIB;
+       sHIB  = segHIBB;
+       eHIB  = segHIBB + segSizeHIB;
+       vm_hib_base = sHIB;

        /* Zero-padded from ehib to stext if text is 2M-aligned */
        /* Zero-padded from ehib to stext if text is 2M-aligned */

-       stext = (vm_offset_t) sectTEXTB;
+       stext = segTEXTB;
+       lowGlo.lgStext = stext;

        etext = (vm_offset_t) round_page_64(lastsectTEXT->addr + lastsectTEXT->size);
        /* Zero-padded from etext to sdata if text is 2M-aligned */
        etext = (vm_offset_t) round_page_64(lastsectTEXT->addr + lastsectTEXT->size);
        /* Zero-padded from etext to sdata if text is 2M-aligned */

-       sdata = (vm_offset_t) sectDATAB;
-       edata = (vm_offset_t) sectDATAB + sectSizeDATA;
-
-#if DEBUG
-       kprintf("sectTEXTB    = %p\n", sectTEXTB);
-       kprintf("sectDATAB    = %p\n", sectDATAB);
-       kprintf("sectOBJCB    = %p\n", sectOBJCB);
-       kprintf("sectLINKB    = %p\n", sectLINKB);
-       kprintf("sectHIBB     = %p\n", sectHIBB);
-       kprintf("sectPRELINKB = %p\n", sectPRELINKB);
-       kprintf("eHIB         = %p\n", (void *) eHIB);
-       kprintf("stext        = %p\n", (void *) stext);
-       kprintf("etext        = %p\n", (void *) etext);
-       kprintf("sdata        = %p\n", (void *) sdata);
-       kprintf("edata        = %p\n", (void *) edata);
-#endif
+       sdata = segDATAB;
+       edata = segDATAB + segSizeDATA;
+
+       sectCONSTB = (vm_offset_t) sectDCONST->addr;
+       sectSizeConst = sectDCONST->size;
+       sconstdata = sectCONSTB;
+       econstdata = sectCONSTB + sectSizeConst;
+
+       if (sectSizeConst & PAGE_MASK) {
+               kernel_section_t *ns = nextsect(segDATA, sectDCONST);
+               if (ns && !(ns->addr & PAGE_MASK))
+                       doconstro_override = TRUE;
+       } else
+               doconstro_override = TRUE;
+
+       DBG("segTEXTB    = %p\n", (void *) segTEXTB);
+       DBG("segDATAB    = %p\n", (void *) segDATAB);
+       DBG("segLINKB    = %p\n", (void *) segLINKB);
+       DBG("segHIBB     = %p\n", (void *) segHIBB);
+       DBG("segPRELINKB = %p\n", (void *) segPRELINKB);
+    DBG("segPRELINKINFOB = %p\n", (void *) segPRELINKINFOB);
+       DBG("sHIB        = %p\n", (void *) sHIB);
+       DBG("eHIB        = %p\n", (void *) eHIB);
+       DBG("stext       = %p\n", (void *) stext);
+       DBG("etext       = %p\n", (void *) etext);
+       DBG("sdata       = %p\n", (void *) sdata);
+       DBG("edata       = %p\n", (void *) edata);
+       DBG("sconstdata  = %p\n", (void *) sconstdata);
+       DBG("econstdata  = %p\n", (void *) econstdata);
+       DBG("kernel_top  = %p\n", (void *) &last_kernel_symbol);
+
+       vm_kernel_base  = sHIB;
+       vm_kernel_top   = (vm_offset_t) &last_kernel_symbol;
+       vm_kernel_stext = stext;
+       vm_kernel_etext = etext;
+    vm_prelink_stext = segPRELINKB;
+    vm_prelink_etext = segPRELINKB + segSizePRELINK;
+    vm_prelink_sinfo = segPRELINKINFOB;
+    vm_prelink_einfo = segPRELINKINFOB + segSizePRELINKINFO;
+    vm_slinkedit = segLINKB;
+    vm_elinkedit = segLINKB + segSizePRELINK;

 
        vm_set_page_size();
 
 
        vm_set_page_size();
 


@@ -229,9 +323,6 @@ i386_vm_init(uint64_t       maxmem,
         * Compute the memory size.
         */
 
         * Compute the memory size.
         */
 

-       if ((1 == vm_himemory_mode) || PE_parse_boot_argn("-x", &safeboot, sizeof (safeboot))) {
-               maxpg = 1 << (32 - I386_PGSHIFT);
-       }

        avail_remaining = 0;
        avail_end = 0;
        pmptr = pmap_memory_regions;
        avail_remaining = 0;
        avail_end = 0;
        pmptr = pmap_memory_regions;


@@ -259,6 +350,32 @@ i386_vm_init(uint64_t      maxmem,
                base = (ppnum_t) (mptr->PhysicalStart >> I386_PGSHIFT);
                top = (ppnum_t) (((mptr->PhysicalStart) >> I386_PGSHIFT) + mptr->NumberOfPages - 1);
 
                base = (ppnum_t) (mptr->PhysicalStart >> I386_PGSHIFT);
                top = (ppnum_t) (((mptr->PhysicalStart) >> I386_PGSHIFT) + mptr->NumberOfPages - 1);
 

+               if (base == 0) {
+                       /*
+                        * Avoid having to deal with the edge case of the 
+                        * very first possible physical page and the roll-over
+                        * to -1; just ignore that page.
+                        */
+                       kprintf("WARNING: ignoring first page in [0x%llx:0x%llx]\n", (uint64_t) base, (uint64_t) top);
+                       base++;
+               }
+               if (top + 1 == 0) {
+                       /*
+                        * Avoid having to deal with the edge case of the 
+                        * very last possible physical page and the roll-over
+                        * to 0; just ignore that page.
+                        */
+                       kprintf("WARNING: ignoring last page in [0x%llx:0x%llx]\n", (uint64_t) base, (uint64_t) top);
+                       top--;
+               }
+               if (top < base) {
+                       /*
+                        * That was the only page in that region, so
+                        * ignore the whole region.
+                        */
+                       continue;
+               }
+

 #if    MR_RSV_TEST
                static uint32_t nmr = 0;
                if ((base > 0x20000) && (nmr++ < 4))
 #if    MR_RSV_TEST
                static uint32_t nmr = 0;
                if ((base > 0x20000) && (nmr++ < 4))


@@ -328,10 +445,10 @@ i386_vm_init(uint64_t     maxmem,
                        break;
                }
 
                        break;
                }
 

-#if DEBUG
-               kprintf("EFI region %d: type %u/%d, base 0x%x, top 0x%x\n",
-                       i, mptr->Type, pmap_type, base, top);
-#endif
+               DBG("EFI region %d: type %u/%d, base 0x%x, top 0x%x %s\n",
+                   i, mptr->Type, pmap_type, base, top,
+                   (mptr->Attribute&EFI_MEMORY_KERN_RESERVED)? "RESERVED" :
+                   (mptr->Attribute&EFI_MEMORY_RUNTIME)? "RUNTIME" : "");

 
                if (maxpg) {
                        if (base >= maxpg)
 
                if (maxpg) {
                        if (base >= maxpg)


@@ -384,15 +501,17 @@ i386_vm_init(uint64_t     maxmem,
 
 
                                if ((mptr->Attribute & EFI_MEMORY_KERN_RESERVED) &&
 
 
                                if ((mptr->Attribute & EFI_MEMORY_KERN_RESERVED) &&

-                                   (top < I386_KERNEL_IMAGE_BASE_PAGE)) {
-                                       pmptr->alloc = pmptr->base;
+                                   (top < vm_kernel_base_page)) {
+                                       pmptr->alloc_up = pmptr->base;
+                                       pmptr->alloc_down = pmptr->end;

                                        pmap_reserved_range_indices[pmap_last_reserved_range_index++] = pmap_memory_region_count;
                                }
                                else {
                                        /*
                                         * mark as already mapped
                                         */
                                        pmap_reserved_range_indices[pmap_last_reserved_range_index++] = pmap_memory_region_count;
                                }
                                else {
                                        /*
                                         * mark as already mapped
                                         */

-                                       pmptr->alloc = top;
+                                       pmptr->alloc_up = top + 1;
+                                       pmptr->alloc_down = top;

                                }
                                pmptr->type = pmap_type;
                                pmptr->attribute = mptr->Attribute;
                                }
                                pmptr->type = pmap_type;
                                pmptr->attribute = mptr->Attribute;


@@ -404,7 +523,9 @@ i386_vm_init(uint64_t       maxmem,
                                 * mark already allocated
                                 */
                                pmptr->base = base;
                                 * mark already allocated
                                 */
                                pmptr->base = base;

-                               pmptr->alloc = pmptr->end = (fap - 1);
+                               pmptr->end = (fap - 1);
+                               pmptr->alloc_up = pmptr->end + 1;
+                               pmptr->alloc_down = pmptr->end;

                                pmptr->type = pmap_type;
                                pmptr->attribute = mptr->Attribute;
                                /*
                                pmptr->type = pmap_type;
                                pmptr->attribute = mptr->Attribute;
                                /*


@@ -414,10 +535,10 @@ i386_vm_init(uint64_t     maxmem,
                                pmptr++;
                                pmap_memory_region_count++;
 
                                pmptr++;
                                pmap_memory_region_count++;
 

-                               pmptr->alloc = pmptr->base = fap;
+                               pmptr->alloc_up = pmptr->base = fap;

                                pmptr->type = pmap_type;
                                pmptr->attribute = mptr->Attribute;
                                pmptr->type = pmap_type;
                                pmptr->attribute = mptr->Attribute;

-                               pmptr->end = top;
+                               pmptr->alloc_down = pmptr->end = top;

 
                                if (mptr->Attribute & EFI_MEMORY_KERN_RESERVED)
                                        pmap_reserved_range_indices[pmap_last_reserved_range_index++] = pmap_memory_region_count;
 
                                if (mptr->Attribute & EFI_MEMORY_KERN_RESERVED)
                                        pmap_reserved_range_indices[pmap_last_reserved_range_index++] = pmap_memory_region_count;


@@ -425,10 +546,10 @@ i386_vm_init(uint64_t     maxmem,
                                /*
                                 * entire range useable
                                 */
                                /*
                                 * entire range useable
                                 */

-                               pmptr->alloc = pmptr->base = base;
+                               pmptr->alloc_up = pmptr->base = base;

                                pmptr->type = pmap_type;
                                pmptr->attribute = mptr->Attribute;
                                pmptr->type = pmap_type;
                                pmptr->attribute = mptr->Attribute;

-                               pmptr->end = top;
+                               pmptr->alloc_down = pmptr->end = top;

                                if (mptr->Attribute & EFI_MEMORY_KERN_RESERVED)
                                        pmap_reserved_range_indices[pmap_last_reserved_range_index++] = pmap_memory_region_count;
                        }
                                if (mptr->Attribute & EFI_MEMORY_KERN_RESERVED)
                                        pmap_reserved_range_indices[pmap_last_reserved_range_index++] = pmap_memory_region_count;
                        }


@@ -444,12 +565,12 @@ i386_vm_init(uint64_t     maxmem,
                        if (prev_pmptr &&
                            (pmptr->type == prev_pmptr->type) &&
                            (coalescing_permitted) &&
                        if (prev_pmptr &&
                            (pmptr->type == prev_pmptr->type) &&
                            (coalescing_permitted) &&

-                           (pmptr->base == pmptr->alloc) &&
+                           (pmptr->base == pmptr->alloc_up) &&
+                           (prev_pmptr->end == prev_pmptr->alloc_down) &&

                            (pmptr->base == (prev_pmptr->end + 1)))
                        {
                            (pmptr->base == (prev_pmptr->end + 1)))
                        {

-                               if (prev_pmptr->end == prev_pmptr->alloc)
-                                       prev_pmptr->alloc = pmptr->base;

                                prev_pmptr->end = pmptr->end;
                                prev_pmptr->end = pmptr->end;

+                               prev_pmptr->alloc_down = pmptr->alloc_down;

                        } else {
                                pmap_memory_region_count++;
                                prev_pmptr = pmptr;
                        } else {
                                pmap_memory_region_count++;
                                prev_pmptr = pmptr;


@@ -465,10 +586,11 @@ i386_vm_init(uint64_t     maxmem,
         addr64_t region_start, region_end;
         addr64_t efi_start, efi_end;
         for (j=0;j<pmap_memory_region_count;j++, p++) {
         addr64_t region_start, region_end;
         addr64_t efi_start, efi_end;
         for (j=0;j<pmap_memory_region_count;j++, p++) {

-            kprintf("pmap region %d type %d base 0x%llx alloc 0x%llx top 0x%llx\n",
+            kprintf("pmap region %d type %d base 0x%llx alloc_up 0x%llx alloc_down 0x%llx top 0x%llx\n",

                    j, p->type,
                     (addr64_t) p->base  << I386_PGSHIFT,
                    j, p->type,
                     (addr64_t) p->base  << I386_PGSHIFT,

-                   (addr64_t) p->alloc << I386_PGSHIFT,
+                   (addr64_t) p->alloc_up << I386_PGSHIFT,
+                   (addr64_t) p->alloc_down << I386_PGSHIFT,

                    (addr64_t) p->end   << I386_PGSHIFT);
             region_start = (addr64_t) p->base << I386_PGSHIFT;
             region_end = ((addr64_t) p->end << I386_PGSHIFT) - 1;
                    (addr64_t) p->end   << I386_PGSHIFT);
             region_start = (addr64_t) p->base << I386_PGSHIFT;
             region_end = ((addr64_t) p->end << I386_PGSHIFT) - 1;


@@ -518,7 +640,7 @@ i386_vm_init(uint64_t       maxmem,
        if ( (maxmem > (uint64_t)first_avail) && (maxmem < sane_size)) {
                ppnum_t discarded_pages  = (ppnum_t)((sane_size - maxmem) >> I386_PGSHIFT);
                ppnum_t highest_pn = 0;
        if ( (maxmem > (uint64_t)first_avail) && (maxmem < sane_size)) {
                ppnum_t discarded_pages  = (ppnum_t)((sane_size - maxmem) >> I386_PGSHIFT);
                ppnum_t highest_pn = 0;

-               ppnum_t cur_alloc  = 0;
+               ppnum_t cur_end  = 0;

                uint64_t        pages_to_use;
                unsigned        cur_region = 0;
 
                uint64_t        pages_to_use;
                unsigned        cur_region = 0;
 


@@ -532,15 +654,17 @@ i386_vm_init(uint64_t     maxmem,
                pages_to_use = avail_remaining;
 
                while (cur_region < pmap_memory_region_count && pages_to_use) {
                pages_to_use = avail_remaining;
 
                while (cur_region < pmap_memory_region_count && pages_to_use) {

-                       for (cur_alloc = pmap_memory_regions[cur_region].alloc;
-                            cur_alloc < pmap_memory_regions[cur_region].end && pages_to_use;
-                            cur_alloc++) {
-                               if (cur_alloc > highest_pn)
-                                       highest_pn = cur_alloc;
+                       for (cur_end = pmap_memory_regions[cur_region].base;
+                            cur_end < pmap_memory_regions[cur_region].end && pages_to_use;
+                            cur_end++) {
+                               if (cur_end > highest_pn)
+                                       highest_pn = cur_end;

                                pages_to_use--;
                        }
                                pages_to_use--;
                        }

-                       if (pages_to_use == 0)
-                               pmap_memory_regions[cur_region].end = cur_alloc;
+                       if (pages_to_use == 0) {
+                               pmap_memory_regions[cur_region].end = cur_end;
+                               pmap_memory_regions[cur_region].alloc_down = cur_end;
+                       }

 
                        cur_region++;
                }
 
                        cur_region++;
                }


@@ -582,7 +706,9 @@ i386_vm_init(uint64_t       maxmem,
                        else
                                maxloreserve = MAXLORESERVE / PAGE_SIZE;
 
                        else
                                maxloreserve = MAXLORESERVE / PAGE_SIZE;
 

+#if SOCKETS

                        mbuf_reserve = bsd_mbuf_cluster_reserve(&mbuf_override) / PAGE_SIZE;
                        mbuf_reserve = bsd_mbuf_cluster_reserve(&mbuf_override) / PAGE_SIZE;

+#endif

                } else
                        maxloreserve = (maxloreserve * (1024 * 1024)) / PAGE_SIZE;
 
                } else
                        maxloreserve = (maxloreserve * (1024 * 1024)) / PAGE_SIZE;
 


@@ -630,8 +756,8 @@ pmap_next_page_reserved(ppnum_t *pn) {
                for (n = 0; n < pmap_last_reserved_range_index; n++) {
                        uint32_t reserved_index = pmap_reserved_range_indices[n];
                        region = &pmap_memory_regions[reserved_index];
                for (n = 0; n < pmap_last_reserved_range_index; n++) {
                        uint32_t reserved_index = pmap_reserved_range_indices[n];
                        region = &pmap_memory_regions[reserved_index];

-                       if (region->alloc < region->end) {
-                               *pn = region->alloc++;
+                       if (region->alloc_up <= region->alloc_down) {
+                               *pn = region->alloc_up++;

                                avail_remaining--;
 
                                if (*pn > max_ppnum)
                                avail_remaining--;
 
                                if (*pn > max_ppnum)


@@ -642,7 +768,7 @@ pmap_next_page_reserved(ppnum_t *pn) {
 
                                pmap_reserved_pages_allocated++;
 #if DEBUG
 
                                pmap_reserved_pages_allocated++;
 #if DEBUG

-                               if (region->alloc == region->end) {
+                               if (region->alloc_up > region->alloc_down) {

                                        kprintf("Exhausted reserved range index: %u, base: 0x%x end: 0x%x, type: 0x%x, attribute: 0x%llx\n", reserved_index, region->base, region->end, region->type, region->attribute);
                                }
 #endif
                                        kprintf("Exhausted reserved range index: %u, base: 0x%x end: 0x%x, type: 0x%x, attribute: 0x%llx\n", reserved_index, region->base, region->end, region->type, region->attribute);
                                }
 #endif


@@ -668,8 +794,8 @@ pmap_next_page_hi(
                for (n = pmap_memory_region_count - 1; n >= 0; n--) {
                        region = &pmap_memory_regions[n];
 
                for (n = pmap_memory_region_count - 1; n >= 0; n--) {
                        region = &pmap_memory_regions[n];
 

-                       if (region->alloc != region->end) {
-                               *pn = region->alloc++;
+                       if (region->alloc_down >= region->alloc_up) {
+                               *pn = region->alloc_down--;

                                avail_remaining--;
 
                                if (*pn > max_ppnum)
                                avail_remaining--;
 
                                if (*pn > max_ppnum)


@@ -697,12 +823,12 @@ pmap_next_page(
               ppnum_t *pn)
 {
        if (avail_remaining) while (pmap_memory_region_current < pmap_memory_region_count) {
               ppnum_t *pn)
 {
        if (avail_remaining) while (pmap_memory_region_current < pmap_memory_region_count) {

-               if (pmap_memory_regions[pmap_memory_region_current].alloc ==
-                               pmap_memory_regions[pmap_memory_region_current].end) {
+               if (pmap_memory_regions[pmap_memory_region_current].alloc_up >
+                   pmap_memory_regions[pmap_memory_region_current].alloc_down) {

                        pmap_memory_region_current++;
                        continue;
                }
                        pmap_memory_region_current++;
                        continue;
                }

-               *pn = pmap_memory_regions[pmap_memory_region_current].alloc++;
+               *pn = pmap_memory_regions[pmap_memory_region_current].alloc_up++;

                avail_remaining--;
 
                if (*pn > max_ppnum)
                avail_remaining--;
 
                if (*pn > max_ppnum)