Use vm_page as the physical memory allocator

This change replaces the historical page allocator with a buddy allocator
implemented in vm/vm_page.c. This allocator allows easy contiguous allocations
and also manages memory inside segments. In a future change, these segments
will be used to service requests with special constraints, such as "usable
for 16-bits DMA" or "must be part of the direct physical mapping".

* Makefrag.am (libkernel_a_SOURCES): Add vm/vm_page.c.
* i386/Makefrag.am (libkernel_a_SOURCES): Add i386/i386at/biosmem.{c,h}.
* i386/i386/vm_param.h: Include kern/macros.h.
(VM_PAGE_DMA_LIMIT, VM_PAGE_MAX_SEGS, VM_PAGE_DMA32_LIMIT,
VM_PAGE_DIRECTMAP_LIMIT, VM_PAGE_HIGHMEM_LIMIT, VM_PAGE_SEG_DMA,
VM_PAGE_SEG_DMA32, VM_PAGE_SEG_DIRECTMAP, VM_PAGE_SEG_HIGHMEM): New macros.
* i386/i386at/model_dep.c: Include i386at/biosmem.h.
(avail_next, avail_remaining): Remove variables.
(mem_size_init): Remove function.
(i386at_init): Initialize and use the biosmem module for early physical
memory management.
(pmap_free_pages): Return phys_last_addr instead of avail_remaining.
(init_alloc_aligned): Turn into a wrapper for biosmem_bootalloc.
(pmap_grab_page): Directly call init_alloc_aligned instead of pmap_next_page.
* i386/include/mach/i386/vm_types.h (phys_addr_t): New type.
* kern/bootstrap.c (free_bootstrap_pages): New function.
(bootstrap_create): Call free_bootstrap_pages instead of vm_page_create.
* kern/cpu_number.h (CPU_L1_SIZE): New macro.
* kern/slab.h: Include kern/cpu_number.h.
(CPU_L1_SIZE): Remove macro, moved to kern/cpu_number.h.
* kern/startup.c (setup_main): Change the value of machine_info.memory_size.
* linux/dev/glue/glue.h (alloc_contig_mem, free_contig_mem): Update prototypes.
* linux/dev/glue/kmem.c (linux_kmem_init): Don't use defunct page queue.
* linux/dev/init/main.c (linux_init): Don't free unused memory.
(alloc_contig_mem, free_contig_mem): Turn into wrappers for the vm_page
allocator.
* linux/pcmcia-cs/glue/ds.c (PAGE_SHIFT): Don't undefine.
* vm/pmap.h (pmap_startup, pmap_next_page): Remove prototypes.
* vm/vm_fault.c (vm_fault_page): Update calls to vm_page_convert.
* vm/vm_init.c (vm_mem_init): Call vm_page_info_all.
* vm/vm_object.c (vm_object_page_map): Update call to vm_page_init.
* vm/vm_page.h (vm_page_queue_free): Remove variable declaration.
(vm_page_create, vm_page_release_fictitious, vm_page_release): Remove
declarations.
(vm_page_convert, vm_page_init): Update prototypes.
(vm_page_grab_contig, vm_page_free_contig): New prototypes.
* vm/vm_resident.c (vm_page_template, vm_page_queue_free,
vm_page_big_pagenum): Remove variables.
(vm_page_bootstrap): Update and call vm_page_setup.
(pmap_steal_memory): Update and call vm_page_bootalloc.
(pmap_startup, vm_page_create, vm_page_grab_contiguous_pages): Remove functions.
(vm_page_init_template, vm_page_grab_contig,
vm_page_free_contig): New functions.
(vm_page_init): Update and call vm_page_init_template.
(vm_page_release_fictitious): Make static.
(vm_page_more_fictitious): Update call to vm_page_init.
(vm_page_convert): Rewrite to comply with vm_page.
(vm_page_grab): Update and call vm_page_alloc_pa.
(vm_page_release): Update and call vm_page_free_pa.

19 files changed, 269 insertions, 832 deletions

diff --git a/Makefrag.am b/Makefrag.am
index 823ece5d..bb600e0c 100644
--- a/Makefrag.am
+++ b/Makefrag.am
@@ -259,6 +259,7 @@ libkernel_a_SOURCES += \
 	vm/vm_map.h \
 	vm/vm_object.c \
 	vm/vm_object.h \
+	vm/vm_page.c \
 	vm/vm_page.h \
 	vm/vm_pageout.c \
 	vm/vm_pageout.h \
diff --git a/i386/Makefrag.am b/i386/Makefrag.am
index ef393d5d..e6cfedd7 100644
--- a/i386/Makefrag.am
+++ b/i386/Makefrag.am
@@ -29,6 +29,8 @@ libkernel_a_SOURCES += \
 
 if PLATFORM_at
 libkernel_a_SOURCES += \
+	i386/i386at/biosmem.c \
+	i386/i386at/biosmem.h \
 	i386/i386at/boothdr.S \
 	i386/i386at/com.c \
 	i386/i386at/com.h \
diff --git a/i386/i386/vm_param.h b/i386/i386/vm_param.h
index 6292ca25..da3126c0 100644
--- a/i386/i386/vm_param.h
+++ b/i386/i386/vm_param.h
@@ -23,6 +23,8 @@
 #ifndef _I386_KERNEL_I386_VM_PARAM_
 #define _I386_KERNEL_I386_VM_PARAM_
 
+#include <kern/macros.h>
+
 /* XXX use xu/vm_param.h */
 #include <mach/vm_param.h>
 #ifdef MACH_PV_PAGETABLES
@@ -101,4 +103,42 @@
 #define kvtolin(a)	((vm_offset_t)(a) - VM_MIN_KERNEL_ADDRESS + LINEAR_MIN_KERNEL_ADDRESS)
 #define lintokv(a)	((vm_offset_t)(a) - LINEAR_MIN_KERNEL_ADDRESS + VM_MIN_KERNEL_ADDRESS)
 
+/*
+ * Physical memory properties.
+ */
+#define VM_PAGE_DMA_LIMIT       DECL_CONST(0x1000000, UL)
+
+#ifdef __LP64__
+#define VM_PAGE_MAX_SEGS 4
+#define VM_PAGE_DMA32_LIMIT     DECL_CONST(0x100000000, UL)
+#define VM_PAGE_DIRECTMAP_LIMIT DECL_CONST(0x400000000000, UL)
+#define VM_PAGE_HIGHMEM_LIMIT   DECL_CONST(0x10000000000000, UL)
+#else /* __LP64__ */
+#define VM_PAGE_DIRECTMAP_LIMIT (VM_MAX_KERNEL_ADDRESS \
+				 - VM_MIN_KERNEL_ADDRESS \
+				 - VM_KERNEL_MAP_SIZE + 1)
+#ifdef PAE
+#define VM_PAGE_MAX_SEGS 3
+#define VM_PAGE_HIGHMEM_LIMIT   DECL_CONST(0x10000000000000, ULL)
+#else /* PAE */
+#define VM_PAGE_MAX_SEGS 3
+#define VM_PAGE_HIGHMEM_LIMIT   DECL_CONST(0xfffff000, UL)
+#endif /* PAE */
+#endif /* __LP64__ */
+
+/*
+ * Physical segment indexes.
+ */
+#define VM_PAGE_SEG_DMA         0
+
+#ifdef __LP64__
+#define VM_PAGE_SEG_DMA32       1
+#define VM_PAGE_SEG_DIRECTMAP   2
+#define VM_PAGE_SEG_HIGHMEM     3
+#else /* __LP64__ */
+#define VM_PAGE_SEG_DMA32       1   /* Alias for the DIRECTMAP segment */
+#define VM_PAGE_SEG_DIRECTMAP   1
+#define VM_PAGE_SEG_HIGHMEM     2
+#endif /* __LP64__ */
+
 #endif /* _I386_KERNEL_I386_VM_PARAM_ */
diff --git a/i386/i386at/model_dep.c b/i386/i386at/model_dep.c
index 04cf6958..dbb9d8b6 100644
--- a/i386/i386at/model_dep.c
+++ b/i386/i386at/model_dep.c
@@ -64,6 +64,7 @@
 #include <i386/locore.h>
 #include <i386/model_dep.h>
 #include <i386at/autoconf.h>
+#include <i386at/biosmem.h>
 #include <i386at/idt.h>
 #include <i386at/int_init.h>
 #include <i386at/kd.h>
@@ -127,20 +128,6 @@ struct multiboot_info boot_info;
 /* Command line supplied to kernel.  */
 char *kernel_cmdline = "";
 
-/* This is used for memory initialization:
-   it gets bumped up through physical memory
-   that exists and is not occupied by boot gunk.
-   It is not necessarily page-aligned.  */
-static vm_offset_t avail_next
-#ifndef MACH_HYP
-	= RESERVED_BIOS /* XX end of BIOS data area */
-#endif	/* MACH_HYP */
-	;
-
-/* Possibly overestimated amount of available memory
-   still remaining to be handed to the VM system.  */
-static vm_size_t avail_remaining;
-
 extern char	version[];
 
 /* If set, reboot the system on ctrl-alt-delete.  */
@@ -275,91 +262,6 @@ void db_reset_cpu(void)
 	halt_all_cpus(1);
 }
 
-
-/*
- * Compute physical memory size and other parameters.
- */
-void
-mem_size_init(void)
-{
-	vm_offset_t max_phys_size;
-
-	/* Physical memory on all PCs starts at physical address 0.
-	   XX make it a constant.  */
-	phys_first_addr = 0;
-
-#ifdef MACH_HYP
-	if (boot_info.nr_pages >= 0x100000) {
-		printf("Truncating memory size to 4GiB\n");
-		phys_last_addr = 0xffffffffU;
-	} else
-		phys_last_addr = boot_info.nr_pages * 0x1000;
-#else	/* MACH_HYP */
-	vm_size_t phys_last_kb;
-
-	if (boot_info.flags & MULTIBOOT_MEM_MAP) {
-		struct multiboot_mmap *map, *map_end;
-
-		map = (void*) phystokv(boot_info.mmap_addr);
-		map_end = (void*) map + boot_info.mmap_count;
-
-		while (map + 1 <= map_end) {
-			if (map->Type == MB_ARD_MEMORY) {
-				unsigned long long start = map->BaseAddr, end = map->BaseAddr + map->Length;;
-
-				if (start >= 0x100000000ULL) {
-					printf("Ignoring %luMiB RAM region above 4GiB\n", (unsigned long) (map->Length >> 20));
-				} else {
-					if (end >= 0x100000000ULL) {
-						printf("Truncating memory region to 4GiB\n");
-						end = 0x0ffffffffU;
-					}
-					if (end > phys_last_addr)
-						phys_last_addr = end;
-
-					printf("AT386 boot: physical memory map from 0x%lx to 0x%lx\n",
-						(unsigned long) start,
-						(unsigned long) end);
-				}
-			}
-			map = (void*) map + map->size + sizeof(map->size);
-		}
-	} else {
-		phys_last_kb = 0x400 + boot_info.mem_upper;
-		/* Avoid 4GiB overflow.  */
-		if (phys_last_kb < 0x400 || phys_last_kb >= 0x400000) {
-			printf("Truncating memory size to 4GiB\n");
-			phys_last_addr = 0xffffffffU;
-		} else
-			phys_last_addr = phys_last_kb * 0x400;
-	}
-#endif	/* MACH_HYP */
-
-	printf("AT386 boot: physical memory from 0x%lx to 0x%lx\n",
-	       phys_first_addr, phys_last_addr);
-
-	/* Reserve room for virtual mappings.
-	 * Yes, this loses memory.  Blame i386.  */
-	max_phys_size = VM_MAX_KERNEL_ADDRESS - VM_MIN_KERNEL_ADDRESS - VM_KERNEL_MAP_SIZE;
-	if (phys_last_addr - phys_first_addr > max_phys_size) {
-		phys_last_addr = phys_first_addr + max_phys_size;
-		printf("Truncating memory to %luMiB\n", (phys_last_addr - phys_first_addr) / (1024 * 1024));
-		/* TODO Xen: be nice, free lost memory */
-	}
-
-	phys_first_addr = round_page(phys_first_addr);
-	phys_last_addr = trunc_page(phys_last_addr);
-
-#ifdef MACH_HYP
-	/* Memory is just contiguous */
-	avail_remaining = phys_last_addr;
-#else	/* MACH_HYP */
-	avail_remaining
-	  = phys_last_addr - (0x100000 - (boot_info.mem_lower * 0x400)
-			      - RESERVED_BIOS);
-#endif	/* MACH_HYP */
-}
-
 /*
  * Basic PC VM initialization.
  * Turns on paging and changes the kernel segments to use high linear addresses.
@@ -382,9 +284,9 @@ i386at_init(void)
 #endif	/* MACH_HYP */
 
 	/*
-	 * Find memory size parameters.
+	 * Read memory map and load it into the physical page allocator.
 	 */
-	mem_size_init();
+	biosmem_bootstrap((struct multiboot_raw_info *) &boot_info);
 
 #ifdef MACH_XEN
 	kernel_cmdline = (char*) boot_info.cmd_line;
@@ -432,6 +334,13 @@ i386at_init(void)
 	pmap_bootstrap();
 
 	/*
+	 *	Load physical segments into the VM system.
+	 *	The early allocation functions become unusable after
+	 *	this point.
+	 */
+	biosmem_setup();
+
+	/*
 	 * We'll have to temporarily install a direct mapping
 	 * between physical memory and low linear memory,
 	 * until we start using our new kernel segment descriptors.
@@ -706,187 +615,20 @@ resettodr(void)
 
 unsigned int pmap_free_pages(void)
 {
-	return atop(avail_remaining);
+	return vm_page_atop(phys_last_addr); /* XXX */
 }
 
-/* Always returns page-aligned regions.  */
 boolean_t
 init_alloc_aligned(vm_size_t size, vm_offset_t *addrp)
 {
-	vm_offset_t addr;
+	*addrp = biosmem_bootalloc(vm_page_atop(vm_page_round(size)));
 
-#ifdef MACH_HYP
-	/* There is none */
-	if (!avail_next)
-		avail_next = _kvtophys(boot_info.pt_base) + (boot_info.nr_pt_frames + 3) * 0x1000;
-#else	/* MACH_HYP */
-	extern char start[], end[];
-	int i;
-	static int wrapped = 0;
-
-	/* Memory regions to skip.  */
-	vm_offset_t cmdline_start_pa = boot_info.flags & MULTIBOOT_CMDLINE
-		? boot_info.cmdline : 0;
-	vm_offset_t cmdline_end_pa = cmdline_start_pa
-		? cmdline_start_pa+strlen((char*)phystokv(cmdline_start_pa))+1
-		: 0;
-	vm_offset_t mods_start_pa = boot_info.flags & MULTIBOOT_MODS
-		? boot_info.mods_addr : 0;
-	vm_offset_t mods_end_pa = mods_start_pa
-		? mods_start_pa
-		  + boot_info.mods_count * sizeof(struct multiboot_module)
-		: 0;
-
-	retry:
-#endif	/* MACH_HYP */
-
-	/* Page-align the start address.  */
-	avail_next = round_page(avail_next);
-
-#ifndef MACH_HYP
-	/* Start with memory above 16MB, reserving the low memory for later. */
-	/* Don't care on Xen */
-	if (!wrapped && phys_last_addr > 16 * 1024*1024)
-	  {
-	    if (avail_next < 16 * 1024*1024)
-	      avail_next = 16 * 1024*1024;
-	    else if (avail_next == phys_last_addr)
-	      {
-		/* We have used all the memory above 16MB, so now start on
-		   the low memory.  This will wind up at the end of the list
-		   of free pages, so it should not have been allocated to any
-		   other use in early initialization before the Linux driver
-		   glue initialization needs to allocate low memory.  */
-		avail_next = RESERVED_BIOS;
-		wrapped = 1;
-	      }
-	  }
-#endif	/* MACH_HYP */
-
-	/* Check if we have reached the end of memory.  */
-        if (avail_next == 
-		(
-#ifndef MACH_HYP
-		wrapped ? 16 * 1024*1024 : 
-#endif	/* MACH_HYP */
-		phys_last_addr))
+	if (*addrp == 0)
 		return FALSE;
 
-	/* Tentatively assign the current location to the caller.  */
-	addr = avail_next;
-
-	/* Bump the pointer past the newly allocated region
-	   and see where that puts us.  */
-	avail_next += size;
-
-#ifndef MACH_HYP
-	/* Skip past the I/O and ROM area.  */
-	if (boot_info.flags & MULTIBOOT_MEM_MAP)
-	{
-		struct multiboot_mmap *map, *map_end, *current = NULL, *next = NULL;
-		unsigned long long minimum_next = ~0ULL;
-
-		map = (void*) phystokv(boot_info.mmap_addr);
-		map_end = (void*) map + boot_info.mmap_count;
-
-		/* Find both our current map, and the next one */
-		while (map + 1 <= map_end)
-		{
-			if (map->Type == MB_ARD_MEMORY)
-			{
-				unsigned long long start = map->BaseAddr;
-				unsigned long long end = start + map->Length;;
-
-				if (start <= addr && avail_next <= end)
-				{
-					/* Ok, fits in the current map */
-					current = map;
-					break;
-				}
-				else if (avail_next <= start && start < minimum_next)
-				{
-					/* This map is not far from avail_next */
-					next = map;
-					minimum_next = start;
-				}
-			}
-			map = (void*) map + map->size + sizeof(map->size);
-		}
-
-		if (!current) {
-			/* Area does not fit in the current map, switch to next
-			 * map if any */
-			if (!next || next->BaseAddr >= phys_last_addr)
-			{
-				/* No further reachable map, we have reached
-				 * the end of memory, but possibly wrap around
-				 * 16MiB. */
-				avail_next = phys_last_addr;
-				goto retry;
-			}
-
-			/* Start from next map */
-			avail_next = next->BaseAddr;
-			goto retry;
-		}
-	}
-	else if ((avail_next > (boot_info.mem_lower * 0x400)) && (addr < 0x100000))
-	{
-		avail_next = 0x100000;
-		goto retry;
-	}
-
-	/* Skip our own kernel code, data, and bss.  */
-	if ((phystokv(avail_next) > (vm_offset_t)start) && (phystokv(addr) < (vm_offset_t)end))
-	{
-		avail_next = _kvtophys(end);
-		goto retry;
-	}
-
-	/* Skip any areas occupied by valuable boot_info data.  */
-	if ((avail_next > cmdline_start_pa) && (addr < cmdline_end_pa))
-	{
-		avail_next = cmdline_end_pa;
-		goto retry;
-	}
-	if ((avail_next > mods_start_pa) && (addr < mods_end_pa))
-	{
-		avail_next = mods_end_pa;
-		goto retry;
-	}
-	if ((phystokv(avail_next) > kern_sym_start) && (phystokv(addr) < kern_sym_end))
-	{
-		avail_next = _kvtophys(kern_sym_end);
-		goto retry;
-	}
-	if (boot_info.flags & MULTIBOOT_MODS)
-	{
-		struct multiboot_module *m = (struct multiboot_module *)
-			phystokv(boot_info.mods_addr);
-		for (i = 0; i < boot_info.mods_count; i++)
-		{
-			if ((avail_next > m[i].mod_start)
-			    && (addr < m[i].mod_end))
-			{
-				avail_next = m[i].mod_end;
-				goto retry;
-			}
-			/* XXX string */
-		}
-	}
-#endif	/* MACH_HYP */
-
-	avail_remaining -= size;
-
-	*addrp = addr;
 	return TRUE;
 }
 
-boolean_t pmap_next_page(vm_offset_t *addrp)
-{
-	return init_alloc_aligned(PAGE_SIZE, addrp);
-}
-
 /* Grab a physical page:
    the standard memory allocation mechanism
    during system initialization.  */
@@ -894,7 +636,7 @@ vm_offset_t
 pmap_grab_page(void)
 {
 	vm_offset_t addr;
-	if (!pmap_next_page(&addr))
+	if (!init_alloc_aligned(PAGE_SIZE, &addr))
 		panic("Not enough memory to initialize Mach");
 	return addr;
 }
diff --git a/i386/include/mach/i386/vm_types.h b/i386/include/mach/i386/vm_types.h
index 1439940b..41272e39 100644
--- a/i386/include/mach/i386/vm_types.h
+++ b/i386/include/mach/i386/vm_types.h
@@ -77,6 +77,11 @@ typedef	unsigned long	vm_offset_t;
 typedef	vm_offset_t *	vm_offset_array_t;
 
 /*
+ * A type for physical addresses.
+ */
+typedef unsigned long phys_addr_t;
+
+/*
  * A vm_size_t is the proper type for e.g.
  * expressing the difference between two
  * vm_offset_t entities.
diff --git a/kern/bootstrap.c b/kern/bootstrap.c
index 249c605c..08362767 100644
--- a/kern/bootstrap.c
+++ b/kern/bootstrap.c
@@ -107,6 +107,20 @@ task_insert_send_right(
 	return name;
 }
 
+static void
+free_bootstrap_pages(phys_addr_t start, phys_addr_t end)
+{
+  struct vm_page *page;
+
+  while (start < end)
+    {
+      page = vm_page_lookup_pa(start);
+      assert(page != NULL);
+      vm_page_manage(page);
+      start += PAGE_SIZE;
+    }
+}
+
 void bootstrap_create(void)
 {
   int compat;
@@ -265,7 +279,7 @@ void bootstrap_create(void)
   /* XXX we could free the memory used
      by the boot loader's descriptors and such.  */
   for (n = 0; n < boot_info.mods_count; n++)
-    vm_page_create(bmods[n].mod_start, bmods[n].mod_end);
+    free_bootstrap_pages(bmods[n].mod_start, bmods[n].mod_end);
 }
 
 static void
diff --git a/kern/cpu_number.h b/kern/cpu_number.h
index 44bbd641..650f4042 100644
--- a/kern/cpu_number.h
+++ b/kern/cpu_number.h
@@ -37,5 +37,7 @@ int	master_cpu;	/* 'master' processor - keeps time */
 	/* cpu number is always 0 on a single processor system */
 #define	cpu_number()	(0)
 
+#define CPU_L1_SIZE (1 << CPU_L1_SHIFT)
+
 #endif	/* NCPUS == 1 */
 #endif /* _KERN_CPU_NUMBER_H_ */
diff --git a/kern/slab.h b/kern/slab.h
index 77db7c1b..5ff3960e 100644
--- a/kern/slab.h
+++ b/kern/slab.h
@@ -48,6 +48,7 @@
 #define _KERN_SLAB_H
 
 #include <cache.h>
+#include <kern/cpu_number.h>
 #include <kern/lock.h>
 #include <kern/list.h>
 #include <kern/rbtree.h>
@@ -56,10 +57,6 @@
 #include <vm/vm_types.h>
 
 #if SLAB_USE_CPU_POOLS
-/*
- * L1 cache line size.
- */
-#define CPU_L1_SIZE (1 << CPU_L1_SHIFT)
 
 /*
  * Per-processor cache of pre-constructed objects.
diff --git a/kern/startup.c b/kern/startup.c
index 30cff5c0..bd296943 100644
--- a/kern/startup.c
+++ b/kern/startup.c
@@ -136,7 +136,7 @@ void setup_main(void)
 	mapable_time_init();
 
 	machine_info.max_cpus = NCPUS;
-	machine_info.memory_size = phys_last_addr - phys_first_addr; /* XXX mem_size */
+	machine_info.memory_size = vm_page_mem_size(); /* XXX phys_addr_t -> vm_size_t */
 	machine_info.avail_cpus = 0;
 	machine_info.major_version = KERNEL_MAJOR_VERSION;
 	machine_info.minor_version = KERNEL_MINOR_VERSION;
diff --git a/linux/dev/glue/glue.h b/linux/dev/glue/glue.h
index 5d4f6d88..8cb118cc 100644
--- a/linux/dev/glue/glue.h
+++ b/linux/dev/glue/glue.h
@@ -25,8 +25,8 @@
 extern int linux_auto_config;
 extern int linux_intr_pri;
 
-extern void *alloc_contig_mem (unsigned, unsigned, unsigned, vm_page_t *);
-extern void free_contig_mem (vm_page_t);
+extern unsigned long alloc_contig_mem (unsigned, unsigned, unsigned, vm_page_t *);
+extern void free_contig_mem (vm_page_t, unsigned);
 extern void init_IRQ (void);
 extern void restore_IRQ (void);
 extern void linux_kmem_init (void);
diff --git a/linux/dev/glue/kmem.c b/linux/dev/glue/kmem.c
index ff052ffc..ed576105 100644
--- a/linux/dev/glue/kmem.c
+++ b/linux/dev/glue/kmem.c
@@ -111,10 +111,8 @@ linux_kmem_init ()
       for (p = pages, j = 0; j < MEM_CHUNK_SIZE - PAGE_SIZE; j += PAGE_SIZE)
 	{
 	  assert (p->phys_addr < MEM_DMA_LIMIT);
-	  assert (p->phys_addr + PAGE_SIZE
-		  == ((vm_page_t) p->pageq.next)->phys_addr);
-
-	  p = (vm_page_t) p->pageq.next;
+	  assert (p->phys_addr + PAGE_SIZE == (p + 1)->phys_addr);
+	  p++;
 	}
 
       pages_free[i].end = pages_free[i].start + MEM_CHUNK_SIZE;
diff --git a/linux/dev/init/main.c b/linux/dev/init/main.c
index 8737b62c..d69b3fc7 100644
--- a/linux/dev/init/main.c
+++ b/linux/dev/init/main.c
@@ -98,7 +98,7 @@ void
 linux_init (void)
 {
   int addr;
-  unsigned memory_start, memory_end;
+  unsigned long memory_start, memory_end;
   vm_page_t pages;
 
   /*
@@ -131,9 +131,7 @@ linux_init (void)
   /*
    * Allocate contiguous memory below 16 MB.
    */
-  memory_start = (unsigned long) alloc_contig_mem (CONTIG_ALLOC,
-						   16 * 1024 * 1024,
-						   0, &pages);
+  memory_start = alloc_contig_mem (CONTIG_ALLOC, 16 * 1024 * 1024, 0, &pages);
   if (memory_start == 0)
     panic ("linux_init: alloc_contig_mem failed");
   memory_end = memory_start + CONTIG_ALLOC;
@@ -147,14 +145,6 @@ linux_init (void)
     panic ("linux_init: ran out memory");
 
   /*
-   * Free unused memory.
-   */
-  while (pages && phystokv(pages->phys_addr) < round_page (memory_start))
-    pages = (vm_page_t) pages->pageq.next;
-  if (pages)
-    free_contig_mem (pages);
-
-  /*
    * Initialize devices.
    */
 #ifdef CONFIG_INET
@@ -182,140 +172,31 @@ linux_init (void)
 
 /*
  * Allocate contiguous memory with the given constraints.
- * This routine is horribly inefficient but it is presently
- * only used during initialization so it's not that bad.
  */
-void *
+unsigned long
 alloc_contig_mem (unsigned size, unsigned limit,
 		  unsigned mask, vm_page_t * pages)
 {
-  int i, j, bits_len;
-  unsigned *bits, len;
-  void *m;
-  vm_page_t p, page_list, tail, prev;
-  vm_offset_t addr = 0, max_addr;
-
-  if (size == 0)
-    return (NULL);
-  size = round_page (size);
-  if ((size >> PAGE_SHIFT) > vm_page_free_count)
-    return (NULL);
-
-  /* Allocate bit array.  */
-  max_addr = phys_last_addr;
-  if (max_addr > limit)
-    max_addr = limit;
-  bits_len = ((((max_addr >> PAGE_SHIFT) + NBPW - 1) / NBPW)
-	      * sizeof (unsigned));
-  bits = (unsigned *) kalloc (bits_len);
-  if (!bits)
-    return (NULL);
-  memset (bits, 0, bits_len);
+  vm_page_t p;
 
-  /*
-   * Walk the page free list and set a bit for every usable page.
-   */
-  simple_lock (&vm_page_queue_free_lock);
-  p = vm_page_queue_free;
-  while (p)
-    {
-      if (p->phys_addr < limit)
-	(bits[(p->phys_addr >> PAGE_SHIFT) / NBPW]
-	 |= 1 << ((p->phys_addr >> PAGE_SHIFT) % NBPW));
-      p = (vm_page_t) p->pageq.next;
-    }
+  p = vm_page_grab_contig(size, VM_PAGE_SEL_DMA);
 
-  /*
-   * Scan bit array for contiguous pages.
-   */
-  len = 0;
-  m = NULL;
-  for (i = 0; len < size && i < bits_len / sizeof (unsigned); i++)
-    for (j = 0; len < size && j < NBPW; j++)
-      if (!(bits[i] & (1 << j)))
-	{
-	  len = 0;
-	  m = NULL;
-	}
-      else
-	{
-	  if (len == 0)
-	    {
-	      addr = ((vm_offset_t) (i * NBPW + j)
-		      << PAGE_SHIFT);
-	      if ((addr & mask) == 0)
-		{
-		  len += PAGE_SIZE;
-		  m = (void *) addr;
-		}
-	    }
-	  else
-	    len += PAGE_SIZE;
-	}
-
-  if (len != size)
-    {
-      simple_unlock (&vm_page_queue_free_lock);
-      kfree ((vm_offset_t) bits, bits_len);
-      return (NULL);
-    }
-
-  /*
-   * Remove pages from free list
-   * and construct list to return to caller.
-   */
-  page_list = NULL;
-  for (len = 0; len < size; len += PAGE_SIZE, addr += PAGE_SIZE)
-    {
-      prev = NULL;
-      for (p = vm_page_queue_free; p; p = (vm_page_t) p->pageq.next)
-	{
-	  if (p->phys_addr == addr)
-	    break;
-	  prev = p;
-	}
-      if (!p)
-	panic ("alloc_contig_mem: page not on free list");
-      if (prev)
-	prev->pageq.next = p->pageq.next;
-      else
-	vm_page_queue_free = (vm_page_t) p->pageq.next;
-      p->free = FALSE;
-      p->pageq.next = NULL;
-      if (!page_list)
-	page_list = tail = p;
-      else
-	{
-	  tail->pageq.next = (queue_entry_t) p;
-	  tail = p;
-	}
-      vm_page_free_count--;
-    }
+  if (p == NULL)
+    return 0;
 
-  simple_unlock (&vm_page_queue_free_lock);
-  kfree ((vm_offset_t) bits, bits_len);
   if (pages)
-    *pages = page_list;
-  return (void *) phystokv(m);
+    *pages = p;
+
+  return phystokv(vm_page_to_pa(p));
 }
 
 /*
  * Free memory allocated by alloc_contig_mem.
  */
 void
-free_contig_mem (vm_page_t pages)
+free_contig_mem (vm_page_t pages, unsigned size)
 {
-  int i;
-  vm_page_t p;
-
-  for (p = pages, i = 0; p->pageq.next; p = (vm_page_t) p->pageq.next, i++)
-    p->free = TRUE;
-  p->free = TRUE;
-  simple_lock (&vm_page_queue_free_lock);
-  vm_page_free_count += i + 1;
-  p->pageq.next = (queue_entry_t) vm_page_queue_free;
-  vm_page_queue_free = pages;
-  simple_unlock (&vm_page_queue_free_lock);
+  vm_page_free_contig(pages, size);
 }
 
 /* This is the number of bits of precision for the loops_per_second.  Each
diff --git a/linux/pcmcia-cs/glue/ds.c b/linux/pcmcia-cs/glue/ds.c
index 8f88b553..cc4b92b5 100644
--- a/linux/pcmcia-cs/glue/ds.c
+++ b/linux/pcmcia-cs/glue/ds.c
@@ -24,12 +24,6 @@
 /* This file is included from linux/pcmcia-cs/modules/ds.c.  */
 
 /*
- * Prepare the namespace for inclusion of Mach header files.
- */
-
-#undef PAGE_SHIFT
-
-/*
  * This is really ugly.  But this is glue code, so...  It's about the `kfree'
  * symbols in <linux/malloc.h> and <kern/kalloc.h>.
  */
diff --git a/vm/pmap.h b/vm/pmap.h
index 134f9c64..9bbcdc32 100644
--- a/vm/pmap.h
+++ b/vm/pmap.h
@@ -67,9 +67,6 @@
 extern vm_offset_t	pmap_steal_memory(vm_size_t);
 /* During VM initialization, report remaining unused physical pages.  */
 extern unsigned int	pmap_free_pages(void);
-/* During VM initialization, use remaining physical pages to allocate page
- * frames.  */
-extern void		pmap_startup(vm_offset_t *, vm_offset_t *);
 /* Initialization, after kernel runs in virtual memory.  */
 extern void		pmap_init(void);
 
@@ -80,18 +77,14 @@ extern void		pmap_init(void);
  *	Otherwise, it must implement
  *		pmap_free_pages
  *		pmap_virtual_space
- *		pmap_next_page
  *		pmap_init
- *	and vm/vm_resident.c implements pmap_steal_memory and pmap_startup
- *	using pmap_free_pages, pmap_next_page, pmap_virtual_space,
- *	and pmap_enter.  pmap_free_pages may over-estimate the number
- *	of unused physical pages, and pmap_next_page may return FALSE
- *	to indicate that there are no more unused pages to return.
+ *	and vm/vm_resident.c implements pmap_steal_memory using
+ *	pmap_free_pages, pmap_virtual_space, and pmap_enter.
+ *
+ *	pmap_free_pages may over-estimate the number of unused physical pages.
  *	However, for best performance pmap_free_pages should be accurate.
  */
 
-/* During VM initialization, return the next unused physical page.  */
-extern boolean_t	pmap_next_page(vm_offset_t *);
 /* During VM initialization, report virtual space available for the kernel.  */
 extern void		pmap_virtual_space(vm_offset_t *, vm_offset_t *);
 #endif	/* MACHINE_PAGES */
diff --git a/vm/vm_fault.c b/vm/vm_fault.c
index 46779f63..4d674174 100644
--- a/vm/vm_fault.c
+++ b/vm/vm_fault.c
@@ -607,7 +607,7 @@ vm_fault_return_t vm_fault_page(
 				 *	won't block for pages.
 				 */
 
-				if (m->fictitious && !vm_page_convert(m, FALSE)) {
+				if (m->fictitious && !vm_page_convert(&m, FALSE)) {
 					VM_PAGE_FREE(m);
 					vm_fault_cleanup(object, first_m);
 					return(VM_FAULT_MEMORY_SHORTAGE);
@@ -725,7 +725,7 @@ vm_fault_return_t vm_fault_page(
 			assert(m->object == object);
 			first_m = VM_PAGE_NULL;
 
-			if (m->fictitious && !vm_page_convert(m, !object->internal)) {
+			if (m->fictitious && !vm_page_convert(&m, !object->internal)) {
 				VM_PAGE_FREE(m);
 				vm_fault_cleanup(object, VM_PAGE_NULL);
 				return(VM_FAULT_MEMORY_SHORTAGE);
diff --git a/vm/vm_init.c b/vm/vm_init.c
index 3d1081cc..23d5d46e 100644
--- a/vm/vm_init.c
+++ b/vm/vm_init.c
@@ -83,4 +83,5 @@ void vm_mem_init(void)
 {
 	vm_object_init();
 	memory_object_proxy_init();
+	vm_page_info_all();
 }
diff --git a/vm/vm_object.c b/vm/vm_object.c
index 6666fcba..eda03c65 100644
--- a/vm/vm_object.c
+++ b/vm/vm_object.c
@@ -2891,7 +2891,8 @@ vm_object_page_map(
 		VM_PAGE_FREE(old_page);
 	    }
 
-	    vm_page_init(m, addr);
+	    vm_page_init(m);
+	    m->phys_addr = addr;
 	    m->private = TRUE;		/* don`t free page */
 	    m->wire_count = 1;
 	    vm_page_lock_queues();
diff --git a/vm/vm_page.h b/vm/vm_page.h
index d7450af8..7607aad0 100644
--- a/vm/vm_page.h
+++ b/vm/vm_page.h
@@ -155,8 +155,6 @@ struct vm_page {
  */
 
 extern
-vm_page_t	vm_page_queue_free;	/* memory free queue */
-extern
 vm_page_t	vm_page_queue_fictitious;	/* fictitious free queue */
 extern
 queue_head_t	vm_page_queue_active;	/* active memory queue */
@@ -211,25 +209,21 @@ extern void		vm_page_bootstrap(
 	vm_offset_t	*endp);
 extern void		vm_page_module_init(void);
 
-extern void		vm_page_create(
-	vm_offset_t	start,
-	vm_offset_t	end);
 extern vm_page_t	vm_page_lookup(
 	vm_object_t	object,
 	vm_offset_t	offset);
 extern vm_page_t	vm_page_grab_fictitious(void);
-extern void		vm_page_release_fictitious(vm_page_t);
-extern boolean_t	vm_page_convert(vm_page_t, boolean_t);
+extern boolean_t	vm_page_convert(vm_page_t *, boolean_t);
 extern void		vm_page_more_fictitious(void);
 extern vm_page_t	vm_page_grab(boolean_t);
-extern void		vm_page_release(vm_page_t, boolean_t);
+extern vm_page_t	vm_page_grab_contig(vm_size_t, unsigned int);
+extern void		vm_page_free_contig(vm_page_t, vm_size_t);
 extern void		vm_page_wait(void (*)(void));
 extern vm_page_t	vm_page_alloc(
 	vm_object_t	object,
 	vm_offset_t	offset);
 extern void		vm_page_init(
-	vm_page_t	mem,
-	vm_offset_t	phys_addr);
+	vm_page_t	mem);
 extern void		vm_page_free(vm_page_t);
 extern void		vm_page_activate(vm_page_t);
 extern void		vm_page_deactivate(vm_page_t);
diff --git a/vm/vm_resident.c b/vm/vm_resident.c
index c70fa734..9fd64918 100644
--- a/vm/vm_resident.c
+++ b/vm/vm_resident.c
@@ -72,7 +72,7 @@
 /*
  *	These variables record the values returned by vm_page_bootstrap,
  *	for debugging purposes.  The implementation of pmap_steal_memory
- *	and pmap_startup here also uses them internally.
+ *	here also uses them internally.
  */
 
 vm_offset_t virtual_space_start;
@@ -95,21 +95,6 @@ vm_page_bucket_t *vm_page_buckets;		/* Array of buckets */
 unsigned int	vm_page_bucket_count = 0;	/* How big is array? */
 unsigned int	vm_page_hash_mask;		/* Mask for hash function */
 
-/*
- *	Resident page structures are initialized from
- *	a template (see vm_page_alloc).
- *
- *	When adding a new field to the virtual memory
- *	object structure, be sure to add initialization
- *	(see vm_page_bootstrap).
- */
-struct vm_page	vm_page_template;
-
-/*
- *	Resident pages that represent real memory
- *	are allocated from a free list.
- */
-vm_page_t	vm_page_queue_free;
 vm_page_t	vm_page_queue_fictitious;
 decl_simple_lock_data(,vm_page_queue_free_lock)
 unsigned int	vm_page_free_wanted;
@@ -192,48 +177,15 @@ void vm_page_bootstrap(
 	vm_offset_t *startp,
 	vm_offset_t *endp)
 {
-	vm_page_t m;
 	int i;
 
 	/*
-	 *	Initialize the vm_page template.
-	 */
-
-	m = &vm_page_template;
-	m->object = VM_OBJECT_NULL;	/* reset later */
-	m->offset = 0;			/* reset later */
-	m->wire_count = 0;
-
-	m->inactive = FALSE;
-	m->active = FALSE;
-	m->laundry = FALSE;
-	m->free = FALSE;
-	m->external = FALSE;
-
-	m->busy = TRUE;
-	m->wanted = FALSE;
-	m->tabled = FALSE;
-	m->fictitious = FALSE;
-	m->private = FALSE;
-	m->absent = FALSE;
-	m->error = FALSE;
-	m->dirty = FALSE;
-	m->precious = FALSE;
-	m->reference = FALSE;
-
-	m->phys_addr = 0;		/* reset later */
-
-	m->page_lock = VM_PROT_NONE;
-	m->unlock_request = VM_PROT_NONE;
-
-	/*
 	 *	Initialize the page queues.
 	 */
 
 	simple_lock_init(&vm_page_queue_free_lock);
 	simple_lock_init(&vm_page_queue_lock);
 
-	vm_page_queue_free = VM_PAGE_NULL;
 	vm_page_queue_fictitious = VM_PAGE_NULL;
 	queue_init(&vm_page_queue_active);
 	queue_init(&vm_page_queue_inactive);
@@ -280,15 +232,8 @@ void vm_page_bootstrap(
 		simple_lock_init(&bucket->lock);
 	}
 
-	/*
-	 *	Machine-dependent code allocates the resident page table.
-	 *	It uses vm_page_init to initialize the page frames.
-	 *	The code also returns to us the virtual space available
-	 *	to the kernel.  We don't trust the pmap module
-	 *	to get the alignment right.
-	 */
+	vm_page_setup();
 
-	pmap_startup(&virtual_space_start, &virtual_space_end);
 	virtual_space_start = round_page(virtual_space_start);
 	virtual_space_end = trunc_page(virtual_space_end);
 
@@ -301,8 +246,8 @@ void vm_page_bootstrap(
 
 #ifndef	MACHINE_PAGES
 /*
- *	We implement pmap_steal_memory and pmap_startup with the help
- *	of two simpler functions, pmap_virtual_space and pmap_next_page.
+ *	We implement pmap_steal_memory with the help
+ *	of two simpler functions, pmap_virtual_space and vm_page_bootalloc.
  */
 
 vm_offset_t pmap_steal_memory(
@@ -310,11 +255,7 @@ vm_offset_t pmap_steal_memory(
 {
 	vm_offset_t addr, vaddr, paddr;
 
-	/*
-	 *	We round the size to an integer multiple.
-	 */
-
-	size = (size + 3) &~ 3;
+	size = round_page(size);
 
 	/*
 	 *	If this is the first call to pmap_steal_memory,
@@ -347,8 +288,7 @@ vm_offset_t pmap_steal_memory(
 	for (vaddr = round_page(addr);
 	     vaddr < addr + size;
 	     vaddr += PAGE_SIZE) {
-		if (!pmap_next_page(&paddr))
-			panic("pmap_steal_memory");
+		paddr = vm_page_bootalloc(PAGE_SIZE);
 
 		/*
 		 *	XXX Logically, these mappings should be wired,
@@ -361,64 +301,6 @@ vm_offset_t pmap_steal_memory(
 
 	return addr;
 }
-
-void pmap_startup(
-	vm_offset_t *startp,
-	vm_offset_t *endp)
-{
-	unsigned int i, npages, pages_initialized;
-	vm_page_t pages;
-	vm_offset_t paddr;
-
-	/*
-	 *	We calculate how many page frames we will have
-	 *	and then allocate the page structures in one chunk.
-	 */
-
-	npages = ((PAGE_SIZE * pmap_free_pages() +
-		   (round_page(virtual_space_start) - virtual_space_start)) /
-		  (PAGE_SIZE + sizeof *pages));
-
-	pages = (vm_page_t) pmap_steal_memory(npages * sizeof *pages);
-
-	/*
-	 *	Initialize the page frames.
-	 */
-
-	for (i = 0, pages_initialized = 0; i < npages; i++) {
-		if (!pmap_next_page(&paddr))
-			break;
-
-		vm_page_init(&pages[i], paddr);
-		pages_initialized++;
-	}
-	i = 0;
-	while (pmap_next_page(&paddr))
-		i++;
-	if (i)
-		printf("%u memory page(s) left away\n", i);
-
-	/*
-	 * Release pages in reverse order so that physical pages
-	 * initially get allocated in ascending addresses. This keeps
-	 * the devices (which must address physical memory) happy if
-	 * they require several consecutive pages.
-	 */
-
-	for (i = pages_initialized; i > 0; i--) {
-		vm_page_release(&pages[i - 1], FALSE);
-	}
-
-	/*
-	 *	We have to re-align virtual_space_start,
-	 *	because pmap_steal_memory has been using it.
-	 */
-
-	virtual_space_start = round_page(virtual_space_start);
-
-	*startp = virtual_space_start;
-	*endp = virtual_space_end;
-}
 #endif	/* MACHINE_PAGES */
 
 /*
@@ -434,34 +316,6 @@ void		vm_page_module_init(void)
 }
 
 /*
- *	Routine:	vm_page_create
- *	Purpose:
- *		After the VM system is up, machine-dependent code
- *		may stumble across more physical memory.  For example,
- *		memory that it was reserving for a frame buffer.
- *		vm_page_create turns this memory into available pages.
- */
-
-void vm_page_create(
-	vm_offset_t	start,
-	vm_offset_t	end)
-{
-	vm_offset_t paddr;
-	vm_page_t m;
-
-	for (paddr = round_page(start);
-	     paddr < trunc_page(end);
-	     paddr += PAGE_SIZE) {
-		m = (vm_page_t) kmem_cache_alloc(&vm_page_cache);
-		if (m == VM_PAGE_NULL)
-			panic("vm_page_create");
-
-		vm_page_init(m, paddr);
-		vm_page_release(m, FALSE);
-	}
-}
-
-/*
  *	vm_page_hash:
  *
  *	Distributes the object/offset key pair among hash buckets.
@@ -750,6 +604,33 @@ void vm_page_rename(
 	vm_page_unlock_queues();
 }
 
+static void vm_page_init_template(vm_page_t m)
+{
+	m->object = VM_OBJECT_NULL;	/* reset later */
+	m->offset = 0;			/* reset later */
+	m->wire_count = 0;
+
+	m->inactive = FALSE;
+	m->active = FALSE;
+	m->laundry = FALSE;
+	m->free = FALSE;
+	m->external = FALSE;
+
+	m->busy = TRUE;
+	m->wanted = FALSE;
+	m->tabled = FALSE;
+	m->fictitious = FALSE;
+	m->private = FALSE;
+	m->absent = FALSE;
+	m->error = FALSE;
+	m->dirty = FALSE;
+	m->precious = FALSE;
+	m->reference = FALSE;
+
+	m->page_lock = VM_PROT_NONE;
+	m->unlock_request = VM_PROT_NONE;
+}
+
 /*
  *	vm_page_init:
  *
@@ -758,11 +639,9 @@ void vm_page_rename(
  *	so that it can be given to vm_page_release or vm_page_insert.
  */
 void vm_page_init(
-	vm_page_t	mem,
-	vm_offset_t	phys_addr)
+	vm_page_t	mem)
 {
-	*mem = vm_page_template;
-	mem->phys_addr = phys_addr;
+	vm_page_init_template(mem);
 }
 
 /*
@@ -794,7 +673,7 @@ vm_page_t vm_page_grab_fictitious(void)
  *	Release a fictitious page to the free list.
  */
 
-void vm_page_release_fictitious(
+static void vm_page_release_fictitious(
 	vm_page_t m)
 {
 	simple_lock(&vm_page_queue_free_lock);
@@ -826,7 +705,8 @@ void vm_page_more_fictitious(void)
 		if (m == VM_PAGE_NULL)
 			panic("vm_page_more_fictitious");
 
-		vm_page_init(m, vm_page_fictitious_addr);
+		vm_page_init(m);
+		m->phys_addr = vm_page_fictitious_addr;
 		m->fictitious = TRUE;
 		vm_page_release_fictitious(m);
 	}
@@ -836,25 +716,46 @@ void vm_page_more_fictitious(void)
  *	vm_page_convert:
  *
  *	Attempt to convert a fictitious page into a real page.
+ *
+ *	The object referenced by *MP must be locked.
  */
 
 boolean_t vm_page_convert(
-	vm_page_t m,
+	struct vm_page **mp,
 	boolean_t external)
 {
-	vm_page_t real_m;
+	struct vm_page *real_m, *fict_m;
+	vm_object_t object;
+	vm_offset_t offset;
+
+	fict_m = *mp;
+
+	assert(fict_m->fictitious);
+	assert(fict_m->phys_addr == vm_page_fictitious_addr);
+	assert(!fict_m->active);
+	assert(!fict_m->inactive);
 
 	real_m = vm_page_grab(external);
 	if (real_m == VM_PAGE_NULL)
 		return FALSE;
 
-	m->phys_addr = real_m->phys_addr;
-	m->fictitious = FALSE;
+	object = fict_m->object;
+	offset = fict_m->offset;
+	vm_page_remove(fict_m);
+
+	memcpy(&real_m->vm_page_header,
+	       &fict_m->vm_page_header,
+	       sizeof(*fict_m) - VM_PAGE_HEADER_SIZE);
+	real_m->fictitious = FALSE;
 
-	real_m->phys_addr = vm_page_fictitious_addr;
-	real_m->fictitious = TRUE;
+	vm_page_insert(real_m, object, offset);
 
-	vm_page_release_fictitious(real_m);
+	assert(real_m->phys_addr != vm_page_fictitious_addr);
+	assert(fict_m->fictitious);
+	assert(fict_m->phys_addr == vm_page_fictitious_addr);
+
+	vm_page_release_fictitious(fict_m);
+	*mp = real_m;
 	return TRUE;
 }
 
@@ -886,15 +787,16 @@ vm_page_t vm_page_grab(
 		return VM_PAGE_NULL;
 	}
 
-	if (vm_page_queue_free == VM_PAGE_NULL)
+	mem = vm_page_alloc_pa(0, VM_PAGE_SEL_DIRECTMAP, VM_PT_KERNEL);
+
+	if (mem == NULL)
 		panic("vm_page_grab");
 
 	if (--vm_page_free_count < vm_page_free_count_minimum)
 		vm_page_free_count_minimum = vm_page_free_count;
 	if (external)
 		vm_page_external_count++;
-	mem = vm_page_queue_free;
-	vm_page_queue_free = (vm_page_t) mem->pageq.next;
+
 	mem->free = FALSE;
 	mem->extcounted = mem->external = external;
 	simple_unlock(&vm_page_queue_free_lock);
@@ -928,208 +830,97 @@ vm_offset_t vm_page_grab_phys_addr(void)
 }
 
 /*
- *	vm_page_grab_contiguous_pages:
- *
- *	Take N pages off the free list, the pages should
- *	cover a contiguous range of physical addresses.
- *	[Used by device drivers to cope with DMA limitations]
+ *	vm_page_release:
  *
- *	Returns the page descriptors in ascending order, or
- *	Returns KERN_RESOURCE_SHORTAGE if it could not.
+ *	Return a page to the free list.
  */
 
-/* Biggest phys page number for the pages we handle in VM */
-
-vm_size_t	vm_page_big_pagenum = 0;	/* Set this before call! */
-
-kern_return_t
-vm_page_grab_contiguous_pages(
-	int		npages,
-	vm_page_t	pages[],
-	natural_t	*bits,
-	boolean_t	external)
+static void vm_page_release(
+	vm_page_t	mem,
+	boolean_t 	external)
 {
-	int		first_set;
-	int		size, alloc_size;
-	kern_return_t	ret;
-	vm_page_t       mem, *prevmemp;
+	simple_lock(&vm_page_queue_free_lock);
+	if (mem->free)
+		panic("vm_page_release");
+	mem->free = TRUE;
+	vm_page_free_pa(mem, 0);
+	vm_page_free_count++;
+	if (external)
+		vm_page_external_count--;
 
-#ifndef	NBBY
-#define	NBBY	8	/* size in bits of sizeof()`s unity */
-#endif
+	/*
+	 *	Check if we should wake up someone waiting for page.
+	 *	But don't bother waking them unless they can allocate.
+	 *
+	 *	We wakeup only one thread, to prevent starvation.
+	 *	Because the scheduling system handles wait queues FIFO,
+	 *	if we wakeup all waiting threads, one greedy thread
+	 *	can starve multiple niceguy threads.  When the threads
+	 *	all wakeup, the greedy threads runs first, grabs the page,
+	 *	and waits for another page.  It will be the first to run
+	 *	when the next page is freed.
+	 *
+	 *	However, there is a slight danger here.
+	 *	The thread we wake might not use the free page.
+	 *	Then the other threads could wait indefinitely
+	 *	while the page goes unused.  To forestall this,
+	 *	the pageout daemon will keep making free pages
+	 *	as long as vm_page_free_wanted is non-zero.
+	 */
 
-#define	NBPEL	(sizeof(natural_t)*NBBY)
+	if ((vm_page_free_wanted > 0) &&
+	    (vm_page_free_count >= vm_page_free_reserved)) {
+		vm_page_free_wanted--;
+		thread_wakeup_one((event_t) &vm_page_free_count);
+	}
 
-	size = (vm_page_big_pagenum + NBPEL - 1)
-		& ~(NBPEL - 1);				/* in bits */
+	simple_unlock(&vm_page_queue_free_lock);
+}
 
-	size = size / NBBY;				/* in bytes */
+/*
+ *	vm_page_grab_contig:
+ *
+ *	Remove a block of contiguous pages from the free list.
+ *	Returns VM_PAGE_NULL if the request fails.
+ */
 
-	/*
-	 * If we are called before the VM system is fully functional
-	 * the invoker must provide us with the work space. [one bit
-	 * per page starting at phys 0 and up to vm_page_big_pagenum]
-	 */
-	if (bits == 0) {
-		alloc_size = round_page(size);
-		if (kmem_alloc_wired(kernel_map,
-				     (vm_offset_t *)&bits,
-				     alloc_size)
-			!= KERN_SUCCESS)
-		    return KERN_RESOURCE_SHORTAGE;
-	} else
-		alloc_size = 0;
+vm_page_t vm_page_grab_contig(
+	vm_size_t size,
+	unsigned int selector)
+{
+	unsigned int i, order, nr_pages;
+	vm_page_t mem;
 
-	memset(bits, 0, size);
+	order = vm_page_order(size);
+	nr_pages = 1 << order;
 
-	/*
-	 * A very large granularity call, its rare so that is ok
-	 */
 	simple_lock(&vm_page_queue_free_lock);
 
 	/*
-	 *	Do not dip into the reserved pool.
+	 *	Only let privileged threads (involved in pageout)
+	 *	dip into the reserved pool or exceed the limit
+	 *	for externally-managed pages.
 	 */
 
-	if ((vm_page_free_count < vm_page_free_reserved)
-	    || (vm_page_external_count >= vm_page_external_limit)) {
-		printf_once("no more room for vm_page_grab_contiguous_pages");
+	if (((vm_page_free_count - nr_pages) <= vm_page_free_reserved)
+	    && !current_thread()->vm_privilege) {
 		simple_unlock(&vm_page_queue_free_lock);
-		return KERN_RESOURCE_SHORTAGE;
-	}
-
-	/*
-	 *	First pass through, build a big bit-array of
-	 *	the pages that are free.  It is not going to
-	 *	be too large anyways, in 4k we can fit info
-	 *	for 32k pages.
-	 */
-	mem = vm_page_queue_free;
-	while (mem) {
-		int word_index, bit_index;
-
-		bit_index = (mem->phys_addr >> PAGE_SHIFT);
-		word_index = bit_index / NBPEL;
-		bit_index = bit_index - (word_index * NBPEL);
-		bits[word_index] |= 1 << bit_index;
-
-		mem = (vm_page_t) mem->pageq.next;
+		return VM_PAGE_NULL;
 	}
 
-	/*
-	 *	Second loop. Scan the bit array for NPAGES
-	 *	contiguous bits.  That gives us, if any,
-	 *	the range of pages we will be grabbing off
-	 *	the free list.
-	 */
-	{
-	    int	bits_so_far = 0, i;
-
-		first_set = 0;
-
-		for (i = 0; i < size; i += sizeof(natural_t)) {
-
-		    natural_t	v = bits[i / sizeof(natural_t)];
-		    int		bitpos;
-
-		    /*
-		     * Bitscan this one word
-		     */
-		    if (v) {
-			/*
-			 * keep counting them beans ?
-			 */
-			bitpos = 0;
-
-			if (bits_so_far) {
-count_ones:
-			    while (v & 1) {
-				bitpos++;
-				/*
-				 * got enough beans ?
-				 */
-				if (++bits_so_far == npages)
-				    goto found_em;
-				v >>= 1;
-			    }
-			    /* if we are being lucky, roll again */
-			    if (bitpos == NBPEL)
-			    	continue;
-			}
-
-			/*
-			 * search for beans here
-			 */
-			bits_so_far = 0;
-			while ((bitpos < NBPEL) && ((v & 1) == 0)) {
-			    bitpos++;
-			    v >>= 1;
-			}
-			if (v & 1) {
-			    first_set = (i * NBBY) + bitpos;
-			    goto count_ones;
-			}
-		    }
-		    /*
-		     * No luck
-		     */
-		    bits_so_far = 0;
-		}
-	}
+	mem = vm_page_alloc_pa(order, selector, VM_PT_KERNEL);
 
-	/*
-	 *	We could not find enough contiguous pages.
-	 */
-	simple_unlock(&vm_page_queue_free_lock);
+	if (mem == NULL)
+		panic("vm_page_grab_contig");
 
-	printf_once("no contiguous room for vm_page_grab_contiguous_pages");
-	ret = KERN_RESOURCE_SHORTAGE;
-	goto out;
+	vm_page_free_count -= nr_pages;
 
-	/*
-	 *	Final pass. Now we know which pages we want.
-	 *	Scan the list until we find them all, grab
-	 *	pages as we go.  FIRST_SET tells us where
-	 *	in the bit-array our pages start.
-	 */
-found_em:
-	vm_page_free_count -= npages;
 	if (vm_page_free_count < vm_page_free_count_minimum)
 		vm_page_free_count_minimum = vm_page_free_count;
-	if (external)
-		vm_page_external_count += npages;
-	{
-	    vm_offset_t	first_phys, last_phys;
-
-	    /* cache values for compare */
-	    first_phys = first_set << PAGE_SHIFT;
-	    last_phys = first_phys + (npages << PAGE_SHIFT);/* not included */
-
-	    /* running pointers */
-	    mem = vm_page_queue_free;
-	    prevmemp = &vm_page_queue_free;
-
-	    while (mem) {
-
-		vm_offset_t	addr;
-
-		addr = mem->phys_addr;
-
-		if ((addr >= first_phys) &&
-		    (addr <  last_phys)) {
-		    *prevmemp = (vm_page_t) mem->pageq.next;
-		    pages[(addr - first_phys) >> PAGE_SHIFT] = mem;
-		    mem->free = FALSE;
-		    mem->extcounted = mem->external = external;
-		    /*
-		     * Got them all ?
-		     */
-		    if (--npages == 0) break;
-		} else
-		    prevmemp = (vm_page_t *) &mem->pageq.next;
-
-		mem = (vm_page_t) mem->pageq.next;
-	    }
+
+	for (i = 0; i < nr_pages; i++) {
+		mem[i].free = FALSE;
+		mem[i].extcounted = mem[i].external = 0;
 	}
 
 	simple_unlock(&vm_page_queue_free_lock);
@@ -1148,55 +939,35 @@ found_em:
 	if ((vm_page_free_count < vm_page_free_min) ||
 	    ((vm_page_free_count < vm_page_free_target) &&
 	     (vm_page_inactive_count < vm_page_inactive_target)))
-		thread_wakeup(&vm_page_free_wanted);
-
-	ret = KERN_SUCCESS;
-out:
-	if (alloc_size)
-		kmem_free(kernel_map, (vm_offset_t) bits, alloc_size);
+		thread_wakeup((event_t) &vm_page_free_wanted);
 
-	return ret;
+	return mem;
 }
 
 /*
- *	vm_page_release:
+ *	vm_page_free_contig:
  *
- *	Return a page to the free list.
+ *	Return a block of contiguous pages to the free list.
  */
 
-void vm_page_release(
-	vm_page_t	mem,
-	boolean_t 	external)
+void vm_page_free_contig(vm_page_t mem, vm_size_t size)
 {
+	unsigned int i, order, nr_pages;
+
+	order = vm_page_order(size);
+	nr_pages = 1 << order;
+
 	simple_lock(&vm_page_queue_free_lock);
-	if (mem->free)
-		panic("vm_page_release");
-	mem->free = TRUE;
-	mem->pageq.next = (queue_entry_t) vm_page_queue_free;
-	vm_page_queue_free = mem;
-	vm_page_free_count++;
-	if (external)
-		vm_page_external_count--;
 
-	/*
-	 *	Check if we should wake up someone waiting for page.
-	 *	But don't bother waking them unless they can allocate.
-	 *
-	 *	We wakeup only one thread, to prevent starvation.
-	 *	Because the scheduling system handles wait queues FIFO,
-	 *	if we wakeup all waiting threads, one greedy thread
-	 *	can starve multiple niceguy threads.  When the threads
-	 *	all wakeup, the greedy threads runs first, grabs the page,
-	 *	and waits for another page.  It will be the first to run
-	 *	when the next page is freed.
-	 *
-	 *	However, there is a slight danger here.
-	 *	The thread we wake might not use the free page.
-	 *	Then the other threads could wait indefinitely
-	 *	while the page goes unused.  To forestall this,
-	 *	the pageout daemon will keep making free pages
-	 *	as long as vm_page_free_wanted is non-zero.
-	 */
+	for (i = 0; i < nr_pages; i++) {
+		if (mem[i].free)
+			panic("vm_page_free_contig");
+
+		mem[i].free = TRUE;
+	}
+
+	vm_page_free_pa(mem, order);
+	vm_page_free_count += nr_pages;
 
 	if ((vm_page_free_wanted > 0) &&
 	    (vm_page_free_count >= vm_page_free_reserved)) {
@@ -1310,12 +1081,13 @@ void vm_page_free(
 	 */
 
 	if (mem->private || mem->fictitious) {
-		vm_page_init(mem, vm_page_fictitious_addr);
+		vm_page_init(mem);
+		mem->phys_addr = vm_page_fictitious_addr;
 		mem->fictitious = TRUE;
 		vm_page_release_fictitious(mem);
 	} else {
 		int external = mem->external && mem->extcounted;
-		vm_page_init(mem, mem->phys_addr);
+		vm_page_init(mem);
 		vm_page_release(mem, external);
 	}
 }