NOTE: libkvm, w, ps, 'top', and any other utility which depends on struct

      proc or any VM system structure will have to be rebuilt!!!

Much needed overhaul of the VM system. Included in this first round of
changes:

1) Improved pager interfaces: init, alloc, dealloc, getpages, putpages,
   haspage, and sync operations are supported. The haspage interface now
   provides information about clusterability. All pager routines now take
   struct vm_object's instead of "pagers".

2) Improved data structures. In the previous paradigm, there is constant
   confusion caused by pagers being both a data structure ("allocate a
   pager") and a collection of routines. The idea of a pager structure has
   escentially been eliminated. Objects now have types, and this type is
   used to index the appropriate pager. In most cases, items in the pager
   structure were duplicated in the object data structure and thus were
   unnecessary. In the few cases that remained, a un_pager structure union
   was created in the object to contain these items.

3) Because of the cleanup of #1 & #2, a lot of unnecessary layering can now
   be removed. For instance, vm_object_enter(), vm_object_lookup(),
   vm_object_remove(), and the associated object hash list were some of the
   things that were removed.

4) simple_lock's removed. Discussion with several people reveals that the
   SMP locking primitives used in the VM system aren't likely the mechanism
   that we'll be adopting. Even if it were, the locking that was in the code
   was very inadequate and would have to be mostly re-done anyway. The
   locking in a uni-processor kernel was a no-op but went a long way toward
   making the code difficult to read and debug.

5) Places that attempted to kludge-up the fact that we don't have kernel
   thread support have been fixed to reflect the reality that we are really
   dealing with processes, not threads. The VM system didn't have complete
   thread support, so the comments and mis-named routines were just wrong.
   We now use tsleep and wakeup directly in the lock routines, for instance.

6) Where appropriate, the pagers have been improved, especially in the
   pager_alloc routines. Most of the pager_allocs have been rewritten and
   are now faster and easier to maintain.

7) The pagedaemon pageout clustering algorithm has been rewritten and
   now tries harder to output an even number of pages before and after
   the requested page. This is sort of the reverse of the ideal pagein
   algorithm and should provide better overall performance.

8) Unnecessary (incorrect) casts to caddr_t in calls to tsleep & wakeup
   have been removed. Some other unnecessary casts have also been removed.

9) Some almost useless debugging code removed.

10) Terminology of shadow objects vs. backing objects straightened out.
    The fact that the vm_object data structure escentially had this
    backwards really confused things. The use of "shadow" and "backing
    object" throughout the code is now internally consistent and correct
    in the Mach terminology.

11) Several minor bug fixes, including one in the vm daemon that caused
    0 RSS objects to not get purged as intended.

12) A "default pager" has now been created which cleans up the transition
    of objects to the "swap" type. The previous checks throughout the code
    for swp->pg_data != NULL were really ugly. This change also provides
    the rudiments for future backing of "anonymous" memory by something
    other than the swap pager (via the vnode pager, for example), and it
    allows the decision about which of these pagers to use to be made
    dynamically (although will need some additional decision code to do
    this, of course).

13) (dyson) MAP_COPY has been deprecated and the corresponding "copy
    object" code has been removed. MAP_COPY was undocumented and non-
    standard. It was furthermore broken in several ways which caused its
    behavior to degrade to MAP_PRIVATE. Binaries that use MAP_COPY will
    continue to work correctly, but via the slightly different semantics
    of MAP_PRIVATE.

14) (dyson) Sharing maps have been removed. It's marginal usefulness in a
    threads design can be worked around in other ways. Both #12 and #13
    were done to simplify the code and improve readability and maintain-
    ability. (As were most all of these changes)

TODO:

1) Rewrite most of the vnode pager to use VOP_GETPAGES/PUTPAGES. Doing
   this will reduce the vnode pager to a mere fraction of its current size.

2) Rewrite vm_fault and the swap/vnode pagers to use the clustering
   information provided by the new haspage pager interface. This will
   substantially reduce the overhead by eliminating a large number of
   VOP_BMAP() calls. The VOP_BMAP() filesystem interface should be
   improved to provide both a "behind" and "ahead" indication of
   contiguousness.

3) Implement the extended features of pager_haspage in swap_pager_haspage().
   It currently just says 0 pages ahead/behind.

4) Re-implement the swap device (swstrategy) in a more elegant way, perhaps
   via a much more general mechanism that could also be used for disk
   striping of regular filesystems.

5) Do something to improve the architecture of vm_object_collapse(). The
   fact that it makes calls into the swap pager and knows too much about
   how the swap pager operates really bothers me. It also doesn't allow
   for collapsing of non-swap pager objects ("unnamed" objects backed by
   other pagers).

1 files changed, 164 insertions, 306 deletions

diff --git a/sys/vm/vnode_pager.c b/sys/vm/vnode_pager.c
index c24d3e5..6e89635 100644
--- a/sys/vm/vnode_pager.c
+++ b/sys/vm/vnode_pager.c
@@ -2,7 +2,8 @@
  * Copyright (c) 1990 University of Utah.
  * Copyright (c) 1991 The Regents of the University of California.
  * All rights reserved.
- * Copyright (c) 1993,1994 John S. Dyson
+ * Copyright (c) 1993, 1994 John S. Dyson
+ * Copyright (c) 1995, David Greenman
  *
  * This code is derived from software contributed to Berkeley by
  * the Systems Programming Group of the University of Utah Computer
@@ -37,25 +38,17 @@
  * SUCH DAMAGE.
  *
  *	from: @(#)vnode_pager.c	7.5 (Berkeley) 4/20/91
- *	$Id: vnode_pager.c,v 1.42 1995/07/06 11:48:48 davidg Exp $
+ *	$Id: vnode_pager.c,v 1.43 1995/07/09 06:58:03 davidg Exp $
  */
 
 /*
  * Page to/from files (vnodes).
- *
- * TODO:
- *	pageouts
- *	fix credential use (uses current process credentials now)
  */
 
 /*
- * 1) Supports multiple - block reads/writes
- * 2) Bypasses buffer cache for reads
- *
  * TODO:
- *	Implement getpage/putpage interface for filesystems.  Should
+ *	Implement VOP_GETPAGES/PUTPAGES interface for filesystems. Will
  *	greatly re-simplify the vnode_pager.
- *
  */
 
 #include <sys/param.h>
@@ -66,64 +59,34 @@
 #include <sys/vnode.h>
 #include <sys/uio.h>
 #include <sys/mount.h>
+#include <sys/buf.h>
 
 #include <vm/vm.h>
 #include <vm/vm_page.h>
+#include <vm/vm_pager.h>
 #include <vm/vnode_pager.h>
 
-#include <sys/buf.h>
-#include <miscfs/specfs/specdev.h>
-
-int vnode_pager_putmulti();
-
-void vnode_pager_init();
-void vnode_pager_dealloc();
-int vnode_pager_getpage();
-int vnode_pager_getmulti();
-int vnode_pager_putpage();
-boolean_t vnode_pager_haspage();
-
 struct pagerops vnodepagerops = {
-	vnode_pager_init,
+	NULL,
 	vnode_pager_alloc,
 	vnode_pager_dealloc,
-	vnode_pager_getpage,
-	vnode_pager_getmulti,
-	vnode_pager_putpage,
-	vnode_pager_putmulti,
-	vnode_pager_haspage
+	vnode_pager_getpages,
+	vnode_pager_putpages,
+	vnode_pager_haspage,
+	NULL
 };
 
-
-
-static int vnode_pager_input(vn_pager_t vnp, vm_page_t * m, int count, int reqpage);
-static int vnode_pager_output(vn_pager_t vnp, vm_page_t * m, int count, int *rtvals);
-
-extern vm_map_t pager_map;
-
-struct pagerlst vnode_pager_list;	/* list of managed vnodes */
-
-#define MAXBP (PAGE_SIZE/DEV_BSIZE);
-
-void
-vnode_pager_init()
-{
-	TAILQ_INIT(&vnode_pager_list);
-}
-
 /*
  * Allocate (or lookup) pager for a vnode.
  * Handle is a vnode pointer.
  */
-vm_pager_t
+vm_object_t
 vnode_pager_alloc(handle, size, prot, offset)
 	void *handle;
 	vm_size_t size;
 	vm_prot_t prot;
 	vm_offset_t offset;
 {
-	register vm_pager_t pager;
-	register vn_pager_t vnp;
 	vm_object_t object;
 	struct vnode *vp;
 
@@ -149,49 +112,31 @@ vnode_pager_alloc(handle, size, prot, offset)
 	 * If the object is being terminated, wait for it to
 	 * go away.
 	 */
-	while (((object = vp->v_object) != NULL) && (object->flags & OBJ_DEAD))
+	while (((object = vp->v_object) != NULL) && (object->flags & OBJ_DEAD)) {
 		tsleep(object, PVM, "vadead", 0);
+	}
 
-	pager = NULL;
-	if (object != NULL)
-		pager = object->pager;
-	if (pager == NULL) {
-
-		/*
-		 * Allocate pager structures
-		 */
-		pager = (vm_pager_t) malloc(sizeof *pager, M_VMPAGER, M_WAITOK);
-		vnp = (vn_pager_t) malloc(sizeof *vnp, M_VMPGDATA, M_WAITOK);
-
+	if (object == NULL) {
 		/*
 		 * And an object of the appropriate size
 		 */
-		object = vm_object_allocate(round_page(size));
+		object = vm_object_allocate(OBJT_VNODE, round_page(size));
 		object->flags = OBJ_CANPERSIST;
-		vm_object_enter(object, pager);
-		object->pager = pager;
 
 		/*
-		 * Hold a reference to the vnode and initialize pager data.
+		 * Hold a reference to the vnode and initialize object data.
 		 */
 		VREF(vp);
-		vnp->vnp_flags = 0;
-		vnp->vnp_vp = vp;
-		vnp->vnp_size = size;
-
-		TAILQ_INSERT_TAIL(&vnode_pager_list, pager, pg_list);
-		pager->pg_handle = handle;
-		pager->pg_type = PG_VNODE;
-		pager->pg_ops = &vnodepagerops;
-		pager->pg_data = (caddr_t) vnp;
-		vp->v_object = (caddr_t) object;
-	} else {
+		object->un_pager.vnp.vnp_size = size;
 
+		object->handle = handle;
+		vp->v_object = object;
+	} else {
 		/*
-		 * vm_object_lookup() will remove the object from the cache if
-		 * found and also gain a reference to the object.
+		 * vm_object_reference() will remove the object from the cache if
+		 * found and gain a reference to the object.
 		 */
-		(void) vm_object_lookup(pager);
+		vm_object_reference(object);
 	}
 
 	if (vp->v_type == VREG)
@@ -202,134 +147,97 @@ vnode_pager_alloc(handle, size, prot, offset)
 		vp->v_flag &= ~VOWANT;
 		wakeup(vp);
 	}
-	return (pager);
+	return (object);
 }
 
 void
-vnode_pager_dealloc(pager)
-	vm_pager_t pager;
-{
-	register vn_pager_t vnp = (vn_pager_t) pager->pg_data;
-	register struct vnode *vp;
+vnode_pager_dealloc(object)
 	vm_object_t object;
+{
+	register struct vnode *vp = object->handle;
 
-	vp = vnp->vnp_vp;
-	if (vp) {
-		int s = splbio();
+	if (vp == NULL)
+		panic("vnode_pager_dealloc: pager already dealloced");
 
-		object = vp->v_object;
-		if (object) {
-			while (object->paging_in_progress) {
-				object->flags |= OBJ_PIPWNT;
-				tsleep(object, PVM, "vnpdea", 0);
-			}
+	if (object->paging_in_progress) {
+		int s = splbio();
+		while (object->paging_in_progress) {
+			object->flags |= OBJ_PIPWNT;
+			tsleep(object, PVM, "vnpdea", 0);
 		}
 		splx(s);
-
-		vp->v_object = NULL;
-		vp->v_flag &= ~(VTEXT | VVMIO);
-		vp->v_flag |= VAGE;
-		vrele(vp);
 	}
-	TAILQ_REMOVE(&vnode_pager_list, pager, pg_list);
-	free((caddr_t) vnp, M_VMPGDATA);
-	free((caddr_t) pager, M_VMPAGER);
-}
-
-int
-vnode_pager_getmulti(pager, m, count, reqpage, sync)
-	vm_pager_t pager;
-	vm_page_t *m;
-	int count;
-	int reqpage;
-	boolean_t sync;
-{
 
-	return vnode_pager_input((vn_pager_t) pager->pg_data, m, count, reqpage);
-}
-
-int
-vnode_pager_getpage(pager, m, sync)
-	vm_pager_t pager;
-	vm_page_t m;
-	boolean_t sync;
-{
+	object->handle = NULL;
 
-	vm_page_t marray[1];
-
-	if (pager == NULL)
-		return FALSE;
-	marray[0] = m;
-
-	return vnode_pager_input((vn_pager_t) pager->pg_data, marray, 1, 0);
-}
-
-boolean_t
-vnode_pager_putpage(pager, m, sync)
-	vm_pager_t pager;
-	vm_page_t m;
-	boolean_t sync;
-{
-	vm_page_t marray[1];
-	int rtvals[1];
-
-	if (pager == NULL)
-		return FALSE;
-	marray[0] = m;
-	vnode_pager_output((vn_pager_t) pager->pg_data, marray, 1, rtvals);
-	return rtvals[0];
-}
-
-int
-vnode_pager_putmulti(pager, m, c, sync, rtvals)
-	vm_pager_t pager;
-	vm_page_t *m;
-	int c;
-	boolean_t sync;
-	int *rtvals;
-{
-	return vnode_pager_output((vn_pager_t) pager->pg_data, m, c, rtvals);
+	vp->v_object = NULL;
+	vp->v_flag &= ~(VTEXT | VVMIO);
+	vp->v_flag |= VAGE;
+	vrele(vp);
 }
 
-
 boolean_t
-vnode_pager_haspage(pager, offset)
-	vm_pager_t pager;
+vnode_pager_haspage(object, offset, before, after)
+	vm_object_t object;
 	vm_offset_t offset;
+	int *before;
+	int *after;
 {
-	register vn_pager_t vnp = (vn_pager_t) pager->pg_data;
-	register struct vnode *vp = vnp->vnp_vp;
+	struct vnode *vp = object->handle;
 	daddr_t bn;
-	int err;
-	daddr_t block;
+	int err, run;
+	daddr_t startblock, reqblock;
 
 	/*
 	 * If filesystem no longer mounted or offset beyond end of file we do
 	 * not have the page.
 	 */
-	if ((vp->v_mount == NULL) || (offset >= vnp->vnp_size))
+	if ((vp->v_mount == NULL) || (offset >= object->un_pager.vnp.vnp_size))
 		return FALSE;
 
-	block = offset / vp->v_mount->mnt_stat.f_iosize;
-	if (incore(vp, block))
-		return TRUE;
+	startblock = reqblock = offset / vp->v_mount->mnt_stat.f_iosize;
+	if (startblock > PFCLUSTER_BEHIND)
+		startblock -= PFCLUSTER_BEHIND;
+	else
+		startblock = 0;;
 
-	/*
-	 * Read the index to find the disk block to read from.  If there is no
-	 * block, report that we don't have this data.
-	 *
-	 * Assumes that the vnode has whole page or nothing.
-	 */
-	err = VOP_BMAP(vp, block, (struct vnode **) 0, &bn, 0);
+	if (before != NULL) {
+		/*
+		 * Loop looking for a contiguous chunk that includes the
+		 * requested page.
+		 */
+		while (TRUE) {
+			err = VOP_BMAP(vp, startblock, (struct vnode **) 0, &bn, &run);
+			if (err || bn == -1) {
+				if (startblock < reqblock) {
+					startblock++;
+					continue;
+				}
+				*before = 0;
+				if (after != NULL)
+					*after = 0;
+				return err ? TRUE : FALSE;
+			}
+			if ((startblock + run) < reqblock) {
+				startblock += run + 1;
+				continue;
+			}
+			*before = reqblock - startblock;
+			if (after != NULL)
+				*after = run;
+			return TRUE;
+		}
+	}
+
+	err = VOP_BMAP(vp, reqblock, (struct vnode **) 0, &bn, after);
 	if (err)
-		return (TRUE);
+		return TRUE;
 	return ((long) bn < 0 ? FALSE : TRUE);
 }
 
 /*
  * Lets the VM system know about a change in size for a file.
- * If this vnode is mapped into some address space (i.e. we have a pager
- * for it) we adjust our own internal size and flush any cached pages in
+ * We adjust our own internal size and flush any cached pages in
  * the associated object that are affected by the size change.
  *
  * Note: this routine may be invoked as a result of a pager put
@@ -340,37 +248,24 @@ vnode_pager_setsize(vp, nsize)
 	struct vnode *vp;
 	u_long nsize;
 {
-	register vn_pager_t vnp;
-	register vm_object_t object;
-	vm_pager_t pager;
+	vm_object_t object = vp->v_object;
 
-	/*
-	 * Not a mapped vnode
-	 */
-	if (vp == NULL || vp->v_type != VREG || vp->v_object == NULL)
+	if (object == NULL)
 		return;
 
 	/*
 	 * Hasn't changed size
 	 */
-	object = vp->v_object;
-	if (object == NULL)
-		return;
-	if ((pager = object->pager) == NULL)
-		return;
-	vnp = (vn_pager_t) pager->pg_data;
-	if (nsize == vnp->vnp_size)
+	if (nsize == object->un_pager.vnp.vnp_size)
 		return;
 
 	/*
 	 * File has shrunk. Toss any cached pages beyond the new EOF.
 	 */
-	if (nsize < vnp->vnp_size) {
-		if (round_page((vm_offset_t) nsize) < vnp->vnp_size) {
-			vm_object_lock(object);
+	if (nsize < object->un_pager.vnp.vnp_size) {
+		if (round_page((vm_offset_t) nsize) < object->un_pager.vnp.vnp_size) {
 			vm_object_page_remove(object,
-			    round_page((vm_offset_t) nsize), vnp->vnp_size, FALSE);
-			vm_object_unlock(object);
+			    round_page((vm_offset_t) nsize), object->un_pager.vnp.vnp_size, FALSE);
 		}
 		/*
 		 * this gets rid of garbage at the end of a page that is now
@@ -389,7 +284,7 @@ vnode_pager_setsize(vp, nsize)
 			}
 		}
 	}
-	vnp->vnp_size = (vm_offset_t) nsize;
+	object->un_pager.vnp.vnp_size = (vm_offset_t) nsize;
 	object->size = round_page(nsize);
 }
 
@@ -397,19 +292,26 @@ void
 vnode_pager_umount(mp)
 	register struct mount *mp;
 {
-	register vm_pager_t pager, npager;
-	struct vnode *vp;
+	struct vnode *vp, *nvp;
+
+loop:
+	for (vp = mp->mnt_vnodelist.lh_first; vp != NULL; vp = nvp) {
+		/*
+		 * Vnode can be reclaimed by getnewvnode() while we
+		 * traverse the list.
+		 */
+		if (vp->v_mount != mp)
+			goto loop;
 
-	for (pager = vnode_pager_list.tqh_first; pager != NULL; pager = npager) {
 		/*
 		 * Save the next pointer now since uncaching may terminate the
-		 * object and render pager invalid
+		 * object and render vnode invalid
 		 */
-		npager = pager->pg_list.tqe_next;
-		vp = ((vn_pager_t) pager->pg_data)->vnp_vp;
-		if (mp == (struct mount *) 0 || vp->v_mount == mp) {
+		nvp = vp->v_mntvnodes.le_next;
+
+		if (vp->v_object != NULL) {
 			VOP_LOCK(vp);
-			(void) vnode_pager_uncache(vp);
+			vnode_pager_uncache(vp);
 			VOP_UNLOCK(vp);
 		}
 	}
@@ -424,46 +326,24 @@ vnode_pager_umount(mp)
  * destruction which may initiate paging activity which may necessitate
  * re-locking the vnode.
  */
-boolean_t
+void
 vnode_pager_uncache(vp)
-	register struct vnode *vp;
+	struct vnode *vp;
 {
-	register vm_object_t object;
-	boolean_t uncached;
-	vm_pager_t pager;
+	vm_object_t object;
 
 	/*
 	 * Not a mapped vnode
 	 */
 	object = vp->v_object;
 	if (object == NULL)
-		return (TRUE);
-
-	pager = object->pager;
-	if (pager == NULL)
-		return (TRUE);
-
-#ifdef DEBUG
-	if (!VOP_ISLOCKED(vp)) {
-		extern int (**nfsv2_vnodeop_p)();
+		return;
 
-		if (vp->v_op != nfsv2_vnodeop_p)
-			panic("vnode_pager_uncache: vnode not locked!");
-	}
-#endif
-	/*
-	 * Must use vm_object_lookup() as it actually removes the object from
-	 * the cache list.
-	 */
-	object = vm_object_lookup(pager);
-	if (object) {
-		uncached = (object->ref_count <= 1);
-		VOP_UNLOCK(vp);
-		pager_cache(object, FALSE);
-		VOP_LOCK(vp);
-	} else
-		uncached = TRUE;
-	return (uncached);
+	vm_object_reference(object);
+	VOP_UNLOCK(vp);
+	pager_cache(object, FALSE);
+	VOP_LOCK(vp);
+	return;
 }
 
 
@@ -523,15 +403,15 @@ vnode_pager_iodone(bp)
 	struct buf *bp;
 {
 	bp->b_flags |= B_DONE;
-	wakeup((caddr_t) bp);
+	wakeup(bp);
 }
 
 /*
  * small block file system vnode pager input
  */
 int
-vnode_pager_input_smlfs(vnp, m)
-	vn_pager_t vnp;
+vnode_pager_input_smlfs(object, m)
+	vm_object_t object;
 	vm_page_t m;
 {
 	int i;
@@ -540,11 +420,10 @@ vnode_pager_input_smlfs(vnp, m)
 	struct buf *bp;
 	vm_offset_t kva;
 	int fileaddr;
-	int block;
 	vm_offset_t bsize;
 	int error = 0;
 
-	vp = vnp->vnp_vp;
+	vp = object->handle;
 	bsize = vp->v_mount->mnt_stat.f_iosize;
 
 
@@ -602,7 +481,6 @@ vnode_pager_input_smlfs(vnp, m)
 			vm_page_set_clean(m, (i * bsize) & (PAGE_SIZE-1), bsize);
 			bzero((caddr_t) kva + i * bsize, bsize);
 		}
-nextblock:
 	}
 	vm_pager_unmap_page(kva);
 	pmap_clear_modify(VM_PAGE_TO_PHYS(m));
@@ -618,8 +496,8 @@ nextblock:
  * old style vnode pager output routine
  */
 int
-vnode_pager_input_old(vnp, m)
-	vn_pager_t vnp;
+vnode_pager_input_old(object, m)
+	vm_object_t object;
 	vm_page_t m;
 {
 	struct uio auio;
@@ -633,12 +511,12 @@ vnode_pager_input_old(vnp, m)
 	/*
 	 * Return failure if beyond current EOF
 	 */
-	if (m->offset >= vnp->vnp_size) {
+	if (m->offset >= object->un_pager.vnp.vnp_size) {
 		return VM_PAGER_BAD;
 	} else {
 		size = PAGE_SIZE;
-		if (m->offset + size > vnp->vnp_size)
-			size = vnp->vnp_size - m->offset;
+		if (m->offset + size > object->un_pager.vnp.vnp_size)
+			size = object->un_pager.vnp.vnp_size - m->offset;
 
 		/*
 		 * Allocate a kernel virtual address and initialize so that
@@ -656,7 +534,7 @@ vnode_pager_input_old(vnp, m)
 		auio.uio_resid = size;
 		auio.uio_procp = (struct proc *) 0;
 
-		error = VOP_READ(vnp->vnp_vp, &auio, 0, curproc->p_ucred);
+		error = VOP_READ(object->handle, &auio, 0, curproc->p_ucred);
 		if (!error) {
 			register int count = size - auio.uio_resid;
 
@@ -676,34 +554,22 @@ vnode_pager_input_old(vnp, m)
  * generic vnode pager input routine
  */
 int
-vnode_pager_input(vnp, m, count, reqpage)
-	register vn_pager_t vnp;
+vnode_pager_getpages(object, m, count, reqpage)
+	vm_object_t object;
 	vm_page_t *m;
-	int count, reqpage;
+	int count;
+	int reqpage;
 {
-	int i;
 	vm_offset_t kva, foff;
-	int size;
-	vm_object_t object;
+	int i, size, bsize, first, firstaddr;
 	struct vnode *dp, *vp;
-	int bsize;
-
-	int first, last;
-	int firstaddr;
-	int block, offset;
 	int runpg;
 	int runend;
-
 	struct buf *bp;
 	int s;
-	int failflag;
-
 	int error = 0;
 
-	object = m[reqpage]->object;	/* all vm_page_t items are in same
-					 * object */
-
-	vp = vnp->vnp_vp;
+	vp = object->handle;
 	bsize = vp->v_mount->mnt_stat.f_iosize;
 
 	/* get the UNDERLYING device for the file with VOP_BMAP() */
@@ -725,7 +591,7 @@ vnode_pager_input(vnp, m, count, reqpage)
 		}
 		cnt.v_vnodein++;
 		cnt.v_vnodepgsin++;
-		return vnode_pager_input_old(vnp, m[reqpage]);
+		return vnode_pager_input_old(object, m[reqpage]);
 
 		/*
 		 * if the blocksize is smaller than a page size, then use
@@ -742,7 +608,7 @@ vnode_pager_input(vnp, m, count, reqpage)
 		}
 		cnt.v_vnodein++;
 		cnt.v_vnodepgsin++;
-		return vnode_pager_input_smlfs(vnp, m[reqpage]);
+		return vnode_pager_input_smlfs(object, m[reqpage]);
 	}
 	/*
 	 * if ANY DEV_BSIZE blocks are valid on a large filesystem block
@@ -768,10 +634,9 @@ vnode_pager_input(vnp, m, count, reqpage)
 	for(first = 0, i = 0; i < count; i = runend) {
 		firstaddr = vnode_pager_addr(vp, m[i]->offset, &runpg);
 		if (firstaddr == -1) {
-			if( i == reqpage && foff < vnp->vnp_size) {
-				printf("vnode_pager_input: unexpected missing page: firstaddr: %d, foff: %d, vnp_size: %d\n",
-			   	 firstaddr, foff, vnp->vnp_size);
-				panic("vnode_pager_input:...");
+			if (i == reqpage && foff < object->un_pager.vnp.vnp_size) {
+				panic("vnode_pager_putpages: unexpected missing page: firstaddr: %d, foff: %ld, vnp_size: %d",
+			   	 firstaddr, foff, object->un_pager.vnp.vnp_size);
 			}
 			vnode_pager_freepage(m[i]);
 			runend = i + 1;
@@ -779,14 +644,14 @@ vnode_pager_input(vnp, m, count, reqpage)
 			continue;
 		}
 		runend = i + runpg;
-		if( runend <= reqpage) {
+		if (runend <= reqpage) {
 			int j;
-			for(j = i; j < runend; j++) {
+			for (j = i; j < runend; j++) {
 				vnode_pager_freepage(m[j]);
 			}
 		} else {
-			if( runpg < (count - first)) {
-				for(i=first + runpg; i < count; i++)
+			if (runpg < (count - first)) {
+				for (i = first + runpg; i < count; i++)
 					vnode_pager_freepage(m[i]);
 				count = first + runpg;
 			}
@@ -816,8 +681,8 @@ vnode_pager_input(vnp, m, count, reqpage)
 	 * calculate the size of the transfer
 	 */
 	size = count * PAGE_SIZE;
-	if ((foff + size) > vnp->vnp_size)
-		size = vnp->vnp_size - foff;
+	if ((foff + size) > object->un_pager.vnp.vnp_size)
+		size = object->un_pager.vnp.vnp_size - foff;
 
 	/*
 	 * round up physical size for real devices
@@ -875,7 +740,6 @@ vnode_pager_input(vnp, m, count, reqpage)
 	 */
 	relpbuf(bp);
 
-finishup:
 	for (i = 0; i < count; i++) {
 		pmap_clear_modify(VM_PAGE_TO_PHYS(m[i]));
 		m[i]->dirty = 0;
@@ -903,7 +767,7 @@ finishup:
 		}
 	}
 	if (error) {
-		printf("vnode_pager_input: I/O read error\n");
+		printf("vnode_pager_getpages: I/O read error\n");
 	}
 	return (error ? VM_PAGER_ERROR : VM_PAGER_OK);
 }
@@ -912,10 +776,11 @@ finishup:
  * generic vnode pager output routine
  */
 int
-vnode_pager_output(vnp, m, count, rtvals)
-	vn_pager_t vnp;
+vnode_pager_putpages(object, m, count, sync, rtvals)
+	vm_object_t object;
 	vm_page_t *m;
 	int count;
+	boolean_t sync;
 	int *rtvals;
 {
 	int i;
@@ -926,12 +791,12 @@ vnode_pager_output(vnp, m, count, rtvals)
 	struct iovec aiov;
 	int error;
 
-	vp = vnp->vnp_vp;
+	vp = object->handle;;
 	for (i = 0; i < count; i++)
 		rtvals[i] = VM_PAGER_AGAIN;
 
 	if ((int) m[0]->offset < 0) {
-		printf("vnode_pager_output: attempt to write meta-data!!! -- 0x%x(%x)\n", m[0]->offset, m[0]->dirty);
+		printf("vnode_pager_putpages: attempt to write meta-data!!! -- 0x%x(%x)\n", m[0]->offset, m[0]->dirty);
 		rtvals[0] = VM_PAGER_BAD;
 		return VM_PAGER_BAD;
 	}
@@ -939,9 +804,9 @@ vnode_pager_output(vnp, m, count, rtvals)
 	maxsize = count * PAGE_SIZE;
 	ncount = count;
 
-	if (maxsize + m[0]->offset > vnp->vnp_size) {
-		if (vnp->vnp_size > m[0]->offset)
-			maxsize = vnp->vnp_size - m[0]->offset;
+	if (maxsize + m[0]->offset > object->un_pager.vnp.vnp_size) {
+		if (object->un_pager.vnp.vnp_size > m[0]->offset)
+			maxsize = object->un_pager.vnp.vnp_size - m[0]->offset;
 		else
 			maxsize = 0;
 		ncount = (maxsize + PAGE_SIZE - 1) / PAGE_SIZE;
@@ -950,8 +815,8 @@ vnode_pager_output(vnp, m, count, rtvals)
 				rtvals[i] = VM_PAGER_BAD;
 			}
 			if (ncount == 0) {
-				printf("vnode_pager_output: write past end of file: %d, %d\n",
-					m[0]->offset, vnp->vnp_size);
+				printf("vnode_pager_putpages: write past end of file: %d, %d\n",
+					m[0]->offset, object->un_pager.vnp.vnp_size);
 				return rtvals[0];
 			}
 		}
@@ -976,10 +841,10 @@ vnode_pager_output(vnp, m, count, rtvals)
 	cnt.v_vnodepgsout += ncount;
 
 	if (error) {
-		printf("vnode_pager_output: I/O error %d\n", error);
+		printf("vnode_pager_putpages: I/O error %d\n", error);
 	}
 	if (auio.uio_resid) {
-		printf("vnode_pager_output: residual I/O %d at %d\n", auio.uio_resid, m[0]->offset);
+		printf("vnode_pager_putpages: residual I/O %d at %d\n", auio.uio_resid, m[0]->offset);
 	}
 	for (i = 0; i < count; i++) {
 		m[i]->busy--;
@@ -987,28 +852,21 @@ vnode_pager_output(vnp, m, count, rtvals)
 			rtvals[i] = VM_PAGER_OK;
 		}
 		if ((m[i]->busy == 0) && (m[i]->flags & PG_WANTED))
-			wakeup((caddr_t) m[i]);
+			wakeup(m[i]);
 	}
 	return rtvals[0];
 }
 
 struct vnode *
-vnode_pager_lock(vm_object_t object) {
-
-	for(;object;object=object->shadow) {
-		vn_pager_t vnp;
-		if( !object->pager || (object->pager->pg_type != PG_VNODE))
+vnode_pager_lock(object)
+	vm_object_t object;
+{
+	for (; object != NULL; object = object->backing_object) {
+		if (object->type != OBJT_VNODE)
 			continue;
 
-		vnp = (vn_pager_t) object->pager->pg_data;
-		VOP_LOCK(vnp->vnp_vp);
-		return vnp->vnp_vp;
+		VOP_LOCK(object->handle);
+		return object->handle;
 	}
-	return (struct vnode *)NULL;
+	return NULL;
 }
-
-void
-vnode_pager_unlock(struct vnode *vp) {
-	VOP_UNLOCK(vp);
-}
-