 @@ -1,1093 +1,1093 @@
-/*	$NetBSD: sysv_shm.c,v 1.121 2011/07/30 06:19:02 uebayasi Exp $	*/
+/*	$NetBSD: sysv_shm.c,v 1.122 2011/08/27 09:11:52 christos Exp $	*/
 /*-
  * Copyright (c) 1999, 2007 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility,
  * NASA Ames Research Center, and by Mindaugas Rasiukevicius.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
 /*
  * Copyright (c) 1994 Adam Glass and Charles M. Hannum.  All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. All advertising materials mentioning features or use of this software
  *    must display the following acknowledgement:
  *	This product includes software developed by Adam Glass and Charles M.
  *	Hannum.
  * 4. The names of the authors may not be used to endorse or promote products
  *    derived from this software without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: sysv_shm.c,v 1.121 2011/07/30 06:19:02 uebayasi Exp $");
+__KERNEL_RCSID(0, "$NetBSD: sysv_shm.c,v 1.122 2011/08/27 09:11:52 christos Exp $");
 #define SYSVSHM
 #include <sys/param.h>
 #include <sys/kernel.h>
 #include <sys/kmem.h>
 #include <sys/shm.h>
 #include <sys/mutex.h>
 #include <sys/mman.h>
 #include <sys/stat.h>
 #include <sys/sysctl.h>
 #include <sys/mount.h>		/* XXX for <sys/syscallargs.h> */
 #include <sys/syscallargs.h>
 #include <sys/queue.h>
 #include <sys/kauth.h>
 #include <uvm/uvm_extern.h>
 #include <uvm/uvm_object.h>
 struct shmmap_entry {
 	SLIST_ENTRY(shmmap_entry) next;
 	vaddr_t va;
 	int shmid;
 };
 int			shm_nused		__cacheline_aligned;
 struct shmid_ds *	shmsegs			__read_mostly;
 static kmutex_t		shm_lock		__cacheline_aligned;
 static kcondvar_t *	shm_cv			__cacheline_aligned;
 static int		shm_last_free		__cacheline_aligned;
 static size_t		shm_committed		__cacheline_aligned;
 static int		shm_use_phys		__read_mostly;
 static kcondvar_t	shm_realloc_cv;
 static bool		shm_realloc_state;
 static u_int		shm_realloc_disable;
 struct shmmap_state {
 	unsigned int nitems;
 	unsigned int nrefs;
 	SLIST_HEAD(, shmmap_entry) entries;
 };
 #ifdef SHMDEBUG
 #define SHMPRINTF(a) printf a
 #else
 #define SHMPRINTF(a)
 #endif
 static int shmrealloc(int);
 /*
  * Find the shared memory segment by the identifier.
  *  => must be called with shm_lock held;
  */
 static struct shmid_ds *
 shm_find_segment_by_shmid(int shmid)
+{
 	int segnum;
 	struct shmid_ds *shmseg;
 	KASSERT(mutex_owned(&shm_lock));
 	segnum = IPCID_TO_IX(shmid);
 	if (segnum < 0 || segnum >= shminfo.shmmni)
 		return NULL;
 	shmseg = &shmsegs[segnum];
 	if ((shmseg->shm_perm.mode & SHMSEG_ALLOCATED) == 0)
 		return NULL;
 	if ((shmseg->shm_perm.mode &
 	    (SHMSEG_REMOVED|SHMSEG_RMLINGER)) == SHMSEG_REMOVED)
 		return NULL;
 	if (shmseg->shm_perm._seq != IPCID_TO_SEQ(shmid))
 		return NULL;
 	return shmseg;
+}
 /*
  * Free memory segment.
  *  => must be called with shm_lock held;
  */
 static void
 shm_free_segment(int segnum)
+{
 	struct shmid_ds *shmseg;
 	size_t size;
 	bool wanted;
 	KASSERT(mutex_owned(&shm_lock));
 	shmseg = &shmsegs[segnum];
 	SHMPRINTF(("shm freeing key 0x%lx seq 0x%x\n",
 	    shmseg->shm_perm._key, shmseg->shm_perm._seq));
 	size = (shmseg->shm_segsz + PGOFSET) & ~PGOFSET;
 	wanted = (shmseg->shm_perm.mode & SHMSEG_WANTED);
 	shmseg->_shm_internal = NULL;
 	shm_committed -= btoc(size);
 	shm_nused--;
 	shmseg->shm_perm.mode = SHMSEG_FREE;
 	shm_last_free = segnum;
 	if (wanted == true)
 		cv_broadcast(&shm_cv[segnum]);
+}
 /*
  * Delete entry from the shm map.
  *  => must be called with shm_lock held;
  */
 static struct uvm_object *
 shm_delete_mapping(struct shmmap_state *shmmap_s,
     struct shmmap_entry *shmmap_se)
+{
 	struct uvm_object *uobj = NULL;
 	struct shmid_ds *shmseg;
 	int segnum;
 	KASSERT(mutex_owned(&shm_lock));
 	segnum = IPCID_TO_IX(shmmap_se->shmid);
 	shmseg = &shmsegs[segnum];
 	SLIST_REMOVE(&shmmap_s->entries, shmmap_se, shmmap_entry, next);
 	shmmap_s->nitems--;
 	shmseg->shm_dtime = time_second;
 	if ((--shmseg->shm_nattch <= 0) &&
 	    (shmseg->shm_perm.mode & SHMSEG_REMOVED)) {
 		uobj = shmseg->_shm_internal;
 		shm_free_segment(segnum);
+	}
 	return uobj;
+}
 /*
  * Get a non-shared shm map for that vmspace.  Note, that memory
  * allocation might be performed with lock held.
  */
 static struct shmmap_state *
 shmmap_getprivate(struct proc *p)
+{
 	struct shmmap_state *oshmmap_s, *shmmap_s;
 	struct shmmap_entry *oshmmap_se, *shmmap_se;
 	KASSERT(mutex_owned(&shm_lock));
 	/* 1. A shm map with refcnt = 1, used by ourselves, thus return */
 	oshmmap_s = (struct shmmap_state *)p->p_vmspace->vm_shm;
 	if (oshmmap_s && oshmmap_s->nrefs == 1)
 		return oshmmap_s;
 	/* 2. No shm map preset - create a fresh one */
 	shmmap_s = kmem_zalloc(sizeof(struct shmmap_state), KM_SLEEP);
 	shmmap_s->nrefs = 1;
 	SLIST_INIT(&shmmap_s->entries);
 	p->p_vmspace->vm_shm = (void *)shmmap_s;
 	if (oshmmap_s == NULL)
 		return shmmap_s;
 	SHMPRINTF(("shmmap_getprivate: vm %p split (%d entries), was used by %d\n",
 	    p->p_vmspace, oshmmap_s->nitems, oshmmap_s->nrefs));
 	/* 3. A shared shm map, copy to a fresh one and adjust refcounts */
 	SLIST_FOREACH(oshmmap_se, &oshmmap_s->entries, next) {
 		shmmap_se = kmem_alloc(sizeof(struct shmmap_entry), KM_SLEEP);
 		shmmap_se->va = oshmmap_se->va;
 		shmmap_se->shmid = oshmmap_se->shmid;
 		SLIST_INSERT_HEAD(&shmmap_s->entries, shmmap_se, next);
+	}
 	shmmap_s->nitems = oshmmap_s->nitems;
 	oshmmap_s->nrefs--;
 	return shmmap_s;
+}
 /*
  * Lock/unlock the memory.
  *  => must be called with shm_lock held;
  *  => called from one place, thus, inline;
  */
 static inline int
 shm_memlock(struct lwp *l, struct shmid_ds *shmseg, int shmid, int cmd)
+{
 	struct proc *p = l->l_proc;
 	struct shmmap_entry *shmmap_se;
 	struct shmmap_state *shmmap_s;
 	size_t size;
 	int error;
 	KASSERT(mutex_owned(&shm_lock));
 	shmmap_s = shmmap_getprivate(p);
 	/* Find our shared memory address by shmid */
 	SLIST_FOREACH(shmmap_se, &shmmap_s->entries, next) {
 		if (shmmap_se->shmid != shmid)
 			continue;
 		size = (shmseg->shm_segsz + PGOFSET) & ~PGOFSET;
 		if (cmd == SHM_LOCK &&
 		    (shmseg->shm_perm.mode & SHMSEG_WIRED) == 0) {
 			/* Wire the object and map, then tag it */
 			error = uvm_obj_wirepages(shmseg->_shm_internal,
-, size);
+, size, NULL);
 			if (error)
 				return EIO;
 			error = uvm_map_pageable(&p->p_vmspace->vm_map,
 			    shmmap_se->va, shmmap_se->va + size, false, 0);
 			if (error) {
 				uvm_obj_unwirepages(shmseg->_shm_internal,
 , size);
 				if (error == EFAULT)
 					error = ENOMEM;
 				return error;
+			}
 			shmseg->shm_perm.mode |= SHMSEG_WIRED;
 		} else if (cmd == SHM_UNLOCK &&
 		    (shmseg->shm_perm.mode & SHMSEG_WIRED) != 0) {
 			/* Unwire the object and map, then untag it */
 			uvm_obj_unwirepages(shmseg->_shm_internal, 0, size);
 			error = uvm_map_pageable(&p->p_vmspace->vm_map,
 			    shmmap_se->va, shmmap_se->va + size, true, 0);
 			if (error)
 				return EIO;
 			shmseg->shm_perm.mode &= ~SHMSEG_WIRED;
+		}
+	}
 	return 0;
+}
 /*
  * Unmap shared memory.
  */
 int
 sys_shmdt(struct lwp *l, const struct sys_shmdt_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(const void *) shmaddr;
 	} */
 	struct proc *p = l->l_proc;
 	struct shmmap_state *shmmap_s1, *shmmap_s;
 	struct shmmap_entry *shmmap_se;
 	struct uvm_object *uobj;
 	struct shmid_ds *shmseg;
 	size_t size;
 	mutex_enter(&shm_lock);
 	/* In case of reallocation, we will wait for completion */
 	while (__predict_false(shm_realloc_state))
 		cv_wait(&shm_realloc_cv, &shm_lock);
 	shmmap_s1 = (struct shmmap_state *)p->p_vmspace->vm_shm;
 	if (shmmap_s1 == NULL) {
 		mutex_exit(&shm_lock);
 		return EINVAL;
+	}
 	/* Find the map entry */
 	SLIST_FOREACH(shmmap_se, &shmmap_s1->entries, next)
 		if (shmmap_se->va == (vaddr_t)SCARG(uap, shmaddr))
 			break;
 	if (shmmap_se == NULL) {
 		mutex_exit(&shm_lock);
 		return EINVAL;
+	}
 	shmmap_s = shmmap_getprivate(p);
 	if (shmmap_s != shmmap_s1) {
 		/* Map has been copied, lookup entry in new map */
 		SLIST_FOREACH(shmmap_se, &shmmap_s->entries, next)
 			if (shmmap_se->va == (vaddr_t)SCARG(uap, shmaddr))
 				break;
 		if (shmmap_se == NULL) {
 			mutex_exit(&shm_lock);
 			return EINVAL;
+		}
+	}
 	SHMPRINTF(("shmdt: vm %p: remove %d @%lx\n",
 	    p->p_vmspace, shmmap_se->shmid, shmmap_se->va));
 	/* Delete the entry from shm map */
 	uobj = shm_delete_mapping(shmmap_s, shmmap_se);
 	shmseg = &shmsegs[IPCID_TO_IX(shmmap_se->shmid)];
 	size = (shmseg->shm_segsz + PGOFSET) & ~PGOFSET;
 	mutex_exit(&shm_lock);
 	uvm_deallocate(&p->p_vmspace->vm_map, shmmap_se->va, size);
 	if (uobj != NULL) {
 		uao_detach(uobj);
+	}
 	kmem_free(shmmap_se, sizeof(struct shmmap_entry));
 	return 0;
+}
 /*
  * Map shared memory.
  */
 int
 sys_shmat(struct lwp *l, const struct sys_shmat_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(int) shmid;
 		syscallarg(const void *) shmaddr;
 		syscallarg(int) shmflg;
 	} */
 	int error, flags = 0;
 	struct proc *p = l->l_proc;
 	kauth_cred_t cred = l->l_cred;
 	struct shmid_ds *shmseg;
 	struct shmmap_state *shmmap_s;
 	struct shmmap_entry *shmmap_se;
 	struct uvm_object *uobj;
 	struct vmspace *vm;
 	vaddr_t attach_va;
 	vm_prot_t prot;
 	vsize_t size;
 	/* Allocate a new map entry and set it */
 	shmmap_se = kmem_alloc(sizeof(struct shmmap_entry), KM_SLEEP);
 	shmmap_se->shmid = SCARG(uap, shmid);
 	mutex_enter(&shm_lock);
 	/* In case of reallocation, we will wait for completion */
 	while (__predict_false(shm_realloc_state))
 		cv_wait(&shm_realloc_cv, &shm_lock);
 	shmseg = shm_find_segment_by_shmid(SCARG(uap, shmid));
 	if (shmseg == NULL) {
 		error = EINVAL;
 		goto err;
+	}
 	error = ipcperm(cred, &shmseg->shm_perm,
 	    (SCARG(uap, shmflg) & SHM_RDONLY) ? IPC_R : IPC_R|IPC_W);
 	if (error)
 		goto err;
 	vm = p->p_vmspace;
 	shmmap_s = (struct shmmap_state *)vm->vm_shm;
 	if (shmmap_s && shmmap_s->nitems >= shminfo.shmseg) {
 		error = EMFILE;
 		goto err;
+	}
 	size = (shmseg->shm_segsz + PGOFSET) & ~PGOFSET;
 	prot = VM_PROT_READ;
 	if ((SCARG(uap, shmflg) & SHM_RDONLY) == 0)
 		prot |= VM_PROT_WRITE;
 	if (SCARG(uap, shmaddr)) {
 		flags |= UVM_FLAG_FIXED;
 		if (SCARG(uap, shmflg) & SHM_RND)
 			attach_va =
 			    (vaddr_t)SCARG(uap, shmaddr) & ~(SHMLBA-1);
 		else if (((vaddr_t)SCARG(uap, shmaddr) & (SHMLBA-1)) == 0)
 			attach_va = (vaddr_t)SCARG(uap, shmaddr);
 		else {
 			error = EINVAL;
 			goto err;
+		}
 	} else {
 		/* This is just a hint to uvm_map() about where to put it. */
 		attach_va = p->p_emul->e_vm_default_addr(p,
 		    (vaddr_t)vm->vm_daddr, size);
+	}
 	/*
 	 * Create a map entry, add it to the list and increase the counters.
 	 * The lock will be dropped before the mapping, disable reallocation.
 	 */
 	shmmap_s = shmmap_getprivate(p);
 	SLIST_INSERT_HEAD(&shmmap_s->entries, shmmap_se, next);
 	shmmap_s->nitems++;
 	shmseg->shm_lpid = p->p_pid;
 	shmseg->shm_nattch++;
 	shm_realloc_disable++;
 	mutex_exit(&shm_lock);
 	/*
 	 * Add a reference to the memory object, map it to the
 	 * address space, and lock the memory, if needed.
 	 */
 	uobj = shmseg->_shm_internal;
 	uao_reference(uobj);
 	error = uvm_map(&vm->vm_map, &attach_va, size, uobj, 0, 0,
 	    UVM_MAPFLAG(prot, prot, UVM_INH_SHARE, UVM_ADV_RANDOM, flags));
 	if (error)
 		goto err_detach;
 	if (shm_use_phys || (shmseg->shm_perm.mode & SHMSEG_WIRED)) {
 		error = uvm_map_pageable(&vm->vm_map, attach_va,
 		    attach_va + size, false, 0);
 		if (error) {
 			if (error == EFAULT)
 				error = ENOMEM;
 			uvm_deallocate(&vm->vm_map, attach_va, size);
 			goto err_detach;
+		}
+	}
 	/* Set the new address, and update the time */
 	mutex_enter(&shm_lock);
 	shmmap_se->va = attach_va;
 	shmseg->shm_atime = time_second;
 	shm_realloc_disable--;
 	retval[0] = attach_va;
 	SHMPRINTF(("shmat: vm %p: add %d @%lx\n",
 	    p->p_vmspace, shmmap_se->shmid, attach_va));
 err:
 	cv_broadcast(&shm_realloc_cv);
 	mutex_exit(&shm_lock);
 	if (error && shmmap_se) {
 		kmem_free(shmmap_se, sizeof(struct shmmap_entry));
+	}
 	return error;
 err_detach:
 	uao_detach(uobj);
 	mutex_enter(&shm_lock);
 	uobj = shm_delete_mapping(shmmap_s, shmmap_se);
 	shm_realloc_disable--;
 	cv_broadcast(&shm_realloc_cv);
 	mutex_exit(&shm_lock);
 	if (uobj != NULL) {
 		uao_detach(uobj);
+	}
 	kmem_free(shmmap_se, sizeof(struct shmmap_entry));
 	return error;
+}
 /*
  * Shared memory control operations.
  */
 int
 sys___shmctl50(struct lwp *l, const struct sys___shmctl50_args *uap,
     register_t *retval)
+{
 	/* {
 		syscallarg(int) shmid;
 		syscallarg(int) cmd;
 		syscallarg(struct shmid_ds *) buf;
 	} */
 	struct shmid_ds shmbuf;
 	int cmd, error;
 	cmd = SCARG(uap, cmd);
 	if (cmd == IPC_SET) {
 		error = copyin(SCARG(uap, buf), &shmbuf, sizeof(shmbuf));
 		if (error)
 			return error;
+	}
 	error = shmctl1(l, SCARG(uap, shmid), cmd,
 	    (cmd == IPC_SET || cmd == IPC_STAT) ? &shmbuf : NULL);
 	if (error == 0 && cmd == IPC_STAT)
 		error = copyout(&shmbuf, SCARG(uap, buf), sizeof(shmbuf));
 	return error;
+}
 int
 shmctl1(struct lwp *l, int shmid, int cmd, struct shmid_ds *shmbuf)
+{
 	struct uvm_object *uobj = NULL;
 	kauth_cred_t cred = l->l_cred;
 	struct shmid_ds *shmseg;
 	int error = 0;
 	mutex_enter(&shm_lock);
 	/* In case of reallocation, we will wait for completion */
 	while (__predict_false(shm_realloc_state))
 		cv_wait(&shm_realloc_cv, &shm_lock);
 	shmseg = shm_find_segment_by_shmid(shmid);
 	if (shmseg == NULL) {
 		mutex_exit(&shm_lock);
 		return EINVAL;
+	}
 	switch (cmd) {
 	case IPC_STAT:
 		if ((error = ipcperm(cred, &shmseg->shm_perm, IPC_R)) != 0)
 			break;
 		memcpy(shmbuf, shmseg, sizeof(struct shmid_ds));
 		break;
 	case IPC_SET:
 		if ((error = ipcperm(cred, &shmseg->shm_perm, IPC_M)) != 0)
 			break;
 		shmseg->shm_perm.uid = shmbuf->shm_perm.uid;
 		shmseg->shm_perm.gid = shmbuf->shm_perm.gid;
 		shmseg->shm_perm.mode =
 		    (shmseg->shm_perm.mode & ~ACCESSPERMS) |
 		    (shmbuf->shm_perm.mode & ACCESSPERMS);
 		shmseg->shm_ctime = time_second;
 		break;
 	case IPC_RMID:
 		if ((error = ipcperm(cred, &shmseg->shm_perm, IPC_M)) != 0)
 			break;
 		shmseg->shm_perm._key = IPC_PRIVATE;
 		shmseg->shm_perm.mode |= SHMSEG_REMOVED;
 		if (shmseg->shm_nattch <= 0) {
 			uobj = shmseg->_shm_internal;
 			shm_free_segment(IPCID_TO_IX(shmid));
+		}
 		break;
 	case SHM_LOCK:
 	case SHM_UNLOCK:
 		if ((error = kauth_authorize_generic(cred,
 		    KAUTH_GENERIC_ISSUSER, NULL)) != 0)
 			break;
 		error = shm_memlock(l, shmseg, shmid, cmd);
 		break;
 	default:
 		error = EINVAL;
+	}
 	mutex_exit(&shm_lock);
 	if (uobj != NULL)
 		uao_detach(uobj);
 	return error;
+}
 /*
  * Try to take an already existing segment.
  *  => must be called with shm_lock held;
  *  => called from one place, thus, inline;
  */
 static inline int
 shmget_existing(struct lwp *l, const struct sys_shmget_args *uap, int mode,
     register_t *retval)
+{
 	struct shmid_ds *shmseg;
 	kauth_cred_t cred = l->l_cred;
 	int segnum, error;
 again:
 	KASSERT(mutex_owned(&shm_lock));
 	/* Find segment by key */
 	for (segnum = 0; segnum < shminfo.shmmni; segnum++)
 		if ((shmsegs[segnum].shm_perm.mode & SHMSEG_ALLOCATED) &&
 		    shmsegs[segnum].shm_perm._key == SCARG(uap, key))
 			break;
 	if (segnum == shminfo.shmmni) {
 		/* Not found */
 		return -1;
+	}
 	shmseg = &shmsegs[segnum];
 	if (shmseg->shm_perm.mode & SHMSEG_REMOVED) {
 		/*
 		 * This segment is in the process of being allocated.  Wait
 		 * until it's done, and look the key up again (in case the
 		 * allocation failed or it was freed).
 		 */
 		shmseg->shm_perm.mode |= SHMSEG_WANTED;
 		error = cv_wait_sig(&shm_cv[segnum], &shm_lock);
 		if (error)
 			return error;
 		goto again;
+	}
 	/*
 	 * First check the flags, to generate a useful error when a
 	 * segment already exists.
 	 */
 	if ((SCARG(uap, shmflg) & (IPC_CREAT | IPC_EXCL)) ==
 	    (IPC_CREAT | IPC_EXCL))
 		return EEXIST;
 	/* Check the permission and segment size. */
 	error = ipcperm(cred, &shmseg->shm_perm, mode);
 	if (error)
 		return error;
 	if (SCARG(uap, size) && SCARG(uap, size) > shmseg->shm_segsz)
 		return EINVAL;
 	*retval = IXSEQ_TO_IPCID(segnum, shmseg->shm_perm);
 	return 0;
+}
 int
 sys_shmget(struct lwp *l, const struct sys_shmget_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(key_t) key;
 		syscallarg(size_t) size;
 		syscallarg(int) shmflg;
 	} */
 	struct shmid_ds *shmseg;
 	kauth_cred_t cred = l->l_cred;
 	key_t key = SCARG(uap, key);
 	size_t size;
 	int error, mode, segnum;
 	bool lockmem;
 	mode = SCARG(uap, shmflg) & ACCESSPERMS;
 	if (SCARG(uap, shmflg) & _SHM_RMLINGER)
 		mode |= SHMSEG_RMLINGER;
 	SHMPRINTF(("shmget: key 0x%lx size 0x%zx shmflg 0x%x mode 0x%x\n",
 	    SCARG(uap, key), SCARG(uap, size), SCARG(uap, shmflg), mode));
 	mutex_enter(&shm_lock);
 	/* In case of reallocation, we will wait for completion */
 	while (__predict_false(shm_realloc_state))
 		cv_wait(&shm_realloc_cv, &shm_lock);
 	if (key != IPC_PRIVATE) {
 		error = shmget_existing(l, uap, mode, retval);
 		if (error != -1) {
 			mutex_exit(&shm_lock);
 			return error;
+		}
 		if ((SCARG(uap, shmflg) & IPC_CREAT) == 0) {
 			mutex_exit(&shm_lock);
 			return ENOENT;
+		}
+	}
 	error = 0;
 	/*
 	 * Check the for the limits.
 	 */
 	size = SCARG(uap, size);
 	if (size < shminfo.shmmin || size > shminfo.shmmax) {
 		mutex_exit(&shm_lock);
 		return EINVAL;
+	}
 	if (shm_nused >= shminfo.shmmni) {
 		mutex_exit(&shm_lock);
 		return ENOSPC;
+	}
 	size = (size + PGOFSET) & ~PGOFSET;
 	if (shm_committed + btoc(size) > shminfo.shmall) {
 		mutex_exit(&shm_lock);
 		return ENOMEM;
+	}
 	/* Find the first available segment */
 	if (shm_last_free < 0) {
 		for (segnum = 0; segnum < shminfo.shmmni; segnum++)
 			if (shmsegs[segnum].shm_perm.mode & SHMSEG_FREE)
 				break;
 		KASSERT(segnum < shminfo.shmmni);
 	} else {
 		segnum = shm_last_free;
 		shm_last_free = -1;
+	}
 	/*
 	 * Initialize the segment.
 	 * We will drop the lock while allocating the memory, thus mark the
 	 * segment present, but removed, that no other thread could take it.
 	 * Also, disable reallocation, while lock is dropped.
 	 */
 	shmseg = &shmsegs[segnum];
 	shmseg->shm_perm.mode = SHMSEG_ALLOCATED | SHMSEG_REMOVED;
 	shm_committed += btoc(size);
 	shm_nused++;
 	lockmem = shm_use_phys;
 	shm_realloc_disable++;
 	mutex_exit(&shm_lock);
 	/* Allocate the memory object and lock it if needed */
 	shmseg->_shm_internal = uao_create(size, 0);
 	if (lockmem) {
 		/* Wire the pages and tag it */
-		error = uvm_obj_wirepages(shmseg->_shm_internal, 0, size);
+		error = uvm_obj_wirepages(shmseg->_shm_internal, 0, size, NULL);
 		if (error) {
 			uao_detach(shmseg->_shm_internal);
 			mutex_enter(&shm_lock);
 			shm_free_segment(segnum);
 			shm_realloc_disable--;
 			mutex_exit(&shm_lock);
 			return error;
+		}
+	}
 	/*
 	 * Please note, while segment is marked, there are no need to hold the
 	 * lock, while setting it (except shm_perm.mode).
 	 */
 	shmseg->shm_perm._key = SCARG(uap, key);
 	shmseg->shm_perm._seq = (shmseg->shm_perm._seq + 1) & 0x7fff;
 	*retval = IXSEQ_TO_IPCID(segnum, shmseg->shm_perm);
 	shmseg->shm_perm.cuid = shmseg->shm_perm.uid = kauth_cred_geteuid(cred);
 	shmseg->shm_perm.cgid = shmseg->shm_perm.gid = kauth_cred_getegid(cred);
 	shmseg->shm_segsz = SCARG(uap, size);
 	shmseg->shm_cpid = l->l_proc->p_pid;
 	shmseg->shm_lpid = shmseg->shm_nattch = 0;
 	shmseg->shm_atime = shmseg->shm_dtime = 0;
 	shmseg->shm_ctime = time_second;
 	/*
 	 * Segment is initialized.
 	 * Enter the lock, mark as allocated, and notify waiters (if any).
 	 * Also, unmark the state of reallocation.
 	 */
 	mutex_enter(&shm_lock);
 	shmseg->shm_perm.mode = (shmseg->shm_perm.mode & SHMSEG_WANTED) |
 	    (mode & (ACCESSPERMS | SHMSEG_RMLINGER)) |
 	    SHMSEG_ALLOCATED | (lockmem ? SHMSEG_WIRED : 0);
 	if (shmseg->shm_perm.mode & SHMSEG_WANTED) {
 		shmseg->shm_perm.mode &= ~SHMSEG_WANTED;
 		cv_broadcast(&shm_cv[segnum]);
+	}
 	shm_realloc_disable--;
 	cv_broadcast(&shm_realloc_cv);
 	mutex_exit(&shm_lock);
 	return error;
+}
 void
 shmfork(struct vmspace *vm1, struct vmspace *vm2)
+{
 	struct shmmap_state *shmmap_s;
 	struct shmmap_entry *shmmap_se;
 	SHMPRINTF(("shmfork %p->%p\n", vm1, vm2));
 	mutex_enter(&shm_lock);
 	vm2->vm_shm = vm1->vm_shm;
 	if (vm1->vm_shm) {
 		shmmap_s = (struct shmmap_state *)vm1->vm_shm;
 		SLIST_FOREACH(shmmap_se, &shmmap_s->entries, next)
 			shmsegs[IPCID_TO_IX(shmmap_se->shmid)].shm_nattch++;
 		shmmap_s->nrefs++;
+	}
 	mutex_exit(&shm_lock);
+}
 void
 shmexit(struct vmspace *vm)
+{
 	struct shmmap_state *shmmap_s;
 	struct shmmap_entry *shmmap_se;
 	mutex_enter(&shm_lock);
 	shmmap_s = (struct shmmap_state *)vm->vm_shm;
 	if (shmmap_s == NULL) {
 		mutex_exit(&shm_lock);
 		return;
+	}
 	vm->vm_shm = NULL;
 	if (--shmmap_s->nrefs > 0) {
 		SHMPRINTF(("shmexit: vm %p drop ref (%d entries), refs = %d\n",
 		    vm, shmmap_s->nitems, shmmap_s->nrefs));
 		SLIST_FOREACH(shmmap_se, &shmmap_s->entries, next) {
 			shmsegs[IPCID_TO_IX(shmmap_se->shmid)].shm_nattch--;
+		}
 		mutex_exit(&shm_lock);
 		return;
+	}
 	SHMPRINTF(("shmexit: vm %p cleanup (%d entries)\n", vm, shmmap_s->nitems));
 	if (shmmap_s->nitems == 0) {
 		mutex_exit(&shm_lock);
 		kmem_free(shmmap_s, sizeof(struct shmmap_state));
 		return;
+	}
 	/*
 	 * Delete the entry from shm map.
 	 */
 	for (;;) {
 		struct shmid_ds *shmseg;
 		struct uvm_object *uobj;
 		size_t sz;
 		shmmap_se = SLIST_FIRST(&shmmap_s->entries);
 		KASSERT(shmmap_se != NULL);
 		shmseg = &shmsegs[IPCID_TO_IX(shmmap_se->shmid)];
 		sz = (shmseg->shm_segsz + PGOFSET) & ~PGOFSET;
 		/* shm_delete_mapping() removes from the list. */
 		uobj = shm_delete_mapping(shmmap_s, shmmap_se);
 		mutex_exit(&shm_lock);
 		uvm_deallocate(&vm->vm_map, shmmap_se->va, sz);
 		if (uobj != NULL) {
 			uao_detach(uobj);
+		}
 		kmem_free(shmmap_se, sizeof(struct shmmap_entry));
 		if (SLIST_EMPTY(&shmmap_s->entries)) {
 			break;
+		}
 		mutex_enter(&shm_lock);
 		KASSERT(!SLIST_EMPTY(&shmmap_s->entries));
+	}
 	kmem_free(shmmap_s, sizeof(struct shmmap_state));
+}
 static int
 shmrealloc(int newshmni)
+{
 	vaddr_t v;
 	struct shmid_ds *oldshmsegs, *newshmsegs;
 	kcondvar_t *newshm_cv, *oldshm_cv;
 	size_t sz;
 	int i, lsegid, oldshmni;
 	if (newshmni < 1)
 		return EINVAL;
 	/* Allocate new memory area */
 	sz = ALIGN(newshmni * sizeof(struct shmid_ds)) +
 	    ALIGN(newshmni * sizeof(kcondvar_t));
 	sz = round_page(sz);
 	v = uvm_km_alloc(kernel_map, sz, 0, UVM_KMF_WIRED|UVM_KMF_ZERO);
 	if (v == 0)
 		return ENOMEM;
 	mutex_enter(&shm_lock);
 	while (shm_realloc_state || shm_realloc_disable)
 		cv_wait(&shm_realloc_cv, &shm_lock);
 	/*
 	 * Get the number of last segment.  Fail we are trying to
 	 * reallocate less memory than we use.
 	 */
 	lsegid = 0;
 	for (i = 0; i < shminfo.shmmni; i++)
 		if ((shmsegs[i].shm_perm.mode & SHMSEG_FREE) == 0)
 			lsegid = i;
 	if (lsegid >= newshmni) {
 		mutex_exit(&shm_lock);
 		uvm_km_free(kernel_map, v, sz, UVM_KMF_WIRED);
 		return EBUSY;
+	}
 	shm_realloc_state = true;
 	newshmsegs = (void *)v;
 	newshm_cv = (void *)((uintptr_t)newshmsegs +
 	    ALIGN(newshmni * sizeof(struct shmid_ds)));
 	/* Copy all memory to the new area */
 	for (i = 0; i < shm_nused; i++)
 		(void)memcpy(&newshmsegs[i], &shmsegs[i],
 		    sizeof(newshmsegs[0]));
 	/* Mark as free all new segments, if there is any */
 	for (; i < newshmni; i++) {
 		cv_init(&newshm_cv[i], "shmwait");
 		newshmsegs[i].shm_perm.mode = SHMSEG_FREE;
 		newshmsegs[i].shm_perm._seq = 0;
+	}
 	oldshmsegs = shmsegs;
 	oldshmni = shminfo.shmmni;
 	shminfo.shmmni = newshmni;
 	shmsegs = newshmsegs;
 	shm_cv = newshm_cv;
 	/* Reallocation completed - notify all waiters, if any */
 	shm_realloc_state = false;
 	cv_broadcast(&shm_realloc_cv);
 	mutex_exit(&shm_lock);
 	/* Release now unused resources. */
 	oldshm_cv = (void *)((uintptr_t)oldshmsegs +
 	    ALIGN(oldshmni * sizeof(struct shmid_ds)));
 	for (i = 0; i < oldshmni; i++)
 		cv_destroy(&oldshm_cv[i]);
 	sz = ALIGN(oldshmni * sizeof(struct shmid_ds)) +
 	    ALIGN(oldshmni * sizeof(kcondvar_t));
 	sz = round_page(sz);
 	uvm_km_free(kernel_map, (vaddr_t)oldshmsegs, sz, UVM_KMF_WIRED);
 	return 0;
+}
 void
 shminit(void)
+{
 	vaddr_t v;
 	size_t sz;
 	int i;
 	mutex_init(&shm_lock, MUTEX_DEFAULT, IPL_NONE);
 	cv_init(&shm_realloc_cv, "shmrealc");
 	/* Allocate the wired memory for our structures */
 	sz = ALIGN(shminfo.shmmni * sizeof(struct shmid_ds)) +
 	    ALIGN(shminfo.shmmni * sizeof(kcondvar_t));
 	sz = round_page(sz);
 	v = uvm_km_alloc(kernel_map, sz, 0, UVM_KMF_WIRED|UVM_KMF_ZERO);
 	if (v == 0)
 		panic("sysv_shm: cannot allocate memory");
 	shmsegs = (void *)v;
 	shm_cv = (void *)((uintptr_t)shmsegs +
 	    ALIGN(shminfo.shmmni * sizeof(struct shmid_ds)));
 	if (shminfo.shmmax == 0)
 		shminfo.shmmax = max(physmem / 4, 1024) * PAGE_SIZE;
 	else
 		shminfo.shmmax *= PAGE_SIZE;
 	shminfo.shmall = shminfo.shmmax / PAGE_SIZE;
 	for (i = 0; i < shminfo.shmmni; i++) {
 		cv_init(&shm_cv[i], "shmwait");
 		shmsegs[i].shm_perm.mode = SHMSEG_FREE;
 		shmsegs[i].shm_perm._seq = 0;
+	}
 	shm_last_free = 0;
 	shm_nused = 0;
 	shm_committed = 0;
 	shm_realloc_disable = 0;
 	shm_realloc_state = false;
+}
 static int
 sysctl_ipc_shmmni(SYSCTLFN_ARGS)
+{
 	int newsize, error;
 	struct sysctlnode node;
 	node = *rnode;
 	node.sysctl_data = &newsize;
 	newsize = shminfo.shmmni;
 	error = sysctl_lookup(SYSCTLFN_CALL(&node));
 	if (error || newp == NULL)
 		return error;
 	sysctl_unlock();
 	error = shmrealloc(newsize);
 	sysctl_relock();
 	return error;
+}
 static int
 sysctl_ipc_shmmaxpgs(SYSCTLFN_ARGS)
+{
 	uint32_t newsize;
 	int error;
 	struct sysctlnode node;
 	node = *rnode;
 	node.sysctl_data = &newsize;
 	newsize = shminfo.shmall;
 	error = sysctl_lookup(SYSCTLFN_CALL(&node));
 	if (error || newp == NULL)
 		return error;
 	if (newsize < 1)
 		return EINVAL;
 	shminfo.shmall = newsize;
 	shminfo.shmmax = (uint64_t)shminfo.shmall * PAGE_SIZE;
 	return 0;
+}
 static int
 sysctl_ipc_shmmax(SYSCTLFN_ARGS)
+{
 	uint64_t newsize;
 	int error;
 	struct sysctlnode node;
 	node = *rnode;
 	node.sysctl_data = &newsize;
 	newsize = shminfo.shmmax;
 	error = sysctl_lookup(SYSCTLFN_CALL(&node));
 	if (error || newp == NULL)
 		return error;
 	if (newsize < PAGE_SIZE)
 		return EINVAL;
 	shminfo.shmmax = round_page(newsize);
 	shminfo.shmall = shminfo.shmmax >> PAGE_SHIFT;
 	return 0;
+}
 SYSCTL_SETUP(sysctl_ipc_shm_setup, "sysctl kern.ipc subtree setup")
+{
 	sysctl_createv(clog, 0, NULL, NULL,
 		CTLFLAG_PERMANENT,
 		CTLTYPE_NODE, "kern", NULL,
 		NULL, 0, NULL, 0,
 		CTL_KERN, CTL_EOL);
 	sysctl_createv(clog, 0, NULL, NULL,
 		CTLFLAG_PERMANENT,
 		CTLTYPE_NODE, "ipc",
 		SYSCTL_DESCR("SysV IPC options"),
 		NULL, 0, NULL, 0,
 		CTL_KERN, KERN_SYSVIPC, CTL_EOL);
 	sysctl_createv(clog, 0, NULL, NULL,
 		CTLFLAG_PERMANENT | CTLFLAG_READWRITE,
 		CTLTYPE_QUAD, "shmmax",
 		SYSCTL_DESCR("Max shared memory segment size in bytes"),
 		sysctl_ipc_shmmax, 0, &shminfo.shmmax, 0,
 		CTL_KERN, KERN_SYSVIPC, KERN_SYSVIPC_SHMMAX, CTL_EOL);
 	sysctl_createv(clog, 0, NULL, NULL,
 		CTLFLAG_PERMANENT | CTLFLAG_READWRITE,
 		CTLTYPE_INT, "shmmni",
 		SYSCTL_DESCR("Max number of shared memory identifiers"),
 		sysctl_ipc_shmmni, 0, &shminfo.shmmni, 0,
 		CTL_KERN, KERN_SYSVIPC, KERN_SYSVIPC_SHMMNI, CTL_EOL);
 	sysctl_createv(clog, 0, NULL, NULL,
 		CTLFLAG_PERMANENT | CTLFLAG_READWRITE,
 		CTLTYPE_INT, "shmseg",
 		SYSCTL_DESCR("Max shared memory segments per process"),
 		NULL, 0, &shminfo.shmseg, 0,
 		CTL_KERN, KERN_SYSVIPC, KERN_SYSVIPC_SHMSEG, CTL_EOL);
 	sysctl_createv(clog, 0, NULL, NULL,
 		CTLFLAG_PERMANENT | CTLFLAG_READWRITE,
 		CTLTYPE_INT, "shmmaxpgs",
 		SYSCTL_DESCR("Max amount of shared memory in pages"),
 		sysctl_ipc_shmmaxpgs, 0, &shminfo.shmall, 0,
 		CTL_KERN, KERN_SYSVIPC, KERN_SYSVIPC_SHMMAXPGS, CTL_EOL);
 	sysctl_createv(clog, 0, NULL, NULL,
 		CTLFLAG_PERMANENT | CTLFLAG_READWRITE,
 		CTLTYPE_INT, "shm_use_phys",
 		SYSCTL_DESCR("Enable/disable locking of shared memory in "
 		    "physical memory"), NULL, 0, &shm_use_phys, 0,
 		CTL_KERN, KERN_SYSVIPC, KERN_SYSVIPC_SHMUSEPHYS, CTL_EOL);
+}

 @@ -1,771 +1,772 @@
-/*	$NetBSD: uvm_extern.h,v 1.174 2011/06/16 09:21:03 hannken Exp $	*/
+/*	$NetBSD: uvm_extern.h,v 1.175 2011/08/27 09:11:53 christos Exp $	*/
 /*
  * Copyright (c) 1997 Charles D. Cranor and Washington University.
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
  * from: Id: uvm_extern.h,v 1.1.2.21 1998/02/07 01:16:53 chs Exp
  */
 /*-
  * Copyright (c) 1991, 1992, 1993
  *	The Regents of the University of California.  All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
+ *
  *	@(#)vm_extern.h	8.5 (Berkeley) 5/3/95
  */
 #ifndef _UVM_UVM_EXTERN_H_
 #define _UVM_UVM_EXTERN_H_
 /*
  * uvm_extern.h: this file defines the external interface to the VM system.
+ *
  * this should be the only file included by non-VM parts of the kernel
  * which need access to VM services.   if you want to know the interface
  * to the MI VM layer without knowing the details, this is the file to
  * learn.
+ *
  * NOTE: vm system calls are prototyped in syscallargs.h
  */
 /*
  * typedefs, necessary for standard UVM headers.
  */
 typedef unsigned int uvm_flag_t;
 typedef int vm_inherit_t;	/* XXX: inheritance codes */
 typedef off_t voff_t;		/* XXX: offset within a uvm_object */
 typedef voff_t pgoff_t;		/* XXX: number of pages within a uvm object */
 /*
  * defines
  */
 /*
  * the following defines are for uvm_map and functions which call it.
  */
 /* protections bits */
 #define UVM_PROT_MASK	0x07	/* protection mask */
 #define UVM_PROT_NONE	0x00	/* protection none */
 #define UVM_PROT_ALL	0x07	/* everything */
 #define UVM_PROT_READ	0x01	/* read */
 #define UVM_PROT_WRITE  0x02	/* write */
 #define UVM_PROT_EXEC	0x04	/* exec */
 /* protection short codes */
 #define UVM_PROT_R	0x01	/* read */
 #define UVM_PROT_W	0x02	/* write */
 #define UVM_PROT_RW	0x03    /* read-write */
 #define UVM_PROT_X	0x04	/* exec */
 #define UVM_PROT_RX	0x05	/* read-exec */
 #define UVM_PROT_WX	0x06	/* write-exec */
 #define UVM_PROT_RWX	0x07	/* read-write-exec */
 /* 0x08: not used */
 /* inherit codes */
 #define UVM_INH_MASK	0x30	/* inherit mask */
 #define UVM_INH_SHARE	0x00	/* "share" */
 #define UVM_INH_COPY	0x10	/* "copy" */
 #define UVM_INH_NONE	0x20	/* "none" */
 #define UVM_INH_DONATE	0x30	/* "donate" << not used */
 /* 0x40, 0x80: not used */
 /* bits 0x700: max protection, 0x800: not used */
 /* bits 0x7000: advice, 0x8000: not used */
 /* advice: matches MADV_* from sys/mman.h and POSIX_FADV_* from sys/fcntl.h */
 #define UVM_ADV_NORMAL	0x0	/* 'normal' */
 #define UVM_ADV_RANDOM	0x1	/* 'random' */
 #define UVM_ADV_SEQUENTIAL 0x2	/* 'sequential' */
 #define UVM_ADV_WILLNEED 0x3	/* pages will be needed */
 #define UVM_ADV_DONTNEED 0x4	/* pages won't be needed */
 #define UVM_ADV_NOREUSE	0x5	/* pages will be used only once */
 #define UVM_ADV_MASK	0x7	/* mask */
 /* bits 0xffff0000: mapping flags */
 #define UVM_FLAG_FIXED   0x010000 /* find space */
 #define UVM_FLAG_OVERLAY 0x020000 /* establish overlay */
 #define UVM_FLAG_NOMERGE 0x040000 /* don't merge map entries */
 #define UVM_FLAG_COPYONW 0x080000 /* set copy_on_write flag */
 #define UVM_FLAG_AMAPPAD 0x100000 /* for bss: pad amap to reduce allocations */
 #define UVM_FLAG_TRYLOCK 0x200000 /* fail if we can not lock map */
 #define UVM_FLAG_NOWAIT  0x400000 /* not allowed to sleep */
 #define UVM_FLAG_QUANTUM 0x800000 /* entry can never be split later */
 #define UVM_FLAG_WAITVA  0x1000000 /* wait for va */
 #define UVM_FLAG_VAONLY  0x2000000 /* unmap: no pages are mapped */
 #define UVM_FLAG_COLORMATCH 0x4000000 /* match color given in off */
 /* macros to extract info */
 #define UVM_PROTECTION(X)	((X) & UVM_PROT_MASK)
 #define UVM_INHERIT(X)		(((X) & UVM_INH_MASK) >> 4)
 #define UVM_MAXPROTECTION(X)	(((X) >> 8) & UVM_PROT_MASK)
 #define UVM_ADVICE(X)		(((X) >> 12) & UVM_ADV_MASK)
 #define UVM_MAPFLAG(PROT,MAXPROT,INH,ADVICE,FLAGS) \
 	(((MAXPROT) << 8)|(PROT)|(INH)|((ADVICE) << 12)|(FLAGS))
 /* magic offset value: offset not known(obj) or don't care(!obj) */
 #define UVM_UNKNOWN_OFFSET ((voff_t) -1)
 /*
  * the following defines are for uvm_km_alloc/free's flags
  */
 #define UVM_KMF_WIRED	0x1			/* allocation type: wired */
 #define UVM_KMF_PAGEABLE 0x2			/* allocation type: pageable */
 #define UVM_KMF_VAONLY	0x4			/* allocation type: VA only */
 #define	UVM_KMF_TYPEMASK (UVM_KMF_VAONLY | UVM_KMF_PAGEABLE | UVM_KMF_WIRED)
 #define UVM_KMF_CANFAIL	0x8			/* caller handles failure */
 #define UVM_KMF_ZERO	0x10			/* want zero filled memory */
 #define UVM_KMF_EXEC	0x20			/* need executable mapping */
 #define UVM_KMF_TRYLOCK	UVM_FLAG_TRYLOCK	/* try locking only */
 #define UVM_KMF_NOWAIT	UVM_FLAG_NOWAIT		/* not allowed to sleep */
 #define UVM_KMF_WAITVA	UVM_FLAG_WAITVA		/* sleep for va */
 /*
  * the following defines the strategies for uvm_pagealloc_strat()
  */
 #define	UVM_PGA_STRAT_NORMAL	0	/* priority (low id to high) walk */
 #define	UVM_PGA_STRAT_ONLY	1	/* only specified free list */
 #define	UVM_PGA_STRAT_FALLBACK	2	/* ONLY falls back on NORMAL */
 /*
  * flags for uvm_pagealloc_strat()
  */
 #define UVM_PGA_USERESERVE	0x0001	/* ok to use reserve pages */
 #define	UVM_PGA_ZERO		0x0002	/* returned page must be zero'd */
 /*
  * flags for ubc_alloc()
  */
 #define UBC_READ	0x001
 #define UBC_WRITE	0x002
 #define UBC_FAULTBUSY	0x004
 /*
  * flags for ubc_release()
  */
 #define UBC_UNMAP	0x010
 /*
  * flags for ubc_uiomve()
  */
 #define	UBC_PARTIALOK	0x100
 /*
  * flags for uvn_findpages().
  */
 #define UFP_ALL		0x00
 #define UFP_NOWAIT	0x01
 #define UFP_NOALLOC	0x02
 #define UFP_NOCACHE	0x04
 #define UFP_NORDONLY	0x08
 #define UFP_DIRTYONLY	0x10
 #define UFP_BACKWARD	0x20
 /*
  * lockflags that control the locking behavior of various functions.
  */
 #define	UVM_LK_ENTER	0x00000001	/* map locked on entry */
 #define	UVM_LK_EXIT	0x00000002	/* leave map locked on exit */
 /*
  * Default number of pages to allocate on the stack
  */
 #define	UBC_MAX_PAGES	8
 /*
  * Value representing inactive emap.
  */
 #define	UVM_EMAP_INACTIVE	(0)
 /*
  * structures
  */
 struct buf;
 struct core;
 struct loadavg;
 struct mount;
 struct pglist;
 struct proc;
 struct uio;
 struct uvm_object;
 struct vm_anon;
 struct vmspace;
 struct pmap;
 struct vnode;
 struct simplelock;
 struct vm_map_entry;
 struct vm_map;
 struct vm_page;
 struct vmtotal;
 /*
  * uvm_pctparam: parameter to be shown as percentage to user.
  */
 #define	UVM_PCTPARAM_SHIFT	8
 #define	UVM_PCTPARAM_SCALE	(1 << UVM_PCTPARAM_SHIFT)
 #define	UVM_PCTPARAM_APPLY(pct, x) \
 	(((x) * (pct)->pct_scaled) >> UVM_PCTPARAM_SHIFT)
 struct uvm_pctparam {
 	int pct_pct;	/* percent [0, 100] */ /* should be the first member */
 	int pct_scaled;
 	int (*pct_check)(struct uvm_pctparam *, int);
 };
 /*
  * uvmexp: global data structures that are exported to parts of the kernel
  * other than the vm system.
  */
 struct uvmexp {
 	/* vm_page constants */
 	int pagesize;   /* size of a page (PAGE_SIZE): must be power of 2 */
 	int pagemask;   /* page mask */
 	int pageshift;  /* page shift */
 	/* vm_page counters */
 	int npages;     /* number of pages we manage */
 	int free;       /* number of free pages */
 	int paging;	/* number of pages in the process of being paged out */
 	int wired;      /* number of wired pages */
 	/*
 	 * Adding anything before this line will break binary compatibility
 	 * with top(1) on NetBSD 1.5.
 	 */
 	int ncolors;	/* number of page color buckets: must be p-o-2 */
 	int colormask;	/* color bucket mask */
 	int zeropages;		/* number of zero'd pages */
 	int reserve_pagedaemon; /* number of pages reserved for pagedaemon */
 	int reserve_kernel;	/* number of pages reserved for kernel */
 	unsigned anonpages;	/* number of pages used by anon mappings */
 	unsigned filepages;	/* number of pages used by cached file data */
 	unsigned execpages;	/* number of pages used by cached exec data */
 	/* pageout params */
 	int freemin;    /* min number of free pages */
 	int freetarg;   /* target number of free pages */
 	int wiredmax;   /* max number of wired pages */
 	/* swap */
 	int nswapdev;	/* number of configured swap devices in system */
 	int swpages;	/* number of PAGE_SIZE'ed swap pages */
 	int swpgavail;	/* number of swap pages currently available */
 	int swpginuse;	/* number of swap pages in use */
 	int swpgonly;	/* number of swap pages in use, not also in RAM */
 	int nswget;	/* number of times fault calls uvm_swap_get() */
 	/* stat counters.  XXX: should be 64-bit counters */
 	int _unused_faults;	/* page fault count */
 	int _unused_traps;	/* trap count */
 	int _unused_intrs;	/* interrupt count */
 	int _unused_swtch;	/* context switch count */
 	int _unused_softs;	/* software interrupt count */
 	int _unused_syscalls;	/* system calls */
 	int pageins;		/* pagein operation count */
 				/* pageouts are in pdpageouts below */
 	int _unused1;
 	int _unused2;
 	int pgswapin;		/* pages swapped in */
 	int pgswapout;		/* pages swapped out */
 	int forks;  		/* forks */
 	int forks_ppwait;	/* forks where parent waits */
 	int forks_sharevm;	/* forks where vmspace is shared */
 	int pga_zerohit;	/* pagealloc where zero wanted and zero
 				   was available */
 	int pga_zeromiss;	/* pagealloc where zero wanted and zero
 				   not available */
 	int zeroaborts;		/* number of times page zeroing was
 				   aborted */
 	int colorhit;		/* pagealloc where we got optimal color */
 	int colormiss;		/* pagealloc where we didn't */
 	int cpuhit;		/* pagealloc where we allocated locally */
 	int cpumiss;		/* pagealloc where we didn't */
 	/* fault subcounters.  XXX: should be 64-bit counters */
 	int fltnoram;	/* number of times fault was out of ram */
 	int fltnoanon;	/* number of times fault was out of anons */
 	int fltpgwait;	/* number of times fault had to wait on a page */
 	int fltpgrele;	/* number of times fault found a released page */
 	int fltrelck;	/* number of times fault relock called */
 	int fltrelckok;	/* number of times fault relock is a success */
 	int fltanget;	/* number of times fault gets anon page */
 	int fltanretry;	/* number of times fault retrys an anon get */
 	int fltamcopy;	/* number of times fault clears "needs copy" */
 	int fltnamap;	/* number of times fault maps a neighbor anon page */
 	int fltnomap;	/* number of times fault maps a neighbor obj page */
 	int fltlget;	/* number of times fault does a locked pgo_get */
 	int fltget;	/* number of times fault does an unlocked get */
 	int flt_anon;	/* number of times fault anon (case 1a) */
 	int flt_acow;	/* number of times fault anon cow (case 1b) */
 	int flt_obj;	/* number of times fault is on object page (2a) */
 	int flt_prcopy;	/* number of times fault promotes with copy (2b) */
 	int flt_przero;	/* number of times fault promotes with zerofill (2b) */
 	/* daemon counters.  XXX: should be 64-bit counters */
 	int pdwoke;	/* number of times daemon woke up */
 	int pdrevs;	/* number of times daemon rev'd clock hand */
 	int _unused3;
 	int pdfreed;	/* number of pages daemon freed since boot */
 	int pdscans;	/* number of pages daemon scanned since boot */
 	int pdanscan;	/* number of anonymous pages scanned by daemon */
 	int pdobscan;	/* number of object pages scanned by daemon */
 	int pdreact;	/* number of pages daemon reactivated since boot */
 	int pdbusy;	/* number of times daemon found a busy page */
 	int pdpageouts;	/* number of times daemon started a pageout */
 	int pdpending;	/* number of times daemon got a pending pagout */
 	int pddeact;	/* number of pages daemon deactivates */
 	int pdreanon;	/* anon pages reactivated due to thresholds */
 	int pdrefile;	/* file pages reactivated due to thresholds */
 	int pdreexec;	/* executable pages reactivated due to thresholds */
 };
 /*
  * The following structure is 64-bit alignment safe.  New elements
  * should only be added to the end of this structure so binary
  * compatibility can be preserved.
  */
 struct uvmexp_sysctl {
 	int64_t	pagesize;
 	int64_t	pagemask;
 	int64_t	pageshift;
 	int64_t	npages;
 	int64_t	free;
 	int64_t	active;
 	int64_t	inactive;
 	int64_t	paging;
 	int64_t	wired;
 	int64_t	zeropages;
 	int64_t	reserve_pagedaemon;
 	int64_t	reserve_kernel;
 	int64_t	freemin;
 	int64_t	freetarg;
 	int64_t	inactarg;		/* unused */
 	int64_t	wiredmax;
 	int64_t	nswapdev;
 	int64_t	swpages;
 	int64_t	swpginuse;
 	int64_t	swpgonly;
 	int64_t	nswget;
 	int64_t	unused1;		/* unused; was nanon */
 	int64_t cpuhit;
 	int64_t cpumiss;
 	int64_t	faults;
 	int64_t	traps;
 	int64_t	intrs;
 	int64_t	swtch;
 	int64_t	softs;
 	int64_t	syscalls;
 	int64_t	pageins;
 	int64_t	swapins;		/* unused */
 	int64_t	swapouts;		/* unused */
 	int64_t	pgswapin;
 	int64_t	pgswapout;
 	int64_t	forks;
 	int64_t	forks_ppwait;
 	int64_t	forks_sharevm;
 	int64_t	pga_zerohit;
 	int64_t	pga_zeromiss;
 	int64_t	zeroaborts;
 	int64_t	fltnoram;
 	int64_t	fltnoanon;
 	int64_t	fltpgwait;
 	int64_t	fltpgrele;
 	int64_t	fltrelck;
 	int64_t	fltrelckok;
 	int64_t	fltanget;
 	int64_t	fltanretry;
 	int64_t	fltamcopy;
 	int64_t	fltnamap;
 	int64_t	fltnomap;
 	int64_t	fltlget;
 	int64_t	fltget;
 	int64_t	flt_anon;
 	int64_t	flt_acow;
 	int64_t	flt_obj;
 	int64_t	flt_prcopy;
 	int64_t	flt_przero;
 	int64_t	pdwoke;
 	int64_t	pdrevs;
 	int64_t	unused4;
 	int64_t	pdfreed;
 	int64_t	pdscans;
 	int64_t	pdanscan;
 	int64_t	pdobscan;
 	int64_t	pdreact;
 	int64_t	pdbusy;
 	int64_t	pdpageouts;
 	int64_t	pdpending;
 	int64_t	pddeact;
 	int64_t	anonpages;
 	int64_t	filepages;
 	int64_t	execpages;
 	int64_t colorhit;
 	int64_t colormiss;
 	int64_t ncolors;
 };
 #ifdef _KERNEL
 /* we need this before including uvm_page.h on some platforms */
 extern struct uvmexp uvmexp;
 /* MD code needs this without including <uvm/uvm.h> */
 extern bool vm_page_zero_enable;
 #endif
 /*
  * Finally, bring in standard UVM headers.
  */
 #include <sys/vmmeter.h>
 #include <sys/queue.h>
 #include <sys/lock.h>
 #include <uvm/uvm_param.h>
 #include <uvm/uvm_prot.h>
 #include <uvm/uvm_pmap.h>
 #include <uvm/uvm_map.h>
 #include <uvm/uvm_pager.h>
 /*
  * helpers for calling ubc_release()
  */
 #ifdef PMAP_CACHE_VIVT
 #define UBC_WANT_UNMAP(vp) (((vp)->v_iflag & VI_TEXT) != 0)
 #else
 #define UBC_WANT_UNMAP(vp) false
 #endif
 #define UBC_UNMAP_FLAG(vp) (UBC_WANT_UNMAP(vp) ? UBC_UNMAP : 0)
 /*
  * Shareable process virtual address space.
  * May eventually be merged with vm_map.
  * Several fields are temporary (text, data stuff).
  */
 struct vmspace {
 	struct	vm_map vm_map;	/* VM address map */
 	int	vm_refcnt;	/* number of references *
 				 * note: protected by vm_map.ref_lock */
 	void *	vm_shm;		/* SYS5 shared memory private data XXX */
 /* we copy from vm_startcopy to the end of the structure on fork */
 #define vm_startcopy vm_rssize
 	segsz_t vm_rssize;	/* current resident set size in pages */
 	segsz_t vm_swrss;	/* resident set size before last swap */
 	segsz_t vm_tsize;	/* text size (pages) XXX */
 	segsz_t vm_dsize;	/* data size (pages) XXX */
 	segsz_t vm_ssize;	/* stack size (pages) */
 	segsz_t vm_issize;	/* initial unmapped stack size (pages) */
 	void *	vm_taddr;	/* user virtual address of text XXX */
 	void *	vm_daddr;	/* user virtual address of data XXX */
 	void *vm_maxsaddr;	/* user VA at max stack growth */
 	void *vm_minsaddr;	/* user VA at top of stack */
 	size_t vm_aslr_delta_mmap;	/* mmap() random delta for ASLR */
 };
 #define	VMSPACE_IS_KERNEL_P(vm)	VM_MAP_IS_KERNEL(&(vm)->vm_map)
 #ifdef _KERNEL
 /*
  * used to keep state while iterating over the map for a core dump.
  */
 struct uvm_coredump_state {
 	void *cookie;		/* opaque for the caller */
 	vaddr_t start;		/* start of region */
 	vaddr_t realend;	/* real end of region */
 	vaddr_t end;		/* virtual end of region */
 	vm_prot_t prot;		/* protection of region */
 	int flags;		/* flags; see below */
 };
 #define	UVM_COREDUMP_STACK	0x01	/* region is user stack */
 /*
  * Structure containig uvm reclaim hooks, uvm_reclaim_list is guarded by
  * uvm_reclaim_lock.
  */
 struct uvm_reclaim_hook {
 	void (*uvm_reclaim_hook)(void);
 	SLIST_ENTRY(uvm_reclaim_hook) uvm_reclaim_next;
 };
 void	uvm_reclaim_init(void);
 void	uvm_reclaim_hook_add(struct uvm_reclaim_hook *);
 void	uvm_reclaim_hook_del(struct uvm_reclaim_hook *);
 /*
  * the various kernel maps, owned by MD code
  */
 extern struct vm_map *kernel_map;
 extern struct vm_map *kmem_map;
 extern struct vm_map *phys_map;
 /*
  * macros
  */
 #define vm_resident_count(vm) (pmap_resident_count((vm)->vm_map.pmap))
 #include <sys/mallocvar.h>
 MALLOC_DECLARE(M_VMMAP);
 MALLOC_DECLARE(M_VMPMAP);
 /* vm_machdep.c */
 int		vmapbuf(struct buf *, vsize_t);
 void		vunmapbuf(struct buf *, vsize_t);
 /* uvm_aobj.c */
 struct uvm_object	*uao_create(vsize_t, int);
 void			uao_detach(struct uvm_object *);
 void			uao_reference(struct uvm_object *);
 /* uvm_bio.c */
 void			ubc_init(void);
 void *			ubc_alloc(struct uvm_object *, voff_t, vsize_t *, int,
 			    int);
 void			ubc_release(void *, int);
 int			ubc_uiomove(struct uvm_object *, struct uio *, vsize_t,
 			    int, int);
 void			ubc_zerorange(struct uvm_object *, off_t, size_t, int);
 void			ubc_purge(struct uvm_object *);
 /* uvm_emap.c */
 void			uvm_emap_sysinit(void);
 #ifdef __HAVE_PMAP_EMAP
 void			uvm_emap_switch(lwp_t *);
 #else
 #define			uvm_emap_switch(l)
 #endif
 u_int			uvm_emap_gen_return(void);
 void			uvm_emap_update(u_int);
 vaddr_t			uvm_emap_alloc(vsize_t, bool);
 void			uvm_emap_free(vaddr_t, size_t);
 void			uvm_emap_enter(vaddr_t, struct vm_page **, u_int);
 void			uvm_emap_remove(vaddr_t, vsize_t);
 #ifdef __HAVE_PMAP_EMAP
 void			uvm_emap_consume(u_int);
 u_int			uvm_emap_produce(void);
 #else
 #define			uvm_emap_consume(x)
 #define			uvm_emap_produce()	UVM_EMAP_INACTIVE
 #endif
 /* uvm_fault.c */
 #define uvm_fault(m, a, p) uvm_fault_internal(m, a, p, 0)
 int		uvm_fault_internal(struct vm_map *, vaddr_t, vm_prot_t, int);
 			/* handle a page fault */
 /* uvm_glue.c */
 #if defined(KGDB)
 void			uvm_chgkprot(void *, size_t, int);
 #endif
 void			uvm_proc_fork(struct proc *, struct proc *, bool);
 void			uvm_lwp_fork(struct lwp *, struct lwp *,
 			    void *, size_t, void (*)(void *), void *);
 int			uvm_coredump_walkmap(struct proc *,
 			    void *,
 			    int (*)(struct proc *, void *,
 				    struct uvm_coredump_state *), void *);
 void			uvm_proc_exit(struct proc *);
 void			uvm_lwp_exit(struct lwp *);
 void			uvm_init_limits(struct proc *);
 bool			uvm_kernacc(void *, size_t, vm_prot_t);
 __dead void		uvm_scheduler(void);
 vaddr_t			uvm_uarea_alloc(void);
 void			uvm_uarea_free(vaddr_t);
 vaddr_t			uvm_uarea_system_alloc(void);
 void			uvm_uarea_system_free(vaddr_t);
 vaddr_t			uvm_lwp_getuarea(lwp_t *);
 void			uvm_lwp_setuarea(lwp_t *, vaddr_t);
 int			uvm_vslock(struct vmspace *, void *, size_t, vm_prot_t);
 void			uvm_vsunlock(struct vmspace *, void *, size_t);
 void			uvm_cpu_attach(struct cpu_info *);
 /* uvm_init.c */
 void			uvm_init(void);
 /* uvm_io.c */
 int			uvm_io(struct vm_map *, struct uio *);
 /* uvm_km.c */
 vaddr_t			uvm_km_alloc(struct vm_map *, vsize_t, vsize_t,
 			    uvm_flag_t);
 void			uvm_km_free(struct vm_map *, vaddr_t, vsize_t,
 			    uvm_flag_t);
 struct vm_map		*uvm_km_suballoc(struct vm_map *, vaddr_t *,
 			    vaddr_t *, vsize_t, int, bool,
 			    struct vm_map_kernel *);
 vaddr_t			uvm_km_alloc_poolpage(struct vm_map *, bool);
 void			uvm_km_free_poolpage(struct vm_map *, vaddr_t);
 vaddr_t			uvm_km_alloc_poolpage_cache(struct vm_map *, bool);
 void			uvm_km_free_poolpage_cache(struct vm_map *, vaddr_t);
 void			uvm_km_vacache_init(struct vm_map *,
 			    const char *, size_t);
 /* uvm_map.c */
 int			uvm_map(struct vm_map *, vaddr_t *, vsize_t,
 			    struct uvm_object *, voff_t, vsize_t,
 			    uvm_flag_t);
 int			uvm_map_pageable(struct vm_map *, vaddr_t,
 			    vaddr_t, bool, int);
 int			uvm_map_pageable_all(struct vm_map *, int, vsize_t);
 bool			uvm_map_checkprot(struct vm_map *, vaddr_t,
 			    vaddr_t, vm_prot_t);
 int			uvm_map_protect(struct vm_map *, vaddr_t,
 			    vaddr_t, vm_prot_t, bool);
 struct vmspace		*uvmspace_alloc(vaddr_t, vaddr_t);
 void			uvmspace_init(struct vmspace *, struct pmap *,
 			    vaddr_t, vaddr_t);
 void			uvmspace_exec(struct lwp *, vaddr_t, vaddr_t);
 struct vmspace		*uvmspace_fork(struct vmspace *);
 void			uvmspace_addref(struct vmspace *);
 void			uvmspace_free(struct vmspace *);
 void			uvmspace_share(struct proc *, struct proc *);
 void			uvmspace_unshare(struct lwp *);
 void			uvm_whatis(uintptr_t, void (*)(const char *, ...));
 /* uvm_meter.c */
 int			uvm_sysctl(int *, u_int, void *, size_t *,
 			    void *, size_t, struct proc *);
 int			uvm_pctparam_check(struct uvm_pctparam *, int);
 void			uvm_pctparam_set(struct uvm_pctparam *, int);
 int			uvm_pctparam_get(struct uvm_pctparam *);
 void			uvm_pctparam_init(struct uvm_pctparam *, int,
 			    int (*)(struct uvm_pctparam *, int));
 int			uvm_pctparam_createsysctlnode(struct uvm_pctparam *,
 			    const char *, const char *);
 /* uvm_mmap.c */
 int			uvm_mmap(struct vm_map *, vaddr_t *, vsize_t,
 			    vm_prot_t, vm_prot_t, int,
 			    void *, voff_t, vsize_t);
 vaddr_t			uvm_default_mapaddr(struct proc *, vaddr_t, vsize_t);
 /* uvm_mremap.c */
 int			uvm_mremap(struct vm_map *, vaddr_t, vsize_t,
 			    struct vm_map *, vaddr_t *, vsize_t,
 			    struct proc *, int);
 /* uvm_object.c */
 void			uvm_obj_init(struct uvm_object *,
 			    const struct uvm_pagerops *, bool, u_int);
 void			uvm_obj_setlock(struct uvm_object *, kmutex_t *);
 void			uvm_obj_destroy(struct uvm_object *, bool);
-int			uvm_obj_wirepages(struct uvm_object *, off_t, off_t);
+int			uvm_obj_wirepages(struct uvm_object *, off_t, off_t,
 			    struct pglist *);
 void			uvm_obj_unwirepages(struct uvm_object *, off_t, off_t);
 /* uvm_page.c */
 struct vm_page		*uvm_pagealloc_strat(struct uvm_object *,
 			    voff_t, struct vm_anon *, int, int, int);
 #define	uvm_pagealloc(obj, off, anon, flags) \
 	    uvm_pagealloc_strat((obj), (off), (anon), (flags), \
 				UVM_PGA_STRAT_NORMAL, 0)
 void			uvm_pagereplace(struct vm_page *,
 			    struct vm_page *);
 void			uvm_pagerealloc(struct vm_page *,
 			    struct uvm_object *, voff_t);
 /* Actually, uvm_page_physload takes PF#s which need their own type */
 void			uvm_page_physload(paddr_t, paddr_t, paddr_t,
 			    paddr_t, int);
 void			uvm_setpagesize(void);
 /* uvm_pager.c */
 void			uvm_aio_biodone(struct buf *);
 void			uvm_aio_aiodone(struct buf *);
 void			uvm_aio_aiodone_pages(struct vm_page **, int, bool,
 			    int);
 /* uvm_pdaemon.c */
 void			uvm_pageout(void *);
 struct work;
 void			uvm_aiodone_worker(struct work *, void *);
 void			uvm_pageout_start(int);
 void			uvm_pageout_done(int);
 void			uvm_estimatepageable(int *, int *);
 /* uvm_pglist.c */
 int			uvm_pglistalloc(psize_t, paddr_t, paddr_t,
 			    paddr_t, paddr_t, struct pglist *, int, int);
 void			uvm_pglistfree(struct pglist *);
 /* uvm_swap.c */
 void			uvm_swap_init(void);
 /* uvm_unix.c */
 int			uvm_grow(struct proc *, vaddr_t);
 /* uvm_user.c */
 void			uvm_deallocate(struct vm_map *, vaddr_t, vsize_t);
 /* uvm_vnode.c */
 void			uvm_vnp_setsize(struct vnode *, voff_t);
 void			uvm_vnp_setwritesize(struct vnode *, voff_t);
 int			uvn_findpages(struct uvm_object *, voff_t,
 			    int *, struct vm_page **, int);
 bool			uvn_text_p(struct uvm_object *);
 bool			uvn_clean_p(struct uvm_object *);
 bool			uvn_needs_writefault_p(struct uvm_object *);
 /* kern_malloc.c */
 void			kmeminit_nkmempages(void);
 void			kmeminit(void);
 extern int		nkmempages;
 #endif /* _KERNEL */
 #endif /* _UVM_UVM_EXTERN_H_ */

 @@ -1,262 +1,265 @@
-/*	$NetBSD: uvm_object.c,v 1.10 2011/06/18 21:14:43 rmind Exp $	*/
+/*	$NetBSD: uvm_object.c,v 1.11 2011/08/27 09:11:53 christos Exp $	*/
 /*
  * Copyright (c) 2006, 2010 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Mindaugas Rasiukevicius.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
 /*
  * uvm_object.c: operate with memory objects
+ *
  * TODO:
  *  1. Support PG_RELEASED-using objects
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: uvm_object.c,v 1.10 2011/06/18 21:14:43 rmind Exp $");
+__KERNEL_RCSID(0, "$NetBSD: uvm_object.c,v 1.11 2011/08/27 09:11:53 christos Exp $");
 #include "opt_ddb.h"
 #include <sys/param.h>
 #include <sys/mutex.h>
 #include <sys/queue.h>
 #include <sys/rbtree.h>
 #include <uvm/uvm.h>
 #include <uvm/uvm_ddb.h>
 /* Page count to fetch per single step. */
 #define	FETCH_PAGECOUNT			16
 /*
  * uvm_obj_init: initialize UVM memory object.
  */
 void
 uvm_obj_init(struct uvm_object *uo, const struct uvm_pagerops *ops,
     bool alock, u_int refs)
+{
 	if (alock) {
 		/* Allocate and assign a lock. */
 		uo->vmobjlock = mutex_obj_alloc(MUTEX_DEFAULT, IPL_NONE);
 	} else {
 		/* The lock will need to be set via uvm_obj_setlock(). */
 		uo->vmobjlock = NULL;
+	}
 	uo->pgops = ops;
 	TAILQ_INIT(&uo->memq);
 	LIST_INIT(&uo->uo_ubc);
 	uo->uo_npages = 0;
 	uo->uo_refs = refs;
 	rb_tree_init(&uo->rb_tree, &uvm_page_tree_ops);
+}
 /*
  * uvm_obj_destroy: destroy UVM memory object.
  */
 void
 uvm_obj_destroy(struct uvm_object *uo, bool dlock)
+{
 	KASSERT(rb_tree_iterate(&uo->rb_tree, NULL, RB_DIR_LEFT) == NULL);
 	/* Purge any UBC entries associated with this object. */
 	ubc_purge(uo);
 	/* Destroy the lock, if requested. */
 	if (dlock) {
 		mutex_obj_free(uo->vmobjlock);
+	}
+}
 /*
  * uvm_obj_setlock: assign a vmobjlock to the UVM object.
+ *
  * => Caller is responsible to ensure that UVM objects is not use.
  * => Only dynamic lock may be previously set.  We drop the reference then.
  */
 void
 uvm_obj_setlock(struct uvm_object *uo, kmutex_t *lockptr)
+{
 	kmutex_t *olockptr = uo->vmobjlock;
 	if (olockptr) {
 		/* Drop the reference on the old lock. */
 		mutex_obj_free(olockptr);
+	}
 	if (lockptr == NULL) {
 		/* If new lock is not passed - allocate default one. */
 		lockptr = mutex_obj_alloc(MUTEX_DEFAULT, IPL_NONE);
+	}
 	uo->vmobjlock = lockptr;
+}
 /*
  * uvm_obj_wirepages: wire the pages of entire UVM object.
+ *
  * => NOTE: this function should only be used for types of objects
  *  where PG_RELEASED flag is never set (aobj objects)
  * => caller must pass page-aligned start and end values
  */
 int
-uvm_obj_wirepages(struct uvm_object *uobj, off_t start, off_t end)
+uvm_obj_wirepages(struct uvm_object *uobj, off_t start, off_t end,
     struct pglist *list)
+{
 	int i, npages, error;
 	struct vm_page *pgs[FETCH_PAGECOUNT], *pg = NULL;
 	off_t offset = start, left;
 	left = (end - start) >> PAGE_SHIFT;
 	mutex_enter(uobj->vmobjlock);
 	while (left) {
 		npages = MIN(FETCH_PAGECOUNT, left);
 		/* Get the pages */
 		memset(pgs, 0, sizeof(pgs));
 		error = (*uobj->pgops->pgo_get)(uobj, offset, pgs, &npages, 0,
 			VM_PROT_READ | VM_PROT_WRITE, UVM_ADV_SEQUENTIAL,
 			PGO_ALLPAGES | PGO_SYNCIO);
 		if (error)
 			goto error;
 		mutex_enter(uobj->vmobjlock);
 		for (i = 0; i < npages; i++) {
 			KASSERT(pgs[i] != NULL);
 			KASSERT(!(pgs[i]->flags & PG_RELEASED));
 			/*
 			 * Loan break
 			 */
 			if (pgs[i]->loan_count) {
 				while (pgs[i]->loan_count) {
 					pg = uvm_loanbreak(pgs[i]);
 					if (!pg) {
 						mutex_exit(uobj->vmobjlock);
 						uvm_wait("uobjwirepg");
 						mutex_enter(uobj->vmobjlock);
 						continue;
+					}
+				}
 				pgs[i] = pg;
+			}
 			if (pgs[i]->pqflags & PQ_AOBJ) {
 				pgs[i]->flags &= ~(PG_CLEAN);
 				uao_dropswap(uobj, i);
+			}
+		}
 		/* Wire the pages */
 		mutex_enter(&uvm_pageqlock);
 		for (i = 0; i < npages; i++) {
 			uvm_pagewire(pgs[i]);
 			if (list != NULL)
 				TAILQ_INSERT_TAIL(list, pgs[i], pageq.queue);
+		}
 		mutex_exit(&uvm_pageqlock);
 		/* Unbusy the pages */
 		uvm_page_unbusy(pgs, npages);
 		left -= npages;
 		offset += npages << PAGE_SHIFT;
+	}
 	mutex_exit(uobj->vmobjlock);
 	return 0;
 error:
 	/* Unwire the pages which has been wired */
 	uvm_obj_unwirepages(uobj, start, offset);
 	return error;
+}
 /*
  * uvm_obj_unwirepages: unwire the pages of entire UVM object.
+ *
  * => NOTE: this function should only be used for types of objects
  *  where PG_RELEASED flag is never set
  * => caller must pass page-aligned start and end values
  */
 void
 uvm_obj_unwirepages(struct uvm_object *uobj, off_t start, off_t end)
+{
 	struct vm_page *pg;
 	off_t offset;
 	mutex_enter(uobj->vmobjlock);
 	mutex_enter(&uvm_pageqlock);
 	for (offset = start; offset < end; offset += PAGE_SIZE) {
 		pg = uvm_pagelookup(uobj, offset);
 		KASSERT(pg != NULL);
 		KASSERT(!(pg->flags & PG_RELEASED));
 		uvm_pageunwire(pg);
+	}
 	mutex_exit(&uvm_pageqlock);
 	mutex_exit(uobj->vmobjlock);
+}
 #if (defined(DDB) || defined(DEBUGPRINT)) && !defined(_RUMPKERNEL)
 /*
  * uvm_object_printit: actually prints the object
  */
 void
 uvm_object_printit(struct uvm_object *uobj, bool full,
     void (*pr)(const char *, ...))
+{
 	struct vm_page *pg;
 	int cnt = 0;
 	(*pr)("OBJECT %p: locked=%d, pgops=%p, npages=%d, ",
 	    uobj, mutex_owned(uobj->vmobjlock), uobj->pgops, uobj->uo_npages);
 	if (UVM_OBJ_IS_KERN_OBJECT(uobj))
 		(*pr)("refs=<SYSTEM>\n");
 	else
 		(*pr)("refs=%d\n", uobj->uo_refs);
 	if (!full) {
 		return;
+	}
 	(*pr)("  PAGES <pg,offset>:\n  ");
 	TAILQ_FOREACH(pg, &uobj->memq, listq.queue) {
 		cnt++;
 		(*pr)("<%p,0x%llx> ", pg, (long long)pg->offset);
 		if ((cnt % 3) == 0) {
 			(*pr)("\n  ");
+		}
+	}
 	if ((cnt % 3) != 0) {
 		(*pr)("\n");
+	}
+}
 #endif /* DDB || DEBUGPRINT */