 @@ -1,14 +1,14 @@
-/*	$NetBSD: uvm_aobj.c,v 1.116 2011/09/06 16:41:55 matt Exp $	*/
+/*	$NetBSD: uvm_aobj.c,v 1.117 2012/09/14 18:56:15 rmind Exp $	*/
 /*
  * Copyright (c) 1998 Chuck Silvers, 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
 @@ -28,191 +28,171 @@
  * from: Id: uvm_aobj.c,v 1.1.2.5 1998/02/06 05:14:38 chs Exp
  */
 /*
  * uvm_aobj.c: anonymous memory uvm_object pager
+ *
  * author: Chuck Silvers <chuq@chuq.com>
  * started: Jan-1998
+ *
  * - design mostly from Chuck Cranor
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: uvm_aobj.c,v 1.116 2011/09/06 16:41:55 matt Exp $");
+__KERNEL_RCSID(0, "$NetBSD: uvm_aobj.c,v 1.117 2012/09/14 18:56:15 rmind Exp $");
 #include "opt_uvmhist.h"
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/proc.h>
 #include <sys/kernel.h>
 #include <sys/kmem.h>
 #include <sys/pool.h>
 #include <uvm/uvm.h>
 /*
- * an aobj manages anonymous-memory backed uvm_objects.   in addition
+ * An anonymous UVM object (aobj) manages anonymous-memory.  In addition to
- * to keeping the list of resident pages, it also keeps a list of
+ * keeping the list of resident pages, it may also keep a list of allocated
- * allocated swap blocks.  depending on the size of the aobj this list
+ * swap blocks.  Depending on the size of the object, this list is either
- * of allocated swap blocks is either stored in an array (small objects)
+ * stored in an array (small objects) or in a hash table (large objects).
  * or in a hash table (large objects).
- */
+ * Lock order
+ *
-/*
+ *	uvm_object::vmobjlock ->
- * local structures
+ *		uao_list_lock
  */
 /*
- * for hash tables, we break the address space of the aobj into blocks
+ * Note: for hash tables, we break the address space of the aobj into blocks
- * of UAO_SWHASH_CLUSTER_SIZE pages.   we require the cluster size to
+ * of UAO_SWHASH_CLUSTER_SIZE pages, which shall be a power of two.
  * be a power of two.
  */
-#define UAO_SWHASH_CLUSTER_SHIFT 4
+#define	UAO_SWHASH_CLUSTER_SHIFT	4
-#define UAO_SWHASH_CLUSTER_SIZE (1 << UAO_SWHASH_CLUSTER_SHIFT)
+#define	UAO_SWHASH_CLUSTER_SIZE		(1 << UAO_SWHASH_CLUSTER_SHIFT)
-/* get the "tag" for this page index */
+/* Get the "tag" for this page index. */
-#define UAO_SWHASH_ELT_TAG(PAGEIDX) \
+#define	UAO_SWHASH_ELT_TAG(idx)		((idx) >> UAO_SWHASH_CLUSTER_SHIFT)
-	((PAGEIDX) >> UAO_SWHASH_CLUSTER_SHIFT)
+#define UAO_SWHASH_ELT_PAGESLOT_IDX(idx) \
     ((idx) & (UAO_SWHASH_CLUSTER_SIZE - 1))
-#define UAO_SWHASH_ELT_PAGESLOT_IDX(PAGEIDX) \
+/* Given an ELT and a page index, find the swap slot. */
-	((PAGEIDX) & (UAO_SWHASH_CLUSTER_SIZE - 1))
+#define	UAO_SWHASH_ELT_PAGESLOT(elt, idx) \
     ((elt)->slots[UAO_SWHASH_ELT_PAGESLOT_IDX(idx)])
-/* given an ELT and a page index, find the swap slot */
+/* Given an ELT, return its pageidx base. */
-#define UAO_SWHASH_ELT_PAGESLOT(ELT, PAGEIDX) \
+#define	UAO_SWHASH_ELT_PAGEIDX_BASE(ELT) \
-	((ELT)->slots[UAO_SWHASH_ELT_PAGESLOT_IDX(PAGEIDX)])
+    ((elt)->tag << UAO_SWHASH_CLUSTER_SHIFT)
-/* given an ELT, return its pageidx base */
+/* The hash function. */
-#define UAO_SWHASH_ELT_PAGEIDX_BASE(ELT) \
+#define	UAO_SWHASH_HASH(aobj, idx) \
-	((ELT)->tag << UAO_SWHASH_CLUSTER_SHIFT)
+    (&(aobj)->u_swhash[(((idx) >> UAO_SWHASH_CLUSTER_SHIFT) \
     & (aobj)->u_swhashmask)])
 /*
- * the swhash hash function
+ * The threshold which determines whether we will use an array or a
  */
 #define UAO_SWHASH_HASH(AOBJ, PAGEIDX) \
 	(&(AOBJ)->u_swhash[(((PAGEIDX) >> UAO_SWHASH_CLUSTER_SHIFT) \
 			    & (AOBJ)->u_swhashmask)])
 /*
  * the swhash threshhold determines if we will use an array or a
  * hash table to store the list of allocated swap blocks.
  */
 #define	UAO_SWHASH_THRESHOLD		(UAO_SWHASH_CLUSTER_SIZE * 4)
-#define UAO_SWHASH_THRESHOLD (UAO_SWHASH_CLUSTER_SIZE * 4)
+#define	UAO_USES_SWHASH(aobj) \
-#define UAO_USES_SWHASH(AOBJ) \
+    ((aobj)->u_pages > UAO_SWHASH_THRESHOLD)
 	((AOBJ)->u_pages > UAO_SWHASH_THRESHOLD)	/* use hash? */
 /* The number of buckets in a hash, with an upper bound. */
-/*
+#define	UAO_SWHASH_MAXBUCKETS		256
- * the number of buckets in a swhash, with an upper bound
+#define	UAO_SWHASH_BUCKETS(aobj) \
- */
+    (MIN((aobj)->u_pages >> UAO_SWHASH_CLUSTER_SHIFT, UAO_SWHASH_MAXBUCKETS))
 #define UAO_SWHASH_MAXBUCKETS 256
 #define UAO_SWHASH_BUCKETS(AOBJ) \
 	(MIN((AOBJ)->u_pages >> UAO_SWHASH_CLUSTER_SHIFT, \
 	     UAO_SWHASH_MAXBUCKETS))
 /*
  * uao_swhash_elt: when a hash table is being used, this structure defines
  * the format of an entry in the bucket list.
  */
 struct uao_swhash_elt {
 	LIST_ENTRY(uao_swhash_elt) list;	/* the hash list */
 	voff_t tag;				/* our 'tag' */
 	int count;				/* our number of active slots */
 	int slots[UAO_SWHASH_CLUSTER_SIZE];	/* the slots */
 };
 /*
  * uao_swhash: the swap hash table structure
  */
 LIST_HEAD(uao_swhash, uao_swhash_elt);
 /*
  * uao_swhash_elt_pool: pool of uao_swhash_elt structures.
  * Note: pages for this pool must not come from a pageable kernel map.
  */
-static struct pool uao_swhash_elt_pool;
+static struct pool	uao_swhash_elt_pool	__cacheline_aligned;
 /*
  * uvm_aobj: the actual anon-backed uvm_object
+ *
  * => the uvm_object is at the top of the structure, this allows
  *   (struct uvm_aobj *) == (struct uvm_object *)
  * => only one of u_swslots and u_swhash is used in any given aobj
  */
 struct uvm_aobj {
 	struct uvm_object u_obj; /* has: lock, pgops, memq, #pages, #refs */
 	pgoff_t u_pages;	 /* number of pages in entire object */
 	int u_flags;		 /* the flags (see uvm_aobj.h) */
 	int *u_swslots;		 /* array of offset->swapslot mappings */
 				 /*
 				  * hashtable of offset->swapslot mappings
 				  * (u_swhash is an array of bucket heads)
 				  */
 	struct uao_swhash *u_swhash;
 	u_long u_swhashmask;		/* mask for hashtable */
 	LIST_ENTRY(uvm_aobj) u_list;	/* global list of aobjs */
 };
 /*
  * local functions
  */
 static void	uao_free(struct uvm_aobj *);
 static int	uao_get(struct uvm_object *, voff_t, struct vm_page **,
 		    int *, int, vm_prot_t, int, int);
 static int	uao_put(struct uvm_object *, voff_t, voff_t, int);
 static void uao_detach_locked(struct uvm_object *);
 static void uao_reference_locked(struct uvm_object *);
 #if defined(VMSWAP)
 static struct uao_swhash_elt *uao_find_swhash_elt
     (struct uvm_aobj *, int, bool);
 static bool uao_pagein(struct uvm_aobj *, int, int);
 static bool uao_pagein_page(struct uvm_aobj *, int);
 static void uao_dropswap_range1(struct uvm_aobj *, voff_t, voff_t);
 #endif /* defined(VMSWAP) */
 /*
  * aobj_pager
+ *
  * note that some functions (e.g. put) are handled elsewhere
  */
 const struct uvm_pagerops aobj_pager = {
 	.pgo_reference = uao_reference,
 	.pgo_detach = uao_detach,
 	.pgo_get = uao_get,
 	.pgo_put = uao_put,
 };
 /*
  * uao_list: global list of active aobjs, locked by uao_list_lock
  */
-static LIST_HEAD(aobjlist, uvm_aobj) uao_list;
+static LIST_HEAD(aobjlist, uvm_aobj) uao_list	__cacheline_aligned;
-static kmutex_t uao_list_lock;
+static kmutex_t		uao_list_lock		__cacheline_aligned;
 /*
  * functions
  */
 /*
  * hash table/array related functions
  */
 #if defined(VMSWAP)
 /*
  * uao_find_swhash_elt: find (or create) a hash table entry for a page
  * offset.
+ *
  * => the object should be locked by the caller
  */
 @@ -262,45 +242,42 @@ uao_find_swhash_elt(struct uvm_aobj *aob
  */
 int
 uao_find_swslot(struct uvm_object *uobj, int pageidx)
+{
 	struct uvm_aobj *aobj = (struct uvm_aobj *)uobj;
 	struct uao_swhash_elt *elt;
 	/*
 	 * if noswap flag is set, then we never return a slot
 	 */
 	if (aobj->u_flags & UAO_FLAG_NOSWAP)
-		return(0);
+		return 0;
 	/*
 	 * if hashing, look in hash table.
 	 */
 	if (UAO_USES_SWHASH(aobj)) {
 		elt = uao_find_swhash_elt(aobj, pageidx, false);
-		if (elt)
+		return elt ? UAO_SWHASH_ELT_PAGESLOT(elt, pageidx) : 0;
 			return(UAO_SWHASH_ELT_PAGESLOT(elt, pageidx));
 		else
 			return(0);
+	}
 	/*
 	 * otherwise, look in the array
 	 */
-	return(aobj->u_swslots[pageidx]);
+	return aobj->u_swslots[pageidx];
+}
 /*
  * uao_set_swslot: set the swap slot for a page in an aobj.
+ *
  * => setting a slot to zero frees the slot
  * => object must be locked by caller
  * => we return the old slot number, or -1 if we failed to allocate
  *    memory to record the new slot number
  */
 int
 uao_set_swslot(struct uvm_object *uobj, int pageidx, int slot)
 @@ -309,31 +286,28 @@ uao_set_swslot(struct uvm_object *uobj,
 	struct uao_swhash_elt *elt;
 	int oldslot;
 	UVMHIST_FUNC("uao_set_swslot"); UVMHIST_CALLED(pdhist);
 	UVMHIST_LOG(pdhist, "aobj %p pageidx %d slot %d",
 	    aobj, pageidx, slot, 0);
 	KASSERT(mutex_owned(uobj->vmobjlock) || uobj->uo_refs == 0);
 	/*
 	 * if noswap flag is set, then we can't set a non-zero slot.
 	 */
 	if (aobj->u_flags & UAO_FLAG_NOSWAP) {
-		if (slot == 0)
+		KASSERTMSG(slot == 0, "uao_set_swslot: no swap object");
-			return(0);
+		return 0;
 		printf("uao_set_swslot: uobj = %p\n", uobj);
 		panic("uao_set_swslot: NOSWAP object");
+	}
 	/*
 	 * are we using a hash table?  if so, add it in the hash.
 	 */
 	if (UAO_USES_SWHASH(aobj)) {
 		/*
 		 * Avoid allocating an entry just to free it again if
 		 * the page had not swap slot in the first place, and
 		 * we are freeing.
 		 */
 @@ -358,74 +332,72 @@ uao_set_swslot(struct uvm_object *uobj,
 			if (oldslot)
 				elt->count--;
 			if (elt->count == 0) {
 				LIST_REMOVE(elt, list);
 				pool_put(&uao_swhash_elt_pool, elt);
+			}
+		}
 	} else {
 		/* we are using an array */
 		oldslot = aobj->u_swslots[pageidx];
 		aobj->u_swslots[pageidx] = slot;
+	}
-	return (oldslot);
+	return oldslot;
+}
 #endif /* defined(VMSWAP) */
 /*
  * end of hash/array functions
  */
 /*
  * uao_free: free all resources held by an aobj, and then free the aobj
+ *
  * => the aobj should be dead
  */
 static void
 uao_free(struct uvm_aobj *aobj)
+{
 	struct uvm_object *uobj = &aobj->u_obj;
-#if defined(VMSWAP)
+	uao_dropswap_range(aobj, 0, 0);
-	uao_dropswap_range1(aobj, 0, 0);
+	mutex_exit(uobj->vmobjlock);
 #endif /* defined(VMSWAP) */
 	mutex_exit(aobj->u_obj.vmobjlock);
 #if defined(VMSWAP)
 	if (UAO_USES_SWHASH(aobj)) {
 		/*
 		 * free the hash table itself.
 		 */
 		hashdone(aobj->u_swhash, HASH_LIST, aobj->u_swhashmask);
 	} else {
 		/*
 		 * free the array itsself.
 		 */
 		kmem_free(aobj->u_swslots, aobj->u_pages * sizeof(int));
+	}
 #endif /* defined(VMSWAP) */
 	/*
 	 * finally free the aobj itself
 	 */
-	uvm_obj_destroy(&aobj->u_obj, true);
+	uvm_obj_destroy(uobj, true);
 	kmem_free(aobj, sizeof(struct uvm_aobj));
+}
 /*
  * pager functions
  */
 /*
  * uao_create: create an aobj of the given size and return its uvm_object.
+ *
  * => for normal use, flags are always zero
  * => for the kernel object, the flags are:
  *	UAO_FLAG_KERNOBJ - allocate the kernel object (can only happen once)
 @@ -483,54 +455,52 @@ uao_create(vsize_t size, int flags)
 			    &aobj->u_swhashmask);
 			if (aobj->u_swhash == NULL)
 				panic("uao_create: hashinit swhash failed");
 		} else {
 			aobj->u_swslots = kmem_zalloc(pages * sizeof(int),
 			    kernswap ? KM_NOSLEEP : KM_SLEEP);
 			if (aobj->u_swslots == NULL)
 				panic("uao_create: swslots allocation failed");
+		}
 #endif /* defined(VMSWAP) */
 		if (flags) {
 			aobj->u_flags &= ~UAO_FLAG_NOSWAP; /* clear noswap */
-			return(&aobj->u_obj);
+			return &aobj->u_obj;
+		}
+	}
 	/*
 	 * Initialise UVM object.
 	 */
 	const bool kernobj = (flags & UAO_FLAG_KERNOBJ) != 0;
 	uvm_obj_init(&aobj->u_obj, &aobj_pager, !kernobj, refs);
 	if (__predict_false(kernobj)) {
 		/* Initialisation only once, for UAO_FLAG_KERNOBJ. */
 		mutex_init(&kernel_object_lock, MUTEX_DEFAULT, IPL_NONE);
 		uvm_obj_setlock(&aobj->u_obj, &kernel_object_lock);
+	}
 	/*
  	 * now that aobj is ready, add it to the global list
  	 */
 	mutex_enter(&uao_list_lock);
 	LIST_INSERT_HEAD(&uao_list, aobj, u_list);
 	mutex_exit(&uao_list_lock);
 	return(&aobj->u_obj);
+}
 /*
  * uao_init: set up aobj pager subsystem
+ *
  * => called at boot time from uvm_pager_init()
  */
 void
 uao_init(void)
+{
 	static int uao_initialized;
 	if (uao_initialized)
 		return;
 @@ -905,29 +875,26 @@ uao_put(struct uvm_object *uobj, voff_t
+ *
  * => prefer map unlocked (not required)
  * => object must be locked!  we will _unlock_ it before starting any I/O.
  * => flags: PGO_ALLPAGES: get all of the pages
  *           PGO_LOCKED: fault data structures are locked
  * => NOTE: offset is the offset of pps[0], _NOT_ pps[centeridx]
  * => NOTE: caller must check for released pages!!
  */
 static int
 uao_get(struct uvm_object *uobj, voff_t offset, struct vm_page **pps,
     int *npagesp, int centeridx, vm_prot_t access_type, int advice, int flags)
+{
 #if defined(VMSWAP)
 	struct uvm_aobj *aobj = (struct uvm_aobj *)uobj;
 #endif /* defined(VMSWAP) */
 	voff_t current_offset;
 	struct vm_page *ptmp = NULL;	/* Quell compiler warning */
 	int lcv, gotpages, maxpages, swslot, pageidx;
 	bool done;
 	UVMHIST_FUNC("uao_get"); UVMHIST_CALLED(pdhist);
 	UVMHIST_LOG(pdhist, "aobj=%p offset=%d, flags=%d",
 		    (struct uvm_aobj *)uobj, offset, flags,0);
 	/*
  	 * get number of pages
  	 */
 @@ -949,27 +916,27 @@ uao_get(struct uvm_object *uobj, voff_t
 		gotpages = 0;	/* # of pages we got so far */
 		for (lcv = 0, current_offset = offset ; lcv < maxpages ;
 		    lcv++, current_offset += PAGE_SIZE) {
 			/* do we care about this page?  if not, skip it */
 			if (pps[lcv] == PGO_DONTCARE)
 				continue;
 			ptmp = uvm_pagelookup(uobj, current_offset);
 			/*
  			 * if page is new, attempt to allocate the page,
 			 * zero-fill'd.
  			 */
-			if (ptmp == NULL && uao_find_swslot(&aobj->u_obj,
+			if (ptmp == NULL && uao_find_swslot(uobj,
 			    current_offset >> PAGE_SHIFT) == 0) {
 				ptmp = uvm_pagealloc(uobj, current_offset,
 				    NULL, UVM_FLAG_COLORMATCH|UVM_PGA_ZERO);
 				if (ptmp) {
 					/* new page */
 					ptmp->flags &= ~(PG_FAKE);
 					ptmp->pqflags |= PQ_AOBJ;
 					goto gotpage;
+				}
+			}
 			/*
 			 * to be useful must get a non-busy page
 @@ -1112,27 +1079,27 @@ gotpage:
 		/*
  		 * if we own the valid page at the correct offset, pps[lcv] will
  		 * point to it.   nothing more to do except go to the next page.
  		 */
 		if (pps[lcv])
 			continue;			/* next lcv */
 		/*
  		 * we have a "fake/busy/clean" page that we just allocated.
  		 * do the needed "i/o", either reading from swap or zeroing.
  		 */
-		swslot = uao_find_swslot(&aobj->u_obj, pageidx);
+		swslot = uao_find_swslot(uobj, pageidx);
 		/*
  		 * just zero the page if there's nothing in swap.
  		 */
 		if (swslot == 0) {
 			/*
 			 * page hasn't existed before, just zero it.
 			 */
 			uvm_pagezero(ptmp);
 		} else {
 @@ -1381,50 +1348,51 @@ restart:
 			 */
 			rv = uao_pagein_page(aobj, i);
 			if (rv) {
 				return rv;
+			}
+		}
+	}
 	return false;
+}
 /*
- * page in a page from an aobj.  used for swap_off.
+ * uao_pagein_page: page in a single page from an anonymous UVM object.
  * returns true if pagein was aborted due to lack of memory.
+ *
- * => aobj must be locked and is returned locked.
+ * => Returns true if pagein was aborted due to lack of memory.
  * => Object must be locked and is returned locked.
  */
 static bool
 uao_pagein_page(struct uvm_aobj *aobj, int pageidx)
+{
 	struct uvm_object *uobj = &aobj->u_obj;
 	struct vm_page *pg;
 	int rv, npages;
 	pg = NULL;
 	npages = 1;
 	/* locked: aobj */
-	rv = uao_get(&aobj->u_obj, pageidx << PAGE_SHIFT,
+	KASSERT(mutex_owned(uobj->vmobjlock));
-	    &pg, &npages, 0, VM_PROT_READ|VM_PROT_WRITE, 0, PGO_SYNCIO);
+	rv = uao_get(uobj, pageidx << PAGE_SHIFT, &pg, &npages,
-	/* unlocked: aobj */
+, VM_PROT_READ | VM_PROT_WRITE, 0, PGO_SYNCIO);
 	/*
 	 * relock and finish up.
 	 */
-	mutex_enter(aobj->u_obj.vmobjlock);
+	mutex_enter(uobj->vmobjlock);
 	switch (rv) {
 	case 0:
 		break;
 	case EIO:
 	case ERESTART:
 		/*
 		 * nothing more to do on errors.
 		 * ERESTART can only mean that the anon was freed,
 		 * so again there's nothing to do.
 		 */
 @@ -1458,37 +1426,30 @@ uao_pagein_page(struct uvm_aobj *aobj, i
+}
 /*
  * uao_dropswap_range: drop swapslots in the range.
+ *
  * => aobj must be locked and is returned locked.
  * => start is inclusive.  end is exclusive.
  */
 void
 uao_dropswap_range(struct uvm_object *uobj, voff_t start, voff_t end)
+{
 	struct uvm_aobj *aobj = (struct uvm_aobj *)uobj;
 	int swpgonlydelta = 0;
 	KASSERT(mutex_owned(uobj->vmobjlock));
 	uao_dropswap_range1(aobj, start, end);
 static void
 uao_dropswap_range1(struct uvm_aobj *aobj, voff_t start, voff_t end)
 	int swpgonlydelta = 0;
 	if (end == 0) {
 		end = INT64_MAX;
+	}
 	if (UAO_USES_SWHASH(aobj)) {
 		int i, hashbuckets = aobj->u_swhashmask + 1;
 		voff_t taghi;
 		voff_t taglo;
 		taglo = UAO_SWHASH_ELT_TAG(start);
 		taghi = UAO_SWHASH_ELT_TAG(end);
 		for (i = 0; i < hashbuckets; i++) {

 @@ -1,14 +1,14 @@
-/*	$NetBSD: uvm_aobj.h,v 1.21 2011/02/02 15:28:38 chuck Exp $	*/
+/*	$NetBSD: uvm_aobj.h,v 1.22 2012/09/14 18:56:15 rmind Exp $	*/
 /*
  * Copyright (c) 1998 Chuck Silvers, 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
 @@ -30,48 +30,42 @@
 /*
  * uvm_aobj.h: anonymous memory uvm_object pager
+ *
  * author: Chuck Silvers <chuq@chuq.com>
  * started: Jan-1998
+ *
  * - design mostly from Chuck Cranor
  */
 #ifndef _UVM_UVM_AOBJ_H_
 #define _UVM_UVM_AOBJ_H_
 /*
- * flags
+ * Flags for uao_create: UAO_FLAG_KERNOBJ and UAO_FLAG_KERNSWAP are
  * used only once, to initialise UVM.
  */
 #define	UAO_FLAG_KERNOBJ	0x1	/* create kernel object */
-/* flags for uao_create: can only be used one time (at bootup) */
+#define	UAO_FLAG_KERNSWAP	0x2	/* enable kernel swap */
-#define UAO_FLAG_KERNOBJ	0x1	/* create kernel object */
+#define	UAO_FLAG_NOSWAP		0x8	/* aobj may not swap */
 #define UAO_FLAG_KERNSWAP	0x2	/* enable kernel swap */
 /* internal flags */
 #define UAO_FLAG_NOSWAP		0x8	/* aobj can't swap (kernel obj only!) */
 #ifdef _KERNEL
 #if defined(_KERNEL_OPT)
 #include "opt_vmswap.h"
 #endif
-/*
+void	uao_init(void);
- * prototypes
+int	uao_set_swslot(struct uvm_object *, int, int);
  */
-void uao_init(void);
+#if	defined(VMSWAP)
-int uao_set_swslot(struct uvm_object *, int, int);
+int	uao_find_swslot(struct uvm_object *, int);
-#if defined(VMSWAP)
+void	uao_dropswap(struct uvm_object *, int);
-int uao_find_swslot(struct uvm_object *, int);
+bool	uao_swap_off(int, int);
-void uao_dropswap(struct uvm_object *, int);
+void	uao_dropswap_range(struct uvm_object *, voff_t, voff_t);
-bool uao_swap_off(int, int);
+#else
 void uao_dropswap_range(struct uvm_object *, voff_t, voff_t);
 #else /* defined(VMSWAP) */
 #define	uao_find_swslot(obj, off)	0
 #define	uao_dropswap(obj, off)		/* nothing */
 #define	uao_dropswap_range(obj, lo, hi)	/* nothing */
-#endif /* defined(VMSWAP) */
+#endif
 #endif /* _KERNEL */
 #endif /* _UVM_UVM_AOBJ_H_ */