Merge in the unified buffer cache code as found in NetBSD 2001/03/10. The

code is written mostly by Chuck Silvers <chuq@chuq.com>/<chs@netbsd.org>.

Tested for the past few weeks by many developers, should be in a pretty stable
state, but will require optimizations and additional cleanups.

72 files changed, 4246 insertions, 2516 deletions

diff --git a/sys/adosfs/advnops.c b/sys/adosfs/advnops.c
index 78d237f41e5..19bfdcc5738 100644
--- a/sys/adosfs/advnops.c
+++ b/sys/adosfs/advnops.c
@@ -1,4 +1,4 @@
-/*	$OpenBSD: advnops.c,v 1.17 2001/06/23 02:14:21 csapuntz Exp $	*/
+/*	$OpenBSD: advnops.c,v 1.18 2001/11/27 05:27:11 art Exp $	*/
 /*	$NetBSD: advnops.c,v 1.32 1996/10/13 02:52:09 christos Exp $	*/
 
 /*
@@ -131,7 +131,9 @@ struct vnodeopv_entry_desc adosfs_vnodeop_entries[] = {
 	{ &vop_pathconf_desc, adosfs_pathconf },	/* pathconf */
 	{ &vop_advlock_desc, adosfs_advlock },		/* advlock */
 	{ &vop_bwrite_desc, adosfs_bwrite },		/* bwrite */
-	{ (struct vnodeop_desc*)NULL, (int(*) __P((void *)))NULL }
+	{ &vop_getpages_desc, genfs_getpages },
+	{ &vop_size_desc, genfs_size },
+	{ NULL, NULL }
 };
 
 struct vnodeopv_desc adosfs_vnodeop_opv_desc =
@@ -272,6 +274,28 @@ adosfs_read(v)
 	/*
 	 * taken from ufs_read()
 	 */
+
+	if (sp->a_vp->v_type == VREG) {
+		error = 0;
+		while (uio->uio_resid > 0) {
+			void *win;
+			vsize_t bytelen = min(ap->fsize - uio->uio_offset,
+					uio->uio_resid);
+
+			if (bytelen == 0) {
+				break;
+			}
+			win = ubc_alloc(&sp->a_vp->v_uvm.u_obj, uio->uio_offset,
+					&bytelen, UBC_READ);
+			error = uiomove(win, bytelen, uio);
+			ubc_release(win, 0);
+			if (error) {
+				break;
+			}
+		}
+		goto reterr;
+	}
+
 	do {
 		/*
 		 * we are only supporting ADosFFS currently
diff --git a/sys/arch/alpha/alpha/pmap.c b/sys/arch/alpha/alpha/pmap.c
index 9ff390da8c2..1d50a35d446 100644
--- a/sys/arch/alpha/alpha/pmap.c
+++ b/sys/arch/alpha/alpha/pmap.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: pmap.c,v 1.23 2001/11/09 15:31:11 art Exp $ */
+/* $OpenBSD: pmap.c,v 1.24 2001/11/27 05:27:11 art Exp $ */
 /* $NetBSD: pmap.c,v 1.154 2000/12/07 22:18:55 thorpej Exp $ */
 
 /*-
@@ -804,8 +804,8 @@ pmap_bootstrap(paddr_t ptaddr, u_int maxasn, u_long ncpuids)
 	/*
 	 * Figure out how many PTE's are necessary to map the kernel.
 	 */
-	lev3mapsize = (VM_PHYS_SIZE +
-		nbuf * MAXBSIZE + + PAGER_MAP_SIZE + 16 * NCARGS) / NBPG +
+	lev3mapsize = (VM_PHYS_SIZE + ubc_nwins * ubc_winsize +
+		nbuf * MAXBSIZE + 16 * NCARGS + PAGER_MAP_SIZE) / NBPG +
 		(maxproc * UPAGES) + NKMEMCLUSTERS;
 
 #ifdef SYSVSHM
diff --git a/sys/arch/i386/i386/vm_machdep.c b/sys/arch/i386/i386/vm_machdep.c
index 516dea6ebea..7de82391532 100644
--- a/sys/arch/i386/i386/vm_machdep.c
+++ b/sys/arch/i386/i386/vm_machdep.c
@@ -1,4 +1,4 @@
-/*	$OpenBSD: vm_machdep.c,v 1.32 2001/11/06 19:53:14 miod Exp $	*/
+/*	$OpenBSD: vm_machdep.c,v 1.33 2001/11/27 05:27:11 art Exp $	*/
 /*	$NetBSD: vm_machdep.c,v 1.61 1996/05/03 19:42:35 christos Exp $	*/
 
 /*-
@@ -371,9 +371,7 @@ vmapbuf(bp, len)
 	while (len) {
 		pmap_extract(vm_map_pmap(&bp->b_proc->p_vmspace->vm_map),
 		    faddr, &fpa);
-		pmap_enter(vm_map_pmap(phys_map), taddr, fpa,
-		    VM_PROT_READ | VM_PROT_WRITE,
-		    VM_PROT_READ | VM_PROT_WRITE | PMAP_WIRED);
+		pmap_kenter_pa(taddr, fpa, VM_PROT_READ|VM_PROT_WRITE);
 		faddr += PAGE_SIZE;
 		taddr += PAGE_SIZE;
 		len -= PAGE_SIZE;
@@ -396,6 +394,7 @@ vunmapbuf(bp, len)
 	addr = trunc_page((vaddr_t)bp->b_data);
 	off = (vm_offset_t)bp->b_data - addr;
 	len = round_page(off + len);
+	pmap_kremove(addr, len);
 	uvm_km_free_wakeup(phys_map, addr, len);
 	bp->b_data = bp->b_saveaddr;
 	bp->b_saveaddr = 0;
diff --git a/sys/conf/files b/sys/conf/files
index a6ce3bcedb0..0ec11fc5bbb 100644
--- a/sys/conf/files
+++ b/sys/conf/files
@@ -1,4 +1,4 @@
-#	$OpenBSD: files,v 1.230 2001/11/21 21:23:56 csapuntz Exp $
+#	$OpenBSD: files,v 1.231 2001/11/27 05:27:11 art Exp $
 #	$NetBSD: files,v 1.87 1996/05/19 17:17:50 jonathan Exp $
 
 #	@(#)files.newconf	7.5 (Berkeley) 5/10/93
@@ -801,6 +801,7 @@ file xfs/xfs_syscalls-dummy.c		!xfs
 file uvm/uvm_amap.c
 file uvm/uvm_anon.c
 file uvm/uvm_aobj.c
+file uvm/uvm_bio.c
 file uvm/uvm_device.c
 file uvm/uvm_fault.c
 file uvm/uvm_glue.c
diff --git a/sys/dev/vnd.c b/sys/dev/vnd.c
index b2935e0edba..6f8c268a283 100644
--- a/sys/dev/vnd.c
+++ b/sys/dev/vnd.c
@@ -1,4 +1,4 @@
-/*	$OpenBSD: vnd.c,v 1.28 2001/11/15 23:15:15 art Exp $	*/
+/*	$OpenBSD: vnd.c,v 1.29 2001/11/27 05:27:11 art Exp $	*/
 /*	$NetBSD: vnd.c,v 1.26 1996/03/30 23:06:11 christos Exp $	*/
 
 /*
@@ -558,10 +558,6 @@ vndstrategy(bp)
 		nbp->vb_buf.b_proc = bp->b_proc;
 		nbp->vb_buf.b_iodone = vndiodone;
 		nbp->vb_buf.b_vp = vp;
-		nbp->vb_buf.b_dirtyoff = bp->b_dirtyoff;
-		nbp->vb_buf.b_dirtyend = bp->b_dirtyend;
-		nbp->vb_buf.b_validoff = bp->b_validoff;
-		nbp->vb_buf.b_validend = bp->b_validend;
 		LIST_INIT(&nbp->vb_buf.b_dep);
 
 		/* save a reference to the old buffer */
diff --git a/sys/isofs/cd9660/cd9660_vfsops.c b/sys/isofs/cd9660/cd9660_vfsops.c
index b4199c4df15..b2b1455e6eb 100644
--- a/sys/isofs/cd9660/cd9660_vfsops.c
+++ b/sys/isofs/cd9660/cd9660_vfsops.c
@@ -1,4 +1,4 @@
-/*	$OpenBSD: cd9660_vfsops.c,v 1.24 2001/11/15 08:27:28 art Exp $	*/
+/*	$OpenBSD: cd9660_vfsops.c,v 1.25 2001/11/27 05:27:11 art Exp $	*/
 /*	$NetBSD: cd9660_vfsops.c,v 1.26 1997/06/13 15:38:58 pk Exp $	*/
 
 /*-
@@ -359,6 +359,8 @@ iso_mountfs(devvp, mp, p, argp)
 	mp->mnt_stat.f_fsid.val[1] = mp->mnt_vfc->vfc_typenum;
 	mp->mnt_maxsymlinklen = 0;
 	mp->mnt_flag |= MNT_LOCAL;
+	mp->mnt_dev_bshift = iso_bsize;
+	mp->mnt_fs_bshift = isomp->im_bshift;
 	isomp->im_mountp = mp;
 	isomp->im_dev = dev;
 	isomp->im_devvp = devvp;
diff --git a/sys/isofs/cd9660/cd9660_vnops.c b/sys/isofs/cd9660/cd9660_vnops.c
index 5f05dc9d65f..cd5567a77b4 100644
--- a/sys/isofs/cd9660/cd9660_vnops.c
+++ b/sys/isofs/cd9660/cd9660_vnops.c
@@ -1,4 +1,4 @@
-/*	$OpenBSD: cd9660_vnops.c,v 1.14 2001/06/23 02:14:23 csapuntz Exp $	*/
+/*	$OpenBSD: cd9660_vnops.c,v 1.15 2001/11/27 05:27:11 art Exp $	*/
 /*	$NetBSD: cd9660_vnops.c,v 1.42 1997/10/16 23:56:57 christos Exp $	*/
 
 /*-
@@ -314,9 +314,9 @@ cd9660_read(v)
 		struct ucred *a_cred;
 	} */ *ap = v;
 	struct vnode *vp = ap->a_vp;
-	register struct uio *uio = ap->a_uio;
-	register struct iso_node *ip = VTOI(vp);
-	register struct iso_mnt *imp;
+	struct uio *uio = ap->a_uio;
+	struct iso_node *ip = VTOI(vp);
+	struct iso_mnt *imp;
 	struct buf *bp;
 	daddr_t lbn, rablock;
 	off_t diff;
@@ -329,6 +329,26 @@ cd9660_read(v)
 		return (EINVAL);
 	ip->i_flag |= IN_ACCESS;
 	imp = ip->i_mnt;
+
+	if (vp->v_type == VREG) {
+		error = 0;
+		while (uio->uio_resid > 0) {
+			void *win;
+			vsize_t bytelen = MIN(ip->i_size - uio->uio_offset,
+					uio->uio_resid);
+
+			if (bytelen == 0)
+				break;
+			win = ubc_alloc(&vp->v_uvm.u_obj, uio->uio_offset,
+					&bytelen, UBC_READ);
+			error = uiomove(win, bytelen, uio);
+			ubc_release(win, 0);
+			if (error)
+				break;
+		}
+		goto out;
+	}
+
 	do {
 		lbn = lblkno(imp, uio->uio_offset);
 		on = blkoff(imp, uio->uio_offset);
@@ -370,6 +390,8 @@ cd9660_read(v)
 			bp->b_flags |= B_AGE;
 		brelse(bp);
 	} while (error == 0 && uio->uio_resid > 0 && n != 0);
+
+out:
 	return (error);
 }
 
@@ -1045,7 +1067,9 @@ struct vnodeopv_entry_desc cd9660_vnodeop_entries[] = {
 	{ &vop_pathconf_desc, cd9660_pathconf },/* pathconf */
 	{ &vop_advlock_desc, cd9660_advlock },	/* advlock */
 	{ &vop_bwrite_desc, vop_generic_bwrite },
-	{ (struct vnodeop_desc*)NULL, (int(*) __P((void *)))NULL }
+	{ &vop_getpages_desc, genfs_getpages },
+	{ &vop_size_desc, genfs_size },
+	{ NULL, NULL }
 };
 struct vnodeopv_desc cd9660_vnodeop_opv_desc =
 	{ &cd9660_vnodeop_p, cd9660_vnodeop_entries };
diff --git a/sys/kern/exec_subr.c b/sys/kern/exec_subr.c
index 770a29f8adc..e79db64dcae 100644
--- a/sys/kern/exec_subr.c
+++ b/sys/kern/exec_subr.c
@@ -1,4 +1,4 @@
-/*	$OpenBSD: exec_subr.c,v 1.14 2001/11/07 01:18:01 art Exp $	*/
+/*	$OpenBSD: exec_subr.c,v 1.15 2001/11/27 05:27:11 art Exp $	*/
 /*	$NetBSD: exec_subr.c,v 1.9 1994/12/04 03:10:42 mycroft Exp $	*/
 
 /*
@@ -167,6 +167,7 @@ vmcmd_map_pagedvn(p, cmd)
 	uobj = uvn_attach((void *) cmd->ev_vp, VM_PROT_READ|VM_PROT_EXECUTE);
 	if (uobj == NULL)
 		return(ENOMEM);
+	VREF(cmd->ev_vp);
 
 	/*
 	 * do the map
diff --git a/sys/kern/init_main.c b/sys/kern/init_main.c
index c909a23141b..f807a181062 100644
--- a/sys/kern/init_main.c
+++ b/sys/kern/init_main.c
@@ -1,4 +1,4 @@
-/*	$OpenBSD: init_main.c,v 1.84 2001/11/10 18:42:31 art Exp $	*/
+/*	$OpenBSD: init_main.c,v 1.85 2001/11/27 05:27:11 art Exp $	*/
 /*	$NetBSD: init_main.c,v 1.84.4.1 1996/06/02 09:08:06 mrg Exp $	*/
 
 /*
@@ -217,6 +217,8 @@ main(framep)
 
 	cpu_configure();
 
+	ubc_init();		/* Initialize the unified buffer cache */
+
 	/* Initialize sysctls (must be done before any processes run) */
 	sysctl_init();
 
diff --git a/sys/kern/kern_exec.c b/sys/kern/kern_exec.c
index 2d12034b386..9f621da43d2 100644
--- a/sys/kern/kern_exec.c
+++ b/sys/kern/kern_exec.c
@@ -1,4 +1,4 @@
-/*	$OpenBSD: kern_exec.c,v 1.60 2001/11/12 01:26:09 art Exp $	*/
+/*	$OpenBSD: kern_exec.c,v 1.61 2001/11/27 05:27:11 art Exp $	*/
 /*	$NetBSD: kern_exec.c,v 1.75 1996/02/09 18:59:28 christos Exp $	*/
 
 /*-
@@ -150,6 +150,7 @@ check_exec(p, epp)
 		goto bad1;
 
 	/* now we have the file, get the exec header */
+	uvn_attach(vp, VM_PROT_READ);
 	error = vn_rdwr(UIO_READ, vp, epp->ep_hdr, epp->ep_hdrlen, 0,
 	    UIO_SYSSPACE, IO_NODELOCKED, p->p_ucred, &resid, p);
 	if (error)
diff --git a/sys/kern/vfs_bio.c b/sys/kern/vfs_bio.c
index 71674e95236..6f361c989c0 100644
--- a/sys/kern/vfs_bio.c
+++ b/sys/kern/vfs_bio.c
@@ -1,4 +1,4 @@
-/*	$OpenBSD: vfs_bio.c,v 1.51 2001/11/15 23:25:37 art Exp $	*/
+/*	$OpenBSD: vfs_bio.c,v 1.52 2001/11/27 05:27:11 art Exp $	*/
 /*	$NetBSD: vfs_bio.c,v 1.44 1996/06/11 11:15:36 pk Exp $	*/
 
 /*-
@@ -406,7 +406,6 @@ bwrite(bp)
 	/* Initiate disk write.  Make sure the appropriate party is charged. */
 	bp->b_vp->v_numoutput++;
 	splx(s);
-	SET(bp->b_flags, B_WRITEINPROG);
 	VOP_STRATEGY(bp);
 
 	if (async)
@@ -466,7 +465,6 @@ bdwrite(bp)
 	}
 
 	/* Otherwise, the "write" is done, so mark and release the buffer. */
-	CLR(bp->b_flags, B_NEEDCOMMIT);
 	SET(bp->b_flags, B_DONE);
 	brelse(bp);
 }
@@ -588,6 +586,7 @@ brelse(bp)
 
 	/* Unlock the buffer. */
 	CLR(bp->b_flags, (B_AGE | B_ASYNC | B_BUSY | B_NOCACHE | B_DEFERRED));
+	SET(bp->b_flags, B_CACHE);
 
 	/* Allow disk interrupts. */
 	splx(s);
@@ -651,44 +650,30 @@ getblk(vp, blkno, size, slpflag, slptimeo)
 	daddr_t blkno;
 	int size, slpflag, slptimeo;
 {
-	struct bufhashhdr *bh;
 	struct buf *bp, *nbp = NULL;
 	int s, err;
 
-	/*
-	 * XXX
-	 * The following is an inlined version of 'incore()', but with
-	 * the 'invalid' test moved to after the 'busy' test.  It's
-	 * necessary because there are some cases in which the NFS
-	 * code sets B_INVAL prior to writing data to the server, but
-	 * in which the buffers actually contain valid data.  In this
-	 * case, we can't allow the system to allocate a new buffer for
-	 * the block until the write is finished.
-	 */
-	bh = BUFHASH(vp, blkno);
 start:
-	bp = bh->lh_first;
-	for (; bp != NULL; bp = bp->b_hash.le_next) {
-		if (bp->b_lblkno != blkno || bp->b_vp != vp)
-			continue;
-
+	bp = incore(vp, blkno);
+	if (bp != NULL) {
 		s = splbio();
 		if (ISSET(bp->b_flags, B_BUSY)) {
 			SET(bp->b_flags, B_WANTED);
 			err = tsleep(bp, slpflag | (PRIBIO + 1), "getblk",
 			    slptimeo);
 			splx(s);
-			if (err)
+			if (err) {
+				if (nbp != NULL) {
+					SET(nbp->b_flags, B_AGE);
+					brelse(nbp);
+				}
 				return (NULL);
+			}
 			goto start;
 		}
 
-		if (!ISSET(bp->b_flags, B_INVAL)) {
-			SET(bp->b_flags, (B_BUSY | B_CACHE));
-			bremfree(bp);
-			splx(s);
-			break;
-		}
+		SET(bp->b_flags, (B_BUSY | B_CACHE));
+		bremfree(bp);
 		splx(s);
 	}
 
@@ -697,7 +682,7 @@ start:
 			goto start;
 		}
 		bp = nbp;
-		binshash(bp, bh);
+		binshash(bp, BUFHASH(vp, blkno));
 		bp->b_blkno = bp->b_lblkno = blkno;
 		s = splbio();
 		bgetvp(vp, bp);
@@ -900,8 +885,6 @@ start:
 	bp->b_error = 0;
 	bp->b_resid = 0;
 	bp->b_bcount = 0;
-	bp->b_dirtyoff = bp->b_dirtyend = 0;
-	bp->b_validoff = bp->b_validend = 0;
 
 	bremhash(bp);
 	*bpp = bp;
@@ -1022,7 +1005,6 @@ biodone(bp)
 		buf_complete(bp);
 
 	if (!ISSET(bp->b_flags, B_READ)) {
-		CLR(bp->b_flags, B_WRITEINPROG);
 		vwakeup(bp->b_vp);
 	}
 
diff --git a/sys/kern/vfs_default.c b/sys/kern/vfs_default.c
index 8f426b3a3f5..61f6d0217e9 100644
--- a/sys/kern/vfs_default.c
+++ b/sys/kern/vfs_default.c
@@ -1,10 +1,9 @@
-/*       $OpenBSD: vfs_default.c,v 1.7 2001/06/25 03:28:03 csapuntz Exp $  */
-
+/*       $OpenBSD: vfs_default.c,v 1.8 2001/11/27 05:27:12 art Exp $  */
 
 /*
  *    Portions of this code are:
  *
- * Copyright (c) 1989, 1993
+ * Copyright (c) 1982, 1986, 1989, 1993
  *	The Regents of the University of California.  All rights reserved.
  * (c) UNIX System Laboratories, Inc.
  * All or some portions of this file are derived from material licensed
@@ -49,9 +48,11 @@
 #include <sys/vnode.h>
 #include <sys/namei.h>
 #include <sys/malloc.h>
+#include <sys/pool.h>
 #include <sys/event.h>
 #include <miscfs/specfs/specdev.h>
 
+#include <uvm/uvm.h>
 
 extern struct simplelock spechash_slock;
 
@@ -310,3 +311,679 @@ lease_check(void *v)
 {
 	return (0);
 }
+
+/*
+ * generic VM getpages routine.
+ * Return PG_BUSY pages for the given range,
+ * reading from backing store if necessary.
+ */
+
+int
+genfs_getpages(v)
+	void *v;
+{
+	struct vop_getpages_args /* {
+		struct vnode *a_vp;
+		voff_t a_offset;
+		vm_page_t *a_m;
+		int *a_count;
+		int a_centeridx;
+		vm_prot_t a_access_type;
+		int a_advice;
+		int a_flags;
+	} */ *ap = v;
+
+	off_t newsize, diskeof, memeof;
+	off_t offset, origoffset, startoffset, endoffset, raoffset;
+	daddr_t lbn, blkno;
+	int s, i, error, npages, orignpages, npgs, run, ridx, pidx, pcount;
+	int fs_bshift, fs_bsize, dev_bshift, dev_bsize;
+	int flags = ap->a_flags;
+	size_t bytes, iobytes, tailbytes, totalbytes, skipbytes;
+	vaddr_t kva;
+	struct buf *bp, *mbp;
+	struct vnode *vp = ap->a_vp;
+	struct uvm_object *uobj = &vp->v_uvm.u_obj;
+	struct vm_page *pgs[16];			/* XXXUBC 16 */
+	struct ucred *cred = curproc->p_ucred;		/* XXXUBC curproc */
+	boolean_t async = (flags & PGO_SYNCIO) == 0;
+	boolean_t write = (ap->a_access_type & VM_PROT_WRITE) != 0;
+	boolean_t sawhole = FALSE;
+	struct proc *p = curproc;
+	UVMHIST_FUNC("genfs_getpages"); UVMHIST_CALLED(ubchist);
+
+	UVMHIST_LOG(ubchist, "vp %p off 0x%x/%x count %d",
+		    vp, ap->a_offset >> 32, ap->a_offset, *ap->a_count);
+
+	/* XXXUBC temp limit */
+	if (*ap->a_count > 16) {
+		return EINVAL;
+	}
+
+	error = 0;
+	origoffset = ap->a_offset;
+	orignpages = *ap->a_count;
+	error = VOP_SIZE(vp, vp->v_uvm.u_size, &diskeof);
+	if (error) {
+		return error;
+	}
+	if (flags & PGO_PASTEOF) {
+		newsize = MAX(vp->v_uvm.u_size,
+			      origoffset + (orignpages << PAGE_SHIFT));
+		error = VOP_SIZE(vp, newsize, &memeof);
+		if (error) {
+			return error;
+		}
+	} else {
+		memeof = diskeof;
+	}
+	KASSERT(ap->a_centeridx >= 0 || ap->a_centeridx <= orignpages);
+	KASSERT((origoffset & (PAGE_SIZE - 1)) == 0 && origoffset >= 0);
+	KASSERT(orignpages > 0);
+
+	/*
+	 * Bounds-check the request.
+	 */
+
+	if (origoffset + (ap->a_centeridx << PAGE_SHIFT) >= memeof) {
+		if ((flags & PGO_LOCKED) == 0) {
+			simple_unlock(&uobj->vmobjlock);
+		}
+		UVMHIST_LOG(ubchist, "off 0x%x count %d goes past EOF 0x%x",
+			    origoffset, *ap->a_count, memeof,0);
+		return EINVAL;
+	}
+
+	/*
+	 * For PGO_LOCKED requests, just return whatever's in memory.
+	 */
+
+	if (flags & PGO_LOCKED) {
+		uvn_findpages(uobj, origoffset, ap->a_count, ap->a_m,
+			      UFP_NOWAIT|UFP_NOALLOC|UFP_NORDONLY);
+
+		return ap->a_m[ap->a_centeridx] == NULL ? EBUSY : 0;
+	}
+
+	/* vnode is VOP_LOCKed, uobj is locked */
+
+	if (write && (vp->v_bioflag & VBIOONSYNCLIST) == 0) {
+		vn_syncer_add_to_worklist(vp, syncdelay);
+	}
+
+	/*
+	 * find the requested pages and make some simple checks.
+	 * leave space in the page array for a whole block.
+	 */
+
+	fs_bshift = vp->v_mount->mnt_fs_bshift;
+	fs_bsize = 1 << fs_bshift;
+	dev_bshift = vp->v_mount->mnt_dev_bshift;
+	dev_bsize = 1 << dev_bshift;
+	KASSERT((diskeof & (dev_bsize - 1)) == 0);
+	KASSERT((memeof & (dev_bsize - 1)) == 0);
+
+	orignpages = MIN(orignpages,
+	    round_page(memeof - origoffset) >> PAGE_SHIFT);
+	npages = orignpages;
+	startoffset = origoffset & ~(fs_bsize - 1);
+	endoffset = round_page((origoffset + (npages << PAGE_SHIFT)
+				+ fs_bsize - 1) & ~(fs_bsize - 1));
+	endoffset = MIN(endoffset, round_page(memeof));
+	ridx = (origoffset - startoffset) >> PAGE_SHIFT;
+
+	memset(pgs, 0, sizeof(pgs));
+	uvn_findpages(uobj, origoffset, &npages, &pgs[ridx], UFP_ALL);
+
+	/*
+	 * if PGO_OVERWRITE is set, don't bother reading the pages.
+	 * PGO_OVERWRITE also means that the caller guarantees
+	 * that the pages already have backing store allocated.
+	 */
+
+	if (flags & PGO_OVERWRITE) {
+		UVMHIST_LOG(ubchist, "PGO_OVERWRITE",0,0,0,0);
+
+		for (i = 0; i < npages; i++) {
+			struct vm_page *pg = pgs[ridx + i];
+
+			if (pg->flags & PG_FAKE) {
+				uvm_pagezero(pg);
+				pg->flags &= ~(PG_FAKE);
+			}
+			pg->flags &= ~(PG_RDONLY);
+		}
+		npages += ridx;
+		goto out;
+	}
+
+	/*
+	 * if the pages are already resident, just return them.
+	 */
+
+	for (i = 0; i < npages; i++) {
+		struct vm_page *pg = pgs[ridx + i];
+
+		if ((pg->flags & PG_FAKE) ||
+		    (write && (pg->flags & PG_RDONLY))) {
+			break;
+		}
+	}
+	if (i == npages) {
+		UVMHIST_LOG(ubchist, "returning cached pages", 0,0,0,0);
+		raoffset = origoffset + (orignpages << PAGE_SHIFT);
+		npages += ridx;
+		goto raout;
+	}
+
+	/*
+	 * the page wasn't resident and we're not overwriting,
+	 * so we're going to have to do some i/o.
+	 * find any additional pages needed to cover the expanded range.
+	 */
+
+	if (startoffset != origoffset) {
+
+		/*
+		 * XXXUBC we need to avoid deadlocks caused by locking
+		 * additional pages at lower offsets than pages we
+		 * already have locked.  for now, unlock them all and
+		 * start over.
+		 */
+
+		for (i = 0; i < npages; i++) {
+			struct vm_page *pg = pgs[ridx + i];
+
+			if (pg->flags & PG_FAKE) {
+				pg->flags |= PG_RELEASED;
+			}
+		}
+		uvm_page_unbusy(&pgs[ridx], npages);
+		memset(pgs, 0, sizeof(pgs));
+
+		UVMHIST_LOG(ubchist, "reset npages start 0x%x end 0x%x",
+			    startoffset, endoffset, 0,0);
+		npages = (endoffset - startoffset) >> PAGE_SHIFT;
+		npgs = npages;
+		uvn_findpages(uobj, startoffset, &npgs, pgs, UFP_ALL);
+	}
+	simple_unlock(&uobj->vmobjlock);
+
+	/*
+	 * read the desired page(s).
+	 */
+
+	totalbytes = npages << PAGE_SHIFT;
+	bytes = MIN(totalbytes, MAX(diskeof - startoffset, 0));
+	tailbytes = totalbytes - bytes;
+	skipbytes = 0;
+
+	kva = uvm_pagermapin(pgs, npages, UVMPAGER_MAPIN_WAITOK |
+			     UVMPAGER_MAPIN_READ);
+
+	s = splbio();
+	mbp = pool_get(&bufpool, PR_WAITOK);
+	splx(s);
+	mbp->b_bufsize = totalbytes;
+	mbp->b_data = (void *)kva;
+	mbp->b_resid = mbp->b_bcount = bytes;
+	mbp->b_flags = B_BUSY|B_READ| (async ? B_CALL : 0);
+	mbp->b_iodone = uvm_aio_biodone;
+	mbp->b_vp = vp;
+	LIST_INIT(&mbp->b_dep);
+
+	/*
+	 * if EOF is in the middle of the range, zero the part past EOF.
+	 */
+
+	if (tailbytes > 0) {
+		memset((void *)(kva + bytes), 0, tailbytes);
+	}
+
+	/*
+	 * now loop over the pages, reading as needed.
+	 */
+
+	if (write) {
+		lockmgr(&vp->v_glock, LK_EXCLUSIVE, NULL, p);
+	} else {
+		lockmgr(&vp->v_glock, LK_SHARED, NULL, p);
+	}
+
+	bp = NULL;
+	for (offset = startoffset;
+	     bytes > 0;
+	     offset += iobytes, bytes -= iobytes) {
+
+		/*
+		 * skip pages which don't need to be read.
+		 */
+
+		pidx = (offset - startoffset) >> PAGE_SHIFT;
+		while ((pgs[pidx]->flags & PG_FAKE) == 0) {
+			size_t b;
+
+			KASSERT((offset & (PAGE_SIZE - 1)) == 0);
+			b = MIN(PAGE_SIZE, bytes);
+			offset += b;
+			bytes -= b;
+			skipbytes += b;
+			pidx++;
+			UVMHIST_LOG(ubchist, "skipping, new offset 0x%x",
+				    offset, 0,0,0);
+			if (bytes == 0) {
+				goto loopdone;
+			}
+		}
+
+		/*
+		 * bmap the file to find out the blkno to read from and
+		 * how much we can read in one i/o.  if bmap returns an error,
+		 * skip the rest of the top-level i/o.
+		 */
+
+		lbn = offset >> fs_bshift;
+		error = VOP_BMAP(vp, lbn, NULL, &blkno, &run);
+		if (error) {
+			UVMHIST_LOG(ubchist, "VOP_BMAP lbn 0x%x -> %d\n",
+				    lbn, error,0,0);
+			skipbytes += bytes;
+			goto loopdone;
+		}
+
+		/*
+		 * see how many pages can be read with this i/o.
+		 * reduce the i/o size if necessary to avoid
+		 * overwriting pages with valid data.
+		 */
+
+		iobytes = MIN((((off_t)lbn + 1 + run) << fs_bshift) - offset,
+		    bytes);
+		if (offset + iobytes > round_page(offset)) {
+			pcount = 1;
+			while (pidx + pcount < npages &&
+			       pgs[pidx + pcount]->flags & PG_FAKE) {
+				pcount++;
+			}
+			iobytes = MIN(iobytes, (pcount << PAGE_SHIFT) -
+				      (offset - trunc_page(offset)));
+		}
+
+		/*
+		 * if this block isn't allocated, zero it instead of reading it.
+		 * if this is a read access, mark the pages we zeroed PG_RDONLY.
+		 */
+
+		if (blkno < 0) {
+			UVMHIST_LOG(ubchist, "lbn 0x%x -> HOLE", lbn,0,0,0);
+
+			sawhole = TRUE;
+			memset((char *)kva + (offset - startoffset), 0,
+			       iobytes);
+			skipbytes += iobytes;
+
+			if (!write) {
+				int holepages =
+					(round_page(offset + iobytes) - 
+					 trunc_page(offset)) >> PAGE_SHIFT;
+				for (i = 0; i < holepages; i++) {
+					pgs[pidx + i]->flags |= PG_RDONLY;
+				}
+			}
+			continue;
+		}
+
+		/*
+		 * allocate a sub-buf for this piece of the i/o
+		 * (or just use mbp if there's only 1 piece),
+		 * and start it going.
+		 */
+
+		if (offset == startoffset && iobytes == bytes) {
+			bp = mbp;
+		} else {
+			s = splbio();
+			bp = pool_get(&bufpool, PR_WAITOK);
+			splx(s);
+			bp->b_data = (char *)kva + offset - startoffset;
+			bp->b_resid = bp->b_bcount = iobytes;
+			bp->b_flags = B_BUSY|B_READ|B_CALL;
+			bp->b_iodone = uvm_aio_biodone1;
+			bp->b_vp = vp;
+			LIST_INIT(&bp->b_dep);
+		}
+		bp->b_lblkno = 0;
+		bp->b_private = mbp;
+
+		/* adjust physical blkno for partial blocks */
+		bp->b_blkno = blkno + ((offset - ((off_t)lbn << fs_bshift)) >>
+				       dev_bshift);
+
+		UVMHIST_LOG(ubchist, "bp %p offset 0x%x bcount 0x%x blkno 0x%x",
+			    bp, offset, iobytes, bp->b_blkno);
+
+		VOP_STRATEGY(bp);
+	}
+
+loopdone:
+	if (skipbytes) {
+		s = splbio();
+		if (error) {
+			mbp->b_flags |= B_ERROR;
+			mbp->b_error = error;
+		}
+		mbp->b_resid -= skipbytes;
+		if (mbp->b_resid == 0) {
+			biodone(mbp);
+		}
+		splx(s);
+	}
+
+	if (async) {
+		UVMHIST_LOG(ubchist, "returning PEND",0,0,0,0);
+		lockmgr(&vp->v_glock, LK_RELEASE, NULL, p);
+		return EINPROGRESS;
+	}
+	if (bp != NULL) {
+		error = biowait(mbp);
+	}
+	s = splbio();
+	pool_put(&bufpool, mbp);
+	splx(s);
+	uvm_pagermapout(kva, npages);
+	raoffset = startoffset + totalbytes;
+
+	/*
+	 * if this we encountered a hole then we have to do a little more work.
+	 * for read faults, we marked the page PG_RDONLY so that future
+	 * write accesses to the page will fault again.
+	 * for write faults, we must make sure that the backing store for
+	 * the page is completely allocated while the pages are locked.
+	 */
+
+	if (error == 0 && sawhole && write) {
+		error = VOP_BALLOCN(vp, startoffset, npages << PAGE_SHIFT,
+				   cred, 0);
+		if (error) {
+			UVMHIST_LOG(ubchist, "balloc lbn 0x%x -> %d",
+				    lbn, error,0,0);
+			lockmgr(&vp->v_glock, LK_RELEASE, NULL, p);
+			simple_lock(&uobj->vmobjlock);
+			goto out;
+		}
+	}
+	lockmgr(&vp->v_glock, LK_RELEASE, NULL, p);
+	simple_lock(&uobj->vmobjlock);
+
+	/*
+	 * see if we want to start any readahead.
+	 * XXXUBC for now, just read the next 128k on 64k boundaries.
+	 * this is pretty nonsensical, but it is 50% faster than reading
+	 * just the next 64k.
+	 */
+
+raout:
+	if (!error && !async && !write && ((int)raoffset & 0xffff) == 0 &&
+	    PAGE_SHIFT <= 16) {
+		int racount;
+
+		racount = 1 << (16 - PAGE_SHIFT);
+		(void) VOP_GETPAGES(vp, raoffset, NULL, &racount, 0,
+				    VM_PROT_READ, 0, 0);
+		simple_lock(&uobj->vmobjlock);
+
+		racount = 1 << (16 - PAGE_SHIFT);
+		(void) VOP_GETPAGES(vp, raoffset + 0x10000, NULL, &racount, 0,
+				    VM_PROT_READ, 0, 0);
+		simple_lock(&uobj->vmobjlock);
+	}
+
+	/*
+	 * we're almost done!  release the pages...
+	 * for errors, we free the pages.
+	 * otherwise we activate them and mark them as valid and clean.
+	 * also, unbusy pages that were not actually requested.
+	 */
+
+out:
+	if (error) {
+		uvm_lock_pageq();
+		for (i = 0; i < npages; i++) {
+			if (pgs[i] == NULL) {
+				continue;
+			}
+			UVMHIST_LOG(ubchist, "examining pg %p flags 0x%x",
+				    pgs[i], pgs[i]->flags, 0,0);
+			if (pgs[i]->flags & PG_WANTED) {
+				wakeup(pgs[i]);
+			}
+			if (pgs[i]->flags & PG_RELEASED) {
+				uvm_unlock_pageq();
+				(uobj->pgops->pgo_releasepg)(pgs[i], NULL);
+				uvm_lock_pageq();
+				continue;
+			}
+			if (pgs[i]->flags & PG_FAKE) {
+				uvm_pagefree(pgs[i]);
+				continue;
+			}
+			uvm_pageactivate(pgs[i]);
+			pgs[i]->flags &= ~(PG_WANTED|PG_BUSY);
+			UVM_PAGE_OWN(pgs[i], NULL);
+		}
+		uvm_unlock_pageq();
+		simple_unlock(&uobj->vmobjlock);
+		UVMHIST_LOG(ubchist, "returning error %d", error,0,0,0);
+		return error;
+	}
+
+	UVMHIST_LOG(ubchist, "succeeding, npages %d", npages,0,0,0);
+	uvm_lock_pageq();
+	for (i = 0; i < npages; i++) {
+		if (pgs[i] == NULL) {
+			continue;
+		}
+		UVMHIST_LOG(ubchist, "examining pg %p flags 0x%x",
+			    pgs[i], pgs[i]->flags, 0,0);
+		if (pgs[i]->flags & PG_FAKE) {
+			UVMHIST_LOG(ubchist, "unfaking pg %p offset 0x%x",
+				    pgs[i], pgs[i]->offset,0,0);
+			pgs[i]->flags &= ~(PG_FAKE);
+			pmap_clear_modify(pgs[i]);
+			pmap_clear_reference(pgs[i]);
+		}
+		if (write) {
+			pgs[i]->flags &= ~(PG_RDONLY);
+		}
+		if (i < ridx || i >= ridx + orignpages || async) {
+			UVMHIST_LOG(ubchist, "unbusy pg %p offset 0x%x",
+				    pgs[i], pgs[i]->offset,0,0);
+			if (pgs[i]->flags & PG_WANTED) {
+				wakeup(pgs[i]);
+			}
+			if (pgs[i]->flags & PG_RELEASED) {
+				uvm_unlock_pageq();
+				(uobj->pgops->pgo_releasepg)(pgs[i], NULL);
+				uvm_lock_pageq();
+				continue;
+			}
+			uvm_pageactivate(pgs[i]);
+			pgs[i]->flags &= ~(PG_WANTED|PG_BUSY);
+			UVM_PAGE_OWN(pgs[i], NULL);
+		}
+	}
+	uvm_unlock_pageq();
+	simple_unlock(&uobj->vmobjlock);
+	if (ap->a_m != NULL) {
+		memcpy(ap->a_m, &pgs[ridx],
+		       orignpages * sizeof(struct vm_page *));
+	}
+	return 0;
+}
+
+/*
+ * generic VM putpages routine.
+ * Write the given range of pages to backing store.
+ */
+
+int
+genfs_putpages(v)
+	void *v;
+{
+	struct vop_putpages_args /* {
+		struct vnode *a_vp;
+		struct vm_page **a_m;
+		int a_count;
+		int a_flags;
+		int *a_rtvals;
+	} */ *ap = v;
+
+	int s, error, npages, run;
+	int fs_bshift, dev_bshift, dev_bsize;
+	vaddr_t kva;
+	off_t eof, offset, startoffset;
+	size_t bytes, iobytes, skipbytes;
+	daddr_t lbn, blkno;
+	struct vm_page *pg;
+	struct buf *mbp, *bp;
+	struct vnode *vp = ap->a_vp;
+	boolean_t async = (ap->a_flags & PGO_SYNCIO) == 0;
+	UVMHIST_FUNC("genfs_putpages"); UVMHIST_CALLED(ubchist);
+	UVMHIST_LOG(ubchist, "vp %p offset 0x%x count %d",
+		    vp, ap->a_m[0]->offset, ap->a_count, 0);
+
+	simple_unlock(&vp->v_uvm.u_obj.vmobjlock);
+
+	error = VOP_SIZE(vp, vp->v_uvm.u_size, &eof);
+	if (error) {
+		return error;
+	}
+
+	error = 0;
+	npages = ap->a_count;
+	fs_bshift = vp->v_mount->mnt_fs_bshift;
+	dev_bshift = vp->v_mount->mnt_dev_bshift;
+	dev_bsize = 1 << dev_bshift;
+	KASSERT((eof & (dev_bsize - 1)) == 0);
+
+	pg = ap->a_m[0];
+	startoffset = pg->offset;
+	bytes = MIN(npages << PAGE_SHIFT, eof - startoffset);
+	skipbytes = 0;
+	KASSERT(bytes != 0);
+
+	kva = uvm_pagermapin(ap->a_m, npages, UVMPAGER_MAPIN_WAITOK);
+
+	s = splbio();
+	vp->v_numoutput += 2;
+	mbp = pool_get(&bufpool, PR_WAITOK);
+	UVMHIST_LOG(ubchist, "vp %p mbp %p num now %d bytes 0x%x",
+		    vp, mbp, vp->v_numoutput, bytes);
+	splx(s);
+	mbp->b_bufsize = npages << PAGE_SHIFT;
+	mbp->b_data = (void *)kva;
+	mbp->b_resid = mbp->b_bcount = bytes;
+	mbp->b_flags = B_BUSY|B_WRITE|B_AGE |
+		(async ? B_CALL : 0) |
+		(curproc == uvm.pagedaemon_proc ? B_PDAEMON : 0);
+	mbp->b_iodone = uvm_aio_biodone;
+	mbp->b_vp = vp;
+	LIST_INIT(&mbp->b_dep);
+
+	bp = NULL;
+	for (offset = startoffset;
+	     bytes > 0;
+	     offset += iobytes, bytes -= iobytes) {
+		lbn = offset >> fs_bshift;
+		error = VOP_BMAP(vp, lbn, NULL, &blkno, &run);
+		if (error) {
+			UVMHIST_LOG(ubchist, "VOP_BMAP() -> %d", error,0,0,0);
+			skipbytes += bytes;
+			bytes = 0;
+			break;
+		}
+
+		iobytes = MIN((((off_t)lbn + 1 + run) << fs_bshift) - offset,
+		    bytes);
+		if (blkno == (daddr_t)-1) {
+			skipbytes += iobytes;
+			continue;
+		}
+
+		/* if it's really one i/o, don't make a second buf */
+		if (offset == startoffset && iobytes == bytes) {
+			bp = mbp;
+		} else {
+			s = splbio();
+			vp->v_numoutput++;
+			bp = pool_get(&bufpool, PR_WAITOK);
+			UVMHIST_LOG(ubchist, "vp %p bp %p num now %d",
+				    vp, bp, vp->v_numoutput, 0);
+			splx(s);
+			bp->b_data = (char *)kva +
+				(vaddr_t)(offset - pg->offset);
+			bp->b_resid = bp->b_bcount = iobytes;
+			bp->b_flags = B_BUSY|B_WRITE|B_CALL|B_ASYNC;
+			bp->b_iodone = uvm_aio_biodone1;
+			bp->b_vp = vp;
+			LIST_INIT(&bp->b_dep);
+		}
+		bp->b_lblkno = 0;
+		bp->b_private = mbp;
+
+		/* adjust physical blkno for partial blocks */
+		bp->b_blkno = blkno + ((offset - ((off_t)lbn << fs_bshift)) >>
+				       dev_bshift);
+		UVMHIST_LOG(ubchist, "vp %p offset 0x%x bcount 0x%x blkno 0x%x",
+			    vp, offset, bp->b_bcount, bp->b_blkno);
+		VOP_STRATEGY(bp);
+	}
+	if (skipbytes) {
+		UVMHIST_LOG(ubchist, "skipbytes %d", skipbytes, 0,0,0);
+		s = splbio();
+		mbp->b_resid -= skipbytes;
+		if (error) {
+			mbp->b_flags |= B_ERROR;
+			mbp->b_error = error;
+		}
+		if (mbp->b_resid == 0) {
+			biodone(mbp);
+		}
+		splx(s);
+	}
+	if (async) {
+		UVMHIST_LOG(ubchist, "returning PEND", 0,0,0,0);
+		return EINPROGRESS;
+	}
+	if (bp != NULL) {
+		UVMHIST_LOG(ubchist, "waiting for mbp %p", mbp,0,0,0);
+		error = biowait(mbp);
+	}
+	if (bioops.io_pageiodone) {
+		(*bioops.io_pageiodone)(mbp);
+	}
+	s = splbio();
+	if (mbp->b_vp)
+		vwakeup(mbp->b_vp);
+	pool_put(&bufpool, mbp);
+	splx(s);
+	uvm_pagermapout(kva, npages);
+	UVMHIST_LOG(ubchist, "returning, error %d", error,0,0,0);
+	return error;
+}
+
+int
+genfs_size(v)
+	void *v;
+{
+	struct vop_size_args /* {
+		struct vnode *a_vp;
+		off_t a_size;
+		off_t *a_eobp;
+	} */ *ap = v;
+	int bsize;
+
+	bsize = 1 << ap->a_vp->v_mount->mnt_fs_bshift;
+	*ap->a_eobp = (ap->a_size + bsize - 1) & ~(bsize - 1);
+	return 0;
+}
diff --git a/sys/kern/vfs_subr.c b/sys/kern/vfs_subr.c
index e4efaff930f..7f668a7edde 100644
--- a/sys/kern/vfs_subr.c
+++ b/sys/kern/vfs_subr.c
@@ -1,4 +1,4 @@
-/*	$OpenBSD: vfs_subr.c,v 1.72 2001/11/21 21:13:34 csapuntz Exp $	*/
+/*	$OpenBSD: vfs_subr.c,v 1.73 2001/11/27 05:27:12 art Exp $	*/
 /*	$NetBSD: vfs_subr.c,v 1.53 1996/04/22 01:39:13 christos Exp $	*/
 
 /*
@@ -377,6 +377,8 @@ getnewvnode(tag, mp, vops, vpp)
 	int (**vops) __P((void *));
 	struct vnode **vpp;
 {
+	extern struct uvm_pagerops uvm_vnodeops;
+	struct uvm_object *uobj;
 	struct proc *p = curproc;			/* XXX */
 	struct freelst *listhd;
 	static int toggle;
@@ -410,7 +412,7 @@ getnewvnode(tag, mp, vops, vpp)
 		splx(s);
 		simple_unlock(&vnode_free_list_slock);
 		vp = pool_get(&vnode_pool, PR_WAITOK);
-		bzero((char *)vp, sizeof *vp);
+		bzero(vp, sizeof *vp);
 		numvnodes++;
 	} else {
 		for (vp = TAILQ_FIRST(listhd); vp != NULLVP;
@@ -423,7 +425,7 @@ getnewvnode(tag, mp, vops, vpp)
 		 * the first NCPUS items on the free list are
 		 * locked, so this is close enough to being empty.
 		 */
-		if (vp == NULLVP) {
+		if (vp == NULL) {
 			splx(s);
 			simple_unlock(&vnode_free_list_slock);
 			tablefull("vnode");
@@ -458,6 +460,7 @@ getnewvnode(tag, mp, vops, vpp)
 		vp->v_socket = 0;
 	}
 	vp->v_type = VNON;
+	lockinit(&vp->v_glock, PVFS, "glock", 0, 0);
 	cache_purge(vp);
 	vp->v_tag = tag;
 	vp->v_op = vops;
@@ -466,6 +469,16 @@ getnewvnode(tag, mp, vops, vpp)
 	vp->v_usecount = 1;
 	vp->v_data = 0;
 	simple_lock_init(&vp->v_uvm.u_obj.vmobjlock);
+
+	/*
+	 * initialize uvm_object within vnode.
+	 */
+
+	uobj = &vp->v_uvm.u_obj;
+	uobj->pgops = &uvm_vnodeops;
+	TAILQ_INIT(&uobj->memq);
+	vp->v_uvm.u_size = VSIZENOTSET;
+
 	return (0);
 }
 
@@ -669,6 +682,10 @@ vget(vp, flags, p)
 		flags |= LK_INTERLOCK;
 	}
 	if (vp->v_flag & VXLOCK) {
+		if (flags & LK_NOWAIT) {
+			simple_unlock(&vp->v_interlock);
+			return (EBUSY);
+		}
  		vp->v_flag |= VXWANT;
 		simple_unlock(&vp->v_interlock);
 		tsleep((caddr_t)vp, PINOD, "vget", 0);
@@ -787,6 +804,11 @@ vput(vp)
 #endif
 	vputonfreelist(vp);
 
+	if (vp->v_flag & VTEXT) {
+		uvmexp.vtextpages -= vp->v_uvm.u_obj.uo_npages;
+		uvmexp.vnodepages += vp->v_uvm.u_obj.uo_npages;
+	}
+	vp->v_flag &= ~VTEXT;
 	simple_unlock(&vp->v_interlock);
 
 	VOP_INACTIVE(vp, p);
@@ -827,6 +849,11 @@ vrele(vp)
 #endif
 	vputonfreelist(vp);
 
+	if (vp->v_flag & VTEXT) {
+		uvmexp.vtextpages -= vp->v_uvm.u_obj.uo_npages;
+		uvmexp.vnodepages += vp->v_uvm.u_obj.uo_npages;
+	}
+	vp->v_flag &= ~VTEXT;
 	if (vn_lock(vp, LK_EXCLUSIVE|LK_INTERLOCK, p) == 0)
 		VOP_INACTIVE(vp, p);
 }
@@ -1009,6 +1036,12 @@ vclean(vp, flags, p)
 	if (vp->v_flag & VXLOCK)
 		panic("vclean: deadlock");
 	vp->v_flag |= VXLOCK;
+	if (vp->v_flag & VTEXT) {
+		uvmexp.vtextpages -= vp->v_uvm.u_obj.uo_npages;
+		uvmexp.vnodepages += vp->v_uvm.u_obj.uo_npages;
+	}
+	vp->v_flag &= ~VTEXT;
+
 	/*
 	 * Even if the count is zero, the VOP_INACTIVE routine may still
 	 * have the object locked while it cleans it out. The VOP_LOCK
@@ -1019,11 +1052,7 @@ vclean(vp, flags, p)
 	VOP_LOCK(vp, LK_DRAIN | LK_INTERLOCK, p);
 
 	/*
-	 * clean out any VM data associated with the vnode.
-	 */
-	uvm_vnp_terminate(vp);
-	/*
-	 * Clean out any buffers associated with the vnode.
+	 * Clean out any cached data associated with the vnode.
 	 */
 	if (flags & DOCLOSE)
 		vinvalbuf(vp, V_SAVE, NOCRED, p, 0, 0);
@@ -1968,9 +1997,22 @@ vinvalbuf(vp, flags, cred, p, slpflag, slptimeo)
 	struct proc *p;
 	int slpflag, slptimeo;
 {
-	register struct buf *bp;
+	struct uvm_object *uobj = &vp->v_uvm.u_obj;
+	struct buf *bp;
 	struct buf *nbp, *blist;
-	int s, error;
+	int s, error, rv;
+	int flushflags = PGO_ALLPAGES|PGO_FREE|PGO_SYNCIO|
+	    (flags & V_SAVE ? PGO_CLEANIT : 0);
+
+	/* XXXUBC this doesn't look at flags or slp* */
+	if (vp->v_type == VREG) {
+		simple_lock(&uobj->vmobjlock);
+		rv = (uobj->pgops->pgo_flush)(uobj, 0, 0, flushflags);
+		simple_unlock(&uobj->vmobjlock);
+		if (!rv) {
+			return EIO;
+		}
+	}
 
 	if (flags & V_SAVE) {
 		s = splbio();
@@ -2040,12 +2082,21 @@ loop:
 
 void
 vflushbuf(vp, sync)
-	register struct vnode *vp;
+	struct vnode *vp;
 	int sync;
 {
-	register struct buf *bp, *nbp;
+	struct uvm_object *uobj = &vp->v_uvm.u_obj;
+	struct buf *bp, *nbp;
 	int s;
 
+	if (vp->v_type == VREG) {
+		int flags = PGO_CLEANIT|PGO_ALLPAGES| (sync ? PGO_SYNCIO : 0);
+
+		simple_lock(&uobj->vmobjlock);
+		(uobj->pgops->pgo_flush)(uobj, 0, 0, flags);
+		simple_unlock(&uobj->vmobjlock);
+	}
+
 loop:
 	s = splbio();
 	for (bp = vp->v_dirtyblkhd.lh_first; bp; bp = nbp) {
@@ -2112,23 +2163,25 @@ bgetvp(vp, bp)
  */
 void
 brelvp(bp)
-	register struct buf *bp;
+	struct buf *bp;
 {
 	struct vnode *vp;
 
-	if ((vp = bp->b_vp) == (struct vnode *) 0)
+	if ((vp = bp->b_vp) == NULL)
 		panic("brelvp: NULL");
+
 	/*
 	 * Delete from old vnode list, if on one.
 	 */
 	if (bp->b_vnbufs.le_next != NOLIST)
 		bufremvn(bp);
-	if ((vp->v_bioflag & VBIOONSYNCLIST) &&
+	if (TAILQ_EMPTY(&vp->v_uvm.u_obj.memq) &&
+	    (vp->v_bioflag & VBIOONSYNCLIST) &&
 	    LIST_FIRST(&vp->v_dirtyblkhd) == NULL) {
 		vp->v_bioflag &= ~VBIOONSYNCLIST;
 		LIST_REMOVE(vp, v_synclist);
 	}
-	bp->b_vp = (struct vnode *) 0;
+	bp->b_vp = NULL;
 
 	simple_lock(&vp->v_interlock);
 #ifdef DIAGNOSTIC
@@ -2205,7 +2258,8 @@ reassignbuf(bp)
 	 */
 	if ((bp->b_flags & B_DELWRI) == 0) {
 		listheadp = &vp->v_cleanblkhd;
-		if ((vp->v_bioflag & VBIOONSYNCLIST) &&
+		if (TAILQ_EMPTY(&vp->v_uvm.u_obj.memq) &&
+		    (vp->v_bioflag & VBIOONSYNCLIST) &&
 		    LIST_FIRST(&vp->v_dirtyblkhd) == NULL) {
 			vp->v_bioflag &= ~VBIOONSYNCLIST;
 			LIST_REMOVE(vp, v_synclist);
diff --git a/sys/kern/vfs_sync.c b/sys/kern/vfs_sync.c
index 4b07d0f373a..0adeb2f3065 100644
--- a/sys/kern/vfs_sync.c
+++ b/sys/kern/vfs_sync.c
@@ -1,4 +1,4 @@
-/*       $OpenBSD: vfs_sync.c,v 1.20 2001/11/15 06:38:48 art Exp $  */
+/*       $OpenBSD: vfs_sync.c,v 1.21 2001/11/27 05:27:12 art Exp $  */
 
 /*
  *  Portions of this code are:
@@ -176,15 +176,12 @@ sched_sync(p)
 			VOP_UNLOCK(vp, 0, p);
 			s = splbio();
 			if (LIST_FIRST(slp) == vp) {
-				/*
-				 * Note: disk vps can remain on the
-				 * worklist too with no dirty blocks, but
-				 * since sync_fsync() moves it to a different
-				 * slot we are safe.
-				 */
-				if (LIST_FIRST(&vp->v_dirtyblkhd) == NULL &&
-				    vp->v_type != VBLK)
-					panic("sched_sync: fsync failed");
+#ifdef DIAGNOSTIC
+				if (!(vp->v_bioflag & VBIOONSYNCLIST)) {
+					vprint("vnode", vp);
+					panic("sched_fsync: on synclist, but no flag");
+				}
+#endif
 				/*
 				 * Put us back on the worklist.  The worklist
 				 * routine will remove us from our current
diff --git a/sys/kern/vfs_syscalls.c b/sys/kern/vfs_syscalls.c
index 284fad0fbda..5433711decd 100644
--- a/sys/kern/vfs_syscalls.c
+++ b/sys/kern/vfs_syscalls.c
@@ -1,4 +1,4 @@
-/*	$OpenBSD: vfs_syscalls.c,v 1.82 2001/11/06 19:53:20 miod Exp $	*/
+/*	$OpenBSD: vfs_syscalls.c,v 1.83 2001/11/27 05:27:12 art Exp $	*/
 /*	$NetBSD: vfs_syscalls.c,v 1.71 1996/04/23 10:29:02 mycroft Exp $	*/
 
 /*
@@ -493,7 +493,6 @@ sys_sync(p, v, retval)
 		if ((mp->mnt_flag & MNT_RDONLY) == 0) {
 			asyncflag = mp->mnt_flag & MNT_ASYNC;
 			mp->mnt_flag &= ~MNT_ASYNC;
-			uvm_vnp_sync(mp);
 			VFS_SYNC(mp, MNT_NOWAIT, p->p_ucred, p);
 			if (asyncflag)
 				mp->mnt_flag |= MNT_ASYNC;
@@ -1064,6 +1063,13 @@ sys_fhopen(p, v, retval)
 	}
 	if ((error = VOP_OPEN(vp, flags, cred, p)) != 0)
 		goto bad;
+
+	if (vp->v_type == VREG &&
+	    uvn_attach(vp, flags & FWRITE ? VM_PROT_WRITE : 0) == NULL) {
+		error = EIO;
+		goto bad;
+	}
+
 	if (flags & FWRITE)
 		vp->v_writecount++;
 
@@ -1475,8 +1481,6 @@ sys_unlink(p, v, retval)
 		goto out;
 	}
 
-	(void)uvm_vnp_uncache(vp);
-
 	VOP_LEASE(nd.ni_dvp, p, p->p_ucred, LEASE_WRITE);
 	VOP_LEASE(vp, p, p->p_ucred, LEASE_WRITE);
 	error = VOP_REMOVE(nd.ni_dvp, nd.ni_vp, &nd.ni_cnd);
@@ -2338,7 +2342,6 @@ out:
 		if (fromnd.ni_dvp != tdvp)
 			VOP_LEASE(fromnd.ni_dvp, p, p->p_ucred, LEASE_WRITE);
 		if (tvp) {
-			(void)uvm_vnp_uncache(tvp);
 			VOP_LEASE(tvp, p, p->p_ucred, LEASE_WRITE);
 		}
 		error = VOP_RENAME(fromnd.ni_dvp, fromnd.ni_vp, &fromnd.ni_cnd,
diff --git a/sys/kern/vfs_vnops.c b/sys/kern/vfs_vnops.c
index ee5eb0baee2..491db1172fa 100644
--- a/sys/kern/vfs_vnops.c
+++ b/sys/kern/vfs_vnops.c
@@ -1,4 +1,4 @@
-/*	$OpenBSD: vfs_vnops.c,v 1.35 2001/11/15 06:22:30 art Exp $	*/
+/*	$OpenBSD: vfs_vnops.c,v 1.36 2001/11/27 05:27:12 art Exp $	*/
 /*	$NetBSD: vfs_vnops.c,v 1.20 1996/02/04 02:18:41 christos Exp $	*/
 
 /*
@@ -165,6 +165,11 @@ vn_open(ndp, fmode, cmode)
 	}
 	if ((error = VOP_OPEN(vp, fmode, cred, p)) != 0)
 		goto bad;
+	if (vp->v_type == VREG &&
+	    uvn_attach(vp, fmode & FWRITE ? VM_PROT_WRITE : 0) == NULL) {
+		error = EIO;
+		goto bad;
+	}
 	if (fmode & FWRITE)
 		vp->v_writecount++;
 	return (0);
@@ -197,11 +202,10 @@ vn_writechk(vp)
 		}
 	}
 	/*
-	 * If there's shared text associated with
-	 * the vnode, try to free it up once.  If
-	 * we fail, we can't allow writing.
+	 * If the vnode is in use as a process's text,
+	 * we can't allow writing.
 	 */
-	if ((vp->v_flag & VTEXT) && !uvm_vnp_uncache(vp))
+	if (vp->v_flag & VTEXT)
 		return (ETXTBSY);
 
 	return (0);
@@ -214,6 +218,23 @@ void
 vn_marktext(vp)
 	struct vnode *vp;
 {
+	if ((vp->v_flag & VTEXT) == 0) {
+		uvmexp.vnodepages -= vp->v_uvm.u_obj.uo_npages;
+		uvmexp.vtextpages += vp->v_uvm.u_obj.uo_npages;
+#if 0
+	/*
+	 * Doesn't help much because the pager is borked and ubc_flush is
+	 * slow.
+	 */
+#ifdef PMAP_PREFER
+		/*
+		 * Get rid of any cached reads from this vnode.
+		 * exec can't respect PMAP_PREFER when mapping the text.
+		 */
+		ubc_flush(&vp->v_uvm.u_obj, 0, 0);
+#endif
+#endif
+	}
 	vp->v_flag |= VTEXT;
 }
 
diff --git a/sys/kern/vnode_if.c b/sys/kern/vnode_if.c
index 1f30d85c507..d2a3d8298bf 100644
--- a/sys/kern/vnode_if.c
+++ b/sys/kern/vnode_if.c
@@ -3,7 +3,7 @@
  * (Modifications made here may easily be lost!)
  *
  * Created from the file:
- *	OpenBSD: vnode_if.src,v 1.11 2001/06/23 02:21:05 csapuntz Exp 
+ *	OpenBSD: vnode_if.src,v 1.13 2001/07/26 20:24:47 millert Exp 
  * by the script:
  *	OpenBSD: vnode_if.sh,v 1.8 2001/02/26 17:34:18 art Exp 
  */
@@ -1230,6 +1230,140 @@ int VOP_WHITEOUT(dvp, cnp, flags)
 	return (VCALL(dvp, VOFFSET(vop_whiteout), &a));
 }
 
+int vop_ballocn_vp_offsets[] = {
+	VOPARG_OFFSETOF(struct vop_ballocn_args,a_vp),
+	VDESC_NO_OFFSET
+};
+struct vnodeop_desc vop_ballocn_desc = {
+	0,
+	"vop_ballocn",
+	0,
+	vop_ballocn_vp_offsets,
+	VDESC_NO_OFFSET,
+	VOPARG_OFFSETOF(struct vop_ballocn_args, a_cred),
+	VDESC_NO_OFFSET,
+	VDESC_NO_OFFSET,
+	NULL,
+};
+
+int VOP_BALLOCN(vp, offset, length, cred, flags)
+	struct vnode *vp;
+	off_t offset;
+	off_t length;
+	struct ucred *cred;
+	int flags;
+{
+	struct vop_ballocn_args a;
+	a.a_desc = VDESC(vop_ballocn);
+	a.a_vp = vp;
+	a.a_offset = offset;
+	a.a_length = length;
+	a.a_cred = cred;
+	a.a_flags = flags;
+	return (VCALL(vp, VOFFSET(vop_ballocn), &a));
+}
+
+int vop_getpages_vp_offsets[] = {
+	VOPARG_OFFSETOF(struct vop_getpages_args,a_vp),
+	VDESC_NO_OFFSET
+};
+struct vnodeop_desc vop_getpages_desc = {
+	0,
+	"vop_getpages",
+	0,
+	vop_getpages_vp_offsets,
+	VDESC_NO_OFFSET,
+	VDESC_NO_OFFSET,
+	VDESC_NO_OFFSET,
+	VDESC_NO_OFFSET,
+	NULL,
+};
+
+int VOP_GETPAGES(vp, offset, m, count, centeridx, access_type, advice, flags)
+	struct vnode *vp;
+	voff_t offset;
+	vm_page_t *m;
+	int *count;
+	int centeridx;
+	vm_prot_t access_type;
+	int advice;
+	int flags;
+{
+	struct vop_getpages_args a;
+	a.a_desc = VDESC(vop_getpages);
+	a.a_vp = vp;
+	a.a_offset = offset;
+	a.a_m = m;
+	a.a_count = count;
+	a.a_centeridx = centeridx;
+	a.a_access_type = access_type;
+	a.a_advice = advice;
+	a.a_flags = flags;
+	return (VCALL(vp, VOFFSET(vop_getpages), &a));
+}
+
+int vop_putpages_vp_offsets[] = {
+	VOPARG_OFFSETOF(struct vop_putpages_args,a_vp),
+	VDESC_NO_OFFSET
+};
+struct vnodeop_desc vop_putpages_desc = {
+	0,
+	"vop_putpages",
+	0,
+	vop_putpages_vp_offsets,
+	VDESC_NO_OFFSET,
+	VDESC_NO_OFFSET,
+	VDESC_NO_OFFSET,
+	VDESC_NO_OFFSET,
+	NULL,
+};
+
+int VOP_PUTPAGES(vp, m, count, flags, rtvals)
+	struct vnode *vp;
+	vm_page_t *m;
+	int count;
+	int flags;
+	int *rtvals;
+{
+	struct vop_putpages_args a;
+	a.a_desc = VDESC(vop_putpages);
+	a.a_vp = vp;
+	a.a_m = m;
+	a.a_count = count;
+	a.a_flags = flags;
+	a.a_rtvals = rtvals;
+	return (VCALL(vp, VOFFSET(vop_putpages), &a));
+}
+
+int vop_size_vp_offsets[] = {
+	VOPARG_OFFSETOF(struct vop_size_args,a_vp),
+	VDESC_NO_OFFSET
+};
+struct vnodeop_desc vop_size_desc = {
+	0,
+	"vop_size",
+	0,
+	vop_size_vp_offsets,
+	VDESC_NO_OFFSET,
+	VDESC_NO_OFFSET,
+	VDESC_NO_OFFSET,
+	VDESC_NO_OFFSET,
+	NULL,
+};
+
+int VOP_SIZE(vp, size, eobp)
+	struct vnode *vp;
+	off_t size;
+	off_t *eobp;
+{
+	struct vop_size_args a;
+	a.a_desc = VDESC(vop_size);
+	a.a_vp = vp;
+	a.a_size = size;
+	a.a_eobp = eobp;
+	return (VCALL(vp, VOFFSET(vop_size), &a));
+}
+
 /* Special cases: */
 
 int vop_strategy_vp_offsets[] = {
@@ -1323,6 +1457,10 @@ struct vnodeop_desc *vfs_op_descs[] = {
 	&vop_advlock_desc,
 	&vop_reallocblks_desc,
 	&vop_whiteout_desc,
+	&vop_ballocn_desc,
+	&vop_getpages_desc,
+	&vop_putpages_desc,
+	&vop_size_desc,
 	NULL
 };
 
diff --git a/sys/kern/vnode_if.src b/sys/kern/vnode_if.src
index fdf8e6e4015..1af0f56e276 100644
--- a/sys/kern/vnode_if.src
+++ b/sys/kern/vnode_if.src
@@ -1,4 +1,4 @@
-#	$OpenBSD: vnode_if.src,v 1.13 2001/07/26 20:24:47 millert Exp $
+#	$OpenBSD: vnode_if.src,v 1.14 2001/11/27 05:27:12 art Exp $
 #	$NetBSD: vnode_if.src,v 1.10 1996/05/11 18:26:27 mycroft Exp $
 #
 # Copyright (c) 1992, 1993
@@ -467,3 +467,48 @@ vop_whiteout {
 #vop_bwrite {
 #	IN struct buf *bp;
 #};
+
+#
+#% ballocn    vp      L L L
+#
+vop_ballocn {
+	IN struct vnode *vp;
+	IN off_t offset;
+	IN off_t length;
+	IN struct ucred *cred;
+	IN int flags;
+};
+
+#
+#% getpages    vp L L L
+#
+vop_getpages {
+	IN struct vnode *vp;
+	IN voff_t offset;
+	IN vm_page_t *m;
+	IN int *count;
+	IN int centeridx;
+	IN vm_prot_t access_type;
+	IN int advice;
+	IN int flags;
+};
+
+#
+#% putpages    vp L L L
+#
+vop_putpages {
+	IN struct vnode *vp;
+	IN vm_page_t *m;
+	IN int count;
+	IN int flags;
+	IN int *rtvals;
+};
+
+#
+#% size                vp = = =
+#
+vop_size {
+	IN struct vnode *vp;
+	IN off_t size;
+	OUT off_t *eobp;
+};
diff --git a/sys/msdosfs/msdosfs_denode.c b/sys/msdosfs/msdosfs_denode.c
index eb82f75afe3..f4ab33d5272 100644
--- a/sys/msdosfs/msdosfs_denode.c
+++ b/sys/msdosfs/msdosfs_denode.c
@@ -1,4 +1,4 @@
-/*	$OpenBSD: msdosfs_denode.c,v 1.19 2001/11/06 19:53:20 miod Exp $	*/
+/*	$OpenBSD: msdosfs_denode.c,v 1.20 2001/11/27 05:27:12 art Exp $	*/
 /*	$NetBSD: msdosfs_denode.c,v 1.23 1997/10/17 11:23:58 ws Exp $	*/
 
 /*-
@@ -72,6 +72,8 @@ u_long dehash;			/* size of hash table - 1 */
 #define	DEHASH(dev, dcl, doff)	(((dev) + (dcl) + (doff) / sizeof(struct direntry)) \
 				 & dehash)
 
+extern int prtactive;
+
 static struct denode *msdosfs_hashget __P((dev_t, u_long, u_long));
 static int msdosfs_hashins __P((struct denode *));
 static void msdosfs_hashrem __P((struct denode *));
@@ -332,6 +334,7 @@ retry:
 		nvp->v_type = VREG;
 	VREF(ldep->de_devvp);
 	*depp = ldep;
+	nvp->v_uvm.u_size = ldep->de_FileSize;
 	return (0);
 }
 
@@ -461,7 +464,7 @@ detrunc(dep, length, flags, cred, p)
 #endif
 			return (error);
 		}
-		uvm_vnp_uncache(DETOV(dep));
+
 		/*
 		 * is this the right place for it?
 		 */
@@ -524,7 +527,7 @@ deextend(dep, length, cred)
 	struct ucred *cred;
 {
 	struct msdosfsmount *pmp = dep->de_pmp;
-	u_long count;
+	u_long count, osize;
 	int error;
 	
 	/*
@@ -557,8 +560,12 @@ deextend(dep, length, cred)
 		}
 	}
 		
+	osize = dep->de_FileSize;
 	dep->de_FileSize = length;
+	uvm_vnp_setsize(DETOV(dep), (voff_t)dep->de_FileSize);
 	dep->de_flag |= DE_UPDATE|DE_MODIFIED;
+	uvm_vnp_zerorange(DETOV(dep), (off_t)osize,
+	    (size_t)(dep->de_FileSize - osize));
 	return (deupdat(dep, 1));
 }
 
@@ -593,7 +600,6 @@ msdosfs_reclaim(v)
 	} */ *ap = v;
 	struct vnode *vp = ap->a_vp;
 	struct denode *dep = VTODE(vp);
-	extern int prtactive;
 	
 #ifdef MSDOSFS_DEBUG
 	printf("msdosfs_reclaim(): dep %08x, file %s, refcnt %d\n",
@@ -634,7 +640,6 @@ msdosfs_inactive(v)
 	struct denode *dep = VTODE(vp);
 	struct proc *p = ap->a_p;
 	int error;
-	extern int prtactive;
 	
 #ifdef MSDOSFS_DEBUG
 	printf("msdosfs_inactive(): dep %08x, de_Name[0] %x\n", dep, dep->de_Name[0]);
@@ -661,7 +666,9 @@ msdosfs_inactive(v)
 	       dep, dep->de_refcnt, vp->v_mount->mnt_flag, MNT_RDONLY);
 #endif
 	if (dep->de_refcnt <= 0 && (vp->v_mount->mnt_flag & MNT_RDONLY) == 0) {
-		error = detrunc(dep, (u_long)0, 0, NOCRED, NULL);
+		if (dep->de_FileSize != 0) {
+			error = detrunc(dep, (u_long)0, 0, NOCRED, NULL);
+		}
 		dep->de_Name[0] = SLOT_DELETED;
 	}
 	deupdat(dep, 0);
diff --git a/sys/msdosfs/msdosfs_fat.c b/sys/msdosfs/msdosfs_fat.c
index 772bdfb67e9..3576a663cdc 100644
--- a/sys/msdosfs/msdosfs_fat.c
+++ b/sys/msdosfs/msdosfs_fat.c
@@ -1,4 +1,4 @@
-/*	$OpenBSD: msdosfs_fat.c,v 1.8 1999/01/10 21:50:32 art Exp $	*/
+/*	$OpenBSD: msdosfs_fat.c,v 1.9 2001/11/27 05:27:12 art Exp $	*/
 /*	$NetBSD: msdosfs_fat.c,v 1.26 1997/10/17 11:24:02 ws Exp $	*/
 
 /*-
@@ -988,8 +988,7 @@ extendfile(dep, count, bpp, ncp, flags)
 	int flags;
 {
 	int error;
-	u_long frcn;
-	u_long cn, got;
+	u_long frcn = 0, cn, got;
 	struct msdosfsmount *pmp = dep->de_pmp;
 	struct buf *bp;
 	
@@ -1060,41 +1059,26 @@ extendfile(dep, count, bpp, ncp, flags)
 		}
 		
 		/*
-		 * Update the "last cluster of the file" entry in the denode's fat
-		 * cache.
+		 * Update the "last cluster of the file" entry in the
+		 * denode's fat cache.
 		 */
+
 		fc_setcache(dep, FC_LASTFC, frcn + got - 1, cn + got - 1);
-		
-		if (flags & DE_CLEAR) {
+		if (flags & DE_CLEAR &&
+		    (dep->de_Attributes & ATTR_DIRECTORY)) {
 			while (got-- > 0) {
-				/*
-				 * Get the buf header for the new block of the file.
-				 */
-				if (dep->de_Attributes & ATTR_DIRECTORY)
-					bp = getblk(pmp->pm_devvp, cntobn(pmp, cn++),
-						    pmp->pm_bpcluster, 0, 0);
-				else {
-					bp = getblk(DETOV(dep), de_cn2bn(pmp, frcn++),
-					    pmp->pm_bpcluster, 0, 0);
-					/*
-					 * Do the bmap now, as in msdosfs_write
-					 */
-					if (pcbmap(dep,
-					    de_bn2cn(pmp, bp->b_lblkno),
-					    &bp->b_blkno, 0, 0))
-						bp->b_blkno = -1;
-					if (bp->b_blkno == -1)
-						panic("extendfile: pcbmap");
-				}
+				bp = getblk(pmp->pm_devvp, cntobn(pmp, cn++),
+				    pmp->pm_bpcluster, 0, 0);
 				clrbuf(bp);
 				if (bpp) {
 					*bpp = bp;
 					bpp = NULL;
-				} else
+				} else {
 					bdwrite(bp);
+				}
 			}
 		}
 	}
-	
+
 	return (0);
 }
diff --git a/sys/msdosfs/msdosfs_vfsops.c b/sys/msdosfs/msdosfs_vfsops.c
index fec59174189..63175e08754 100644
--- a/sys/msdosfs/msdosfs_vfsops.c
+++ b/sys/msdosfs/msdosfs_vfsops.c
@@ -1,4 +1,4 @@
-/*	$OpenBSD: msdosfs_vfsops.c,v 1.25 2001/11/21 21:37:01 csapuntz Exp $	*/
+/*	$OpenBSD: msdosfs_vfsops.c,v 1.26 2001/11/27 05:27:12 art Exp $	*/
 /*	$NetBSD: msdosfs_vfsops.c,v 1.48 1997/10/18 02:54:57 briggs Exp $	*/
 
 /*-
@@ -584,15 +584,9 @@ msdosfs_mountfs(devvp, mp, p, argp)
 	mp->mnt_data = (qaddr_t)pmp;
         mp->mnt_stat.f_fsid.val[0] = (long)dev;
         mp->mnt_stat.f_fsid.val[1] = mp->mnt_vfc->vfc_typenum;
-#ifdef QUOTA
-	/*
-	 * If we ever do quotas for DOS filesystems this would be a place
-	 * to fill in the info in the msdosfsmount structure. You dolt,
-	 * quotas on dos filesystems make no sense because files have no
-	 * owners on dos filesystems. of course there is some empty space
-	 * in the directory entry where we could put uid's and gid's.
-	 */
-#endif
+	mp->mnt_dev_bshift = pmp->pm_bnshift;
+	mp->mnt_fs_bshift = pmp->pm_cnshift;
+
 	devvp->v_specmountpoint = mp;
 
 	return (0);
@@ -720,10 +714,11 @@ msdosfs_sync_vnode(struct vnode *vp, void *arg)
 	struct denode *dep;
 
 	dep = VTODE(vp);
-	if (vp->v_type == VNON || 
-	    ((dep->de_flag & (DE_ACCESS | DE_CREATE | DE_UPDATE | DE_MODIFIED)) == 0
-		&& vp->v_dirtyblkhd.lh_first == NULL) ||
-	    msa->waitfor == MNT_LAZY) {
+	if (msa->waitfor == MNT_LAZY || vp->v_type == VNON ||
+	    (((dep->de_flag &
+	    (DE_ACCESS | DE_CREATE | DE_UPDATE | DE_MODIFIED)) == 0) &&
+	    (LIST_EMPTY(&vp->v_dirtyblkhd) &&
+	     vp->v_uvm.u_obj.uo_npages == 0))) {
 		simple_unlock(&vp->v_interlock);
 		return (0);
 	}
diff --git a/sys/msdosfs/msdosfs_vnops.c b/sys/msdosfs/msdosfs_vnops.c
index 7f1ab384295..1e364039937 100644
--- a/sys/msdosfs/msdosfs_vnops.c
+++ b/sys/msdosfs/msdosfs_vnops.c
@@ -1,4 +1,4 @@
-/*	$OpenBSD: msdosfs_vnops.c,v 1.28 2001/11/06 19:53:20 miod Exp $	*/
+/*	$OpenBSD: msdosfs_vnops.c,v 1.29 2001/11/27 05:27:12 art Exp $	*/
 /*	$NetBSD: msdosfs_vnops.c,v 1.63 1997/10/17 11:24:19 ws Exp $	*/
 
 /*-
@@ -413,11 +413,11 @@ msdosfs_read(v)
 	int error = 0;
 	int diff;
 	int blsize;
-	int isadir;
 	long n;
 	long on;
 	daddr_t lbn;
-	daddr_t rablock;
+	void *win;
+	vsize_t bytelen;
 	struct buf *bp;
 	struct vnode *vp = ap->a_vp;
 	struct denode *dep = VTODE(vp);
@@ -432,42 +432,45 @@ msdosfs_read(v)
 	if (uio->uio_offset < 0)
 		return (EINVAL);
 
-	isadir = dep->de_Attributes & ATTR_DIRECTORY;
+	if (vp->v_type == VREG) {
+		while (uio->uio_resid > 0) {
+			bytelen = MIN(dep->de_FileSize - uio->uio_offset,
+			    uio->uio_resid);
+
+			if (bytelen == 0)
+				break;
+			win = ubc_alloc(&vp->v_uvm.u_obj, uio->uio_offset,
+			    &bytelen, UBC_READ);
+			error = uiomove(win, bytelen, uio);
+			ubc_release(win, 0);
+			if (error)
+				break;
+		}
+		dep->de_flag |= DE_ACCESS;
+		goto out;
+	}
+
+	/* this loop is only for directories now */
 	do {
 		lbn = de_cluster(pmp, uio->uio_offset);
 		on = uio->uio_offset & pmp->pm_crbomask;
-		n = min((u_long) (pmp->pm_bpcluster - on), uio->uio_resid);
+		n = MIN((pmp->pm_bpcluster - on), uio->uio_resid);
 		diff = dep->de_FileSize - uio->uio_offset;
 		if (diff <= 0)
 			return (0);
 		if (diff < n)
 			n = diff;
 		/* convert cluster # to block # if a directory */
-		if (isadir) {
-			error = pcbmap(dep, lbn, &lbn, 0, &blsize);
-			if (error)
-				return (error);
-		}
+		error = pcbmap(dep, lbn, &lbn, 0, &blsize);
+		if (error)
+			return (error);
 		/*
 		 * If we are operating on a directory file then be sure to
 		 * do i/o with the vnode for the filesystem instead of the
 		 * vnode for the directory.
 		 */
-		if (isadir) {
-			error = bread(pmp->pm_devvp, lbn, blsize, NOCRED, &bp);
-		} else {
-			rablock = lbn + 1;
-			if (dep->de_lastr + 1 == lbn &&
-			    de_cn2off(pmp, rablock) < dep->de_FileSize)
-				error = breada(vp, de_cn2bn(pmp, lbn),
-				    pmp->pm_bpcluster, de_cn2bn(pmp, rablock),
-				    pmp->pm_bpcluster, NOCRED, &bp);
-			else
-				error = bread(vp, de_cn2bn(pmp, lbn),
-				    pmp->pm_bpcluster, NOCRED, &bp);
-			dep->de_lastr = lbn;
-		}
-		n = min(n, pmp->pm_bpcluster - bp->b_resid);
+		error = bread(pmp->pm_devvp, lbn, blsize, NOCRED, &bp);
+		n = MIN(n, pmp->pm_bpcluster - bp->b_resid);
 		if (error) {
 			brelse(bp);
 			return (error);
@@ -475,8 +478,10 @@ msdosfs_read(v)
 		error = uiomove(bp->b_data + on, (int) n, uio);
 		brelse(bp);
 	} while (error == 0 && uio->uio_resid > 0 && n != 0);
-	if (!isadir && !(vp->v_mount->mnt_flag & MNT_NOATIME))
-		dep->de_flag |= DE_ACCESS;
+
+out:
+	if ((ap->a_ioflag & IO_SYNC) == IO_SYNC)
+		error = deupdat(dep, 1);
 	return (error);
 }
 
@@ -493,19 +498,19 @@ msdosfs_write(v)
 		int a_ioflag;
 		struct ucred *a_cred;
 	} */ *ap = v;
-	int n;
-	int croffset;
 	int resid;
 	u_long osize;
 	int error = 0;
 	u_long count;
-	daddr_t bn, lastcn;
-	struct buf *bp;
+	daddr_t lastcn;
 	int ioflag = ap->a_ioflag;
+	void *win;
+	vsize_t bytelen;
+	off_t oldoff;
+	boolean_t rv;
 	struct uio *uio = ap->a_uio;
 	struct proc *p = uio->uio_procp;
 	struct vnode *vp = ap->a_vp;
-	struct vnode *thisvp;
 	struct denode *dep = VTODE(vp);
 	struct msdosfsmount *pmp = dep->de_pmp;
 	struct ucred *cred = ap->a_cred;
@@ -521,7 +526,6 @@ msdosfs_write(v)
 	case VREG:
 		if (ioflag & IO_APPEND)
 			uio->uio_offset = dep->de_FileSize;
-		thisvp = vp;
 		break;
 	case VDIR:
 		return EISDIR;
@@ -576,84 +580,52 @@ msdosfs_write(v)
 	} else
 		lastcn = de_clcount(pmp, osize) - 1;
 
+	if (dep->de_FileSize < uio->uio_offset + resid) {
+		dep->de_FileSize = uio->uio_offset + resid;
+		uvm_vnp_setsize(vp, dep->de_FileSize);
+	}
+
 	do {
-		if (de_cluster(pmp, uio->uio_offset) > lastcn) {
+		oldoff = uio->uio_offset;
+		if (de_cluster(pmp, oldoff) > lastcn) {
 			error = ENOSPC;
 			break;
 		}
-
-		bn = de_blk(pmp, uio->uio_offset);
-		if ((uio->uio_offset & pmp->pm_crbomask) == 0
-		    && (de_blk(pmp, uio->uio_offset + uio->uio_resid) > de_blk(pmp, uio->uio_offset)
-			|| uio->uio_offset + uio->uio_resid >= dep->de_FileSize)) {
-			/*
-			 * If either the whole cluster gets written,
-			 * or we write the cluster from its start beyond EOF,
-			 * then no need to read data from disk.
-			 */
-			bp = getblk(thisvp, bn, pmp->pm_bpcluster, 0, 0);
-			clrbuf(bp);
-			/*
-			 * Do the bmap now, since pcbmap needs buffers
-			 * for the fat table. (see msdosfs_strategy)
-			 */
-			if (bp->b_blkno == bp->b_lblkno) {
-				error = pcbmap(dep,
-					       de_bn2cn(pmp, bp->b_lblkno),
-					       &bp->b_blkno, 0, 0);
-				if (error)
-					bp->b_blkno = -1;
-			}
-			if (bp->b_blkno == -1) {
-				brelse(bp);
-				if (!error)
-					error = EIO;		/* XXX */
-				break;
-			}
-		} else {
-			/*
-			 * The block we need to write into exists, so read it in.
-			 */
-			error = bread(thisvp, bn, pmp->pm_bpcluster,
-				      NOCRED, &bp);
-			if (error) {
-				brelse(bp);
-				break;
-			}
-		}
-
-		croffset = uio->uio_offset & pmp->pm_crbomask;
-		n = min(uio->uio_resid, pmp->pm_bpcluster - croffset);
-		if (uio->uio_offset + n > dep->de_FileSize) {
-			dep->de_FileSize = uio->uio_offset + n;
-			uvm_vnp_setsize(vp, dep->de_FileSize);
-		}
-		uvm_vnp_uncache(vp);
-		/*
-		 * Should these vnode_pager_* functions be done on dir
-		 * files?
-		 */
+		bytelen = MIN(dep->de_FileSize - oldoff, uio->uio_resid);
 
 		/*
-		 * Copy the data from user space into the buf header.
+		 * XXXUBC if file is mapped and this is the last block,
+		 * process one page at a time.
 		 */
-		error = uiomove(bp->b_data + croffset, n, uio);
 
+		if (bytelen == 0)
+			break;
+		win = ubc_alloc(&vp->v_uvm.u_obj, oldoff, &bytelen, UBC_READ);
+		error = uiomove(win, bytelen, uio);
+		ubc_release(win, 0);
+		if (error) {
+			break;
+		}
 		/*
-		 * If they want this synchronous then write it and wait for
-		 * it.  Otherwise, if on a cluster boundary write it
-		 * asynchronously so we can move on to the next block
-		 * without delay.  Otherwise do a delayed write because we
-		 * may want to write somemore into the block later.
+		 * flush what we just wrote if necessary.
+		 * XXXUBC simplistic async flushing.
 		 */
-		if (ioflag & IO_SYNC)
-			(void) bwrite(bp);
-		else if (n + croffset == pmp->pm_bpcluster)
-			bawrite(bp);
-		else
-			bdwrite(bp);
-		dep->de_flag |= DE_UPDATE;
+		if (ioflag & IO_SYNC) {
+			
+			simple_lock(&vp->v_uvm.u_obj.vmobjlock);
+			rv = vp->v_uvm.u_obj.pgops->pgo_flush(
+			    &vp->v_uvm.u_obj, oldoff,
+			    oldoff + bytelen, PGO_CLEANIT|PGO_SYNCIO);
+			simple_unlock(&vp->v_uvm.u_obj.vmobjlock);
+		} else if (oldoff >> 16 != uio->uio_offset >> 16) {
+			simple_lock(&vp->v_uvm.u_obj.vmobjlock);
+			rv = vp->v_uvm.u_obj.pgops->pgo_flush(
+			    &vp->v_uvm.u_obj, (oldoff >> 16) << 16,
+			    (uio->uio_offset >> 16) << 16, PGO_CLEANIT);
+			simple_unlock(&vp->v_uvm.u_obj.vmobjlock);
+		}
 	} while (error == 0 && uio->uio_resid > 0);
+	dep->de_flag |= DE_UPDATE;
 
 	/*
 	 * If the write failed and they want us to, truncate the file back
@@ -666,7 +638,8 @@ errexit:
 			uio->uio_offset -= resid - uio->uio_resid;
 			uio->uio_resid = resid;
 		} else {
-			detrunc(dep, dep->de_FileSize, ioflag & IO_SYNC, NOCRED, NULL);
+			detrunc(dep, dep->de_FileSize, ioflag & IO_SYNC, NOCRED,
+			    NULL);
 			if (uio->uio_resid != resid)
 				error = 0;
 		}
@@ -1506,11 +1479,11 @@ msdosfs_readdir(v)
 	while (uio->uio_resid > 0) {
 		lbn = de_cluster(pmp, offset - bias);
 		on = (offset - bias) & pmp->pm_crbomask;
-		n = min(pmp->pm_bpcluster - on, uio->uio_resid);
+		n = MIN(pmp->pm_bpcluster - on, uio->uio_resid);
 		diff = dep->de_FileSize - (offset - bias);
 		if (diff <= 0)
 			break;
-		n = min(n, diff);
+		n = MIN(n, diff);
 		if ((error = pcbmap(dep, lbn, &bn, &cn, &blsize)) != 0)
 			break;
 		error = bread(pmp->pm_devvp, bn, blsize, NOCRED, &bp);
@@ -1518,7 +1491,7 @@ msdosfs_readdir(v)
 			brelse(bp);
 			return (error);
 		}
-		n = min(n, blsize - bp->b_resid);
+		n = MIN(n, blsize - bp->b_resid);
 
 		/*
 		 * Convert from dos directory entries to fs-independent
@@ -1779,12 +1752,12 @@ msdosfs_strategy(v)
 		biodone(bp);
 		return (error);
 	}
-#ifdef DIAGNOSTIC
-#endif
+
 	/*
 	 * Read/write the block from/to the disk that contains the desired
 	 * file block.
 	 */
+
 	vp = dep->de_devvp;
 	bp->b_dev = vp->v_rdev;
 	VOCALL(vp->v_op, VOFFSET(vop_strategy), ap);
@@ -1902,7 +1875,10 @@ struct vnodeopv_entry_desc msdosfs_vnodeop_entries[] = {
 	{ &vop_advlock_desc, msdosfs_advlock },		/* advlock */
 	{ &vop_reallocblks_desc, msdosfs_reallocblks },	/* reallocblks */
 	{ &vop_bwrite_desc, vop_generic_bwrite },		/* bwrite */
-	{ (struct vnodeop_desc *)NULL, (int (*) __P((void *)))NULL }
+	{ &vop_getpages_desc, genfs_getpages },
+	{ &vop_putpages_desc, genfs_putpages },
+	{ &vop_size_desc, genfs_size },
+	{ NULL, NULL }
 };
 struct vnodeopv_desc msdosfs_vnodeop_opv_desc =
 	{ &msdosfs_vnodeop_p, msdosfs_vnodeop_entries };
diff --git a/sys/nfs/nfs.h b/sys/nfs/nfs.h
index 33435dc23e4..b86819902f2 100644
--- a/sys/nfs/nfs.h
+++ b/sys/nfs/nfs.h
@@ -1,4 +1,4 @@
-/*	$OpenBSD: nfs.h,v 1.13 2001/09/16 00:42:44 millert Exp $	*/
+/*	$OpenBSD: nfs.h,v 1.14 2001/11/27 05:27:12 art Exp $	*/
 /*	$NetBSD: nfs.h,v 1.10.4.1 1996/05/27 11:23:56 fvdl Exp $	*/
 
 /*
@@ -78,8 +78,18 @@
  * Ideally, NFS_DIRBLKSIZ should be bigger, but I've seen servers with
  * broken NFS/ethernet drivers that won't work with anything bigger (Linux..)
  */
-#define	NFS_DIRBLKSIZ	1024		/* Must be a multiple of DIRBLKSIZ */
+#if 1
+/*
+ * XXXUBC temp hack because of the removal of b_validend.
+ * eventually we'll store NFS VDIR data in the page cache as well,
+ * we'll fix this at that point.
+ */
+#define	NFS_DIRBLKSIZ		PAGE_SIZE
+#define	NFS_READDIRBLKSIZ	PAGE_SIZE
+#else
+#define	NFS_DIRBLKSIZ		1024	/* Must be a multiple of DIRBLKSIZ */
 #define NFS_READDIRBLKSIZ	512	/* Size of read dir blocks. XXX */
+#endif
 
 /*
  * Oddballs
@@ -111,10 +121,10 @@
 #endif
 
 /*
- * The B_INVAFTERWRITE flag should be set to whatever is required by the
- * buffer cache code to say "Invalidate the block after it is written back".
+ * Use the vm_page flag reserved for pager use to indicate pages
+ * which have been written to the server but not yet committed.
  */
-#define	B_INVAFTERWRITE	B_INVAL
+#define	PG_NEEDCOMMIT	PG_PAGER1
 
 /*
  * The IO_METASYNC flag should be implemented for local file systems.
diff --git a/sys/nfs/nfs_bio.c b/sys/nfs/nfs_bio.c
index 1f33bc2eab7..42b25763a88 100644
--- a/sys/nfs/nfs_bio.c
+++ b/sys/nfs/nfs_bio.c
@@ -1,4 +1,4 @@
-/*	$OpenBSD: nfs_bio.c,v 1.24 2001/11/15 23:15:15 art Exp $	*/
+/*	$OpenBSD: nfs_bio.c,v 1.25 2001/11/27 05:27:12 art Exp $	*/
 /*	$NetBSD: nfs_bio.c,v 1.25.4.2 1996/07/08 20:47:04 jtc Exp $	*/
 
 /*
@@ -50,8 +50,9 @@
 #include <sys/mount.h>
 #include <sys/kernel.h>
 #include <sys/namei.h>
+#include <sys/pool.h>
 
-#include <uvm/uvm_extern.h>
+#include <uvm/uvm.h>
 
 #include <nfs/rpcv2.h>
 #include <nfs/nfsproto.h>
@@ -70,20 +71,19 @@ struct nfsstats nfsstats;
  */
 int
 nfs_bioread(vp, uio, ioflag, cred)
-	register struct vnode *vp;
-	register struct uio *uio;
+	struct vnode *vp;
+	struct uio *uio;
 	int ioflag;
 	struct ucred *cred;
 {
-	register struct nfsnode *np = VTONFS(vp);
-	register int biosize, diff;
-	struct buf *bp = NULL, *rabp;
+	struct nfsnode *np = VTONFS(vp);
+	int biosize;
+	struct buf *bp = NULL;
 	struct vattr vattr;
 	struct proc *p;
 	struct nfsmount *nmp = VFSTONFS(vp->v_mount);
-	daddr_t lbn, bn, rabn;
 	caddr_t baddr;
-	int got_buf = 0, nra, error = 0, n = 0, on = 0, not_readin;
+	int got_buf = 0, error = 0, n = 0, on = 0;
 
 #ifdef DIAGNOSTIC
 	if (uio->uio_rw != UIO_READ)
@@ -153,87 +153,25 @@ nfs_bioread(vp, uio, ioflag, cred)
 	    switch (vp->v_type) {
 	    case VREG:
 		nfsstats.biocache_reads++;
-		lbn = uio->uio_offset / biosize;
-		on = uio->uio_offset & (biosize - 1);
-		bn = lbn * (biosize / DEV_BSIZE);
-		not_readin = 1;
-
-		/*
-		 * Start the read ahead(s), as required.
-		 */
-		if (nfs_numasync > 0 && nmp->nm_readahead > 0) {
-		    for (nra = 0; nra < nmp->nm_readahead &&
-			(lbn + 1 + nra) * biosize < np->n_size; nra++) {
-			rabn = (lbn + 1 + nra) * (biosize / DEV_BSIZE);
-			if (!incore(vp, rabn)) {
-			    rabp = nfs_getcacheblk(vp, rabn, biosize, p);
-			    if (!rabp)
-				return (EINTR);
-			    if ((rabp->b_flags & (B_DELWRI | B_DONE)) == 0) {
-				rabp->b_flags |= (B_READ | B_ASYNC);
-				if (nfs_asyncio(rabp)) {
-				    rabp->b_flags |= B_INVAL;
-				    brelse(rabp);
-				}
-			    } else
-				brelse(rabp);
-			}
-		    }
-		}
+		error = 0;
+		while (uio->uio_resid > 0) {
+			void *win;
+			vsize_t bytelen = MIN(np->n_size - uio->uio_offset,
+					      uio->uio_resid);
 
-		/*
-		 * If the block is in the cache and has the required data
-		 * in a valid region, just copy it out.
-		 * Otherwise, get the block and write back/read in,
-		 * as required.
-		 */
-		if ((bp = incore(vp, bn)) &&
-		    (bp->b_flags & (B_BUSY | B_WRITEINPROG)) ==
-		    (B_BUSY | B_WRITEINPROG))
-			got_buf = 0;
-		else {
-again:
-			bp = nfs_getcacheblk(vp, bn, biosize, p);
-			if (!bp)
-				return (EINTR);
-			got_buf = 1;
-			if ((bp->b_flags & (B_DONE | B_DELWRI)) == 0) {
-				bp->b_flags |= B_READ;
-				not_readin = 0;
-				error = nfs_doio(bp, p);
-				if (error) {
-				    brelse(bp);
-				    return (error);
-				}
-			}
-		}
-		n = min((unsigned)(biosize - on), uio->uio_resid);
-		diff = np->n_size - uio->uio_offset;
-		if (diff < n)
-			n = diff;
-		if (not_readin && n > 0) {
-			if (on < bp->b_validoff || (on + n) > bp->b_validend) {
-				if (!got_buf) {
-				    bp = nfs_getcacheblk(vp, bn, biosize, p);
-				    if (!bp)
-					return (EINTR);
-				    got_buf = 1;
-				}
-				bp->b_flags |= B_INVAFTERWRITE;
-				if (bp->b_dirtyend > 0) {
-				    if ((bp->b_flags & B_DELWRI) == 0)
-					panic("nfsbioread");
-				    if (VOP_BWRITE(bp) == EINTR)
-					return (EINTR);
-				} else
-				    brelse(bp);
-				goto again;
+			if (bytelen == 0)
+				break;
+			win = ubc_alloc(&vp->v_uvm.u_obj, uio->uio_offset,
+					&bytelen, UBC_READ);
+			error = uiomove(win, bytelen, uio);
+			ubc_release(win, 0);
+			if (error) {
+				break;
 			}
 		}
-		diff = (on >= bp->b_validend) ? 0 : (bp->b_validend - on);
-		if (diff < n)
-			n = diff;
+		n = 0;
 		break;
+
 	    case VLNK:
 		nfsstats.biocache_readlinks++;
 		bp = nfs_getcacheblk(vp, (daddr_t)0, NFS_MAXPATHLEN, p);
@@ -247,7 +185,7 @@ again:
 				return (error);
 			}
 		}
-		n = min(uio->uio_resid, NFS_MAXPATHLEN - bp->b_resid);
+		n = MIN(uio->uio_resid, NFS_MAXPATHLEN - bp->b_resid);
 		got_buf = 1;
 		on = 0;
 		break;
@@ -289,18 +227,17 @@ nfs_write(v)
 		int  a_ioflag;
 		struct ucred *a_cred;
 	} */ *ap = v;
-	register int biosize;
-	register struct uio *uio = ap->a_uio;
+	int biosize;
+	struct uio *uio = ap->a_uio;
 	struct proc *p = uio->uio_procp;
-	register struct vnode *vp = ap->a_vp;
+	struct vnode *vp = ap->a_vp;
 	struct nfsnode *np = VTONFS(vp);
-	register struct ucred *cred = ap->a_cred;
+	struct ucred *cred = ap->a_cred;
 	int ioflag = ap->a_ioflag;
-	struct buf *bp;
 	struct vattr vattr;
 	struct nfsmount *nmp = VFSTONFS(vp->v_mount);
-	daddr_t lbn, bn;
-	int n, on, error = 0;
+	int error = 0;
+	int rv;
 
 #ifdef DIAGNOSTIC
 	if (uio->uio_rw != UIO_WRITE)
@@ -360,85 +297,47 @@ nfs_write(v)
 	 */
 	biosize = nmp->nm_rsize;
 	do {
-
-		/*
-		 * XXX make sure we aren't cached in the VM page cache
-		 */
-		uvm_vnp_uncache(vp);
+		void *win;
+		voff_t oldoff = uio->uio_offset;
+		vsize_t bytelen = uio->uio_resid;
 
 		nfsstats.biocache_writes++;
-		lbn = uio->uio_offset / biosize;
-		on = uio->uio_offset & (biosize-1);
-		n = min((unsigned)(biosize - on), uio->uio_resid);
-		bn = lbn * (biosize / DEV_BSIZE);
-again:
-		bp = nfs_getcacheblk(vp, bn, biosize, p);
-		if (!bp)
-			return (EINTR);
 		np->n_flag |= NMODIFIED;
-		if (uio->uio_offset + n > np->n_size) {
-			np->n_size = uio->uio_offset + n;
-			uvm_vnp_setsize(vp, (u_long)np->n_size);
-		}
-
-		/*
-		 * If the new write will leave a contiguous dirty
-		 * area, just update the b_dirtyoff and b_dirtyend,
-		 * otherwise force a write rpc of the old dirty area.
-		 */
-		if (bp->b_dirtyend > 0 &&
-		    (on > bp->b_dirtyend || (on + n) < bp->b_dirtyoff)) {
-			bp->b_proc = p;
-			if (VOP_BWRITE(bp) == EINTR)
-				return (EINTR);
-			goto again;
-		}
-
-		error = uiomove((char *)bp->b_data + on, n, uio);
-		if (error) {
-			bp->b_flags |= B_ERROR;
-			brelse(bp);
-			return (error);
+		if (np->n_size < uio->uio_offset + bytelen) {
+			np->n_size = uio->uio_offset + bytelen;
+			uvm_vnp_setsize(vp, np->n_size);
 		}
-		if (bp->b_dirtyend > 0) {
-			bp->b_dirtyoff = min(on, bp->b_dirtyoff);
-			bp->b_dirtyend = max((on + n), bp->b_dirtyend);
-		} else {
-			bp->b_dirtyoff = on;
-			bp->b_dirtyend = on + n;
+		win = ubc_alloc(&vp->v_uvm.u_obj, uio->uio_offset, &bytelen,
+				UBC_WRITE);
+		error = uiomove(win, bytelen, uio);
+		ubc_release(win, 0);
+		rv = 1;
+		if ((ioflag & IO_SYNC)) {
+			simple_lock(&vp->v_uvm.u_obj.vmobjlock);
+			rv = vp->v_uvm.u_obj.pgops->pgo_flush(
+			    &vp->v_uvm.u_obj,
+			    oldoff & ~(nmp->nm_wsize - 1),
+			    uio->uio_offset & ~(nmp->nm_wsize - 1),
+			    PGO_CLEANIT|PGO_SYNCIO);
+			simple_unlock(&vp->v_uvm.u_obj.vmobjlock);
+		} else if ((oldoff & ~(nmp->nm_wsize - 1)) !=
+		    (uio->uio_offset & ~(nmp->nm_wsize - 1))) {
+			simple_lock(&vp->v_uvm.u_obj.vmobjlock);
+			rv = vp->v_uvm.u_obj.pgops->pgo_flush(
+			    &vp->v_uvm.u_obj,
+			    oldoff & ~(nmp->nm_wsize - 1),
+			    uio->uio_offset & ~(nmp->nm_wsize - 1),
+			    PGO_CLEANIT|PGO_WEAK);
+			simple_unlock(&vp->v_uvm.u_obj.vmobjlock);
 		}
-		if (bp->b_validend == 0 || bp->b_validend < bp->b_dirtyoff ||
-		    bp->b_validoff > bp->b_dirtyend) {
-			bp->b_validoff = bp->b_dirtyoff;
-			bp->b_validend = bp->b_dirtyend;
-		} else {
-			bp->b_validoff = min(bp->b_validoff, bp->b_dirtyoff);
-			bp->b_validend = max(bp->b_validend, bp->b_dirtyend);
+		if (!rv) {
+			error = EIO;
 		}
-
-		/*
-		 * Since this block is being modified, it must be written
-		 * again and not just committed.
-		 */
-		bp->b_flags &= ~B_NEEDCOMMIT;
-
-		/*
-		 * If the lease is non-cachable or IO_SYNC do bwrite().
-		 */
-		if (ioflag & IO_SYNC) {
-			bp->b_proc = p;
-			error = VOP_BWRITE(bp);
-			if (error)
-				return (error);
-		} else if ((n + on) == biosize) {
-			bp->b_proc = (struct proc *)0;
-			bp->b_flags |= B_ASYNC;
-			(void)nfs_writebp(bp, 0);
-		} else {
-			bdwrite(bp);
+		if (error) {
+			break;
 		}
-	} while (uio->uio_resid > 0 && n > 0);
-	return (0);
+	} while (uio->uio_resid > 0);
+	return (error);
 }
 
 /*
@@ -460,9 +359,9 @@ nfs_getcacheblk(vp, bn, size, p)
 
 	if (nmp->nm_flag & NFSMNT_INT) {
 		bp = getblk(vp, bn, size, PCATCH, 0);
-		while (bp == (struct buf *)0) {
-			if (nfs_sigintr(nmp, (struct nfsreq *)0, p))
-				return ((struct buf *)0);
+		while (bp == NULL) {
+			if (nfs_sigintr(nmp, NULL, p))
+				return (NULL);
 			bp = getblk(vp, bn, size, 0, 2 * hz);
 		}
 	} else
@@ -502,7 +401,7 @@ nfs_vinvalbuf(vp, flags, cred, p, intrflg)
 		np->n_flag |= NFLUSHWANT;
 		error = tsleep((caddr_t)&np->n_flag, PRIBIO + 2, "nfsvinval",
 			slptimeo);
-		if (error && intrflg && nfs_sigintr(nmp, (struct nfsreq *)0, p))
+		if (error && intrflg && nfs_sigintr(nmp, NULL, p))
 			return (EINTR);
 	}
 
@@ -512,7 +411,7 @@ nfs_vinvalbuf(vp, flags, cred, p, intrflg)
 	np->n_flag |= NFLUSHINPROG;
 	error = vinvalbuf(vp, flags, cred, p, slpflag, 0);
 	while (error) {
-		if (intrflg && nfs_sigintr(nmp, (struct nfsreq *)0, p)) {
+		if (intrflg && nfs_sigintr(nmp, NULL, p)) {
 			np->n_flag &= ~NFLUSHINPROG;
 			if (np->n_flag & NFLUSHWANT) {
 				np->n_flag &= ~NFLUSHWANT;
@@ -539,41 +438,20 @@ int
 nfs_asyncio(bp)
 	struct buf *bp;
 {
-	int i,s;
+	int i;
 
 	if (nfs_numasync == 0)
 		return (EIO);
-	for (i = 0; i < NFS_MAXASYNCDAEMON; i++)
+	for (i = 0; i < NFS_MAXASYNCDAEMON; i++) {
 	    if (nfs_iodwant[i]) {
-		if ((bp->b_flags & B_READ) == 0) {
-			bp->b_flags |= B_WRITEINPROG;
-		}
-	
 		TAILQ_INSERT_TAIL(&nfs_bufq, bp, b_freelist);
-		nfs_iodwant[i] = (struct proc *)0;
+		nfs_iodwant[i] = NULL;
 		wakeup((caddr_t)&nfs_iodwant[i]);
 		return (0);
 	    }
+	}
 
-	/*
-	 * If it is a read or a write already marked B_WRITEINPROG or B_NOCACHE
-	 * return EIO so the process will call nfs_doio() and do it
-	 * synchronously.
-	 */
-	if (bp->b_flags & (B_READ | B_WRITEINPROG | B_NOCACHE))
-		return (EIO);
-
-	/*
-	 * Just turn the async write into a delayed write, instead of
-	 * doing in synchronously. Hopefully, at least one of the nfsiods
-	 * is currently doing a write for this file and will pick up the
-	 * delayed writes before going back to sleep.
-	 */
-	s = splbio();
-	buf_dirty(bp);
-	splx(s);
-	biodone(bp);
-	return (0);
+	return (EIO);
 }
 
 /*
@@ -589,7 +467,7 @@ nfs_doio(bp, p)
 	register struct vnode *vp;
 	struct nfsnode *np;
 	struct nfsmount *nmp;
-	int s, error = 0, diff, len, iomode, must_commit = 0;
+	int error = 0, diff, len, iomode, must_commit = 0;
 	struct uio uio;
 	struct iovec io;
 
@@ -636,9 +514,7 @@ nfs_doio(bp, p)
 		uiop->uio_offset = ((off_t)bp->b_blkno) << DEV_BSHIFT;
 		nfsstats.read_bios++;
 		error = nfs_readrpc(vp, uiop);
-		if (!error) {
-		    bp->b_validoff = 0;
-		    if (uiop->uio_resid) {
+		if (!error && uiop->uio_resid) {
 			/*
 			 * If len > 0, there is a hole in the file and
 			 * no writes after the hole have been pushed to
@@ -649,13 +525,9 @@ nfs_doio(bp, p)
 			len = np->n_size - ((((off_t)bp->b_blkno) << DEV_BSHIFT)
 				+ diff);
 			if (len > 0) {
-			    len = min(len, uiop->uio_resid);
-			    bzero((char *)bp->b_data + diff, len);
-			    bp->b_validend = diff + len;
-			} else
-			    bp->b_validend = diff;
-		    } else
-			bp->b_validend = bp->b_bcount;
+				len = MIN(len, uiop->uio_resid);
+				memset((char *)bp->b_data + diff, 0, len);
+			}
 		}
 		if (p && (vp->v_flag & VTEXT) &&
 		    (np->n_mtime != np->n_vattr.va_mtime.tv_sec)) {
@@ -672,62 +544,19 @@ nfs_doio(bp, p)
 	    default:
 		printf("nfs_doio:  type %x unexpected\n",vp->v_type);
 		break;
-	    };
+	    }
 	    if (error) {
 		bp->b_flags |= B_ERROR;
 		bp->b_error = error;
 	    }
 	} else {
-	    io.iov_len = uiop->uio_resid = bp->b_dirtyend
-		- bp->b_dirtyoff;
-	    uiop->uio_offset = ((off_t)bp->b_blkno) * DEV_BSIZE
-		+ bp->b_dirtyoff;
-	    io.iov_base = (char *)bp->b_data + bp->b_dirtyoff;
+	    io.iov_base = bp->b_data;
+	    io.iov_len = uiop->uio_resid = bp->b_bcount;
+	    uiop->uio_offset = ((off_t)bp->b_blkno) << DEV_BSHIFT;
 	    uiop->uio_rw = UIO_WRITE;
 	    nfsstats.write_bios++;
-	    if ((bp->b_flags & (B_ASYNC | B_NEEDCOMMIT | B_NOCACHE)) == B_ASYNC)
-		iomode = NFSV3WRITE_UNSTABLE;
-	    else
-		iomode = NFSV3WRITE_FILESYNC;
-	    bp->b_flags |= B_WRITEINPROG;
-#ifdef fvdl_debug
-	    printf("nfs_doio(%x): bp %x doff %d dend %d\n", 
-		vp, bp, bp->b_dirtyoff, bp->b_dirtyend);
-#endif
+	    iomode = NFSV3WRITE_UNSTABLE;
 	    error = nfs_writerpc(vp, uiop, &iomode, &must_commit);
-	    if (!error && iomode == NFSV3WRITE_UNSTABLE)
-		bp->b_flags |= B_NEEDCOMMIT;
-	    else
-		bp->b_flags &= ~B_NEEDCOMMIT;
-	    bp->b_flags &= ~B_WRITEINPROG;
-
-	    /*
-	     * For an interrupted write, the buffer is still valid and the
-	     * write hasn't been pushed to the server yet, so we can't set
-	     * B_ERROR and report the interruption by setting B_EINTR. For
-	     * the B_ASYNC case, B_EINTR is not relevant, so the rpc attempt
-	     * is essentially a noop.
-	     * For the case of a V3 write rpc not being committed to stable
-	     * storage, the block is still dirty and requires either a commit
-	     * rpc or another write rpc with iomode == NFSV3WRITE_FILESYNC
-	     * before the block is reused. This is indicated by setting the
-	     * B_DELWRI and B_NEEDCOMMIT flags.
-	     */
-	    if (error == EINTR || (!error && (bp->b_flags & B_NEEDCOMMIT))) {
-		    s = splbio();
-		    buf_dirty(bp);
-		    splx(s);
-
-		    if (!(bp->b_flags & B_ASYNC) && error)
-			    bp->b_flags |= B_EINTR;
-	    } else {
-		if (error) {
-		    bp->b_flags |= B_ERROR;
-		    bp->b_error = np->n_error = error;
-		    np->n_flag |= NWRITEERR;
-		}
-		bp->b_dirtyoff = bp->b_dirtyend = 0;
-	    }
 	}
 	bp->b_resid = uiop->uio_resid;
 	if (must_commit)
@@ -735,3 +564,590 @@ nfs_doio(bp, p)
 	biodone(bp);
 	return (error);
 }
+
+/*
+ * Vnode op for VM getpages.
+ */
+int
+nfs_getpages(v)
+	void *v;
+{
+	struct vop_getpages_args /* {
+		struct vnode *a_vp;
+		voff_t a_offset;
+		vm_page_t *a_m;
+		int *a_count;
+		int a_centeridx;
+		vm_prot_t a_access_type;
+		int a_advice;
+		int a_flags;
+	} */ *ap = v;
+
+	off_t eof, offset, origoffset, startoffset, endoffset;
+	int s, i, error, npages, orignpages, npgs, ridx, pidx, pcount;
+	vaddr_t kva;
+	struct buf *bp, *mbp;
+	struct vnode *vp = ap->a_vp;
+	struct nfsnode *np = VTONFS(vp);
+	struct uvm_object *uobj = &vp->v_uvm.u_obj;
+	struct nfsmount *nmp = VFSTONFS(vp->v_mount);
+	size_t bytes, iobytes, tailbytes, totalbytes, skipbytes;
+	int flags = ap->a_flags;
+	int bsize;
+	struct vm_page *pgs[16];			/* XXXUBC 16 */
+	boolean_t v3 = NFS_ISV3(vp);
+	boolean_t async = (flags & PGO_SYNCIO) == 0;
+	boolean_t write = (ap->a_access_type & VM_PROT_WRITE) != 0;
+	struct proc *p = curproc;
+
+	UVMHIST_FUNC("nfs_getpages"); UVMHIST_CALLED(ubchist);
+	UVMHIST_LOG(ubchist, "vp %p off 0x%x count %d", vp, (int)ap->a_offset,
+		    *ap->a_count,0);
+
+#ifdef DIAGNOSTIC
+	if (ap->a_centeridx < 0 || ap->a_centeridx >= *ap->a_count) {
+		panic("nfs_getpages: centeridx %d out of range",
+		      ap->a_centeridx);
+	}
+#endif
+
+	error = 0;
+	origoffset = ap->a_offset;
+	eof = vp->v_uvm.u_size;
+	if (origoffset >= eof) {
+		if ((flags & PGO_LOCKED) == 0) {
+			simple_unlock(&uobj->vmobjlock);
+		}
+		UVMHIST_LOG(ubchist, "off 0x%x past EOF 0x%x",
+			    (int)origoffset, (int)eof,0,0);
+		return EINVAL;
+	}
+
+	if (flags & PGO_LOCKED) {
+		uvn_findpages(uobj, origoffset, ap->a_count, ap->a_m,
+			      UFP_NOWAIT|UFP_NOALLOC);
+		return 0;
+	}
+
+	/* vnode is VOP_LOCKed, uobj is locked */
+
+	bsize = nmp->nm_rsize;
+	orignpages = MIN(*ap->a_count,
+			 round_page(eof - origoffset) >> PAGE_SHIFT);
+	npages = orignpages;
+	startoffset = origoffset & ~(bsize - 1);
+	endoffset = round_page((origoffset + (npages << PAGE_SHIFT)
+				+ bsize - 1) & ~(bsize - 1));
+	endoffset = MIN(endoffset, round_page(eof));
+	ridx = (origoffset - startoffset) >> PAGE_SHIFT;
+
+	if (!async && !write) {
+		int rapages = MAX(PAGE_SIZE, nmp->nm_rsize) >> PAGE_SHIFT;
+
+		(void) VOP_GETPAGES(vp, endoffset, NULL, &rapages, 0,
+				    VM_PROT_READ, 0, 0);
+		simple_lock(&uobj->vmobjlock);
+	}
+
+	UVMHIST_LOG(ubchist, "npages %d offset 0x%x", npages,
+		    (int)origoffset, 0,0);
+	memset(pgs, 0, sizeof(pgs));
+	uvn_findpages(uobj, origoffset, &npages, &pgs[ridx], UFP_ALL);
+
+	if (flags & PGO_OVERWRITE) {
+		UVMHIST_LOG(ubchist, "PGO_OVERWRITE",0,0,0,0);
+
+		/* XXXUBC for now, zero the page if we allocated it */
+		for (i = 0; i < npages; i++) {
+			struct vm_page *pg = pgs[ridx + i];
+
+			if (pg->flags & PG_FAKE) {
+				uvm_pagezero(pg);
+				pg->flags &= ~(PG_FAKE);
+			}
+		}
+		npages += ridx;
+		if (v3) {
+			simple_unlock(&uobj->vmobjlock);
+			goto uncommit;
+		}
+		goto out;
+	}
+
+	/*
+	 * if the pages are already resident, just return them.
+	 */
+
+	for (i = 0; i < npages; i++) {
+		struct vm_page *pg = pgs[ridx + i];
+
+		if ((pg->flags & PG_FAKE) != 0 ||
+		    ((ap->a_access_type & VM_PROT_WRITE) &&
+		      (pg->flags & PG_RDONLY))) {
+			break;
+		}
+	}
+	if (i == npages) {
+		UVMHIST_LOG(ubchist, "returning cached pages", 0,0,0,0);
+		npages += ridx;
+		goto out;
+	}
+
+	/*
+	 * the page wasn't resident and we're not overwriting,
+	 * so we're going to have to do some i/o.
+	 * find any additional pages needed to cover the expanded range.
+	 */
+
+	if (startoffset != origoffset ||
+	    startoffset + (npages << PAGE_SHIFT) != endoffset) {
+
+		/*
+		 * XXXUBC we need to avoid deadlocks caused by locking
+		 * additional pages at lower offsets than pages we
+		 * already have locked.  for now, unlock them all and
+		 * start over.
+		 */
+
+		for (i = 0; i < npages; i++) {
+			struct vm_page *pg = pgs[ridx + i];
+
+			if (pg->flags & PG_FAKE) {
+				pg->flags |= PG_RELEASED;
+			}
+		}
+		uvm_page_unbusy(&pgs[ridx], npages);
+		memset(pgs, 0, sizeof(pgs));
+
+		UVMHIST_LOG(ubchist, "reset npages start 0x%x end 0x%x",
+			    startoffset, endoffset, 0,0);
+		npages = (endoffset - startoffset) >> PAGE_SHIFT;
+		npgs = npages;
+		uvn_findpages(uobj, startoffset, &npgs, pgs, UFP_ALL);
+	}
+	simple_unlock(&uobj->vmobjlock);
+
+	/*
+	 * update the cached read creds for this node.
+	 */
+
+	if (np->n_rcred) {
+		crfree(np->n_rcred);
+	}
+	np->n_rcred = curproc->p_ucred;
+	crhold(np->n_rcred);
+
+	/*
+	 * read the desired page(s).
+	 */
+
+	totalbytes = npages << PAGE_SHIFT;
+	bytes = MIN(totalbytes, vp->v_uvm.u_size - startoffset);
+	tailbytes = totalbytes - bytes;
+	skipbytes = 0;
+
+	kva = uvm_pagermapin(pgs, npages, UVMPAGER_MAPIN_WAITOK |
+			     UVMPAGER_MAPIN_READ);
+
+	s = splbio();
+	mbp = pool_get(&bufpool, PR_WAITOK);
+	splx(s);
+	mbp->b_bufsize = totalbytes;
+	mbp->b_data = (void *)kva;
+	mbp->b_resid = mbp->b_bcount = bytes;
+	mbp->b_flags = B_BUSY|B_READ| (async ? B_CALL|B_ASYNC : 0);
+	mbp->b_iodone = uvm_aio_biodone;
+	mbp->b_vp = vp;
+	mbp->b_proc = NULL;		/* XXXUBC */
+	LIST_INIT(&mbp->b_dep);
+
+	/*
+	 * if EOF is in the middle of the last page, zero the part past EOF.
+	 */
+
+	if (tailbytes > 0 && (pgs[bytes >> PAGE_SHIFT]->flags & PG_FAKE)) {
+		memset((char *)kva + bytes, 0, tailbytes);
+	}
+
+	/*
+	 * now loop over the pages, reading as needed.
+	 */
+
+	bp = NULL;
+	for (offset = startoffset;
+	     bytes > 0;
+	     offset += iobytes, bytes -= iobytes) {
+
+		/*
+		 * skip pages which don't need to be read.
+		 */
+
+		pidx = (offset - startoffset) >> PAGE_SHIFT;
+		UVMHIST_LOG(ubchist, "pidx %d offset 0x%x startoffset 0x%x",
+			    pidx, (int)offset, (int)startoffset,0);
+		while ((pgs[pidx]->flags & PG_FAKE) == 0) {
+			size_t b;
+
+			KASSERT((offset & (PAGE_SIZE - 1)) == 0);
+			b = MIN(PAGE_SIZE, bytes);
+			offset += b;
+			bytes -= b;
+			skipbytes += b;
+			pidx++;
+			UVMHIST_LOG(ubchist, "skipping, new offset 0x%x",
+				    (int)offset, 0,0,0);
+			if (bytes == 0) {
+				goto loopdone;
+			}
+		}
+
+		/*
+		 * see how many pages can be read with this i/o.
+		 * reduce the i/o size if necessary.
+		 */
+
+		iobytes = bytes;
+		if (offset + iobytes > round_page(offset)) {
+			pcount = 1;
+			while (pidx + pcount < npages &&
+			       pgs[pidx + pcount]->flags & PG_FAKE) {
+				pcount++;
+			}
+			iobytes = MIN(iobytes, (pcount << PAGE_SHIFT) -
+				      (offset - trunc_page(offset)));
+		}
+		iobytes = MIN(iobytes, nmp->nm_rsize);
+
+		/*
+		 * allocate a sub-buf for this piece of the i/o
+		 * (or just use mbp if there's only 1 piece),
+		 * and start it going.
+		 */
+
+		if (offset == startoffset && iobytes == bytes) {
+			bp = mbp;
+		} else {
+			s = splbio();
+			bp = pool_get(&bufpool, PR_WAITOK);
+			splx(s);
+			bp->b_data = (char *)kva + offset - startoffset;
+			bp->b_resid = bp->b_bcount = iobytes;
+			bp->b_flags = B_BUSY|B_READ|B_CALL|B_ASYNC;
+			bp->b_iodone = uvm_aio_biodone1;
+			bp->b_vp = vp;
+			bp->b_proc = NULL;	/* XXXUBC */
+			LIST_INIT(&bp->b_dep);
+		}
+		bp->b_private = mbp;
+		bp->b_lblkno = bp->b_blkno = offset >> DEV_BSHIFT;
+
+		UVMHIST_LOG(ubchist, "bp %p offset 0x%x bcount 0x%x blkno 0x%x",
+			    bp, offset, iobytes, bp->b_blkno);
+
+		VOP_STRATEGY(bp);
+	}
+
+loopdone:
+	if (skipbytes) {
+		s = splbio();
+		mbp->b_resid -= skipbytes;
+		if (mbp->b_resid == 0) {
+			biodone(mbp);
+		}
+		splx(s);
+	}
+	if (async) {
+		UVMHIST_LOG(ubchist, "returning PEND",0,0,0,0);
+		return EINPROGRESS;
+	}
+	if (bp != NULL) {
+		error = biowait(mbp);
+	}
+	s = splbio();
+	pool_put(&bufpool, mbp);
+	splx(s);
+	uvm_pagermapout(kva, npages);
+ 
+	if (write && v3) {
+uncommit:
+ 		lockmgr(&np->n_commitlock, LK_EXCLUSIVE, NULL, p);
+		nfs_del_committed_range(vp, origoffset, npages);
+		nfs_del_tobecommitted_range(vp, origoffset, npages);
+		simple_lock(&uobj->vmobjlock);
+		for (i = 0; i < npages; i++) {
+			if (pgs[i] == NULL) {
+				continue;
+			}
+			pgs[i]->flags &= ~(PG_NEEDCOMMIT|PG_RDONLY);
+		}
+		simple_unlock(&uobj->vmobjlock);
+ 		lockmgr(&np->n_commitlock, LK_RELEASE, NULL, p);
+	}
+
+	simple_lock(&uobj->vmobjlock);
+
+out:
+	if (error) {
+		uvm_lock_pageq();
+		for (i = 0; i < npages; i++) {
+			if (pgs[i] == NULL) {
+				continue;
+			}
+			UVMHIST_LOG(ubchist, "examining pg %p flags 0x%x",
+				    pgs[i], pgs[i]->flags, 0,0);
+			if (pgs[i]->flags & PG_WANTED) {
+				wakeup(pgs[i]);
+			}
+			if (pgs[i]->flags & PG_RELEASED) {
+				uvm_unlock_pageq();
+				(uobj->pgops->pgo_releasepg)(pgs[i], NULL);
+				uvm_lock_pageq();
+				continue;
+			}
+			if (pgs[i]->flags & PG_FAKE) {
+				uvm_pagefree(pgs[i]);
+				continue;
+			}
+			uvm_pageactivate(pgs[i]);
+			pgs[i]->flags &= ~(PG_WANTED|PG_BUSY);
+			UVM_PAGE_OWN(pgs[i], NULL);
+		}
+		uvm_unlock_pageq();
+		simple_unlock(&uobj->vmobjlock);
+		UVMHIST_LOG(ubchist, "returning error %d", error,0,0,0);
+		return error;
+	}
+
+	UVMHIST_LOG(ubchist, "ridx %d count %d", ridx, npages, 0,0);
+	uvm_lock_pageq();
+	for (i = 0; i < npages; i++) {
+		if (pgs[i] == NULL) {
+			continue;
+		}
+		UVMHIST_LOG(ubchist, "examining pg %p flags 0x%x",
+			    pgs[i], pgs[i]->flags, 0,0);
+		if (pgs[i]->flags & PG_FAKE) {
+			UVMHIST_LOG(ubchist, "unfaking pg %p offset 0x%x",
+				    pgs[i], (int)pgs[i]->offset,0,0);
+			pgs[i]->flags &= ~(PG_FAKE);
+			pmap_clear_modify(pgs[i]);
+			pmap_clear_reference(pgs[i]);
+		}
+		if (i < ridx || i >= ridx + orignpages || async) {
+			UVMHIST_LOG(ubchist, "unbusy pg %p offset 0x%x",
+				    pgs[i], (int)pgs[i]->offset,0,0);
+			if (pgs[i]->flags & PG_WANTED) {
+				wakeup(pgs[i]);
+			}
+			if (pgs[i]->flags & PG_RELEASED) {
+				uvm_unlock_pageq();
+				(uobj->pgops->pgo_releasepg)(pgs[i], NULL);
+				uvm_lock_pageq();
+				continue;
+			}
+			uvm_pageactivate(pgs[i]);
+			pgs[i]->flags &= ~(PG_WANTED|PG_BUSY);
+			UVM_PAGE_OWN(pgs[i], NULL);
+		}
+	}
+	uvm_unlock_pageq();
+	simple_unlock(&uobj->vmobjlock);
+	if (ap->a_m != NULL) {
+		memcpy(ap->a_m, &pgs[ridx],
+		       *ap->a_count * sizeof(struct vm_page *));
+	}
+	return 0;
+}
+
+/*
+ * Vnode op for VM putpages.
+ */
+int
+nfs_putpages(v)
+	void *v;
+{
+	struct vop_putpages_args /* {
+		struct vnode *a_vp;
+		struct vm_page **a_m;
+		int a_count;
+		int a_flags;
+		int *a_rtvals;
+	} */ *ap = v;
+
+	struct vnode *vp = ap->a_vp;
+	struct nfsnode *np = VTONFS(vp);
+	struct nfsmount *nmp = VFSTONFS(vp->v_mount);
+	struct buf *bp, *mbp;
+	struct vm_page **pgs = ap->a_m;
+	int flags = ap->a_flags;
+	int npages = ap->a_count;
+	int s, error, i;
+	size_t bytes, iobytes, skipbytes;
+	vaddr_t kva;
+	off_t offset, origoffset, commitoff;
+	uint32_t commitbytes;
+	boolean_t v3 = NFS_ISV3(vp);
+	boolean_t async = (flags & PGO_SYNCIO) == 0;
+	boolean_t weak = (flags & PGO_WEAK) && v3;
+	struct proc *p = curproc;
+	UVMHIST_FUNC("nfs_putpages"); UVMHIST_CALLED(ubchist);
+
+	UVMHIST_LOG(ubchist, "vp %p pgp %p count %d",
+		    vp, ap->a_m, ap->a_count,0);
+
+	simple_unlock(&vp->v_uvm.u_obj.vmobjlock);
+
+	error = 0;
+	origoffset = pgs[0]->offset;
+	bytes = MIN(ap->a_count << PAGE_SHIFT, vp->v_uvm.u_size - origoffset);
+	skipbytes = 0;
+
+	/*
+	 * if the range has been committed already, mark the pages thus.
+	 * if the range just needs to be committed, we're done
+	 * if it's a weak putpage, otherwise commit the range.
+	 */
+
+	if (v3) {
+ 		lockmgr(&np->n_commitlock, LK_EXCLUSIVE, NULL, p);
+		if (nfs_in_committed_range(vp, origoffset, bytes)) {
+			goto committed;
+		}
+		if (nfs_in_tobecommitted_range(vp, origoffset, bytes)) {
+			if (weak) {
+				lockmgr(&np->n_commitlock, LK_RELEASE, NULL, p);
+				return 0;
+			} else {
+				commitoff = np->n_pushlo;
+				commitbytes = (uint32_t)(np->n_pushhi -
+							 np->n_pushlo);
+				goto commit;
+			}
+		}
+		lockmgr(&np->n_commitlock, LK_RELEASE, NULL, p);
+	}
+
+	/*
+	 * otherwise write or commit all the pages.
+	 */
+
+	kva = uvm_pagermapin(pgs, ap->a_count, UVMPAGER_MAPIN_WAITOK|
+			     UVMPAGER_MAPIN_WRITE);
+
+	s = splbio();
+	vp->v_numoutput += 2;
+	mbp = pool_get(&bufpool, PR_WAITOK);
+	UVMHIST_LOG(ubchist, "vp %p mbp %p num now %d bytes 0x%x",
+		    vp, mbp, vp->v_numoutput, bytes);
+	splx(s);
+	mbp->b_bufsize = npages << PAGE_SHIFT;
+	mbp->b_data = (void *)kva;
+	mbp->b_resid = mbp->b_bcount = bytes;
+	mbp->b_flags = B_BUSY|B_WRITE|B_AGE |
+		(async ? B_CALL|B_ASYNC : 0) |
+		(curproc == uvm.pagedaemon_proc ? B_PDAEMON : 0);
+	mbp->b_iodone = uvm_aio_biodone;
+	mbp->b_vp = vp;
+	mbp->b_proc = NULL;		/* XXXUBC */
+	LIST_INIT(&mbp->b_dep);
+
+	for (offset = origoffset;
+	     bytes > 0;
+	     offset += iobytes, bytes -= iobytes) {
+		iobytes = MIN(nmp->nm_wsize, bytes);
+
+ 		/*
+		 * skip writing any pages which only need a commit.
+		 */
+
+		if ((pgs[(offset - origoffset) >> PAGE_SHIFT]->flags &
+		     PG_NEEDCOMMIT) != 0) {
+			KASSERT((offset & (PAGE_SIZE - 1)) == 0);
+			iobytes = MIN(PAGE_SIZE, bytes);
+			skipbytes += iobytes;
+			continue;
+		}
+
+		/* if it's really one i/o, don't make a second buf */
+		if (offset == origoffset && iobytes == bytes) {
+			bp = mbp;
+		} else {
+			s = splbio();
+			vp->v_numoutput++;
+			bp = pool_get(&bufpool, PR_WAITOK);
+			UVMHIST_LOG(ubchist, "vp %p bp %p num now %d",
+				    vp, bp, vp->v_numoutput, 0);
+			splx(s);
+			bp->b_data = (char *)kva + (offset - origoffset);
+			bp->b_resid = bp->b_bcount = iobytes;
+			bp->b_flags = B_BUSY|B_WRITE|B_CALL|B_ASYNC;
+			bp->b_iodone = uvm_aio_biodone1;
+			bp->b_vp = vp;
+			bp->b_proc = NULL;	/* XXXUBC */
+			LIST_INIT(&bp->b_dep);
+		}
+		bp->b_private = mbp;
+		bp->b_lblkno = bp->b_blkno = (daddr_t)(offset >> DEV_BSHIFT);
+		UVMHIST_LOG(ubchist, "bp %p numout %d",
+			    bp, vp->v_numoutput,0,0);
+		VOP_STRATEGY(bp);
+	}
+	if (skipbytes) {
+		UVMHIST_LOG(ubchist, "skipbytes %d", bytes, 0,0,0);
+		s = splbio();
+		mbp->b_resid -= skipbytes;
+		if (mbp->b_resid == 0) {
+			biodone(mbp);
+		}
+		splx(s);
+	}
+	if (async) {
+		return EINPROGRESS;
+	}
+	if (bp != NULL) {
+		error = biowait(mbp);
+	}
+
+	s = splbio();
+	if (mbp->b_vp)
+		vwakeup(mbp->b_vp);
+	pool_put(&bufpool, mbp);
+	splx(s);
+
+	uvm_pagermapout(kva, ap->a_count);
+	if (error || !v3) {
+		UVMHIST_LOG(ubchist, "returning error %d", error, 0,0,0);
+		return error;
+	}
+
+	/*
+	 * for a weak put, mark the range as "to be committed"
+	 * and mark the pages read-only so that we will be notified
+	 * to remove the pages from the "to be committed" range
+	 * if they are made dirty again.
+	 * for a strong put, commit the pages and remove them from the
+	 * "to be committed" range.  also, mark them as writable
+	 * and not cleanable with just a commit.
+	 */
+
+	lockmgr(&np->n_commitlock, LK_EXCLUSIVE, NULL, p);
+	if (weak) {
+		nfs_add_tobecommitted_range(vp, origoffset,
+					    npages << PAGE_SHIFT);
+		for (i = 0; i < npages; i++) {
+			pgs[i]->flags |= PG_NEEDCOMMIT|PG_RDONLY;
+		}
+	} else {
+		commitoff = origoffset;
+		commitbytes = npages << PAGE_SHIFT;
+commit:
+		error = nfs_commit(vp, commitoff, commitbytes, curproc);
+		nfs_del_tobecommitted_range(vp, commitoff, commitbytes);
+committed:
+		for (i = 0; i < npages; i++) {
+			pgs[i]->flags &= ~(PG_NEEDCOMMIT|PG_RDONLY);
+		}
+	}
+	lockmgr(&np->n_commitlock, LK_RELEASE, NULL, p);
+	return error;
+}
diff --git a/sys/nfs/nfs_node.c b/sys/nfs/nfs_node.c
index 987259eadc3..567738584da 100644
--- a/sys/nfs/nfs_node.c
+++ b/sys/nfs/nfs_node.c
@@ -1,4 +1,4 @@
-/*	$OpenBSD: nfs_node.c,v 1.16 2001/11/15 23:15:15 art Exp $	*/
+/*	$OpenBSD: nfs_node.c,v 1.17 2001/11/27 05:27:12 art Exp $	*/
 /*	$NetBSD: nfs_node.c,v 1.16 1996/02/18 11:53:42 fvdl Exp $	*/
 
 /*
@@ -145,6 +145,7 @@ loop:
 	vp = nvp;
 	np = pool_get(&nfs_node_pool, PR_WAITOK);
 	bzero((caddr_t)np, sizeof *np);
+	lockinit(&np->n_commitlock, PINOD, "nfsclock", 0, 0);
 	vp->v_data = np;
 	np->n_vnode = vp;
 
@@ -169,6 +170,17 @@ loop:
 		np->n_fhp = &np->n_fh;
 	bcopy((caddr_t)fhp, (caddr_t)np->n_fhp, fhsize);
 	np->n_fhsize = fhsize;
+
+	/*
+	 * XXXUBC doing this while holding the nfs_hashlock is bad,
+	 * but there's no alternative at the moment.
+	 */
+	error = VOP_GETATTR(vp, &np->n_vattr, curproc->p_ucred, curproc);
+	if (error) {
+		return error;
+	}
+	uvm_vnp_setsize(vp, np->n_vattr.va_size);
+
 	lockmgr(&nfs_hashlock, LK_RELEASE, 0, p);
 	*npp = np;
 	return (0);
@@ -185,11 +197,12 @@ nfs_inactive(v)
 	struct nfsnode *np;
 	struct sillyrename *sp;
 	struct proc *p = curproc;	/* XXX */
+	struct vnode *vp = ap->a_vp;
 
-	np = VTONFS(ap->a_vp);
-	if (prtactive && ap->a_vp->v_usecount != 0)
-		vprint("nfs_inactive: pushing active", ap->a_vp);
-	if (ap->a_vp->v_type != VDIR) {
+	np = VTONFS(vp);
+	if (prtactive && vp->v_usecount != 0)
+		vprint("nfs_inactive: pushing active", vp);
+	if (vp->v_type != VDIR) {
 		sp = np->n_sillyrename;
 		np->n_sillyrename = (struct sillyrename *)0;
 	} else
@@ -198,7 +211,7 @@ nfs_inactive(v)
 		/*
 		 * Remove the silly file that was rename'd earlier
 		 */
-		(void) nfs_vinvalbuf(ap->a_vp, 0, sp->s_cred, p, 1);
+		(void) nfs_vinvalbuf(vp, 0, sp->s_cred, p, 1);
 		nfs_removeit(sp);
 		crfree(sp->s_cred);
 		vrele(sp->s_dvp);
@@ -206,7 +219,7 @@ nfs_inactive(v)
 	}
 	np->n_flag &= (NMODIFIED | NFLUSHINPROG | NFLUSHWANT);
 
-	VOP_UNLOCK(ap->a_vp, 0, ap->a_p);
+	VOP_UNLOCK(vp, 0, ap->a_p);
 	return (0);
 }
 
diff --git a/sys/nfs/nfs_serv.c b/sys/nfs/nfs_serv.c
index 9d4de9fd9a1..9534e7221da 100644
--- a/sys/nfs/nfs_serv.c
+++ b/sys/nfs/nfs_serv.c
@@ -1,4 +1,4 @@
-/*	$OpenBSD: nfs_serv.c,v 1.27 2001/11/06 19:53:21 miod Exp $	*/
+/*	$OpenBSD: nfs_serv.c,v 1.28 2001/11/27 05:27:12 art Exp $	*/
 /*     $NetBSD: nfs_serv.c,v 1.34 1997/05/12 23:37:12 fvdl Exp $       */
 
 /*
@@ -1663,8 +1663,6 @@ nfsrv_remove(nfsd, slp, procp, mrq)
 			error = EBUSY;
 			goto out;
 		}
-		if (vp->v_flag & VTEXT)
-			uvm_vnp_uncache(vp);
 out:
 		if (!error) {
 			error = VOP_REMOVE(nd.ni_dvp, nd.ni_vp, &nd.ni_cnd);
@@ -3276,11 +3274,10 @@ nfsrv_access(vp, flags, cred, rdonly, p, override)
 			}
 		}
 		/*
-		 * If there's shared text associated with
-		 * the inode, try to free it up once.  If
-		 * we fail, we can't allow writing.
+		 * If the vnode is in use as a process's text,
+		 * we can't allow writing.
 		 */
-		if ((vp->v_flag & VTEXT) && !uvm_vnp_uncache(vp))
+		if ((vp->v_flag & VTEXT))
 			return (ETXTBSY);
 	}
 	error = VOP_ACCESS(vp, flags, cred, p);
diff --git a/sys/nfs/nfs_subs.c b/sys/nfs/nfs_subs.c
index 9689d9f36a5..4a8bc11528d 100644
--- a/sys/nfs/nfs_subs.c
+++ b/sys/nfs/nfs_subs.c
@@ -1,4 +1,4 @@
-/*	$OpenBSD: nfs_subs.c,v 1.35 2001/11/06 19:53:21 miod Exp $	*/
+/*	$OpenBSD: nfs_subs.c,v 1.36 2001/11/27 05:27:12 art Exp $	*/
 /*	$NetBSD: nfs_subs.c,v 1.27.4.3 1996/07/08 20:34:24 jtc Exp $	*/
 
 /*
@@ -39,6 +39,40 @@
  *	@(#)nfs_subs.c	8.8 (Berkeley) 5/22/95
  */
 
+/*
+ * Copyright 2000 Wasabi Systems, Inc.
+ * All rights reserved.
+ *
+ * Written by Frank van der Linden for Wasabi Systems, Inc.
+ *
+ * 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 for the NetBSD Project by
+ *      Wasabi Systems, Inc.
+ * 4. The name of Wasabi Systems, Inc. may not be used to endorse
+ *    or promote products derived from this software without specific prior
+ *    written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY WASABI SYSTEMS, INC. ``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 WASABI SYSTEMS, INC
+ * 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.
+ */
 
 /*
  * These functions support the macros and help fiddle mbuf chains for
@@ -1241,17 +1275,14 @@ nfs_loadattrcache(vpp, mdp, dposp, vaper)
 		vap->va_filerev = 0;
 	}
 	if (vap->va_size != np->n_size) {
-		if (vap->va_type == VREG) {
-			if (np->n_flag & NMODIFIED) {
-				if (vap->va_size < np->n_size)
-					vap->va_size = np->n_size;
-				else
-					np->n_size = vap->va_size;
-			} else
-				np->n_size = vap->va_size;
-			uvm_vnp_setsize(vp, np->n_size);
-		} else
+		if ((np->n_flag & NMODIFIED) && vap->va_size < np->n_size) {
+			vap->va_size = np->n_size;
+		} else {
 			np->n_size = vap->va_size;
+			if (vap->va_type == VREG) {
+				uvm_vnp_setsize(vp, np->n_size);
+			}
+		}
 	}
 	np->n_attrstamp = time.tv_sec;
 	if (vaper != NULL) {
@@ -1741,26 +1772,216 @@ void
 nfs_clearcommit(mp)
 	struct mount *mp;
 {
-	register struct vnode *vp, *nvp;
-	register struct buf *bp, *nbp;
+	struct vnode *vp;
+	struct vm_page *pg;
+	struct nfsnode *np;
 	int s;
 
 	s = splbio();
-loop:
-	for (vp = mp->mnt_vnodelist.lh_first; vp; vp = nvp) {
-		if (vp->v_mount != mp)	/* Paranoia */
-			goto loop;
-		nvp = vp->v_mntvnodes.le_next;
-		for (bp = vp->v_dirtyblkhd.lh_first; bp; bp = nbp) {
-			nbp = bp->b_vnbufs.le_next;
-			if ((bp->b_flags & (B_BUSY | B_DELWRI | B_NEEDCOMMIT))
-				== (B_DELWRI | B_NEEDCOMMIT))
-				bp->b_flags &= ~B_NEEDCOMMIT;
+	LIST_FOREACH(vp, &mp->mnt_vnodelist, v_mntvnodes) {
+		if (vp->v_type == VNON)
+			continue;
+		np = VTONFS(vp);
+		np->n_pushlo = np->n_pushhi = np->n_pushedlo =
+		    np->n_pushedhi = 0;
+		np->n_commitflags &=
+		    ~(NFS_COMMIT_PUSH_VALID | NFS_COMMIT_PUSHED_VALID);
+		simple_lock(&vp->v_uvm.u_obj.vmobjlock);
+		TAILQ_FOREACH(pg, &vp->v_uvm.u_obj.memq, listq) {
+			pg->flags &= ~PG_NEEDCOMMIT;
 		}
+		simple_unlock(&vp->v_uvm.u_obj.vmobjlock);
 	}
 	splx(s);
 }
 
+void
+nfs_merge_commit_ranges(vp)
+	struct vnode *vp;
+{
+	struct nfsnode *np = VTONFS(vp);
+
+	if (!(np->n_commitflags & NFS_COMMIT_PUSHED_VALID)) {
+		np->n_pushedlo = np->n_pushlo;
+		np->n_pushedhi = np->n_pushhi;
+		np->n_commitflags |= NFS_COMMIT_PUSHED_VALID;
+	} else {
+		if (np->n_pushlo < np->n_pushedlo)
+			np->n_pushedlo = np->n_pushlo;
+		if (np->n_pushhi > np->n_pushedhi)
+			np->n_pushedhi = np->n_pushhi;
+	}
+
+	np->n_pushlo = np->n_pushhi = 0;
+	np->n_commitflags &= ~NFS_COMMIT_PUSH_VALID;
+
+#ifdef fvdl_debug
+	printf("merge: committed: %u - %u\n", (unsigned)np->n_pushedlo,
+	    (unsigned)np->n_pushedhi);
+#endif
+}
+
+int
+nfs_in_committed_range(vp, off, len)
+	struct vnode *vp;
+	off_t off, len;
+{
+	struct nfsnode *np = VTONFS(vp);
+	off_t lo, hi;
+
+	if (!(np->n_commitflags & NFS_COMMIT_PUSHED_VALID))
+		return 0;
+	lo = off;
+	hi = lo + len;
+
+	return (lo >= np->n_pushedlo && hi <= np->n_pushedhi);
+}
+
+int
+nfs_in_tobecommitted_range(vp, off, len)
+	struct vnode *vp;
+	off_t off, len;
+{
+	struct nfsnode *np = VTONFS(vp);
+	off_t lo, hi;
+
+	if (!(np->n_commitflags & NFS_COMMIT_PUSH_VALID))
+		return 0;
+	lo = off;
+	hi = lo + len;
+
+	return (lo >= np->n_pushlo && hi <= np->n_pushhi);
+}
+
+void
+nfs_add_committed_range(vp, off, len)
+	struct vnode *vp;
+	off_t off, len;
+{
+	struct nfsnode *np = VTONFS(vp);
+	off_t lo, hi;
+
+	lo = off;
+	hi = lo + len;
+
+	if (!(np->n_commitflags & NFS_COMMIT_PUSHED_VALID)) {
+		np->n_pushedlo = lo;
+		np->n_pushedhi = hi;
+		np->n_commitflags |= NFS_COMMIT_PUSHED_VALID;
+	} else {
+		if (hi > np->n_pushedhi)
+			np->n_pushedhi = hi;
+		if (lo < np->n_pushedlo)
+			np->n_pushedlo = lo;
+	}
+#ifdef fvdl_debug
+	printf("add: committed: %u - %u\n", (unsigned)np->n_pushedlo,
+	    (unsigned)np->n_pushedhi);
+#endif
+}
+
+void
+nfs_del_committed_range(vp, off, len)
+	struct vnode *vp;
+	off_t off, len;
+{
+	struct nfsnode *np = VTONFS(vp);
+	off_t lo, hi;
+
+	if (!(np->n_commitflags & NFS_COMMIT_PUSHED_VALID))
+		return;
+
+	lo = off;
+	hi = lo + len;
+
+	if (lo > np->n_pushedhi || hi < np->n_pushedlo)
+		return;
+	if (lo <= np->n_pushedlo)
+		np->n_pushedlo = hi;
+	else if (hi >= np->n_pushedhi)
+		np->n_pushedhi = lo;
+	else {
+		/*
+		 * XXX There's only one range. If the deleted range
+		 * is in the middle, pick the largest of the
+		 * contiguous ranges that it leaves.
+		 */
+		if ((np->n_pushedlo - lo) > (hi - np->n_pushedhi))
+			np->n_pushedhi = lo;
+		else
+			np->n_pushedlo = hi;
+	}
+#ifdef fvdl_debug
+	printf("del: committed: %u - %u\n", (unsigned)np->n_pushedlo,
+	    (unsigned)np->n_pushedhi);
+#endif
+}
+
+void
+nfs_add_tobecommitted_range(vp, off, len)
+	struct vnode *vp;
+	off_t off, len;
+{
+	struct nfsnode *np = VTONFS(vp);
+	off_t lo, hi;
+
+	lo = off;
+	hi = lo + len;
+
+	if (!(np->n_commitflags & NFS_COMMIT_PUSH_VALID)) {
+		np->n_pushlo = lo;
+		np->n_pushhi = hi;
+		np->n_commitflags |= NFS_COMMIT_PUSH_VALID;
+	} else {
+		if (lo < np->n_pushlo)
+			np->n_pushlo = lo;
+		if (hi > np->n_pushhi)
+			np->n_pushhi = hi;
+	}
+#ifdef fvdl_debug
+	printf("add: tobecommitted: %u - %u\n", (unsigned)np->n_pushlo,
+	    (unsigned)np->n_pushhi);
+#endif
+}
+
+void
+nfs_del_tobecommitted_range(vp, off, len)
+	struct vnode *vp;
+	off_t off, len;
+{
+	struct nfsnode *np = VTONFS(vp);
+	off_t lo, hi;
+
+	if (!(np->n_commitflags & NFS_COMMIT_PUSH_VALID))
+		return;
+
+	lo = off;
+	hi = lo + len;
+
+	if (lo > np->n_pushhi || hi < np->n_pushlo)
+		return;
+
+	if (lo <= np->n_pushlo)
+		np->n_pushlo = hi;
+	else if (hi >= np->n_pushhi)
+		np->n_pushhi = lo;
+	else {
+		/*
+		 * XXX There's only one range. If the deleted range
+		 * is in the middle, pick the largest of the
+		 * contiguous ranges that it leaves.
+		 */
+		if ((np->n_pushlo - lo) > (hi - np->n_pushhi))
+			np->n_pushhi = lo;
+		else
+			np->n_pushlo = hi;
+	}
+#ifdef fvdl_debug
+	printf("del: tobecommitted: %u - %u\n", (unsigned)np->n_pushlo,
+	    (unsigned)np->n_pushhi);
+#endif
+}
+
 /*
  * Map errnos to NFS error numbers. For Version 3 also filter out error
  * numbers not specified for the associated procedure.
diff --git a/sys/nfs/nfs_syscalls.c b/sys/nfs/nfs_syscalls.c
index c71a662ccb2..5a189ba344d 100644
--- a/sys/nfs/nfs_syscalls.c
+++ b/sys/nfs/nfs_syscalls.c
@@ -1,4 +1,4 @@
-/*	$OpenBSD: nfs_syscalls.c,v 1.20 2001/11/15 23:15:15 art Exp $	*/
+/*	$OpenBSD: nfs_syscalls.c,v 1.21 2001/11/27 05:27:12 art Exp $	*/
 /*	$NetBSD: nfs_syscalls.c,v 1.19 1996/02/18 11:53:52 fvdl Exp $	*/
 
 /*
@@ -913,10 +913,9 @@ int
 nfssvc_iod(p)
 	struct proc *p;
 {
-	register struct buf *bp, *nbp;
-	register int i, myiod;
-	struct vnode *vp;
-	int error = 0, s;
+	struct buf *bp;
+	int i, myiod;
+	int error = 0;
 
 	/*
 	 * Assign my position or return error if too many already running
@@ -944,39 +943,7 @@ nfssvc_iod(p)
 	    while ((bp = nfs_bufq.tqh_first) != NULL) {
 		/* Take one off the front of the list */
 		TAILQ_REMOVE(&nfs_bufq, bp, b_freelist);
-		if (bp->b_flags & B_READ)
-		    (void) nfs_doio(bp, NULL);
-		else do {
-		    /*
-		     * Look for a delayed write for the same vnode, so I can do 
-		     * it now. We must grab it before calling nfs_doio() to
-		     * avoid any risk of the vnode getting vclean()'d while
-		     * we are doing the write rpc.
-		     */
-		    vp = bp->b_vp;
-		    s = splbio();
-		    for (nbp = vp->v_dirtyblkhd.lh_first; nbp;
-			nbp = nbp->b_vnbufs.le_next) {
-			if ((nbp->b_flags &
-			    (B_BUSY|B_DELWRI|B_NEEDCOMMIT|B_NOCACHE))!=B_DELWRI)
-			    continue;
-			bremfree(nbp);
-			nbp->b_flags |= (B_BUSY|B_ASYNC);
-			break;
-		    }
-		    /*
-		     * For the delayed write, do the first part of nfs_bwrite()
-		     * up to, but not including nfs_strategy().
-		     */
-		    if (nbp) {
-			nbp->b_flags &= ~(B_READ|B_DONE|B_ERROR);
-			buf_undirty(bp);
-			nbp->b_vp->v_numoutput++;
-		    }
-		    splx(s);
-
-		    (void) nfs_doio(bp, NULL);
-		} while ((bp = nbp) != NULL);
+		(void) nfs_doio(bp, NULL);
 	    }
 	    if (error) {
 		PRELE(p);
diff --git a/sys/nfs/nfs_var.h b/sys/nfs/nfs_var.h
index 861eaf3059e..71985e581a8 100644
--- a/sys/nfs/nfs_var.h
+++ b/sys/nfs/nfs_var.h
@@ -1,4 +1,4 @@
-/*	$OpenBSD: nfs_var.h,v 1.15 2001/11/15 23:15:15 art Exp $	*/
+/*	$OpenBSD: nfs_var.h,v 1.16 2001/11/27 05:27:12 art Exp $	*/
 /*	$NetBSD: nfs_var.h,v 1.3 1996/02/18 11:53:54 fvdl Exp $	*/
 
 /*
@@ -119,7 +119,7 @@ int nfs_sillyrename __P((struct vnode *, struct vnode *,
 			 struct componentname *));
 int nfs_lookitup __P((struct vnode *, char *, int, struct ucred *,
 		      struct proc *, struct nfsnode **));
-int nfs_commit __P((struct vnode *, u_quad_t, int, struct proc *));
+int nfs_commit __P((struct vnode *, u_quad_t, unsigned, struct proc *));
 int nfs_bmap __P((void *));
 int nfs_strategy __P((void *));
 int nfs_mmap __P((void *));
@@ -134,7 +134,6 @@ int nfs_vfree __P((void *));
 int nfs_truncate __P((void *));
 int nfs_update __P((void *));
 int nfs_bwrite __P((void *));
-int nfs_writebp __P((struct buf *, int));
 int nfsspec_access __P((void *));
 int nfsspec_read __P((void *));
 int nfsspec_write __P((void *));
@@ -258,7 +257,16 @@ void nfsm_srvfattr __P((struct nfsrv_descript *, struct vattr *,
 int nfsrv_fhtovp __P((fhandle_t *, int, struct vnode **, struct ucred *,
 		      struct nfssvc_sock *, struct mbuf *, int *, int));
 int netaddr_match __P((int, union nethostaddr *, struct mbuf *));
+
 void nfs_clearcommit __P((struct mount *));
+void nfs_merge_commit_ranges __P((struct vnode *));
+int nfs_in_committed_range __P((struct vnode *, off_t, off_t));
+int nfs_in_tobecommitted_range __P((struct vnode *, off_t, off_t));
+void nfs_add_committed_range __P((struct vnode *, off_t, off_t));
+void nfs_del_committed_range __P((struct vnode *, off_t, off_t));
+void nfs_add_tobecommitted_range __P((struct vnode *, off_t, off_t));
+void nfs_del_tobecommitted_range __P((struct vnode *, off_t, off_t));
+
 int nfsrv_errmap __P((struct nfsrv_descript *, int));
 void nfsrvw_sort __P((gid_t *, int));
 void nfsrv_setcred __P((struct ucred *, struct ucred *));
diff --git a/sys/nfs/nfs_vfsops.c b/sys/nfs/nfs_vfsops.c
index 13420530fc3..91f84da52b6 100644
--- a/sys/nfs/nfs_vfsops.c
+++ b/sys/nfs/nfs_vfsops.c
@@ -1,4 +1,4 @@
-/*	$OpenBSD: nfs_vfsops.c,v 1.38 2001/11/14 23:37:33 mickey Exp $	*/
+/*	$OpenBSD: nfs_vfsops.c,v 1.39 2001/11/27 05:27:12 art Exp $	*/
 /*	$NetBSD: nfs_vfsops.c,v 1.46.4.1 1996/05/25 22:40:35 fvdl Exp $	*/
 
 /*
@@ -748,6 +748,8 @@ mountnfs(argp, mp, nam, pth, hst)
 	 * point.
 	 */
 	mp->mnt_stat.f_iosize = NFS_MAXDGRAMDATA;
+	mp->mnt_fs_bshift = DEV_BSHIFT;
+	mp->mnt_dev_bshift = -1;
 
 	return (0);
 bad:
@@ -856,8 +858,9 @@ loop:
 		 */
 		if (vp->v_mount != mp)
 			goto loop;
-		if (VOP_ISLOCKED(vp) || vp->v_dirtyblkhd.lh_first == NULL ||
-		    waitfor == MNT_LAZY)
+		if (waitfor == MNT_LAZY || VOP_ISLOCKED(vp) ||
+		    (LIST_EMPTY(&vp->v_dirtyblkhd) &&
+		     vp->v_uvm.u_obj.uo_npages == 0))
 			continue;
 		if (vget(vp, LK_EXCLUSIVE, p))
 			goto loop;
diff --git a/sys/nfs/nfs_vnops.c b/sys/nfs/nfs_vnops.c
index 0813b439cb2..4c176c1c1ec 100644
--- a/sys/nfs/nfs_vnops.c
+++ b/sys/nfs/nfs_vnops.c
@@ -1,4 +1,4 @@
-/*	$OpenBSD: nfs_vnops.c,v 1.39 2001/11/15 23:15:15 art Exp $	*/
+/*	$OpenBSD: nfs_vnops.c,v 1.40 2001/11/27 05:27:12 art Exp $	*/
 /*	$NetBSD: nfs_vnops.c,v 1.62.4.1 1996/07/08 20:26:52 jtc Exp $	*/
 
 /*
@@ -126,7 +126,9 @@ struct vnodeopv_entry_desc nfsv2_vnodeop_entries[] = {
 	{ &vop_advlock_desc, nfs_advlock },	/* advlock */
 	{ &vop_reallocblks_desc, nfs_reallocblks },	/* reallocblks */
 	{ &vop_bwrite_desc, nfs_bwrite },
-	{ (struct vnodeop_desc*)NULL, (int(*) __P((void *)))NULL }
+	{ &vop_getpages_desc, nfs_getpages },		/* getpages */
+	{ &vop_putpages_desc, nfs_putpages },		/* putpages */
+	{ NULL, NULL }
 };
 struct vnodeopv_desc nfsv2_vnodeop_opv_desc =
 	{ &nfsv2_vnodeop_p, nfsv2_vnodeop_entries };
@@ -151,7 +153,7 @@ struct vnodeopv_entry_desc spec_nfsv2nodeop_entries[] = {
 	{ &vop_ioctl_desc, spec_ioctl },	/* ioctl */
 	{ &vop_select_desc, spec_select },	/* select */
 	{ &vop_revoke_desc, spec_revoke },	/* revoke */
-	{ &vop_fsync_desc, nfs_fsync },		/* fsync */
+	{ &vop_fsync_desc, spec_fsync },	/* fsync */
 	{ &vop_remove_desc, spec_remove },	/* remove */
 	{ &vop_link_desc, spec_link },		/* link */
 	{ &vop_rename_desc, spec_rename },	/* rename */
@@ -373,11 +375,30 @@ nfs_open(v)
 		return (EACCES);
 	}
 
+	/*
+	 * Initialize read and write creds here, for swapfiles
+	 * and other paths that don't set the creds themselves.
+	 */
+
+	if (ap->a_mode & FREAD) {
+		if (np->n_rcred) {
+			crfree(np->n_rcred);
+		}
+		np->n_rcred = ap->a_cred;
+		crhold(np->n_rcred);
+	}
+	if (ap->a_mode & FWRITE) {
+		if (np->n_wcred) {
+			crfree(np->n_wcred);
+		}
+		np->n_wcred = ap->a_cred;
+		crhold(np->n_wcred);
+	}
+
 	if (np->n_flag & NMODIFIED) {
 		if ((error = nfs_vinvalbuf(vp, V_SAVE, ap->a_cred,
 			 ap->a_p, 1)) == EINTR)
 			return (error);
-		uvm_vnp_uncache(vp);
 		np->n_attrstamp = 0;
 		if (vp->v_type == VDIR)
 			np->n_direofoffset = 0;
@@ -395,7 +416,6 @@ nfs_open(v)
 			if ((error = nfs_vinvalbuf(vp, V_SAVE,
 				 ap->a_cred, ap->a_p, 1)) == EINTR)
 				return (error);
-			uvm_vnp_uncache(vp);
 			np->n_mtime = vattr.va_mtime.tv_sec;
 		}
 	}
@@ -2511,7 +2531,7 @@ int
 nfs_commit(vp, offset, cnt, procp)
 	struct vnode *vp;
 	u_quad_t offset;
-	int cnt;
+	unsigned cnt;
 	struct proc *procp;
 {
 	caddr_t cp;
@@ -2626,9 +2646,7 @@ nfs_fsync(v)
 }
 
 /*
- * Flush all the blocks associated with a vnode.
- * 	Walk through the buffer pool and push any dirty pages
- *	associated with the vnode.
+ * Flush all the data associated with a vnode.
  */
 int
 nfs_flush(vp, cred, waitfor, p, commit)
@@ -2638,154 +2656,19 @@ nfs_flush(vp, cred, waitfor, p, commit)
 	struct proc *p;
 	int commit;
 {
+	struct uvm_object *uobj = &vp->v_uvm.u_obj;
 	struct nfsnode *np = VTONFS(vp);
-	struct buf *bp;
-	int i;
-	struct buf *nbp;
-	struct nfsmount *nmp = VFSTONFS(vp->v_mount);
-	int s, error = 0, slptimeo = 0, slpflag = 0, retv, bvecpos;
-	int passone = 1;
-	u_quad_t off = (u_quad_t)-1, endoff = 0, toff;
-#ifndef NFS_COMMITBVECSIZ
-#define NFS_COMMITBVECSIZ	20
-#endif
-	struct buf *bvec[NFS_COMMITBVECSIZ];
+	int error;
+	int flushflags = PGO_ALLPAGES|PGO_CLEANIT|PGO_SYNCIO;
+	int rv;
 
-	if (nmp->nm_flag & NFSMNT_INT)
-		slpflag = PCATCH;
-	if (!commit)
-		passone = 0;
-	/*
-	 * A b_flags == (B_DELWRI | B_NEEDCOMMIT) block has been written to the
-	 * server, but nas not been committed to stable storage on the server
-	 * yet. On the first pass, the byte range is worked out and the commit
-	 * rpc is done. On the second pass, nfs_writebp() is called to do the
-	 * job.
-	 */
-again:
-	bvecpos = 0;
-	if (NFS_ISV3(vp) && commit) {
-		s = splbio();
-		for (bp = vp->v_dirtyblkhd.lh_first; bp; bp = nbp) {
-			nbp = bp->b_vnbufs.le_next;
-			if (bvecpos >= NFS_COMMITBVECSIZ)
-				break;
-			if ((bp->b_flags & (B_BUSY | B_DELWRI | B_NEEDCOMMIT))
-				!= (B_DELWRI | B_NEEDCOMMIT))
-				continue;
-			bremfree(bp);
-			bp->b_flags |= (B_BUSY | B_WRITEINPROG);
-			/*
-			 * A list of these buffers is kept so that the
-			 * second loop knows which buffers have actually
-			 * been committed. This is necessary, since there
-			 * may be a race between the commit rpc and new
-			 * uncommitted writes on the file.
-			 */
-			bvec[bvecpos++] = bp;
-			toff = ((u_quad_t)bp->b_blkno) * DEV_BSIZE +
-				bp->b_dirtyoff;
-			if (toff < off)
-				off = toff;
-			toff += (u_quad_t)(bp->b_dirtyend - bp->b_dirtyoff);
-			if (toff > endoff)
-				endoff = toff;
-		}
-		splx(s);
-	}
-	if (bvecpos > 0) {
-		/*
-		 * Commit data on the server, as required.
-		 */
-		retv = nfs_commit(vp, off, (int)(endoff - off), p);
-		if (retv == NFSERR_STALEWRITEVERF)
-			nfs_clearcommit(vp->v_mount);
-		/*
-		 * Now, either mark the blocks I/O done or mark the
-		 * blocks dirty, depending on whether the commit
-		 * succeeded.
-		 */
-		for (i = 0; i < bvecpos; i++) {
-			bp = bvec[i];
-			bp->b_flags &= ~(B_NEEDCOMMIT | B_WRITEINPROG);
-			if (retv)
-			    brelse(bp);
-			else {
-			    s = splbio();
-			    buf_undirty(bp);
-			    vp->v_numoutput++;
-			    bp->b_flags |= B_ASYNC;
-			    bp->b_flags &= ~(B_READ|B_DONE|B_ERROR);
-			    bp->b_dirtyoff = bp->b_dirtyend = 0;
-			    splx(s);
-			    biodone(bp);
-			}
-		}
-	}
+	error = 0;
 
-	/*
-	 * Start/do any write(s) that are required.
-	 */
-loop:
-	s = splbio();
-	for (bp = vp->v_dirtyblkhd.lh_first; bp; bp = nbp) {
-		nbp = bp->b_vnbufs.le_next;
-		if (bp->b_flags & B_BUSY) {
-			if (waitfor != MNT_WAIT || passone)
-				continue;
-			bp->b_flags |= B_WANTED;
-			error = tsleep((caddr_t)bp, slpflag | (PRIBIO + 1),
-				"nfsfsync", slptimeo);
-			splx(s);
-			if (error) {
-			    if (nfs_sigintr(nmp, (struct nfsreq *)0, p))
-				return (EINTR);
-			    if (slpflag == PCATCH) {
-				slpflag = 0;
-				slptimeo = 2 * hz;
-			    }
-			}
-			goto loop;
-		}
-		if ((bp->b_flags & B_DELWRI) == 0)
-			panic("nfs_fsync: not dirty");
-		if ((passone || !commit) && (bp->b_flags & B_NEEDCOMMIT))
-			continue;
-		bremfree(bp);
-		if (passone || !commit)
-		    bp->b_flags |= (B_BUSY|B_ASYNC);
-		else
-		    bp->b_flags |= (B_BUSY|B_ASYNC|B_WRITEINPROG|B_NEEDCOMMIT);
-		splx(s);
-		VOP_BWRITE(bp);
-		goto loop;
-	}
-	splx(s);
-	if (passone) {
-		passone = 0;
-		goto again;
-	}
-	if (waitfor == MNT_WAIT) {
- loop2:
-	        s = splbio();
-		error = vwaitforio(vp, slpflag, "nfs_fsync", slptimeo);
-		splx(s);
-		if (error) {
-			if (nfs_sigintr(nmp, (struct nfsreq *)0, p))
-				return (EINTR);
-			if (slpflag == PCATCH) {
-				slpflag = 0;
-				slptimeo = 2 * hz;
-			}
-			goto loop2;
-		}
-			
-		if (vp->v_dirtyblkhd.lh_first && commit) {
-#if 0
-			vprint("nfs_fsync: dirty", vp);
-#endif
-			goto loop;
-		}
+	simple_lock(&uobj->vmobjlock);
+	rv = (uobj->pgops->pgo_flush)(uobj, 0, 0, flushflags);
+	simple_unlock(&uobj->vmobjlock);
+	if (!rv) {
+		error = EIO;
 	}
 	if (np->n_flag & NWRITEERR) {
 		error = np->n_error;
@@ -2860,7 +2743,7 @@ nfs_print(v)
 }
 
 /*
- * Just call nfs_writebp() with the force argument set to 1.
+ * Just call bwrite().
  */
 int
 nfs_bwrite(v)
@@ -2870,76 +2753,7 @@ nfs_bwrite(v)
 		struct buf *a_bp;
 	} */ *ap = v;
 
-	return (nfs_writebp(ap->a_bp, 1));
-}
-
-/*
- * This is a clone of vop_generic_bwrite(), except that B_WRITEINPROG isn't set unless
- * the force flag is one and it also handles the B_NEEDCOMMIT flag.
- */
-int
-nfs_writebp(bp, force)
-	register struct buf *bp;
-	int force;
-{
-	register int oldflags = bp->b_flags, retv = 1;
-	register struct proc *p = curproc;	/* XXX */
-	off_t off;
-	int   s;
-
-	if(!(bp->b_flags & B_BUSY))
-		panic("bwrite: buffer is not busy???");
-
-#ifdef fvdl_debug
-	printf("nfs_writebp(%x): vp %x voff %d vend %d doff %d dend %d\n",
-	    bp, bp->b_vp, bp->b_validoff, bp->b_validend, bp->b_dirtyoff,
-	    bp->b_dirtyend);
-#endif
-	bp->b_flags &= ~(B_READ|B_DONE|B_ERROR);
-
-	s = splbio();
-	buf_undirty(bp);
-
-	if ((oldflags & B_ASYNC) && !(oldflags & B_DELWRI) && p)
-		++p->p_stats->p_ru.ru_oublock;
-
-	bp->b_vp->v_numoutput++;
-	splx(s);
-
-	/*
-	 * If B_NEEDCOMMIT is set, a commit rpc may do the trick. If not
-	 * an actual write will have to be scheduled via. VOP_STRATEGY().
-	 * If B_WRITEINPROG is already set, then push it with a write anyhow.
-	 */
-	if ((oldflags & (B_NEEDCOMMIT | B_WRITEINPROG)) == B_NEEDCOMMIT) {
-		off = ((u_quad_t)bp->b_blkno) * DEV_BSIZE + bp->b_dirtyoff;
-		bp->b_flags |= B_WRITEINPROG;
-		retv = nfs_commit(bp->b_vp, off, bp->b_dirtyend-bp->b_dirtyoff,
-			bp->b_proc);
-		bp->b_flags &= ~B_WRITEINPROG;
-		if (!retv) {
-			bp->b_dirtyoff = bp->b_dirtyend = 0;
-			bp->b_flags &= ~B_NEEDCOMMIT;
-			biodone(bp);
-		} else if (retv == NFSERR_STALEWRITEVERF)
-			nfs_clearcommit(bp->b_vp->v_mount);
-	}
-	if (retv) {
-		if (force)
-			bp->b_flags |= B_WRITEINPROG;
-		VOP_STRATEGY(bp);
-	}
-
-	if( (oldflags & B_ASYNC) == 0) {
-		int rtval = biowait(bp);
-		if (!(oldflags & B_DELWRI) && p) {
-			++p->p_stats->p_ru.ru_oublock;
-		}
-		brelse(bp);
-		return (rtval);
-	} 
-
-	return (0);
+	return (bwrite(ap->a_bp));
 }
 
 /*
diff --git a/sys/nfs/nfsnode.h b/sys/nfs/nfsnode.h
index e1e0fd64327..42aaddfa637 100644
--- a/sys/nfs/nfsnode.h
+++ b/sys/nfs/nfsnode.h
@@ -1,4 +1,4 @@
-/*	$OpenBSD: nfsnode.h,v 1.11 2001/11/15 23:15:15 art Exp $	*/
+/*	$OpenBSD: nfsnode.h,v 1.12 2001/11/27 05:27:12 art Exp $	*/
 /*	$NetBSD: nfsnode.h,v 1.16 1996/02/18 11:54:04 fvdl Exp $	*/
 
 /*
@@ -119,8 +119,20 @@ struct nfsnode {
 	nfsfh_t			n_fh;		/* Small File Handle */
 	struct ucred		*n_rcred;
 	struct ucred		*n_wcred;
+	off_t			n_pushedlo;     /* 1st blk in commited range */
+	off_t			n_pushedhi;     /* Last block in range */
+	off_t			n_pushlo;       /* 1st block in commit range */
+	off_t			n_pushhi;       /* Last block in range */
+	struct lock		n_commitlock;   /* Serialize commits XXX */
+	int			n_commitflags;
 };
 
+/*
+ * Values for n_commitflags
+ */
+#define NFS_COMMIT_PUSH_VALID		0x0001	/* push range valid */
+#define NFS_COMMIT_PUSHED_VALID		0x0002	/* pushed range valid */
+
 #define n_atim		n_un1.nf_atim
 #define n_mtim		n_un2.nf_mtim
 #define n_sillyrename	n_un3.nf_silly
@@ -199,6 +211,8 @@ int	nfs_bwrite __P((void *));
 int	nfs_vget __P((struct mount *, ino_t, struct vnode **));
 #define nfs_reallocblks \
 	((int (*) __P((void *)))eopnotsupp)
+int	nfs_getpages __P((void *));
+int	nfs_putpages __P((void *));
 
 /* other stuff */
 int	nfs_removeit __P((struct sillyrename *));
diff --git a/sys/sys/buf.h b/sys/sys/buf.h
index cabdcbbe084..054a07c24d5 100644
--- a/sys/sys/buf.h
+++ b/sys/sys/buf.h
@@ -1,4 +1,4 @@
-/*	$OpenBSD: buf.h,v 1.33 2001/11/15 23:15:15 art Exp $	*/
+/*	$OpenBSD: buf.h,v 1.34 2001/11/27 05:27:12 art Exp $	*/
 /*	$NetBSD: buf.h,v 1.25 1997/04/09 21:12:17 mycroft Exp $	*/
 
 /*
@@ -68,6 +68,7 @@ extern struct bio_ops {
 	void	(*io_deallocate) __P((struct buf *));
 	void	(*io_movedeps) __P((struct buf *, struct buf *));
 	int	(*io_countdeps) __P((struct buf *, int, int));
+	void	(*io_pageiodone) __P((struct buf *));
 } bioops;
 
 /*
@@ -96,10 +97,7 @@ struct buf {
 					/* Function to call upon completion. */
 	void	(*b_iodone) __P((struct buf *));
 	struct	vnode *b_vp;		/* Device vnode. */
-	int	b_dirtyoff;		/* Offset in buffer of dirty region. */
-	int	b_dirtyend;		/* Offset of end of dirty region. */
-	int	b_validoff;		/* Offset in buffer of valid region. */
-	int	b_validend;		/* Offset of end of valid region. */
+	void	*b_private;
  	struct	workhead b_dep;		/* List of filesystem dependencies. */
 };
 
@@ -120,7 +118,6 @@ struct buf {
  * These flags are kept in b_flags.
  */
 #define	B_AGE		0x00000001	/* Move to age queue when I/O done. */
-#define	B_NEEDCOMMIT	0x00000002	/* Needs committing to stable storage */
 #define	B_ASYNC		0x00000004	/* Start I/O, do not wait. */
 #define	B_BAD		0x00000008	/* Bad block revectoring in progress. */
 #define	B_BUSY		0x00000010	/* I/O in progress. */
@@ -144,7 +141,6 @@ struct buf {
 #define	B_UAREA		0x00400000	/* Buffer describes Uarea I/O. */
 #define	B_WANTED	0x00800000	/* Process wants this buffer. */
 #define	B_WRITE		0x00000000	/* Write buffer (pseudo flag). */
-#define	B_WRITEINPROG	0x01000000	/* Write in progress. */
 #define	B_XXX		0x02000000	/* Debugging flag. */
 #define	B_DEFERRED	0x04000000	/* Skipped over for cleaning */
 #define	B_SCANNED	0x08000000	/* Block already pushed during sync */
diff --git a/sys/sys/mount.h b/sys/sys/mount.h
index f398a301c69..50f59e4a532 100644
--- a/sys/sys/mount.h
+++ b/sys/sys/mount.h
@@ -1,4 +1,4 @@
-/*	$OpenBSD: mount.h,v 1.40 2001/11/21 21:13:34 csapuntz Exp $	*/
+/*	$OpenBSD: mount.h,v 1.41 2001/11/27 05:27:12 art Exp $	*/
 /*	$NetBSD: mount.h,v 1.48 1996/02/18 11:55:47 fvdl Exp $	*/
 
 /*
@@ -336,6 +336,8 @@ struct mount {
 	struct lock     mnt_lock;               /* mount structure lock */
 	int		mnt_flag;		/* flags */
 	int		mnt_maxsymlinklen;	/* max size of short symlink */
+	int		mnt_fs_bshift;		/* offset shift for lblkno */
+	int		mnt_dev_bshift;		/* shift for device sectors */
 	struct statfs	mnt_stat;		/* cache of filesystem stats */
 	qaddr_t		mnt_data;		/* private data */
 };
diff --git a/sys/sys/param.h b/sys/sys/param.h
index a950b196cc3..59fe3a01548 100644
--- a/sys/sys/param.h
+++ b/sys/sys/param.h
@@ -1,4 +1,4 @@
-/*	$OpenBSD: param.h,v 1.41 2001/09/11 13:11:18 deraadt Exp $	*/
+/*	$OpenBSD: param.h,v 1.42 2001/11/27 05:27:12 art Exp $	*/
 /*	$NetBSD: param.h,v 1.23 1996/03/17 01:02:29 thorpej Exp $	*/
 
 /*-
@@ -227,3 +227,16 @@
 #define RFCNAMEG	(1<<10) /* UNIMPL zero plan9 `name space' */
 #define RFCENVG		(1<<11) /* UNIMPL zero plan9 `env space' */
 #define RFCFDG		(1<<12)	/* zero fd table */
+
+#ifdef _KERNEL
+/*
+ * Defaults for Unified Buffer Cache parameters.
+ */
+
+#ifndef UBC_WINSIZE
+#define UBC_WINSIZE 8192
+#endif
+#ifndef UBC_NWINS
+#define UBC_NWINS 1024
+#endif
+#endif /* _KERNEL */
diff --git a/sys/sys/vnode.h b/sys/sys/vnode.h
index 64a90990d0e..9eaf484201f 100644
--- a/sys/sys/vnode.h
+++ b/sys/sys/vnode.h
@@ -1,4 +1,4 @@
-/*	$OpenBSD: vnode.h,v 1.41 2001/11/15 06:22:30 art Exp $	*/
+/*	$OpenBSD: vnode.h,v 1.42 2001/11/27 05:27:12 art Exp $	*/
 /*	$NetBSD: vnode.h,v 1.38 1996/02/29 20:59:05 cgd Exp $	*/
 
 /*
@@ -90,8 +90,10 @@ struct vnode {
 	struct uvm_vnode v_uvm;			/* uvm data */
 	int	(**v_op) __P((void *));		/* vnode operations vector */
 	enum	vtype v_type;			/* vnode type */
-	u_int	v_flag;				/* vnode flags (see below) */
-	u_int   v_usecount;			/* reference count of users */
+#define v_flag v_uvm.u_flags
+#define v_usecount v_uvm.u_obj.uo_refs
+#define v_interlock v_uvm.u_obj.vmobjlock
+#define v_numoutput v_uvm.u_nio
 	/* reference count of writers */
 	u_int   v_writecount;			
 	/* Flags that can be read/written in interrupts */
@@ -103,7 +105,6 @@ struct vnode {
 	LIST_ENTRY(vnode) v_mntvnodes;		/* vnodes for mount point */
 	struct	buflists v_cleanblkhd;		/* clean blocklist head */
 	struct	buflists v_dirtyblkhd;		/* dirty blocklist head */
-	u_int   v_numoutput;			/* num of writes in progress */
 	LIST_ENTRY(vnode) v_synclist;		/* vnode with dirty buffers */
 	union {
 		struct mount	*vu_mountedhere;/* ptr to mounted vfs (VDIR) */
@@ -112,8 +113,8 @@ struct vnode {
 		struct fifoinfo	*vu_fifoinfo;	/* fifo (VFIFO) */
 	} v_un;
 
-	struct  simplelock v_interlock;		/* lock on usecount and flag */
 	struct  lock *v_vnlock;			/* used for non-locking fs's */
+	struct	lock v_glock;			/* getpage lock */
 	enum	vtagtype v_tag;			/* type of underlying data */
 	void 	*v_data;			/* private data for fs */
 	struct {
@@ -137,6 +138,9 @@ struct vnode {
 #define	VXWANT		0x0200	/* process is waiting for vnode */
 #define	VALIASED	0x0800	/* vnode has an alias */
 #define VLOCKSWORK	0x4000	/* FS supports locking discipline */
+#define	VDIRTY		0x8000	/* vnode possibly has dirty pages */
+
+#define VSIZENOTSET	((voff_t)-1)
 
 /*
  * (v_bioflag) Flags that may be manipulated by interrupt handlers
@@ -446,6 +450,12 @@ int	vop_generic_unlock __P((void *));
 int	vop_generic_revoke __P((void *));
 int	vop_generic_kqfilter __P((void *));
 
+/* XXXUBC - doesn't really belong here. */
+int	genfs_getpages __P((void *));
+int	genfs_putpages __P((void *));
+int	genfs_size __P((void *));
+
+
 int	vn_stat __P((struct vnode *vp, struct stat *sb, struct proc *p));
 int	vn_statfile __P((struct file *fp, struct stat *sb, struct proc *p));
 int	vn_writechk __P((struct vnode *vp));
diff --git a/sys/sys/vnode_if.h b/sys/sys/vnode_if.h
index 00cdadabe25..57aff6f4c97 100644
--- a/sys/sys/vnode_if.h
+++ b/sys/sys/vnode_if.h
@@ -3,7 +3,7 @@
  * (Modifications made here may easily be lost!)
  *
  * Created from the file:
- *	OpenBSD: vnode_if.src,v 1.11 2001/06/23 02:21:05 csapuntz Exp 
+ *	OpenBSD: vnode_if.src,v 1.13 2001/07/26 20:24:47 millert Exp 
  * by the script:
  *	OpenBSD: vnode_if.sh,v 1.8 2001/02/26 17:34:18 art Exp 
  */
@@ -397,6 +397,52 @@ struct vop_whiteout_args {
 extern struct vnodeop_desc vop_whiteout_desc;
 int VOP_WHITEOUT __P((struct vnode *, struct componentname *, int));
 
+struct vop_ballocn_args {
+	struct vnodeop_desc *a_desc;
+	struct vnode *a_vp;
+	off_t a_offset;
+	off_t a_length;
+	struct ucred *a_cred;
+	int a_flags;
+};
+extern struct vnodeop_desc vop_ballocn_desc;
+int VOP_BALLOCN __P((struct vnode *, off_t, off_t, struct ucred *, int));
+
+struct vop_getpages_args {
+	struct vnodeop_desc *a_desc;
+	struct vnode *a_vp;
+	voff_t a_offset;
+	vm_page_t *a_m;
+	int *a_count;
+	int a_centeridx;
+	vm_prot_t a_access_type;
+	int a_advice;
+	int a_flags;
+};
+extern struct vnodeop_desc vop_getpages_desc;
+int VOP_GETPAGES __P((struct vnode *, voff_t, vm_page_t *, int *, int, 
+    vm_prot_t, int, int));
+
+struct vop_putpages_args {
+	struct vnodeop_desc *a_desc;
+	struct vnode *a_vp;
+	vm_page_t *a_m;
+	int a_count;
+	int a_flags;
+	int *a_rtvals;
+};
+extern struct vnodeop_desc vop_putpages_desc;
+int VOP_PUTPAGES __P((struct vnode *, vm_page_t *, int, int, int *));
+
+struct vop_size_args {
+	struct vnodeop_desc *a_desc;
+	struct vnode *a_vp;
+	off_t a_size;
+	off_t *a_eobp;
+};
+extern struct vnodeop_desc vop_size_desc;
+int VOP_SIZE __P((struct vnode *, off_t, off_t *));
+
 /* Special cases: */
 #include <sys/buf.h>
 
diff --git a/sys/ufs/ext2fs/ext2fs_balloc.c b/sys/ufs/ext2fs/ext2fs_balloc.c
index 849a8864b2a..78fb0a8371c 100644
--- a/sys/ufs/ext2fs/ext2fs_balloc.c
+++ b/sys/ufs/ext2fs/ext2fs_balloc.c
@@ -1,5 +1,4 @@
-/*	$OpenBSD: ext2fs_balloc.c,v 1.7 2001/11/06 19:53:21 miod Exp $	*/
-/*	$NetBSD: ext2fs_balloc.c,v 1.10 2001/07/04 21:16:01 chs Exp $	*/
+/*	$NetBSD: ext2fs_balloc.c,v 1.8 2000/12/10 06:38:31 chs Exp $	*/
 
 /*
  * Copyright (c) 1997 Manuel Bouyer.
@@ -44,8 +43,9 @@
 #include <sys/proc.h>
 #include <sys/file.h>
 #include <sys/vnode.h>
+#include <sys/mount.h>
 
-#include <uvm/uvm_extern.h>
+#include <uvm/uvm.h>
 
 #include <ufs/ufs/quota.h>
 #include <ufs/ufs/inode.h>
@@ -73,8 +73,13 @@ ext2fs_buf_alloc(struct inode *ip, daddr_t bn, int size, struct ucred *cred,
 	u_int deallocated;
 	ufs_daddr_t *allocib, *blkp, *allocblk, allociblk[NIADDR + 1];
 	int unwindidx = -1;
+	UVMHIST_FUNC("ext2fs_buf_alloc"); UVMHIST_CALLED(ubchist);
 
-	*bpp = NULL;
+	UVMHIST_LOG(ubchist, "bn 0x%x", bn,0,0,0);
+
+	if (bpp != NULL) {
+		*bpp = NULL;
+	}
 	if (bn < 0)
 		return (EFBIG);
 	fs = ip->i_e2fs;
@@ -86,20 +91,29 @@ ext2fs_buf_alloc(struct inode *ip, daddr_t bn, int size, struct ucred *cred,
 	if (bn < NDADDR) {
 		nb = fs2h32(ip->i_e2fs_blocks[bn]);
 		if (nb != 0) {
-			error = bread(vp, bn, fs->e2fs_bsize, NOCRED, &bp);
-			if (error) {
-				brelse(bp);
-				return (error);
+
+			/*
+			 * the block is already allocated, just read it.
+			 */
+
+			if (bpp != NULL) {
+				error = bread(vp, bn, fs->e2fs_bsize, NOCRED,
+					      &bp);
+				if (error) {
+					brelse(bp);
+					return (error);
+				}
+				*bpp = bp;
 			}
-			*bpp = bp;
 			return (0);
 		}
 
 		/*
 		 * allocate a new direct block.
 		 */
+
 		error = ext2fs_alloc(ip, bn,
-		    ext2fs_blkpref(ip, bn, (int)bn, &ip->i_e2fs_blocks[0]),
+		    ext2fs_blkpref(ip, bn, bn, &ip->i_e2fs_blocks[0]),
 		    cred, &newb);
 		if (error)
 			return (error);
@@ -107,11 +121,13 @@ ext2fs_buf_alloc(struct inode *ip, daddr_t bn, int size, struct ucred *cred,
 		ip->i_e2fs_last_blk = newb;
 		ip->i_e2fs_blocks[bn] = h2fs32(newb);
 		ip->i_flag |= IN_CHANGE | IN_UPDATE;
-		bp = getblk(vp, bn, fs->e2fs_bsize, 0, 0);
-		bp->b_blkno = fsbtodb(fs, newb);
-		if (flags & B_CLRBUF)
-			clrbuf(bp);
-		*bpp = bp;
+		if (bpp != NULL) {
+			bp = getblk(vp, bn, fs->e2fs_bsize, 0, 0);
+			bp->b_blkno = fsbtodb(fs, newb);
+			if (flags & B_CLRBUF)
+				clrbuf(bp);
+			*bpp = bp;
+		}
 		return (0);
 	}
 	/*
@@ -229,26 +245,30 @@ ext2fs_buf_alloc(struct inode *ip, daddr_t bn, int size, struct ucred *cred,
 		} else {
 			bdwrite(bp);
 		}
-		nbp = getblk(vp, lbn, fs->e2fs_bsize, 0, 0);
-		nbp->b_blkno = fsbtodb(fs, nb);
-		if (flags & B_CLRBUF)
-			clrbuf(nbp);
-		*bpp = nbp;
+		if (bpp != NULL) {
+			nbp = getblk(vp, lbn, fs->e2fs_bsize, 0, 0);
+			nbp->b_blkno = fsbtodb(fs, nb);
+			if (flags & B_CLRBUF)
+				clrbuf(nbp);
+			*bpp = nbp;
+		}
 		return (0);
 	}
 	brelse(bp);
-	if (flags & B_CLRBUF) {
-		error = bread(vp, lbn, (int)fs->e2fs_bsize, NOCRED, &nbp);
-		if (error) {
-			brelse(nbp);
-			goto fail;
+	if (bpp != NULL) {
+		if (flags & B_CLRBUF) {
+			error = bread(vp, lbn, (int)fs->e2fs_bsize, NOCRED,
+				      &nbp);
+			if (error) {
+				brelse(nbp);
+				goto fail;
+			}
+		} else {
+			nbp = getblk(vp, lbn, fs->e2fs_bsize, 0, 0);
+			nbp->b_blkno = fsbtodb(fs, nb);
 		}
-	} else {
-		nbp = getblk(vp, lbn, fs->e2fs_bsize, 0, 0);
-		nbp->b_blkno = fsbtodb(fs, nb);
+		*bpp = nbp;
 	}
-
-	*bpp = nbp;
 	return (0);
 fail:
 	/*
@@ -292,3 +312,153 @@ fail:
 	}
 	return error;
 }
+
+int
+ext2fs_ballocn(v)
+	void *v;
+{
+	struct vop_ballocn_args /* {
+		struct vnode *a_vp;
+		off_t a_offset;
+		off_t a_length;
+		struct ucred *a_cred;
+		int a_flags;
+	} */ *ap = v;
+	off_t off, len;
+	struct vnode *vp = ap->a_vp;
+	struct inode *ip = VTOI(vp);
+	struct m_ext2fs *fs = ip->i_e2fs;
+	int error, delta, bshift, bsize;
+	UVMHIST_FUNC("ext2fs_ballocn"); UVMHIST_CALLED(ubchist);
+
+	bshift = fs->e2fs_bshift;
+	bsize = 1 << bshift;
+
+	off = ap->a_offset;
+	len = ap->a_length;
+
+	delta = off & (bsize - 1);
+	off -= delta;
+	len += delta;
+
+	while (len > 0) {
+		bsize = min(bsize, len);
+		UVMHIST_LOG(ubchist, "off 0x%x len 0x%x bsize 0x%x",
+			    off, len, bsize, 0);
+
+		error = ext2fs_buf_alloc(ip, lblkno(fs, off), bsize, ap->a_cred,
+		    NULL, ap->a_flags);
+		if (error) {
+			UVMHIST_LOG(ubchist, "error %d", error, 0,0,0);
+			return error;
+		}
+
+		/*
+		 * increase file size now, VOP_BALLOC() requires that
+		 * EOF be up-to-date before each call.
+		 */
+
+		if (ip->i_e2fs_size < off + bsize) {
+			UVMHIST_LOG(ubchist, "old 0x%x new 0x%x",
+				    ip->i_e2fs_size, off + bsize,0,0);
+			ip->i_e2fs_size = off + bsize;
+			if (vp->v_uvm.u_size < ip->i_e2fs_size) {
+				uvm_vnp_setsize(vp, ip->i_e2fs_size);
+			}
+		}
+
+		off += bsize;
+		len -= bsize;
+	}
+	return 0;
+}
+
+/*
+ * allocate a range of blocks in a file.
+ * after this function returns, any page entirely contained within the range
+ * will map to invalid data and thus must be overwritten before it is made
+ * accessible to others.
+ */
+
+int
+ext2fs_balloc_range(vp, off, len, cred, flags)
+	struct vnode *vp;
+	off_t off, len;
+	struct ucred *cred;
+	int flags;
+{
+	off_t oldeof, eof, pagestart;
+	struct uvm_object *uobj;
+	int i, delta, error, npages;
+	int bshift = vp->v_mount->mnt_fs_bshift;
+	int bsize = 1 << bshift;
+	int ppb = max(bsize >> PAGE_SHIFT, 1);
+	struct vm_page *pgs[ppb];
+	UVMHIST_FUNC("ext2fs_balloc_range"); UVMHIST_CALLED(ubchist);
+	UVMHIST_LOG(ubchist, "vp %p off 0x%x len 0x%x u_size 0x%x",
+		    vp, off, len, vp->v_uvm.u_size);
+
+	error = 0;
+	uobj = &vp->v_uvm.u_obj;
+	oldeof = vp->v_uvm.u_size;
+	eof = max(oldeof, off + len);
+	UVMHIST_LOG(ubchist, "new eof 0x%x", eof,0,0,0);
+	pgs[0] = NULL;
+
+	/*
+	 * cache the new range of the file.  this will create zeroed pages
+	 * where the new block will be and keep them locked until the
+	 * new block is allocated, so there will be no window where
+	 * the old contents of the new block is visible to racing threads.
+	 */
+
+	pagestart = trunc_page(off) & ~(bsize - 1);
+	npages = min(ppb, (round_page(eof) - pagestart) >> PAGE_SHIFT);
+	memset(pgs, 0, npages);
+	simple_lock(&uobj->vmobjlock);
+	error = VOP_GETPAGES(vp, pagestart, pgs, &npages, 0,
+	    VM_PROT_READ, 0, PGO_SYNCIO | PGO_PASTEOF);
+	if (error) {
+		UVMHIST_LOG(ubchist, "getpages %d", error,0,0,0);
+		goto errout;
+	}
+	for (i = 0; i < npages; i++) {
+		UVMHIST_LOG(ubchist, "got pgs[%d] %p", i, pgs[i],0,0);
+		KASSERT((pgs[i]->flags & PG_RELEASED) == 0);
+		pgs[i]->flags &= ~PG_CLEAN;
+		uvm_pageactivate(pgs[i]);
+	}
+
+	/*
+	 * adjust off to be block-aligned.
+	 */
+
+	delta = off & (bsize - 1);
+	off -= delta;
+	len += delta;
+
+	/*
+	 * now allocate the range.
+	 */
+
+	lockmgr(&vp->v_glock, LK_EXCLUSIVE, NULL, curproc);
+	error = VOP_BALLOCN(vp, off, len, cred, flags);
+	UVMHIST_LOG(ubchist, "ballocn %d", error,0,0,0);
+	lockmgr(&vp->v_glock, LK_RELEASE, NULL, curproc);
+
+	/*
+	 * unbusy any pages we are holding.
+	 */
+
+errout:
+	simple_lock(&uobj->vmobjlock);
+	if (error) {
+		(void) (uobj->pgops->pgo_flush)(uobj, oldeof, pagestart + ppb,
+		    PGO_FREE);
+	}
+	if (pgs[0] != NULL) {
+		uvm_page_unbusy(pgs, npages);
+	}
+	simple_unlock(&uobj->vmobjlock);
+	return (error);
+}
diff --git a/sys/ufs/ext2fs/ext2fs_extern.h b/sys/ufs/ext2fs/ext2fs_extern.h
index b7a3f96df38..af23fb6ef2d 100644
--- a/sys/ufs/ext2fs/ext2fs_extern.h
+++ b/sys/ufs/ext2fs/ext2fs_extern.h
@@ -1,5 +1,5 @@
-/*	$OpenBSD: ext2fs_extern.h,v 1.10 2001/09/18 00:39:15 art Exp $	*/
-/*	$NetBSD: ext2fs_extern.h,v 1.1 1997/06/11 09:33:55 bouyer Exp $	*/
+/*	$OpenBSD: ext2fs_extern.h,v 1.11 2001/11/27 05:27:12 art Exp $	*/
+/*	$NetBSD: ext2fs_extern.h,v 1.9 2000/11/27 08:39:53 chs Exp $	*/
 
 /*-
  * Copyright (c) 1997 Manuel Bouyer.
@@ -74,6 +74,9 @@ int ext2fs_inode_free(struct inode *pip, ino_t ino, int mode);
 /* ext2fs_balloc.c */
 int ext2fs_buf_alloc(struct inode *, daddr_t, int, struct ucred *,
 			struct buf **, int);
+int ext2fs_ballocn __P((void *));
+int ext2fs_balloc_range __P((struct vnode *, off_t, off_t, struct ucred *,
+			     int));
 
 /* ext2fs_bmap.c */
 int ext2fs_bmap __P((void *));
diff --git a/sys/ufs/ext2fs/ext2fs_inode.c b/sys/ufs/ext2fs/ext2fs_inode.c
index 4af28d9bf0e..f77c99c47b5 100644
--- a/sys/ufs/ext2fs/ext2fs_inode.c
+++ b/sys/ufs/ext2fs/ext2fs_inode.c
@@ -1,5 +1,4 @@
-/*	$OpenBSD: ext2fs_inode.c,v 1.17 2001/11/06 19:53:21 miod Exp $	*/
-/*	$NetBSD: ext2fs_inode.c,v 1.24 2001/06/19 12:59:18 wiz Exp $	*/
+/*	$NetBSD: ext2fs_inode.c,v 1.23 2001/02/18 20:17:04 chs Exp $	*/
 
 /*
  * Copyright (c) 1997 Manuel Bouyer.
@@ -59,8 +58,10 @@
 #include <ufs/ext2fs/ext2fs.h>
 #include <ufs/ext2fs/ext2fs_extern.h>
 
+extern int prtactive;
+
 static int ext2fs_indirtrunc __P((struct inode *, ufs_daddr_t, ufs_daddr_t,
-				ufs_daddr_t, int, long *));
+				  ufs_daddr_t, int, long *));
 
 /*
  * Last reference to an inode.  If necessary, write or delete it.
@@ -78,7 +79,6 @@ ext2fs_inactive(v)
 	struct proc *p = ap->a_p;
 	struct timespec ts;
 	int error = 0;
-	extern int prtactive;
 	
 	if (prtactive && vp->v_usecount != 0)
 		vprint("ext2fs_inactive: pushing active", vp);
@@ -171,14 +171,13 @@ ext2fs_truncate(struct inode *oip, off_t length, int flags, struct ucred *cred)
 {
 	struct vnode *ovp = ITOV(oip);
 	ufs_daddr_t lastblock;
-	ufs_daddr_t bn, lbn, lastiblock[NIADDR], indir_lbn[NIADDR];
+	ufs_daddr_t bn, lastiblock[NIADDR], indir_lbn[NIADDR];
 	ufs_daddr_t oldblks[NDADDR + NIADDR], newblks[NDADDR + NIADDR];
 	struct m_ext2fs *fs;
-	struct buf *bp;
 	int offset, size, level;
 	long count, nblocks, vflags, blocksreleased = 0;
 	int i;
-	int aflags, error, allerror;
+	int error, allerror;
 	off_t osize;
 
 	if (length < 0)
@@ -219,22 +218,8 @@ ext2fs_truncate(struct inode *oip, off_t length, int flags, struct ucred *cred)
 		if (length > fs->fs_maxfilesize)
 			return (EFBIG);
 #endif
-		offset = blkoff(fs, length - 1);
-		lbn = lblkno(fs, length - 1);
-		aflags = B_CLRBUF;
-		if (flags & IO_SYNC)
-			aflags |= B_SYNC;
-		error = ext2fs_buf_alloc(oip, lbn, offset + 1, cred, &bp,
-		    aflags);
-		if (error)
-			return (error);
-		oip->i_e2fs_size = length;
-		uvm_vnp_setsize(ovp, length);
-		uvm_vnp_uncache(ovp);
-		if (aflags & B_SYNC)
-			bwrite(bp);
-		else
-			bawrite(bp);
+		ext2fs_balloc_range(ovp, length - 1, 1, cred,
+		    flags & IO_SYNC ? B_SYNC : 0);
 		oip->i_flag |= IN_CHANGE | IN_UPDATE;
 		return (ext2fs_update(oip, NULL, NULL, 1));
 	}
@@ -246,28 +231,15 @@ ext2fs_truncate(struct inode *oip, off_t length, int flags, struct ucred *cred)
 	 * of subsequent file growth.
 	 */
 	offset = blkoff(fs, length);
-	if (offset == 0) {
-		oip->i_e2fs_size = length;
-	} else {
-		lbn = lblkno(fs, length);
-		aflags = B_CLRBUF;
-		if (flags & IO_SYNC)
-			aflags |= B_SYNC;
-		error = ext2fs_buf_alloc(oip, lbn, offset, cred, &bp, 
-		    aflags);
-		if (error)
-			return (error);
-		oip->i_e2fs_size = length;
+	if (offset != 0) {
 		size = fs->e2fs_bsize;
-		uvm_vnp_setsize(ovp, length);
-		uvm_vnp_uncache(ovp);
-		bzero((char *)bp->b_data + offset, (u_int)(size - offset));
-		allocbuf(bp, size);
-		if (aflags & B_SYNC)
-			bwrite(bp);
-		else
-			bawrite(bp);
+
+		/* XXXUBC we should handle more than just VREG */
+		uvm_vnp_zerorange(ovp, length, size - offset);
 	}
+	oip->i_e2fs_size = length;
+	uvm_vnp_setsize(ovp, length);
+
 	/*
 	 * Calculate index into inode's block list of
 	 * last direct and indirect blocks (if any)
diff --git a/sys/ufs/ext2fs/ext2fs_readwrite.c b/sys/ufs/ext2fs/ext2fs_readwrite.c
index 9ae4322756f..94424055733 100644
--- a/sys/ufs/ext2fs/ext2fs_readwrite.c
+++ b/sys/ufs/ext2fs/ext2fs_readwrite.c
@@ -79,6 +79,8 @@ ext2fs_read(v)
 	struct uio *uio;
 	struct m_ext2fs *fs;
 	struct buf *bp;
+	void *win;
+	vsize_t bytelen;
 	ufs_daddr_t lbn, nextlbn;
 	off_t bytesinfile;
 	long size, xfersize, blkoffset;
@@ -107,6 +109,27 @@ ext2fs_read(v)
 	if (uio->uio_resid == 0)
 		return (0);
 
+	if (vp->v_type == VREG) {
+		error = 0;
+		while (uio->uio_resid > 0) {
+
+			bytelen = MIN(ip->i_e2fs_size - uio->uio_offset,
+			    uio->uio_resid);
+
+			if (bytelen == 0) {
+				break;
+			}
+			win = ubc_alloc(&vp->v_uvm.u_obj, uio->uio_offset,
+					&bytelen, UBC_READ);
+			error = uiomove(win, bytelen, uio);
+			ubc_release(win, 0);
+			if (error) {
+				break;
+			}
+		}
+		goto out;
+	}
+
 	for (error = 0, bp = NULL; uio->uio_resid > 0; bp = NULL) {
 		if ((bytesinfile = ip->i_e2fs_size - uio->uio_offset) <= 0)
 			break;
@@ -156,8 +179,11 @@ ext2fs_read(v)
 	if (bp != NULL)
 		brelse(bp);
 
+out:
 	if (!(vp->v_mount->mnt_flag & MNT_NOATIME)) {
 		ip->i_flag |= IN_ACCESS;
+		if ((ap->a_ioflag & IO_SYNC) == IO_SYNC)
+			error = ext2fs_update(ip, NULL, NULL, 1);
 	}
 	return (error);
 }
@@ -183,12 +209,17 @@ ext2fs_write(v)
 	struct proc *p;
 	ufs_daddr_t lbn;
 	off_t osize;
-	int blkoffset, error, flags, ioflag, resid, size, xfersize;
+	int blkoffset, error, flags, ioflag, resid, xfersize;
+	vsize_t bytelen;
+	void *win;
+	off_t oldoff;
+	boolean_t rv;
 
 	ioflag = ap->a_ioflag;
 	uio = ap->a_uio;
 	vp = ap->a_vp;
 	ip = VTOI(vp);
+	error = 0;
 
 #ifdef DIAGNOSTIC
 	if (uio->uio_rw != UIO_WRITE)
@@ -232,35 +263,65 @@ ext2fs_write(v)
 
 	resid = uio->uio_resid;
 	osize = ip->i_e2fs_size;
-	flags = ioflag & IO_SYNC ? B_SYNC : 0;
 
+	if (vp->v_type == VREG) {
+		while (uio->uio_resid > 0) {
+			oldoff = uio->uio_offset;
+			blkoffset = blkoff(fs, uio->uio_offset);
+			bytelen = MIN(fs->e2fs_bsize - blkoffset,
+			    uio->uio_resid);
+
+			/*
+			 * XXXUBC if file is mapped and this is the last block,
+			 * process one page at a time.
+			 */
+
+			error = ext2fs_balloc_range(vp, uio->uio_offset,
+			    bytelen, ap->a_cred, 0);
+			if (error) {
+				break;
+			}
+			win = ubc_alloc(&vp->v_uvm.u_obj, uio->uio_offset,
+			    &bytelen, UBC_WRITE);
+			error = uiomove(win, bytelen, uio);
+			ubc_release(win, 0);
+			if (error) {
+				break;
+			}
+
+			/*
+			 * flush what we just wrote if necessary.
+			 * XXXUBC simplistic async flushing.
+			 */
+
+			if (oldoff >> 16 != uio->uio_offset >> 16) {
+				simple_lock(&vp->v_uvm.u_obj.vmobjlock);
+				rv = vp->v_uvm.u_obj.pgops->pgo_flush(
+				    &vp->v_uvm.u_obj, (oldoff >> 16) << 16,
+				    (uio->uio_offset >> 16) << 16, PGO_CLEANIT);
+				simple_unlock(&vp->v_uvm.u_obj.vmobjlock);
+			}
+		}
+		goto out;
+	}
+
+	flags = ioflag & IO_SYNC ? B_SYNC : 0;
 	for (error = 0; uio->uio_resid > 0;) {
 		lbn = lblkno(fs, uio->uio_offset);
 		blkoffset = blkoff(fs, uio->uio_offset);
-		xfersize = fs->e2fs_bsize - blkoffset;
-		if (uio->uio_resid < xfersize)
-			xfersize = uio->uio_resid;
-		if (fs->e2fs_bsize > xfersize)
+		xfersize = MIN(fs->e2fs_bsize - blkoffset, uio->uio_resid);
+		if (xfersize < fs->e2fs_bsize)
 			flags |= B_CLRBUF;
 		else
 			flags &= ~B_CLRBUF;
-
 		error = ext2fs_buf_alloc(ip,
-			lbn, blkoffset + xfersize, ap->a_cred, &bp, flags);
+		    lbn, blkoffset + xfersize, ap->a_cred, &bp, flags);
 		if (error)
 			break;
-		if (uio->uio_offset + xfersize > ip->i_e2fs_size) {
+		if (ip->i_e2fs_size < uio->uio_offset + xfersize) {
 			ip->i_e2fs_size = uio->uio_offset + xfersize;
-			uvm_vnp_setsize(vp, ip->i_e2fs_size);
 		}
-		uvm_vnp_uncache(vp);
-
-		size = fs->e2fs_bsize - bp->b_resid;
-		if (size < xfersize)
-			xfersize = size;
-
-		error =
-			uiomove((char *)bp->b_data + blkoffset, (int)xfersize, uio);
+		error = uiomove((char *)bp->b_data + blkoffset, xfersize, uio);
 		if (ioflag & IO_SYNC)
 			(void)bwrite(bp);
 		else if (xfersize + blkoffset == fs->e2fs_bsize) {
@@ -272,13 +333,14 @@ ext2fs_write(v)
 			bdwrite(bp);
 		if (error || xfersize == 0)
 			break;
-		ip->i_flag |= IN_CHANGE | IN_UPDATE;
 	}
 	/*
 	 * If we successfully wrote any data, and we are not the superuser
 	 * we clear the setuid and setgid bits as a precaution against
 	 * tampering.
 	 */
+out:
+	ip->i_flag |= IN_CHANGE | IN_UPDATE;
 	if (resid > uio->uio_resid && ap->a_cred && ap->a_cred->cr_uid != 0)
 		ip->i_e2fs_mode &= ~(ISUID | ISGID);
 	if (error) {
@@ -288,8 +350,7 @@ ext2fs_write(v)
 			uio->uio_offset -= resid - uio->uio_resid;
 			uio->uio_resid = resid;
 		}
-	} else if (resid > uio->uio_resid && (ioflag & IO_SYNC)) {
+	} else if (resid > uio->uio_resid && (ioflag & IO_SYNC) == IO_SYNC)
 		error = ext2fs_update(ip, NULL, NULL, 1);
-	}
 	return (error);
 }
diff --git a/sys/ufs/ext2fs/ext2fs_subr.c b/sys/ufs/ext2fs/ext2fs_subr.c
index 82165b8f242..3263f7e5391 100644
--- a/sys/ufs/ext2fs/ext2fs_subr.c
+++ b/sys/ufs/ext2fs/ext2fs_subr.c
@@ -1,5 +1,4 @@
-/*	$OpenBSD: ext2fs_subr.c,v 1.6 2001/09/18 01:39:13 art Exp $	*/
-/*	$NetBSD: ext2fs_subr.c,v 1.1 1997/06/11 09:34:03 bouyer Exp $	*/
+/*	$NetBSD: ext2fs_subr.c,v 1.4 2000/03/30 12:41:11 augustss Exp $	*/
 
 /*
  * Copyright (c) 1997 Manuel Bouyer.
@@ -96,7 +95,7 @@ ext2fs_checkoverlap(bp, ip)
 		if (ep == bp || (ep->b_flags & B_INVAL) ||
 			ep->b_vp == NULLVP)
 			continue;
-		if (VOP_BMAP(ep->b_vp, (daddr_t)0, &vp, (daddr_t)0, NULL))
+		if (VOP_BMAP(ep->b_vp, (ufs_daddr_t)0, &vp, (ufs_daddr_t)0, NULL))
 			continue;
 		if (vp != ip->i_devvp)
 			continue;
diff --git a/sys/ufs/ext2fs/ext2fs_vfsops.c b/sys/ufs/ext2fs/ext2fs_vfsops.c
index 6991cf9d650..e438268acbc 100644
--- a/sys/ufs/ext2fs/ext2fs_vfsops.c
+++ b/sys/ufs/ext2fs/ext2fs_vfsops.c
@@ -1,5 +1,5 @@
-/*	$OpenBSD: ext2fs_vfsops.c,v 1.16 2001/11/21 22:21:48 csapuntz Exp $	*/
-/*	$NetBSD: ext2fs_vfsops.c,v 1.1 1997/06/11 09:34:07 bouyer Exp $	*/
+/*	$OpenBSD: ext2fs_vfsops.c,v 1.17 2001/11/27 05:27:12 art Exp $	*/
+/*	$NetBSD: ext2fs_vfsops.c,v 1.40 2000/11/27 08:39:53 chs Exp $	*/
 
 /*
  * Copyright (c) 1997 Manuel Bouyer.
@@ -402,9 +402,11 @@ ext2fs_reload(mountp, cred, p)
 	 * Step 1: invalidate all cached meta-data.
 	 */
 	devvp = VFSTOUFS(mountp)->um_devvp;
-	if (vinvalbuf(devvp, 0, cred, p, 0, 0))
+	vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, p);
+	error = vinvalbuf(devvp, 0, cred, p, 0, 0);
+	VOP_UNLOCK(devvp, 0, p);
+	if (error)
 		panic("ext2fs_reload: dirty1");
-
 	/*
 	 * Step 2: re-read superblock from disk.
 	 */
@@ -583,14 +585,18 @@ ext2fs_mountfs(devvp, mp, p)
 	mp->mnt_stat.f_fsid.val[1] = mp->mnt_vfc->vfc_typenum;
 	mp->mnt_maxsymlinklen = EXT2_MAXSYMLINKLEN;
 	mp->mnt_flag |= MNT_LOCAL;
+	mp->mnt_dev_bshift = DEV_BSHIFT;	/* XXX */
+	mp->mnt_fs_bshift = m_fs->e2fs_bshift;
 	ump->um_mountp = mp;
 	ump->um_dev = dev;
 	ump->um_devvp = devvp;
 	ump->um_nindir = NINDIR(m_fs);
+	ump->um_lognindir = ffs(NINDIR(m_fs)) - 1;
 	ump->um_bptrtodb = m_fs->e2fs_fsbtodb;
 	ump->um_seqinc = 1; /* no frags */
 	devvp->v_specmountpoint = mp;
 	return (0);
+
 out:
 	if (bp)
 		brelse(bp);
@@ -924,6 +930,7 @@ ext2fs_vget(mp, ino, vpp)
 			ip->i_flag |= IN_MODIFIED;
 	}
 
+	vp->v_uvm.u_size = ip->i_e2fs_size;
 	*vpp = vp;
 	return (0);
 }
diff --git a/sys/ufs/ext2fs/ext2fs_vnops.c b/sys/ufs/ext2fs/ext2fs_vnops.c
index 0faba75ffd2..fffdd494d5a 100644
--- a/sys/ufs/ext2fs/ext2fs_vnops.c
+++ b/sys/ufs/ext2fs/ext2fs_vnops.c
@@ -1,5 +1,5 @@
-/*	$OpenBSD: ext2fs_vnops.c,v 1.17 2001/11/06 19:53:21 miod Exp $	*/
-/*	$NetBSD: ext2fs_vnops.c,v 1.1 1997/06/11 09:34:09 bouyer Exp $	*/
+/*	$OpenBSD: ext2fs_vnops.c,v 1.18 2001/11/27 05:27:12 art Exp $	*/
+/*	$NetBSD: ext2fs_vnops.c,v 1.30 2000/11/27 08:39:53 chs Exp $	*/
 
 /*
  * Copyright (c) 1997 Manuel Bouyer.
@@ -402,8 +402,6 @@ ext2fs_chmod(vp, mode, cred, p)
 	ip->i_e2fs_mode &= ~ALLPERMS;
 	ip->i_e2fs_mode |= (mode & ALLPERMS);
 	ip->i_flag |= IN_CHANGE;
-	if ((vp->v_flag & VTEXT) && (ip->i_e2fs_mode & S_ISTXT) == 0)
-		(void) uvm_vnp_uncache(vp);
 	return (0);
 }
 
@@ -1469,7 +1467,11 @@ struct vnodeopv_entry_desc ext2fs_vnodeop_entries[] = {
 	{ &vop_pathconf_desc, ufs_pathconf },	/* pathconf */
 	{ &vop_advlock_desc, ext2fs_advlock },	/* advlock */
 	{ &vop_bwrite_desc, vop_generic_bwrite },		/* bwrite */
-	{ (struct vnodeop_desc*)NULL, (int(*) __P((void*)))NULL }
+	{ &vop_ballocn_desc, ext2fs_ballocn },
+	{ &vop_getpages_desc, genfs_getpages },
+	{ &vop_putpages_desc, genfs_putpages },
+	{ &vop_size_desc, genfs_size },
+	{ NULL, NULL }
 };
 struct vnodeopv_desc ext2fs_vnodeop_opv_desc =
 	{ &ext2fs_vnodeop_p, ext2fs_vnodeop_entries };
diff --git a/sys/ufs/ffs/ffs_alloc.c b/sys/ufs/ffs/ffs_alloc.c
index 8ddf99405fc..a53d87828c3 100644
--- a/sys/ufs/ffs/ffs_alloc.c
+++ b/sys/ufs/ffs/ffs_alloc.c
@@ -1,4 +1,4 @@
-/*	$OpenBSD: ffs_alloc.c,v 1.35 2001/11/21 21:23:56 csapuntz Exp $	*/
+/*	$OpenBSD: ffs_alloc.c,v 1.36 2001/11/27 05:27:12 art Exp $	*/
 /*	$NetBSD: ffs_alloc.c,v 1.11 1996/05/11 18:27:09 mycroft Exp $	*/
 
 /*
@@ -169,14 +169,15 @@ ffs_realloccg(ip, lbprev, bpref, osize, nsize, cred, bpp, blknop)
 	struct buf **bpp;
 	ufs_daddr_t *blknop;
 {
-	register struct fs *fs;
-	struct buf *bp = NULL;
+	struct fs *fs;
+	struct buf *bp;
 	ufs_daddr_t quota_updated = 0;
 	int cg, request, error;
 	daddr_t bprev, bno;
 
 	if (bpp != NULL)
 		*bpp = NULL;
+
 	fs = ip->i_fs;
 #ifdef DIAGNOSTIC
 	if ((u_int)osize > fs->fs_bsize || fragoff(fs, osize) != 0 ||
@@ -282,7 +283,6 @@ ffs_realloccg(ip, lbprev, bpref, osize, nsize, cred, bpp, blknop)
 	if (bno <= 0) 
 		goto nospace;
 
-	(void) uvm_vnp_uncache(ITOV(ip));
 	if (!DOINGSOFTDEP(ITOV(ip)))
 		ffs_blkfree(ip, bprev, (long)osize);
 	if (nsize < request)
@@ -362,7 +362,8 @@ ffs_reallocblks(v)
 	struct indir start_ap[NIADDR + 1], end_ap[NIADDR + 1], *idp;
 	int i, len, start_lvl, end_lvl, pref, ssize;
 
-	if (doreallocblks == 0)
+	/* XXXUBC - don't reallocblks for now */
+	if (1 || doreallocblks == 0)
 		return (ENOSPC);
 
 	vp = ap->a_vp;
diff --git a/sys/ufs/ffs/ffs_balloc.c b/sys/ufs/ffs/ffs_balloc.c
index 009adc91ff9..5f6ddc3d94e 100644
--- a/sys/ufs/ffs/ffs_balloc.c
+++ b/sys/ufs/ffs/ffs_balloc.c
@@ -1,4 +1,4 @@
-/*	$OpenBSD: ffs_balloc.c,v 1.18 2001/11/21 21:23:56 csapuntz Exp $	*/
+/*	$OpenBSD: ffs_balloc.c,v 1.19 2001/11/27 05:27:12 art Exp $	*/
 /*	$NetBSD: ffs_balloc.c,v 1.3 1996/02/09 22:22:21 christos Exp $	*/
 
 /*
@@ -402,3 +402,61 @@ fail:
 
 	return (error);
 }
+
+int
+ffs_ballocn(v)
+	void *v;
+{
+	struct vop_ballocn_args /* {
+		struct vnode *a_vp;
+		off_t a_offset;
+		off_t a_length;
+		struct ucred *a_cred;
+		int a_flags;
+	} */ *ap = v;
+
+	off_t off, len;
+	struct vnode *vp = ap->a_vp;
+	struct inode *ip = VTOI(vp);
+	struct fs *fs = ip->i_fs;
+	int error, delta, bshift, bsize;
+
+	error = 0;
+	bshift = fs->fs_bshift;
+	bsize = 1 << bshift;
+
+	off = ap->a_offset;
+	len = ap->a_length;
+
+	delta = off & (bsize - 1);
+	off -= delta;
+	len += delta;
+
+	while (len > 0) {
+		bsize = min(bsize, len);
+
+		error = ffs_balloc(ip, off, bsize, ap->a_cred, ap->a_flags,
+				   NULL);
+		if (error) {
+			goto out;
+		}
+
+		/*
+		 * increase file size now, VOP_BALLOC() requires that
+		 * EOF be up-to-date before each call.
+		 */
+
+		if (ip->i_ffs_size < off + bsize) {
+			ip->i_ffs_size = off + bsize;
+			if (vp->v_uvm.u_size < ip->i_ffs_size) {
+				uvm_vnp_setsize(vp, ip->i_ffs_size);
+			}
+		}
+
+		off += bsize;
+		len -= bsize;
+	}
+
+out:
+	return error;
+ }
diff --git a/sys/ufs/ffs/ffs_extern.h b/sys/ufs/ffs/ffs_extern.h
index eeeba209c69..2875a332a57 100644
--- a/sys/ufs/ffs/ffs_extern.h
+++ b/sys/ufs/ffs/ffs_extern.h
@@ -1,4 +1,4 @@
-/*	$OpenBSD: ffs_extern.h,v 1.14 2001/11/13 00:10:56 art Exp $	*/
+/*	$OpenBSD: ffs_extern.h,v 1.15 2001/11/27 05:27:12 art Exp $	*/
 /*	$NetBSD: ffs_extern.h,v 1.4 1996/02/09 22:22:22 christos Exp $	*/
 
 /*-
@@ -87,6 +87,7 @@ void ffs_clusteracct __P((struct fs *, struct cg *, daddr_t, int));
 
 /* ffs_balloc.c */
 int ffs_balloc(struct inode *, off_t, int, struct ucred *, int, struct buf **);
+int ffs_ballocn(void *);
 
 /* ffs_inode.c */
 int ffs_init __P((struct vfsconf *));
@@ -128,7 +129,7 @@ int ffs_read __P((void *));
 int ffs_write __P((void *));
 int ffs_fsync __P((void *));
 int ffs_reclaim __P((void *));
-
+int ffs_size __P((void *));
 
 /*
  * Soft dependency function prototypes.
diff --git a/sys/ufs/ffs/ffs_inode.c b/sys/ufs/ffs/ffs_inode.c
index c81c795b2ac..cddf6a368ca 100644
--- a/sys/ufs/ffs/ffs_inode.c
+++ b/sys/ufs/ffs/ffs_inode.c
@@ -1,4 +1,4 @@
-/*	$OpenBSD: ffs_inode.c,v 1.25 2001/11/21 21:23:56 csapuntz Exp $	*/
+/*	$OpenBSD: ffs_inode.c,v 1.26 2001/11/27 05:27:12 art Exp $	*/
 /*	$NetBSD: ffs_inode.c,v 1.10 1996/05/11 18:27:19 mycroft Exp $	*/
 
 /*
@@ -150,14 +150,14 @@ ffs_truncate(struct inode *oip, off_t length, int flags, struct ucred *cred)
 {
 	struct vnode *ovp;
 	daddr_t lastblock;
-	daddr_t bn, lbn, lastiblock[NIADDR], indir_lbn[NIADDR];
+	daddr_t bn, lastiblock[NIADDR], indir_lbn[NIADDR];
 	daddr_t oldblks[NDADDR + NIADDR], newblks[NDADDR + NIADDR];
 	struct fs *fs;
-	struct buf *bp;
+	struct proc *p = curproc;
 	int offset, size, level;
 	long count, nblocks, vflags, blocksreleased = 0;
 	register int i;
-	int aflags, error, allerror;
+	int error, allerror;
 	off_t osize;
 
 	if (length < 0)
@@ -188,10 +188,55 @@ ffs_truncate(struct inode *oip, off_t length, int flags, struct ucred *cred)
 	if ((error = getinoquota(oip)) != 0)
 		return (error);
 
-	uvm_vnp_setsize(ovp, length);
+	fs = oip->i_fs;
+	if (length > fs->fs_maxfilesize)
+		return (EFBIG);
+	osize = oip->i_ffs_size; 
 	oip->i_ci.ci_lasta = oip->i_ci.ci_clen 
 	    = oip->i_ci.ci_cstart = oip->i_ci.ci_lastw = 0;
 
+	/*
+	 * Lengthen the size of the file. We must ensure that the
+	 * last byte of the file is allocated. Since the smallest
+	 * value of osize is 0, length will be at least 1.
+	 */
+
+	if (osize < length) {
+		ufs_balloc_range(ovp, length - 1, 1, cred,
+		    flags & IO_SYNC ? B_SYNC : 0);
+		oip->i_flag |= IN_CHANGE | IN_UPDATE;
+		return (UFS_UPDATE(oip, 1));
+	}
+
+	/*
+	 * When truncating a regular file down to a non-block-aligned size,
+	 * we must zero the part of last block which is past the new EOF.
+	 * We must synchronously flush the zeroed pages to disk
+	 * since the new pages will be invalidated as soon as we
+	 * inform the VM system of the new, smaller size.
+	 * We must to this before acquiring the GLOCK, since fetching
+	 * the pages will acquire the GLOCK internally.
+	 * So there is a window where another thread could see a whole
+	 * zeroed page past EOF, but that's life.
+	 */
+
+	offset = blkoff(fs, length);
+	if (ovp->v_type == VREG && length < osize && offset != 0) {
+		struct uvm_object *uobj;
+		voff_t eoz;
+
+		size = blksize(fs, oip, lblkno(fs, length));
+		eoz = min(lblktosize(fs, lblkno(fs, length)) + size, osize);
+		uvm_vnp_zerorange(ovp, length, eoz - length);
+		uobj = &ovp->v_uvm.u_obj;
+		simple_lock(&uobj->vmobjlock);
+		uobj->pgops->pgo_flush(uobj, length, eoz,
+		    PGO_CLEANIT|PGO_DEACTIVATE|PGO_SYNCIO);
+		simple_unlock(&ovp->v_uvm.u_obj.vmobjlock);
+	}
+
+	lockmgr(&ovp->v_glock, LK_EXCLUSIVE, NULL, p);
+
 	if (DOINGSOFTDEP(ovp)) {
 		if (length > 0 || softdep_slowdown(ovp)) {
 			/*
@@ -204,80 +249,29 @@ ffs_truncate(struct inode *oip, off_t length, int flags, struct ucred *cred)
 			 * so that it will have no data structures left.
 			 */
 			if ((error = VOP_FSYNC(ovp, cred, MNT_WAIT,
-					       curproc)) != 0)
+			    curproc)) != 0) {
+				lockmgr(&ovp->v_glock, LK_RELEASE, NULL, p);
 				return (error);
+			}
 		} else {
+			uvm_vnp_setsize(ovp, length);
 			(void)ufs_quota_free_blocks(oip, oip->i_ffs_blocks, 
 			    NOCRED);
 			softdep_setup_freeblocks(oip, length);
 			(void) vinvalbuf(ovp, 0, cred, curproc, 0, 0);
+			lockmgr(&ovp->v_glock, LK_RELEASE, NULL, p);
 			oip->i_flag |= IN_CHANGE | IN_UPDATE;
 			return (UFS_UPDATE(oip, 0));
 		}
 	}
 
-	fs = oip->i_fs;
-	osize = oip->i_ffs_size; 
 	/*
-	 * Lengthen the size of the file. We must ensure that the
-	 * last byte of the file is allocated. Since the smallest
-	 * value of osize is 0, length will be at least 1.
+	 * Reduce the size of the file.
 	 */
-	if (osize < length) {
-		if (length > fs->fs_maxfilesize)
-			return (EFBIG);
-		aflags = B_CLRBUF;
-		if (flags & IO_SYNC)
-			aflags |= B_SYNC;
-		error = UFS_BUF_ALLOC(oip, length - 1, 1, 
-				   cred, aflags, &bp);
-		if (error)
-			return (error);
-		oip->i_ffs_size = length;
-		uvm_vnp_setsize(ovp, length);
-		(void) uvm_vnp_uncache(ovp);
-		if (aflags & B_SYNC)
-			bwrite(bp);
-		else
-			bawrite(bp);
-		oip->i_flag |= IN_CHANGE | IN_UPDATE;
-		return (UFS_UPDATE(oip, MNT_WAIT));
-	}
+	oip->i_ffs_size = length;
 	uvm_vnp_setsize(ovp, length);
 
 	/*
-	 * Shorten the size of the file. If the file is not being
-	 * truncated to a block boundary, the contents of the
-	 * partial block following the end of the file must be
-	 * zero'ed in case it ever becomes accessible again because
-	 * of subsequent file growth. Directories however are not
-	 * zero'ed as they should grow back initialized to empty.
-	 */
-	offset = blkoff(fs, length);
-	if (offset == 0) {
-		oip->i_ffs_size = length;
-	} else {
-		lbn = lblkno(fs, length);
-		aflags = B_CLRBUF;
-		if (flags & IO_SYNC)
-			aflags |= B_SYNC;
-		error = UFS_BUF_ALLOC(oip, length - 1, 1,
-				   cred, aflags, &bp);
-		if (error)
-			return (error);
-		oip->i_ffs_size = length;
-		size = blksize(fs, oip, lbn);
-		(void) uvm_vnp_uncache(ovp);
-		if (ovp->v_type != VDIR)
-			bzero((char *)bp->b_data + offset,
-			      (u_int)(size - offset));
-		allocbuf(bp, size);
-		if (aflags & B_SYNC)
-			bwrite(bp);
-		else
-			bawrite(bp);
-	}
-	/*
 	 * Calculate index into inode's block list of
 	 * last direct and indirect blocks (if any)
 	 * which we want to keep.  Lastblock is -1 when
@@ -402,6 +396,7 @@ done:
 	oip->i_ffs_blocks -= blocksreleased;
 	if (oip->i_ffs_blocks < 0)			/* sanity */
 		oip->i_ffs_blocks = 0;
+	lockmgr(&ovp->v_glock, LK_RELEASE, NULL, p);
 	oip->i_flag |= IN_CHANGE;
 	(void)ufs_quota_free_blocks(oip, blocksreleased, NOCRED);
 	return (allerror);
diff --git a/sys/ufs/ffs/ffs_softdep.c b/sys/ufs/ffs/ffs_softdep.c
index 1d66094cc06..7a66eed4d8b 100644
--- a/sys/ufs/ffs/ffs_softdep.c
+++ b/sys/ufs/ffs/ffs_softdep.c
@@ -1,4 +1,4 @@
-/*	$OpenBSD: ffs_softdep.c,v 1.25 2001/11/13 14:19:24 art Exp $	*/
+/*	$OpenBSD: ffs_softdep.c,v 1.26 2001/11/27 05:27:12 art Exp $	*/
 /*
  * Copyright 1998, 2000 Marshall Kirk McKusick. All Rights Reserved.
  *
@@ -56,6 +56,7 @@
 #include <sys/malloc.h>
 #include <sys/mount.h>
 #include <sys/proc.h>
+#include <sys/pool.h>
 #include <sys/syslog.h>
 #include <sys/systm.h>
 #include <sys/vnode.h>
@@ -69,6 +70,10 @@
 #include <ufs/ffs/ffs_extern.h>
 #include <ufs/ufs/ufs_extern.h>
 
+#include <uvm/uvm.h>
+struct pool sdpcpool;
+int softdep_lockedbufs;
+
 #define STATIC
 
 /*
@@ -109,6 +114,13 @@ extern char *memname[];
  */
 
 /*
+ * Definitions for page cache info hashtable.
+ */
+#define PCBPHASHSIZE 1024
+LIST_HEAD(, buf) pcbphashhead[PCBPHASHSIZE];
+#define PCBPHASH(vp, lbn) ((((vaddr_t)(vp) >> 8) ^ (lbn)) & (PCBPHASHSIZE - 1))
+
+/*
  * Internal function prototypes.
  */
 STATIC	void softdep_error __P((char *, int));
@@ -160,6 +172,13 @@ STATIC	void pause_timer __P((void *));
 STATIC	int request_cleanup __P((int, int));
 STATIC	int process_worklist_item __P((struct mount *, int));
 STATIC	void add_to_worklist __P((struct worklist *));
+STATIC struct buf *softdep_setup_pagecache __P((struct inode *, ufs_lbn_t,
+						long));
+STATIC void softdep_collect_pagecache __P((struct inode *));
+STATIC void softdep_free_pagecache __P((struct inode *));
+STATIC struct vnode *softdep_lookupvp(struct fs *, ino_t);
+STATIC struct buf *softdep_lookup_pcbp __P((struct vnode *, ufs_lbn_t));
+void softdep_pageiodone __P((struct buf *));
 
 /*
  * Exported softdep operations.
@@ -176,6 +195,7 @@ struct bio_ops bioops = {
 	softdep_deallocate_dependencies,	/* io_deallocate */
 	softdep_move_dependencies,		/* io_movedeps */
 	softdep_count_dependencies,		/* io_countdeps */
+	softdep_pageiodone,			/* io_pagedone */
 };
 
 /*
@@ -1055,6 +1075,7 @@ top:
 void 
 softdep_initialize()
 {
+	int i;
 
 	LIST_INIT(&mkdirlisthd);
 	LIST_INIT(&softdep_workitem_pending);
@@ -1073,6 +1094,11 @@ softdep_initialize()
 	newblk_hashtbl = hashinit(64, M_NEWBLK, M_WAITOK, &newblk_hash);
 	sema_init(&newblk_in_progress, "newblk", PRIBIO, 0);
 	timeout_set(&proc_waiting_timeout, pause_timer, 0);
+	pool_init(&sdpcpool, sizeof(struct buf), 0, 0, 0, "sdpcpool",
+	    0, pool_page_alloc_nointr, pool_page_free_nointr, M_TEMP);
+	for (i = 0; i < PCBPHASHSIZE; i++) {
+		LIST_INIT(&pcbphashhead[i]);
+	}
 }
 
 /*
@@ -1325,11 +1351,16 @@ softdep_setup_allocdirect(ip, lbn, newblkno, oldblkno, newsize, oldsize, bp)
 	LIST_REMOVE(newblk, nb_hash);
 	FREE(newblk, M_NEWBLK);
 
+	/*
+	 * If we were not passed a bp to attach the dep to,
+	 * then this must be for a regular file.
+	 * Allocate a buffer to represent the page cache pages
+	 * that are the real dependency.  The pages themselves
+	 * cannot refer to the dependency since we don't want to
+	 * add a field to struct vm_page for this.
+	 */
 	if (bp == NULL) {
-		/*
-		 * XXXUBC - Yes, I know how to fix this, but not right now.
-		 */
-		panic("softdep_setup_allocdirect: Bonk art in the head\n");
+		bp = softdep_setup_pagecache(ip, lbn, newsize);
 	}
 	WORKLIST_INSERT(&bp->b_dep, &adp->ad_list);
 	if (lbn >= NDADDR) {
@@ -1563,10 +1594,7 @@ softdep_setup_allocindir_page(ip, lbn, bp, ptrno, newblkno, oldblkno, nbp)
 	    pagedep_lookup(ip, lbn, DEPALLOC, &pagedep) == 0)
 		WORKLIST_INSERT(&nbp->b_dep, &pagedep->pd_list);
 	if (nbp == NULL) {
-		/*
-		 * XXXUBC - Yes, I know how to fix this, but not right now.
-		 */
-		panic("softdep_setup_allocindir_page: Bonk art in the head\n");
+		nbp = softdep_setup_pagecache(ip, lbn, ip->i_fs->fs_bsize);
 	}
 	WORKLIST_INSERT(&nbp->b_dep, &aip->ai_list);
 	FREE_LOCK(&lk);
@@ -1745,6 +1773,7 @@ softdep_setup_freeblocks(ip, length)
 	int i, delay, error;
 
 	fs = ip->i_fs;
+	vp = ITOV(ip);
 	if (length != 0)
 		panic("softdep_setup_freeblocks: non-zero length");
 	MALLOC(freeblks, struct freeblks *, sizeof(struct freeblks),
@@ -1804,9 +1833,15 @@ softdep_setup_freeblocks(ip, length)
 	 * with this inode are obsolete and can simply be de-allocated.
 	 * We must first merge the two dependency lists to get rid of
 	 * any duplicate freefrag structures, then purge the merged list.
+	 * We must remove any pagecache markers from the pagecache
+	 * hashtable first because any I/Os in flight will want to see
+	 * dependencies attached to their pagecache markers.  We cannot
+	 * free the pagecache markers until after we've freed all the
+	 * dependencies that reference them later.
 	 * If we still have a bitmap dependency, then the inode has never
 	 * been written to disk, so we can free any fragments without delay.
 	 */
+	softdep_collect_pagecache(ip);
 	merge_inode_lists(inodedep);
 	while ((adp = TAILQ_FIRST(&inodedep->id_inoupdt)) != 0)
 		free_allocdirect(&inodedep->id_inoupdt, adp, delay);
@@ -1818,7 +1853,6 @@ softdep_setup_freeblocks(ip, length)
 	 * Once they are all there, walk the list and get rid of
 	 * any dependencies.
 	 */
-	vp = ITOV(ip);
 	ACQUIRE_LOCK(&lk);
 	drain_output(vp, 1);
 	while (getdirtybuf(&LIST_FIRST(&vp->v_dirtyblkhd), MNT_WAIT)) {
@@ -1830,6 +1864,7 @@ softdep_setup_freeblocks(ip, length)
 		brelse(bp);
 		ACQUIRE_LOCK(&lk);
 	}
+	softdep_free_pagecache(ip);
 	if (inodedep_lookup(fs, ip->i_number, 0, &inodedep) != 0)
 		(void) free_inodedep(inodedep);
 	FREE_LOCK(&lk);
@@ -2898,7 +2933,6 @@ handle_workitem_freefile(freefile)
 	struct freefile *freefile;
 {
 	struct fs *fs;
-	struct vnode vp;
 	struct inode tip;
 	struct inodedep *idp;
 	int error;
@@ -2914,8 +2948,7 @@ handle_workitem_freefile(freefile)
 	tip.i_devvp = freefile->fx_devvp;
 	tip.i_dev = freefile->fx_devvp->v_rdev;
 	tip.i_fs = fs;
-	tip.i_vnode = &vp;
-	vp.v_data = &tip;
+	tip.i_vnode = NULL;
 
 	if ((error = ffs_freefile(&tip, freefile->fx_oldinum, 
 		 freefile->fx_mode)) != 0) {
@@ -4313,6 +4346,7 @@ flush_inodedep_deps(fs, ino)
 	struct allocdirect *adp;
 	int error, waitfor;
 	struct buf *bp;
+	struct vnode *vp;
 
 	/*
 	 * This work is done in two passes. The first pass grabs most
@@ -4332,6 +4366,27 @@ flush_inodedep_deps(fs, ino)
 		ACQUIRE_LOCK(&lk);
 		if (inodedep_lookup(fs, ino, 0, &inodedep) == 0)
 			return (0);
+
+		/*
+		 * When file data was in the buffer cache,
+		 * softdep_sync_metadata() would start i/o on
+		 * file data buffers itself.  But now that
+		 * we're using the page cache to hold file data,
+		 * we need something else to trigger those flushes.
+		 * let's just do it here.
+		 */
+
+		vp = softdep_lookupvp(fs, ino);
+		if (vp) {
+			struct uvm_object *uobj = &vp->v_uvm.u_obj;
+
+			simple_lock(&uobj->vmobjlock);
+			(uobj->pgops->pgo_flush)(uobj, 0, 0,
+			    PGO_ALLPAGES|PGO_CLEANIT|
+			    (waitfor == MNT_NOWAIT ? 0: PGO_SYNCIO));
+			simple_unlock(&uobj->vmobjlock);
+		}
+
 		TAILQ_FOREACH(adp, &inodedep->id_inoupdt, ad_next) {
 			if (adp->ad_state & DEPCOMPLETE)
 				continue;
@@ -4944,3 +4999,196 @@ softdep_error(func, error)
 	/* XXX should do something better! */
 	printf("%s: got error %d while accessing filesystem\n", func, error);
 }
+
+/*
+ * Allocate a buffer on which to attach a dependency.
+ */
+STATIC struct buf *
+softdep_setup_pagecache(ip, lbn, size)
+	struct inode *ip;
+	ufs_lbn_t lbn;
+	long size;
+{
+	struct vnode *vp = ITOV(ip);
+	struct buf *bp;
+	int s;
+
+	/*
+	 * Enter pagecache dependency buf in hash.
+	 */
+
+	bp = softdep_lookup_pcbp(vp, lbn);
+	if (bp == NULL) {
+		s = splbio();
+		bp = pool_get(&sdpcpool, PR_WAITOK);
+		splx(s);
+
+		bp->b_vp = vp;
+		bp->b_lblkno = lbn;
+		bp->b_bcount = bp->b_resid = size;
+		LIST_INIT(&bp->b_dep);
+		LIST_INSERT_HEAD(&pcbphashhead[PCBPHASH(vp, lbn)], bp, b_hash);
+		LIST_INSERT_HEAD(&ip->i_pcbufhd, bp, b_vnbufs);
+	} else {
+		KASSERT(size >= bp->b_bcount);
+		bp->b_resid += size - bp->b_bcount;
+		bp->b_bcount = size;
+	}
+	return bp;
+}
+
+/*
+ * softdep_collect_pagecache() and softdep_free_pagecache()
+ * are used to remove page cache dependency buffers when
+ * a file is being truncated to 0.
+ */
+
+STATIC void
+softdep_collect_pagecache(ip)
+	struct inode *ip;
+{
+	struct buf *bp;
+
+	LIST_FOREACH(bp, &ip->i_pcbufhd, b_vnbufs) {
+		LIST_REMOVE(bp, b_hash);
+	}
+}
+
+STATIC void
+softdep_free_pagecache(ip)
+	struct inode *ip;
+{
+	struct buf *bp, *nextbp;
+
+	for (bp = LIST_FIRST(&ip->i_pcbufhd); bp != NULL; bp = nextbp) {
+		nextbp = LIST_NEXT(bp, b_vnbufs);
+		LIST_REMOVE(bp, b_vnbufs);
+		KASSERT(LIST_FIRST(&bp->b_dep) == NULL);
+		pool_put(&sdpcpool, bp);
+	}
+}
+
+STATIC struct vnode *
+softdep_lookupvp(fs, ino)
+	struct fs *fs;
+	ino_t ino;
+{
+	struct mount *mp;
+	extern struct vfsops ffs_vfsops;
+
+	CIRCLEQ_FOREACH(mp, &mountlist, mnt_list) {
+		if (mp->mnt_op == &ffs_vfsops &&
+		    VFSTOUFS(mp)->um_fs == fs) {
+			break;
+		}
+	}
+	if (mp == NULL) {
+		return NULL;
+	}
+	return ufs_ihashlookup(VFSTOUFS(mp)->um_dev, ino);
+}
+
+STATIC struct buf *
+softdep_lookup_pcbp(vp, lbn)
+	struct vnode *vp;
+	ufs_lbn_t lbn;
+{
+	struct buf *bp;
+
+	LIST_FOREACH(bp, &pcbphashhead[PCBPHASH(vp, lbn)], b_hash) {
+		if (bp->b_vp == vp && bp->b_lblkno == lbn) {
+			break;
+		}
+	}
+	return bp;	     
+}
+
+/*
+ * Do softdep i/o completion processing for page cache writes.
+ */
+ 
+void
+softdep_pageiodone(bp)
+	struct buf *bp;
+{
+	int npages = bp->b_bufsize >> PAGE_SHIFT;
+	struct vnode *vp = bp->b_vp;
+	struct vm_page *pg;
+	struct buf *pcbp = NULL;
+	struct allocdirect *adp;
+	struct allocindir *aip;
+	struct worklist *wk;
+	ufs_lbn_t lbn;
+	voff_t off;
+	long iosize = bp->b_bcount;
+	int size, asize, bshift, bsize;
+	int i;
+
+	KASSERT(!(bp->b_flags & B_READ));
+	bshift = vp->v_mount->mnt_fs_bshift;
+	bsize = 1 << bshift;
+	asize = min(PAGE_SIZE, bsize);
+	ACQUIRE_LOCK(&lk);
+	for (i = 0; i < npages; i++) {
+		pg = uvm_pageratop((vaddr_t)bp->b_data + (i << PAGE_SHIFT));
+		if (pg == NULL) {
+			continue;
+		}
+
+		for (off = pg->offset;
+		     off < pg->offset + PAGE_SIZE;
+		     off += bsize) {
+			size = min(asize, iosize);
+			iosize -= size;
+			lbn = off >> bshift;
+			if (pcbp == NULL || pcbp->b_lblkno != lbn) {
+				pcbp = softdep_lookup_pcbp(vp, lbn);
+			}
+			if (pcbp == NULL) {
+				continue;
+			}
+			pcbp->b_resid -= size;
+			if (pcbp->b_resid < 0) {
+				panic("softdep_pageiodone: "
+				      "resid < 0, vp %p lbn 0x%lx pcbp %p",
+				      vp, lbn, pcbp);
+			}
+			if (pcbp->b_resid > 0) {
+				continue;
+			}
+
+			/*
+			 * We've completed all the i/o for this block.
+			 * mark the dep complete.
+			 */
+
+			KASSERT(LIST_FIRST(&pcbp->b_dep) != NULL);
+			while ((wk = LIST_FIRST(&pcbp->b_dep))) {
+				WORKLIST_REMOVE(wk);
+				switch (wk->wk_type) {
+				case D_ALLOCDIRECT:
+					adp = WK_ALLOCDIRECT(wk);
+					adp->ad_state |= COMPLETE;
+					handle_allocdirect_partdone(adp);
+					break;
+
+				case D_ALLOCINDIR:
+					aip = WK_ALLOCINDIR(wk);
+					aip->ai_state |= COMPLETE;
+					handle_allocindir_partdone(aip);
+					break;
+
+				default:
+					panic("softdep_pageiodone: "
+					      "bad type %d, pcbp %p wk %p",
+					      wk->wk_type, pcbp, wk);
+				}
+			}
+			LIST_REMOVE(pcbp, b_hash);
+			LIST_REMOVE(pcbp, b_vnbufs);
+			pool_put(&sdpcpool, pcbp);
+			pcbp = NULL;
+		}
+	}
+	FREE_LOCK(&lk);
+}
diff --git a/sys/ufs/ffs/ffs_vfsops.c b/sys/ufs/ffs/ffs_vfsops.c
index b1dee123893..19c77726fa8 100644
--- a/sys/ufs/ffs/ffs_vfsops.c
+++ b/sys/ufs/ffs/ffs_vfsops.c
@@ -1,4 +1,4 @@
-/*	$OpenBSD: ffs_vfsops.c,v 1.45 2001/11/21 22:21:48 csapuntz Exp $	*/
+/*	$OpenBSD: ffs_vfsops.c,v 1.46 2001/11/27 05:27:12 art Exp $	*/
 /*	$NetBSD: ffs_vfsops.c,v 1.19 1996/02/09 22:22:26 christos Exp $	*/
 
 /*
@@ -737,11 +737,14 @@ ffs_mountfs(devvp, mp, p)
 	else
 		mp->mnt_stat.f_fsid.val[1] = mp->mnt_vfc->vfc_typenum;
 	mp->mnt_maxsymlinklen = fs->fs_maxsymlinklen;
+	mp->mnt_fs_bshift = fs->fs_bshift;
+	mp->mnt_dev_bshift = DEV_BSHIFT;
 	mp->mnt_flag |= MNT_LOCAL;
 	ump->um_mountp = mp;
 	ump->um_dev = dev;
 	ump->um_devvp = devvp;
 	ump->um_nindir = fs->fs_nindir;
+	ump->um_lognindir = ffs(fs->fs_nindir) - 1;
 	ump->um_bptrtodb = fs->fs_fsbtodb;
 	ump->um_seqinc = fs->fs_frag;
 	for (i = 0; i < MAXQUOTAS; i++)
@@ -1119,6 +1122,7 @@ retry:
 	ip->i_fs = fs = ump->um_fs;
 	ip->i_dev = dev;
 	ip->i_number = ino;
+	LIST_INIT(&ip->i_pcbufhd);
 	ip->i_vtbl = &ffs_vtbl;
 
 	/*
@@ -1199,6 +1203,7 @@ retry:
 		ip->i_ffs_uid = ip->i_din.ffs_din.di_ouid;	/* XXX */
 		ip->i_ffs_gid = ip->i_din.ffs_din.di_ogid;	/* XXX */
 	}							/* XXX */
+	uvm_vnp_setsize(vp, ip->i_ffs_size);
 
 	*vpp = vp;
 	return (0);
diff --git a/sys/ufs/ffs/ffs_vnops.c b/sys/ufs/ffs/ffs_vnops.c
index 26e9bbaf9da..8190ef82eb3 100644
--- a/sys/ufs/ffs/ffs_vnops.c
+++ b/sys/ufs/ffs/ffs_vnops.c
@@ -1,4 +1,4 @@
-/*	$OpenBSD: ffs_vnops.c,v 1.20 2001/11/06 19:53:21 miod Exp $	*/
+/*	$OpenBSD: ffs_vnops.c,v 1.21 2001/11/27 05:27:12 art Exp $	*/
 /*	$NetBSD: ffs_vnops.c,v 1.7 1996/05/11 18:27:24 mycroft Exp $	*/
 
 /*
@@ -107,8 +107,13 @@ struct vnodeopv_entry_desc ffs_vnodeop_entries[] = {
 	{ &vop_advlock_desc, ufs_advlock },		/* advlock */
 	{ &vop_reallocblks_desc, ffs_reallocblks },	/* reallocblks */
 	{ &vop_bwrite_desc, vop_generic_bwrite },
-	{ (struct vnodeop_desc*)NULL, (int(*) __P((void*)))NULL }
+	{ &vop_ballocn_desc, ffs_ballocn },
+	{ &vop_getpages_desc, genfs_getpages },
+	{ &vop_putpages_desc, genfs_putpages },
+	{ &vop_size_desc, ffs_size },
+	{ NULL, NULL }
 };
+
 struct vnodeopv_desc ffs_vnodeop_opv_desc =
 	{ &ffs_vnodeop_p, ffs_vnodeop_entries };
 
@@ -229,6 +234,7 @@ ffs_fsync(v)
 	struct vnode *vp = ap->a_vp;
 	struct buf *bp, *nbp;
 	int s, error, passes, skipmeta;
+	struct uvm_object *uobj;
 
 	if (vp->v_type == VBLK &&
 	    vp->v_specmountpoint != NULL &&
@@ -236,13 +242,22 @@ ffs_fsync(v)
 		softdep_fsync_mountdev(vp);
 
 	/*
-	 * Flush all dirty buffers associated with a vnode.
+	 * Flush all dirty data associated with a vnode.
 	 */
 	passes = NIADDR + 1;
 	skipmeta = 0;
 	if (ap->a_waitfor == MNT_WAIT)
 		skipmeta = 1;
 	s = splbio();
+
+	if (vp->v_type == VREG) {
+		uobj = &vp->v_uvm.u_obj;
+		simple_lock(&uobj->vmobjlock);
+		(uobj->pgops->pgo_flush)(uobj, 0, 0, PGO_ALLPAGES|PGO_CLEANIT|
+		    ((ap->a_waitfor == MNT_WAIT) ? PGO_SYNCIO : 0));
+		simple_unlock(&uobj->vmobjlock);
+	}
+
 loop:
 	for (bp = LIST_FIRST(&vp->v_dirtyblkhd); bp;
 	     bp = LIST_NEXT(bp, b_vnbufs))
@@ -281,8 +296,10 @@ loop:
 		 */
 		if (passes > 0 || ap->a_waitfor != MNT_WAIT)
 			(void) bawrite(bp);
-		else if ((error = bwrite(bp)) != 0)
+		else if ((error = bwrite(bp)) != 0) {
+			printf("ffs_fsync: bwrite failed %d\n", error);
 			return (error);
+		}
 		s = splbio();
 		/*
 		 * Since we may have slept during the I/O, we need
@@ -325,7 +342,11 @@ loop:
 		}
 	}
 	splx(s);
-	return (UFS_UPDATE(VTOI(vp), ap->a_waitfor == MNT_WAIT));
+	
+	error = (UFS_UPDATE(VTOI(vp), ap->a_waitfor == MNT_WAIT));
+	if (error)
+		printf("ffs_fsync: UFS_UPDATE failed. %d\n", error);
+	return (error);
 }
 
 /*
@@ -349,3 +370,31 @@ ffs_reclaim(v)
 	vp->v_data = NULL;
 	return (0);
 }
+
+/*
+ * Return the last logical file offset that should be written for this file
+ * if we're doing a write that ends at "size".
+ */
+int
+ffs_size(v)
+	void *v;
+{
+	struct vop_size_args /* {
+		struct vnode *a_vp;
+		off_t a_size;
+		off_t *a_eobp;
+	} */ *ap = v;
+	struct inode *ip = VTOI(ap->a_vp);
+	struct fs *fs = ip->i_fs;
+	ufs_lbn_t olbn, nlbn;
+
+	olbn = lblkno(fs, ip->i_ffs_size);
+	nlbn = lblkno(fs, ap->a_size);
+
+	if (nlbn < NDADDR && olbn <= nlbn) {
+		*ap->a_eobp = fragroundup(fs, ap->a_size);
+	} else {
+		*ap->a_eobp = blkroundup(fs, ap->a_size);
+	}
+	return 0;
+}
diff --git a/sys/ufs/ufs/inode.h b/sys/ufs/ufs/inode.h
index 5665b276a0f..98c73de5579 100644
--- a/sys/ufs/ufs/inode.h
+++ b/sys/ufs/ufs/inode.h
@@ -1,4 +1,4 @@
-/*	$OpenBSD: inode.h,v 1.16 2001/07/04 06:10:50 angelos Exp $	*/
+/*	$OpenBSD: inode.h,v 1.17 2001/11/27 05:27:12 art Exp $	*/
 /*	$NetBSD: inode.h,v 1.8 1995/06/15 23:22:50 cgd Exp $	*/
 
 /*
@@ -84,6 +84,7 @@ struct inode {
 #define i_e2fs  inode_u.e2fs
 
 	struct   cluster_info i_ci;
+	LIST_HEAD(,buf) i_pcbufhd;
 	struct	 dquot *i_dquot[MAXQUOTAS]; /* Dquot structures. */
 	u_quad_t i_modrev;	/* Revision level for NFS lease. */
 	struct	 lockf *i_lockf;/* Head of byte-level lock list. */
diff --git a/sys/ufs/ufs/ufs_bmap.c b/sys/ufs/ufs/ufs_bmap.c
index add641e15ce..fdf5c1be055 100644
--- a/sys/ufs/ufs/ufs_bmap.c
+++ b/sys/ufs/ufs/ufs_bmap.c
@@ -1,4 +1,4 @@
-/*	$OpenBSD: ufs_bmap.c,v 1.10 2001/11/21 22:24:24 csapuntz Exp $	*/
+/*	$OpenBSD: ufs_bmap.c,v 1.11 2001/11/27 05:27:12 art Exp $	*/
 /*	$NetBSD: ufs_bmap.c,v 1.3 1996/02/09 22:36:00 christos Exp $	*/
 
 /*
@@ -233,6 +233,7 @@ ufs_getlbns(vp, bn, ap, nump)
 	long metalbn, realbn;
 	struct ufsmount *ump;
 	int64_t blockcnt;
+	int lbc;
 	int i, numlevels, off;
 
 	ump = VFSTOUFS(vp->v_mount);
@@ -260,10 +261,14 @@ ufs_getlbns(vp, bn, ap, nump)
 	 * at the given level of indirection, and NIADDR - i is the number
 	 * of levels of indirection needed to locate the requested block.
 	 */
-	for (blockcnt = 1, i = NIADDR, bn -= NDADDR;; i--, bn -= blockcnt) {
+	bn -= NDADDR;
+	for (lbc = 0, i = NIADDR;; i--, bn -= blockcnt) {
 		if (i == 0)
 			return (EFBIG);
-		blockcnt *= MNINDIR(ump);
+
+		lbc += ump->um_lognindir;
+		blockcnt = (int64_t)1 << lbc;
+
 		if (bn < blockcnt)
 			break;
 	}
@@ -289,8 +294,9 @@ ufs_getlbns(vp, bn, ap, nump)
 		if (metalbn == realbn)
 			break;
 
-		blockcnt /= MNINDIR(ump);
-		off = (bn / blockcnt) % MNINDIR(ump);
+		lbc -= ump->um_lognindir;
+		blockcnt = (int64_t)1 << lbc;
+		off = (bn >> lbc) & (MNINDIR(ump) - 1);
 
 		++numlevels;
 		ap->in_lbn = metalbn;
diff --git a/sys/ufs/ufs/ufs_extern.h b/sys/ufs/ufs/ufs_extern.h
index 50175a0ec86..fc39e16b45e 100644
--- a/sys/ufs/ufs/ufs_extern.h
+++ b/sys/ufs/ufs/ufs_extern.h
@@ -1,4 +1,4 @@
-/*	$OpenBSD: ufs_extern.h,v 1.12 2001/11/21 21:23:56 csapuntz Exp $	*/
+/*	$OpenBSD: ufs_extern.h,v 1.13 2001/11/27 05:27:12 art Exp $	*/
 /*	$NetBSD: ufs_extern.h,v 1.5 1996/02/09 22:36:03 christos Exp $	*/
 
 /*-
@@ -121,6 +121,7 @@ void ufs_ihashrem __P((struct inode *));
 /* ufs_inode.c */
 int ufs_init __P((struct vfsconf *));
 int ufs_reclaim __P((struct vnode *, struct proc *));
+int ufs_balloc_range __P((struct vnode *, off_t, off_t, struct ucred *, int));
 
 /* ufs_lookup.c */
 void ufs_dirbad __P((struct inode *, doff_t, char *));
diff --git a/sys/ufs/ufs/ufs_inode.c b/sys/ufs/ufs/ufs_inode.c
index 8a3935632fb..3865342fde0 100644
--- a/sys/ufs/ufs/ufs_inode.c
+++ b/sys/ufs/ufs/ufs_inode.c
@@ -1,4 +1,4 @@
-/*	$OpenBSD: ufs_inode.c,v 1.10 2001/11/21 21:23:56 csapuntz Exp $	*/
+/*	$OpenBSD: ufs_inode.c,v 1.11 2001/11/27 05:27:12 art Exp $	*/
 /*	$NetBSD: ufs_inode.c,v 1.7 1996/05/11 18:27:52 mycroft Exp $	*/
 
 /*
@@ -151,3 +151,150 @@ ufs_reclaim(vp, p)
 	ufs_quota_delete(ip);
 	return (0);
 }
+
+/*
+ * allocate a range of blocks in a file.
+ * after this function returns, any page entirely contained within the range
+ * will map to invalid data and thus must be overwritten before it is made
+ * accessible to others.
+ */
+
+int
+ufs_balloc_range(vp, off, len, cred, flags)
+	struct vnode *vp;
+	off_t off, len;
+	struct ucred *cred;
+	int flags;
+{
+	off_t oldeof, neweof, oldeob, neweob, oldpagestart, pagestart;
+	struct uvm_object *uobj;
+	int i, delta, error, npages1, npages2;
+	int bshift = vp->v_mount->mnt_fs_bshift;
+	int bsize = 1 << bshift;
+	int ppb = MAX(bsize >> PAGE_SHIFT, 1);
+	struct vm_page *pgs1[ppb], *pgs2[ppb];
+	UVMHIST_FUNC("ufs_balloc_range"); UVMHIST_CALLED(ubchist);
+	UVMHIST_LOG(ubchist, "vp %p off 0x%x len 0x%x u_size 0x%x",
+		    vp, off, len, vp->v_uvm.u_size);
+
+	oldeof = vp->v_uvm.u_size;
+	error = VOP_SIZE(vp, oldeof, &oldeob);
+	if (error) {
+		return error;
+	}
+
+	neweof = MAX(vp->v_uvm.u_size, off + len);
+	error = VOP_SIZE(vp, neweof, &neweob);
+	if (error) {
+		return error;
+	}
+
+	error = 0;
+	uobj = &vp->v_uvm.u_obj;
+	pgs1[0] = pgs2[0] = NULL;
+
+	/*
+	 * if the last block in the file is not a full block (ie. it is a
+	 * fragment), and this allocation is causing the fragment to change
+	 * size (either to expand the fragment or promote it to a full block),
+	 * cache the old last block (at its new size).
+	 */
+
+	oldpagestart = trunc_page(oldeof) & ~(bsize - 1);
+	if ((oldeob & (bsize - 1)) != 0 && oldeob != neweob) {
+		npages1 = MIN(ppb, (round_page(neweob) - oldpagestart) >>
+			      PAGE_SHIFT);
+		memset(pgs1, 0, npages1 * sizeof(struct vm_page *));
+		simple_lock(&uobj->vmobjlock);
+		error = VOP_GETPAGES(vp, oldpagestart, pgs1, &npages1,
+		    0, VM_PROT_READ, 0, PGO_SYNCIO|PGO_PASTEOF);
+		if (error) {
+			goto out;
+		}
+		simple_lock(&uobj->vmobjlock);
+		uvm_lock_pageq();
+		for (i = 0; i < npages1; i++) {
+			UVMHIST_LOG(ubchist, "got pgs1[%d] %p", i, pgs1[i],0,0);
+			KASSERT((pgs1[i]->flags & PG_RELEASED) == 0);
+			pgs1[i]->flags &= ~PG_CLEAN;
+			uvm_pageactivate(pgs1[i]);
+		}
+		uvm_unlock_pageq();
+		simple_unlock(&uobj->vmobjlock);
+	}
+
+	/*
+	 * cache the new range as well.  this will create zeroed pages
+	 * where the new block will be and keep them locked until the
+	 * new block is allocated, so there will be no window where
+	 * the old contents of the new block is visible to racing threads.
+	 */
+
+	pagestart = trunc_page(off) & ~(bsize - 1);
+	if (pagestart != oldpagestart || pgs1[0] == NULL) {
+		npages2 = MIN(ppb, (round_page(neweob) - pagestart) >>
+			      PAGE_SHIFT);
+		memset(pgs2, 0, npages2 * sizeof(struct vm_page *));
+		simple_lock(&uobj->vmobjlock);
+		error = VOP_GETPAGES(vp, pagestart, pgs2, &npages2, 0,
+		    VM_PROT_READ, 0, PGO_SYNCIO|PGO_PASTEOF);
+		if (error) {
+			goto out;
+		}
+		simple_lock(&uobj->vmobjlock);
+		uvm_lock_pageq();
+		for (i = 0; i < npages2; i++) {
+			UVMHIST_LOG(ubchist, "got pgs2[%d] %p", i, pgs2[i],0,0);
+			KASSERT((pgs2[i]->flags & PG_RELEASED) == 0);
+			pgs2[i]->flags &= ~PG_CLEAN;
+			uvm_pageactivate(pgs2[i]);
+		}
+		uvm_unlock_pageq();
+		simple_unlock(&uobj->vmobjlock);
+	}
+
+	/*
+	 * adjust off to be block-aligned.
+	 */
+
+	delta = off & (bsize - 1);
+	off -= delta;
+	len += delta;
+
+	/*
+	 * now allocate the range.
+	 */
+
+	lockmgr(&vp->v_glock, LK_EXCLUSIVE, NULL, curproc);
+	error = VOP_BALLOCN(vp, off, len, cred, flags);
+	lockmgr(&vp->v_glock, LK_RELEASE, NULL, curproc);
+
+	/*
+	 * unbusy any pages we are holding.
+	 * if we got an error, free any pages we created past the old eob.
+	 */
+
+out:
+	simple_lock(&uobj->vmobjlock);
+	if (error) {
+		(void) (uobj->pgops->pgo_flush)(uobj, round_page(oldeob), 0,
+		    PGO_FREE);
+	}
+	if (pgs1[0] != NULL) {
+		uvm_page_unbusy(pgs1, npages1);
+
+		/*
+		 * The data in the frag might be moving to a new disk location.
+		 * We need to flush pages to the new disk locations.
+		 */
+
+		(uobj->pgops->pgo_flush)(uobj, oldeof & ~(bsize - 1),
+		    MIN((oldeof + bsize) & ~(bsize - 1), neweof),
+		    PGO_CLEANIT | ((flags & B_SYNC) ? PGO_SYNCIO : 0));
+	}
+	if (pgs2[0] != NULL) {
+		uvm_page_unbusy(pgs2, npages2);
+	}
+	simple_unlock(&uobj->vmobjlock);
+	return error;
+}
diff --git a/sys/ufs/ufs/ufs_readwrite.c b/sys/ufs/ufs/ufs_readwrite.c
index bbf1391dfe5..e0777e4b55f 100644
--- a/sys/ufs/ufs/ufs_readwrite.c
+++ b/sys/ufs/ufs/ufs_readwrite.c
@@ -1,4 +1,4 @@
-/*	$OpenBSD: ufs_readwrite.c,v 1.19 2001/06/27 04:58:49 art Exp $	*/
+/*	$OpenBSD: ufs_readwrite.c,v 1.20 2001/11/27 05:27:12 art Exp $	*/
 /*	$NetBSD: ufs_readwrite.c,v 1.9 1996/05/11 18:27:57 mycroft Exp $	*/
 
 /*-
@@ -76,21 +76,22 @@ READ(v)
 		int a_ioflag;
 		struct ucred *a_cred;
 	} */ *ap = v;
-	register struct vnode *vp;
-	register struct inode *ip;
-	register struct uio *uio;
-	register FS *fs;
+	struct vnode *vp;
+	struct inode *ip;
+	struct uio *uio;
+	FS *fs;
+	void *win;
+	vsize_t bytelen;
 	struct buf *bp;
 	daddr_t lbn, nextlbn;
 	off_t bytesinfile;
 	long size, xfersize, blkoffset;
 	int error;
-	u_short mode;
 
 	vp = ap->a_vp;
 	ip = VTOI(vp);
-	mode = ip->i_ffs_mode;
 	uio = ap->a_uio;
+	error = 0;
 
 #ifdef DIAGNOSTIC
 	if (uio->uio_rw != UIO_READ)
@@ -110,6 +111,24 @@ READ(v)
 
 	if (uio->uio_resid == 0)
 		return (0);
+	if (uio->uio_offset >= ip->i_ffs_size)
+		goto out;
+
+	if (vp->v_type == VREG) {
+		while (uio->uio_resid > 0) {
+			bytelen = min(ip->i_ffs_size - uio->uio_offset,
+			    uio->uio_resid);
+			if (bytelen == 0)
+				break;
+			win = ubc_alloc(&vp->v_uvm.u_obj, uio->uio_offset,
+			    &bytelen, UBC_READ);
+			error = uiomove(win, bytelen, uio);
+			ubc_release(win, 0);
+			if (error)
+			        break;
+		}
+		goto out;
+	}
 
 	for (error = 0, bp = NULL; uio->uio_resid > 0; bp = NULL) {
 		if ((bytesinfile = ip->i_ffs_size - uio->uio_offset) <= 0)
@@ -131,9 +150,6 @@ READ(v)
 #else
 		if (lblktosize(fs, nextlbn) >= ip->i_ffs_size)
 			error = bread(vp, lbn, size, NOCRED, &bp);
-		else if (doclusterread)
-			error = cluster_read(vp, &ip->i_ci,
-			    ip->i_ffs_size, lbn, size, NOCRED, &bp);
 		else if (lbn - 1 == ip->i_ci.ci_lastr) {
 			int nextsize = BLKSIZE(fs, ip, nextlbn);
 			error = breadn(vp, lbn,
@@ -158,7 +174,7 @@ READ(v)
 				break;
 			xfersize = size;
 		}
-		error = uiomove((char *)bp->b_data + blkoffset, (int)xfersize,
+		error = uiomove((char *)bp->b_data + blkoffset, xfersize,
 				uio);
 		if (error)
 			break;
@@ -166,6 +182,7 @@ READ(v)
 	}
 	if (bp != NULL)
 		brelse(bp);
+out:
 	ip->i_flag |= IN_ACCESS;
 	return (error);
 }
@@ -183,15 +200,19 @@ WRITE(v)
 		int a_ioflag;
 		struct ucred *a_cred;
 	} */ *ap = v;
-	register struct vnode *vp;
-	register struct uio *uio;
-	register struct inode *ip;
-	register FS *fs;
+	struct vnode *vp;
+	struct uio *uio;
+	struct inode *ip;
+	FS *fs;
 	struct buf *bp;
 	struct proc *p;
 	daddr_t lbn;
 	off_t osize;
 	int blkoffset, error, extended, flags, ioflag, resid, size, xfersize;
+	void *win;
+	vsize_t bytelen;
+	off_t oldoff;
+	boolean_t rv;
 
 	extended = 0;
 	ioflag = ap->a_ioflag;
@@ -239,9 +260,77 @@ WRITE(v)
 
 	resid = uio->uio_resid;
 	osize = ip->i_ffs_size;
-	flags = ioflag & IO_SYNC ? B_SYNC : 0;
+	error = 0;
+
+	if (vp->v_type != VREG)
+		goto bcache;
+
+	while (uio->uio_resid > 0) {
+		oldoff = uio->uio_offset;
+		blkoffset = blkoff(fs, uio->uio_offset);
+		bytelen = min(fs->fs_bsize - blkoffset, uio->uio_resid);
+ 
+		/*
+		 * XXXUBC if file is mapped and this is the last block,
+		 * process one page at a time.
+		 */
+
+		error = ufs_balloc_range(vp, uio->uio_offset, bytelen,
+		    ap->a_cred, ioflag & IO_SYNC ? B_SYNC : 0);
+		if (error) {
+			return error;
+		}
 
-	for (error = 0; uio->uio_resid > 0;) {
+		win = ubc_alloc(&vp->v_uvm.u_obj, uio->uio_offset, &bytelen,
+				UBC_WRITE);
+		error = uiomove(win, bytelen, uio);
+		ubc_release(win, 0);
+
+		/*
+		 * flush what we just wrote if necessary.
+		 * XXXUBC simplistic async flushing.
+		 */
+
+		if (ioflag & IO_SYNC) {
+			simple_lock(&vp->v_uvm.u_obj.vmobjlock);
+#if 1
+			/*
+			 * XXX 
+			 * flush whole blocks in case there are deps.
+			 * otherwise we can dirty and flush part of
+			 * a block multiple times and the softdep code
+			 * will get confused.  fixing this the right way
+			 * is complicated so we'll work around it for now.
+			 */
+                      
+			rv = vp->v_uvm.u_obj.pgops->pgo_flush(
+			    &vp->v_uvm.u_obj,
+			    oldoff & ~(fs->fs_bsize - 1),
+			    (oldoff + bytelen + fs->fs_bsize - 1) &
+			    ~(fs->fs_bsize - 1),
+			    PGO_CLEANIT|PGO_SYNCIO);
+#else
+			rv = vp->v_uvm.u_obj.pgops->pgo_flush(
+			    &vp->v_uvm.u_obj, oldoff, oldoff + bytelen,
+			    PGO_CLEANIT|PGO_SYNCIO);
+#endif
+			simple_unlock(&vp->v_uvm.u_obj.vmobjlock);
+		} else if (oldoff >> 16 != uio->uio_offset >> 16) {
+			simple_lock(&vp->v_uvm.u_obj.vmobjlock);
+			rv = vp->v_uvm.u_obj.pgops->pgo_flush(
+			    &vp->v_uvm.u_obj, (oldoff >> 16) << 16,
+			    (uio->uio_offset >> 16) << 16, PGO_CLEANIT);
+			simple_unlock(&vp->v_uvm.u_obj.vmobjlock);
+		}
+		if (error) {
+			break;
+		}
+	}
+	goto out;
+
+bcache:
+	flags = ioflag & IO_SYNC ? B_SYNC : 0;
+	while (uio->uio_resid > 0) {
 		lbn = lblkno(fs, uio->uio_offset);
 		blkoffset = blkoff(fs, uio->uio_offset);
 		xfersize = fs->fs_bsize - blkoffset;
@@ -260,14 +349,12 @@ WRITE(v)
 			uvm_vnp_setsize(vp, ip->i_ffs_size);
 			extended = 1;
 		}
-		(void)uvm_vnp_uncache(vp);
 
 		size = BLKSIZE(fs, ip, lbn) - bp->b_resid;
 		if (size < xfersize)
 			xfersize = size;
 
-		error =
-		    uiomove((char *)bp->b_data + blkoffset, xfersize, uio);
+		error = uiomove((char *)bp->b_data + blkoffset, xfersize, uio);
 
 		if (error != 0)
 			bzero((char *)bp->b_data + blkoffset, xfersize);
@@ -287,13 +374,14 @@ WRITE(v)
 #endif
 		if (error || xfersize == 0)
 			break;
-		ip->i_flag |= IN_CHANGE | IN_UPDATE;
 	}
 	/*
 	 * If we successfully wrote any data, and we are not the superuser
 	 * we clear the setuid and setgid bits as a precaution against
 	 * tampering.
 	 */
+out:
+	ip->i_flag |= IN_CHANGE | IN_UPDATE;
 	if (resid > uio->uio_resid && ap->a_cred && ap->a_cred->cr_uid != 0)
 		ip->i_ffs_mode &= ~(ISUID | ISGID);
 	if (resid > uio->uio_resid)
diff --git a/sys/ufs/ufs/ufs_vnops.c b/sys/ufs/ufs/ufs_vnops.c
index 4caf0ef78c7..e926ee7aff6 100644
--- a/sys/ufs/ufs/ufs_vnops.c
+++ b/sys/ufs/ufs/ufs_vnops.c
@@ -1,4 +1,4 @@
-/*	$OpenBSD: ufs_vnops.c,v 1.39 2001/11/21 21:23:56 csapuntz Exp $	*/
+/*	$OpenBSD: ufs_vnops.c,v 1.40 2001/11/27 05:27:12 art Exp $	*/
 /*	$NetBSD: ufs_vnops.c,v 1.18 1996/05/11 18:28:04 mycroft Exp $	*/
 
 /*
@@ -469,8 +469,6 @@ ufs_chmod(vp, mode, cred, p)
 	ip->i_ffs_mode &= ~ALLPERMS;
 	ip->i_ffs_mode |= (mode & ALLPERMS);
 	ip->i_flag |= IN_CHANGE;
-	if ((vp->v_flag & VTEXT) && (ip->i_ffs_mode & S_ISTXT) == 0)
-		(void) uvm_vnp_uncache(vp);
 	return (0);
 }
 
diff --git a/sys/ufs/ufs/ufsmount.h b/sys/ufs/ufs/ufsmount.h
index e9dc71f9855..981eb21474b 100644
--- a/sys/ufs/ufs/ufsmount.h
+++ b/sys/ufs/ufs/ufsmount.h
@@ -1,4 +1,4 @@
-/*	$OpenBSD: ufsmount.h,v 1.5 1999/06/01 01:48:52 millert Exp $	*/
+/*	$OpenBSD: ufsmount.h,v 1.6 2001/11/27 05:27:12 art Exp $	*/
 /*	$NetBSD: ufsmount.h,v 1.4 1994/12/21 20:00:23 mycroft Exp $	*/
 
 /*
@@ -64,6 +64,7 @@ struct ufsmount {
 	struct	vnode *um_quotas[MAXQUOTAS];	/* pointer to quota files */
 	struct	ucred *um_cred[MAXQUOTAS];	/* quota file access cred */
 	u_long	um_nindir;			/* indirect ptrs per block */
+	u_long	um_lognindir;			/* log2 of um_nindir */
 	u_long	um_bptrtodb;			/* indir ptr to disk block */
 	u_long	um_seqinc;			/* inc between seq blocks */
 	time_t	um_btime[MAXQUOTAS];		/* block quota time limit */
diff --git a/sys/uvm/uvm_anon.c b/sys/uvm/uvm_anon.c
index 347867e47b8..8478141a72c 100644
--- a/sys/uvm/uvm_anon.c
+++ b/sys/uvm/uvm_anon.c
@@ -1,4 +1,4 @@
-/*	$OpenBSD: uvm_anon.c,v 1.15 2001/11/11 01:16:56 art Exp $	*/
+/*	$OpenBSD: uvm_anon.c,v 1.16 2001/11/27 05:27:12 art Exp $	*/
 /*	$NetBSD: uvm_anon.c,v 1.15 2001/02/18 21:19:08 chs Exp $	*/
 
 /*
@@ -518,9 +518,6 @@ anon_pagein(anon)
 	 */
 
 	pmap_clear_reference(pg);
-#ifndef UBC
-	pmap_page_protect(pg, VM_PROT_NONE);
-#endif
 	uvm_lock_pageq();
 	uvm_pagedeactivate(pg);
 	uvm_unlock_pageq();
diff --git a/sys/uvm/uvm_aobj.c b/sys/uvm/uvm_aobj.c
index 85ce0a495f6..0ebf53c3502 100644
--- a/sys/uvm/uvm_aobj.c
+++ b/sys/uvm/uvm_aobj.c
@@ -1,4 +1,4 @@
-/*	$OpenBSD: uvm_aobj.c,v 1.20 2001/11/11 01:16:56 art Exp $	*/
+/*	$OpenBSD: uvm_aobj.c,v 1.21 2001/11/27 05:27:12 art Exp $	*/
 /*	$NetBSD: uvm_aobj.c,v 1.39 2001/02/18 21:19:08 chs Exp $	*/
 
 /*
@@ -878,15 +878,8 @@ uao_flush(uobj, start, stop, flags)
 			    pp->wire_count != 0)
 				continue;
 
-#ifdef UBC
 			/* ...and deactivate the page. */
 			pmap_clear_reference(pp);
-#else
-			/* zap all mappings for the page. */
-			pmap_page_protect(pp, VM_PROT_NONE);
-
-			/* ...and deactivate the page. */
-#endif
 			uvm_pagedeactivate(pp);
 
 			continue;
@@ -1523,9 +1516,6 @@ uao_pagein_page(aobj, pageidx)
 	 * deactivate the page (to put it on a page queue).
 	 */
 	pmap_clear_reference(pg);
-#ifndef UBC
-	pmap_page_protect(pg, VM_PROT_NONE);
-#endif
 	uvm_lock_pageq();
 	uvm_pagedeactivate(pg);
 	uvm_unlock_pageq();
diff --git a/sys/uvm/uvm_bio.c b/sys/uvm/uvm_bio.c
new file mode 100644
index 00000000000..fccf51b8ece
--- /dev/null
+++ b/sys/uvm/uvm_bio.c
@@ -0,0 +1,547 @@
+/*	$NetBSD: uvm_bio.c,v 1.7 2001/02/02 01:55:52 enami Exp $	*/
+
+/* 
+ * Copyright (c) 1998 Chuck Silvers.
+ * 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. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * 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.
+ *
+ */
+
+/*
+ * uvm_bio.c: buffered i/o vnode mapping cache
+ */
+
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/malloc.h>
+#include <sys/kernel.h>
+#include <sys/vnode.h>
+
+#include <uvm/uvm.h>
+#include <uvm/uvm_page.h>
+
+/*
+ * global data structures
+ */
+
+/*
+ * local functions
+ */
+
+static int	ubc_fault __P((struct uvm_faultinfo *, vaddr_t, 
+			       vm_page_t *, int, int, vm_fault_t, vm_prot_t,
+			       int));
+static struct ubc_map *ubc_find_mapping __P((struct uvm_object *, voff_t));
+
+/*
+ * local data structues
+ */
+
+#define UBC_HASH(uobj, offset) (((((u_long)(uobj)) >> 8) + \
+				 (((u_long)(offset)) >> PAGE_SHIFT)) & \
+				ubc_object.hashmask)
+
+#define UBC_QUEUE(offset) (&ubc_object.inactive[((offset) / ubc_winsize) & \
+					       (UBC_NQUEUES - 1)])
+
+struct ubc_map
+{
+	struct uvm_object *	uobj;		/* mapped object */
+	voff_t			offset;		/* offset into uobj */
+	int			refcount;	/* refcount on mapping */
+	voff_t			writeoff;	/* overwrite offset */
+	vsize_t			writelen;	/* overwrite len */
+
+	LIST_ENTRY(ubc_map)	hash;		/* hash table */
+	TAILQ_ENTRY(ubc_map)	inactive;	/* inactive queue */
+};
+
+static struct ubc_object
+{
+	struct uvm_object uobj;		/* glue for uvm_map() */
+	char *kva;			/* where ubc_object is mapped */
+	struct ubc_map *umap;		/* array of ubc_map's */
+
+	LIST_HEAD(, ubc_map) *hash;	/* hashtable for cached ubc_map's */
+	u_long hashmask;		/* mask for hashtable */
+
+	TAILQ_HEAD(ubc_inactive_head, ubc_map) *inactive;
+					/* inactive queues for ubc_map's */
+
+} ubc_object;
+
+struct uvm_pagerops ubc_pager =
+{
+	NULL,		/* init */
+	NULL,		/* reference */
+	NULL,		/* detach */
+	ubc_fault,	/* fault */
+	/* ... rest are NULL */
+};
+
+int ubc_nwins = UBC_NWINS;
+int ubc_winsize = UBC_WINSIZE;
+#ifdef PMAP_PREFER
+int ubc_nqueues;
+boolean_t ubc_release_unmap = FALSE;
+#define UBC_NQUEUES ubc_nqueues
+#define UBC_RELEASE_UNMAP ubc_release_unmap
+#else
+#define UBC_NQUEUES 1
+#define UBC_RELEASE_UNMAP FALSE
+#endif
+
+/*
+ * ubc_init
+ *
+ * init pager private data structures.
+ */
+
+void
+ubc_init(void)
+{
+	struct ubc_map *umap;
+	vaddr_t va;
+	int i;
+
+	/*
+	 * init ubc_object.
+	 * alloc and init ubc_map's.
+	 * init inactive queues.
+	 * alloc and init hashtable.
+	 * map in ubc_object.
+	 */
+
+	simple_lock_init(&ubc_object.uobj.vmobjlock);
+	ubc_object.uobj.pgops = &ubc_pager;
+	TAILQ_INIT(&ubc_object.uobj.memq);
+	ubc_object.uobj.uo_npages = 0;
+	ubc_object.uobj.uo_refs = UVM_OBJ_KERN;
+
+	ubc_object.umap = malloc(ubc_nwins * sizeof(struct ubc_map),
+				 M_TEMP, M_NOWAIT);
+	if (ubc_object.umap == NULL)
+		panic("ubc_init: failed to allocate ubc_map");
+	bzero(ubc_object.umap, ubc_nwins * sizeof(struct ubc_map));
+
+	va = (vaddr_t)1L;
+#ifdef PMAP_PREFER
+	PMAP_PREFER(0, &va);
+	if (va < ubc_winsize) {
+		va = ubc_winsize;
+	}
+	ubc_nqueues = va / ubc_winsize;
+	if (ubc_nqueues != 1) {
+		ubc_release_unmap = TRUE;
+	}
+#endif
+	ubc_object.inactive = malloc(UBC_NQUEUES *
+				     sizeof(struct ubc_inactive_head),
+				     M_TEMP, M_NOWAIT);
+	if (ubc_object.inactive == NULL)
+		panic("ubc_init: failed to allocate inactive queue heads");
+	for (i = 0; i < UBC_NQUEUES; i++) {
+		TAILQ_INIT(&ubc_object.inactive[i]);
+	}
+	for (i = 0; i < ubc_nwins; i++) {
+		umap = &ubc_object.umap[i];
+		TAILQ_INSERT_TAIL(&ubc_object.inactive[i & (UBC_NQUEUES - 1)],
+				  umap, inactive);
+	}
+
+	ubc_object.hash = hashinit(ubc_nwins, M_TEMP, M_NOWAIT,
+				   &ubc_object.hashmask);
+	for (i = 0; i <= ubc_object.hashmask; i++) {
+		LIST_INIT(&ubc_object.hash[i]);
+	}
+
+	if (uvm_map(kernel_map, (vaddr_t *)&ubc_object.kva,
+		    ubc_nwins * ubc_winsize, &ubc_object.uobj, 0, (vsize_t)va,
+		    UVM_MAPFLAG(UVM_PROT_ALL, UVM_PROT_ALL, UVM_INH_NONE,
+				UVM_ADV_RANDOM, UVM_FLAG_NOMERGE))
+	    != KERN_SUCCESS) {
+		panic("ubc_init: failed to map ubc_object\n");
+	}
+	UVMHIST_INIT(ubchist, 300);
+}
+
+
+/*
+ * ubc_fault: fault routine for ubc mapping
+ */
+static int
+ubc_fault(ufi, ign1, ign2, ign3, ign4, fault_type, access_type, flags)
+	struct uvm_faultinfo *ufi;
+	vaddr_t ign1;
+	vm_page_t *ign2;
+	int ign3, ign4;
+	vm_fault_t fault_type;
+	vm_prot_t access_type;
+	int flags;
+{
+	struct uvm_object *uobj;
+	struct vnode *vp;
+	struct ubc_map *umap;
+	vaddr_t va, eva, ubc_offset, slot_offset;
+	int i, error, rv, npages;
+	struct vm_page *pgs[ubc_winsize >> PAGE_SHIFT], *pg;
+	UVMHIST_FUNC("ubc_fault");  UVMHIST_CALLED(ubchist);
+
+	/*
+	 * no need to try with PGO_LOCKED...
+	 * we don't need to have the map locked since we know that
+	 * no one will mess with it until our reference is released.
+	 */
+	if (flags & PGO_LOCKED) {
+#if 0
+		return VM_PAGER_UNLOCK;
+#else
+		uvmfault_unlockall(ufi, NULL, &ubc_object.uobj, NULL);
+		flags &= ~PGO_LOCKED;
+#endif
+	}
+
+	va = ufi->orig_rvaddr;
+	ubc_offset = va - (vaddr_t)ubc_object.kva;
+
+	UVMHIST_LOG(ubchist, "va 0x%lx ubc_offset 0x%lx at %d",
+		    va, ubc_offset, access_type,0);
+
+	umap = &ubc_object.umap[ubc_offset / ubc_winsize];
+	KASSERT(umap->refcount != 0);
+	slot_offset = trunc_page(ubc_offset & (ubc_winsize - 1));
+
+	/* no umap locking needed since we have a ref on the umap */
+	uobj = umap->uobj;
+	vp = (struct vnode *)uobj;
+	KASSERT(uobj != NULL);
+
+	npages = (ubc_winsize - slot_offset) >> PAGE_SHIFT;
+
+	/*
+	 * XXXUBC
+	 * if npages is more than 1 we have to be sure that
+	 * we set PGO_OVERWRITE correctly.
+	 */
+	if (access_type == VM_PROT_WRITE) {
+		npages = 1;
+	}
+
+again:
+	memset(pgs, 0, sizeof (pgs));
+	simple_lock(&uobj->vmobjlock);
+
+	UVMHIST_LOG(ubchist, "slot_offset 0x%x writeoff 0x%x writelen 0x%x "
+		    "u_size 0x%x", slot_offset, umap->writeoff, umap->writelen,
+		    vp->v_uvm.u_size);
+
+	if (access_type & VM_PROT_WRITE &&
+	    slot_offset >= umap->writeoff &&
+	    (slot_offset + PAGE_SIZE <= umap->writeoff + umap->writelen ||
+	     slot_offset + PAGE_SIZE >= vp->v_uvm.u_size - umap->offset)) {
+		UVMHIST_LOG(ubchist, "setting PGO_OVERWRITE", 0,0,0,0);
+		flags |= PGO_OVERWRITE;
+	}
+	else { UVMHIST_LOG(ubchist, "NOT setting PGO_OVERWRITE", 0,0,0,0); }
+	/* XXX be sure to zero any part of the page past EOF */
+
+	/*
+	 * XXX
+	 * ideally we'd like to pre-fault all of the pages we're overwriting.
+	 * so for PGO_OVERWRITE, we should call VOP_GETPAGES() with all of the
+	 * pages in [writeoff, writeoff+writesize] instead of just the one.
+	 */
+
+	UVMHIST_LOG(ubchist, "getpages vp %p offset 0x%x npages %d",
+		    uobj, umap->offset + slot_offset, npages, 0);
+
+	error = VOP_GETPAGES(vp, umap->offset + slot_offset, pgs, &npages, 0,
+	    access_type, 0, flags);
+	UVMHIST_LOG(ubchist, "getpages error %d npages %d", error, npages,0,0);
+
+	if (error == EAGAIN) {
+		tsleep(&lbolt, PVM, "ubc_fault", 0);
+		goto again;
+	}
+	if (error) {
+		return VM_PAGER_ERROR;
+	}
+	if (npages == 0) {
+		return VM_PAGER_OK;
+	}
+
+	va = ufi->orig_rvaddr;
+	eva = ufi->orig_rvaddr + (npages << PAGE_SHIFT);
+
+	UVMHIST_LOG(ubchist, "va 0x%lx eva 0x%lx", va, eva, 0,0);
+	simple_lock(&uobj->vmobjlock);
+	for (i = 0; va < eva; i++, va += PAGE_SIZE) {
+		UVMHIST_LOG(ubchist, "pgs[%d] = %p", i, pgs[i],0,0);
+		pg = pgs[i];
+
+		if (pg == NULL || pg == PGO_DONTCARE) {
+			continue;
+		}
+		if (pg->flags & PG_WANTED) {
+			wakeup(pg);
+		}
+		KASSERT((pg->flags & PG_FAKE) == 0);
+		if (pg->flags & PG_RELEASED) {
+			rv = uobj->pgops->pgo_releasepg(pg, NULL);
+			KASSERT(rv);
+			continue;
+		}
+		KASSERT(access_type == VM_PROT_READ ||
+			(pg->flags & PG_RDONLY) == 0);
+
+		uvm_lock_pageq();
+		uvm_pageactivate(pg);
+		uvm_unlock_pageq();
+
+		pmap_enter(ufi->orig_map->pmap, va, VM_PAGE_TO_PHYS(pg),
+			   VM_PROT_READ | VM_PROT_WRITE, access_type);
+
+		pg->flags &= ~(PG_BUSY);
+		UVM_PAGE_OWN(pg, NULL);
+	}
+	simple_unlock(&uobj->vmobjlock);
+	return VM_PAGER_OK;
+}
+
+/*
+ * local functions
+ */
+
+static struct ubc_map *
+ubc_find_mapping(uobj, offset)
+	struct uvm_object *uobj;
+	voff_t offset;
+{
+	struct ubc_map *umap;
+
+	LIST_FOREACH(umap, &ubc_object.hash[UBC_HASH(uobj, offset)], hash) {
+		if (umap->uobj == uobj && umap->offset == offset) {
+			return umap;
+		}
+	}
+	return NULL;
+}
+
+
+/*
+ * ubc interface functions
+ */
+
+/*
+ * ubc_alloc:  allocate a buffer mapping
+ */
+void *
+ubc_alloc(uobj, offset, lenp, flags)
+	struct uvm_object *uobj;
+	voff_t offset;
+	vsize_t *lenp;
+	int flags;
+{
+	int s;
+	vaddr_t slot_offset, va;
+	struct ubc_map *umap;
+	voff_t umap_offset;
+	UVMHIST_FUNC("ubc_alloc"); UVMHIST_CALLED(ubchist);
+
+	UVMHIST_LOG(ubchist, "uobj %p offset 0x%lx len 0x%lx filesize 0x%x",
+		    uobj, offset, *lenp, ((struct uvm_vnode *)uobj)->u_size);
+
+	umap_offset = (offset & ~((voff_t)ubc_winsize - 1));
+	slot_offset = (vaddr_t)(offset & ((voff_t)ubc_winsize - 1));
+	*lenp = min(*lenp, ubc_winsize - slot_offset);
+
+	/*
+	 * the vnode is always locked here, so we don't need to add a ref.
+	 */
+
+	s = splbio();
+
+again:
+	simple_lock(&ubc_object.uobj.vmobjlock);
+	umap = ubc_find_mapping(uobj, umap_offset);
+	if (umap == NULL) {
+		umap = TAILQ_FIRST(UBC_QUEUE(offset));
+		if (umap == NULL) {
+			simple_unlock(&ubc_object.uobj.vmobjlock);
+			tsleep(&lbolt, PVM, "ubc_alloc", 0);
+			goto again;
+		}
+
+		/*
+		 * remove from old hash (if any),
+		 * add to new hash.
+		 */
+
+		if (umap->uobj != NULL) {
+			LIST_REMOVE(umap, hash);
+		}
+
+		umap->uobj = uobj;
+		umap->offset = umap_offset;
+
+		LIST_INSERT_HEAD(&ubc_object.hash[UBC_HASH(uobj, umap_offset)],
+				 umap, hash);
+
+		va = (vaddr_t)(ubc_object.kva +
+			       (umap - ubc_object.umap) * ubc_winsize);
+		pmap_remove(pmap_kernel(), va, va + ubc_winsize);
+	}
+
+	if (umap->refcount == 0) {
+		TAILQ_REMOVE(UBC_QUEUE(offset), umap, inactive);
+	}
+
+#ifdef DIAGNOSTIC
+	if ((flags & UBC_WRITE) &&
+	    (umap->writeoff || umap->writelen)) {
+		panic("ubc_fault: concurrent writes vp %p", uobj);
+	}
+#endif
+	if (flags & UBC_WRITE) {
+		umap->writeoff = slot_offset;
+		umap->writelen = *lenp;
+	}
+
+	umap->refcount++;
+	simple_unlock(&ubc_object.uobj.vmobjlock);
+	splx(s);
+	UVMHIST_LOG(ubchist, "umap %p refs %d va %p",
+		    umap, umap->refcount,
+		    ubc_object.kva + (umap - ubc_object.umap) * ubc_winsize,0);
+
+	return ubc_object.kva +
+		(umap - ubc_object.umap) * ubc_winsize + slot_offset;
+}
+
+
+void
+ubc_release(va, wlen)
+	void *va;
+	vsize_t wlen;
+{
+	struct ubc_map *umap;
+	struct uvm_object *uobj;
+	int s;
+	UVMHIST_FUNC("ubc_release"); UVMHIST_CALLED(ubchist);
+
+	UVMHIST_LOG(ubchist, "va %p", va,0,0,0);
+
+	s = splbio();
+	simple_lock(&ubc_object.uobj.vmobjlock);
+
+	umap = &ubc_object.umap[((char *)va - ubc_object.kva) / ubc_winsize];
+	uobj = umap->uobj;
+	KASSERT(uobj != NULL);
+
+	umap->writeoff = 0;
+	umap->writelen = 0;
+	umap->refcount--;
+	if (umap->refcount == 0) {
+		if (UBC_RELEASE_UNMAP &&
+		    (((struct vnode *)uobj)->v_flag & VTEXT)) {
+			vaddr_t va;
+
+			/*
+			 * if this file is the executable image of
+			 * some process, that process will likely have
+			 * the file mapped at an alignment other than
+			 * what PMAP_PREFER() would like.  we'd like
+			 * to have process text be able to use the
+			 * cache even if someone is also reading the
+			 * file, so invalidate mappings of such files
+			 * as soon as possible.
+			 */
+
+			va = (vaddr_t)(ubc_object.kva +
+			    (umap - ubc_object.umap) * ubc_winsize);
+			pmap_remove(pmap_kernel(), va, va + ubc_winsize);
+			LIST_REMOVE(umap, hash);
+			umap->uobj = NULL;
+			TAILQ_INSERT_HEAD(UBC_QUEUE(umap->offset), umap,
+			    inactive);
+		} else {
+			TAILQ_INSERT_TAIL(UBC_QUEUE(umap->offset), umap,
+			    inactive);
+		}
+	}
+	UVMHIST_LOG(ubchist, "umap %p refs %d", umap, umap->refcount,0,0);
+	simple_unlock(&ubc_object.uobj.vmobjlock);
+	splx(s);
+}
+
+
+/*
+ * removing a range of mappings from the ubc mapping cache.
+ */
+
+void
+ubc_flush(uobj, start, end)
+	struct uvm_object *uobj;
+	voff_t start, end;
+{
+	struct ubc_map *umap;
+	vaddr_t va;
+	int s;
+	UVMHIST_FUNC("ubc_flush");  UVMHIST_CALLED(ubchist);
+
+	UVMHIST_LOG(ubchist, "uobj %p start 0x%lx end 0x%lx",
+		    uobj, start, end,0);
+
+	s = splbio(); 
+	simple_lock(&ubc_object.uobj.vmobjlock);
+	for (umap = ubc_object.umap;
+	     umap < &ubc_object.umap[ubc_nwins];
+	     umap++) {
+
+		if (umap->uobj != uobj || 
+		    umap->offset < start ||
+		    (umap->offset >= end && end != 0) ||
+		    umap->refcount > 0) {
+			continue;
+		}
+
+		/*
+		 * remove from hash,
+		 * move to head of inactive queue.
+		 */
+
+		va = (vaddr_t)(ubc_object.kva +
+			       (umap - ubc_object.umap) * ubc_winsize);
+		pmap_remove(pmap_kernel(), va, va + ubc_winsize);
+
+		LIST_REMOVE(umap, hash);
+		umap->uobj = NULL;
+		TAILQ_REMOVE(UBC_QUEUE(umap->offset), umap, inactive);
+		TAILQ_INSERT_HEAD(UBC_QUEUE(umap->offset), umap, inactive);
+	}
+	simple_unlock(&ubc_object.uobj.vmobjlock);
+	splx(s);
+}
diff --git a/sys/uvm/uvm_extern.h b/sys/uvm/uvm_extern.h
index 5575021ad6f..bb6b841f0ca 100644
--- a/sys/uvm/uvm_extern.h
+++ b/sys/uvm/uvm_extern.h
@@ -1,4 +1,4 @@
-/*	$OpenBSD: uvm_extern.h,v 1.33 2001/11/12 01:26:09 art Exp $	*/
+/*	$OpenBSD: uvm_extern.h,v 1.34 2001/11/27 05:27:12 art Exp $	*/
 /*	$NetBSD: uvm_extern.h,v 1.57 2001/03/09 01:02:12 chs Exp $	*/
 
 /*
@@ -223,6 +223,21 @@ typedef int		vm_prot_t;
 #define	UVM_PGA_ZERO		0x0002	/* returned page must be zero'd */
 
 /*
+ * the following defines are for ubc_alloc's flags
+ */
+#define UBC_READ	0
+#define UBC_WRITE	1
+
+/*
+ * flags for uvn_findpages().
+ */
+#define UFP_ALL		0x0
+#define UFP_NOWAIT	0x1
+#define UFP_NOALLOC	0x2
+#define UFP_NOCACHE	0x4
+#define UFP_NORDONLY	0x8
+
+/*
  * lockflags that control the locking behavior of various functions.
  */
 #define	UVM_LK_ENTER	0x00000001	/* map locked on entry */
@@ -464,9 +479,16 @@ void			uao_detach_locked __P((struct uvm_object *));
 void			uao_reference __P((struct uvm_object *));
 void			uao_reference_locked __P((struct uvm_object *));
 
+/* uvm_bio.c */
+void			ubc_init __P((void));
+void *			ubc_alloc __P((struct uvm_object *, voff_t, vsize_t *,
+				       int));
+void			ubc_release __P((void *, vsize_t));
+void			ubc_flush __P((struct uvm_object *, voff_t, voff_t));
+
 /* uvm_fault.c */
-int			uvm_fault __P((vm_map_t, vaddr_t, 
-				vm_fault_t, vm_prot_t));
+int			uvm_fault __P((vm_map_t, vaddr_t, vm_fault_t,
+				       vm_prot_t));
 				/* handle a page fault */
 
 /* uvm_glue.c */
@@ -593,10 +615,11 @@ int			uvm_deallocate __P((vm_map_t, vaddr_t, vsize_t));
 /* uvm_vnode.c */
 void			uvm_vnp_setsize __P((struct vnode *, voff_t));
 void			uvm_vnp_sync __P((struct mount *));
-void 			uvm_vnp_terminate __P((struct vnode *));
-				/* terminate a uvm/uvn object */
-boolean_t		uvm_vnp_uncache __P((struct vnode *));
 struct uvm_object	*uvn_attach __P((void *, vm_prot_t));
+void			uvn_findpages __P((struct uvm_object *, voff_t,
+					   int *, struct vm_page **, int));
+void			uvm_vnp_zerorange __P((struct vnode *, off_t, size_t));
+void			uvm_vnp_asyncget __P((struct vnode *, off_t, size_t));
 
 /* kern_malloc.c */
 void			kmeminit_nkmempages __P((void));
diff --git a/sys/uvm/uvm_fault.c b/sys/uvm/uvm_fault.c
index 662e2509321..0e4103fe49b 100644
--- a/sys/uvm/uvm_fault.c
+++ b/sys/uvm/uvm_fault.c
@@ -1,4 +1,4 @@
-/*	$OpenBSD: uvm_fault.c,v 1.24 2001/11/12 01:26:09 art Exp $	*/
+/*	$OpenBSD: uvm_fault.c,v 1.25 2001/11/27 05:27:12 art Exp $	*/
 /*	$NetBSD: uvm_fault.c,v 1.56 2001/02/18 21:19:08 chs Exp $	*/
 
 /*
@@ -204,11 +204,7 @@ uvmfault_anonflush(anons, n)
 		if (pg && (pg->flags & PG_BUSY) == 0 && pg->loan_count == 0) {
 			uvm_lock_pageq();
 			if (pg->wire_count == 0) {
-#ifdef UBC
 				pmap_clear_reference(pg);
-#else
-				pmap_page_protect(pg, VM_PROT_NONE);
-#endif
 				uvm_pagedeactivate(pg);
 			}
 			uvm_unlock_pageq();
diff --git a/sys/uvm/uvm_map.h b/sys/uvm/uvm_map.h
index bbc2afb9f19..2c95aff1607 100644
--- a/sys/uvm/uvm_map.h
+++ b/sys/uvm/uvm_map.h
@@ -1,4 +1,4 @@
-/*	$OpenBSD: uvm_map.h,v 1.15 2001/11/12 01:26:09 art Exp $	*/
+/*	$OpenBSD: uvm_map.h,v 1.16 2001/11/27 05:27:12 art Exp $	*/
 /*	$NetBSD: uvm_map.h,v 1.24 2001/02/18 21:19:08 chs Exp $	*/
 
 /* 
@@ -427,7 +427,7 @@ vm_map_lock(map)
 	simple_lock(&map->flags_lock);
 	while (map->flags & VM_MAP_BUSY) {
 		map->flags |= VM_MAP_WANTLOCK;
-		ltsleep(&map->flags, PVM, (char *)vmmapbsy, 0, &map->flags_lock);
+		ltsleep(&map->flags, PVM, vmmapbsy, 0, &map->flags_lock);
 	}
 
 	error = lockmgr(&map->lock, LK_EXCLUSIVE|LK_SLEEPFAIL|LK_INTERLOCK,
diff --git a/sys/uvm/uvm_mmap.c b/sys/uvm/uvm_mmap.c
index 6bd7260b6a0..3c4c4bdf961 100644
--- a/sys/uvm/uvm_mmap.c
+++ b/sys/uvm/uvm_mmap.c
@@ -1,4 +1,4 @@
-/*	$OpenBSD: uvm_mmap.c,v 1.27 2001/11/12 01:26:09 art Exp $	*/
+/*	$OpenBSD: uvm_mmap.c,v 1.28 2001/11/27 05:27:12 art Exp $	*/
 /*	$NetBSD: uvm_mmap.c,v 1.49 2001/02/18 21:19:08 chs Exp $	*/
 
 /*
@@ -1126,40 +1126,8 @@ uvm_mmap(map, addr, size, prot, maxprot, flags, handle, foff, locklimit)
 			uobj = uvn_attach((void *) vp, (flags & MAP_SHARED) ?
 			   maxprot : (maxprot & ~VM_PROT_WRITE));
 
-#ifndef UBC
-			/*
-			 * XXXCDC: hack from old code
-			 * don't allow vnodes which have been mapped
-			 * shared-writeable to persist [forces them to be
-			 * flushed out when last reference goes].
-			 * XXXCDC: interesting side effect: avoids a bug.
-			 * note that in WRITE [ufs_readwrite.c] that we
-			 * allocate buffer, uncache, and then do the write.
-			 * the problem with this is that if the uncache causes
-			 * VM data to be flushed to the same area of the file
-			 * we are writing to... in that case we've got the
-			 * buffer locked and our process goes to sleep forever.
-			 *
-			 * XXXCDC: checking maxprot protects us from the
-			 * "persistbug" program but this is not a long term
-			 * solution.
-			 * 
-			 * XXXCDC: we don't bother calling uncache with the vp
-			 * VOP_LOCKed since we know that we are already
-			 * holding a valid reference to the uvn (from the
-			 * uvn_attach above), and thus it is impossible for
-			 * the uncache to kill the uvn and trigger I/O.
-			 */
-			if (flags & MAP_SHARED) {
-				if ((prot & VM_PROT_WRITE) ||
-				    (maxprot & VM_PROT_WRITE)) {
-					uvm_vnp_uncache(vp);
-				}
-			}
-#else
 			/* XXX for now, attach doesn't gain a ref */
 			VREF(vp);
-#endif
 		} else {
 			uobj = udv_attach((void *) &vp->v_rdev,
 			    (flags & MAP_SHARED) ? maxprot :
diff --git a/sys/uvm/uvm_page.c b/sys/uvm/uvm_page.c
index 4ea890c8c3b..f7ebbd77f80 100644
--- a/sys/uvm/uvm_page.c
+++ b/sys/uvm/uvm_page.c
@@ -1,4 +1,4 @@
-/*	$OpenBSD: uvm_page.c,v 1.31 2001/11/12 01:26:09 art Exp $	*/
+/*	$OpenBSD: uvm_page.c,v 1.32 2001/11/27 05:27:12 art Exp $	*/
 /*	$NetBSD: uvm_page.c,v 1.51 2001/03/09 01:02:12 chs Exp $	*/
 
 /* 
@@ -906,17 +906,11 @@ uvm_pagealloc_strat(obj, off, anon, flags, strat, free_list)
 	 * the pagedaemon.
 	 */
 
-#ifdef UBC
 	if (uvmexp.free + uvmexp.paging < uvmexp.freemin ||
 	    (uvmexp.free + uvmexp.paging < uvmexp.freetarg &&
 	     uvmexp.inactive < uvmexp.inactarg)) {
 		wakeup(&uvm.pagedaemon);
 	}
-#else
-	if (uvmexp.free < uvmexp.freemin || (uvmexp.free < uvmexp.freetarg &&
-	    uvmexp.inactive < uvmexp.inactarg))
-		wakeup(&uvm.pagedaemon);
-#endif
 
 	/*
 	 * fail if any of these conditions is true:
diff --git a/sys/uvm/uvm_page_i.h b/sys/uvm/uvm_page_i.h
index e0547d8414b..3ea680714c6 100644
--- a/sys/uvm/uvm_page_i.h
+++ b/sys/uvm/uvm_page_i.h
@@ -1,4 +1,4 @@
-/*	$OpenBSD: uvm_page_i.h,v 1.10 2001/11/12 01:26:10 art Exp $	*/
+/*	$OpenBSD: uvm_page_i.h,v 1.11 2001/11/27 05:27:12 art Exp $	*/
 /*	$NetBSD: uvm_page_i.h,v 1.16 2001/01/28 23:30:45 thorpej Exp $	*/
 
 /* 
@@ -219,9 +219,6 @@ uvm_pagedeactivate(pg)
 			TAILQ_INSERT_TAIL(&uvm.page_inactive_obj, pg, pageq);
 		pg->pqflags |= PQ_INACTIVE;
 		uvmexp.inactive++;
-#ifndef UBC
-		pmap_clear_reference(pg);
-#endif
 		/*
 		 * update the "clean" bit.  this isn't 100%
 		 * accurate, and doesn't have to be.  we'll
diff --git a/sys/uvm/uvm_pager.c b/sys/uvm/uvm_pager.c
index 69400e5f010..2fded9caf08 100644
--- a/sys/uvm/uvm_pager.c
+++ b/sys/uvm/uvm_pager.c
@@ -1,4 +1,4 @@
-/*	$OpenBSD: uvm_pager.c,v 1.22 2001/11/12 01:26:10 art Exp $	*/
+/*	$OpenBSD: uvm_pager.c,v 1.23 2001/11/27 05:27:12 art Exp $	*/
 /*	$NetBSD: uvm_pager.c,v 1.41 2001/02/18 19:26:50 chs Exp $	*/
 
 /*
@@ -58,17 +58,13 @@ struct pool *uvm_aiobuf_pool;
 
 extern struct uvm_pagerops uvm_deviceops;
 extern struct uvm_pagerops uvm_vnodeops;
-#ifdef UBC
 extern struct uvm_pagerops ubc_pager;
-#endif
 
 struct uvm_pagerops *uvmpagerops[] = {
 	&aobj_pager,
 	&uvm_deviceops,
 	&uvm_vnodeops,
-#ifdef UBC
 	&ubc_pager,
-#endif
 };
 
 /*
@@ -153,7 +149,7 @@ ReStart:
 	kva = 0;			/* let system choose VA */
 
 	if (uvm_map(pager_map, &kva, size, NULL, 
-	      UVM_UNKNOWN_OFFSET, 0, UVM_FLAG_NOMERGE) != KERN_SUCCESS) {
+	    UVM_UNKNOWN_OFFSET, 0, UVM_FLAG_NOMERGE) != KERN_SUCCESS) {
 		if (curproc == uvm.pagedaemon_proc) {
 			simple_lock(&pager_map_wanted_lock);
 			if (emerginuse) {
@@ -733,7 +729,6 @@ uvm_pager_dropcluster(uobj, pg, ppsp, npages, flags)
 	}
 }
 
-#ifdef UBC
 /*
  * interrupt-context iodone handler for nested i/o bufs.
  *
@@ -757,7 +752,6 @@ uvm_aio_biodone1(bp)
 		biodone(mbp);
 	}
 }
-#endif
 
 /*
  * interrupt-context iodone handler for single-buf i/os
@@ -798,12 +792,10 @@ uvm_aio_aiodone(bp)
 
 	error = (bp->b_flags & B_ERROR) ? (bp->b_error ? bp->b_error : EIO) : 0;
 	write = (bp->b_flags & B_READ) == 0;
-#ifdef UBC
 	/* XXXUBC B_NOCACHE is for swap pager, should be done differently */
 	if (write && !(bp->b_flags & B_NOCACHE) && bioops.io_pageiodone) {
 		(*bioops.io_pageiodone)(bp);
 	}
-#endif
 
 	uobj = NULL;
 	for (i = 0; i < npages; i++) {
diff --git a/sys/uvm/uvm_param.h b/sys/uvm/uvm_param.h
index d7cdccc28a4..78b3f1bc5ba 100644
--- a/sys/uvm/uvm_param.h
+++ b/sys/uvm/uvm_param.h
@@ -1,4 +1,4 @@
-/*	$OpenBSD: uvm_param.h,v 1.2 2001/11/12 01:26:10 art Exp $	*/
+/*	$OpenBSD: uvm_param.h,v 1.3 2001/11/27 05:27:12 art Exp $	*/
 /*	$NetBSD: uvm_param.h,v 1.5 2001/03/09 01:02:12 chs Exp $	*/
 
 /* 
@@ -114,7 +114,7 @@ typedef int	boolean_t;
 #define	VM_ANONMIN	7
 #define	VM_VTEXTMIN	8
 #define	VM_VNODEMIN	9
-#define	VM_MAXID	9		/* number of valid vm ids */
+#define	VM_MAXID	10		/* number of valid vm ids */
 
 #define	CTL_VM_NAMES { \
 	{ 0, 0 }, \
@@ -166,10 +166,8 @@ struct _ps_strings {
 #define	trunc_page(x)	((x) & ~PAGE_MASK)
 
 extern psize_t		mem_size;	/* size of physical memory (bytes) */
-#ifdef UBC
 extern int		ubc_nwins;	/* number of UBC mapping windows */
 extern int		ubc_winsize;	/* size of a UBC mapping window */
-#endif
 
 #else
 /* out-of-kernel versions of round_page and trunc_page */
diff --git a/sys/uvm/uvm_swap.c b/sys/uvm/uvm_swap.c
index 4697d8a23f6..c4298200688 100644
--- a/sys/uvm/uvm_swap.c
+++ b/sys/uvm/uvm_swap.c
@@ -1,4 +1,4 @@
-/*	$OpenBSD: uvm_swap.c,v 1.41 2001/11/15 23:15:15 art Exp $	*/
+/*	$OpenBSD: uvm_swap.c,v 1.42 2001/11/27 05:27:12 art Exp $	*/
 /*	$NetBSD: uvm_swap.c,v 1.46 2001/02/18 21:19:08 chs Exp $	*/
 
 /*
@@ -1393,32 +1393,6 @@ sw_reg_strategy(sdp, bp, bn)
 		nbp->vb_buf.b_vnbufs.le_next = NOLIST;
 		LIST_INIT(&nbp->vb_buf.b_dep);
 
-		/* 
-		 * set b_dirtyoff/end and b_validoff/end.   this is
-		 * required by the NFS client code (otherwise it will
-		 * just discard our I/O request).
-		 */
-		if (bp->b_dirtyend == 0) {
-			nbp->vb_buf.b_dirtyoff = 0;
-			nbp->vb_buf.b_dirtyend = sz;
-		} else {
-			nbp->vb_buf.b_dirtyoff =
-			    max(0, bp->b_dirtyoff - (bp->b_bcount-resid));
-			nbp->vb_buf.b_dirtyend =
-			    min(sz,
-				max(0, bp->b_dirtyend - (bp->b_bcount-resid)));
-		}
-		if (bp->b_validend == 0) {
-			nbp->vb_buf.b_validoff = 0;
-			nbp->vb_buf.b_validend = sz;
-		} else {
-			nbp->vb_buf.b_validoff =
-			    max(0, bp->b_validoff - (bp->b_bcount-resid));
-			nbp->vb_buf.b_validend =
-			    min(sz,
-				max(0, bp->b_validend - (bp->b_bcount-resid)));
-		}
-
 		nbp->vb_xfer = vnx;	/* patch it back in to vnx */
 
 		/*
@@ -1990,8 +1964,6 @@ uvm_swap_io(pps, startslot, npages, flags)
 	 * and we bump v_numoutput (counter of number of active outputs).
 	 */
 	if (write) {
-		bp->b_dirtyoff = 0;
-		bp->b_dirtyend = npages << PAGE_SHIFT;
 #ifdef UVM_SWAP_ENCRYPT
 		/* mark the pages in the drum for decryption */
 		if (swap_encrypt_initalized)
diff --git a/sys/uvm/uvm_vnode.c b/sys/uvm/uvm_vnode.c
index e921e4fb846..667cbc5b458 100644
--- a/sys/uvm/uvm_vnode.c
+++ b/sys/uvm/uvm_vnode.c
@@ -1,5 +1,5 @@
-/*	$OpenBSD: uvm_vnode.c,v 1.24 2001/11/10 18:42:32 art Exp $	*/
-/*	$NetBSD: uvm_vnode.c,v 1.36 2000/11/24 20:34:01 chs Exp $	*/
+/*	$OpenBSD: uvm_vnode.c,v 1.25 2001/11/27 05:27:12 art Exp $	*/
+/*	$NetBSD: uvm_vnode.c,v 1.47 2001/03/09 01:02:13 chs Exp $	*/
 
 /*
  * Copyright (c) 1997 Charles D. Cranor and Washington University.
@@ -52,6 +52,7 @@
 
 #include <sys/param.h>
 #include <sys/systm.h>
+#include <sys/kernel.h>
 #include <sys/proc.h>
 #include <sys/malloc.h>
 #include <sys/vnode.h>
@@ -59,6 +60,8 @@
 #include <sys/ioctl.h>
 #include <sys/fcntl.h>
 #include <sys/conf.h>
+#include <sys/pool.h>
+#include <sys/mount.h>
 
 #include <miscfs/specfs/specdev.h>
 
@@ -66,55 +69,38 @@
 #include <uvm/uvm_vnode.h>
 
 /*
- * private global data structure
- *
- * we keep a list of writeable active vnode-backed VM objects for sync op.
- * we keep a simpleq of vnodes that are currently being sync'd.
- */
-
-LIST_HEAD(uvn_list_struct, uvm_vnode);
-static struct uvn_list_struct uvn_wlist;	/* writeable uvns */
-static simple_lock_data_t uvn_wl_lock;		/* locks uvn_wlist */
-
-SIMPLEQ_HEAD(uvn_sq_struct, uvm_vnode);
-static struct uvn_sq_struct uvn_sync_q;		/* sync'ing uvns */
-lock_data_t uvn_sync_lock;			/* locks sync operation */
-
-/*
  * functions
  */
 
-static void		   uvn_cluster __P((struct uvm_object *, voff_t,
-					   voff_t *, voff_t *));
-static void                uvn_detach __P((struct uvm_object *));
-static boolean_t           uvn_flush __P((struct uvm_object *, voff_t, 
-					 voff_t, int));
-static int                 uvn_get __P((struct uvm_object *, voff_t,
-					vm_page_t *, int *, int, 
-					vm_prot_t, int, int));
-static void		   uvn_init __P((void));
-static int		   uvn_io __P((struct uvm_vnode *, vm_page_t *,
-				      int, int, int));
-static int		   uvn_put __P((struct uvm_object *, vm_page_t *,
-					int, boolean_t));
-static void                uvn_reference __P((struct uvm_object *));
-static boolean_t	   uvn_releasepg __P((struct vm_page *, 
-					      struct vm_page **));
+static void		uvn_cluster __P((struct uvm_object *, voff_t, voff_t *,
+					 voff_t *));
+static void		uvn_detach __P((struct uvm_object *));
+static int		uvn_findpage __P((struct uvm_object *, voff_t,
+					  struct vm_page **, int));
+boolean_t		uvn_flush __P((struct uvm_object *, voff_t, voff_t,
+				       int));
+static int		uvn_get __P((struct uvm_object *, voff_t, vm_page_t *,
+				     int *, int, vm_prot_t, int, int));
+static int		uvn_put __P((struct uvm_object *, vm_page_t *, int,
+				     boolean_t));
+static void		uvn_reference __P((struct uvm_object *));
+static boolean_t	uvn_releasepg __P((struct vm_page *,
+					   struct vm_page **));
 
 /*
  * master pager structure
  */
 
 struct uvm_pagerops uvm_vnodeops = {
-	uvn_init,
+	NULL,
 	uvn_reference,
 	uvn_detach,
-	NULL,			/* no specialized fault routine required */
+	NULL,
 	uvn_flush,
 	uvn_get,
 	uvn_put,
 	uvn_cluster,
-	uvm_mk_pcluster, /* use generic version of this: see uvm_pager.c */
+	uvm_mk_pcluster,
 	uvn_releasepg,
 };
 
@@ -123,22 +109,6 @@ struct uvm_pagerops uvm_vnodeops = {
  */
 
 /*
- * uvn_init
- *
- * init pager private data structures.
- */
-
-static void
-uvn_init()
-{
-
-	LIST_INIT(&uvn_wlist);
-	simple_lock_init(&uvn_wl_lock);
-	/* note: uvn_sync_q init'd in uvm_vnp_sync() */
-	lockinit(&uvn_sync_lock, PVM, "uvnsync", 0, 0);
-}
-
-/*
  * uvn_attach
  *
  * attach a vnode structure to a VM object.  if the vnode is already
@@ -161,23 +131,20 @@ uvn_attach(arg, accessprot)
 	struct vnode *vp = arg;
 	struct uvm_vnode *uvn = &vp->v_uvm;
 	struct vattr vattr;
-	int oldflags, result;
+	int result;
 	struct partinfo pi;
-	u_quad_t used_vnode_size;
+	voff_t used_vnode_size;
 	UVMHIST_FUNC("uvn_attach"); UVMHIST_CALLED(maphist);
 
 	UVMHIST_LOG(maphist, "(vn=0x%x)", arg,0,0,0);
-
-	used_vnode_size = (u_quad_t)0;	/* XXX gcc -Wuninitialized */
+	used_vnode_size = (voff_t)0;
 
 	/*
 	 * first get a lock on the uvn.
 	 */
 	simple_lock(&uvn->u_obj.vmobjlock);
-	while (uvn->u_flags & UVM_VNODE_BLOCKED) {
-		printf("uvn_attach: blocked at 0x%p flags 0x%x\n",
-		    uvn, uvn->u_flags);
-		uvn->u_flags |= UVM_VNODE_WANTED;
+	while (uvn->u_flags & VXLOCK) {
+		uvn->u_flags |= VXWANT;
 		UVMHIST_LOG(maphist, "  SLEEPING on blocked vn",0,0,0,0);
 		UVM_UNLOCK_AND_WAIT(uvn, &uvn->u_obj.vmobjlock, FALSE,
 		    "uvn_attach", 0);
@@ -189,56 +156,26 @@ uvn_attach(arg, accessprot)
 	 * if we're mapping a BLK device, make sure it is a disk.
 	 */
 	if (vp->v_type == VBLK && bdevsw[major(vp->v_rdev)].d_type != D_DISK) {
-		simple_unlock(&uvn->u_obj.vmobjlock); /* drop lock */
+		simple_unlock(&uvn->u_obj.vmobjlock);
 		UVMHIST_LOG(maphist,"<- done (VBLK not D_DISK!)", 0,0,0,0);
 		return(NULL);
 	}
 
-	/*
-	 * now we have lock and uvn must not be in a blocked state.
-	 * first check to see if it is already active, in which case
-	 * we can bump the reference count, check to see if we need to
-	 * add it to the writeable list, and then return.
-	 */
-	if (uvn->u_flags & UVM_VNODE_VALID) {	/* already active? */
-
-		/* regain VREF if we were persisting */
-		if (uvn->u_obj.uo_refs == 0) {
-			VREF(vp);
-			UVMHIST_LOG(maphist," VREF (reclaim persisting vnode)",
-			    0,0,0,0);
-		}
-		uvn->u_obj.uo_refs++;		/* bump uvn ref! */
-
-		/* check for new writeable uvn */
-		if ((accessprot & VM_PROT_WRITE) != 0 && 
-		    (uvn->u_flags & UVM_VNODE_WRITEABLE) == 0) {
-			simple_lock(&uvn_wl_lock);
-			LIST_INSERT_HEAD(&uvn_wlist, uvn, u_wlist);
-			simple_unlock(&uvn_wl_lock);
-			/* we are now on wlist! */
-			uvn->u_flags |= UVM_VNODE_WRITEABLE;
-		}
-
-		/* unlock and return */
-		simple_unlock(&uvn->u_obj.vmobjlock);
-		UVMHIST_LOG(maphist,"<- done, refcnt=%d", uvn->u_obj.uo_refs,
-		    0, 0, 0);
-		return (&uvn->u_obj);
-	} 
+#ifdef DIAGNOSTIC
+	if (vp->v_type != VREG) {
+		panic("uvn_attach: vp %p not VREG", vp);
+	}
+#endif
 
 	/*
-	 * need to call VOP_GETATTR() to get the attributes, but that could
-	 * block (due to I/O), so we want to unlock the object before calling.
-	 * however, we want to keep anyone else from playing with the object
-	 * while it is unlocked.   to do this we set UVM_VNODE_ALOCK which
-	 * prevents anyone from attaching to the vnode until we are done with
-	 * it.
+	 * set up our idea of the size
+	 * if this hasn't been done already.
 	 */
-	uvn->u_flags = UVM_VNODE_ALOCK;
+	if (uvn->u_size == VSIZENOTSET) {
+
+	uvn->u_flags |= VXLOCK;
 	simple_unlock(&uvn->u_obj.vmobjlock); /* drop lock in case we sleep */
 		/* XXX: curproc? */
-
 	if (vp->v_type == VBLK) {
 		/*
 		 * We could implement this as a specfs getattr call, but:
@@ -252,8 +189,8 @@ uvn_attach(arg, accessprot)
 		    DIOCGPART, (caddr_t)&pi, FREAD, curproc);
 		if (result == 0) {
 			/* XXX should remember blocksize */
-			used_vnode_size = (u_quad_t)pi.disklab->d_secsize *
-			    (u_quad_t)pi.part->p_size;
+			used_vnode_size = (voff_t)pi.disklab->d_secsize *
+			    (voff_t)pi.part->p_size;
 		}
 	} else {
 		result = VOP_GETATTR(vp, &vattr, curproc->p_ucred, curproc);
@@ -262,58 +199,26 @@ uvn_attach(arg, accessprot)
 	}
 
 	/* relock object */
-	simple_lock(&uvn->u_obj.vmobjlock); 
+	simple_lock(&uvn->u_obj.vmobjlock);
+
+	if (uvn->u_flags & VXWANT)
+		wakeup(uvn);
+	uvn->u_flags &= ~(VXLOCK|VXWANT);
 
 	if (result != 0) {
-		if (uvn->u_flags & UVM_VNODE_WANTED)
-			wakeup(uvn);
-		uvn->u_flags = 0;
 		simple_unlock(&uvn->u_obj.vmobjlock); /* drop lock */
 		UVMHIST_LOG(maphist,"<- done (VOP_GETATTR FAILED!)", 0,0,0,0);
 		return(NULL);
 	}
-
-	/*
-	 * make sure that the newsize fits within a vaddr_t
-	 * XXX: need to revise addressing data types
-	 */
-#ifdef DEBUG
-	if (vp->v_type == VBLK)
-		printf("used_vnode_size = %llu\n", (long long)used_vnode_size);
-#endif
-
-	/*
-	 * now set up the uvn.
-	 */
-	uvn->u_obj.pgops = &uvm_vnodeops;
-	TAILQ_INIT(&uvn->u_obj.memq);
-	uvn->u_obj.uo_npages = 0;
-	uvn->u_obj.uo_refs = 1;			/* just us... */
-	oldflags = uvn->u_flags;
-	uvn->u_flags = UVM_VNODE_VALID|UVM_VNODE_CANPERSIST;
-	uvn->u_nio = 0;
 	uvn->u_size = used_vnode_size;
 
-	/* if write access, we need to add it to the wlist */
-	if (accessprot & VM_PROT_WRITE) {
-		simple_lock(&uvn_wl_lock);
-		LIST_INSERT_HEAD(&uvn_wlist, uvn, u_wlist);
-		simple_unlock(&uvn_wl_lock);
-		uvn->u_flags |= UVM_VNODE_WRITEABLE;	/* we are on wlist! */
 	}
 
-	/*
-	 * add a reference to the vnode.   this reference will stay as long
-	 * as there is a valid mapping of the vnode.   dropped when the
-	 * reference count goes to zero [and we either free or persist].
-	 */
-	VREF(vp);
+	/* unlock and return */
 	simple_unlock(&uvn->u_obj.vmobjlock);
-	if (oldflags & UVM_VNODE_WANTED)
-		wakeup(uvn);
-
-	UVMHIST_LOG(maphist,"<- done/VREF, ret 0x%x", &uvn->u_obj,0,0,0);
-	return(&uvn->u_obj);
+	UVMHIST_LOG(maphist,"<- done, refcnt=%d", uvn->u_obj.uo_refs,
+	    0, 0, 0);
+	return (&uvn->u_obj);
 }
 
 
@@ -333,23 +238,7 @@ static void
 uvn_reference(uobj)
 	struct uvm_object *uobj;
 {
-#ifdef DEBUG
-	struct uvm_vnode *uvn = (struct uvm_vnode *) uobj;
-#endif
-	UVMHIST_FUNC("uvn_reference"); UVMHIST_CALLED(maphist);
-
-	simple_lock(&uobj->vmobjlock);
-#ifdef DEBUG
-	if ((uvn->u_flags & UVM_VNODE_VALID) == 0) {
-		printf("uvn_reference: ref=%d, flags=0x%x\n", uvn->u_flags,
-		    uobj->uo_refs);
-		panic("uvn_reference: invalid state");
-	}
-#endif
-	uobj->uo_refs++;
-	UVMHIST_LOG(maphist, "<- done (uobj=0x%x, ref = %d)", 
-	uobj, uobj->uo_refs,0,0);
-	simple_unlock(&uobj->vmobjlock);
+	VREF((struct vnode *)uobj);
 }
 
 /*
@@ -365,291 +254,7 @@ static void
 uvn_detach(uobj)
 	struct uvm_object *uobj;
 {
-	struct uvm_vnode *uvn;
-	struct vnode *vp;
-	int oldflags;
-	UVMHIST_FUNC("uvn_detach"); UVMHIST_CALLED(maphist);
-
-	simple_lock(&uobj->vmobjlock);
-
-	UVMHIST_LOG(maphist,"  (uobj=0x%x)  ref=%d", uobj,uobj->uo_refs,0,0);
-	uobj->uo_refs--;			/* drop ref! */
-	if (uobj->uo_refs) {			/* still more refs */
-		simple_unlock(&uobj->vmobjlock);
-		UVMHIST_LOG(maphist, "<- done (rc>0)", 0,0,0,0);
-		return;
-	}
-
-	/*
-	 * get other pointers ...
-	 */
-
-	uvn = (struct uvm_vnode *) uobj;
-	vp = (struct vnode *) uobj;
-
-	/*
-	 * clear VTEXT flag now that there are no mappings left (VTEXT is used
-	 * to keep an active text file from being overwritten).
-	 */
-	vp->v_flag &= ~VTEXT;
-
-	/*
-	 * we just dropped the last reference to the uvn.   see if we can
-	 * let it "stick around".
-	 */
-
-	if (uvn->u_flags & UVM_VNODE_CANPERSIST) {
-		/* won't block */
-		uvn_flush(uobj, 0, 0, PGO_DEACTIVATE|PGO_ALLPAGES);
-		simple_unlock(&uobj->vmobjlock);
-		vrele(vp);			/* drop vnode reference */
-		UVMHIST_LOG(maphist,"<- done/vrele!  (persist)", 0,0,0,0);
-		return;
-	}
-
-	/*
-	 * its a goner!
-	 */
-
-	UVMHIST_LOG(maphist,"  its a goner (flushing)!", 0,0,0,0);
-
-	uvn->u_flags |= UVM_VNODE_DYING;
-
-	/*
-	 * even though we may unlock in flush, no one can gain a reference
-	 * to us until we clear the "dying" flag [because it blocks
-	 * attaches].  we will not do that until after we've disposed of all
-	 * the pages with uvn_flush().  note that before the flush the only
-	 * pages that could be marked PG_BUSY are ones that are in async
-	 * pageout by the daemon.  (there can't be any pending "get"'s
-	 * because there are no references to the object).
-	 */
-
-	(void) uvn_flush(uobj, 0, 0, PGO_CLEANIT|PGO_FREE|PGO_ALLPAGES);
-
-	UVMHIST_LOG(maphist,"  its a goner (done flush)!", 0,0,0,0);
-
-	/*
-	 * given the structure of this pager, the above flush request will
-	 * create the following state: all the pages that were in the object
-	 * have either been free'd or they are marked PG_BUSY|PG_RELEASED.
-	 * the PG_BUSY bit was set either by us or the daemon for async I/O.
-	 * in either case, if we have pages left we can't kill the object
-	 * yet because i/o is pending.  in this case we set the "relkill"
-	 * flag which will cause pgo_releasepg to kill the object once all
-	 * the I/O's are done [pgo_releasepg will be called from the aiodone
-	 * routine or from the page daemon].
-	 */
-
-	if (uobj->uo_npages) {		/* I/O pending.  iodone will free */
-#ifdef DEBUG
-		/* 
-		 * XXXCDC: very unlikely to happen until we have async i/o
-		 * so print a little info message in case it does.
-		 */
-		printf("uvn_detach: vn %p has pages left after flush - "
-		    "relkill mode\n", uobj);
-#endif
-		uvn->u_flags |= UVM_VNODE_RELKILL;
-		simple_unlock(&uobj->vmobjlock);
-		UVMHIST_LOG(maphist,"<- done! (releasepg will kill obj)", 0, 0,
-		    0, 0);
-		return;
-	}
-
-	/*
-	 * kill object now.   note that we can't be on the sync q because
-	 * all references are gone.
-	 */
-	if (uvn->u_flags & UVM_VNODE_WRITEABLE) {
-		simple_lock(&uvn_wl_lock);		/* protect uvn_wlist */
-		LIST_REMOVE(uvn, u_wlist);
-		simple_unlock(&uvn_wl_lock);
-	}
-#ifdef DIAGNOSTIC
-	if (uobj->memq.tqh_first != NULL)
-		panic("uvn_deref: vnode VM object still has pages afer "
-		    "syncio/free flush");
-#endif
-	oldflags = uvn->u_flags;
-	uvn->u_flags = 0;
-	simple_unlock(&uobj->vmobjlock);
-	
-	/* wake up any sleepers */
-	if (oldflags & UVM_VNODE_WANTED)
-		wakeup(uvn);
-
-	/*
-	 * drop our reference to the vnode.
-	 */
-	vrele(vp);
-	UVMHIST_LOG(maphist,"<- done (vrele) final", 0,0,0,0);
-
-	return;
-}
-
-/*
- * uvm_vnp_terminate: external hook to clear out a vnode's VM
- *
- * called in two cases:
- *  [1] when a persisting vnode vm object (i.e. one with a zero reference
- *      count) needs to be freed so that a vnode can be reused.  this
- *      happens under "getnewvnode" in vfs_subr.c.   if the vnode from
- *      the free list is still attached (i.e. not VBAD) then vgone is
- *	called.   as part of the vgone trace this should get called to
- *	free the vm object.   this is the common case.
- *  [2] when a filesystem is being unmounted by force (MNT_FORCE, 
- *	"umount -f") the vgone() function is called on active vnodes
- *	on the mounted file systems to kill their data (the vnodes become
- *	"dead" ones [see src/sys/miscfs/deadfs/...]).  that results in a
- *	call here (even if the uvn is still in use -- i.e. has a non-zero
- *	reference count).  this case happens at "umount -f" and during a
- *	"reboot/halt" operation.
- *
- * => the caller must XLOCK and VOP_LOCK the vnode before calling us
- *	[protects us from getting a vnode that is already in the DYING
- *	 state...]
- * => unlike uvn_detach, this function must not return until all the
- *	uvn's pages are disposed of.
- * => in case [2] the uvn is still alive after this call, but all I/O
- *	ops will fail (due to the backing vnode now being "dead").  this
- *	will prob. kill any process using the uvn due to pgo_get failing.
- */
-
-void
-uvm_vnp_terminate(vp)
-	struct vnode *vp;
-{
-	struct uvm_vnode *uvn = &vp->v_uvm;
-	int oldflags;
-	UVMHIST_FUNC("uvm_vnp_terminate"); UVMHIST_CALLED(maphist);
-
-	/*
-	 * lock object and check if it is valid
-	 */
-	simple_lock(&uvn->u_obj.vmobjlock);
-	UVMHIST_LOG(maphist, "  vp=0x%x, ref=%d, flag=0x%x", vp,
-	    uvn->u_obj.uo_refs, uvn->u_flags, 0);
-	if ((uvn->u_flags & UVM_VNODE_VALID) == 0) {
-		simple_unlock(&uvn->u_obj.vmobjlock);
-		UVMHIST_LOG(maphist, "<- done (not active)", 0, 0, 0, 0);
-		return;
-	}
-
-	/*
-	 * must be a valid uvn that is not already dying (because XLOCK
-	 * protects us from that).   the uvn can't in the ALOCK state
-	 * because it is valid, and uvn's that are in the ALOCK state haven't
-	 * been marked valid yet.
-	 */
-
-#ifdef DEBUG
-	/*
-	 * debug check: are we yanking the vnode out from under our uvn?
-	 */
-	if (uvn->u_obj.uo_refs) {
-		printf("uvm_vnp_terminate(%p): terminating active vnode "
-		    "(refs=%d)\n", uvn, uvn->u_obj.uo_refs);
-	} 
-#endif
-	
-	/*
-	 * it is possible that the uvn was detached and is in the relkill
-	 * state [i.e. waiting for async i/o to finish so that releasepg can
-	 * kill object].  we take over the vnode now and cancel the relkill.
-	 * we want to know when the i/o is done so we can recycle right
-	 * away.   note that a uvn can only be in the RELKILL state if it
-	 * has a zero reference count.
-	 */
-	
-	if (uvn->u_flags & UVM_VNODE_RELKILL)
-		uvn->u_flags &= ~UVM_VNODE_RELKILL;	/* cancel RELKILL */
-
-	/*
-	 * block the uvn by setting the dying flag, and then flush the
-	 * pages.  (note that flush may unlock object while doing I/O, but
-	 * it will re-lock it before it returns control here).
-	 *
-	 * also, note that we tell I/O that we are already VOP_LOCK'd so
-	 * that uvn_io doesn't attempt to VOP_LOCK again.
-	 *
-	 * XXXCDC: setting VNISLOCKED on an active uvn which is being terminated
-	 *	due to a forceful unmount might not be a good idea.  maybe we
-	 *	need a way to pass in this info to uvn_flush through a
-	 *	pager-defined PGO_ constant [currently there are none].
-	 */
-	uvn->u_flags |= UVM_VNODE_DYING|UVM_VNODE_VNISLOCKED;
-
-	(void) uvn_flush(&uvn->u_obj, 0, 0, PGO_CLEANIT|PGO_FREE|PGO_ALLPAGES);
-
-	/*
-	 * as we just did a flush we expect all the pages to be gone or in 
-	 * the process of going.  sleep to wait for the rest to go [via iosync].
-	 */
-
-	while (uvn->u_obj.uo_npages) {
-#ifdef DEBUG
-		struct vm_page *pp;
-		for (pp = uvn->u_obj.memq.tqh_first ; pp != NULL ; 
-		     pp = pp->listq.tqe_next) {
-			if ((pp->flags & PG_BUSY) == 0)
-				panic("uvm_vnp_terminate: detected unbusy pg");
-		}
-		if (uvn->u_nio == 0)
-			panic("uvm_vnp_terminate: no I/O to wait for?");
-		printf("uvm_vnp_terminate: waiting for I/O to fin.\n");
-		/* 
-		 * XXXCDC: this is unlikely to happen without async i/o so we 
-		 * put a printf in just to keep an eye on it.
-		 */
-#endif
-		uvn->u_flags |= UVM_VNODE_IOSYNC;
-		UVM_UNLOCK_AND_WAIT(&uvn->u_nio, &uvn->u_obj.vmobjlock, FALSE, 
-		    "uvn_term",0);
-		simple_lock(&uvn->u_obj.vmobjlock);
-	}
-
-	/*
-	 * done.   now we free the uvn if its reference count is zero
-	 * (true if we are zapping a persisting uvn).   however, if we are
-	 * terminating a uvn with active mappings we let it live ... future
-	 * calls down to the vnode layer will fail.
-	 */
-
-	oldflags = uvn->u_flags;
-	if (uvn->u_obj.uo_refs) {
-
-		/*
-		 * uvn must live on it is dead-vnode state until all references 
-		 * are gone.   restore flags.    clear CANPERSIST state.
-		 */
-
-		uvn->u_flags &= ~(UVM_VNODE_DYING|UVM_VNODE_VNISLOCKED|
-		      UVM_VNODE_WANTED|UVM_VNODE_CANPERSIST);
-	
-	} else {
-
-		/*
-		 * free the uvn now.   note that the VREF reference is already
-		 * gone [it is dropped when we enter the persist state].
-		 */
-		if (uvn->u_flags & UVM_VNODE_IOSYNCWANTED)
-			panic("uvm_vnp_terminate: io sync wanted bit set");
-
-		if (uvn->u_flags & UVM_VNODE_WRITEABLE) {
-			simple_lock(&uvn_wl_lock);
-			LIST_REMOVE(uvn, u_wlist);
-			simple_unlock(&uvn_wl_lock);
-		}
-		uvn->u_flags = 0;	/* uvn is history, clear all bits */
-	}
-
-	if (oldflags & UVM_VNODE_WANTED)
-		wakeup(uvn);		/* object lock still held */
-
-	simple_unlock(&uvn->u_obj.vmobjlock);
-	UVMHIST_LOG(maphist, "<- done", 0, 0, 0, 0);
-
+	vrele((struct vnode *)uobj);
 }
 
 /*
@@ -662,7 +267,7 @@ uvm_vnp_terminate(vp)
  * => returns TRUE if page's object is still alive, FALSE if we
  *	killed the page's object.    if we return TRUE, then we
  *	return with the object locked.
- * => if (nextpgp != NULL) => we return pageq.tqe_next here, and return
+ * => if (nextpgp != NULL) => we return the next page on the queue, and return
  *				with the page queues locked [for pagedaemon]
  * => if (nextpgp == NULL) => we return with page queues unlocked [normal case]
  * => we kill the uvn if it is not referenced and we are suppose to
@@ -674,11 +279,7 @@ uvn_releasepg(pg, nextpgp)
 	struct vm_page *pg;
 	struct vm_page **nextpgp;	/* OUT */
 {
-	struct uvm_vnode *uvn = (struct uvm_vnode *) pg->uobject;
-#ifdef DIAGNOSTIC
-	if ((pg->flags & PG_RELEASED) == 0)
-		panic("uvn_releasepg: page not released!");
-#endif
+	KASSERT(pg->flags & PG_RELEASED);
 	
 	/*
 	 * dispose of the page [caller handles PG_WANTED]
@@ -686,64 +287,25 @@ uvn_releasepg(pg, nextpgp)
 	pmap_page_protect(pg, VM_PROT_NONE);
 	uvm_lock_pageq();
 	if (nextpgp)
-		*nextpgp = pg->pageq.tqe_next;	/* next page for daemon */
+		*nextpgp = TAILQ_NEXT(pg, pageq);
 	uvm_pagefree(pg);
 	if (!nextpgp)
 		uvm_unlock_pageq();
 
-	/*
-	 * now see if we need to kill the object
-	 */
-	if (uvn->u_flags & UVM_VNODE_RELKILL) {
-		if (uvn->u_obj.uo_refs)
-			panic("uvn_releasepg: kill flag set on referenced "
-			    "object!");
-		if (uvn->u_obj.uo_npages == 0) {
-			if (uvn->u_flags & UVM_VNODE_WRITEABLE) {
-				simple_lock(&uvn_wl_lock);
-				LIST_REMOVE(uvn, u_wlist);
-				simple_unlock(&uvn_wl_lock);
-			}
-#ifdef DIAGNOSTIC
-			if (uvn->u_obj.memq.tqh_first)
-	panic("uvn_releasepg: pages in object with npages == 0");
-#endif
-			if (uvn->u_flags & UVM_VNODE_WANTED)
-				/* still holding object lock */
-				wakeup(uvn);
-
-			uvn->u_flags = 0;		/* DEAD! */
-			simple_unlock(&uvn->u_obj.vmobjlock);
-			return (FALSE);
-		}
-	}
 	return (TRUE);
 }
 
 /*
- * NOTE: currently we have to use VOP_READ/VOP_WRITE because they go
- * through the buffer cache and allow I/O in any size.  These VOPs use
- * synchronous i/o.  [vs. VOP_STRATEGY which can be async, but doesn't
- * go through the buffer cache or allow I/O sizes larger than a
- * block].  we will eventually want to change this.
- *
  * issues to consider:
- *   uvm provides the uvm_aiodesc structure for async i/o management.
  * there are two tailq's in the uvm. structure... one for pending async
  * i/o and one for "done" async i/o.   to do an async i/o one puts
- * an aiodesc on the "pending" list (protected by splbio()), starts the
+ * a buf on the "pending" list (protected by splbio()), starts the
  * i/o and returns VM_PAGER_PEND.    when the i/o is done, we expect
  * some sort of "i/o done" function to be called (at splbio(), interrupt
- * time).   this function should remove the aiodesc from the pending list
+ * time).   this function should remove the buf from the pending list
  * and place it on the "done" list and wakeup the daemon.   the daemon
  * will run at normal spl() and will remove all items from the "done"
- * list and call the "aiodone" hook for each done request (see uvm_pager.c).
- * [in the old vm code, this was done by calling the "put" routine with
- * null arguments which made the code harder to read and understand because
- * you had one function ("put") doing two things.]  
- *
- * so the current pager needs: 
- *   int uvn_aiodone(struct uvm_aiodesc *)
+ * list and call the iodone hook for each done request (see uvm_pager.c).
  *
  * => return KERN_SUCCESS (aio finished, free it).  otherwise requeue for
  *	later collection.
@@ -764,15 +326,17 @@ uvn_releasepg(pg, nextpgp)
 /*
  * uvn_flush: flush pages out of a uvm object.
  *
+ * => "stop == 0" means flush all pages at or after "start".
  * => object should be locked by caller.   we may _unlock_ the object
- *	if (and only if) we need to clean a page (PGO_CLEANIT).
+ *	if (and only if) we need to clean a page (PGO_CLEANIT), or
+ *	if PGO_SYNCIO is set and there are pages busy.
  *	we return with the object locked.
- * => if PGO_CLEANIT is set, we may block (due to I/O).   thus, a caller
- *	might want to unlock higher level resources (e.g. vm_map)
- *	before calling flush.
- * => if PGO_CLEANIT is not set, then we will neither unlock the object
- *	or block.
- * => if PGO_ALLPAGE is set, then all pages in the object are valid targets
+ * => if PGO_CLEANIT or PGO_SYNCIO is set, we may block (due to I/O).
+ *	thus, a caller might want to unlock higher level resources
+ *	(e.g. vm_map) before calling flush.
+ * => if neither PGO_CLEANIT nor PGO_SYNCIO is set, then we will neither
+ *	unlock the object nor block.
+ * => if PGO_ALLPAGES is set, then all pages in the object are valid targets
  *	for flushing.
  * => NOTE: we rely on the fact that the object's memq is a TAILQ and
  *	that new pages are inserted on the tail end of the list.   thus,
@@ -814,39 +378,62 @@ uvn_releasepg(pg, nextpgp)
 
 #define UVN_HASH_PENALTY 4	/* XXX: a guess */
 
-static boolean_t
+boolean_t
 uvn_flush(uobj, start, stop, flags)
 	struct uvm_object *uobj;
 	voff_t start, stop;
 	int flags;
 {
-	struct uvm_vnode *uvn = (struct uvm_vnode *) uobj;
+	struct uvm_vnode *uvn = (struct uvm_vnode *)uobj;
+	struct vnode *vp = (struct vnode *)uobj;
 	struct vm_page *pp, *ppnext, *ptmp;
-	struct vm_page *pps[MAXBSIZE >> PAGE_SHIFT], **ppsp;
+	struct vm_page *pps[256], **ppsp;
+	int s;
 	int npages, result, lcv;
-	boolean_t retval, need_iosync, by_list, needs_clean, all;
+	boolean_t retval, need_iosync, by_list, needs_clean, all, wasclean;
 	voff_t curoff;
 	u_short pp_version;
 	UVMHIST_FUNC("uvn_flush"); UVMHIST_CALLED(maphist);
+	UVMHIST_LOG(maphist, "uobj %p start 0x%x stop 0x%x flags 0x%x",
+		    uobj, start, stop, flags);
+	KASSERT(flags & (PGO_CLEANIT|PGO_FREE|PGO_DEACTIVATE));
+
+	if (uobj->uo_npages == 0) {
+		s = splbio();
+		if (LIST_FIRST(&vp->v_dirtyblkhd) == NULL &&
+		    (vp->v_bioflag & VBIOONSYNCLIST)) {
+			vp->v_bioflag &= ~VBIOONSYNCLIST;
+			LIST_REMOVE(vp, v_synclist);
+		}
+		splx(s);
+		return TRUE;
+	}
+
+#ifdef DIAGNOSTIC
+	if (uvn->u_size == VSIZENOTSET) {
+		printf("uvn_flush: size not set vp %p\n", uvn);
+		vprint("uvn_flush VSIZENOTSET", vp);
+		flags |= PGO_ALLPAGES;
+	}
+#endif
 
-	curoff = 0;	/* XXX: shut up gcc */
 	/*
 	 * get init vals and determine how we are going to traverse object
 	 */
 
+	if (stop == 0) {
+		stop = trunc_page(LLONG_MAX);
+	}
+	curoff = 0;
 	need_iosync = FALSE;
-	retval = TRUE;		/* return value */
+	retval = TRUE;
+	wasclean = TRUE;
 	if (flags & PGO_ALLPAGES) {
 		all = TRUE;
-		by_list = TRUE;		/* always go by the list */
+		by_list = TRUE;
 	} else {
 		start = trunc_page(start);
 		stop = round_page(stop);
-#ifdef DEBUG
-		if (stop > round_page(uvn->u_size))
-			printf("uvn_flush: strange, got an out of range "
-			    "flush (fixed)\n");
-#endif
 		all = FALSE;
 		by_list = (uobj->uo_npages <= 
 		    ((stop - start) >> PAGE_SHIFT) * UVN_HASH_PENALTY);
@@ -870,8 +457,7 @@ uvn_flush(uobj, start, stop, flags)
 	if ((flags & PGO_CLEANIT) != 0 &&
 	    uobj->pgops->pgo_mk_pcluster != NULL) {
 		if (by_list) {
-			for (pp = uobj->memq.tqh_first ; pp != NULL ;
-			    pp = pp->listq.tqe_next) {
+			TAILQ_FOREACH(pp, &uobj->memq, listq) {
 				if (!all &&
 				    (pp->offset < start || pp->offset >= stop))
 					continue;
@@ -895,45 +481,32 @@ uvn_flush(uobj, start, stop, flags)
 	 */
 
 	if (by_list) {
-		pp = uobj->memq.tqh_first;
+		pp = TAILQ_FIRST(&uobj->memq);
 	} else {
 		curoff = start;
 		pp = uvm_pagelookup(uobj, curoff);
 	}
 
-	ppnext = NULL;	/* XXX: shut up gcc */ 
-	ppsp = NULL;		/* XXX: shut up gcc */
-	uvm_lock_pageq();	/* page queues locked */
+	ppnext = NULL;
+	ppsp = NULL;
+	uvm_lock_pageq();
 
 	/* locked: both page queues and uobj */
 	for ( ; (by_list && pp != NULL) || 
-	  (!by_list && curoff < stop) ; pp = ppnext) {
-
+		      (!by_list && curoff < stop) ; pp = ppnext) {
 		if (by_list) {
-
-			/*
-			 * range check
-			 */
-
 			if (!all &&
 			    (pp->offset < start || pp->offset >= stop)) {
-				ppnext = pp->listq.tqe_next;
+				ppnext = TAILQ_NEXT(pp, listq);
 				continue;
 			}
-
 		} else {
-
-			/*
-			 * null check
-			 */
-
 			curoff += PAGE_SIZE;
 			if (pp == NULL) {
 				if (curoff < stop)
 					ppnext = uvm_pagelookup(uobj, curoff);
 				continue;
 			}
-
 		}
 
 		/*
@@ -949,24 +522,23 @@ uvn_flush(uobj, start, stop, flags)
 
 		if ((flags & PGO_CLEANIT) == 0 || (pp->flags & PG_BUSY) != 0) {
 			needs_clean = FALSE;
-			if ((pp->flags & PG_BUSY) != 0 &&
-			    (flags & (PGO_CLEANIT|PGO_SYNCIO)) ==
-			             (PGO_CLEANIT|PGO_SYNCIO))
+			if (flags & PGO_SYNCIO)
 				need_iosync = TRUE;
 		} else {
+
 			/*
 			 * freeing: nuke all mappings so we can sync
 			 * PG_CLEAN bit with no race
 			 */
 			if ((pp->flags & PG_CLEAN) != 0 && 
 			    (flags & PGO_FREE) != 0 &&
-			    (pp->pqflags & PQ_ACTIVE) != 0)
+			    /* XXX ACTIVE|INACTIVE test unnecessary? */
+			    (pp->pqflags & (PQ_ACTIVE|PQ_INACTIVE)) != 0)
 				pmap_page_protect(pp, VM_PROT_NONE);
 			if ((pp->flags & PG_CLEAN) != 0 &&
 			    pmap_is_modified(pp))
 				pp->flags &= ~(PG_CLEAN);
-			pp->flags |= PG_CLEANCHK;	/* update "hint" */
-
+			pp->flags |= PG_CLEANCHK;
 			needs_clean = ((pp->flags & PG_CLEAN) == 0);
 		}
 
@@ -974,29 +546,26 @@ uvn_flush(uobj, start, stop, flags)
 		 * if we don't need a clean... load ppnext and dispose of pp
 		 */
 		if (!needs_clean) {
-			/* load ppnext */
 			if (by_list)
-				ppnext = pp->listq.tqe_next;
+				ppnext = TAILQ_NEXT(pp, listq);
 			else {
 				if (curoff < stop)
 					ppnext = uvm_pagelookup(uobj, curoff);
 			}
 
-			/* now dispose of pp */
 			if (flags & PGO_DEACTIVATE) {
 				if ((pp->pqflags & PQ_INACTIVE) == 0 &&
+				    (pp->flags & PG_BUSY) == 0 &&
 				    pp->wire_count == 0) {
-					pmap_page_protect(pp, VM_PROT_NONE);
+					pmap_clear_reference(pp);
 					uvm_pagedeactivate(pp);
 				}
 
 			} else if (flags & PGO_FREE) {
 				if (pp->flags & PG_BUSY) {
-					/* release busy pages */
 					pp->flags |= PG_RELEASED;
 				} else {
 					pmap_page_protect(pp, VM_PROT_NONE);
-					/* removed page from object */
 					uvm_pagefree(pp);
 				}
 			}
@@ -1013,6 +582,7 @@ uvn_flush(uobj, start, stop, flags)
 		 * note: locked: uobj and page queues.
 		 */
 
+		wasclean = FALSE;
 		pp->flags |= PG_BUSY;	/* we 'own' page now */
 		UVM_PAGE_OWN(pp, "uvn_flush");
 		pmap_page_protect(pp, VM_PROT_READ);
@@ -1023,7 +593,7 @@ ReTry:
 
 		/* locked: page queues, uobj */
 		result = uvm_pager_put(uobj, pp, &ppsp, &npages, 
-			   flags | PGO_DOACTCLUST, start, stop);
+				       flags | PGO_DOACTCLUST, start, stop);
 		/* unlocked: page queues, uobj */
 
 		/*
@@ -1046,7 +616,8 @@ ReTry:
 		 */
 
 		if (result == VM_PAGER_AGAIN) {
-			/* 
+
+			/*
 			 * it is unlikely, but page could have been released
 			 * while we had the object lock dropped.   we ignore
 			 * this now and retry the I/O.  we will detect and
@@ -1073,27 +644,22 @@ ReTry:
 		 * we can move on to the next page.
 		 */
 
-		if (result == VM_PAGER_PEND) {
+		if (result == VM_PAGER_PEND &&
+		    (flags & (PGO_DEACTIVATE|PGO_FREE)) == 0) {
 
-			if ((flags & (PGO_DEACTIVATE|PGO_FREE)) == 0) {
-				/*
-				 * no per-page ops: refresh ppnext and continue
-				 */
-				if (by_list) {
-					if (pp->version == pp_version)
-						ppnext = pp->listq.tqe_next;
-					else
-						/* reset */
-						ppnext = uobj->memq.tqh_first;
-				} else {
-					if (curoff < stop)
-						ppnext = uvm_pagelookup(uobj,
-						    curoff);
-				}
-				continue;
+			/*
+			 * no per-page ops: refresh ppnext and continue
+			 */
+			if (by_list) {
+				if (pp->version == pp_version)
+					ppnext = TAILQ_NEXT(pp, listq);
+				else
+					ppnext = TAILQ_FIRST(&uobj->memq);
+			} else {
+				if (curoff < stop)
+					ppnext = uvm_pagelookup(uobj, curoff);
 			}
-
-			/* need to do anything here? */
+			continue;
 		}
 
 		/*
@@ -1120,18 +686,19 @@ ReTry:
 				/* set up next page for outer loop */
 				if (by_list) {
 					if (pp->version == pp_version)
-						ppnext = pp->listq.tqe_next;
+						ppnext = TAILQ_NEXT(pp, listq);
 					else
-						/* reset */
-						ppnext = uobj->memq.tqh_first;
+						ppnext = TAILQ_FIRST(
+						    &uobj->memq);
 				} else {
 					if (curoff < stop)
-					ppnext = uvm_pagelookup(uobj, curoff);
+						ppnext = uvm_pagelookup(uobj,
+						    curoff);
 				}
 			}
 
 			/*
-			 * verify the page didn't get moved while obj was
+			 * verify the page wasn't moved while obj was
 			 * unlocked
 			 */
 			if (result == VM_PAGER_PEND && ptmp->uobject != uobj)
@@ -1145,26 +712,32 @@ ReTry:
 			 */
 
 			if (result != VM_PAGER_PEND) {
-				if (ptmp->flags & PG_WANTED)
+				if (ptmp->flags & PG_WANTED) {
 					/* still holding object lock */
 					wakeup(ptmp);
-
+				}
 				ptmp->flags &= ~(PG_WANTED|PG_BUSY);
 				UVM_PAGE_OWN(ptmp, NULL);
 				if (ptmp->flags & PG_RELEASED) {
-
-					/* pgo_releasepg wants this */
 					uvm_unlock_pageq();
-					if (!uvn_releasepg(ptmp, NULL))
+					if (!uvn_releasepg(ptmp, NULL)) {
+						UVMHIST_LOG(maphist,
+							    "released %p",
+							    ptmp, 0,0,0);
 						return (TRUE);
-
-					uvm_lock_pageq();	/* relock */
-					continue;		/* next page */
-
+					}
+					uvm_lock_pageq();
+					continue;
 				} else {
-					ptmp->flags |= (PG_CLEAN|PG_CLEANCHK);
-					if ((flags & PGO_FREE) == 0)
-						pmap_clear_modify(ptmp);
+					if ((flags & PGO_WEAK) == 0 &&
+					    !(result == VM_PAGER_ERROR &&
+					      curproc == uvm.pagedaemon_proc)) {
+						ptmp->flags |=
+							(PG_CLEAN|PG_CLEANCHK);
+						if ((flags & PGO_FREE) == 0) {
+							pmap_clear_modify(ptmp);
+						}
+					}
 				}
 			}
 	  
@@ -1174,11 +747,11 @@ ReTry:
 
 			if (flags & PGO_DEACTIVATE) {
 				if ((pp->pqflags & PQ_INACTIVE) == 0 &&
+				    (pp->flags & PG_BUSY) == 0 &&
 				    pp->wire_count == 0) {
-					pmap_page_protect(ptmp, VM_PROT_NONE);
+					pmap_clear_reference(ptmp);
 					uvm_pagedeactivate(ptmp);
 				}
-
 			} else if (flags & PGO_FREE) {
 				if (result == VM_PAGER_PEND) {
 					if ((ptmp->flags & PG_BUSY) != 0)
@@ -1187,10 +760,10 @@ ReTry:
 				} else {
 					if (result != VM_PAGER_OK) {
 						printf("uvn_flush: obj=%p, "
-						   "offset=0x%llx.  error "
-						   "during pageout.\n",
+						   "offset=0x%llx.  error %d\n",
 						    pp->uobject,
-						    (long long)pp->offset);
+						    (long long)pp->offset,
+						    result);
 						printf("uvn_flush: WARNING: "
 						    "changes to page may be "
 						    "lost!\n");
@@ -1200,31 +773,38 @@ ReTry:
 					uvm_pagefree(ptmp);
 				}
 			}
-
 		}		/* end of "lcv" for loop */
-
 	}		/* end of "pp" for loop */
 
-	/*
-	 * done with pagequeues: unlock
-	 */
 	uvm_unlock_pageq();
-
-	/*
-	 * now wait for all I/O if required.
-	 */
+	s = splbio();
+	if ((flags & PGO_CLEANIT) && all && wasclean &&
+	    LIST_FIRST(&vp->v_dirtyblkhd) == NULL &&
+	    (vp->v_bioflag & VBIOONSYNCLIST)) {
+		vp->v_bioflag &= ~VBIOONSYNCLIST;
+		LIST_REMOVE(vp, v_synclist);
+	}
+	splx(s);
 	if (need_iosync) {
-
 		UVMHIST_LOG(maphist,"  <<DOING IOSYNC>>",0,0,0,0);
-		while (uvn->u_nio != 0) {
-			uvn->u_flags |= UVM_VNODE_IOSYNC;
-			UVM_UNLOCK_AND_WAIT(&uvn->u_nio, &uvn->u_obj.vmobjlock, 
-			  FALSE, "uvn_flush",0);
+
+		/*
+		 * XXX this doesn't use the new two-flag scheme,
+		 * but to use that, all i/o initiators will have to change.
+		 */
+
+		s = splbio();
+		while (vp->v_numoutput != 0) {
+			UVMHIST_LOG(ubchist, "waiting for vp %p num %d",
+				    vp, vp->v_numoutput,0,0);
+
+	                vp->v_bioflag |= VBIOWAIT;
+			UVM_UNLOCK_AND_WAIT(&vp->v_numoutput,
+					    &uvn->u_obj.vmobjlock, 
+					    FALSE, "uvn_flush",0);
 			simple_lock(&uvn->u_obj.vmobjlock);
 		}
-		if (uvn->u_flags & UVM_VNODE_IOSYNCWANTED)
-			wakeup(&uvn->u_flags);
-		uvn->u_flags &= ~(UVM_VNODE_IOSYNC|UVM_VNODE_IOSYNCWANTED);
+		splx(s);
 	}
 
 	/* return, with object locked! */
@@ -1248,31 +828,18 @@ uvn_cluster(uobj, offset, loffset, hoffset)
 	voff_t offset;
 	voff_t *loffset, *hoffset; /* OUT */
 {
-	struct uvm_vnode *uvn = (struct uvm_vnode *) uobj;
-	*loffset = offset;
-
-	if (*loffset >= uvn->u_size)
-		panic("uvn_cluster: offset out of range");
+	struct uvm_vnode *uvn = (struct uvm_vnode *)uobj;
 
-	/*
-	 * XXX: old pager claims we could use VOP_BMAP to get maxcontig value.
-	 */
-	*hoffset = *loffset + MAXBSIZE;
-	if (*hoffset > round_page(uvn->u_size))	/* past end? */
-		*hoffset = round_page(uvn->u_size);
-
-	return;
+	*loffset = offset;
+	*hoffset = MIN(offset + MAXBSIZE, round_page(uvn->u_size));
 }
 
 /*
  * uvn_put: flush page data to backing store.
  *
- * => prefer map unlocked (not required)
  * => object must be locked!   we will _unlock_ it before starting I/O.
  * => flags: PGO_SYNCIO -- use sync. I/O
  * => note: caller must set PG_CLEAN and pmap_clear_modify (if needed)
- * => XXX: currently we use VOP_READ/VOP_WRITE which are only sync.
- *	[thus we never do async i/o!  see iodone comment]
  */
 
 static int
@@ -1281,13 +848,11 @@ uvn_put(uobj, pps, npages, flags)
 	struct vm_page **pps;
 	int npages, flags;
 {
-	int retval;
-
-	/* note: object locked */
-	retval = uvn_io((struct uvm_vnode*)uobj, pps, npages, flags, UIO_WRITE);
-	/* note: object unlocked */
+	struct vnode *vp = (struct vnode *)uobj;
+	int error;
 
-	return(retval);
+	error = VOP_PUTPAGES(vp, pps, npages, flags, NULL);
+	return uvm_errno2vmerror(error);
 }
 
 
@@ -1308,551 +873,121 @@ uvn_get(uobj, offset, pps, npagesp, centeridx, access_type, advice, flags)
 	voff_t offset;
 	struct vm_page **pps;		/* IN/OUT */
 	int *npagesp;			/* IN (OUT if PGO_LOCKED) */
-	int centeridx, advice, flags;
+	int centeridx;
 	vm_prot_t access_type;
+	int advice, flags;
 {
-	voff_t current_offset;
-	struct vm_page *ptmp;
-	int lcv, result, gotpages;
-	boolean_t done;
-	UVMHIST_FUNC("uvn_get"); UVMHIST_CALLED(maphist);
-	UVMHIST_LOG(maphist, "flags=%d", flags,0,0,0);
-
-	/*
-	 * step 1: handled the case where fault data structures are locked.
-	 */
-
-	if (flags & PGO_LOCKED) {
-
-		/*
-		 * gotpages is the current number of pages we've gotten (which
-		 * we pass back up to caller via *npagesp.
-		 */
-
-		gotpages = 0;
-
-		/*
-		 * step 1a: get pages that are already resident.   only do this
-		 * if the data structures are locked (i.e. the first time
-		 * through).
-		 */
-
-		done = TRUE;	/* be optimistic */
-
-		for (lcv = 0, current_offset = offset ; lcv < *npagesp ;
-		    lcv++, current_offset += PAGE_SIZE) {
-
-			/* do we care about this page?  if not, skip it */
-			if (pps[lcv] == PGO_DONTCARE)
-				continue;
-
-			/* lookup page */
-			ptmp = uvm_pagelookup(uobj, current_offset);
-
-			/* to be useful must get a non-busy, non-released pg */
-			if (ptmp == NULL ||
-			    (ptmp->flags & (PG_BUSY|PG_RELEASED)) != 0) {
-				if (lcv == centeridx || (flags & PGO_ALLPAGES)
-				    != 0)
-				done = FALSE;	/* need to do a wait or I/O! */
-				continue;
-			}
-
-			/*
-			 * useful page: busy/lock it and plug it in our
-			 * result array
-			 */
-			ptmp->flags |= PG_BUSY;		/* loan up to caller */
-			UVM_PAGE_OWN(ptmp, "uvn_get1");
-			pps[lcv] = ptmp;
-			gotpages++;
-
-		}	/* "for" lcv loop */
-
-		/*
-		 * XXX: given the "advice", should we consider async read-ahead?
-		 * XXX: fault current does deactive of pages behind us.  is 
-		 * this good (other callers might now).
-		 */
-		/* 
-		 * XXX: read-ahead currently handled by buffer cache (bread)
-		 * level.
-		 * XXX: no async i/o available.
-		 * XXX: so we don't do anything now.
-		 */
-
-		/*
-		 * step 1c: now we've either done everything needed or we to
-		 * unlock and do some waiting or I/O.
-		 */
-
-		*npagesp = gotpages;		/* let caller know */
-		if (done)
-			return(VM_PAGER_OK);		/* bingo! */
-		else
-			/* EEK!   Need to unlock and I/O */
-			return(VM_PAGER_UNLOCK);
-	}
-
-	/*
-	 * step 2: get non-resident or busy pages.
-	 * object is locked.   data structures are unlocked.
-	 *
-	 * XXX: because we can't do async I/O at this level we get things
-	 * page at a time (otherwise we'd chunk).   the VOP_READ() will do 
-	 * async-read-ahead for us at a lower level.
-	 */
-
-	for (lcv = 0, current_offset = offset ; 
-			 lcv < *npagesp ; lcv++, current_offset += PAGE_SIZE) {
-		
-		/* skip over pages we've already gotten or don't want */
-		/* skip over pages we don't _have_ to get */
-		if (pps[lcv] != NULL || (lcv != centeridx &&
-		    (flags & PGO_ALLPAGES) == 0))
-			continue;
-
-		/*
-		 * we have yet to locate the current page (pps[lcv]).   we first
-		 * look for a page that is already at the current offset.   if
-		 * we fine a page, we check to see if it is busy or released.
-		 * if that is the case, then we sleep on the page until it is
-		 * no longer busy or released and repeat the lookup.    if the
-		 * page we found is neither busy nor released, then we busy it
-		 * (so we own it) and plug it into pps[lcv].   this breaks the
-		 * following while loop and indicates we are ready to move on
-		 * to the next page in the "lcv" loop above.
-		 *
-		 * if we exit the while loop with pps[lcv] still set to NULL,
-		 * then it means that we allocated a new busy/fake/clean page
-		 * ptmp in the object and we need to do I/O to fill in the data.
-		 */
-
-		while (pps[lcv] == NULL) {	/* top of "pps" while loop */
-			
-			/* look for a current page */
-			ptmp = uvm_pagelookup(uobj, current_offset);
-
-			/* nope?   allocate one now (if we can) */
-			if (ptmp == NULL) {
-
-				ptmp = uvm_pagealloc(uobj, current_offset,
-				    NULL, 0);
-
-				/* out of RAM? */
-				if (ptmp == NULL) {
-					simple_unlock(&uobj->vmobjlock);
-					uvm_wait("uvn_getpage");
-					simple_lock(&uobj->vmobjlock);
-
-					/* goto top of pps while loop */
-					continue;	
-				}
-
-				/* 
-				 * got new page ready for I/O.  break pps
-				 * while loop.  pps[lcv] is still NULL.
-				 */
-				break;		
-			}
-
-			/* page is there, see if we need to wait on it */
-			if ((ptmp->flags & (PG_BUSY|PG_RELEASED)) != 0) {
-				ptmp->flags |= PG_WANTED;
-				UVM_UNLOCK_AND_WAIT(ptmp,
-				    &uobj->vmobjlock, FALSE, "uvn_get",0);
-				simple_lock(&uobj->vmobjlock);
-				continue;	/* goto top of pps while loop */
-			}
-			
-			/* 
-			 * if we get here then the page has become resident
-			 * and unbusy between steps 1 and 2.  we busy it
-			 * now (so we own it) and set pps[lcv] (so that we
-			 * exit the while loop).
-			 */
-			ptmp->flags |= PG_BUSY;
-			UVM_PAGE_OWN(ptmp, "uvn_get2");
-			pps[lcv] = ptmp;
-		}
-
-		/*
-		 * if we own the a 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
-		 * I/O to fill it with valid data.  note that object must be
-		 * locked going into uvn_io, but will be unlocked afterwards.
-		 */
-
-		result = uvn_io((struct uvm_vnode *) uobj, &ptmp, 1,
-		    PGO_SYNCIO, UIO_READ);
-
-		/*
-		 * I/O done.   object is unlocked (by uvn_io).   because we used
-		 * syncio the result can not be PEND or AGAIN.   we must relock
-		 * and check for errors.
-		 */
-
-		/* lock object.   check for errors.   */
-		simple_lock(&uobj->vmobjlock);
-		if (result != VM_PAGER_OK) {
-			if (ptmp->flags & PG_WANTED)
-				/* object lock still held */
-				wakeup(ptmp);
-
-			ptmp->flags &= ~(PG_WANTED|PG_BUSY);
-			UVM_PAGE_OWN(ptmp, NULL);
-			uvm_lock_pageq();
-			uvm_pagefree(ptmp);
-			uvm_unlock_pageq();
-			simple_unlock(&uobj->vmobjlock);
-			return(result);
-		}
-
-		/* 
-		 * we got the page!   clear the fake flag (indicates valid
-		 * data now in page) and plug into our result array.   note
-		 * that page is still busy.   
-		 *
-		 * it is the callers job to:
-		 * => check if the page is released
-		 * => unbusy the page
-		 * => activate the page
-		 */
-
-		ptmp->flags &= ~PG_FAKE;		/* data is valid ... */
-		pmap_clear_modify(ptmp);		/* ... and clean */
-		pps[lcv] = ptmp;
-
-	}	/* lcv loop */
-
-	/*
-	 * finally, unlock object and return.
-	 */
-
-	simple_unlock(&uobj->vmobjlock);
-	return (VM_PAGER_OK);
+	struct vnode *vp = (struct vnode *)uobj;
+	int error;
+	UVMHIST_FUNC("uvn_get"); UVMHIST_CALLED(ubchist);
+
+	UVMHIST_LOG(ubchist, "vp %p off 0x%x", vp, (int)offset, 0,0);
+	error = VOP_GETPAGES(vp, offset, pps, npagesp, centeridx,
+			     access_type, advice, flags);
+	return uvm_errno2vmerror(error);
 }
 
+
 /*
- * uvn_io: do I/O to a vnode
- *
- * => prefer map unlocked (not required)
- * => object must be locked!   we will _unlock_ it before starting I/O.
- * => flags: PGO_SYNCIO -- use sync. I/O
- * => XXX: currently we use VOP_READ/VOP_WRITE which are only sync.
- *	[thus we never do async i/o!  see iodone comment]
+ * uvn_findpages:
+ * return the page for the uobj and offset requested, allocating if needed.
+ * => uobj must be locked.
+ * => returned page will be BUSY.
  */
 
-static int
-uvn_io(uvn, pps, npages, flags, rw)
-	struct uvm_vnode *uvn;
-	vm_page_t *pps;
-	int npages, flags, rw;
+void
+uvn_findpages(uobj, offset, npagesp, pps, flags)
+	struct uvm_object *uobj;
+	voff_t offset;
+	int *npagesp;
+	struct vm_page **pps;
+	int flags;
 {
-	struct vnode *vn;
-	struct uio uio;
-	struct iovec iov;
-	vaddr_t kva;
-	off_t file_offset;
-	int waitf, result, mapinflags;
-	size_t got, wanted;
-	UVMHIST_FUNC("uvn_io"); UVMHIST_CALLED(maphist);
-
-	UVMHIST_LOG(maphist, "rw=%d", rw,0,0,0);
-	
-	/*
-	 * init values
-	 */
-
-	waitf = (flags & PGO_SYNCIO) ? M_WAITOK : M_NOWAIT;
-	vn = (struct vnode *) uvn;
-	file_offset = pps[0]->offset;
-	
-	/*
-	 * check for sync'ing I/O.
-	 */
-	
-	while (uvn->u_flags & UVM_VNODE_IOSYNC) {
-		if (waitf == M_NOWAIT) { 
-			simple_unlock(&uvn->u_obj.vmobjlock);
-			UVMHIST_LOG(maphist,"<- try again (iosync)",0,0,0,0);
-			return(VM_PAGER_AGAIN);
-		}
-		uvn->u_flags |= UVM_VNODE_IOSYNCWANTED;
-		UVM_UNLOCK_AND_WAIT(&uvn->u_flags, &uvn->u_obj.vmobjlock, 
-			FALSE, "uvn_iosync",0);
-		simple_lock(&uvn->u_obj.vmobjlock);
-	}
-
-	/*
-	 * check size
-	 */
-
-	if (file_offset >= uvn->u_size) {
-			simple_unlock(&uvn->u_obj.vmobjlock);
-			UVMHIST_LOG(maphist,"<- BAD (size check)",0,0,0,0);
-			return(VM_PAGER_BAD);
-	}
-
-	/*
-	 * first try and map the pages in (without waiting)
-	 */
-
-	mapinflags = (rw == UIO_READ) ?
-	    UVMPAGER_MAPIN_READ : UVMPAGER_MAPIN_WRITE;
-
-	kva = uvm_pagermapin(pps, npages, mapinflags);
-	if (kva == 0 && waitf == M_NOWAIT) {
-		simple_unlock(&uvn->u_obj.vmobjlock);
-		UVMHIST_LOG(maphist,"<- mapin failed (try again)",0,0,0,0);
-		return(VM_PAGER_AGAIN);
-	}
-
-	/*
-	 * ok, now bump u_nio up.   at this point we are done with uvn
-	 * and can unlock it.   if we still don't have a kva, try again
-	 * (this time with sleep ok).
-	 */
-	
-	uvn->u_nio++;			/* we have an I/O in progress! */
-	simple_unlock(&uvn->u_obj.vmobjlock);
-	/* NOTE: object now unlocked */
-	if (kva == 0)
-		kva = uvm_pagermapin(pps, npages,
-		    mapinflags | UVMPAGER_MAPIN_WAITOK);
-
-	/*
-	 * ok, mapped in.  our pages are PG_BUSY so they are not going to
-	 * get touched (so we can look at "offset" without having to lock
-	 * the object).  set up for I/O.
-	 */
-
-	/*
-	 * fill out uio/iov
-	 */
-	
-	iov.iov_base = (caddr_t) kva;
-	wanted = npages << PAGE_SHIFT;
-	if (file_offset + wanted > uvn->u_size)
-		wanted = uvn->u_size - file_offset;	/* XXX: needed? */
-	iov.iov_len = wanted;
-	uio.uio_iov = &iov;
-	uio.uio_iovcnt = 1;
-	uio.uio_offset = file_offset;
-	uio.uio_segflg = UIO_SYSSPACE;
-	uio.uio_rw = rw;
-	uio.uio_resid = wanted;
-	uio.uio_procp = curproc;
-
-	/*
-	 * do the I/O!  (XXX: curproc?)
-	 */
-
-	UVMHIST_LOG(maphist, "calling VOP",0,0,0,0);
-
-	/*
-	 * This process may already have this vnode locked, if we faulted in
-	 * copyin() or copyout() on a region backed by this vnode
-	 * while doing I/O to the vnode.  If this is the case, don't
-	 * panic.. instead, return the error to the user.
-	 *
-	 * XXX this is a stopgap to prevent a panic.
-	 * Ideally, this kind of operation *should* work.
-	 */
-	result = 0;
-	if ((uvn->u_flags & UVM_VNODE_VNISLOCKED) == 0)
-		result = vn_lock(vn, LK_EXCLUSIVE | LK_RETRY | LK_RECURSEFAIL, curproc);
-
-	if (result == 0) {
-		/* NOTE: vnode now locked! */
-
-		if (rw == UIO_READ)
-			result = VOP_READ(vn, &uio, 0, curproc->p_ucred);
-		else
-			result = VOP_WRITE(vn, &uio, 0, curproc->p_ucred);
+	int i, rv, npages;
 
-		if ((uvn->u_flags & UVM_VNODE_VNISLOCKED) == 0)
-			VOP_UNLOCK(vn, 0, curproc);
+	rv = 0;
+	npages = *npagesp;
+	for (i = 0; i < npages; i++, offset += PAGE_SIZE) {
+		rv += uvn_findpage(uobj, offset, &pps[i], flags);
 	}
-	
-	/* NOTE: vnode now unlocked (unless vnislocked) */
-
-	UVMHIST_LOG(maphist, "done calling VOP",0,0,0,0);
-
-	/*
-	 * result == unix style errno (0 == OK!)
-	 *
-	 * zero out rest of buffer (if needed)
-	 */
-
-	if (result == 0) {
-		got = wanted - uio.uio_resid;
-
-		if (wanted && got == 0) {
-			result = EIO;		/* XXX: error? */
-		} else if (got < PAGE_SIZE * npages && rw == UIO_READ) {
-			memset((void *) (kva + got), 0,
-			       (npages << PAGE_SHIFT) - got);
-		}
-	}
-
-	/*
-	 * now remove pager mapping
-	 */
-	uvm_pagermapout(kva, npages);
-		
-	/*
-	 * now clean up the object (i.e. drop I/O count)
-	 */
-
-	simple_lock(&uvn->u_obj.vmobjlock);
-	/* NOTE: object now locked! */
-
-	uvn->u_nio--;			/* I/O DONE! */
-	if ((uvn->u_flags & UVM_VNODE_IOSYNC) != 0 && uvn->u_nio == 0) {
-		wakeup(&uvn->u_nio);
-	}
-	simple_unlock(&uvn->u_obj.vmobjlock);
-	/* NOTE: object now unlocked! */
-
-	/*
-	 * done!
-	 */
-
-	UVMHIST_LOG(maphist, "<- done (result %d)", result,0,0,0);
-	if (result == 0)
-		return(VM_PAGER_OK);
-	else
-		return(VM_PAGER_ERROR);
+	*npagesp = rv;
 }
 
-/*
- * uvm_vnp_uncache: disable "persisting" in a vnode... when last reference
- * is gone we will kill the object (flushing dirty pages back to the vnode
- * if needed).
- *
- * => returns TRUE if there was no uvm_object attached or if there was
- *	one and we killed it [i.e. if there is no active uvn]
- * => called with the vnode VOP_LOCK'd [we will unlock it for I/O, if
- *	needed]
- *
- * => XXX: given that we now kill uvn's when a vnode is recycled (without
- *	having to hold a reference on the vnode) and given a working
- *	uvm_vnp_sync(), how does that effect the need for this function?
- *      [XXXCDC: seems like it can die?]
- *
- * => XXX: this function should DIE once we merge the VM and buffer 
- *	cache.
- *
- * research shows that this is called in the following places:
- * ext2fs_truncate, ffs_truncate, detrunc[msdosfs]: called when vnode
- *	changes sizes
- * ext2fs_write, WRITE [ufs_readwrite], msdosfs_write: called when we
- *	are written to
- * ex2fs_chmod, ufs_chmod: called if VTEXT vnode and the sticky bit
- *	is off
- * ffs_realloccg: when we can't extend the current block and have 
- *	to allocate a new one we call this [XXX: why?]
- * nfsrv_rename, rename_files: called when the target filename is there
- *	and we want to remove it
- * nfsrv_remove, sys_unlink: called on file we are removing
- * nfsrv_access: if VTEXT and we want WRITE access and we don't uncache
- *	then return "text busy"
- * nfs_open: seems to uncache any file opened with nfs
- * vn_writechk: if VTEXT vnode and can't uncache return "text busy"
- */
-
-boolean_t
-uvm_vnp_uncache(vp)
-	struct vnode *vp;
+static int
+uvn_findpage(uobj, offset, pgp, flags)
+	struct uvm_object *uobj;
+	voff_t offset;
+	struct vm_page **pgp;
+	int flags;
 {
-	struct uvm_vnode *uvn = &vp->v_uvm;
-
-	/*
-	 * lock uvn part of the vnode and check to see if we need to do anything
-	 */
+	struct vm_page *pg;
+	UVMHIST_FUNC("uvn_findpage"); UVMHIST_CALLED(ubchist);
+	UVMHIST_LOG(ubchist, "vp %p off 0x%lx", uobj, offset,0,0);
 
-	simple_lock(&uvn->u_obj.vmobjlock);
-	if ((uvn->u_flags & UVM_VNODE_VALID) == 0 || 
-			(uvn->u_flags & UVM_VNODE_BLOCKED) != 0) {
-		simple_unlock(&uvn->u_obj.vmobjlock);
-		return(TRUE);
+	if (*pgp != NULL) {
+		UVMHIST_LOG(ubchist, "dontcare", 0,0,0,0);
+		return 0;
 	}
+	for (;;) {
+		/* look for an existing page */
+		pg = uvm_pagelookup(uobj, offset);
+
+		/* nope?   allocate one now */
+		if (pg == NULL) {
+			if (flags & UFP_NOALLOC) {
+				UVMHIST_LOG(ubchist, "noalloc", 0,0,0,0);
+				return 0;
+			}
+			pg = uvm_pagealloc(uobj, offset, NULL, 0);
+			if (pg == NULL) {
+				if (flags & UFP_NOWAIT) {
+					UVMHIST_LOG(ubchist, "nowait",0,0,0,0);
+					return 0;
+				}
+				simple_unlock(&uobj->vmobjlock);
+				uvm_wait("uvn_fp1");
+				simple_lock(&uobj->vmobjlock);
+				continue;
+			}
+			if (UVM_OBJ_IS_VTEXT(uobj)) {
+				uvmexp.vtextpages++;
+			} else {
+				uvmexp.vnodepages++;
+			}
+			UVMHIST_LOG(ubchist, "alloced",0,0,0,0);
+			break;
+		} else if (flags & UFP_NOCACHE) {
+			UVMHIST_LOG(ubchist, "nocache",0,0,0,0);
+			return 0;
+		}
 
-	/*
-	 * we have a valid, non-blocked uvn.   clear persist flag.
-	 * if uvn is currently active we can return now.
-	 */
-
-	uvn->u_flags &= ~UVM_VNODE_CANPERSIST;
-	if (uvn->u_obj.uo_refs) {
-		simple_unlock(&uvn->u_obj.vmobjlock);
-		return(FALSE);
-	}
-
-	/*
-	 * uvn is currently persisting!   we have to gain a reference to
-	 * it so that we can call uvn_detach to kill the uvn.
-	 */
-
-	VREF(vp);			/* seems ok, even with VOP_LOCK */
-	uvn->u_obj.uo_refs++;		/* value is now 1 */
-	simple_unlock(&uvn->u_obj.vmobjlock);
-
-
-#ifdef DEBUG
-	/*
-	 * carry over sanity check from old vnode pager: the vnode should
-	 * be VOP_LOCK'd, and we confirm it here.
-	 */
-	if (!VOP_ISLOCKED(vp)) {
-		boolean_t is_ok_anyway = FALSE;
-#if defined(NFSCLIENT)
-		extern int (**nfsv2_vnodeop_p) __P((void *));
-		extern int (**spec_nfsv2nodeop_p) __P((void *));
-		extern int (**fifo_nfsv2nodeop_p) __P((void *));
-
-		/* vnode is NOT VOP_LOCKed: some vnode types _never_ lock */
-		if (vp->v_op == nfsv2_vnodeop_p ||
-		    vp->v_op == spec_nfsv2nodeop_p) {
-			is_ok_anyway = TRUE;
+		/* page is there, see if we need to wait on it */
+		if ((pg->flags & (PG_BUSY|PG_RELEASED)) != 0) {
+			if (flags & UFP_NOWAIT) {
+				UVMHIST_LOG(ubchist, "nowait",0,0,0,0);
+				return 0;
+			}
+			pg->flags |= PG_WANTED;
+			UVM_UNLOCK_AND_WAIT(pg, &uobj->vmobjlock, 0,
+					    "uvn_fp2", 0);
+			simple_lock(&uobj->vmobjlock);
+			continue;
 		}
-		if (vp->v_op == fifo_nfsv2nodeop_p) {
-			is_ok_anyway = TRUE;
+			
+		/* skip PG_RDONLY pages if requested */
+		if ((flags & UFP_NORDONLY) && (pg->flags & PG_RDONLY)) {
+			UVMHIST_LOG(ubchist, "nordonly",0,0,0,0);
+			return 0;
 		}
-#endif	/* defined(NFSSERVER) || defined(NFSCLIENT) */
-		if (!is_ok_anyway)
-			panic("uvm_vnp_uncache: vnode not locked!");
-	}
-#endif	/* DEBUG */
 
-	/*
-	 * now drop our reference to the vnode.   if we have the sole 
-	 * reference to the vnode then this will cause it to die [as we
-	 * just cleared the persist flag].   we have to unlock the vnode 
-	 * while we are doing this as it may trigger I/O.
-	 *
-	 * XXX: it might be possible for uvn to get reclaimed while we are
-	 * unlocked causing us to return TRUE when we should not.   we ignore
-	 * this as a false-positive return value doesn't hurt us.
-	 */
-	VOP_UNLOCK(vp, 0, curproc);
-	uvn_detach(&uvn->u_obj);
-	vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, curproc);
-	
-	/*
-	 * and return...
-	 */
-	
-	return(TRUE);
+		/* mark the page BUSY and we're done. */
+		pg->flags |= PG_BUSY;
+		UVM_PAGE_OWN(pg, "uvn_findpage");
+		UVMHIST_LOG(ubchist, "found",0,0,0,0);
+		break;
+	}
+	*pgp = pg;
+	return 1;
 }
 
 /*
@@ -1879,150 +1014,49 @@ uvm_vnp_setsize(vp, newsize)
 	voff_t newsize;
 {
 	struct uvm_vnode *uvn = &vp->v_uvm;
+	voff_t pgend = round_page(newsize);
+	UVMHIST_FUNC("uvm_vnp_setsize"); UVMHIST_CALLED(ubchist);
 
-	/*
-	 * lock uvn and check for valid object, and if valid: do it!
-	 */
 	simple_lock(&uvn->u_obj.vmobjlock);
-	if (uvn->u_flags & UVM_VNODE_VALID) {
-
-		/*
-		 * now check if the size has changed: if we shrink we had better
-		 * toss some pages...
-		 */
 
-		if (uvn->u_size > newsize) {
-			(void)uvn_flush(&uvn->u_obj, newsize,
-			    uvn->u_size, PGO_FREE);
-		}
-		uvn->u_size = newsize;
-	}
-	simple_unlock(&uvn->u_obj.vmobjlock);
+	UVMHIST_LOG(ubchist, "old 0x%x new 0x%x", uvn->u_size, newsize, 0,0);
 
 	/*
-	 * done
+	 * now check if the size has changed: if we shrink we had better
+	 * toss some pages...
 	 */
-	return;
+
+	if (uvn->u_size > pgend && uvn->u_size != VSIZENOTSET) {
+		(void) uvn_flush(&uvn->u_obj, pgend, 0, PGO_FREE);
+	}
+	uvn->u_size = newsize;
+	simple_unlock(&uvn->u_obj.vmobjlock);
 }
 
 /*
- * uvm_vnp_sync: flush all dirty VM pages back to their backing vnodes.
- *
- * => called from sys_sync with no VM structures locked
- * => only one process can do a sync at a time (because the uvn
- *    structure only has one queue for sync'ing).  we ensure this
- *    by holding the uvn_sync_lock while the sync is in progress.
- *    other processes attempting a sync will sleep on this lock
- *    until we are done.
+ * uvm_vnp_zerorange:  set a range of bytes in a file to zero.
  */
 
 void
-uvm_vnp_sync(mp)
-	struct mount *mp;
-{
-	struct uvm_vnode *uvn;
+uvm_vnp_zerorange(vp, off, len)
 	struct vnode *vp;
-	boolean_t got_lock;
-
-	/*
-	 * step 1: ensure we are only ones using the uvn_sync_q by locking
-	 * our lock...
-	 */
-	lockmgr(&uvn_sync_lock, LK_EXCLUSIVE, NULL, curproc);
-
-	/*
-	 * step 2: build up a simpleq of uvns of interest based on the 
-	 * write list.   we gain a reference to uvns of interest.  must 
-	 * be careful about locking uvn's since we will be holding uvn_wl_lock
-	 * in the body of the loop.
-	 */
-	SIMPLEQ_INIT(&uvn_sync_q);
-	simple_lock(&uvn_wl_lock);
-	for (uvn = uvn_wlist.lh_first ; uvn != NULL ;
-	    uvn = uvn->u_wlist.le_next) {
-
-		vp = (struct vnode *) uvn;
-		if (mp && vp->v_mount != mp)
-			continue;
-
-		/* attempt to gain reference */
-		while ((got_lock = simple_lock_try(&uvn->u_obj.vmobjlock)) ==
-		    						FALSE && 
-				(uvn->u_flags & UVM_VNODE_BLOCKED) == 0)
-			/* spin */ ;
-
-		/*
-		 * we will exit the loop if either if the following are true:
-		 *  - we got the lock [always true if NCPU == 1]
-		 *  - we failed to get the lock but noticed the vnode was
-		 * 	"blocked" -- in this case the vnode must be a dying
-		 *	vnode, and since dying vnodes are in the process of
-		 *	being flushed out, we can safely skip this one
-		 *
-		 * we want to skip over the vnode if we did not get the lock,
-		 * or if the vnode is already dying (due to the above logic).
-		 *
-		 * note that uvn must already be valid because we found it on
-		 * the wlist (this also means it can't be ALOCK'd).
-		 */
-		if (!got_lock || (uvn->u_flags & UVM_VNODE_BLOCKED) != 0) {
-			if (got_lock)
-				simple_unlock(&uvn->u_obj.vmobjlock);
-			continue;		/* skip it */
-		}
-		
-		/*
-		 * gain reference.   watch out for persisting uvns (need to
-		 * regain vnode REF).
-		 */
-		if (uvn->u_obj.uo_refs == 0)
-			VREF(vp);
-		uvn->u_obj.uo_refs++;
-		simple_unlock(&uvn->u_obj.vmobjlock);
-
-		/*
-		 * got it!
-		 */
-		SIMPLEQ_INSERT_HEAD(&uvn_sync_q, uvn, u_syncq);
-	}
-	simple_unlock(&uvn_wl_lock);
+	off_t off;
+	size_t len;
+{
+        void *win;
 
-	/*
-	 * step 3: we now have a list of uvn's that may need cleaning.
-	 * we are holding the uvn_sync_lock, but have dropped the uvn_wl_lock
-	 * (so we can now safely lock uvn's again).
-	 */
+        /*
+         * XXXUBC invent kzero() and use it
+         */
 
-	for (uvn = uvn_sync_q.sqh_first ; uvn ; uvn = uvn->u_syncq.sqe_next) {
-		simple_lock(&uvn->u_obj.vmobjlock);
-#ifdef DEBUG
-		if (uvn->u_flags & UVM_VNODE_DYING) {
-			printf("uvm_vnp_sync: dying vnode on sync list\n");
-		}
-#endif
-		uvn_flush(&uvn->u_obj, 0, 0,
-		    PGO_CLEANIT|PGO_ALLPAGES|PGO_DOACTCLUST);
+        while (len) {
+                vsize_t bytelen = len;
 
-		/*
-		 * if we have the only reference and we just cleaned the uvn,
-		 * then we can pull it out of the UVM_VNODE_WRITEABLE state
-		 * thus allowing us to avoid thinking about flushing it again
-		 * on later sync ops.
-		 */
-		if (uvn->u_obj.uo_refs == 1 &&
-		    (uvn->u_flags & UVM_VNODE_WRITEABLE)) {
-			LIST_REMOVE(uvn, u_wlist);
-			uvn->u_flags &= ~UVM_VNODE_WRITEABLE;
-		}
-
-		simple_unlock(&uvn->u_obj.vmobjlock);
+                win = ubc_alloc(&vp->v_uvm.u_obj, off, &bytelen, UBC_WRITE);
+                memset(win, 0, bytelen);
+                ubc_release(win, 0);
 
-		/* now drop our reference to the uvn */
-		uvn_detach(&uvn->u_obj);
-	}
-
-	/*
-	 * done!  release sync lock
-	 */
-	lockmgr(&uvn_sync_lock, LK_RELEASE, (void *)0, curproc);
+                off += bytelen;
+                len -= bytelen;
+        }
 }
diff --git a/sys/uvm/uvm_vnode.h b/sys/uvm/uvm_vnode.h
index 29efe4d2ac4..ce853189207 100644
--- a/sys/uvm/uvm_vnode.h
+++ b/sys/uvm/uvm_vnode.h
@@ -1,4 +1,4 @@
-/*	$OpenBSD: uvm_vnode.h,v 1.8 2001/08/06 14:03:05 art Exp $	*/
+/*	$OpenBSD: uvm_vnode.h,v 1.9 2001/11/27 05:27:12 art Exp $	*/
 /*	$NetBSD: uvm_vnode.h,v 1.9 2000/03/26 20:54:48 kleink Exp $	*/
 
 /*
@@ -55,56 +55,6 @@ struct uvm_vnode {
 	int u_flags;			/* flags */
 	int u_nio;			/* number of running I/O requests */
 	voff_t u_size;			/* size of object */
-
-	/* the following entry is locked by uvn_wl_lock */
-	LIST_ENTRY(uvm_vnode) u_wlist;	/* list of writeable vnode objects */
-
-	/* the following entry is locked by uvn_sync_lock */
-	SIMPLEQ_ENTRY(uvm_vnode) u_syncq; /* vnode objects due for a "sync" */
 };
 
-/*
- * u_flags values
- */
-#define UVM_VNODE_VALID		0x001	/* we are attached to the vnode */
-#define UVM_VNODE_CANPERSIST	0x002	/* we can persist after ref == 0 */
-#define UVM_VNODE_ALOCK		0x004	/* uvn_attach is locked out */
-#define UVM_VNODE_DYING		0x008	/* final detach/terminate in 
-					   progress */
-#define UVM_VNODE_RELKILL	0x010	/* uvn should be killed by releasepg
-					   when final i/o is done */
-#define UVM_VNODE_WANTED	0x020	/* someone is waiting for alock,
-					   dying, or relkill to clear */
-#define UVM_VNODE_VNISLOCKED	0x040	/* underlying vnode struct is locked
-					   (valid when DYING is true) */
-#define UVM_VNODE_IOSYNC	0x080	/* I/O sync in progress ... setter
-					   sleeps on &uvn->u_nio */
-#define UVM_VNODE_IOSYNCWANTED	0x100	/* a process is waiting for the
-					   i/o sync to clear so it can do
-					   i/o */
-#define UVM_VNODE_WRITEABLE	0x200	/* uvn has pages that are writeable */
-
-/*
- * UVM_VNODE_BLOCKED: any condition that should new processes from
- * touching the vnode [set WANTED and sleep to wait for it to clear]
- */
-#define UVM_VNODE_BLOCKED (UVM_VNODE_ALOCK|UVM_VNODE_DYING|UVM_VNODE_RELKILL)
-
-#ifdef _KERNEL
-
-/*
- * prototypes
- */
-
-#if 0
-/*
- * moved uvn_attach to uvm_extern.h because uvm_vnode.h is needed to
- * include sys/vnode.h, and files that include sys/vnode.h don't know
- * what a vm_prot_t is.
- */
-struct uvm_object  *uvn_attach __P((void *, vm_prot_t));
-#endif
-
-#endif /* _KERNEL */
-
 #endif /* _UVM_UVM_VNODE_H_ */