3 files changed, 804 insertions, 232 deletions

diff --git a/sys/miscfs/devfs/devfs_tree.c b/sys/miscfs/devfs/devfs_tree.c
index ffcb243d72e0..c43a01109d29 100644
--- a/sys/miscfs/devfs/devfs_tree.c
+++ b/sys/miscfs/devfs/devfs_tree.c
@@ -24,7 +24,7 @@
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  * 
- *	$Id: devfs_tree.c,v 1.54 1998/06/21 14:53:20 bde Exp $
+ *	$Id: devfs_tree.c,v 1.55 1998/07/04 22:30:22 julian Exp $
  */
 
 
@@ -498,7 +498,7 @@ dev_add_node(int entrytype, union typeinfo *by, dn_p proto,
 		 * Make sure it has DEVICE type ops
 		 * and device specific fields are correct
 		 */
-		dnp->ops = &dev_spec_vnodeop_p;
+		dnp->ops = &devfs_spec_vnodeop_p;
 		dnp->by.Bdev.bdevsw = by->Bdev.bdevsw;
 		dnp->by.Bdev.dev = by->Bdev.dev;
 		break;
@@ -507,7 +507,7 @@ dev_add_node(int entrytype, union typeinfo *by, dn_p proto,
 		 * Make sure it has DEVICE type ops
 		 * and device specific fields are correct
 		 */
-		dnp->ops = &dev_spec_vnodeop_p;
+		dnp->ops = &devfs_spec_vnodeop_p;
 		dnp->by.Cdev.cdevsw = by->Cdev.cdevsw;
 		dnp->by.Cdev.dev = by->Cdev.dev;
 		break;
diff --git a/sys/miscfs/devfs/devfs_vnops.c b/sys/miscfs/devfs/devfs_vnops.c
index 92232aa8ed90..a916f9c8a5bd 100644
--- a/sys/miscfs/devfs/devfs_vnops.c
+++ b/sys/miscfs/devfs/devfs_vnops.c
@@ -23,7 +23,7 @@
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  * 
- *	$Id: devfs_vnops.c,v 1.55 1998/05/07 04:58:32 msmith Exp $
+ *	$Id: devfs_vnops.c,v 1.56 1998/06/10 06:34:54 peter Exp $
  */
 
 
@@ -31,14 +31,28 @@
 #include <sys/systm.h>
 #include <sys/namei.h>
 #include <sys/kernel.h>
+#include <sys/fcntl.h>
+#include <sys/conf.h>
+#include <sys/disklabel.h>
 #include <sys/lock.h>
 #include <sys/stat.h>
+#include <sys/mount.h>
 #include <sys/proc.h>
 #include <sys/time.h>
 #include <sys/vnode.h>
 #include <miscfs/specfs/specdev.h>/* definitions of spec functions we use */
 #include <sys/dirent.h>
 #include <miscfs/devfs/devfsdefs.h>
+#include <sys/vmmeter.h>                                                        
+
+#include <vm/vm.h>
+#include <vm/vm_prot.h>
+#include <vm/vm_object.h>
+#include <vm/vm_page.h>
+#include <vm/vm_pager.h>
+#include <vm/vnode_pager.h>
+#include <vm/vm_extern.h>
+
 
 /*
  * Insert description here
@@ -299,72 +313,8 @@ DBPRINT(("GOT\n"));
 }
 
 /*
- *  Create a regular file.
- *  We must also free the pathname buffer pointed at
- *  by ndp->ni_pnbuf, always on error, or only if the
- *  SAVESTART bit in ni_nameiop is clear on success.
- * <still true in 4.4?>
- *
- *  Always  error... no such thing in this FS
  */
 
-#ifdef notyet
-static int
-devfs_create(struct vop_mknod_args  *ap)
-        /*struct vop_mknod_args  {
-                struct vnode *a_dvp;
-                struct vnode **a_vpp;
-                struct componentname *a_cnp;
-                struct vattr *a_vap;
-        } */
-{
-DBPRINT(("create\n"));
-        return EINVAL;
-}
-
-static int
-devfs_mknod( struct vop_mknod_args *ap)
-        /*struct vop_mknod_args  {
-                struct vnode *a_dvp;
-                struct vnode **a_vpp;
-                struct componentname *a_cnp;
-                struct vattr *a_vap;
-        } */
-{
-        int error;
-
-
-DBPRINT(("mknod\n"));
-	switch (ap->a_vap->va_type) {
-	case VDIR:
-#ifdef VNSLEAZE
-		return devfs_mkdir(ap);
-		/*XXX check for WILLRELE settings (different)*/
-#else
-		error = VOP_MKDIR(ap->a_dvp, ap->a_vpp, ap->a_cnp, ap->a_vap);
-#endif
-		break;
-
-/*
- *  devfs_create() sets ndp->ni_vp.
- */
-	case VREG:
-#ifdef VNSLEAZE
-		return devfs_create(ap);
-		/*XXX check for WILLRELE settings (different)*/
-#else
-		error = VOP_CREATE(ap->a_dvp, ap->a_vpp, ap->a_cnp, ap->a_vap);
-#endif
-		break;
-
-	default:
-		return EINVAL;
-		break;
-	}
-	return error;
-}
-#endif /* notyet */
-
 static int
 devfs_access(struct vop_access_args *ap)
         /*struct vop_access_args  {
@@ -638,7 +588,7 @@ cando:
 
 
 static int
-devfs_read(struct vop_read_args *ap)
+devfs_xread(struct vop_read_args *ap)
         /*struct vop_read_args {
                 struct vnode *a_vp;
                 struct uio *a_uio;
@@ -665,9 +615,7 @@ DBPRINT(("read\n"));
 					NULL,NULL,NULL);
 	case VCHR:
 	case VBLK:
-		error = VOCALL(spec_vnodeop_p, VOFFSET(vop_read), ap);
-		getnanotime(&(file_node->atime));
-		return(error);
+		panic("devfs:  vnode methods");
 
 	default:
 		panic("devfs_read(): bad file type");
@@ -679,7 +627,7 @@ DBPRINT(("read\n"));
  *  Write data to a file or directory.
  */
 static int
-devfs_write(struct vop_write_args *ap)
+devfs_xwrite(struct vop_write_args *ap)
         /*struct vop_write_args  {
                 struct vnode *a_vp;
                 struct uio *a_uio;
@@ -690,14 +638,6 @@ devfs_write(struct vop_write_args *ap)
 	dn_p	file_node;
 	int	error;
 
-DBPRINT(("write\n"));
-	if (error = devfs_vntodn(ap->a_vp,&file_node))
-	{
-		printf("devfs_vntodn returned %d ",error);
-		return error;
-	}
-
-
 	switch (ap->a_vp->v_type) {
 	case VREG:
 		return(EINVAL);
@@ -705,49 +645,12 @@ DBPRINT(("write\n"));
 		return(EISDIR);
 	case VCHR:
 	case VBLK:
-		error = VOCALL(spec_vnodeop_p, VOFFSET(vop_write), ap);
-		getnanotime(&(file_node->mtime));
-		return(error);
-
+		panic("devfs:  vnode methods");
 	default:
 		panic("devfs_write(): bad file type");
-		break;
 	}
 }
 
-/* presently not called from devices anyhow */
-#ifdef notyet
-static int
-devfs_ioctl(struct vop_ioctl_args *ap)
-        /*struct vop_ioctl_args  {
-                struct vnode *a_vp;
-                int  a_command;
-                caddr_t  a_data;
-                int  a_fflag;
-                struct ucred *a_cred;
-                struct proc *a_p;
-        } */ 
-{
-DBPRINT(("ioctl\n"));
-	return ENOTTY;
-}
-
-static int
-devfs_select(struct vop_select_args *ap)
-        /*struct vop_select_args {
-                struct vnode *a_vp;
-                int  a_which;
-                int  a_fflags;
-                struct ucred *a_cred;
-                struct proc *a_p;
-        } */
-{
-DBPRINT(("select\n"));
-	return 1;		/* filesystems never block? */
-}
-
-
-#endif /* notyet */
 
 static int
 devfs_remove(struct vop_remove_args *ap)
@@ -1154,34 +1057,6 @@ out:
 	return (error);
 }
 
-#ifdef notyet
-static int
-devfs_mkdir(struct vop_mkdir_args *ap)
-        /*struct vop_mkdir_args {
-                struct vnode *a_dvp;
-                struct vnode **a_vpp;
-                struct componentname *a_cnp;
-                struct vattr *a_vap;
-        } */ 
-{
-DBPRINT(("mkdir\n"));
-	vput(ap->a_dvp);
-	return EINVAL;
-}
-
-static int
-devfs_rmdir(struct vop_rmdir_args *ap)
-        /*struct vop_rmdir_args {
-                struct vnode *a_dvp;
-                struct vnode *a_vp;
-                struct componentname *a_cnp;
-        } */ 
-{
-DBPRINT(("rmdir\n"));
-	return (0);
-}
-#endif
-
 static int
 devfs_symlink(struct vop_symlink_args *ap)
         /*struct vop_symlink_args {
@@ -1367,70 +1242,6 @@ DBPRINT(("abortop\n"));
 }
 #endif /* notyet */
 
-static int
-devfs_inactive(struct vop_inactive_args *ap)
-        /*struct vop_inactive_args {
-                struct vnode *a_vp;
-        } */
-{
-DBPRINT(("inactive\n"));
-	return 0;
-}
-
-#ifdef notyet
-static int
-devfs_lock(struct vop_lock_args *ap)
-{
-DBPRINT(("lock\n"));
-	return 0;
-}
-
-static int
-devfs_unlock( struct vop_unlock_args *ap)
-{
-DBPRINT(("unlock\n"));
-	return 0;
-}
-
-static int
-devfs_islocked(struct vop_islocked_args *ap)
-        /*struct vop_islocked_args {
-                struct vnode *a_vp;
-        } */
-{
-DBPRINT(("islocked\n"));
-	return 0;
-}
-
-static int
-devfs_bmap(struct vop_bmap_args *ap)
-        /*struct vop_bmap_args {
-                struct vnode *a_vp;
-                daddr_t  a_bn;
-                struct vnode **a_vpp;
-                daddr_t *a_bnp;
-                int *a_runp;
-                int *a_runb;
-        } */
-{
-DBPRINT(("bmap\n"));
-		return 0;
-}
-
-static int
-devfs_advlock(struct vop_advlock_args *ap)
-        /*struct vop_advlock_args {
-                struct vnode *a_vp;
-                caddr_t  a_id;
-                int  a_op;
-                struct flock *a_fl;
-                int  a_flags;
-        } */
-{
-DBPRINT(("advlock\n"));
-	return EINVAL;		/* we don't do locking yet		*/
-}
-#endif /* notyet */
 
 static int
 devfs_reclaim(struct vop_reclaim_args *ap)
@@ -1484,17 +1295,6 @@ devfs_enotsupp(void *junk)
 	return (EOPNOTSUPP);
 }
 
-/*
- * /devfs "should never get here" operation
- */
-static int
-devfs_badop(void *junk)
-{
-
-	panic("devfs: bad op");
-	/* NOTREACHED */
-}
-
 /*proto*/
 void
 devfs_dropvnode(dn_p dnp)
@@ -1518,6 +1318,754 @@ devfs_dropvnode(dn_p dnp)
 	dnp->vn = NULL; /* be pedantic about this */
 }
 
+/* struct vnode *speclisth[SPECHSZ];*/ /* till specfs goes away */
+
+/*
+ * Open a special file.
+	struct vop_open_args {
+		struct vnode *a_vp;
+		int  a_mode;
+		struct ucred *a_cred;
+		struct proc *a_p;
+	} *ap;
+ */
+/* ARGSUSED */
+static int
+devfs_open( struct vop_open_args *ap)
+{
+	struct proc *p = ap->a_p;
+	struct vnode *bvp, *vp = ap->a_vp;
+	dev_t bdev, dev = (dev_t)vp->v_rdev;
+	int error;
+	dn_p	dnp;
+
+	if (error = devfs_vntodn(vp,&dnp))
+		return error;
+
+	switch (vp->v_type) {
+	case VCHR:
+		VOP_UNLOCK(vp, 0, p);
+		error = (*dnp->by.Cdev.cdevsw->d_open)(
+					dnp->by.Cdev.dev,
+					ap->a_mode,
+					S_IFCHR,
+					p);
+		vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
+		return (error);
+
+	case VBLK:
+		error = (*dnp->by.Bdev.bdevsw->d_open)(
+					dnp->by.Bdev.dev,
+					ap->a_mode,
+					S_IFBLK,
+					p);
+	}
+	return (error);
+}
+
+/*
+ * Vnode op for read
+	struct vop_read_args {
+		struct vnode *a_vp;
+		struct uio *a_uio;
+		int  a_ioflag;
+		struct ucred *a_cred;
+	} 
+
+ */
+/* ARGSUSED */
+static int
+devfs_read( struct vop_read_args *ap)
+{
+	register struct vnode *vp = ap->a_vp;
+	register struct uio *uio = ap->a_uio;
+ 	struct proc *p = uio->uio_procp;
+	struct buf *bp;
+	daddr_t bn, nextbn;
+	long bsize, bscale;
+	struct partinfo dpart;
+	int n, on, majordev;
+	d_ioctl_t *ioctl;
+	int error = 0;
+	dev_t dev;
+	dn_p	dnp;
+
+	if (error = devfs_vntodn(vp,&dnp))
+		return error;
+
+
+#ifdef DIAGNOSTIC
+	if (uio->uio_rw != UIO_READ)
+		panic("devfs_read mode");
+	if (uio->uio_segflg == UIO_USERSPACE && uio->uio_procp != curproc)
+		panic("devfs_read proc");
+#endif
+	if (uio->uio_resid == 0)
+		return (0);
+
+	switch (vp->v_type) {
+
+	case VCHR:
+		VOP_UNLOCK(vp, 0, p);
+		error = (*dnp->by.Cdev.cdevsw->d_read)
+			(dnp->by.Cdev.dev, uio, ap->a_ioflag);
+		vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
+		return (error);
+
+	case VBLK:
+		if (uio->uio_offset < 0)
+			return (EINVAL);
+		bsize = BLKDEV_IOSIZE;
+		dev = dnp->by.Bdev.dev;
+		/*
+		 * This is a hack!
+		 */
+		if ( (ioctl = dnp->by.Bdev.bdevsw->d_ioctl) != NULL &&
+		    (*ioctl)(dev, DIOCGPART, (caddr_t)&dpart, FREAD, p) == 0 &&
+		    dpart.part->p_fstype == FS_BSDFFS &&
+		    dpart.part->p_frag != 0 && dpart.part->p_fsize != 0)
+			bsize = dpart.part->p_frag * dpart.part->p_fsize;
+		bscale = btodb(bsize);
+		/* 
+		 * Get buffers with this data from the buffer cache.
+		 * If it's not there the strategy() entrypoint will be called.
+		 * We may do this in several chunks.
+		 */
+		do {
+			bn = btodb(uio->uio_offset) & ~(bscale - 1);
+			on = uio->uio_offset % bsize;
+			n = min((unsigned)(bsize - on), uio->uio_resid);
+			if (vp->v_lastr + bscale == bn) {
+				nextbn = bn + bscale;
+				error = breadn(vp, bn, (int)bsize, &nextbn,
+					(int *)&bsize, 1, NOCRED, &bp);
+			} else
+				error = bread(vp, bn, (int)bsize, NOCRED, &bp);
+			vp->v_lastr = bn;
+			n = min(n, bsize - bp->b_resid);
+			if (error) {
+				brelse(bp);
+				return (error);
+			}
+			/* 
+			 * Copy it to the user's space
+			 */
+			error = uiomove((char *)bp->b_data + on, n, uio);
+			brelse(bp);
+		} while (error == 0 && uio->uio_resid > 0 && n != 0);
+		return (error);
+
+	default:
+		panic("devfs_read type");
+	}
+	/* NOTREACHED */
+}
+
+/*
+ * Vnode op for write
+	struct vop_write_args  {
+		struct vnode *a_vp;
+		struct uio *a_uio;
+		int  a_ioflag;
+		struct ucred *a_cred;
+	}
+ */
+/* ARGSUSED */
+static int
+devfs_write( struct vop_write_args *ap)
+{
+	register struct vnode *vp = ap->a_vp;
+	register struct uio *uio = ap->a_uio;
+	struct proc *p = uio->uio_procp;
+	struct buf *bp;
+	daddr_t bn;
+	int bsize, blkmask;
+	struct partinfo dpart;
+	register int n, on;
+	int error = 0;
+	dn_p	dnp;
+
+	if (error = devfs_vntodn(vp,&dnp))
+		return error;
+
+
+#ifdef DIAGNOSTIC
+	if (uio->uio_rw != UIO_WRITE)
+		panic("devfs_write mode");
+	if (uio->uio_segflg == UIO_USERSPACE && uio->uio_procp != curproc)
+		panic("devfs_write proc");
+#endif
+
+	switch (vp->v_type) {
+
+	case VCHR:
+		VOP_UNLOCK(vp, 0, p);
+		error = (*dnp->by.Cdev.cdevsw->d_write)
+			(dnp->by.Cdev.dev, uio, ap->a_ioflag);
+		vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
+		return (error);
+
+	case VBLK:
+		if (uio->uio_resid == 0)
+			return (0);
+		if (uio->uio_offset < 0)
+			return (EINVAL);
+		bsize = BLKDEV_IOSIZE;
+		if ((dnp->by.Bdev.bdevsw->d_ioctl != NULL)
+		&& ((*dnp->by.Bdev.bdevsw->d_ioctl)(dnp->by.Bdev.dev, DIOCGPART,
+					(caddr_t)&dpart, FREAD, p) == 0)
+		&& (dpart.part->p_fstype == FS_BSDFFS)
+		&& (dpart.part->p_frag != 0)
+		&& (dpart.part->p_fsize != 0)) {
+			bsize = dpart.part->p_frag * dpart.part->p_fsize;
+		}
+		blkmask = btodb(bsize) - 1;
+		do {
+			bn = btodb(uio->uio_offset) & ~blkmask;
+			on = uio->uio_offset % bsize;
+			n = min((unsigned)(bsize - on), uio->uio_resid);
+			if (n == bsize)
+				bp = getblk(vp, bn, bsize, 0, 0);
+			else
+				error = bread(vp, bn, bsize, NOCRED, &bp);
+			n = min(n, bsize - bp->b_resid);
+			if (error) {
+				brelse(bp);
+				return (error);
+			}
+			error = uiomove((char *)bp->b_data + on, n, uio);
+			if (n + on == bsize)
+				bawrite(bp);
+			else
+				bdwrite(bp);
+		} while (error == 0 && uio->uio_resid > 0 && n != 0);
+		return (error);
+
+	default:
+		panic("devfs_write type");
+	}
+	/* NOTREACHED */
+}
+
+/*
+ * Device ioctl operation.
+	struct vop_ioctl_args {
+		struct vnode *a_vp;
+		int  a_command;
+		caddr_t  a_data;
+		int  a_fflag;
+		struct ucred *a_cred;
+		struct proc *a_p;
+	}
+ */
+/* ARGSUSED */
+static int
+devfs_ioctl(struct vop_ioctl_args *ap)
+{
+	dn_p	dnp;
+	int	error;
+
+	if (error = devfs_vntodn(ap->a_vp,&dnp))
+		return error;
+
+
+	switch (ap->a_vp->v_type) {
+
+	case VCHR:
+		return ((*dnp->by.Cdev.cdevsw->d_ioctl)(dnp->by.Cdev.dev,
+					ap->a_command,
+					ap->a_data,
+					ap->a_fflag,
+					ap->a_p));
+	case VBLK:
+		return ((*dnp->by.Bdev.bdevsw->d_ioctl)(dnp->by.Bdev.dev,
+					ap->a_command,
+					ap->a_data,
+					ap->a_fflag,
+					ap->a_p));
+	default:
+		panic("devfs_ioctl");
+		/* NOTREACHED */
+	}
+}
+
+/*
+	struct vop_poll_args {
+		struct vnode *a_vp;
+		int  a_events;
+		struct ucred *a_cred;
+		struct proc *a_p;
+	} *ap;
+*/
+/* ARGSUSED */
+static int
+devfs_poll(struct vop_poll_args *ap)
+{
+	dn_p	dnp;
+	int	error;
+
+	if (error = devfs_vntodn(ap->a_vp,&dnp))
+		return error;
+
+
+	switch (ap->a_vp->v_type) {
+
+	case VCHR:
+		return (*dnp->by.Cdev.cdevsw->d_poll)(dnp->by.Cdev.dev,
+					ap->a_events,
+					ap->a_p);
+	default:
+		return (vop_defaultop((struct vop_generic_args *)ap));
+
+	}
+}
+/*
+ * Synch buffers associated with a block device
+	struct vop_fsync_args {
+		struct vnode *a_vp;
+		struct ucred *a_cred;
+		int  a_waitfor;
+		struct proc *a_p;
+	} 
+ */
+/* ARGSUSED */
+static int
+devfs_fsync(struct vop_fsync_args *ap)
+{
+	register struct vnode *vp = ap->a_vp;
+	register struct buf *bp;
+	struct buf *nbp;
+	int s;
+	dn_p	dnp;
+	int	error;
+
+	if (error = devfs_vntodn(vp,&dnp))
+		return error;
+
+
+	if (vp->v_type == VCHR)
+		return (0);
+	/*
+	 * Flush all dirty buffers associated with a block device.
+	 */
+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))
+			continue;
+		if ((bp->b_flags & B_DELWRI) == 0)
+			panic("devfs_fsync: not dirty");
+		if ((vp->v_flag & VOBJBUF) && (bp->b_flags & B_CLUSTEROK)) {
+			vfs_bio_awrite(bp);
+			splx(s);
+		} else {
+			bremfree(bp);
+			bp->b_flags |= B_BUSY;
+			splx(s);
+			bawrite(bp);
+		}
+		goto loop;
+	}
+	if (ap->a_waitfor == MNT_WAIT) {
+		while (vp->v_numoutput) {
+			vp->v_flag |= VBWAIT;
+			(void) tsleep((caddr_t)&vp->v_numoutput, PRIBIO + 1, "spfsyn", 0);
+		}
+#ifdef DIAGNOSTIC
+		if (vp->v_dirtyblkhd.lh_first) {
+			vprint("devfs_fsync: dirty", vp);
+			splx(s);
+			goto loop;
+		}
+#endif
+	}
+	splx(s);
+	return (0);
+}
+/*
+ *
+ *	struct vop_inactive_args {
+ *		struct vnode *a_vp;
+ *		struct proc *a_p;
+ *	} 
+ */
+
+static int
+devfs_inactive(struct vop_inactive_args *ap)
+{
+
+	VOP_UNLOCK(ap->a_vp, 0, ap->a_p);
+	return (0);
+}
+
+/*
+ * Just call the device strategy routine
+	struct vop_strategy_args {
+		struct vnode *a_vp;
+		struct buf *a_bp;
+	}
+ */
+static int
+devfs_strategy(struct vop_strategy_args *ap)
+{
+	struct buf *bp = ap->a_bp;
+	dn_p	dnp;
+	int	error;
+
+	if ((ap->a_vp->v_type != VCHR)
+	&&  (ap->a_vp->v_type != VBLK))
+		panic ("devfs_strat:badvnode type");
+	if (error = devfs_vntodn(ap->a_vp,&dnp))
+		return error;
+
+
+	if (((bp->b_flags & B_READ) == 0) &&
+		(LIST_FIRST(&bp->b_dep)) != NULL && bioops.io_start)
+		(*bioops.io_start)(bp);
+	switch (ap->a_vp->v_type) {
+	case VCHR:
+		(*dnp->by.Cdev.cdevsw->d_strategy)(bp);
+	case VBLK:
+		(*dnp->by.Bdev.bdevsw->d_strategy)(bp);
+	}
+	return (0);
+}
+
+/*
+ * This is a noop, simply returning what one has been given.
+	struct vop_bmap_args  {
+		struct vnode *a_vp;
+		daddr_t  a_bn;
+		struct vnode **a_vpp;
+		daddr_t *a_bnp;
+		int *a_runp;
+		int *a_runb;
+	}
+ */
+static int
+devfs_bmap(struct vop_bmap_args *ap)
+{
+
+	if (ap->a_vpp != NULL)
+		*ap->a_vpp = ap->a_vp;
+	if (ap->a_bnp != NULL)
+		*ap->a_bnp = ap->a_bn;
+	if (ap->a_runp != NULL)
+		*ap->a_runp = 0;
+	if (ap->a_runb != NULL)
+		*ap->a_runb = 0;
+	return (0);
+}
+
+/*
+ * Device close routine
+	struct vop_close_args {
+		struct vnode *a_vp;
+		int  a_fflag;
+		struct ucred *a_cred;
+		struct proc *a_p;
+	}
+ */
+/* ARGSUSED */
+static int
+devfs_close(struct vop_close_args *ap)
+{
+	register struct vnode *vp = ap->a_vp;
+	struct proc *p = ap->a_p;
+	dev_t dev = vp->v_rdev;
+	d_close_t *devclose;
+	int mode, error;
+	dn_p	dnp;
+
+	if (error = devfs_vntodn(vp,&dnp))
+		return error;
+
+
+	switch (vp->v_type) {
+
+	case VCHR:
+		/*
+		 * Hack: a tty device that is a controlling terminal
+		 * has a reference from the session structure.
+		 * We cannot easily tell that a character device is
+		 * a controlling terminal, unless it is the closing
+		 * process' controlling terminal.  In that case,
+		 * if the reference count is 2 (this last descriptor
+		 * plus the session), release the reference from the session.
+		 */
+		if (vcount(vp) == 2 && ap->a_p &&
+		    (vp->v_flag & VXLOCK) == 0 &&
+		    vp == ap->a_p->p_session->s_ttyvp) {
+			vrele(vp);
+			ap->a_p->p_session->s_ttyvp = NULL;
+		}
+		/*
+		 * If the vnode is locked, then we are in the midst
+		 * of forcably closing the device, otherwise we only
+		 * close on last reference.
+		 */
+		if (vcount(vp) > 1 && (vp->v_flag & VXLOCK) == 0)
+			return (0);
+		return ((*dnp->by.Cdev.cdevsw->d_close)(dnp->by.Cdev.dev,
+						ap->a_fflag,
+						S_IFCHR,
+						ap->a_p));
+		break;
+
+	case VBLK:
+		/*
+		 * On last close of a block device (that isn't mounted)
+		 * we must invalidate any in core blocks, so that
+		 * we can, for instance, change floppy disks.
+		 */
+		vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, ap->a_p);
+		error = vinvalbuf(vp, V_SAVE, ap->a_cred, ap->a_p, 0, 0);
+		VOP_UNLOCK(vp, 0, ap->a_p);
+		if (error)
+			return (error);
+
+		/*
+		 * We do not want to really close the device if it
+		 * is still in use unless we are trying to close it
+		 * forcibly. Since every use (buffer, vnode, swap, cmap)
+		 * holds a reference to the vnode, and because we mark
+		 * any other vnodes that alias this device, when the
+		 * sum of the reference counts on all the aliased
+		 * vnodes descends to one, we are on last close.
+		 */
+		if ((vcount(vp) > 1) && (vp->v_flag & VXLOCK) == 0)
+			return (0);
+
+		return ((*dnp->by.Bdev.bdevsw->d_close)(dnp->by.Bdev.dev,
+						ap->a_fflag,
+						S_IFBLK,
+						ap->a_p));
+
+	default:
+		panic("devfs_close: not special");
+	}
+}
+
+/*
+ * Print out the contents of a special device vnode.
+	struct vop_print_args {
+		struct vnode *a_vp;
+	}
+ */
+
+/*
+ * Special device advisory byte-level locks.
+	struct vop_advlock_args {
+		struct vnode *a_vp;
+		caddr_t  a_id;
+		int  a_op;
+		struct flock *a_fl;
+		int  a_flags;
+	}
+ */
+/* ARGSUSED */
+static int
+devfs_advlock(struct vop_advlock_args *ap)
+{
+
+	return (ap->a_flags & F_FLOCK ? EOPNOTSUPP : EINVAL);
+}
+
+/*
+ * Special device bad operation
+ */
+static int
+devfs_badop(void)
+{
+
+	panic("devfs_badop called");
+	/* NOTREACHED */
+}
+
+static void
+devfs_getpages_iodone(struct buf *bp)
+{
+
+	bp->b_flags |= B_DONE;
+	wakeup(bp);
+}
+
+static int
+devfs_getpages(struct vop_getpages_args *ap)
+{
+	vm_offset_t kva;
+	int error;
+	int i, pcount, size, s;
+	daddr_t blkno;
+	struct buf *bp;
+	vm_page_t m;
+	vm_ooffset_t offset;
+	int toff, nextoff, nread;
+	struct vnode *vp = ap->a_vp;
+	int blksiz;
+	int gotreqpage;
+
+	error = 0;
+	pcount = round_page(ap->a_count) / PAGE_SIZE;
+
+	/*
+	 * Calculate the offset of the transfer.
+	 */
+	offset = IDX_TO_OFF(ap->a_m[0]->pindex) + ap->a_offset;
+
+	/* XXX sanity check before we go into details. */
+	/* XXX limits should be defined elsewhere. */
+#define	DADDR_T_BIT	32
+#define	OFFSET_MAX	((1LL << (DADDR_T_BIT + DEV_BSHIFT)) - 1)
+	if (offset < 0 || offset > OFFSET_MAX) {
+		/* XXX still no %q in kernel. */
+		printf("devfs_getpages: preposterous offset 0x%x%08x\n",
+		       (u_int)((u_quad_t)offset >> 32),
+		       (u_int)(offset & 0xffffffff));
+		return (VM_PAGER_ERROR);
+	}
+
+	blkno = btodb(offset);
+
+	/*
+	 * Round up physical size for real devices, use the
+	 * fundamental blocksize of the fs if possible.
+	 */
+	if (vp && vp->v_mount) {
+		if (vp->v_type != VBLK) {
+			vprint("Non VBLK", vp);
+		}
+		blksiz = vp->v_mount->mnt_stat.f_bsize;
+		if (blksiz < DEV_BSIZE) {
+			blksiz = DEV_BSIZE;
+		}
+	}
+	else
+		blksiz = DEV_BSIZE;
+	size = (ap->a_count + blksiz - 1) & ~(blksiz - 1);
+
+	bp = getpbuf();
+	kva = (vm_offset_t)bp->b_data;
+
+	/*
+	 * Map the pages to be read into the kva.
+	 */
+	pmap_qenter(kva, ap->a_m, pcount);
+
+	/* Build a minimal buffer header. */
+	bp->b_flags = B_BUSY | B_READ | B_CALL;
+	bp->b_iodone = devfs_getpages_iodone;
+
+	/* B_PHYS is not set, but it is nice to fill this in. */
+	bp->b_proc = curproc;
+	bp->b_rcred = bp->b_wcred = bp->b_proc->p_ucred;
+	if (bp->b_rcred != NOCRED)
+		crhold(bp->b_rcred);
+	if (bp->b_wcred != NOCRED)
+		crhold(bp->b_wcred);
+	bp->b_blkno = blkno;
+	bp->b_lblkno = blkno;
+	pbgetvp(ap->a_vp, bp);
+	bp->b_bcount = size;
+	bp->b_bufsize = size;
+	bp->b_resid = 0;
+
+	cnt.v_vnodein++;
+	cnt.v_vnodepgsin += pcount;
+
+	/* Do the input. */
+	VOP_STRATEGY(bp->b_vp, bp);
+
+	s = splbio();
+
+	/* We definitely need to be at splbio here. */
+	while ((bp->b_flags & B_DONE) == 0)
+		tsleep(bp, PVM, "spread", 0);
+
+	splx(s);
+
+	if ((bp->b_flags & B_ERROR) != 0) {
+		if (bp->b_error)
+			error = bp->b_error;
+		else
+			error = EIO;
+	}
+
+	nread = size - bp->b_resid;
+
+	if (nread < ap->a_count) {
+		bzero((caddr_t)kva + nread,
+			ap->a_count - nread);
+	}
+	pmap_qremove(kva, pcount);
+
+
+	gotreqpage = 0;
+	for (i = 0, toff = 0; i < pcount; i++, toff = nextoff) {
+		nextoff = toff + PAGE_SIZE;
+		m = ap->a_m[i];
+
+		m->flags &= ~PG_ZERO;
+
+		if (nextoff <= nread) {
+			m->valid = VM_PAGE_BITS_ALL;
+			m->dirty = 0;
+		} else if (toff < nread) {
+			int nvalid = ((nread + DEV_BSIZE - 1) - toff) & ~(DEV_BSIZE - 1);
+			vm_page_set_validclean(m, 0, nvalid);
+		} else {
+			m->valid = 0;
+			m->dirty = 0;
+		}
+
+		if (i != ap->a_reqpage) {
+			/*
+			 * Just in case someone was asking for this page we
+			 * now tell them that it is ok to use.
+			 */
+			if (!error || (m->valid == VM_PAGE_BITS_ALL)) {
+				if (m->valid) {
+					if (m->flags & PG_WANTED) {
+						vm_page_activate(m);
+					} else {
+						vm_page_deactivate(m);
+					}
+					PAGE_WAKEUP(m);
+				} else {
+					vm_page_free(m);
+				}
+			} else {
+				vm_page_free(m);
+			}
+		} else if (m->valid) {
+			gotreqpage = 1;
+		}
+	}
+	if (!gotreqpage) {
+		m = ap->a_m[ap->a_reqpage];
+#ifndef MAX_PERF
+		printf("devfs_getpages: I/O read failure: (error code=%d)\n", error);
+		printf("               size: %d, resid: %d, a_count: %d, valid: 0x%x\n",
+				size, bp->b_resid, ap->a_count, m->valid);
+		printf("               nread: %d, reqpage: %d, pindex: %d, pcount: %d\n",
+				nread, ap->a_reqpage, m->pindex, pcount);
+#endif
+		/*
+		 * Free the buffer header back to the swap buffer pool.
+		 */
+		relpbuf(bp);
+		return VM_PAGER_ERROR;
+	}
+	/*
+	 * Free the buffer header back to the swap buffer pool.
+	 */
+	relpbuf(bp);
+	return VM_PAGER_OK;
+}
+
+
+
 /* These are the operations used by directories etc in a devfs */
 
 vop_t **devfs_vnodeop_p;
@@ -1531,7 +2079,7 @@ static struct vnodeopv_entry_desc devfs_vnodeop_entries[] = {
 	{ &vop_lookup_desc,		(vop_t *) devfs_lookup },
 	{ &vop_pathconf_desc,		(vop_t *) vop_stdpathconf },
 	{ &vop_print_desc,		(vop_t *) devfs_print },
-	{ &vop_read_desc,		(vop_t *) devfs_read },
+	{ &vop_read_desc,		(vop_t *) devfs_xread },
 	{ &vop_readdir_desc,		(vop_t *) devfs_readdir },
 	{ &vop_readlink_desc,		(vop_t *) devfs_readlink },
 	{ &vop_reclaim_desc,		(vop_t *) devfs_reclaim },
@@ -1539,7 +2087,7 @@ static struct vnodeopv_entry_desc devfs_vnodeop_entries[] = {
 	{ &vop_rename_desc,		(vop_t *) devfs_rename },
 	{ &vop_setattr_desc,		(vop_t *) devfs_setattr },
 	{ &vop_symlink_desc,		(vop_t *) devfs_symlink },
-	{ &vop_write_desc,		(vop_t *) devfs_write },
+	{ &vop_write_desc,		(vop_t *) devfs_xwrite },
 	{ NULL, NULL }
 };
 static struct vnodeopv_desc devfs_vnodeop_opv_desc =
@@ -1549,20 +2097,44 @@ VNODEOP_SET(devfs_vnodeop_opv_desc);
 
 
 
-vop_t **dev_spec_vnodeop_p;
-static struct vnodeopv_entry_desc dev_spec_vnodeop_entries[] = {
-	{ &vop_default_desc,		(vop_t *) spec_vnoperate },
+vop_t **devfs_spec_vnodeop_p;
+static struct vnodeopv_entry_desc devfs_spec_vnodeop_entries[] = {
+	{ &vop_default_desc,		(vop_t *) vop_defaultop },
 	{ &vop_access_desc,		(vop_t *) devfs_access },
+	{ &vop_advlock_desc,		(vop_t *) devfs_advlock },
+	{ &vop_bmap_desc,		(vop_t *) devfs_bmap },
+	{ &vop_close_desc,		(vop_t *) devfs_close },
+	{ &vop_create_desc,		(vop_t *) devfs_badop },
+	{ &vop_fsync_desc,		(vop_t *) devfs_fsync },
 	{ &vop_getattr_desc,		(vop_t *) devfs_getattr },
+	{ &vop_getpages_desc,		(vop_t *) devfs_getpages },
+	{ &vop_inactive_desc,		(vop_t *) devfs_inactive },
+	{ &vop_ioctl_desc,		(vop_t *) devfs_ioctl },
+	{ &vop_lease_desc,		(vop_t *) vop_null },
+	{ &vop_link_desc,		(vop_t *) devfs_badop },
+	{ &vop_lookup_desc,		(vop_t *) devfs_lookup },
+	{ &vop_mkdir_desc,		(vop_t *) devfs_badop },
+	{ &vop_mknod_desc,		(vop_t *) devfs_badop },
+	{ &vop_open_desc,		(vop_t *) devfs_open },
+	{ &vop_pathconf_desc,		(vop_t *) vop_stdpathconf },
+	{ &vop_poll_desc,		(vop_t *) devfs_poll },
+	{ &vop_print_desc,		(vop_t *) devfs_print },
 	{ &vop_read_desc,		(vop_t *) devfs_read },
+	{ &vop_readdir_desc,		(vop_t *) devfs_badop },
+	{ &vop_readlink_desc,		(vop_t *) devfs_badop },
+	{ &vop_reallocblks_desc,	(vop_t *) devfs_badop },
 	{ &vop_reclaim_desc,		(vop_t *) devfs_reclaim },
+	{ &vop_remove_desc,		(vop_t *) devfs_badop },
+	{ &vop_rename_desc,		(vop_t *) devfs_badop },
+	{ &vop_rmdir_desc,		(vop_t *) devfs_badop },
 	{ &vop_setattr_desc,		(vop_t *) devfs_setattr },
+	{ &vop_strategy_desc,		(vop_t *) devfs_strategy },
 	{ &vop_symlink_desc,		(vop_t *) devfs_symlink },
 	{ &vop_write_desc,		(vop_t *) devfs_write },
 	{ NULL, NULL }
 };
-static struct vnodeopv_desc dev_spec_vnodeop_opv_desc =
-	{ &dev_spec_vnodeop_p, dev_spec_vnodeop_entries };
+static struct vnodeopv_desc devfs_spec_vnodeop_opv_desc =
+	{ &devfs_spec_vnodeop_p, devfs_spec_vnodeop_entries };
 
-VNODEOP_SET(dev_spec_vnodeop_opv_desc);
+VNODEOP_SET(devfs_spec_vnodeop_opv_desc);
 
diff --git a/sys/miscfs/devfs/devfsdefs.h b/sys/miscfs/devfs/devfsdefs.h
index cbde81df1593..76280dd449a9 100644
--- a/sys/miscfs/devfs/devfsdefs.h
+++ b/sys/miscfs/devfs/devfsdefs.h
@@ -23,7 +23,7 @@
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  * 
- * $Id: devfsdefs.h,v 1.14 1998/04/19 23:32:20 julian Exp $
+ * $Id: devfsdefs.h,v 1.15 1998/07/04 22:30:22 julian Exp $
  */
 #ifdef DEVFS_DEBUG
 #define DBPRINT(A) printf(A)
@@ -89,7 +89,7 @@
 
 
 extern vop_t **devfs_vnodeop_p;		/* our own vector array for dirs */
-extern vop_t **dev_spec_vnodeop_p;	/* our own vector array for devs */
+extern vop_t **devfs_spec_vnodeop_p;	/* our own vector array for devs */
 
 typedef struct dev_name *devnm_p;
 typedef	struct devnode	*dn_p;