 @@ -1,14 +1,14 @@
-/*	$NetBSD: uvm_km.c,v 1.102 2008/12/01 10:54:57 ad Exp $	*/
+/*	$NetBSD: uvm_km.c,v 1.103 2008/12/13 11:34:43 ad Exp $	*/
 /*
  * Copyright (c) 1997 Charles D. Cranor and Washington University.
  * Copyright (c) 1991, 1993, The Regents of the University of California.
+ *
  * All rights reserved.
+ *
  * This code is derived from software contributed to Berkeley by
  * The Mach Operating System project at Carnegie-Mellon University.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
 @@ -118,27 +118,27 @@
  *   uvm_km_alloc(kernel_map, PAGE_SIZE) [allocate 1 wired down page in the
  *   kernel map].    if uvm_km_alloc returns virtual address 0xf8235000,
  *   then that means that the page at offset 0x235000 in kernel_object is
  *   mapped at 0xf8235000.
+ *
  * kernel object have one other special property: when the kernel virtual
  * memory mapping them is unmapped, the backing memory in the object is
  * freed right away.   this is done with the uvm_km_pgremove() function.
  * this has to be done because there is no backing store for kernel pages
  * and no need to save them after they are no longer referenced.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: uvm_km.c,v 1.102 2008/12/01 10:54:57 ad Exp $");
+__KERNEL_RCSID(0, "$NetBSD: uvm_km.c,v 1.103 2008/12/13 11:34:43 ad Exp $");
 #include "opt_uvmhist.h"
 #include <sys/param.h>
 #include <sys/malloc.h>
 #include <sys/systm.h>
 #include <sys/proc.h>
 #include <sys/pool.h>
 #include <uvm/uvm.h>
 /*
  * global data structures
 @@ -579,27 +579,29 @@ uvm_km_alloc(struct vm_map *map, vsize_t
 	 */
 	offset = kva - vm_map_min(kernel_map);
 	UVMHIST_LOG(maphist, "  kva=0x%x, offset=0x%x", kva, offset,0,0);
 	/*
 	 * now allocate and map in the memory... note that we are the only ones
 	 * whom should ever get a handle on this area of VM.
 	 */
 	loopva = kva;
 	loopsize = size;
-	pgaflags = UVM_PGA_USERESERVE;
+	pgaflags = 0;
 	if (flags & UVM_KMF_NOWAIT)
 		pgaflags |= UVM_PGA_USERESERVE;
 	if (flags & UVM_KMF_ZERO)
 		pgaflags |= UVM_PGA_ZERO;
 	prot = VM_PROT_READ | VM_PROT_WRITE;
 	if (flags & UVM_KMF_EXEC)
 		prot |= VM_PROT_EXECUTE;
 	while (loopsize) {
 		KASSERT(!pmap_extract(pmap_kernel(), loopva, NULL));
 		pg = uvm_pagealloc(NULL, offset, NULL, pgaflags);
 		/*
 		 * out of memory?
 		 */
 @@ -688,53 +690,53 @@ uvm_km_alloc_poolpage_cache(struct vm_ma
 #else
 	struct vm_page *pg;
 	struct pool *pp = &vm_map_to_kernel(map)->vmk_vacache;
 	vaddr_t va;
 	if ((map->flags & VM_MAP_VACACHE) == 0)
 		return uvm_km_alloc_poolpage(map, waitok);
 	va = (vaddr_t)pool_get(pp, waitok ? PR_WAITOK : PR_NOWAIT);
 	if (va == 0)
 		return 0;
 	KASSERT(!pmap_extract(pmap_kernel(), va, NULL));
 again:
-	pg = uvm_pagealloc(NULL, 0, NULL, UVM_PGA_USERESERVE);
+	pg = uvm_pagealloc(NULL, 0, NULL, waitok ? 0 : UVM_PGA_USERESERVE);
 	if (__predict_false(pg == NULL)) {
 		if (waitok) {
 			uvm_wait("plpg");
 			goto again;
 		} else {
 			pool_put(pp, (void *)va);
 			return 0;
+		}
+	}
 	pmap_kenter_pa(va, VM_PAGE_TO_PHYS(pg),
 	    VM_PROT_READ|VM_PROT_WRITE|PMAP_KMPAGE);
 	pmap_update(pmap_kernel());
 	return va;
 #endif /* PMAP_MAP_POOLPAGE */
+}
 vaddr_t
 uvm_km_alloc_poolpage(struct vm_map *map, bool waitok)
+{
 #if defined(PMAP_MAP_POOLPAGE)
 	struct vm_page *pg;
 	vaddr_t va;
  again:
-	pg = uvm_pagealloc(NULL, 0, NULL, UVM_PGA_USERESERVE);
+	pg = uvm_pagealloc(NULL, 0, NULL, waitok ? 0 : UVM_PGA_USERESERVE);
 	if (__predict_false(pg == NULL)) {
 		if (waitok) {
 			uvm_wait("plpg");
 			goto again;
 		} else
 			return (0);
+	}
 	va = PMAP_MAP_POOLPAGE(VM_PAGE_TO_PHYS(pg));
 	if (__predict_false(va == 0))
 		uvm_pagefree(pg);
 	return (va);
 #else
 	vaddr_t va;

 @@ -1,14 +1,14 @@
-/*	$NetBSD: uvm_map.c,v 1.264 2008/12/01 10:54:57 ad Exp $	*/
+/*	$NetBSD: uvm_map.c,v 1.265 2008/12/13 11:34:43 ad Exp $	*/
 /*
  * Copyright (c) 1997 Charles D. Cranor and Washington University.
  * Copyright (c) 1991, 1993, The Regents of the University of California.
+ *
  * All rights reserved.
+ *
  * This code is derived from software contributed to Berkeley by
  * The Mach Operating System project at Carnegie-Mellon University.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
 @@ -61,27 +61,27 @@
  *  School of Computer Science
  *  Carnegie Mellon University
  *  Pittsburgh PA 15213-3890
+ *
  * any improvements or extensions that they make and grant Carnegie the
  * rights to redistribute these changes.
  */
 /*
  * uvm_map.c: uvm map operations
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: uvm_map.c,v 1.264 2008/12/01 10:54:57 ad Exp $");
+__KERNEL_RCSID(0, "$NetBSD: uvm_map.c,v 1.265 2008/12/13 11:34:43 ad Exp $");
 #include "opt_ddb.h"
 #include "opt_uvmhist.h"
 #include "opt_uvm.h"
 #include "opt_sysv.h"
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/mman.h>
 #include <sys/proc.h>
 #include <sys/malloc.h>
 #include <sys/pool.h>
 #include <sys/kernel.h>
 @@ -4606,27 +4606,28 @@ again:
 			LIST_REMOVE(ukh, ukh_listq);
+	}
 	mutex_spin_exit(&uvm_kentry_lock);
 	if (entry)
 		return entry;
 	/*
 	 * there's no free entry for this vm_map.
 	 * now we need to allocate some vm_map_entry.
 	 * for simplicity, always allocate one page chunk of them at once.
 	 */
-	pg = uvm_pagealloc(NULL, 0, NULL, 0);
+	pg = uvm_pagealloc(NULL, 0, NULL,
 	    (flags & UVM_KMF_NOWAIT) != 0 ? UVM_PGA_USERESERVE : 0);
 	if (__predict_false(pg == NULL)) {
 		if (flags & UVM_FLAG_NOWAIT)
 			return NULL;
 		uvm_wait("kme_alloc");
 		goto again;
+	}
 	error = uvm_map_prepare(map, 0, PAGE_SIZE, NULL, UVM_UNKNOWN_OFFSET,
 , mapflags, &args);
 	if (error) {
 		uvm_pagefree(pg);
 		return NULL;
+	}

 @@ -1,14 +1,14 @@
-/*	$NetBSD: uvm_page.c,v 1.140 2008/07/04 10:56:59 ad Exp $	*/
+/*	$NetBSD: uvm_page.c,v 1.141 2008/12/13 11:34:43 ad Exp $	*/
 /*
  * Copyright (c) 1997 Charles D. Cranor and Washington University.
  * Copyright (c) 1991, 1993, The Regents of the University of California.
+ *
  * All rights reserved.
+ *
  * This code is derived from software contributed to Berkeley by
  * The Mach Operating System project at Carnegie-Mellon University.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
 @@ -61,27 +61,27 @@
  *  School of Computer Science
  *  Carnegie Mellon University
  *  Pittsburgh PA 15213-3890
+ *
  * any improvements or extensions that they make and grant Carnegie the
  * rights to redistribute these changes.
  */
 /*
  * uvm_page.c: page ops.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: uvm_page.c,v 1.140 2008/07/04 10:56:59 ad Exp $");
+__KERNEL_RCSID(0, "$NetBSD: uvm_page.c,v 1.141 2008/12/13 11:34:43 ad Exp $");
 #include "opt_uvmhist.h"
 #include "opt_readahead.h"
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/malloc.h>
 #include <sys/sched.h>
 #include <sys/kernel.h>
 #include <sys/vnode.h>
 #include <sys/proc.h>
 #include <sys/atomic.h>
 #include <sys/cpu.h>
 @@ -1061,27 +1061,27 @@ uvm_pagealloc_pgfl(struct uvm_cpu *ucpu,
  *	unknown contents page.  This is because we live with the
  *	consequences of a bad free list decision for the entire
  *	lifetime of the page, e.g. if the page comes from memory that
  *	is slower to access.
  */
 struct vm_page *
 uvm_pagealloc_strat(struct uvm_object *obj, voff_t off, struct vm_anon *anon,
     int flags, int strat, int free_list)
+{
 	int lcv, try1, try2, zeroit = 0, color;
 	struct uvm_cpu *ucpu;
 	struct vm_page *pg;
-	bool use_reserve;
+	lwp_t *l;
 	KASSERT(obj == NULL || anon == NULL);
 	KASSERT(anon == NULL || off == 0);
 	KASSERT(off == trunc_page(off));
 	KASSERT(obj == NULL || mutex_owned(&obj->vmobjlock));
 	KASSERT(anon == NULL || mutex_owned(&anon->an_lock));
 	mutex_spin_enter(&uvm_fpageqlock);
 	/*
 	 * This implements a global round-robin page coloring
 	 * algorithm.
+	 *
 @@ -1092,36 +1092,40 @@ uvm_pagealloc_strat(struct uvm_object *o
 	color = ucpu->page_free_nextcolor;
 	/*
 	 * check to see if we need to generate some free pages waking
 	 * the pagedaemon.
 	 */
 	uvm_kick_pdaemon();
 	/*
 	 * fail if any of these conditions is true:
 	 * [1]  there really are no free pages, or
 	 * [2]  only kernel "reserved" pages remain and
-	 *        the page isn't being allocated to a kernel object.
+	 *        reserved pages have not been requested.
 	 * [3]  only pagedaemon "reserved" pages remain and
 	 *        the requestor isn't the pagedaemon.
 	 * we make kernel reserve pages available if called by a
 	 * kernel thread or a realtime thread.
 	 */
 	l = curlwp;
-	use_reserve = (flags & UVM_PGA_USERESERVE) ||
+	if (__predict_true(l != NULL) && lwp_eprio(l) >= PRI_KTHREAD) {
-		(obj && UVM_OBJ_IS_KERN_OBJECT(obj));
+		flags |= UVM_PGA_USERESERVE;
 	if ((uvmexp.free <= uvmexp.reserve_kernel && !use_reserve) ||
 	if ((uvmexp.free <= uvmexp.reserve_kernel &&
 	    (flags & UVM_PGA_USERESERVE) == 0) ||
 	    (uvmexp.free <= uvmexp.reserve_pagedaemon &&
-	     !(use_reserve && curlwp == uvm.pagedaemon_lwp)))
+	     curlwp != uvm.pagedaemon_lwp))
 		goto fail;
 #if PGFL_NQUEUES != 2
 #error uvm_pagealloc_strat needs to be updated
 #endif
 	/*
 	 * If we want a zero'd page, try the ZEROS queue first, otherwise
 	 * we try the UNKNOWN queue first.
 	 */
 	if (flags & UVM_PGA_ZERO) {
 		try1 = PGFL_ZEROS;
 		try2 = PGFL_UNKNOWN;