mach-defpager: Drop kalloc/kfree

glibc is removing its malloc hooks, but gnumach now has support for
mlockall, which we can just use instead of kalloc/kfree.

* mach-defpager/main.c (main): Call mlockall.
* mach-defpager/kalloc.c: Remove.
* mach-defpager/kalloc.h: Remove.
* mach-defpager/default_pager.c: Use malloc/free instead of
  kalloc/kfree.
* mach-defpager/setup.c: Likewise.

6 files changed, 65 insertions, 409 deletions

diff --git a/mach-defpager/Makefile b/mach-defpager/Makefile
index 9bf394e7..310be710 100644
--- a/mach-defpager/Makefile
+++ b/mach-defpager/Makefile
@@ -23,7 +23,7 @@ dir	:= mach-defpager
 makemode:= server
 target	:= mach-defpager
 
-SRCS	:= default_pager.c kalloc.c wiring.c main.c setup.c
+SRCS	:= default_pager.c wiring.c main.c setup.c
 OBJS 	:= $(SRCS:.c=.o) \
 	   $(addsuffix Server.o,\
 		       memory_object default_pager memory_object_default exc) \
diff --git a/mach-defpager/default_pager.c b/mach-defpager/default_pager.c
index 0596704e..8b1f37d3 100644
--- a/mach-defpager/default_pager.c
+++ b/mach-defpager/default_pager.c
@@ -47,12 +47,12 @@
 
 #include "queue.h"
 #include "wiring.h"
-#include "kalloc.h"
 #include "default_pager.h"
 
 #include <assert-backtrace.h>
 #include <errno.h>
 #include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
 #include <stdarg.h>
 
@@ -186,14 +186,14 @@ new_partition (const char *name, struct file_direct *fdp,
 	size = atop(fdp->fd_size * fdp->fd_bsize);
 	bmsize = howmany(size, NB_BM) * sizeof(bm_entry_t);
 
-	part = (partition_t) kalloc(sizeof(struct part));
+	part = (partition_t) malloc(sizeof(struct part));
 	pthread_mutex_init(&part->p_lock, NULL);
-	part->name	= (char*) kalloc(n + 1);
+	part->name	= (char*) malloc(n + 1);
 	strcpy(part->name, name);
 	part->total_size = size;
 	part->free	= size;
 	part->id	= id;
-	part->bitmap	= (bm_entry_t *)kalloc(bmsize);
+	part->bitmap	= (bm_entry_t *)malloc(bmsize);
 	part->going_away= FALSE;
 	part->file = fdp;
 
@@ -337,9 +337,9 @@ new_partition (const char *name, struct file_direct *fdp,
 			    hdr->version,
 			    name);
 		    vm_deallocate(mach_task_self(), raddr, rsize);
-		    kfree(part->bitmap, bmsize);
-		    kfree(part->name, strlen(part->name) + 1);
-		    kfree(part, sizeof *part);
+		    free(part->bitmap);
+		    free(part->name);
+		    free(part);
 		    return 0;
 		  }
 		else
@@ -389,9 +389,9 @@ new_partition (const char *name, struct file_direct *fdp,
 		    "Cannot find Linux swap signature page!  "
 		    "SKIPPING %s (%uk partition)!",
 		    name, part->total_size * (vm_page_size / 1024));
-	    kfree(part->bitmap, bmsize);
-	    kfree(part->name, strlen(part->name) + 1);
-	    kfree(part, sizeof *part);
+	    free(part->bitmap);
+	    free(part->name);
+	    free(part);
 	    part = 0;
 	  }
 	else
@@ -433,7 +433,7 @@ create_paging_partition(const char *name,
 
 			n = i ? (i<<1) : 2;
 			new_list = (partition_t *)
-				kalloc( n * sizeof(partition_t) );
+				malloc( n * sizeof(partition_t) );
 			if (new_list == 0) no_paging_space(TRUE);
 			memset (new_list, 0, n * sizeof(partition_t));
 			if (i) {
@@ -442,7 +442,7 @@ create_paging_partition(const char *name,
 			}
 			all_partitions.partition_list = new_list;
 			all_partitions.n_partitions = n;
-			if (i) kfree(old_list, i*sizeof(partition_t));
+			if (i) free(old_list);
 		}
 		set_partition_of(i, part);
 	}
@@ -635,7 +635,7 @@ dp_map_t pager_get_direct_map(pager)
 		init_value = (dp_map_t)NO_BLOCK;
 	    }
 
-	    mapptr = (dp_map_t) kalloc(alloc_size);
+	    mapptr = (dp_map_t) malloc(alloc_size);
 	    for (emapptr = &mapptr[(alloc_size-1) / sizeof(vm_offset_t)];
 		 emapptr >= mapptr;
 		 emapptr--)
@@ -686,11 +686,11 @@ pager_alloc(pager, part, size)
 #ifdef	CHECKSUM
 	if (INDIRECT_PAGEMAP(size)) {
 		mapptr = (vm_offset_t *)
-			kalloc(INDIRECT_PAGEMAP_SIZE(size));
+			malloc(INDIRECT_PAGEMAP_SIZE(size));
 		for (i = INDIRECT_PAGEMAP_ENTRIES(size); --i >= 0;)
 			mapptr[i] = 0;
 	} else {
-		mapptr = (vm_offset_t *) kalloc(PAGEMAP_SIZE(size));
+		mapptr = (vm_offset_t *) malloc(PAGEMAP_SIZE(size));
 		for (i = 0; i < size; i++)
 			mapptr[i] = NO_CHECKSUM;
 	}
@@ -834,24 +834,24 @@ pager_extend(pager, new_size)
 	     * a larger indirect block.
 	     */
 	    new_mapptr = (dp_map_t)
-			kalloc(INDIRECT_PAGEMAP_SIZE(new_size));
+			malloc(INDIRECT_PAGEMAP_SIZE(new_size));
 	    old_mapptr = pager_get_direct_map(pager);
 	    for (i = 0; i < INDIRECT_PAGEMAP_ENTRIES(old_size); i++)
 		new_mapptr[i] = old_mapptr[i];
 	    for (; i < INDIRECT_PAGEMAP_ENTRIES(new_size); i++)
 		new_mapptr[i].indirect = (dp_map_t)0;
-	    kfree((char *)old_mapptr, INDIRECT_PAGEMAP_SIZE(old_size));
+	    free((char *)old_mapptr);
 	    pager->map = new_mapptr;
 	    pager->size = new_size;
 #ifdef	CHECKSUM
 	    new_mapptr = (vm_offset_t *)
-			kalloc(INDIRECT_PAGEMAP_SIZE(new_size));
+			malloc(INDIRECT_PAGEMAP_SIZE(new_size));
 	    old_mapptr = pager->checksum;
 	    for (i = 0; i < INDIRECT_PAGEMAP_ENTRIES(old_size); i++)
 		new_mapptr[i] = old_mapptr[i];
 	    for (; i < INDIRECT_PAGEMAP_ENTRIES(new_size); i++)
 		new_mapptr[i] = 0;
-	    kfree((char *)old_mapptr, INDIRECT_PAGEMAP_SIZE(old_size));
+	    free((char *)old_mapptr);
 	    pager->checksum = new_mapptr;
 #endif	 /* CHECKSUM */
 #if	DEBUG_READER_CONFLICTS
@@ -879,13 +879,13 @@ pager_extend(pager, new_size)
 	    /*
 	     * Allocate new second-level map first.
 	     */
-	    new_mapptr = (dp_map_t) kalloc(PAGEMAP_SIZE(PAGEMAP_ENTRIES));
+	    new_mapptr = (dp_map_t) malloc(PAGEMAP_SIZE(PAGEMAP_ENTRIES));
 	    old_mapptr = pager_get_direct_map(pager);
 	    for (i = 0; i < old_size; i++)
 		new_mapptr[i] = old_mapptr[i];
 	    for (; i < PAGEMAP_ENTRIES; i++)
 		invalidate_block(new_mapptr[i]);
-	    kfree((char *)old_mapptr, PAGEMAP_SIZE(old_size));
+	    free((char *)old_mapptr);
 	    old_mapptr = new_mapptr;
 
 #if 0
@@ -900,7 +900,7 @@ pager_extend(pager, new_size)
 	     * Now allocate indirect map.
 	     */
 	    new_mapptr = (dp_map_t)
-			kalloc(INDIRECT_PAGEMAP_SIZE(new_size));
+			malloc(INDIRECT_PAGEMAP_SIZE(new_size));
 	    new_mapptr[0].indirect = old_mapptr;
 	    for (i = 1; i < INDIRECT_PAGEMAP_ENTRIES(new_size); i++)
 		new_mapptr[i].indirect = 0;
@@ -910,20 +910,20 @@ pager_extend(pager, new_size)
 	    /*
 	     * Allocate new second-level map first.
 	     */
-	    new_mapptr = (vm_offset_t *)kalloc(PAGEMAP_SIZE(PAGEMAP_ENTRIES));
+	    new_mapptr = (vm_offset_t *)malloc(PAGEMAP_SIZE(PAGEMAP_ENTRIES));
 	    old_mapptr = pager->checksum;
 	    for (i = 0; i < old_size; i++)
 		new_mapptr[i] = old_mapptr[i];
 	    for (; i < PAGEMAP_ENTRIES; i++)
 		new_mapptr[i] = NO_CHECKSUM;
-	    kfree((char *)old_mapptr, PAGEMAP_SIZE(old_size));
+	    free((char *)old_mapptr);
 	    old_mapptr = new_mapptr;
 
 	    /*
 	     * Now allocate indirect map.
 	     */
 	    new_mapptr = (vm_offset_t *)
-			kalloc(INDIRECT_PAGEMAP_SIZE(new_size));
+			malloc(INDIRECT_PAGEMAP_SIZE(new_size));
 	    new_mapptr[0] = (vm_offset_t) old_mapptr;
 	    for (i = 1; i < INDIRECT_PAGEMAP_ENTRIES(new_size); i++)
 		new_mapptr[i] = 0;
@@ -938,24 +938,24 @@ pager_extend(pager, new_size)
 	/*
 	 * Enlarging a direct block.
 	 */
-	new_mapptr = (dp_map_t)	kalloc(PAGEMAP_SIZE(new_size));
+	new_mapptr = (dp_map_t)	malloc(PAGEMAP_SIZE(new_size));
 	old_mapptr = pager_get_direct_map(pager);
 	for (i = 0; i < old_size; i++)
 	    new_mapptr[i] = old_mapptr[i];
 	for (; i < new_size; i++)
 	    invalidate_block(new_mapptr[i]);
-	kfree((char *)old_mapptr, PAGEMAP_SIZE(old_size));
+	free((char *)old_mapptr);
 	pager->map = new_mapptr;
 	pager->size = new_size;
 #ifdef	CHECKSUM
 	new_mapptr = (vm_offset_t *)
-		kalloc(PAGEMAP_SIZE(new_size));
+		malloc(PAGEMAP_SIZE(new_size));
 	old_mapptr = pager->checksum;
 	for (i = 0; i < old_size; i++)
 	    new_mapptr[i] = old_mapptr[i];
 	for (; i < new_size; i++)
 	    new_mapptr[i] = NO_CHECKSUM;
-	kfree((char *)old_mapptr, PAGEMAP_SIZE(old_size));
+	free((char *)old_mapptr);
 	pager->checksum = new_mapptr;
 #endif	 /* CHECKSUM */
 #if	DEBUG_READER_CONFLICTS
@@ -1016,7 +1016,7 @@ pager_truncate(dpager_t pager, vm_size_t new_size)	/* in pages */
 	  const dp_map_t mapptr = pager->map[i].indirect;
 	  pager->map[i].indirect = (dp_map_t)0;
 	  dealloc_direct (mapptr, PAGEMAP_ENTRIES, 0);
-	  kfree ((char *)mapptr, PAGEMAP_SIZE(PAGEMAP_ENTRIES));
+	  free ((char *)mapptr);
 	}
 
       /* Now truncate what's now the final nonempty direct block.  */
@@ -1027,9 +1027,9 @@ pager_truncate(dpager_t pager, vm_size_t new_size)	/* in pages */
       if (INDIRECT_PAGEMAP (new_size))
 	{
 	  const dp_map_t old_mapptr = pager->map;
-	  pager->map = (dp_map_t) kalloc (INDIRECT_PAGEMAP_SIZE(new_size));
+	  pager->map = (dp_map_t) malloc (INDIRECT_PAGEMAP_SIZE(new_size));
 	  memcpy (pager->map, old_mapptr, INDIRECT_PAGEMAP_SIZE(new_size));
-	  kfree ((char *) old_mapptr, INDIRECT_PAGEMAP_SIZE (old_size));
+	  free ((char *) old_mapptr);
 	}
       else
 	{
@@ -1037,7 +1037,7 @@ pager_truncate(dpager_t pager, vm_size_t new_size)	/* in pages */
 	     a one-level map.  We already have that map, as the first and only
 	     nonempty element in our indirect map.  */
 	  const dp_map_t mapptr = pager->map[0].indirect;
-	  kfree((char *)pager->map, INDIRECT_PAGEMAP_SIZE(old_size));
+	  free((char *)pager->map);
 	  pager->map = mapptr;
 	}
     }
@@ -1046,16 +1046,11 @@ pager_truncate(dpager_t pager, vm_size_t new_size)	/* in pages */
     {
       /* First deallocate pages in the truncated region.  */
       dealloc_direct (pager->map, old_size, new_size);
-      /* Now reduce the size of the direct map itself.  We don't bother
-	 with kalloc/kfree if it's not shrinking enough that kalloc.c
-	 would actually use less.  */
-      if (PAGEMAP_SIZE (new_size) <= PAGEMAP_SIZE (old_size) / 2)
-	{
-	  const dp_map_t old_mapptr = pager->map;
-	  pager->map = (dp_map_t) kalloc (PAGEMAP_SIZE (new_size));
-	  memcpy (pager->map, old_mapptr, PAGEMAP_SIZE (new_size));
-	  kfree ((char *) old_mapptr, PAGEMAP_SIZE (old_size));
-	}
+      /* Now reduce the size of the direct map itself.  */
+      const dp_map_t old_mapptr = pager->map;
+      pager->map = (dp_map_t) malloc (PAGEMAP_SIZE (new_size));
+      memcpy (pager->map, old_mapptr, PAGEMAP_SIZE (new_size));
+      free ((char *) old_mapptr);
     }
 
  done:
@@ -1396,7 +1391,7 @@ pager_write_offset(pager, offset)
 		int i;
 		ddprintf ("pager_write_offset: allocating indirect\n");
 
-		mapptr = (dp_map_t) kalloc(PAGEMAP_SIZE(PAGEMAP_ENTRIES));
+		mapptr = (dp_map_t) malloc(PAGEMAP_SIZE(PAGEMAP_ENTRIES));
 		if (mapptr == 0) {
 		    /* out of space! */
 		    no_paging_space(TRUE);
@@ -1411,7 +1406,7 @@ pager_write_offset(pager, offset)
 		    int j;
 
 		    cksumptr = (vm_offset_t *)
-				kalloc(PAGEMAP_SIZE(PAGEMAP_ENTRIES));
+				malloc(PAGEMAP_SIZE(PAGEMAP_ENTRIES));
 		    if (cksumptr == 0) {
 			/* out of space! */
 			no_paging_space(TRUE);
@@ -1510,21 +1505,20 @@ pager_dealloc(pager)
 			    pager_dealloc_page(block.block.p_index,
 			    			block.block.p_offset, TRUE);
 		    }
-		    kfree((char *)mapptr, PAGEMAP_SIZE(PAGEMAP_ENTRIES));
+		    free((char *)mapptr);
 		    pager->map[i].indirect = (dp_map_t) 0;
 		}
 	    }
-	    kfree((char *)pager->map, INDIRECT_PAGEMAP_SIZE(pager->size));
+	    free((char *)pager->map);
 	    pager->map = (dp_map_t) 0;
 #ifdef	CHECKSUM
 	    for (i = INDIRECT_PAGEMAP_ENTRIES(pager->size); --i >= 0; ) {
 		mapptr = (vm_offset_t *)pager->checksum[i];
 		if (mapptr) {
-		    kfree((char *)mapptr, PAGEMAP_SIZE(PAGEMAP_ENTRIES));
+		    free((char *)mapptr);
 		}
 	    }
-	    kfree((char *)pager->checksum,
-		  INDIRECT_PAGEMAP_SIZE(pager->size));
+	    free((char *)pager->checksum);
 #endif	 /* CHECKSUM */
 	}
 	else {
@@ -1535,10 +1529,10 @@ pager_dealloc(pager)
 		    pager_dealloc_page(block.block.p_index,
 		    			block.block.p_offset, TRUE);
 	    }
-	    kfree((char *)pager->map, PAGEMAP_SIZE(pager->size));
+	    free((char *)pager->map);
 	    pager->map = (dp_map_t) 0;
 #ifdef	CHECKSUM
-	    kfree((char *)pager->checksum, PAGEMAP_SIZE(pager->size));
+	    free((char *)pager->checksum);
 #endif	 /* CHECKSUM */
 	}
 }
@@ -1911,9 +1905,9 @@ dprintf("Partition x%p (id x%x) for %s, all_ok %d\n", part, id, name, all_ok);
 
 		set_partition_of(pindex, 0);
 		*pp_private = part->file;
-		kfree(part->bitmap, howmany(part->total_size, NB_BM) * sizeof(bm_entry_t));
-		kfree(part->name, strlen(part->name) + 1);
-		kfree(part, sizeof(struct part));
+		free(part->bitmap);
+		free(part->name);
+		free(part);
 		dprintf("%s Removed paging partition %s\n", my_name, name);
 		return KERN_SUCCESS;
 	}
@@ -2124,7 +2118,7 @@ default_pager_t pager_port_alloc(size)
 	default_pager_t ds;
 	p_index_t	part;
 
-	ds = (default_pager_t) kalloc(sizeof *ds);
+	ds = (default_pager_t) malloc(sizeof *ds);
 	if (ds == DEFAULT_PAGER_NULL)
 	    panic("%spager_port_alloc",my_name);
 	memset ((char *)ds, 0, sizeof *ds);
@@ -2441,7 +2435,7 @@ void default_pager_no_senders(ds, seqno, mscount)
 	/*
 	 * Do this *after* deallocating the port name
 	 */
-	kfree((char *) ds, sizeof(*ds));
+	free((char *) ds);
 
 	/*
 	 * Recover memory that we might have wasted because
@@ -2453,7 +2447,7 @@ void default_pager_no_senders(ds, seqno, mscount)
 
 		ds = (default_pager_t) queue_first(&all_pagers.leak_queue);
 		queue_remove_first(&all_pagers.leak_queue, ds, default_pager_t, links);
-		kfree((char *) ds, sizeof(*ds));
+		free((char *) ds);
 	}
 
 	pthread_mutex_unlock(&all_pagers.lock);
@@ -3011,7 +3005,7 @@ start_default_pager_thread(internal)
 	kern_return_t kr;
 	error_t err;
 
-	ndpt = (default_pager_thread_t *) kalloc(sizeof *ndpt);
+	ndpt = (default_pager_thread_t *) malloc(sizeof *ndpt);
 	if (ndpt == 0)
 		panic(my_name);
 
@@ -3176,7 +3170,7 @@ S_default_pager_object_create (mach_port_t pager,
 				     &port);
 	if (result != KERN_SUCCESS)
 	  {
-	    kfree ((char *) ds, sizeof *ds);
+	    free ((char *) ds);
 	    return result;
 	  }
 
diff --git a/mach-defpager/kalloc.c b/mach-defpager/kalloc.c
deleted file mode 100644
index 33566438..00000000
--- a/mach-defpager/kalloc.c
+++ /dev/null
@@ -1,313 +0,0 @@
-/*
- * Mach Operating System
- * Copyright (c) 1993-1987 Carnegie Mellon University
- * All Rights Reserved.
- *
- * Permission to use, copy, modify and distribute this software and its
- * documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
- * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie Mellon
- * the rights to redistribute these changes.
- */
-/*
- *	File:	kern/kalloc.c
- *	Author:	Avadis Tevanian, Jr.
- *	Date:	1985
- *
- *	General kernel memory allocator.  This allocator is designed
- *	to be used by the kernel to manage dynamic memory fast.
- */
-
-#include <mach.h>
-#include <pthread.h>		/* for spin locks */
-#include <malloc.h> 		/* for malloc_hook/free_hook */
-
-#include "wiring.h"
-
-static void init_hook (void);
-static void *malloc_hook (size_t size, const void *caller);
-static void *realloc_hook (void *ptr, size_t size, const void *caller);
-static void *memalign_hook (size_t alignment, size_t size, const void *caller);
-static void free_hook (void *ptr, const void *caller);
-
-/* GNU libc 2.14 defines this macro to declare hook variables as volatile.
-   Define it as empty for older libc versions.  */
-#ifndef __MALLOC_HOOK_VOLATILE
-# define __MALLOC_HOOK_VOLATILE
-#endif
-
-void (*__MALLOC_HOOK_VOLATILE __malloc_initialize_hook) (void) = init_hook;
-
-
-/* #define	DEBUG */
-
-/*
- *	All allocations of size less than kalloc_max are rounded to the
- *	next highest power of 2.
- */
-vm_size_t	kalloc_max;		/* max before we use vm_allocate */
-#define		MINSIZE	sizeof(vm_offset_t)		/* minimum allocation size */
-
-struct free_list {
-	pthread_spinlock_t	lock;
-	vm_offset_t		head;	/* head of free list */
-#ifdef	DEBUG
-	int			count;
-#endif	/*DEBUG*/
-};
-
-#define	KLIST_MAX	13
-					/* sizes: 4, 8, 16, 32, 64,
-						128, 256, 512, 1024,
-						2048, 4096, 8192, 16384 */
-struct free_list	kfree_list[KLIST_MAX];
-
-pthread_spinlock_t	kget_space_lock;
-vm_offset_t		kalloc_next_space = 0;
-vm_offset_t		kalloc_end_of_space = 0;
-
-vm_size_t		kalloc_wasted_space = 0;
-
-boolean_t		kalloc_initialized = FALSE;
-
-/*
- *	Initialize the memory allocator.  This should be called only
- *	once on a system wide basis (i.e. first processor to get here
- *	does the initialization).
- *
- *	This initializes all of the zones.
- */
-
-void kalloc_init(void)
-{
-	int i;
-
-	/*
-	 * Support free lists for items up to vm_page_size or
-	 * 16Kbytes, whichever is less.
-	 */
-
-	if (vm_page_size > (MINSIZE << (KLIST_MAX-1)))
-		kalloc_max = (MINSIZE << (KLIST_MAX-1));
-	else
-		kalloc_max = vm_page_size;
-
-	for (i = 0; i < KLIST_MAX; i++) {
-	    pthread_spin_init(&kfree_list[i].lock, PTHREAD_PROCESS_PRIVATE);
-	    kfree_list[i].head = 0;
-	}
-	pthread_spin_init(&kget_space_lock, PTHREAD_PROCESS_PRIVATE);
-
-	/*
-	 * Do not allocate memory at address 0.
-	 */
-	kalloc_next_space = vm_page_size;
-	kalloc_end_of_space = vm_page_size;
-}
-
-/*
- * Contiguous space allocator for items of less than a page size.
- */
-vm_offset_t kget_space(vm_offset_t size)
-{
-	vm_size_t	space_to_add = 0;
-	vm_offset_t	new_space = 0;
-	vm_offset_t	addr;
-
-	pthread_spin_lock(&kget_space_lock);
-	while (kalloc_next_space + size > kalloc_end_of_space) {
-	    /*
-	     * Add at least one page to allocation area.
-	     */
-	    space_to_add = round_page(size);
-
-	    if (new_space == 0) {
-		/*
-		 * Unlock and allocate memory.
-		 * Try to make it contiguous with the last
-		 * allocation area.
-		 */
-		pthread_spin_unlock(&kget_space_lock);
-
-		new_space = kalloc_end_of_space;
-		if (vm_map(mach_task_self(),
-			   &new_space, space_to_add, (vm_offset_t) 0, TRUE,
-			   MEMORY_OBJECT_NULL, (vm_offset_t) 0, FALSE,
-			   VM_PROT_DEFAULT, VM_PROT_ALL, VM_INHERIT_DEFAULT)
-			!= KERN_SUCCESS)
-		    return 0;
-		pthread_spin_lock(&kget_space_lock);
-		continue;
-	    }
-
-	    /*
-	     * Memory was allocated in a previous iteration.
-	     * Check whether the new region is contiguous with the
-	     * old one.
-	     */
-	    if (new_space != kalloc_end_of_space) {
-		/*
-		 * Throw away the remainder of the old space,
-		 * and start a new one.
-		 */
-		kalloc_wasted_space +=
-			kalloc_end_of_space - kalloc_next_space;
-		kalloc_next_space = new_space;
-	    }
-	    kalloc_end_of_space = new_space + space_to_add;
-
-	    new_space = 0;
-	}
-
-	addr = kalloc_next_space;
-	kalloc_next_space += size;
-	pthread_spin_unlock(&kget_space_lock);
-
-	if (new_space != 0)
-	    (void) vm_deallocate(mach_task_self(), new_space, space_to_add);
-
-	return addr;
-}
-
-void *kalloc(vm_size_t size)
-{
-	vm_size_t allocsize;
-	vm_offset_t addr;
-	struct free_list *fl;
-
-	if (!kalloc_initialized) {
-	    kalloc_init();
-	    kalloc_initialized = TRUE;
-	}
-
-	/* compute the size of the block that we will actually allocate */
-
-	allocsize = size;
-	if (size <= kalloc_max) {
-	    allocsize = MINSIZE;
-	    fl = kfree_list;
-	    while (allocsize < size) {
-		allocsize <<= 1;
-		fl++;
-	    }
-	}
-
-	/*
-	 * If our size is still small enough, check the queue for that size
-	 * and allocate.
-	 */
-
-	if (allocsize <= kalloc_max) {
-	    pthread_spin_lock(&fl->lock);
-	    if ((addr = fl->head) != 0) {
-		fl->head = *(vm_offset_t *)addr;
-#ifdef	DEBUG
-		fl->count--;
-#endif
-		pthread_spin_unlock(&fl->lock);
-	    }
-	    else {
-		pthread_spin_unlock(&fl->lock);
-		addr = kget_space(allocsize);
-	    }
-	}
-	else {
-	    if (vm_allocate(mach_task_self(), &addr, allocsize, TRUE)
-			!= KERN_SUCCESS)
-		addr = 0;
-	}
-	return (void *) addr;
-}
-
-void
-kfree(	void *data,
-	vm_size_t size)
-{
-	vm_size_t freesize;
-	struct free_list *fl;
-
-	freesize = size;
-	if (size <= kalloc_max) {
-	    freesize = MINSIZE;
-	    fl = kfree_list;
-	    while (freesize < size) {
-		freesize <<= 1;
-		fl++;
-	    }
-	}
-
-	if (freesize <= kalloc_max) {
-	    pthread_spin_lock(&fl->lock);
-	    *(vm_offset_t *)data = fl->head;
-	    fl->head = (vm_offset_t) data;
-#ifdef	DEBUG
-	    fl->count++;
-#endif
-	    pthread_spin_unlock(&fl->lock);
-	}
-	else {
-	    (void) vm_deallocate(mach_task_self(), (vm_offset_t)data, freesize);
-	}
-}
-
-static void
-init_hook (void)
-{
-  __malloc_hook = malloc_hook;
-  __realloc_hook = realloc_hook;
-  __memalign_hook = memalign_hook;
-  __free_hook = free_hook;
-}
-
-static void *
-malloc_hook (size_t size, const void *caller)
-{
-  return (void *) kalloc ((vm_size_t) size);
-}
-
-static void *
-realloc_hook (void *ptr, size_t size, const void *caller)
-{
-  panic("realloc_hook not implemented");
-}
-
-static void *
-memalign_hook (size_t alignment, size_t size, const void *caller)
-{
-  if (alignment > vm_page_size)
-    panic("memalign_hook not implemented");
-  return malloc_hook(size, caller);
-}
-
-static void
-free_hook (void *ptr, const void *caller)
-{
-  /* Just ignore harmless attempts at cleanliness.  */
-  /*	panic("free not implemented"); */
-}
-
-void malloc_fork_prepare()
-{
-}
-
-void malloc_fork_parent()
-{
-}
-
-void malloc_fork_child()
-{
-}
diff --git a/mach-defpager/kalloc.h b/mach-defpager/kalloc.h
deleted file mode 100644
index 8f52f1a5..00000000
--- a/mach-defpager/kalloc.h
+++ /dev/null
@@ -1,30 +0,0 @@
-/* Backing store access callbacks for Hurd version of Mach default pager.
-   Copyright (C) 2012 Free Software Foundation, Inc.
-
-   This file is part of the GNU Hurd.
-
-   The GNU Hurd is free software; you can redistribute it and/or
-   modify it under the terms of the GNU General Public License as
-   published by the Free Software Foundation; either version 2, or (at
-   your option) any later version.
-
-   The GNU Hurd is distributed in the hope that it will be useful, but
-   WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
-
-/*
- * General kernel memory allocator.
- */
-
-#ifndef _KALLOC_H_
-#define _KALLOC_H_
-
-void *kalloc (vm_size_t size);
-void kfree (void *data, vm_size_t size);
-
-#endif /* _KALLOC_H_ */
diff --git a/mach-defpager/main.c b/mach-defpager/main.c
index 71615c8f..67d4c585 100644
--- a/mach-defpager/main.c
+++ b/mach-defpager/main.c
@@ -32,6 +32,7 @@
 #include <error.h>
 #include <signal.h>
 #include <string.h>
+#include <sys/mman.h>
 
 /* XXX */
 #include <fcntl.h>
@@ -89,6 +90,10 @@ main (int argc, char **argv)
   if (err)
     error (1, err, "cannot get privileged ports");
 
+  err = mlockall(MCL_CURRENT | MCL_FUTURE);
+  if (err)
+    error (1, err, "cannot lock all memory");
+
   defpager = MACH_PORT_NULL;
   err = vm_set_default_memory_manager (bootstrap_master_host_port, &defpager);
   if (err)
diff --git a/mach-defpager/setup.c b/mach-defpager/setup.c
index 94685c0e..0fc4d9d4 100644
--- a/mach-defpager/setup.c
+++ b/mach-defpager/setup.c
@@ -24,9 +24,9 @@
 #include <mach.h>
 #include <string.h>
 #include <strings.h>
+#include <stdlib.h>
 
 #include "default_pager.h"
-#include "kalloc.h"
 
 #include "file_io.h"
 #include "default_pager_S.h"
@@ -74,7 +74,7 @@ S_default_pager_paging_storage (mach_port_t pager,
     /* We can't write disk blocks larger than pages.  */
     return EINVAL;
 
-  fdp = kalloc (offsetof (struct file_direct, runs[nrun]));
+  fdp = malloc (offsetof (struct file_direct, runs[nrun]));
   if (fdp == 0)
     return ENOMEM;
 
@@ -89,7 +89,7 @@ S_default_pager_paging_storage (mach_port_t pager,
       fdp->runs[i].length = runs[i + 1];
       if (fdp->runs[i].start + fdp->runs[i].length > devsize)
 	{
-	  kfree (fdp, offsetof (struct file_direct, runs[nrun]));
+	  free (fdp);
 	  return EINVAL;
 	}
       fdp->fd_size += fdp->runs[i].length;
@@ -269,7 +269,7 @@ add_paging_file(master_device_port, file_name, linux_signature)
   else
     {
       struct file_direct *fdp;
-      fdp = kalloc (offsetof (struct file_direct, runs[1]));
+      fdp = malloc (offsetof (struct file_direct, runs[1]));
       if (fdp == 0)
 	return ENOMEM;
 
@@ -301,7 +301,7 @@ remove_paging_file (char *file_name)
   if (kr == KERN_SUCCESS && fdp != 0)
     {
       mach_port_deallocate (mach_task_self (), fdp->device);
-      kfree (fdp, (char *) &fdp->runs[fdp->nruns] - (char *) fdp);
+      free (fdp);
     }
   return kr;
 }