- FDESC, FIFO, NULL, PORTAL, PROC, UMAP and UNION file

  systems were repo-copied from sys/miscfs to sys/fs.

- Renamed the following file systems and their modules:
  fdesc -> fdescfs, portal -> portalfs, union -> unionfs.

- Renamed corresponding kernel options:
  FDESC -> FDESCFS, PORTAL -> PORTALFS, UNION -> UNIONFS.

- Install header files for the above file systems.

- Removed bogus -I${.CURDIR}/../../sys CFLAGS from userland
  Makefiles.

117 files changed, 156 insertions, 14501 deletions

diff --git a/etc/mtree/BSD.include.dist b/etc/mtree/BSD.include.dist
index 2f6eeea..05a2ed1 100644
--- a/etc/mtree/BSD.include.dist
+++ b/etc/mtree/BSD.include.dist
@@ -20,8 +20,22 @@
         ..
     ..
     fs
+        fdescfs
+        ..
+        fifofs
+        ..
+        nullfs
+        ..
+        portalfs
+        ..
+        procfs
+        ..
         smbfs
         ..
+        umapfs
+        ..
+        unionfs
+        ..
     ..
     g++
         std
diff --git a/include/Makefile b/include/Makefile
index 0bf4116..bdeef56 100644
--- a/include/Makefile
+++ b/include/Makefile
@@ -44,8 +44,10 @@ LDIRS=	cam msdosfs net netatalk netatm netgraph netinet netinet6 \
 	sys vm
 
 LNOHEADERDIRS=	fs isofs ufs dev
-LSUBDIRS=	fs/smbfs isofs/cd9660 ufs/ffs ufs/mfs ufs/ufs \
-	cam/scsi dev/ppbus dev/usb dev/wi
+
+LSUBDIRS=	cam/scsi dev/ppbus dev/usb dev/wi \
+	fs/fdesc fs/fifofs fs/nullfs fs/portal fs/procfs fs/smbfs \
+	fs/umapfs fs/union isofs/cd9660 ufs/ffs ufs/mfs ufs/ufs
 
 # Define SHARED to indicate whether you want symbolic links to the system
 # source (``symlinks''), or a separate copy (``copies'').  ``symlinks'' is
diff --git a/sbin/mount_null/Makefile b/sbin/mount_null/Makefile
index 68b488d..3c50252 100644
--- a/sbin/mount_null/Makefile
+++ b/sbin/mount_null/Makefile
@@ -6,7 +6,7 @@ SRCS=	mount_null.c getmntopts.c
 MAN=	mount_null.8
 
 MOUNT=	${.CURDIR}/../mount
-CFLAGS+= -I${.CURDIR}/../../sys -I${MOUNT}
+CFLAGS+=-I${MOUNT}
 .PATH:	${MOUNT}
 
 .include <bsd.prog.mk>
diff --git a/sbin/mount_null/mount_null.c b/sbin/mount_null/mount_null.c
index d38e7e3..8e6b8f0 100644
--- a/sbin/mount_null/mount_null.c
+++ b/sbin/mount_null/mount_null.c
@@ -50,7 +50,7 @@ static const char rcsid[] =
 
 #include <sys/param.h>
 #include <sys/mount.h>
-#include <miscfs/nullfs/null.h>
+#include <fs/nullfs/null.h>
 
 #include <err.h>
 #include <stdio.h>
diff --git a/sbin/mount_nullfs/Makefile b/sbin/mount_nullfs/Makefile
index 68b488d..3c50252 100644
--- a/sbin/mount_nullfs/Makefile
+++ b/sbin/mount_nullfs/Makefile
@@ -6,7 +6,7 @@ SRCS=	mount_null.c getmntopts.c
 MAN=	mount_null.8
 
 MOUNT=	${.CURDIR}/../mount
-CFLAGS+= -I${.CURDIR}/../../sys -I${MOUNT}
+CFLAGS+=-I${MOUNT}
 .PATH:	${MOUNT}
 
 .include <bsd.prog.mk>
diff --git a/sbin/mount_nullfs/mount_nullfs.c b/sbin/mount_nullfs/mount_nullfs.c
index d38e7e3..8e6b8f0 100644
--- a/sbin/mount_nullfs/mount_nullfs.c
+++ b/sbin/mount_nullfs/mount_nullfs.c
@@ -50,7 +50,7 @@ static const char rcsid[] =
 
 #include <sys/param.h>
 #include <sys/mount.h>
-#include <miscfs/nullfs/null.h>
+#include <fs/nullfs/null.h>
 
 #include <err.h>
 #include <stdio.h>
diff --git a/sbin/mount_portal/Makefile b/sbin/mount_portal/Makefile
index 00b96dc..fc332ee 100644
--- a/sbin/mount_portal/Makefile
+++ b/sbin/mount_portal/Makefile
@@ -7,7 +7,7 @@ SRCS=	mount_portal.c activate.c conf.c getmntopts.c pt_conf.c \
 MAN=	mount_portal.8
 
 MOUNT=	${.CURDIR}/../mount
-CFLAGS+= -I${.CURDIR}/../../sys -I${MOUNT}
+CFLAGS+=-I${MOUNT}
 .PATH:	${MOUNT}
 
 .include <bsd.prog.mk>
diff --git a/sbin/mount_portal/portald.h b/sbin/mount_portal/portald.h
index 4131834..5837bd7 100644
--- a/sbin/mount_portal/portald.h
+++ b/sbin/mount_portal/portald.h
@@ -40,7 +40,7 @@
  */
 
 #include <sys/cdefs.h>
-#include <miscfs/portal/portal.h>
+#include <fs/portalfs/portal.h>
 
 /*
  * Meta-chars in an RE.  Paths in the config file containing
diff --git a/sbin/mount_portalfs/Makefile b/sbin/mount_portalfs/Makefile
index 00b96dc..fc332ee 100644
--- a/sbin/mount_portalfs/Makefile
+++ b/sbin/mount_portalfs/Makefile
@@ -7,7 +7,7 @@ SRCS=	mount_portal.c activate.c conf.c getmntopts.c pt_conf.c \
 MAN=	mount_portal.8
 
 MOUNT=	${.CURDIR}/../mount
-CFLAGS+= -I${.CURDIR}/../../sys -I${MOUNT}
+CFLAGS+=-I${MOUNT}
 .PATH:	${MOUNT}
 
 .include <bsd.prog.mk>
diff --git a/sbin/mount_portalfs/portald.h b/sbin/mount_portalfs/portald.h
index 4131834..5837bd7 100644
--- a/sbin/mount_portalfs/portald.h
+++ b/sbin/mount_portalfs/portald.h
@@ -40,7 +40,7 @@
  */
 
 #include <sys/cdefs.h>
-#include <miscfs/portal/portal.h>
+#include <fs/portalfs/portal.h>
 
 /*
  * Meta-chars in an RE.  Paths in the config file containing
diff --git a/sbin/mount_umap/Makefile b/sbin/mount_umap/Makefile
index 9ae6798..7dc1fc6b 100644
--- a/sbin/mount_umap/Makefile
+++ b/sbin/mount_umap/Makefile
@@ -6,7 +6,7 @@ SRCS=	mount_umap.c getmntopts.c
 MAN=	mount_umap.8
 
 MOUNT=	${.CURDIR}/../mount
-CFLAGS+= -I${.CURDIR}/../../sys -I${MOUNT}
+CFLAGS+=-I${MOUNT}
 .PATH:	${MOUNT}
 
 .include <bsd.prog.mk>
diff --git a/sbin/mount_umap/mount_umap.c b/sbin/mount_umap/mount_umap.c
index 0aa7b8c..14299fd 100644
--- a/sbin/mount_umap/mount_umap.c
+++ b/sbin/mount_umap/mount_umap.c
@@ -52,7 +52,7 @@ static const char rcsid[] =
 #include <sys/mount.h>
 #include <sys/stat.h>
 
-#include <miscfs/umapfs/umap.h>
+#include <fs/umapfs/umap.h>
 
 #include <err.h>
 #include <stdio.h>
diff --git a/sbin/mount_umapfs/Makefile b/sbin/mount_umapfs/Makefile
index 9ae6798..7dc1fc6b 100644
--- a/sbin/mount_umapfs/Makefile
+++ b/sbin/mount_umapfs/Makefile
@@ -6,7 +6,7 @@ SRCS=	mount_umap.c getmntopts.c
 MAN=	mount_umap.8
 
 MOUNT=	${.CURDIR}/../mount
-CFLAGS+= -I${.CURDIR}/../../sys -I${MOUNT}
+CFLAGS+=-I${MOUNT}
 .PATH:	${MOUNT}
 
 .include <bsd.prog.mk>
diff --git a/sbin/mount_umapfs/mount_umapfs.c b/sbin/mount_umapfs/mount_umapfs.c
index 0aa7b8c..14299fd 100644
--- a/sbin/mount_umapfs/mount_umapfs.c
+++ b/sbin/mount_umapfs/mount_umapfs.c
@@ -52,7 +52,7 @@ static const char rcsid[] =
 #include <sys/mount.h>
 #include <sys/stat.h>
 
-#include <miscfs/umapfs/umap.h>
+#include <fs/umapfs/umap.h>
 
 #include <err.h>
 #include <stdio.h>
diff --git a/sbin/mount_union/Makefile b/sbin/mount_union/Makefile
index 6b58c2d..7e0df33 100644
--- a/sbin/mount_union/Makefile
+++ b/sbin/mount_union/Makefile
@@ -6,7 +6,7 @@ SRCS=	mount_union.c getmntopts.c
 MAN=	mount_union.8
 
 MOUNT=	${.CURDIR}/../mount
-CFLAGS+= -I${.CURDIR}/../../sys -I${MOUNT}
+CFLAGS+=-I${MOUNT}
 .PATH:	${MOUNT}
 
 .include <bsd.prog.mk>
diff --git a/sbin/mount_union/mount_union.c b/sbin/mount_union/mount_union.c
index 1d5d3eb..d07f427 100644
--- a/sbin/mount_union/mount_union.c
+++ b/sbin/mount_union/mount_union.c
@@ -52,7 +52,7 @@ static const char rcsid[] =
 #include <sys/param.h>
 #include <sys/mount.h>
 
-#include <miscfs/union/union.h>
+#include <fs/unionfs/union.h>
 
 #include <err.h>
 #include <stdio.h>
diff --git a/sbin/mount_unionfs/Makefile b/sbin/mount_unionfs/Makefile
index 6b58c2d..7e0df33 100644
--- a/sbin/mount_unionfs/Makefile
+++ b/sbin/mount_unionfs/Makefile
@@ -6,7 +6,7 @@ SRCS=	mount_union.c getmntopts.c
 MAN=	mount_union.8
 
 MOUNT=	${.CURDIR}/../mount
-CFLAGS+= -I${.CURDIR}/../../sys -I${MOUNT}
+CFLAGS+=-I${MOUNT}
 .PATH:	${MOUNT}
 
 .include <bsd.prog.mk>
diff --git a/sbin/mount_unionfs/mount_unionfs.c b/sbin/mount_unionfs/mount_unionfs.c
index 1d5d3eb..d07f427 100644
--- a/sbin/mount_unionfs/mount_unionfs.c
+++ b/sbin/mount_unionfs/mount_unionfs.c
@@ -52,7 +52,7 @@ static const char rcsid[] =
 #include <sys/param.h>
 #include <sys/mount.h>
 
-#include <miscfs/union/union.h>
+#include <fs/unionfs/union.h>
 
 #include <err.h>
 #include <stdio.h>
diff --git a/sys/alpha/alpha/machdep.c b/sys/alpha/alpha/machdep.c
index ddedd8e..9e1a6ef 100644
--- a/sys/alpha/alpha/machdep.c
+++ b/sys/alpha/alpha/machdep.c
@@ -142,7 +142,7 @@
 #include <ddb/ddb.h>
 #include <alpha/alpha/db_instruction.h>
 #include <sys/vnode.h>
-#include <miscfs/procfs/procfs.h>
+#include <fs/procfs/procfs.h>
 #include <machine/sigframe.h>
 
 u_int64_t cycles_per_usec;
diff --git a/sys/alpha/alpha/procfs_machdep.c b/sys/alpha/alpha/procfs_machdep.c
index 06869b0..96fd0e5 100644
--- a/sys/alpha/alpha/procfs_machdep.c
+++ b/sys/alpha/alpha/procfs_machdep.c
@@ -75,7 +75,7 @@
 
 #include <machine/md_var.h>
 #include <machine/reg.h>
-#include <miscfs/procfs/procfs.h>
+#include <fs/procfs/procfs.h>
 
 #include <vm/vm.h>
 #include <vm/pmap.h>
diff --git a/sys/alpha/osf1/osf1_signal.c b/sys/alpha/osf1/osf1_signal.c
index f84bd4a..4152521 100644
--- a/sys/alpha/osf1/osf1_signal.c
+++ b/sys/alpha/osf1/osf1_signal.c
@@ -75,7 +75,7 @@
 #include <ddb/ddb.h>
 #include <alpha/alpha/db_instruction.h>
 #include <sys/vnode.h>
-#include <miscfs/procfs/procfs.h>
+#include <fs/procfs/procfs.h>
 
 #include <alpha/osf1/osf1_signal.h>
 #include <alpha/osf1/osf1_proto.h>
diff --git a/sys/conf/NOTES b/sys/conf/NOTES
index 14302b2..117c6fd 100644
--- a/sys/conf/NOTES
+++ b/sys/conf/NOTES
@@ -662,16 +662,16 @@ options 	NFS			#Network File System
 # The rest are optional:
 #options 	NFS_NOSERVER		#Disable the NFS-server code.
 options 	CD9660			#ISO 9660 filesystem
-options 	FDESC			#File descriptor filesystem
+options 	FDESCFS			#File descriptor filesystem
 options 	HPFS			#OS/2 File system
 options 	MSDOSFS			#MS DOS File System (FAT, FAT32)
 options 	NTFS			#NT File System
 options 	NULLFS			#NULL filesystem
 options 	NWFS			#NetWare filesystem
-options 	PORTAL			#Portal filesystem
+options 	PORTALFS		#Portal filesystem
 options 	PROCFS			#Process filesystem
 options 	UMAPFS			#UID map filesystem
-options 	UNION			#Union filesystem
+options 	UNIONFS			#Union filesystem
 # options 	NODEVFS			#disable devices filesystem
 # The xFS_ROOT options REQUIRE the associated ``options xFS''
 options 	NFS_ROOT		#NFS usable as root device
diff --git a/sys/conf/files b/sys/conf/files
index 5d7ae36..168abd7 100644
--- a/sys/conf/files
+++ b/sys/conf/files
@@ -585,15 +585,44 @@ dev/wds/wd7000.c		optional wds isa
 dev/wi/if_wi.c			optional wi card
 dev/wi/if_wi.c			optional wi pccard
 dev/xe/if_xe.c			optional xe card
-fs/devfs/devfs_vnops.c		standard
-fs/devfs/devfs_vfsops.c		standard
+fs/deadfs/dead_vnops.c	standard
 fs/devfs/devfs_devs.c		standard
-fs/hpfs/hpfs_vfsops.c		optional hpfs
-fs/hpfs/hpfs_vnops.c		optional hpfs
+fs/devfs/devfs_vfsops.c		standard
+fs/devfs/devfs_vnops.c		standard
+fs/fdescfs/fdesc_vfsops.c	optional fdescfs
+fs/fdescfs/fdesc_vnops.c	optional fdescfs
+fs/fifofs/fifo_vnops.c	standard
+fs/hpfs/hpfs_alsubr.c		optional hpfs
 fs/hpfs/hpfs_hash.c		optional hpfs
-fs/hpfs/hpfs_subr.c		optional hpfs
 fs/hpfs/hpfs_lookup.c		optional hpfs
-fs/hpfs/hpfs_alsubr.c		optional hpfs
+fs/hpfs/hpfs_subr.c		optional hpfs
+fs/hpfs/hpfs_vfsops.c		optional hpfs
+fs/hpfs/hpfs_vnops.c		optional hpfs
+fs/nullfs/null_subr.c	optional nullfs
+fs/nullfs/null_vfsops.c	optional nullfs
+fs/nullfs/null_vnops.c	optional nullfs
+fs/portalfs/portal_vfsops.c	optional portalfs
+fs/portalfs/portal_vnops.c	optional portalfs
+fs/procfs/procfs_ctl.c	optional procfs
+fs/procfs/procfs_dbregs.c	standard
+fs/procfs/procfs_fpregs.c	standard
+fs/procfs/procfs_map.c	optional procfs
+fs/procfs/procfs_mem.c	standard
+fs/procfs/procfs_note.c	optional procfs
+fs/procfs/procfs_regs.c	standard
+fs/procfs/procfs_rlimit.c	optional procfs
+fs/procfs/procfs_status.c	optional procfs
+fs/procfs/procfs_subr.c	optional procfs
+fs/procfs/procfs_type.c	optional procfs
+fs/procfs/procfs_vfsops.c	optional procfs
+fs/procfs/procfs_vnops.c	optional procfs
+fs/specfs/spec_vnops.c	standard
+fs/umapfs/umap_subr.c	optional umapfs
+fs/umapfs/umap_vfsops.c	optional umapfs
+fs/umapfs/umap_vnops.c	optional umapfs
+fs/unionfs/union_subr.c	optional unionfs
+fs/unionfs/union_vfsops.c	optional unionfs
+fs/unionfs/union_vnops.c	optional unionfs
 gnu/ext2fs/ext2_alloc.c		optional ext2fs
 gnu/ext2fs/ext2_balloc.c	optional ext2fs
 gnu/ext2fs/ext2_inode.c		optional ext2fs
@@ -803,35 +832,6 @@ libkern/strtol.c	standard
 libkern/strtoq.c	standard
 libkern/strtoul.c	standard
 libkern/strtouq.c	standard
-miscfs/deadfs/dead_vnops.c	standard
-miscfs/fdesc/fdesc_vfsops.c	optional fdesc
-miscfs/fdesc/fdesc_vnops.c	optional fdesc
-miscfs/fifofs/fifo_vnops.c	standard
-miscfs/nullfs/null_subr.c	optional nullfs
-miscfs/nullfs/null_vfsops.c	optional nullfs
-miscfs/nullfs/null_vnops.c	optional nullfs
-miscfs/portal/portal_vfsops.c	optional portal
-miscfs/portal/portal_vnops.c	optional portal
-miscfs/procfs/procfs_ctl.c	optional procfs
-miscfs/procfs/procfs_dbregs.c	standard
-miscfs/procfs/procfs_fpregs.c	standard
-miscfs/procfs/procfs_map.c	optional procfs
-miscfs/procfs/procfs_mem.c	standard
-miscfs/procfs/procfs_note.c	optional procfs
-miscfs/procfs/procfs_regs.c	standard
-miscfs/procfs/procfs_rlimit.c	optional procfs
-miscfs/procfs/procfs_status.c	optional procfs
-miscfs/procfs/procfs_subr.c	optional procfs
-miscfs/procfs/procfs_type.c	optional procfs
-miscfs/procfs/procfs_vfsops.c	optional procfs
-miscfs/procfs/procfs_vnops.c	optional procfs
-miscfs/specfs/spec_vnops.c	standard
-miscfs/umapfs/umap_subr.c	optional umapfs
-miscfs/umapfs/umap_vfsops.c	optional umapfs
-miscfs/umapfs/umap_vnops.c	optional umapfs
-miscfs/union/union_subr.c	optional union
-miscfs/union/union_vfsops.c	optional union
-miscfs/union/union_vnops.c	optional union
 msdosfs/msdosfs_conv.c		optional msdosfs
 msdosfs/msdosfs_denode.c	optional msdosfs
 msdosfs/msdosfs_fat.c		optional msdosfs
diff --git a/sys/conf/options b/sys/conf/options
index a4bb13e..f94d6a6 100644
--- a/sys/conf/options
+++ b/sys/conf/options
@@ -118,7 +118,7 @@ INCLUDE_CONFIG_FILE	opt_config.h
 CD9660		opt_dontuse.h
 CODA		opt_dontuse.h
 EXT2FS		opt_dontuse.h
-FDESC		opt_dontuse.h
+FDESCFS		opt_dontuse.h
 FFS		opt_dontuse.h
 IFS		opt_dontuse.h
 LINPROCFS	opt_dontuse.h
@@ -126,12 +126,12 @@ MFS		opt_dontuse.h
 MSDOSFS		opt_dontuse.h
 NULLFS		opt_dontuse.h
 NWFS		opt_dontuse.h
-PORTAL		opt_dontuse.h
+PORTALFS	opt_dontuse.h
 PROCFS		opt_dontuse.h
 UMAPFS		opt_dontuse.h
 NTFS		opt_dontuse.h
 HPFS		opt_dontuse.h
-UNION		opt_dontuse.h
+UNIONFS		opt_dontuse.h
 
 # These static filesystems has one slightly bogus static dependency in
 # sys/i386/i386/autoconf.c.  If any of these filesystems are
diff --git a/sys/fs/cd9660/cd9660_vnops.c b/sys/fs/cd9660/cd9660_vnops.c
index e8eb934..702823e 100644
--- a/sys/fs/cd9660/cd9660_vnops.c
+++ b/sys/fs/cd9660/cd9660_vnops.c
@@ -48,7 +48,7 @@
 #include <sys/buf.h>
 #include <sys/mount.h>
 #include <sys/vnode.h>
-#include <miscfs/fifofs/fifo.h>
+#include <fs/fifofs/fifo.h>
 #include <sys/malloc.h>
 #include <sys/dirent.h>
 #include <sys/unistd.h>
diff --git a/sys/fs/fdescfs/fdesc_vfsops.c b/sys/fs/fdescfs/fdesc_vfsops.c
index a758bb8..1bb1f71 100644
--- a/sys/fs/fdescfs/fdesc_vfsops.c
+++ b/sys/fs/fdescfs/fdesc_vfsops.c
@@ -54,7 +54,7 @@
 #include <sys/socket.h>
 #include <sys/vnode.h>
 
-#include <miscfs/fdesc/fdesc.h>
+#include <fs/fdescfs/fdesc.h>
 
 static MALLOC_DEFINE(M_FDESCMNT, "FDESC mount", "FDESC mount structure");
 
diff --git a/sys/fs/fdescfs/fdesc_vnops.c b/sys/fs/fdescfs/fdesc_vnops.c
index 065e0a8..cb90212 100644
--- a/sys/fs/fdescfs/fdesc_vnops.c
+++ b/sys/fs/fdescfs/fdesc_vnops.c
@@ -58,7 +58,7 @@
 #include <sys/stat.h>
 #include <sys/vnode.h>
 
-#include <miscfs/fdesc/fdesc.h>
+#include <fs/fdescfs/fdesc.h>
 
 #define FDL_WANT	0x01
 #define FDL_LOCKED	0x02
diff --git a/sys/fs/fifofs/fifo_vnops.c b/sys/fs/fifofs/fifo_vnops.c
index 3cd5425..2a3078f 100644
--- a/sys/fs/fifofs/fifo_vnops.c
+++ b/sys/fs/fifofs/fifo_vnops.c
@@ -49,7 +49,7 @@
 #include <sys/event.h>
 #include <sys/poll.h>
 #include <sys/un.h>
-#include <miscfs/fifofs/fifo.h>
+#include <fs/fifofs/fifo.h>
 
 /*
  * This structure is associated with the FIFO vnode and stores
diff --git a/sys/fs/nullfs/null_subr.c b/sys/fs/nullfs/null_subr.c
index 88f1584..97aa492 100644
--- a/sys/fs/nullfs/null_subr.c
+++ b/sys/fs/nullfs/null_subr.c
@@ -47,7 +47,7 @@
 #include <sys/proc.h>
 #include <sys/vnode.h>
 
-#include <miscfs/nullfs/null.h>
+#include <fs/nullfs/null.h>
 
 #define LOG2_SIZEVNODE 7		/* log2(sizeof struct vnode) */
 #define	NNULLNODECACHE 16
diff --git a/sys/fs/nullfs/null_vfsops.c b/sys/fs/nullfs/null_vfsops.c
index 8573398..e2287ef 100644
--- a/sys/fs/nullfs/null_vfsops.c
+++ b/sys/fs/nullfs/null_vfsops.c
@@ -54,7 +54,7 @@
 #include <sys/proc.h>
 #include <sys/vnode.h>
 
-#include <miscfs/nullfs/null.h>
+#include <fs/nullfs/null.h>
 
 static MALLOC_DEFINE(M_NULLFSMNT, "NULLFS mount", "NULLFS mount structure");
 
diff --git a/sys/fs/nullfs/null_vnops.c b/sys/fs/nullfs/null_vnops.c
index d37ef73..32b9665 100644
--- a/sys/fs/nullfs/null_vnops.c
+++ b/sys/fs/nullfs/null_vnops.c
@@ -185,7 +185,7 @@
 #include <sys/sysctl.h>
 #include <sys/vnode.h>
 
-#include <miscfs/nullfs/null.h>
+#include <fs/nullfs/null.h>
 
 #include <vm/vm.h>
 #include <vm/vm_extern.h>
diff --git a/sys/fs/portalfs/portal_vfsops.c b/sys/fs/portalfs/portal_vfsops.c
index 423cd38..7178599 100644
--- a/sys/fs/portalfs/portal_vfsops.c
+++ b/sys/fs/portalfs/portal_vfsops.c
@@ -57,7 +57,7 @@
 #include <sys/socketvar.h>
 #include <sys/vnode.h>
 
-#include <miscfs/portal/portal.h>
+#include <fs/portalfs/portal.h>
 
 static MALLOC_DEFINE(M_PORTALFSMNT, "PORTAL mount", "PORTAL mount structure");
 
diff --git a/sys/fs/portalfs/portal_vnops.c b/sys/fs/portalfs/portal_vnops.c
index b53c4ca..726873e 100644
--- a/sys/fs/portalfs/portal_vnops.c
+++ b/sys/fs/portalfs/portal_vnops.c
@@ -61,7 +61,7 @@
 #include <sys/socketvar.h>
 #include <sys/un.h>
 #include <sys/unpcb.h>
-#include <miscfs/portal/portal.h>
+#include <fs/portalfs/portal.h>
 
 static int portal_fileid = PORTAL_ROOTFILEID+1;
 
diff --git a/sys/fs/procfs/procfs_ctl.c b/sys/fs/procfs/procfs_ctl.c
index 5818758..a507349 100644
--- a/sys/fs/procfs/procfs_ctl.c
+++ b/sys/fs/procfs/procfs_ctl.c
@@ -48,7 +48,7 @@
 #include <sys/sx.h>
 #include <sys/vnode.h>
 
-#include <miscfs/procfs/procfs.h>
+#include <fs/procfs/procfs.h>
 
 #include <vm/vm.h>
 
diff --git a/sys/fs/procfs/procfs_dbregs.c b/sys/fs/procfs/procfs_dbregs.c
index d80e28c..cd64a34 100644
--- a/sys/fs/procfs/procfs_dbregs.c
+++ b/sys/fs/procfs/procfs_dbregs.c
@@ -52,7 +52,7 @@
 
 #include <machine/reg.h>
 
-#include <miscfs/procfs/procfs.h>
+#include <fs/procfs/procfs.h>
 
 #include <vm/vm.h>
 
diff --git a/sys/fs/procfs/procfs_fpregs.c b/sys/fs/procfs/procfs_fpregs.c
index 7e2ff52..c71e444 100644
--- a/sys/fs/procfs/procfs_fpregs.c
+++ b/sys/fs/procfs/procfs_fpregs.c
@@ -49,7 +49,7 @@
 
 #include <machine/reg.h>
 
-#include <miscfs/procfs/procfs.h>
+#include <fs/procfs/procfs.h>
 
 #include <vm/vm.h>
 
diff --git a/sys/fs/procfs/procfs_map.c b/sys/fs/procfs/procfs_map.c
index 5c21993..e974b04 100644
--- a/sys/fs/procfs/procfs_map.c
+++ b/sys/fs/procfs/procfs_map.c
@@ -46,7 +46,7 @@
 #include <sys/proc.h>
 #include <sys/vnode.h>
 
-#include <miscfs/procfs/procfs.h>
+#include <fs/procfs/procfs.h>
 
 #include <vm/vm.h>
 #include <vm/pmap.h>
diff --git a/sys/fs/procfs/procfs_mem.c b/sys/fs/procfs/procfs_mem.c
index 1e28870..b8c60d6 100644
--- a/sys/fs/procfs/procfs_mem.c
+++ b/sys/fs/procfs/procfs_mem.c
@@ -54,7 +54,7 @@
 #include <sys/user.h>
 #include <sys/vnode.h>
 
-#include <miscfs/procfs/procfs.h>
+#include <fs/procfs/procfs.h>
 
 #include <vm/vm.h>
 #include <vm/vm_param.h>
diff --git a/sys/fs/procfs/procfs_note.c b/sys/fs/procfs/procfs_note.c
index 273010b..c669654 100644
--- a/sys/fs/procfs/procfs_note.c
+++ b/sys/fs/procfs/procfs_note.c
@@ -41,7 +41,7 @@
 
 #include <sys/param.h>
 #include <sys/vnode.h>
-#include <miscfs/procfs/procfs.h>
+#include <fs/procfs/procfs.h>
 
 int
 procfs_donote(curp, p, pfs, uio)
diff --git a/sys/fs/procfs/procfs_regs.c b/sys/fs/procfs/procfs_regs.c
index ba58517..c7eeb1c 100644
--- a/sys/fs/procfs/procfs_regs.c
+++ b/sys/fs/procfs/procfs_regs.c
@@ -52,7 +52,7 @@
 #include <vm/vm.h>
 #include <vm/vm_extern.h>
 
-#include <miscfs/procfs/procfs.h>
+#include <fs/procfs/procfs.h>
 
 int
 procfs_doregs(curp, p, pfs, uio)
diff --git a/sys/fs/procfs/procfs_rlimit.c b/sys/fs/procfs/procfs_rlimit.c
index 361f6f6..f74874d 100644
--- a/sys/fs/procfs/procfs_rlimit.c
+++ b/sys/fs/procfs/procfs_rlimit.c
@@ -52,7 +52,7 @@
 #include <sys/resourcevar.h>
 #include <sys/resource.h>
 #include <sys/types.h>
-#include <miscfs/procfs/procfs.h>
+#include <fs/procfs/procfs.h>
 
 
 int
diff --git a/sys/fs/procfs/procfs_status.c b/sys/fs/procfs/procfs_status.c
index b29b4a9..9620be5 100644
--- a/sys/fs/procfs/procfs_status.c
+++ b/sys/fs/procfs/procfs_status.c
@@ -56,7 +56,7 @@
 #include <vm/pmap.h>
 #include <vm/vm_param.h>
 
-#include <miscfs/procfs/procfs.h>
+#include <fs/procfs/procfs.h>
 
 #define DOCHECK() do { if (ps >= psbuf+sizeof(psbuf)) goto bailout; } while (0)
 int
diff --git a/sys/fs/procfs/procfs_subr.c b/sys/fs/procfs/procfs_subr.c
index 64adecb..36d366f 100644
--- a/sys/fs/procfs/procfs_subr.c
+++ b/sys/fs/procfs/procfs_subr.c
@@ -50,7 +50,7 @@
 #include <sys/sysctl.h>
 #include <sys/vnode.h>
 
-#include <miscfs/procfs/procfs.h>
+#include <fs/procfs/procfs.h>
 
 static struct pfsnode *pfshead;
 static int pfsvplock;
diff --git a/sys/fs/procfs/procfs_type.c b/sys/fs/procfs/procfs_type.c
index cb2a45f..3919c88 100644
--- a/sys/fs/procfs/procfs_type.c
+++ b/sys/fs/procfs/procfs_type.c
@@ -42,7 +42,7 @@
 #include <sys/proc.h>
 #include <sys/sysent.h>
 #include <sys/vnode.h>
-#include <miscfs/procfs/procfs.h>
+#include <fs/procfs/procfs.h>
 
 int
 procfs_dotype(curp, p, pfs, uio)
diff --git a/sys/fs/procfs/procfs_vfsops.c b/sys/fs/procfs/procfs_vfsops.c
index 91daf9d..c0d7add 100644
--- a/sys/fs/procfs/procfs_vfsops.c
+++ b/sys/fs/procfs/procfs_vfsops.c
@@ -49,7 +49,7 @@
 #include <sys/proc.h>
 #include <sys/mount.h>
 #include <sys/vnode.h>
-#include <miscfs/procfs/procfs.h>
+#include <fs/procfs/procfs.h>
 
 static int	procfs_mount __P((struct mount *mp, char *path, caddr_t data,
 				  struct nameidata *ndp, struct proc *p));
diff --git a/sys/fs/procfs/procfs_vnops.c b/sys/fs/procfs/procfs_vnops.c
index dbdafc8..a054eb9 100644
--- a/sys/fs/procfs/procfs_vnops.c
+++ b/sys/fs/procfs/procfs_vnops.c
@@ -66,7 +66,7 @@
 
 #include <vm/vm_zone.h>
 
-#include <miscfs/procfs/procfs.h>
+#include <fs/procfs/procfs.h>
 
 static int	procfs_access __P((struct vop_access_args *));
 static int	procfs_badop __P((void));
diff --git a/sys/fs/umapfs/umap_subr.c b/sys/fs/umapfs/umap_subr.c
index 1f94d50..afcaceb 100644
--- a/sys/fs/umapfs/umap_subr.c
+++ b/sys/fs/umapfs/umap_subr.c
@@ -45,7 +45,7 @@
 #include <sys/proc.h>
 #include <sys/vnode.h>
 
-#include <miscfs/umapfs/umap.h>
+#include <fs/umapfs/umap.h>
 
 #define LOG2_SIZEVNODE 7		/* log2(sizeof struct vnode) */
 #define	NUMAPNODECACHE 16
diff --git a/sys/fs/umapfs/umap_vfsops.c b/sys/fs/umapfs/umap_vfsops.c
index 280ded9..b8dc4c9 100644
--- a/sys/fs/umapfs/umap_vfsops.c
+++ b/sys/fs/umapfs/umap_vfsops.c
@@ -53,7 +53,7 @@
 #include <sys/namei.h>
 #include <sys/vnode.h>
 
-#include <miscfs/umapfs/umap.h>
+#include <fs/umapfs/umap.h>
 
 static MALLOC_DEFINE(M_UMAPFSMNT, "UMAP mount", "UMAP mount structure");
 
diff --git a/sys/fs/umapfs/umap_vnops.c b/sys/fs/umapfs/umap_vnops.c
index 5bf29c8..b73ff2c 100644
--- a/sys/fs/umapfs/umap_vnops.c
+++ b/sys/fs/umapfs/umap_vnops.c
@@ -51,8 +51,8 @@
 #include <sys/sysctl.h>
 #include <sys/vnode.h>
 
-#include <miscfs/umapfs/umap.h>
-#include <miscfs/nullfs/null.h>
+#include <fs/umapfs/umap.h>
+#include <fs/nullfs/null.h>
 
 static int umap_bug_bypass = 0;   /* for debugging: enables bypass printf'ing */
 SYSCTL_INT(_debug, OID_AUTO, umapfs_bug_bypass, CTLFLAG_RW,
diff --git a/sys/fs/unionfs/union_subr.c b/sys/fs/unionfs/union_subr.c
index ce38e2d..52a5483 100644
--- a/sys/fs/unionfs/union_subr.c
+++ b/sys/fs/unionfs/union_subr.c
@@ -58,7 +58,7 @@
 #include <vm/vm_zone.h>
 #include <vm/vm_object.h>	/* for vm cache coherency */
 
-#include <miscfs/union/union.h>
+#include <fs/unionfs/union.h>
 
 #include <sys/proc.h>
 
diff --git a/sys/fs/unionfs/union_vfsops.c b/sys/fs/unionfs/union_vfsops.c
index d38f31e..5a5af5d 100644
--- a/sys/fs/unionfs/union_vfsops.c
+++ b/sys/fs/unionfs/union_vfsops.c
@@ -51,7 +51,7 @@
 #include <sys/namei.h>
 #include <sys/malloc.h>
 #include <sys/filedesc.h>
-#include <miscfs/union/union.h>
+#include <fs/unionfs/union.h>
 
 static MALLOC_DEFINE(M_UNIONFSMNT, "UNION mount", "UNION mount structure");
 
diff --git a/sys/fs/unionfs/union_vnops.c b/sys/fs/unionfs/union_vnops.c
index 3402825..b5abfa7 100644
--- a/sys/fs/unionfs/union_vnops.c
+++ b/sys/fs/unionfs/union_vnops.c
@@ -51,7 +51,7 @@
 #include <sys/buf.h>
 #include <sys/lock.h>
 #include <sys/sysctl.h>
-#include <miscfs/union/union.h>
+#include <fs/unionfs/union.h>
 
 #include <vm/vm.h>
 #include <vm/vnode_pager.h>
diff --git a/sys/i386/conf/NOTES b/sys/i386/conf/NOTES
index 14302b2..117c6fd 100644
--- a/sys/i386/conf/NOTES
+++ b/sys/i386/conf/NOTES
@@ -662,16 +662,16 @@ options 	NFS			#Network File System
 # The rest are optional:
 #options 	NFS_NOSERVER		#Disable the NFS-server code.
 options 	CD9660			#ISO 9660 filesystem
-options 	FDESC			#File descriptor filesystem
+options 	FDESCFS			#File descriptor filesystem
 options 	HPFS			#OS/2 File system
 options 	MSDOSFS			#MS DOS File System (FAT, FAT32)
 options 	NTFS			#NT File System
 options 	NULLFS			#NULL filesystem
 options 	NWFS			#NetWare filesystem
-options 	PORTAL			#Portal filesystem
+options 	PORTALFS		#Portal filesystem
 options 	PROCFS			#Process filesystem
 options 	UMAPFS			#UID map filesystem
-options 	UNION			#Union filesystem
+options 	UNIONFS			#Union filesystem
 # options 	NODEVFS			#disable devices filesystem
 # The xFS_ROOT options REQUIRE the associated ``options xFS''
 options 	NFS_ROOT		#NFS usable as root device
diff --git a/sys/i386/i386/procfs_machdep.c b/sys/i386/i386/procfs_machdep.c
index 44a5564..f951b0f 100644
--- a/sys/i386/i386/procfs_machdep.c
+++ b/sys/i386/i386/procfs_machdep.c
@@ -77,7 +77,7 @@
 
 #include <machine/reg.h>
 #include <machine/md_var.h>
-#include <miscfs/procfs/procfs.h>
+#include <fs/procfs/procfs.h>
 
 #include <vm/vm.h>
 #include <vm/pmap.h>
diff --git a/sys/ia64/ia64/machdep.c b/sys/ia64/ia64/machdep.c
index e2223a8..9dae762 100644
--- a/sys/ia64/ia64/machdep.c
+++ b/sys/ia64/ia64/machdep.c
@@ -75,7 +75,7 @@
 #include <ddb/ddb.h>
 #include <alpha/alpha/db_instruction.h>
 #include <sys/vnode.h>
-#include <miscfs/procfs/procfs.h>
+#include <fs/procfs/procfs.h>
 #include <machine/sigframe.h>
 
 u_int64_t cycles_per_usec;
diff --git a/sys/ia64/ia64/procfs_machdep.c b/sys/ia64/ia64/procfs_machdep.c
index 6deaafa..e623e49 100644
--- a/sys/ia64/ia64/procfs_machdep.c
+++ b/sys/ia64/ia64/procfs_machdep.c
@@ -73,7 +73,7 @@
 #include <sys/vnode.h>
 #include <machine/reg.h>
 #include <machine/md_var.h>
-#include <miscfs/procfs/procfs.h>
+#include <fs/procfs/procfs.h>
 
 #include <vm/vm.h>
 #include <vm/pmap.h>
diff --git a/sys/isofs/cd9660/cd9660_vnops.c b/sys/isofs/cd9660/cd9660_vnops.c
index e8eb934..702823e 100644
--- a/sys/isofs/cd9660/cd9660_vnops.c
+++ b/sys/isofs/cd9660/cd9660_vnops.c
@@ -48,7 +48,7 @@
 #include <sys/buf.h>
 #include <sys/mount.h>
 #include <sys/vnode.h>
-#include <miscfs/fifofs/fifo.h>
+#include <fs/fifofs/fifo.h>
 #include <sys/malloc.h>
 #include <sys/dirent.h>
 #include <sys/unistd.h>
diff --git a/sys/kern/Make.tags.inc b/sys/kern/Make.tags.inc
index 3f9f980..59dd7a7 100644
--- a/sys/kern/Make.tags.inc
+++ b/sys/kern/Make.tags.inc
@@ -28,17 +28,17 @@ COMM=	${SYS}/conf/*.[ch] \
 	${SYS}/dev/smbus/*.[ch] \
 	${SYS}/dev/vn/*.[ch] \
 	${SYS}/dev/vx/*.[ch] \
+	${SYS}/fs/deadfs/*.[ch] \
+	${SYS}/fs/fdescfs/*.[ch] \
+	${SYS}/fs/fifofs/*.[ch] \
+	${SYS}/fs/nullfs/*.[ch] \
+	${SYS}/fs/portalfs/*.[ch] \
+	${SYS}/fs/procfs/*.[ch] \
+	${SYS}/fs/specfs/*.[ch] \
+	${SYS}/fs/umapfs/*.[ch] \
+	${SYS}/fs/unionfs/*.[ch] \
 	${SYS}/isofs/cd9660/*.[ch] \
 	${SYS}/kern/*.[ch] \
-	${SYS}/miscfs/deadfs/*.[ch] \
-	${SYS}/miscfs/fdesc/*.[ch] \
-	${SYS}/miscfs/fifofs/*.[ch] \
-	${SYS}/miscfs/nullfs/*.[ch] \
-	${SYS}/miscfs/portal/*.[ch] \
-	${SYS}/miscfs/procfs/*.[ch] \
-	${SYS}/miscfs/specfs/*.[ch] \
-	${SYS}/miscfs/umapfs/*.[ch] \
-	${SYS}/miscfs/union/*.[ch] \
 	${SYS}/msdosfs/*.[ch] \
 	${SYS}/net/*.[ch] \
 	${SYS}/netatalk/*.[ch] \
@@ -91,17 +91,17 @@ COMMDIR2= ${SYS}/dev/advansys \
 	${SYS}/dev/smbus \
 	${SYS}/dev/vn \
 	${SYS}/dev/vx \
+	${SYS}/fs/deadfs \
+	${SYS}/fs/devfs \
+	${SYS}/fs/fdescfs \
+	${SYS}/fs/fifofs \
+	${SYS}/fs/nullfs \
+	${SYS}/fs/portalfs \
+	${SYS}/fs/procfs \
+	${SYS}/fs/specfs \
+	${SYS}/fs/umapfs \
+	${SYS}/fs/unionfs \
 	${SYS}/isofs/cd9660 \
-	${SYS}/miscfs/deadfs \
-	${SYS}/miscfs/devfs \
-	${SYS}/miscfs/fdesc \
-	${SYS}/miscfs/fifofs \
-	${SYS}/miscfs/nullfs \
-	${SYS}/miscfs/portal \
-	${SYS}/miscfs/procfs \
-	${SYS}/miscfs/specfs \
-	${SYS}/miscfs/umapfs \
-	${SYS}/miscfs/union \
 	${SYS}/ufs/ffs \
 	${SYS}/ufs/mfs \
 	${SYS}/ufs/ufs
diff --git a/sys/kern/Makefile b/sys/kern/Makefile
index 37f03ab..5cc169d 100644
--- a/sys/kern/Makefile
+++ b/sys/kern/Makefile
@@ -33,11 +33,11 @@ SYSDIR=/sys
 # Directories in which to place tags links (other than machine-dependent)
 DGEN=	conf \
 	dev dev/scsi \
+	fs fs/deadfs fs/fdescfs fs/fifofs \
+	fs/lofs fs/nullfs fs/portalfs fs/procfs \
+	fs/specfs fs/umapfs fs/unionfs \
 	hp hp/dev hp/hpux \
 	kern libkern \
-	miscfs miscfs/deadfs miscfs/fdesc miscfs/fifofs \
-	miscfs/lofs miscfs/nullfs miscfs/portal miscfs/procfs \
-	miscfs/specfs miscfs/umapfs miscfs/union \
 	net netccitt netinet netiso netns nfs scripts sys \
 	ufs ufs/ffs ufs/lfs ufs/mfs ufs/ufs \
 	vm
diff --git a/sys/kern/sys_process.c b/sys/kern/sys_process.c
index 03640cf..799608d 100644
--- a/sys/kern/sys_process.c
+++ b/sys/kern/sys_process.c
@@ -49,7 +49,7 @@
 #include <vm/vm_map.h>
 #include <vm/vm_page.h>
 
-#include <miscfs/procfs/procfs.h>
+#include <fs/procfs/procfs.h>
 
 /* use the equivalent procfs code */
 #if 0
diff --git a/sys/kern/vfs_extattr.c b/sys/kern/vfs_extattr.c
index 3f97551..e5ee6e7 100644
--- a/sys/kern/vfs_extattr.c
+++ b/sys/kern/vfs_extattr.c
@@ -68,7 +68,6 @@
 #include <sys/jail.h>
 
 #include <machine/limits.h>
-#include <miscfs/union/union.h>
 #include <sys/sysctl.h>
 #include <vm/vm.h>
 #include <vm/vm_object.h>
diff --git a/sys/kern/vfs_syscalls.c b/sys/kern/vfs_syscalls.c
index 3f97551..e5ee6e7 100644
--- a/sys/kern/vfs_syscalls.c
+++ b/sys/kern/vfs_syscalls.c
@@ -68,7 +68,6 @@
 #include <sys/jail.h>
 
 #include <machine/limits.h>
-#include <miscfs/union/union.h>
 #include <sys/sysctl.h>
 #include <vm/vm.h>
 #include <vm/vm_object.h>
diff --git a/sys/miscfs/deadfs/dead_vnops.c b/sys/miscfs/deadfs/dead_vnops.c
deleted file mode 100644
index 9911453..0000000
--- a/sys/miscfs/deadfs/dead_vnops.c
+++ /dev/null
@@ -1,295 +0,0 @@
-/*
- * Copyright (c) 1989, 1993
- *	The Regents of the University of California.  All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)dead_vnops.c	8.1 (Berkeley) 6/10/93
- * $FreeBSD$
- */
-
-#include <sys/param.h>
-#include <sys/systm.h>
-#include <sys/kernel.h>
-#include <sys/lock.h>
-#include <sys/mutex.h>
-#include <sys/poll.h>
-#include <sys/vnode.h>
-
-static int	chkvnlock __P((struct vnode *));
-/*
- * Prototypes for dead operations on vnodes.
- */
-static int	dead_badop __P((void));
-static int	dead_bmap __P((struct vop_bmap_args *));
-static int	dead_ioctl __P((struct vop_ioctl_args *));
-static int	dead_lock __P((struct vop_lock_args *));
-static int	dead_lookup __P((struct vop_lookup_args *));
-static int	dead_open __P((struct vop_open_args *));
-static int	dead_poll __P((struct vop_poll_args *));
-static int	dead_print __P((struct vop_print_args *));
-static int	dead_read __P((struct vop_read_args *));
-static int	dead_write __P((struct vop_write_args *));
-
-vop_t **dead_vnodeop_p;
-static struct vnodeopv_entry_desc dead_vnodeop_entries[] = {
-	{ &vop_default_desc,		(vop_t *) vop_defaultop },
-	{ &vop_access_desc,		(vop_t *) vop_ebadf },
-	{ &vop_advlock_desc,		(vop_t *) vop_ebadf },
-	{ &vop_bmap_desc,		(vop_t *) dead_bmap },
-	{ &vop_create_desc,		(vop_t *) dead_badop },
-	{ &vop_getattr_desc,		(vop_t *) vop_ebadf },
-	{ &vop_inactive_desc,		(vop_t *) vop_null },
-	{ &vop_ioctl_desc,		(vop_t *) dead_ioctl },
-	{ &vop_link_desc,		(vop_t *) dead_badop },
-	{ &vop_lock_desc,		(vop_t *) dead_lock },
-	{ &vop_lookup_desc,		(vop_t *) dead_lookup },
-	{ &vop_mkdir_desc,		(vop_t *) dead_badop },
-	{ &vop_mknod_desc,		(vop_t *) dead_badop },
-	{ &vop_open_desc,		(vop_t *) dead_open },
-	{ &vop_pathconf_desc,		(vop_t *) vop_ebadf },	/* per pathconf(2) */
-	{ &vop_poll_desc,		(vop_t *) dead_poll },
-	{ &vop_print_desc,		(vop_t *) dead_print },
-	{ &vop_read_desc,		(vop_t *) dead_read },
-	{ &vop_readdir_desc,		(vop_t *) vop_ebadf },
-	{ &vop_readlink_desc,		(vop_t *) vop_ebadf },
-	{ &vop_reclaim_desc,		(vop_t *) vop_null },
-	{ &vop_remove_desc,		(vop_t *) dead_badop },
-	{ &vop_rename_desc,		(vop_t *) dead_badop },
-	{ &vop_rmdir_desc,		(vop_t *) dead_badop },
-	{ &vop_setattr_desc,		(vop_t *) vop_ebadf },
-	{ &vop_symlink_desc,		(vop_t *) dead_badop },
-	{ &vop_write_desc,		(vop_t *) dead_write },
-	{ NULL, NULL }
-};
-static struct vnodeopv_desc dead_vnodeop_opv_desc =
-	{ &dead_vnodeop_p, dead_vnodeop_entries };
-
-VNODEOP_SET(dead_vnodeop_opv_desc);
-
-/*
- * Trivial lookup routine that always fails.
- */
-/* ARGSUSED */
-static int
-dead_lookup(ap)
-	struct vop_lookup_args /* {
-		struct vnode * a_dvp;
-		struct vnode ** a_vpp;
-		struct componentname * a_cnp;
-	} */ *ap;
-{
-
-	*ap->a_vpp = NULL;
-	return (ENOTDIR);
-}
-
-/*
- * Open always fails as if device did not exist.
- */
-/* ARGSUSED */
-static int
-dead_open(ap)
-	struct vop_open_args /* {
-		struct vnode *a_vp;
-		int  a_mode;
-		struct ucred *a_cred;
-		struct proc *a_p;
-	} */ *ap;
-{
-
-	return (ENXIO);
-}
-
-/*
- * Vnode op for read
- */
-/* ARGSUSED */
-static int
-dead_read(ap)
-	struct vop_read_args /* {
-		struct vnode *a_vp;
-		struct uio *a_uio;
-		int  a_ioflag;
-		struct ucred *a_cred;
-	} */ *ap;
-{
-
-	if (chkvnlock(ap->a_vp))
-		panic("dead_read: lock");
-	/*
-	 * Return EOF for tty devices, EIO for others
-	 */
-	if ((ap->a_vp->v_flag & VISTTY) == 0)
-		return (EIO);
-	return (0);
-}
-
-/*
- * Vnode op for write
- */
-/* ARGSUSED */
-static int
-dead_write(ap)
-	struct vop_write_args /* {
-		struct vnode *a_vp;
-		struct uio *a_uio;
-		int  a_ioflag;
-		struct ucred *a_cred;
-	} */ *ap;
-{
-
-	if (chkvnlock(ap->a_vp))
-		panic("dead_write: lock");
-	return (EIO);
-}
-
-/*
- * Device ioctl operation.
- */
-/* ARGSUSED */
-static int
-dead_ioctl(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;
-	} */ *ap;
-{
-
-	if (!chkvnlock(ap->a_vp))
-		return (ENOTTY);
-	return (VCALL(ap->a_vp, VOFFSET(vop_ioctl), ap));
-}
-
-
-/*
- * Wait until the vnode has finished changing state.
- */
-static int
-dead_lock(ap)
-	struct vop_lock_args /* {
-		struct vnode *a_vp;
-		int a_flags;
-		struct proc *a_p;
-	} */ *ap;
-{
-	struct vnode *vp = ap->a_vp;
-
-	/*
-	 * Since we are not using the lock manager, we must clear
-	 * the interlock here.
-	 */
-	if (ap->a_flags & LK_INTERLOCK) {
-		mtx_unlock(&vp->v_interlock);
-		ap->a_flags &= ~LK_INTERLOCK;
-	}
-	if (!chkvnlock(vp))
-		return (0);
-	return (VCALL(vp, VOFFSET(vop_lock), ap));
-}
-
-/*
- * Wait until the vnode has finished changing state.
- */
-static int
-dead_bmap(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;
-	} */ *ap;
-{
-
-	if (!chkvnlock(ap->a_vp))
-		return (EIO);
-	return (VOP_BMAP(ap->a_vp, ap->a_bn, ap->a_vpp, ap->a_bnp, ap->a_runp, ap->a_runb));
-}
-
-/*
- * Print out the contents of a dead vnode.
- */
-/* ARGSUSED */
-static int
-dead_print(ap)
-	struct vop_print_args /* {
-		struct vnode *a_vp;
-	} */ *ap;
-{
-
-	printf("tag VT_NON, dead vnode\n");
-	return (0);
-}
-
-/*
- * Empty vnode bad operation
- */
-static int
-dead_badop()
-{
-
-	panic("dead_badop called");
-	/* NOTREACHED */
-}
-
-/*
- * We have to wait during times when the vnode is
- * in a state of change.
- */
-int
-chkvnlock(vp)
-	register struct vnode *vp;
-{
-	int locked = 0;
-
-	while (vp->v_flag & VXLOCK) {
-		vp->v_flag |= VXWANT;
-		(void) tsleep((caddr_t)vp, PINOD, "ckvnlk", 0);
-		locked = 1;
-	}
-	return (locked);
-}
-
-/*
- * Trivial poll routine that always returns POLLHUP.
- * This is necessary so that a process which is polling a file
- * gets notified when that file is revoke()d.
- */
-static int
-dead_poll(ap)
-	struct vop_poll_args *ap;
-{
-	return (POLLHUP);
-}
diff --git a/sys/miscfs/fdesc/fdesc.h b/sys/miscfs/fdesc/fdesc.h
deleted file mode 100644
index b78d132..0000000
--- a/sys/miscfs/fdesc/fdesc.h
+++ /dev/null
@@ -1,69 +0,0 @@
-/*
- * Copyright (c) 1992, 1993
- *	The Regents of the University of California.  All rights reserved.
- *
- * This code is derived from software donated to Berkeley by
- * Jan-Simon Pendry.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)fdesc.h	8.5 (Berkeley) 1/21/94
- *
- * $FreeBSD$
- */
-
-#ifdef _KERNEL
-struct fdescmount {
-	struct vnode	*f_root;	/* Root node */
-};
-
-#define FD_ROOT		1
-#define FD_DESC		3
-
-typedef enum {
-	Froot,
-	Fdesc
-} fdntype;
-
-struct fdescnode {
-	LIST_ENTRY(fdescnode) fd_hash;	/* Hash list */
-	struct vnode	*fd_vnode;	/* Back ptr to vnode */
-	fdntype		fd_type;	/* Type of this node */
-	unsigned	fd_fd;		/* Fd to be dup'ed */
-	int		fd_ix;		/* filesystem index */
-};
-
-#define VFSTOFDESC(mp)	((struct fdescmount *)((mp)->mnt_data))
-#define	VTOFDESC(vp) ((struct fdescnode *)(vp)->v_data)
-
-extern int fdesc_init __P((struct vfsconf *));
-extern int fdesc_root __P((struct mount *, struct vnode **));
-extern int fdesc_allocvp __P((fdntype, int, struct mount *, struct vnode **,
-			      struct proc *));
-#endif /* _KERNEL */
diff --git a/sys/miscfs/fdesc/fdesc_vfsops.c b/sys/miscfs/fdesc/fdesc_vfsops.c
deleted file mode 100644
index a758bb8..0000000
--- a/sys/miscfs/fdesc/fdesc_vfsops.c
+++ /dev/null
@@ -1,226 +0,0 @@
-/*
- * Copyright (c) 1992, 1993, 1995
- *	The Regents of the University of California.  All rights reserved.
- *
- * This code is derived from software donated to Berkeley by
- * Jan-Simon Pendry.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)fdesc_vfsops.c	8.4 (Berkeley) 1/21/94
- *
- * $FreeBSD$
- */
-
-/*
- * /dev/fd Filesystem
- */
-
-#include <sys/param.h>
-#include <sys/systm.h>
-#include <sys/filedesc.h>
-#include <sys/kernel.h>
-#include <sys/lock.h>
-#include <sys/malloc.h>
-#include <sys/mount.h>
-#include <sys/proc.h>
-#include <sys/resourcevar.h>
-#include <sys/socket.h>
-#include <sys/vnode.h>
-
-#include <miscfs/fdesc/fdesc.h>
-
-static MALLOC_DEFINE(M_FDESCMNT, "FDESC mount", "FDESC mount structure");
-
-static int	fdesc_mount __P((struct mount *mp, char *path, caddr_t data,
-				 struct nameidata *ndp, struct proc *p));
-static int	fdesc_unmount __P((struct mount *mp, int mntflags,
-				   struct proc *p));
-static int	fdesc_statfs __P((struct mount *mp, struct statfs *sbp,
-				  struct proc *p));
-  
-/*
- * Mount the per-process file descriptors (/dev/fd)
- */
-static int
-fdesc_mount(mp, path, data, ndp, p)
-	struct mount *mp;
-	char *path;
-	caddr_t data;
-	struct nameidata *ndp;
-	struct proc *p;
-{
-	int error = 0;
-	struct fdescmount *fmp;
-	struct vnode *rvp;
-
-	/*
-	 * Update is a no-op
-	 */
-	if (mp->mnt_flag & MNT_UPDATE)
-		return (EOPNOTSUPP);
-
-	error = fdesc_allocvp(Froot, FD_ROOT, mp, &rvp, p);
-	if (error)
-		return (error);
-
-	MALLOC(fmp, struct fdescmount *, sizeof(struct fdescmount),
-				M_FDESCMNT, M_WAITOK);	/* XXX */
-	rvp->v_type = VDIR;
-	rvp->v_flag |= VROOT;
-	fmp->f_root = rvp;
-	/* XXX -- don't mark as local to work around fts() problems */
-	/*mp->mnt_flag |= MNT_LOCAL;*/
-	mp->mnt_data = (qaddr_t) fmp;
-	vfs_getnewfsid(mp);
-
-	bzero(mp->mnt_stat.f_mntfromname, MNAMELEN);
-	bcopy("fdesc", mp->mnt_stat.f_mntfromname, sizeof("fdesc"));
-	(void)fdesc_statfs(mp, &mp->mnt_stat, p);
-	return (0);
-}
-
-static int
-fdesc_unmount(mp, mntflags, p)
-	struct mount *mp;
-	int mntflags;
-	struct proc *p;
-{
-	int error;
-	int flags = 0;
-
-	if (mntflags & MNT_FORCE)
-		flags |= FORCECLOSE;
-
-	/*
-	 * Clear out buffer cache.  I don't think we
-	 * ever get anything cached at this level at the
-	 * moment, but who knows...
-	 *
-	 * There is 1 extra root vnode reference corresponding
-	 * to f_root.
-	 */
-	if ((error = vflush(mp, 1, flags)) != 0)
-		return (error);
-
-	/*
-	 * Finally, throw away the fdescmount structure
-	 */
-	free(mp->mnt_data, M_FDESCMNT);	/* XXX */
-	mp->mnt_data = 0;
-
-	return (0);
-}
-
-int
-fdesc_root(mp, vpp)
-	struct mount *mp;
-	struct vnode **vpp;
-{
-	struct proc *p = curproc;	/* XXX */
-	struct vnode *vp;
-
-	/*
-	 * Return locked reference to root.
-	 */
-	vp = VFSTOFDESC(mp)->f_root;
-	VREF(vp);
-	vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
-	*vpp = vp;
-	return (0);
-}
-
-static int
-fdesc_statfs(mp, sbp, p)
-	struct mount *mp;
-	struct statfs *sbp;
-	struct proc *p;
-{
-	struct filedesc *fdp;
-	int lim;
-	int i;
-	int last;
-	int freefd;
-
-	/*
-	 * Compute number of free file descriptors.
-	 * [ Strange results will ensue if the open file
-	 * limit is ever reduced below the current number
-	 * of open files... ]
-	 */
-	lim = p->p_rlimit[RLIMIT_NOFILE].rlim_cur;
-	fdp = p->p_fd;
-	last = min(fdp->fd_nfiles, lim);
-	freefd = 0;
-	for (i = fdp->fd_freefile; i < last; i++)
-		if (fdp->fd_ofiles[i] == NULL)
-			freefd++;
-
-	/*
-	 * Adjust for the fact that the fdesc array may not
-	 * have been fully allocated yet.
-	 */
-	if (fdp->fd_nfiles < lim)
-		freefd += (lim - fdp->fd_nfiles);
-
-	sbp->f_flags = 0;
-	sbp->f_bsize = DEV_BSIZE;
-	sbp->f_iosize = DEV_BSIZE;
-	sbp->f_blocks = 2;		/* 1K to keep df happy */
-	sbp->f_bfree = 0;
-	sbp->f_bavail = 0;
-	sbp->f_files = lim + 1;		/* Allow for "." */
-	sbp->f_ffree = freefd;		/* See comments above */
-	if (sbp != &mp->mnt_stat) {
-		sbp->f_type = mp->mnt_vfc->vfc_typenum;
-		bcopy(&mp->mnt_stat.f_fsid, &sbp->f_fsid, sizeof(sbp->f_fsid));
-		bcopy(mp->mnt_stat.f_mntonname, sbp->f_mntonname, MNAMELEN);
-		bcopy(mp->mnt_stat.f_mntfromname, sbp->f_mntfromname, MNAMELEN);
-	}
-	return (0);
-}
-
-static struct vfsops fdesc_vfsops = {
-	fdesc_mount,
-	vfs_stdstart,
-	fdesc_unmount,
-	fdesc_root,
-	vfs_stdquotactl,
-	fdesc_statfs,
-	vfs_stdsync,
-	vfs_stdvget,
-	vfs_stdfhtovp,
-	vfs_stdcheckexp,
-	vfs_stdvptofh,
-	fdesc_init,
-	vfs_stduninit,
-	vfs_stdextattrctl,
-};
-
-VFS_SET(fdesc_vfsops, fdesc, VFCF_SYNTHETIC);
diff --git a/sys/miscfs/fdesc/fdesc_vnops.c b/sys/miscfs/fdesc/fdesc_vnops.c
deleted file mode 100644
index 065e0a8..0000000
--- a/sys/miscfs/fdesc/fdesc_vnops.c
+++ /dev/null
@@ -1,576 +0,0 @@
-/*
- * Copyright (c) 1992, 1993
- *	The Regents of the University of California.  All rights reserved.
- *
- * This code is derived from software donated to Berkeley by
- * Jan-Simon Pendry.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)fdesc_vnops.c	8.9 (Berkeley) 1/21/94
- *
- * $FreeBSD$
- */
-
-/*
- * /dev/fd Filesystem
- */
-
-#include <sys/param.h>
-#include <sys/systm.h>
-#include <sys/conf.h>
-#include <sys/dirent.h>
-#include <sys/filedesc.h>
-#include <sys/kernel.h>	/* boottime */
-#include <sys/lock.h>
-#include <sys/malloc.h>
-#include <sys/file.h>	/* Must come after sys/malloc.h */
-#include <sys/mount.h>
-#include <sys/namei.h>
-#include <sys/proc.h>
-#include <sys/socket.h>
-#include <sys/stat.h>
-#include <sys/vnode.h>
-
-#include <miscfs/fdesc/fdesc.h>
-
-#define FDL_WANT	0x01
-#define FDL_LOCKED	0x02
-static int fdcache_lock;
-
-static vop_t **fdesc_vnodeop_p;
-
-#define	NFDCACHE 4
-#define FD_NHASH(ix) \
-	(&fdhashtbl[(ix) & fdhash])
-static LIST_HEAD(fdhashhead, fdescnode) *fdhashtbl;
-static u_long fdhash;
-
-static int	fdesc_badop __P((void));
-static int	fdesc_getattr __P((struct vop_getattr_args *ap));
-static int	fdesc_inactive __P((struct vop_inactive_args *ap));
-static int	fdesc_lookup __P((struct vop_lookup_args *ap));
-static int	fdesc_open __P((struct vop_open_args *ap));
-static int	fdesc_print __P((struct vop_print_args *ap));
-static int	fdesc_readdir __P((struct vop_readdir_args *ap));
-static int	fdesc_reclaim __P((struct vop_reclaim_args *ap));
-static int	fdesc_poll __P((struct vop_poll_args *ap));
-static int	fdesc_setattr __P((struct vop_setattr_args *ap));
-
-/*
- * Initialise cache headers
- */
-int
-fdesc_init(vfsp)
-	struct vfsconf *vfsp;
-{
-
-	fdhashtbl = hashinit(NFDCACHE, M_CACHE, &fdhash);
-	return (0);
-}
-
-int
-fdesc_allocvp(ftype, ix, mp, vpp, p)
-	fdntype ftype;
-	int ix;
-	struct mount *mp;
-	struct vnode **vpp;
-	struct proc *p;
-{
-	struct fdhashhead *fc;
-	struct fdescnode *fd;
-	int error = 0;
-
-	fc = FD_NHASH(ix);
-loop:
-	LIST_FOREACH(fd, fc, fd_hash) {
-		if (fd->fd_ix == ix && fd->fd_vnode->v_mount == mp) {
-			if (vget(fd->fd_vnode, 0, p))
-				goto loop;
-			*vpp = fd->fd_vnode;
-			return (error);
-		}
-	}
-
-	/*
-	 * otherwise lock the array while we call getnewvnode
-	 * since that can block.
-	 */
-	if (fdcache_lock & FDL_LOCKED) {
-		fdcache_lock |= FDL_WANT;
-		(void) tsleep((caddr_t) &fdcache_lock, PINOD, "fdalvp", 0);
-		goto loop;
-	}
-	fdcache_lock |= FDL_LOCKED;
-
-	/*
-	 * Do the MALLOC before the getnewvnode since doing so afterward
-	 * might cause a bogus v_data pointer to get dereferenced
-	 * elsewhere if MALLOC should block.
-	 */
-	MALLOC(fd, struct fdescnode *, sizeof(struct fdescnode), M_TEMP, M_WAITOK);
-
-	error = getnewvnode(VT_FDESC, mp, fdesc_vnodeop_p, vpp);
-	if (error) {
-		FREE(fd, M_TEMP);
-		goto out;
-	}
-	(*vpp)->v_data = fd;
-	fd->fd_vnode = *vpp;
-	fd->fd_type = ftype;
-	fd->fd_fd = -1;
-	fd->fd_ix = ix;
-	LIST_INSERT_HEAD(fc, fd, fd_hash);
-
-out:
-	fdcache_lock &= ~FDL_LOCKED;
-
-	if (fdcache_lock & FDL_WANT) {
-		fdcache_lock &= ~FDL_WANT;
-		wakeup((caddr_t) &fdcache_lock);
-	}
-
-	return (error);
-}
-
-/*
- * vp is the current namei directory
- * ndp is the name to locate in that directory...
- */
-static int
-fdesc_lookup(ap)
-	struct vop_lookup_args /* {
-		struct vnode * a_dvp;
-		struct vnode ** a_vpp;
-		struct componentname * a_cnp;
-	} */ *ap;
-{
-	struct vnode **vpp = ap->a_vpp;
-	struct vnode *dvp = ap->a_dvp;
-	struct componentname *cnp = ap->a_cnp;
-	char *pname = cnp->cn_nameptr;
-	struct proc *p = cnp->cn_proc;
-	int nlen = cnp->cn_namelen;
-	int nfiles = p->p_fd->fd_nfiles;
-	u_int fd;
-	int error;
-	struct vnode *fvp;
-
-	if (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME) {
-		error = EROFS;
-		goto bad;
-	}
-
-	VOP_UNLOCK(dvp, 0, p);
-	if (cnp->cn_namelen == 1 && *pname == '.') {
-		*vpp = dvp;
-		VREF(dvp);	
-		vn_lock(dvp, LK_SHARED | LK_RETRY, p);
-		return (0);
-	}
-
-	if (VTOFDESC(dvp)->fd_type != Froot) {
-		error = ENOTDIR;
-		goto bad;
-	}
-
-	fd = 0;
-	/* the only time a leading 0 is acceptable is if it's "0" */
-	if (*pname == '0' && nlen != 1) {
-		error = ENOENT;
-		goto bad;
-	}
-	while (nlen--) {
-		if (*pname < '0' || *pname > '9') {
-			error = ENOENT;
-			goto bad;
-		}
-		fd = 10 * fd + *pname++ - '0';
-	}
-
-	if (fd >= nfiles || p->p_fd->fd_ofiles[fd] == NULL) {
-		error = EBADF;
-		goto bad;
-	}
-
-	error = fdesc_allocvp(Fdesc, FD_DESC+fd, dvp->v_mount, &fvp, p);
-	if (error)
-		goto bad;
-	VTOFDESC(fvp)->fd_fd = fd;
-	vn_lock(fvp, LK_SHARED | LK_RETRY, p);
-	*vpp = fvp;
-	return (0);
-
-bad:
-	vn_lock(dvp, LK_SHARED | LK_RETRY, p);
-	*vpp = NULL;
-	return (error);
-}
-
-static int
-fdesc_open(ap)
-	struct vop_open_args /* {
-		struct vnode *a_vp;
-		int  a_mode;
-		struct ucred *a_cred;
-		struct proc *a_p;
-	} */ *ap;
-{
-	struct vnode *vp = ap->a_vp;
-
-	if (VTOFDESC(vp)->fd_type == Froot)
-		return (0);
-
-	/*
-	 * XXX Kludge: set p->p_dupfd to contain the value of the the file
-	 * descriptor being sought for duplication. The error return ensures
-	 * that the vnode for this device will be released by vn_open. Open
-	 * will detect this special error and take the actions in dupfdopen.
-	 * Other callers of vn_open or VOP_OPEN will simply report the
-	 * error.
-	 */
-	ap->a_p->p_dupfd = VTOFDESC(vp)->fd_fd;	/* XXX */
-	return (ENODEV);
-}
-
-static int
-fdesc_getattr(ap)
-	struct vop_getattr_args /* {
-		struct vnode *a_vp;
-		struct vattr *a_vap;
-		struct ucred *a_cred;
-		struct proc *a_p;
-	} */ *ap;
-{
-	struct vnode *vp = ap->a_vp;
-	struct vattr *vap = ap->a_vap;
-	struct filedesc *fdp = ap->a_p->p_fd;
-	struct file *fp;
-	struct stat stb;
-	u_int fd;
-	int error = 0;
-
-	switch (VTOFDESC(vp)->fd_type) {
-	case Froot:
-		VATTR_NULL(vap);
-
-		vap->va_mode = S_IRUSR|S_IXUSR|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH;
-		vap->va_type = VDIR;
-		vap->va_nlink = 2;
-		vap->va_size = DEV_BSIZE;
-		vap->va_fileid = VTOFDESC(vp)->fd_ix;
-		vap->va_uid = 0;
-		vap->va_gid = 0;
-		vap->va_blocksize = DEV_BSIZE;
-		vap->va_atime.tv_sec = boottime.tv_sec;
-		vap->va_atime.tv_nsec = 0;
-		vap->va_mtime = vap->va_atime;
-		vap->va_ctime = vap->va_mtime;
-		vap->va_gen = 0;
-		vap->va_flags = 0;
-		vap->va_rdev = 0;
-		vap->va_bytes = 0;
-		break;
-
-	case Fdesc:
-		fd = VTOFDESC(vp)->fd_fd;
-
-		if (fd >= fdp->fd_nfiles || (fp = fdp->fd_ofiles[fd]) == NULL)
-			return (EBADF);
-
-		bzero(&stb, sizeof(stb));
-		error = fo_stat(fp, &stb, ap->a_p);
-		if (error == 0) {
-			VATTR_NULL(vap);
-			vap->va_type = IFTOVT(stb.st_mode);
-			vap->va_mode = stb.st_mode;
-#define FDRX (VREAD|VEXEC)
-			if (vap->va_type == VDIR)
-				vap->va_mode &= ~((FDRX)|(FDRX>>3)|(FDRX>>6));
-#undef FDRX
-			vap->va_nlink = 1;
-			vap->va_flags = 0;
-			vap->va_bytes = stb.st_blocks * stb.st_blksize;
-			vap->va_fileid = VTOFDESC(vp)->fd_ix;
-			vap->va_size = stb.st_size;
-			vap->va_blocksize = stb.st_blksize;
-			vap->va_rdev = stb.st_rdev;
-
-			/*
-			 * If no time data is provided, use the current time.
-			 */
-			if (stb.st_atimespec.tv_sec == 0 &&
-			    stb.st_atimespec.tv_nsec == 0)
-				nanotime(&stb.st_atimespec);
-
-			if (stb.st_ctimespec.tv_sec == 0 &&
-			    stb.st_ctimespec.tv_nsec == 0)
-				nanotime(&stb.st_ctimespec);
-
-			if (stb.st_mtimespec.tv_sec == 0 &&
-			    stb.st_mtimespec.tv_nsec == 0)
-				nanotime(&stb.st_mtimespec);
-
-			vap->va_atime = stb.st_atimespec;
-			vap->va_mtime = stb.st_mtimespec;
-			vap->va_ctime = stb.st_ctimespec;
-			vap->va_uid = stb.st_uid;
-			vap->va_gid = stb.st_gid;
-		}
-		break;
-
-	default:
-		panic("fdesc_getattr");
-		break;
-	}
-
-	if (error == 0)
-		vp->v_type = vap->va_type;
-	return (error);
-}
-
-static int
-fdesc_setattr(ap)
-	struct vop_setattr_args /* {
-		struct vnode *a_vp;
-		struct vattr *a_vap;
-		struct ucred *a_cred;
-		struct proc *a_p;
-	} */ *ap;
-{
-	struct vattr *vap = ap->a_vap;
-	struct vnode *vp;
-	struct mount *mp;
-	struct file *fp;
-	unsigned fd;
-	int error;
-
-	/*
-	 * Can't mess with the root vnode
-	 */
-	if (VTOFDESC(ap->a_vp)->fd_type == Froot)
-		return (EACCES);
-
-	fd = VTOFDESC(ap->a_vp)->fd_fd;
-
-	/*
-	 * Allow setattr where there is an underlying vnode.
-	 */
-	error = getvnode(ap->a_p->p_fd, fd, &fp);
-	if (error) {
-		/*
-		 * getvnode() returns EINVAL if the file descriptor is not
-		 * backed by a vnode.  Silently drop all changes except
-		 * chflags(2) in this case.
-		 */
-		if (error == EINVAL) {
-			if (vap->va_flags != VNOVAL)
-				error = EOPNOTSUPP;
-			else
-				error = 0;
-		}
-		return (error);
-	}
-	vp = (struct vnode *)fp->f_data;
-	if ((error = vn_start_write(vp, &mp, V_WAIT | PCATCH)) != 0)
-		return (error);
-	error = VOP_SETATTR(vp, ap->a_vap, ap->a_cred, ap->a_p);
-	vn_finished_write(mp);
-	return (error);
-}
-
-#define UIO_MX 16
-
-static int
-fdesc_readdir(ap)
-	struct vop_readdir_args /* {
-		struct vnode *a_vp;
-		struct uio *a_uio;
-		struct ucred *a_cred;
-		int *a_eofflag;
-		u_long *a_cookies;
-		int a_ncookies;
-	} */ *ap;
-{
-	struct uio *uio = ap->a_uio;
-	struct filedesc *fdp;
-	struct dirent d;
-	struct dirent *dp = &d;
-	int error, i, off, fcnt;
-
-	/*
-	 * We don't allow exporting fdesc mounts, and currently local
-	 * requests do not need cookies.
-	 */
-	if (ap->a_ncookies)
-		panic("fdesc_readdir: not hungry");
-
-	if (VTOFDESC(ap->a_vp)->fd_type != Froot)
-		panic("fdesc_readdir: not dir");
-
-	off = (int)uio->uio_offset;
-	if (off != uio->uio_offset || off < 0 || (u_int)off % UIO_MX != 0 ||
-	    uio->uio_resid < UIO_MX)
-		return (EINVAL);
-	i = (u_int)off / UIO_MX;
-	fdp = uio->uio_procp->p_fd;
-	error = 0;
-
-	fcnt = i - 2;		/* The first two nodes are `.' and `..' */
-
-	while (i < fdp->fd_nfiles + 2 && uio->uio_resid >= UIO_MX) {
-		switch (i) {
-		case 0:	/* `.' */
-		case 1: /* `..' */
-			bzero((caddr_t)dp, UIO_MX);
-
-			dp->d_fileno = i + FD_ROOT;
-			dp->d_namlen = i + 1;
-			dp->d_reclen = UIO_MX;
-			bcopy("..", dp->d_name, dp->d_namlen);
-			dp->d_name[i + 1] = '\0';
-			dp->d_type = DT_DIR;
-			break;
-		default:
-			if (fdp->fd_ofiles[fcnt] == NULL)
-				goto done;
-
-			bzero((caddr_t) dp, UIO_MX);
-			dp->d_namlen = sprintf(dp->d_name, "%d", fcnt);
-			dp->d_reclen = UIO_MX;
-			dp->d_type = DT_UNKNOWN;
-			dp->d_fileno = i + FD_DESC;
-			break;
-		}
-		/*
-		 * And ship to userland
-		 */
-		error = uiomove((caddr_t) dp, UIO_MX, uio);
-		if (error)
-			break;
-		i++;
-		fcnt++;
-	}
-
-done:
-	uio->uio_offset = i * UIO_MX;
-	return (error);
-}
-
-static int
-fdesc_poll(ap)
-	struct vop_poll_args /* {
-		struct vnode *a_vp;
-		int  a_events;
-		struct ucred *a_cred;
-		struct proc *a_p;
-	} */ *ap;
-{
-	return seltrue(0, ap->a_events, ap->a_p);
-}
-
-static int
-fdesc_inactive(ap)
-	struct vop_inactive_args /* {
-		struct vnode *a_vp;
-		struct proc *a_p;
-	} */ *ap;
-{
-	struct vnode *vp = ap->a_vp;
-
-	/*
-	 * Clear out the v_type field to avoid
-	 * nasty things happening in vgone().
-	 */
-	VOP_UNLOCK(vp, 0, ap->a_p);
-	vp->v_type = VNON;
-	return (0);
-}
-
-static int
-fdesc_reclaim(ap)
-	struct vop_reclaim_args /* {
-		struct vnode *a_vp;
-	} */ *ap;
-{
-	struct vnode *vp = ap->a_vp;
-	struct fdescnode *fd = VTOFDESC(vp);
-
-	LIST_REMOVE(fd, fd_hash);
-	FREE(vp->v_data, M_TEMP);
-	vp->v_data = 0;
-
-	return (0);
-}
-
-/*
- * Print out the contents of a /dev/fd vnode.
- */
-/* ARGSUSED */
-static int
-fdesc_print(ap)
-	struct vop_print_args /* {
-		struct vnode *a_vp;
-	} */ *ap;
-{
-
-	printf("tag VT_NON, fdesc vnode\n");
-	return (0);
-}
-
-/*
- * /dev/fd "should never get here" operation
- */
-static int
-fdesc_badop()
-{
-
-	panic("fdesc: bad op");
-	/* NOTREACHED */
-}
-
-static struct vnodeopv_entry_desc fdesc_vnodeop_entries[] = {
-	{ &vop_default_desc,		(vop_t *) vop_defaultop },
-	{ &vop_access_desc,		(vop_t *) vop_null },
-	{ &vop_getattr_desc,		(vop_t *) fdesc_getattr },
-	{ &vop_inactive_desc,		(vop_t *) fdesc_inactive },
-	{ &vop_lookup_desc,		(vop_t *) fdesc_lookup },
-	{ &vop_open_desc,		(vop_t *) fdesc_open },
-	{ &vop_pathconf_desc,		(vop_t *) vop_stdpathconf },
-	{ &vop_poll_desc,		(vop_t *) fdesc_poll },
-	{ &vop_print_desc,		(vop_t *) fdesc_print },
-	{ &vop_readdir_desc,		(vop_t *) fdesc_readdir },
-	{ &vop_reclaim_desc,		(vop_t *) fdesc_reclaim },
-	{ &vop_setattr_desc,		(vop_t *) fdesc_setattr },
-	{ NULL, NULL }
-};
-static struct vnodeopv_desc fdesc_vnodeop_opv_desc =
-	{ &fdesc_vnodeop_p, fdesc_vnodeop_entries };
-
-VNODEOP_SET(fdesc_vnodeop_opv_desc);
diff --git a/sys/miscfs/fifofs/fifo.h b/sys/miscfs/fifofs/fifo.h
deleted file mode 100644
index e630207..0000000
--- a/sys/miscfs/fifofs/fifo.h
+++ /dev/null
@@ -1,44 +0,0 @@
-/*
- * Copyright (c) 1991, 1993
- *	The Regents of the University of California.  All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)fifo.h	8.6 (Berkeley) 5/21/95
- * $FreeBSD$
- */
-
-extern vop_t **fifo_vnodeop_p;
-
-/*
- * Prototypes for fifo operations on vnodes.
- */
-int	fifo_vnoperate __P((struct vop_generic_args *));
-int	fifo_printinfo __P((struct vnode *));
-
diff --git a/sys/miscfs/fifofs/fifo_vnops.c b/sys/miscfs/fifofs/fifo_vnops.c
deleted file mode 100644
index 3cd5425..0000000
--- a/sys/miscfs/fifofs/fifo_vnops.c
+++ /dev/null
@@ -1,587 +0,0 @@
-/*
- * Copyright (c) 1990, 1993, 1995
- *	The Regents of the University of California.  All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)fifo_vnops.c	8.10 (Berkeley) 5/27/95
- * $FreeBSD$
- */
-
-#include <sys/param.h>
-#include <sys/systm.h>
-#include <sys/unistd.h>
-#include <sys/kernel.h>
-#include <sys/lock.h>
-#include <sys/malloc.h>
-#include <sys/vnode.h>
-#include <sys/socket.h>
-#include <sys/socketvar.h>
-#include <sys/filio.h>
-#include <sys/fcntl.h>
-#include <sys/file.h>
-#include <sys/event.h>
-#include <sys/poll.h>
-#include <sys/un.h>
-#include <miscfs/fifofs/fifo.h>
-
-/*
- * This structure is associated with the FIFO vnode and stores
- * the state associated with the FIFO.
- */
-struct fifoinfo {
-	struct socket	*fi_readsock;
-	struct socket	*fi_writesock;
-	long		fi_readers;
-	long		fi_writers;
-};
-
-static int	fifo_badop __P((void));
-static int	fifo_print __P((struct vop_print_args *));
-static int	fifo_lookup __P((struct vop_lookup_args *));
-static int	fifo_open __P((struct vop_open_args *));
-static int	fifo_close __P((struct vop_close_args *));
-static int	fifo_read __P((struct vop_read_args *));
-static int	fifo_write __P((struct vop_write_args *));
-static int	fifo_ioctl __P((struct vop_ioctl_args *));
-static int	fifo_poll __P((struct vop_poll_args *));
-static int	fifo_kqfilter __P((struct vop_kqfilter_args *));
-static int	fifo_pathconf __P((struct vop_pathconf_args *));
-static int	fifo_advlock __P((struct vop_advlock_args *));
-
-static void	filt_fifordetach(struct knote *kn);
-static int	filt_fiforead(struct knote *kn, long hint);
-static void	filt_fifowdetach(struct knote *kn);
-static int	filt_fifowrite(struct knote *kn, long hint);
-
-static struct filterops fiforead_filtops =
-	{ 1, NULL, filt_fifordetach, filt_fiforead };
-static struct filterops fifowrite_filtops =
-	{ 1, NULL, filt_fifowdetach, filt_fifowrite };
-
-vop_t **fifo_vnodeop_p;
-static struct vnodeopv_entry_desc fifo_vnodeop_entries[] = {
-	{ &vop_default_desc,		(vop_t *) vop_defaultop },
-	{ &vop_access_desc,		(vop_t *) vop_ebadf },
-	{ &vop_advlock_desc,		(vop_t *) fifo_advlock },
-	{ &vop_close_desc,		(vop_t *) fifo_close },
-	{ &vop_create_desc,		(vop_t *) fifo_badop },
-	{ &vop_getattr_desc,		(vop_t *) vop_ebadf },
-	{ &vop_getwritemount_desc, 	(vop_t *) vop_stdgetwritemount },
-	{ &vop_ioctl_desc,		(vop_t *) fifo_ioctl },
-	{ &vop_lease_desc,		(vop_t *) vop_null },
-	{ &vop_link_desc,		(vop_t *) fifo_badop },
-	{ &vop_lookup_desc,		(vop_t *) fifo_lookup },
-	{ &vop_mkdir_desc,		(vop_t *) fifo_badop },
-	{ &vop_mknod_desc,		(vop_t *) fifo_badop },
-	{ &vop_open_desc,		(vop_t *) fifo_open },
-	{ &vop_pathconf_desc,		(vop_t *) fifo_pathconf },
-	{ &vop_poll_desc,		(vop_t *) fifo_poll },
-	{ &vop_kqfilter_desc,		(vop_t *) fifo_kqfilter },
-	{ &vop_print_desc,		(vop_t *) fifo_print },
-	{ &vop_read_desc,		(vop_t *) fifo_read },
-	{ &vop_readdir_desc,		(vop_t *) fifo_badop },
-	{ &vop_readlink_desc,		(vop_t *) fifo_badop },
-	{ &vop_reallocblks_desc,	(vop_t *) fifo_badop },
-	{ &vop_reclaim_desc,		(vop_t *) vop_null },
-	{ &vop_remove_desc,		(vop_t *) fifo_badop },
-	{ &vop_rename_desc,		(vop_t *) fifo_badop },
-	{ &vop_rmdir_desc,		(vop_t *) fifo_badop },
-	{ &vop_setattr_desc,		(vop_t *) vop_ebadf },
-	{ &vop_symlink_desc,		(vop_t *) fifo_badop },
-	{ &vop_write_desc,		(vop_t *) fifo_write },
-	{ NULL, NULL }
-};
-static struct vnodeopv_desc fifo_vnodeop_opv_desc =
-	{ &fifo_vnodeop_p, fifo_vnodeop_entries };
-
-VNODEOP_SET(fifo_vnodeop_opv_desc);
-
-int
-fifo_vnoperate(ap)
-	struct vop_generic_args /* {
-		struct vnodeop_desc *a_desc;
-		<other random data follows, presumably>
-	} */ *ap;
-{
-	return (VOCALL(fifo_vnodeop_p, ap->a_desc->vdesc_offset, ap));
-}
-
-/*
- * Trivial lookup routine that always fails.
- */
-/* ARGSUSED */
-static int
-fifo_lookup(ap)
-	struct vop_lookup_args /* {
-		struct vnode * a_dvp;
-		struct vnode ** a_vpp;
-		struct componentname * a_cnp;
-	} */ *ap;
-{
-
-	*ap->a_vpp = NULL;
-	return (ENOTDIR);
-}
-
-/*
- * Open called to set up a new instance of a fifo or
- * to find an active instance of a fifo.
- */
-/* ARGSUSED */
-static int
-fifo_open(ap)
-	struct vop_open_args /* {
-		struct vnode *a_vp;
-		int  a_mode;
-		struct ucred *a_cred;
-		struct proc *a_p;
-	} */ *ap;
-{
-	struct vnode *vp = ap->a_vp;
-	struct fifoinfo *fip;
-	struct proc *p = ap->a_p;
-	struct socket *rso, *wso;
-	int error;
-
-	if ((fip = vp->v_fifoinfo) == NULL) {
-		MALLOC(fip, struct fifoinfo *, sizeof(*fip), M_VNODE, M_WAITOK);
-		vp->v_fifoinfo = fip;
-		error = socreate(AF_LOCAL, &rso, SOCK_STREAM, 0, ap->a_p);
-		if (error) {
-			free(fip, M_VNODE);
-			vp->v_fifoinfo = NULL;
-			return (error);
-		}
-		fip->fi_readsock = rso;
-		error = socreate(AF_LOCAL, &wso, SOCK_STREAM, 0, ap->a_p);
-		if (error) {
-			(void)soclose(rso);
-			free(fip, M_VNODE);
-			vp->v_fifoinfo = NULL;
-			return (error);
-		}
-		fip->fi_writesock = wso;
-		error = unp_connect2(wso, rso);
-		if (error) {
-			(void)soclose(wso);
-			(void)soclose(rso);
-			free(fip, M_VNODE);
-			vp->v_fifoinfo = NULL;
-			return (error);
-		}
-		fip->fi_readers = fip->fi_writers = 0;
-		wso->so_snd.sb_lowat = PIPE_BUF;
-		rso->so_state |= SS_CANTRCVMORE;
-	}
-	if (ap->a_mode & FREAD) {
-		fip->fi_readers++;
-		if (fip->fi_readers == 1) {
-			fip->fi_writesock->so_state &= ~SS_CANTSENDMORE;
-			if (fip->fi_writers > 0)
-				wakeup((caddr_t)&fip->fi_writers);
-		}
-	}
-	if (ap->a_mode & FWRITE) {
-		fip->fi_writers++;
-		if (fip->fi_writers == 1) {
-			fip->fi_readsock->so_state &= ~SS_CANTRCVMORE;
-			if (fip->fi_readers > 0)
-				wakeup((caddr_t)&fip->fi_readers);
-		}
-	}
-	if ((ap->a_mode & FREAD) && (ap->a_mode & O_NONBLOCK) == 0) {
-		while (fip->fi_writers == 0) {
-			VOP_UNLOCK(vp, 0, p);
-			error = tsleep((caddr_t)&fip->fi_readers,
-			    PCATCH | PSOCK, "fifoor", 0);
-			vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
-			if (error)
-				goto bad;
-		}
-	}
-	if (ap->a_mode & FWRITE) {
-		if (ap->a_mode & O_NONBLOCK) {
-			if (fip->fi_readers == 0) {
-				error = ENXIO;
-				goto bad;
-			}
-		} else {
-			while (fip->fi_readers == 0) {
-				VOP_UNLOCK(vp, 0, p);
-				error = tsleep((caddr_t)&fip->fi_writers,
-				    PCATCH | PSOCK, "fifoow", 0);
-				vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
-				if (error)
-					goto bad;
-			}
-		}
-	}
-	return (0);
-bad:
-	VOP_CLOSE(vp, ap->a_mode, ap->a_cred, p);
-	return (error);
-}
-
-/*
- * Vnode op for read
- */
-/* ARGSUSED */
-static int
-fifo_read(ap)
-	struct vop_read_args /* {
-		struct vnode *a_vp;
-		struct uio *a_uio;
-		int  a_ioflag;
-		struct ucred *a_cred;
-	} */ *ap;
-{
-	struct uio *uio = ap->a_uio;
-	struct socket *rso = ap->a_vp->v_fifoinfo->fi_readsock;
-	struct proc *p = uio->uio_procp;
-	int error, startresid;
-
-#ifdef DIAGNOSTIC
-	if (uio->uio_rw != UIO_READ)
-		panic("fifo_read mode");
-#endif
-	if (uio->uio_resid == 0)
-		return (0);
-	if (ap->a_ioflag & IO_NDELAY)
-		rso->so_state |= SS_NBIO;
-	startresid = uio->uio_resid;
-	VOP_UNLOCK(ap->a_vp, 0, p);
-	error = soreceive(rso, (struct sockaddr **)0, uio, (struct mbuf **)0,
-	    (struct mbuf **)0, (int *)0);
-	vn_lock(ap->a_vp, LK_EXCLUSIVE | LK_RETRY, p);
-	if (ap->a_ioflag & IO_NDELAY)
-		rso->so_state &= ~SS_NBIO;
-	return (error);
-}
-
-/*
- * Vnode op for write
- */
-/* ARGSUSED */
-static int
-fifo_write(ap)
-	struct vop_write_args /* {
-		struct vnode *a_vp;
-		struct uio *a_uio;
-		int  a_ioflag;
-		struct ucred *a_cred;
-	} */ *ap;
-{
-	struct socket *wso = ap->a_vp->v_fifoinfo->fi_writesock;
-	struct proc *p = ap->a_uio->uio_procp;
-	int error;
-
-#ifdef DIAGNOSTIC
-	if (ap->a_uio->uio_rw != UIO_WRITE)
-		panic("fifo_write mode");
-#endif
-	if (ap->a_ioflag & IO_NDELAY)
-		wso->so_state |= SS_NBIO;
-	VOP_UNLOCK(ap->a_vp, 0, p);
-	error = sosend(wso, (struct sockaddr *)0, ap->a_uio, 0,
-		       (struct mbuf *)0, 0, p);
-	vn_lock(ap->a_vp, LK_EXCLUSIVE | LK_RETRY, p);
-	if (ap->a_ioflag & IO_NDELAY)
-		wso->so_state &= ~SS_NBIO;
-	return (error);
-}
-
-/*
- * Device ioctl operation.
- */
-/* ARGSUSED */
-static int
-fifo_ioctl(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;
-	} */ *ap;
-{
-	struct file filetmp;
-	int error;
-
-	if (ap->a_command == FIONBIO)
-		return (0);
-	if (ap->a_fflag & FREAD) {
-		filetmp.f_data = (caddr_t)ap->a_vp->v_fifoinfo->fi_readsock;
-		error = soo_ioctl(&filetmp, ap->a_command, ap->a_data, ap->a_p);
-		if (error)
-			return (error);
-	}
-	if (ap->a_fflag & FWRITE) {
-		filetmp.f_data = (caddr_t)ap->a_vp->v_fifoinfo->fi_writesock;
-		error = soo_ioctl(&filetmp, ap->a_command, ap->a_data, ap->a_p);
-		if (error)
-			return (error);
-	}
-	return (0);
-}
-
-/* ARGSUSED */
-static int
-fifo_kqfilter(ap)
-	struct vop_kqfilter_args /* {
-		struct vnode *a_vp;
-		struct knote *a_kn;
-	} */ *ap;
-{
-	struct socket *so = (struct socket *)ap->a_vp->v_fifoinfo->fi_readsock;
-	struct sockbuf *sb;
-
-	switch (ap->a_kn->kn_filter) {
-	case EVFILT_READ:
-		ap->a_kn->kn_fop = &fiforead_filtops;
-		sb = &so->so_rcv;
-		break;
-	case EVFILT_WRITE:
-		ap->a_kn->kn_fop = &fifowrite_filtops;
-		sb = &so->so_snd;
-		break;
-	default:
-		return (1);
-	}
-
-	ap->a_kn->kn_hook = (caddr_t)so;
-
-	SLIST_INSERT_HEAD(&sb->sb_sel.si_note, ap->a_kn, kn_selnext);
-	sb->sb_flags |= SB_KNOTE;
-
-	return (0);
-}
-
-static void
-filt_fifordetach(struct knote *kn)
-{
-	struct socket *so = (struct socket *)kn->kn_hook;
-
-	SLIST_REMOVE(&so->so_rcv.sb_sel.si_note, kn, knote, kn_selnext);
-	if (SLIST_EMPTY(&so->so_rcv.sb_sel.si_note))
-		so->so_rcv.sb_flags &= ~SB_KNOTE;
-}
-
-static int
-filt_fiforead(struct knote *kn, long hint)
-{
-	struct socket *so = (struct socket *)kn->kn_hook;
-
-	kn->kn_data = so->so_rcv.sb_cc;
-	if (so->so_state & SS_CANTRCVMORE) {
-		kn->kn_flags |= EV_EOF;
-		return (1);
-	}
-	kn->kn_flags &= ~EV_EOF;
-	return (kn->kn_data > 0);
-}
-
-static void
-filt_fifowdetach(struct knote *kn)
-{
-	struct socket *so = (struct socket *)kn->kn_hook;
-
-	SLIST_REMOVE(&so->so_snd.sb_sel.si_note, kn, knote, kn_selnext);
-	if (SLIST_EMPTY(&so->so_snd.sb_sel.si_note))
-		so->so_snd.sb_flags &= ~SB_KNOTE;
-}
-
-static int
-filt_fifowrite(struct knote *kn, long hint)
-{
-	struct socket *so = (struct socket *)kn->kn_hook;
-
-	kn->kn_data = sbspace(&so->so_snd);
-	if (so->so_state & SS_CANTSENDMORE) {
-		kn->kn_flags |= EV_EOF;
-		return (1);
-	}
-	kn->kn_flags &= ~EV_EOF;
-	return (kn->kn_data >= so->so_snd.sb_lowat);
-}
-
-/* ARGSUSED */
-static int
-fifo_poll(ap)
-	struct vop_poll_args /* {
-		struct vnode *a_vp;
-		int  a_events;
-		struct ucred *a_cred;
-		struct proc *a_p;
-	} */ *ap;
-{
-	struct file filetmp;
-	int revents = 0;
-
-	if (ap->a_events & (POLLIN | POLLPRI | POLLRDNORM | POLLRDBAND)) {
-		filetmp.f_data = (caddr_t)ap->a_vp->v_fifoinfo->fi_readsock;
-		if (filetmp.f_data)
-			revents |= soo_poll(&filetmp, ap->a_events, ap->a_cred,
-			    ap->a_p);
-	}
-	if (ap->a_events & (POLLOUT | POLLWRNORM | POLLWRBAND)) {
-		filetmp.f_data = (caddr_t)ap->a_vp->v_fifoinfo->fi_writesock;
-		if (filetmp.f_data)
-			revents |= soo_poll(&filetmp, ap->a_events, ap->a_cred,
-			    ap->a_p);
-	}
-	return (revents);
-}
-
-/*
- * Device close routine
- */
-/* ARGSUSED */
-static int
-fifo_close(ap)
-	struct vop_close_args /* {
-		struct vnode *a_vp;
-		int  a_fflag;
-		struct ucred *a_cred;
-		struct proc *a_p;
-	} */ *ap;
-{
-	register struct vnode *vp = ap->a_vp;
-	register struct fifoinfo *fip = vp->v_fifoinfo;
-	int error1, error2;
-
-	if (ap->a_fflag & FREAD) {
-		fip->fi_readers--;
-		if (fip->fi_readers == 0)
-			socantsendmore(fip->fi_writesock);
-	}
-	if (ap->a_fflag & FWRITE) {
-		fip->fi_writers--;
-		if (fip->fi_writers == 0)
-			socantrcvmore(fip->fi_readsock);
-	}
-	if (vp->v_usecount > 1)
-		return (0);
-	error1 = soclose(fip->fi_readsock);
-	error2 = soclose(fip->fi_writesock);
-	FREE(fip, M_VNODE);
-	vp->v_fifoinfo = NULL;
-	if (error1)
-		return (error1);
-	return (error2);
-}
-
-
-/*
- * Print out internal contents of a fifo vnode.
- */
-int
-fifo_printinfo(vp)
-	struct vnode *vp;
-{
-	register struct fifoinfo *fip = vp->v_fifoinfo;
-
-	printf(", fifo with %ld readers and %ld writers",
-		fip->fi_readers, fip->fi_writers);
-	return (0);
-}
-
-/*
- * Print out the contents of a fifo vnode.
- */
-static int
-fifo_print(ap)
-	struct vop_print_args /* {
-		struct vnode *a_vp;
-	} */ *ap;
-{
-
-	printf("tag VT_NON");
-	fifo_printinfo(ap->a_vp);
-	printf("\n");
-	return (0);
-}
-
-/*
- * Return POSIX pathconf information applicable to fifo's.
- */
-int
-fifo_pathconf(ap)
-	struct vop_pathconf_args /* {
-		struct vnode *a_vp;
-		int a_name;
-		int *a_retval;
-	} */ *ap;
-{
-
-	switch (ap->a_name) {
-	case _PC_LINK_MAX:
-		*ap->a_retval = LINK_MAX;
-		return (0);
-	case _PC_PIPE_BUF:
-		*ap->a_retval = PIPE_BUF;
-		return (0);
-	case _PC_CHOWN_RESTRICTED:
-		*ap->a_retval = 1;
-		return (0);
-	default:
-		return (EINVAL);
-	}
-	/* NOTREACHED */
-}
-
-/*
- * Fifo advisory byte-level locks.
- */
-/* ARGSUSED */
-static int
-fifo_advlock(ap)
-	struct vop_advlock_args /* {
-		struct vnode *a_vp;
-		caddr_t  a_id;
-		int  a_op;
-		struct flock *a_fl;
-		int  a_flags;
-	} */ *ap;
-{
-
-	return (ap->a_flags & F_FLOCK ? EOPNOTSUPP : EINVAL);
-}
-
-/*
- * Fifo bad operation
- */
-static int
-fifo_badop()
-{
-
-	panic("fifo_badop called");
-	/* NOTREACHED */
-}
diff --git a/sys/miscfs/nullfs/null.h b/sys/miscfs/nullfs/null.h
deleted file mode 100644
index a5ebf87..0000000
--- a/sys/miscfs/nullfs/null.h
+++ /dev/null
@@ -1,89 +0,0 @@
-/*
- * Copyright (c) 1992, 1993
- *	The Regents of the University of California.  All rights reserved.
- *
- * This code is derived from software donated to Berkeley by
- * Jan-Simon Pendry.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)null.h	8.3 (Berkeley) 8/20/94
- *
- * $FreeBSD$
- */
-
-struct null_args {
-	char		*target;	/* Target of loopback  */
-};
-
-struct null_mount {
-	struct mount	*nullm_vfs;
-	struct vnode	*nullm_rootvp;	/* Reference to root null_node */
-};
-
-#ifdef _KERNEL
-/*
- * A cache of vnode references
- */
-struct null_node {
-	LIST_ENTRY(null_node)	null_hash;	/* Hash list */
-	struct vnode	        *null_lowervp;	/* VREFed once */
-	struct vnode		*null_vnode;	/* Back pointer */
-};
-
-#define	MOUNTTONULLMOUNT(mp) ((struct null_mount *)((mp)->mnt_data))
-#define	VTONULL(vp) ((struct null_node *)(vp)->v_data)
-#define	NULLTOV(xp) ((xp)->null_vnode)
-
-int nullfs_init(struct vfsconf *vfsp);
-int nullfs_uninit(struct vfsconf *vfsp);
-int null_node_create(struct mount *mp, struct vnode *target, struct vnode **vpp);
-int null_bypass(struct vop_generic_args *ap);
-
-#ifdef DIAGNOSTIC
-struct vnode *null_checkvp(struct vnode *vp, char *fil, int lno);
-#define	NULLVPTOLOWERVP(vp) null_checkvp((vp), __FILE__, __LINE__)
-#else
-#define	NULLVPTOLOWERVP(vp) (VTONULL(vp)->null_lowervp)
-#endif
-
-extern vop_t **null_vnodeop_p;
-extern struct lock null_hashlock;
-
-#ifdef MALLOC_DECLARE
-MALLOC_DECLARE(M_NULLFSNODE);
-#endif
-
-#ifdef NULLFS_DEBUG
-#define NULLFSDEBUG(format, args...) printf(format ,## args)
-#else
-#define NULLFSDEBUG(format, args...)
-#endif /* NULLFS_DEBUG */
-
-#endif /* _KERNEL */
diff --git a/sys/miscfs/nullfs/null_subr.c b/sys/miscfs/nullfs/null_subr.c
deleted file mode 100644
index 88f1584..0000000
--- a/sys/miscfs/nullfs/null_subr.c
+++ /dev/null
@@ -1,345 +0,0 @@
-/*
- * Copyright (c) 1992, 1993
- *	The Regents of the University of California.  All rights reserved.
- *
- * This code is derived from software donated to Berkeley by
- * Jan-Simon Pendry.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)null_subr.c	8.7 (Berkeley) 5/14/95
- *
- * $FreeBSD$
- */
-
-#include <sys/param.h>
-#include <sys/systm.h>
-#include <sys/kernel.h>
-#include <sys/lock.h>
-#include <sys/malloc.h>
-#include <sys/mount.h>
-#include <sys/proc.h>
-#include <sys/vnode.h>
-
-#include <miscfs/nullfs/null.h>
-
-#define LOG2_SIZEVNODE 7		/* log2(sizeof struct vnode) */
-#define	NNULLNODECACHE 16
-
-/*
- * Null layer cache:
- * Each cache entry holds a reference to the lower vnode
- * along with a pointer to the alias vnode.  When an
- * entry is added the lower vnode is VREF'd.  When the
- * alias is removed the lower vnode is vrele'd.
- */
-
-#define	NULL_NHASH(vp) \
-	(&null_node_hashtbl[(((uintptr_t)vp)>>LOG2_SIZEVNODE) & null_node_hash])
-
-static LIST_HEAD(null_node_hashhead, null_node) *null_node_hashtbl;
-static u_long null_node_hash;
-struct lock null_hashlock;
-
-static MALLOC_DEFINE(M_NULLFSHASH, "NULLFS hash", "NULLFS hash table");
-MALLOC_DEFINE(M_NULLFSNODE, "NULLFS node", "NULLFS vnode private part");
-
-static int	null_node_alloc(struct mount *mp, struct vnode *lowervp,
-				     struct vnode **vpp);
-static struct vnode *
-		null_node_find(struct mount *mp, struct vnode *lowervp);
-
-/*
- * Initialise cache headers
- */
-int
-nullfs_init(vfsp)
-	struct vfsconf *vfsp;
-{
-
-	NULLFSDEBUG("nullfs_init\n");		/* printed during system boot */
-	null_node_hashtbl = hashinit(NNULLNODECACHE, M_NULLFSHASH, &null_node_hash);
-	lockinit(&null_hashlock, PVFS, "nullhs", 0, 0);
-	return (0);
-}
-
-int
-nullfs_uninit(vfsp)
-	struct vfsconf *vfsp;
-{
-
-        if (null_node_hashtbl) {
-		lockdestroy(&null_hashlock);
-		free(null_node_hashtbl, M_NULLFSHASH);
-	}
-	return (0);
-}
-
-/*
- * Return a VREF'ed alias for lower vnode if already exists, else 0.
- * Lower vnode should be locked on entry and will be left locked on exit.
- */
-static struct vnode *
-null_node_find(mp, lowervp)
-	struct mount *mp;
-	struct vnode *lowervp;
-{
-	struct proc *p = curproc;	/* XXX */
-	struct null_node_hashhead *hd;
-	struct null_node *a;
-	struct vnode *vp;
-
-	/*
-	 * Find hash base, and then search the (two-way) linked
-	 * list looking for a null_node structure which is referencing
-	 * the lower vnode.  If found, the increment the null_node
-	 * reference count (but NOT the lower vnode's VREF counter).
-	 */
-	hd = NULL_NHASH(lowervp);
-loop:
-	lockmgr(&null_hashlock, LK_EXCLUSIVE, NULL, p);
-	LIST_FOREACH(a, hd, null_hash) {
-		if (a->null_lowervp == lowervp && NULLTOV(a)->v_mount == mp) {
-			vp = NULLTOV(a);
-			lockmgr(&null_hashlock, LK_RELEASE, NULL, p);
-			/*
-			 * We need vget for the VXLOCK
-			 * stuff, but we don't want to lock
-			 * the lower node.
-			 */
-			if (vget(vp, LK_EXCLUSIVE | LK_CANRECURSE, p)) {
-				printf ("null_node_find: vget failed.\n");
-				goto loop;
-			};
-			/*
-			 * Now we got both vnodes locked, so release the
-			 * lower one.
-			 */
-			VOP_UNLOCK(lowervp, 0, p);
-			return (vp);
-		}
-	}
-	lockmgr(&null_hashlock, LK_RELEASE, NULL, p);
-
-	return NULLVP;
-}
-
-
-/*
- * Make a new null_node node.
- * Vp is the alias vnode, lofsvp is the lower vnode.
- * Maintain a reference to (lowervp).
- */
-static int
-null_node_alloc(mp, lowervp, vpp)
-	struct mount *mp;
-	struct vnode *lowervp;
-	struct vnode **vpp;
-{
-	struct proc *p = curproc;	/* XXX */
-	struct null_node_hashhead *hd;
-	struct null_node *xp;
-	struct vnode *othervp, *vp;
-	int error;
-
-	/*
-	 * Do the MALLOC before the getnewvnode since doing so afterward
-	 * might cause a bogus v_data pointer to get dereferenced
-	 * elsewhere if MALLOC should block.
-	 */
-	MALLOC(xp, struct null_node *, sizeof(struct null_node),
-	    M_NULLFSNODE, M_WAITOK);
-
-	error = getnewvnode(VT_NULL, mp, null_vnodeop_p, vpp);
-	if (error) {
-		FREE(xp, M_NULLFSNODE);
-		return (error);
-	}
-	vp = *vpp;
-
-	vp->v_type = lowervp->v_type;
-	xp->null_vnode = vp;
-	vp->v_data = xp;
-	xp->null_lowervp = lowervp;
-	/*
-	 * Before we insert our new node onto the hash chains,
-	 * check to see if someone else has beaten us to it.
-	 * (We could have slept in MALLOC.)
-	 */
-	othervp = null_node_find(mp, lowervp);
-	if (othervp) {
-		vp->v_data = NULL;
-		FREE(xp, M_NULLFSNODE);
-		vp->v_type = VBAD;	/* node is discarded */
-		vrele(vp);
-		*vpp = othervp;
-		return 0;
-	};
-
-	/*
-	 * From NetBSD:
-	 * Now lock the new node. We rely on the fact that we were passed
-	 * a locked vnode. If the lower node is exporting a struct lock
-	 * (v_vnlock != NULL) then we just set the upper v_vnlock to the
-	 * lower one, and both are now locked. If the lower node is exporting
-	 * NULL, then we copy that up and manually lock the new vnode.
-	 */
-
-	lockmgr(&null_hashlock, LK_EXCLUSIVE, NULL, p);
-	vp->v_vnlock = lowervp->v_vnlock;
-	error = VOP_LOCK(vp, LK_EXCLUSIVE | LK_THISLAYER, p);
-	if (error)
-		panic("null_node_alloc: can't lock new vnode\n");
-
-	VREF(lowervp);
-	hd = NULL_NHASH(lowervp);
-	LIST_INSERT_HEAD(hd, xp, null_hash);
-	lockmgr(&null_hashlock, LK_RELEASE, NULL, p);
-	return 0;
-}
-
-
-/*
- * Try to find an existing null_node vnode refering to the given underlying
- * vnode (which should be locked). If no vnode found, create a new null_node
- * vnode which contains a reference to the lower vnode.
- */
-int
-null_node_create(mp, lowervp, newvpp)
-	struct mount *mp;
-	struct vnode *lowervp;
-	struct vnode **newvpp;
-{
-	struct vnode *aliasvp;
-
-	aliasvp = null_node_find(mp, lowervp);
-	if (aliasvp) {
-		/*
-		 * null_node_find has taken another reference
-		 * to the alias vnode.
-		 */
-		 vrele(lowervp);
-#ifdef NULLFS_DEBUG
-		vprint("null_node_create: exists", aliasvp);
-#endif
-	} else {
-		int error;
-
-		/*
-		 * Get new vnode.
-		 */
-		NULLFSDEBUG("null_node_create: create new alias vnode\n");
-
-		/*
-		 * Make new vnode reference the null_node.
-		 */
-		error = null_node_alloc(mp, lowervp, &aliasvp);
-		if (error)
-			return error;
-
-		/*
-		 * aliasvp is already VREF'd by getnewvnode()
-		 */
-	}
-
-#ifdef DIAGNOSTIC
-	if (lowervp->v_usecount < 1) {
-		/* Should never happen... */
-		vprint ("null_node_create: alias ", aliasvp);
-		vprint ("null_node_create: lower ", lowervp);
-		panic ("null_node_create: lower has 0 usecount.");
-	};
-#endif
-
-#ifdef NULLFS_DEBUG
-	vprint("null_node_create: alias", aliasvp);
-	vprint("null_node_create: lower", lowervp);
-#endif
-
-	*newvpp = aliasvp;
-	return (0);
-}
-
-#ifdef DIAGNOSTIC
-#include "opt_ddb.h"
-
-#ifdef DDB
-#define	null_checkvp_barrier	1
-#else
-#define	null_checkvp_barrier	0
-#endif
-
-struct vnode *
-null_checkvp(vp, fil, lno)
-	struct vnode *vp;
-	char *fil;
-	int lno;
-{
-	struct null_node *a = VTONULL(vp);
-#ifdef notyet
-	/*
-	 * Can't do this check because vop_reclaim runs
-	 * with a funny vop vector.
-	 */
-	if (vp->v_op != null_vnodeop_p) {
-		printf ("null_checkvp: on non-null-node\n");
-		while (null_checkvp_barrier) /*WAIT*/ ;
-		panic("null_checkvp");
-	};
-#endif
-	if (a->null_lowervp == NULLVP) {
-		/* Should never happen */
-		int i; u_long *p;
-		printf("vp = %p, ZERO ptr\n", (void *)vp);
-		for (p = (u_long *) a, i = 0; i < 8; i++)
-			printf(" %lx", p[i]);
-		printf("\n");
-		/* wait for debugger */
-		while (null_checkvp_barrier) /*WAIT*/ ;
-		panic("null_checkvp");
-	}
-	if (a->null_lowervp->v_usecount < 1) {
-		int i; u_long *p;
-		printf("vp = %p, unref'ed lowervp\n", (void *)vp);
-		for (p = (u_long *) a, i = 0; i < 8; i++)
-			printf(" %lx", p[i]);
-		printf("\n");
-		/* wait for debugger */
-		while (null_checkvp_barrier) /*WAIT*/ ;
-		panic ("null with unref'ed lowervp");
-	};
-#ifdef notyet
-	printf("null %x/%d -> %x/%d [%s, %d]\n",
-	        NULLTOV(a), NULLTOV(a)->v_usecount,
-		a->null_lowervp, a->null_lowervp->v_usecount,
-		fil, lno);
-#endif
-	return a->null_lowervp;
-}
-#endif
diff --git a/sys/miscfs/nullfs/null_vfsops.c b/sys/miscfs/nullfs/null_vfsops.c
deleted file mode 100644
index 8573398..0000000
--- a/sys/miscfs/nullfs/null_vfsops.c
+++ /dev/null
@@ -1,425 +0,0 @@
-/*
- * Copyright (c) 1992, 1993, 1995
- *	The Regents of the University of California.  All rights reserved.
- *
- * This code is derived from software donated to Berkeley by
- * Jan-Simon Pendry.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)null_vfsops.c	8.2 (Berkeley) 1/21/94
- *
- * @(#)lofs_vfsops.c	1.2 (Berkeley) 6/18/92
- * $FreeBSD$
- */
-
-/*
- * Null Layer
- * (See null_vnops.c for a description of what this does.)
- */
-
-#include <sys/param.h>
-#include <sys/systm.h>
-#include <sys/kernel.h>
-#include <sys/lock.h>
-#include <sys/malloc.h>
-#include <sys/mount.h>
-#include <sys/namei.h>
-#include <sys/proc.h>
-#include <sys/vnode.h>
-
-#include <miscfs/nullfs/null.h>
-
-static MALLOC_DEFINE(M_NULLFSMNT, "NULLFS mount", "NULLFS mount structure");
-
-static int	nullfs_fhtovp(struct mount *mp, struct fid *fidp,
-				   struct vnode **vpp);
-static int	nullfs_checkexp(struct mount *mp, struct sockaddr *nam,
-				    int *extflagsp, struct ucred **credanonp);
-static int	nullfs_mount(struct mount *mp, char *path, caddr_t data,
-				  struct nameidata *ndp, struct proc *p);
-static int	nullfs_quotactl(struct mount *mp, int cmd, uid_t uid,
-				     caddr_t arg, struct proc *p);
-static int	nullfs_root(struct mount *mp, struct vnode **vpp);
-static int	nullfs_start(struct mount *mp, int flags, struct proc *p);
-static int	nullfs_statfs(struct mount *mp, struct statfs *sbp,
-				   struct proc *p);
-static int	nullfs_sync(struct mount *mp, int waitfor,
-				 struct ucred *cred, struct proc *p);
-static int	nullfs_unmount(struct mount *mp, int mntflags, struct proc *p);
-static int	nullfs_vget(struct mount *mp, ino_t ino, struct vnode **vpp);
-static int	nullfs_vptofh(struct vnode *vp, struct fid *fhp);
-static int	nullfs_extattrctl(struct mount *mp, int cmd,
-				       struct vnode *filename_vp,
-				       int namespace, const char *attrname,
-				       struct proc *p);
-
-/*
- * Mount null layer
- */
-static int
-nullfs_mount(mp, path, data, ndp, p)
-	struct mount *mp;
-	char *path;
-	caddr_t data;
-	struct nameidata *ndp;
-	struct proc *p;
-{
-	int error = 0;
-	struct null_args args;
-	struct vnode *lowerrootvp, *vp;
-	struct vnode *nullm_rootvp;
-	struct null_mount *xmp;
-	u_int size;
-	int isvnunlocked = 0;
-
-	NULLFSDEBUG("nullfs_mount(mp = %p)\n", (void *)mp);
-
-	/*
-	 * Update is a no-op
-	 */
-	if (mp->mnt_flag & MNT_UPDATE) {
-		return (EOPNOTSUPP);
-		/* return VFS_MOUNT(MOUNTTONULLMOUNT(mp)->nullm_vfs, path, data, ndp, p);*/
-	}
-
-	/*
-	 * Get argument
-	 */
-	error = copyin(data, (caddr_t)&args, sizeof(struct null_args));
-	if (error)
-		return (error);
-
-	/*
-	 * Unlock lower node to avoid deadlock.
-	 * (XXX) VOP_ISLOCKED is needed?
-	 */
-	if ((mp->mnt_vnodecovered->v_op == null_vnodeop_p) &&
-		VOP_ISLOCKED(mp->mnt_vnodecovered, NULL)) {
-		VOP_UNLOCK(mp->mnt_vnodecovered, 0, p);
-		isvnunlocked = 1;
-	}
-	/*
-	 * Find lower node
-	 */
-	NDINIT(ndp, LOOKUP, FOLLOW|WANTPARENT|LOCKLEAF,
-		UIO_USERSPACE, args.target, p);
-	error = namei(ndp);
-	/*
-	 * Re-lock vnode.
-	 */
-	if (isvnunlocked && !VOP_ISLOCKED(mp->mnt_vnodecovered, NULL))
-		vn_lock(mp->mnt_vnodecovered, LK_EXCLUSIVE | LK_RETRY, p);
-
-	if (error)
-		return (error);
-	NDFREE(ndp, NDF_ONLY_PNBUF);
-
-	/*
-	 * Sanity check on lower vnode
-	 */
-	lowerrootvp = ndp->ni_vp;
-
-	vrele(ndp->ni_dvp);
-	ndp->ni_dvp = NULLVP;
-
-	/*
-	 * Check multi null mount to avoid `lock against myself' panic.
-	 */
-	if (lowerrootvp == VTONULL(mp->mnt_vnodecovered)->null_lowervp) {
-		NULLFSDEBUG("nullfs_mount: multi null mount?\n");
-		vput(lowerrootvp);
-		return (EDEADLK);
-	}
-
-	xmp = (struct null_mount *) malloc(sizeof(struct null_mount),
-				M_NULLFSMNT, M_WAITOK);	/* XXX */
-
-	/*
-	 * Save reference to underlying FS
-	 */
-	xmp->nullm_vfs = lowerrootvp->v_mount;
-
-	/*
-	 * Save reference.  Each mount also holds
-	 * a reference on the root vnode.
-	 */
-	error = null_node_create(mp, lowerrootvp, &vp);
-	/*
-	 * Unlock the node (either the lower or the alias)
-	 */
-	VOP_UNLOCK(vp, 0, p);
-	/*
-	 * Make sure the node alias worked
-	 */
-	if (error) {
-		vrele(lowerrootvp);
-		free(xmp, M_NULLFSMNT);	/* XXX */
-		return (error);
-	}
-
-	/*
-	 * Keep a held reference to the root vnode.
-	 * It is vrele'd in nullfs_unmount.
-	 */
-	nullm_rootvp = vp;
-	nullm_rootvp->v_flag |= VROOT;
-	xmp->nullm_rootvp = nullm_rootvp;
-	if (NULLVPTOLOWERVP(nullm_rootvp)->v_mount->mnt_flag & MNT_LOCAL)
-		mp->mnt_flag |= MNT_LOCAL;
-	mp->mnt_data = (qaddr_t) xmp;
-	vfs_getnewfsid(mp);
-
-	(void) copyinstr(args.target, mp->mnt_stat.f_mntfromname, MNAMELEN - 1,
-	    &size);
-	bzero(mp->mnt_stat.f_mntfromname + size, MNAMELEN - size);
-	(void)nullfs_statfs(mp, &mp->mnt_stat, p);
-	NULLFSDEBUG("nullfs_mount: lower %s, alias at %s\n",
-		mp->mnt_stat.f_mntfromname, mp->mnt_stat.f_mntonname);
-	return (0);
-}
-
-/*
- * VFS start.  Nothing needed here - the start routine
- * on the underlying filesystem will have been called
- * when that filesystem was mounted.
- */
-static int
-nullfs_start(mp, flags, p)
-	struct mount *mp;
-	int flags;
-	struct proc *p;
-{
-	return (0);
-	/* return VFS_START(MOUNTTONULLMOUNT(mp)->nullm_vfs, flags, p); */
-}
-
-/*
- * Free reference to null layer
- */
-static int
-nullfs_unmount(mp, mntflags, p)
-	struct mount *mp;
-	int mntflags;
-	struct proc *p;
-{
-	void *mntdata;
-	int error;
-	int flags = 0;
-
-	NULLFSDEBUG("nullfs_unmount: mp = %p\n", (void *)mp);
-
-	if (mntflags & MNT_FORCE)
-		flags |= FORCECLOSE;
-
-	/* There is 1 extra root vnode reference (nullm_rootvp). */
-	error = vflush(mp, 1, flags);
-	if (error)
-		return (error);
-
-	/*
-	 * Finally, throw away the null_mount structure
-	 */
-	mntdata = mp->mnt_data;
-	mp->mnt_data = 0;
-	free(mntdata, M_NULLFSMNT);
-	return 0;
-}
-
-static int
-nullfs_root(mp, vpp)
-	struct mount *mp;
-	struct vnode **vpp;
-{
-	struct proc *p = curproc;	/* XXX */
-	struct vnode *vp;
-
-	NULLFSDEBUG("nullfs_root(mp = %p, vp = %p->%p)\n", (void *)mp,
-	    (void *)MOUNTTONULLMOUNT(mp)->nullm_rootvp,
-	    (void *)NULLVPTOLOWERVP(MOUNTTONULLMOUNT(mp)->nullm_rootvp));
-
-	/*
-	 * Return locked reference to root.
-	 */
-	vp = MOUNTTONULLMOUNT(mp)->nullm_rootvp;
-	VREF(vp);
-
-#ifdef NULLFS_DEBUG
-	if (VOP_ISLOCKED(vp, NULL)) {
-		Debugger("root vnode is locked.\n");
-		vrele(vp);
-		return (EDEADLK);
-	}
-#endif
-	vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
-	*vpp = vp;
-	return 0;
-}
-
-static int
-nullfs_quotactl(mp, cmd, uid, arg, p)
-	struct mount *mp;
-	int cmd;
-	uid_t uid;
-	caddr_t arg;
-	struct proc *p;
-{
-	return VFS_QUOTACTL(MOUNTTONULLMOUNT(mp)->nullm_vfs, cmd, uid, arg, p);
-}
-
-static int
-nullfs_statfs(mp, sbp, p)
-	struct mount *mp;
-	struct statfs *sbp;
-	struct proc *p;
-{
-	int error;
-	struct statfs mstat;
-
-	NULLFSDEBUG("nullfs_statfs(mp = %p, vp = %p->%p)\n", (void *)mp,
-	    (void *)MOUNTTONULLMOUNT(mp)->nullm_rootvp,
-	    (void *)NULLVPTOLOWERVP(MOUNTTONULLMOUNT(mp)->nullm_rootvp));
-
-	bzero(&mstat, sizeof(mstat));
-
-	error = VFS_STATFS(MOUNTTONULLMOUNT(mp)->nullm_vfs, &mstat, p);
-	if (error)
-		return (error);
-
-	/* now copy across the "interesting" information and fake the rest */
-	sbp->f_type = mstat.f_type;
-	sbp->f_flags = mstat.f_flags;
-	sbp->f_bsize = mstat.f_bsize;
-	sbp->f_iosize = mstat.f_iosize;
-	sbp->f_blocks = mstat.f_blocks;
-	sbp->f_bfree = mstat.f_bfree;
-	sbp->f_bavail = mstat.f_bavail;
-	sbp->f_files = mstat.f_files;
-	sbp->f_ffree = mstat.f_ffree;
-	if (sbp != &mp->mnt_stat) {
-		bcopy(&mp->mnt_stat.f_fsid, &sbp->f_fsid, sizeof(sbp->f_fsid));
-		bcopy(mp->mnt_stat.f_mntonname, sbp->f_mntonname, MNAMELEN);
-		bcopy(mp->mnt_stat.f_mntfromname, sbp->f_mntfromname, MNAMELEN);
-	}
-	return (0);
-}
-
-static int
-nullfs_sync(mp, waitfor, cred, p)
-	struct mount *mp;
-	int waitfor;
-	struct ucred *cred;
-	struct proc *p;
-{
-	/*
-	 * XXX - Assumes no data cached at null layer.
-	 */
-	return (0);
-}
-
-static int
-nullfs_vget(mp, ino, vpp)
-	struct mount *mp;
-	ino_t ino;
-	struct vnode **vpp;
-{
-	int error;
-	error = VFS_VGET(MOUNTTONULLMOUNT(mp)->nullm_vfs, ino, vpp);
-	if (error)
-		return (error);
-
-	return (null_node_create(mp, *vpp, vpp));
-}
-
-static int
-nullfs_fhtovp(mp, fidp, vpp)
-	struct mount *mp;
-	struct fid *fidp;
-	struct vnode **vpp;
-{
-	int error;
-	error = VFS_FHTOVP(MOUNTTONULLMOUNT(mp)->nullm_vfs, fidp, vpp);
-	if (error)
-		return (error);
-
-	return (null_node_create(mp, *vpp, vpp));
-}
-
-static int
-nullfs_checkexp(mp, nam, extflagsp, credanonp)
-	struct mount *mp;
-	struct sockaddr *nam;
-	int *extflagsp; 
-	struct ucred **credanonp;
-{
-
-	return VFS_CHECKEXP(MOUNTTONULLMOUNT(mp)->nullm_vfs, nam, 
-		extflagsp, credanonp);
-}
-
-static int
-nullfs_vptofh(vp, fhp)
-	struct vnode *vp;
-	struct fid *fhp;
-{
-	return VFS_VPTOFH(NULLVPTOLOWERVP(vp), fhp);
-}
-
-static int                        
-nullfs_extattrctl(mp, cmd, filename_vp, namespace, attrname, p)
-	struct mount *mp;
-	int cmd;
-	struct vnode *filename_vp;
-	int namespace;
-	const char *attrname;
-	struct proc *p;            
-{
-	return VFS_EXTATTRCTL(MOUNTTONULLMOUNT(mp)->nullm_vfs, cmd, filename_vp,
-	    namespace, attrname, p);
-}
-
-
-static struct vfsops null_vfsops = {
-	nullfs_mount,
-	nullfs_start,
-	nullfs_unmount,
-	nullfs_root,
-	nullfs_quotactl,
-	nullfs_statfs,
-	nullfs_sync,
-	nullfs_vget,
-	nullfs_fhtovp,
-	nullfs_checkexp,
-	nullfs_vptofh,
-	nullfs_init,
-	nullfs_uninit,
-	nullfs_extattrctl,
-};
-
-VFS_SET(null_vfsops, nullfs, VFCF_LOOPBACK);
diff --git a/sys/miscfs/nullfs/null_vnops.c b/sys/miscfs/nullfs/null_vnops.c
deleted file mode 100644
index d37ef73..0000000
--- a/sys/miscfs/nullfs/null_vnops.c
+++ /dev/null
@@ -1,852 +0,0 @@
-/*
- * Copyright (c) 1992, 1993
- *	The Regents of the University of California.  All rights reserved.
- *
- * This code is derived from software contributed to Berkeley by
- * John Heidemann of the UCLA Ficus project.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)null_vnops.c	8.6 (Berkeley) 5/27/95
- *
- * Ancestors:
- *	@(#)lofs_vnops.c	1.2 (Berkeley) 6/18/92
- *	...and...
- *	@(#)null_vnodeops.c 1.20 92/07/07 UCLA Ficus project
- *
- * $FreeBSD$
- */
-
-/*
- * Null Layer
- *
- * (See mount_null(8) for more information.)
- *
- * The null layer duplicates a portion of the file system
- * name space under a new name.  In this respect, it is
- * similar to the loopback file system.  It differs from
- * the loopback fs in two respects:  it is implemented using
- * a stackable layers techniques, and its "null-node"s stack above
- * all lower-layer vnodes, not just over directory vnodes.
- *
- * The null layer has two purposes.  First, it serves as a demonstration
- * of layering by proving a layer which does nothing.  (It actually
- * does everything the loopback file system does, which is slightly
- * more than nothing.)  Second, the null layer can serve as a prototype
- * layer.  Since it provides all necessary layer framework,
- * new file system layers can be created very easily be starting
- * with a null layer.
- *
- * The remainder of this man page examines the null layer as a basis
- * for constructing new layers.
- *
- *
- * INSTANTIATING NEW NULL LAYERS
- *
- * New null layers are created with mount_null(8).
- * Mount_null(8) takes two arguments, the pathname
- * of the lower vfs (target-pn) and the pathname where the null
- * layer will appear in the namespace (alias-pn).  After
- * the null layer is put into place, the contents
- * of target-pn subtree will be aliased under alias-pn.
- *
- *
- * OPERATION OF A NULL LAYER
- *
- * The null layer is the minimum file system layer,
- * simply bypassing all possible operations to the lower layer
- * for processing there.  The majority of its activity centers
- * on the bypass routine, through which nearly all vnode operations
- * pass.
- *
- * The bypass routine accepts arbitrary vnode operations for
- * handling by the lower layer.  It begins by examing vnode
- * operation arguments and replacing any null-nodes by their
- * lower-layer equivlants.  It then invokes the operation
- * on the lower layer.  Finally, it replaces the null-nodes
- * in the arguments and, if a vnode is return by the operation,
- * stacks a null-node on top of the returned vnode.
- *
- * Although bypass handles most operations, vop_getattr, vop_lock,
- * vop_unlock, vop_inactive, vop_reclaim, and vop_print are not
- * bypassed. Vop_getattr must change the fsid being returned.
- * Vop_lock and vop_unlock must handle any locking for the
- * current vnode as well as pass the lock request down.
- * Vop_inactive and vop_reclaim are not bypassed so that
- * they can handle freeing null-layer specific data. Vop_print
- * is not bypassed to avoid excessive debugging information.
- * Also, certain vnode operations change the locking state within
- * the operation (create, mknod, remove, link, rename, mkdir, rmdir,
- * and symlink). Ideally these operations should not change the
- * lock state, but should be changed to let the caller of the
- * function unlock them. Otherwise all intermediate vnode layers
- * (such as union, umapfs, etc) must catch these functions to do
- * the necessary locking at their layer.
- *
- *
- * INSTANTIATING VNODE STACKS
- *
- * Mounting associates the null layer with a lower layer,
- * effect stacking two VFSes.  Vnode stacks are instead
- * created on demand as files are accessed.
- *
- * The initial mount creates a single vnode stack for the
- * root of the new null layer.  All other vnode stacks
- * are created as a result of vnode operations on
- * this or other null vnode stacks.
- *
- * New vnode stacks come into existance as a result of
- * an operation which returns a vnode.
- * The bypass routine stacks a null-node above the new
- * vnode before returning it to the caller.
- *
- * For example, imagine mounting a null layer with
- * "mount_null /usr/include /dev/layer/null".
- * Changing directory to /dev/layer/null will assign
- * the root null-node (which was created when the null layer was mounted).
- * Now consider opening "sys".  A vop_lookup would be
- * done on the root null-node.  This operation would bypass through
- * to the lower layer which would return a vnode representing
- * the UFS "sys".  Null_bypass then builds a null-node
- * aliasing the UFS "sys" and returns this to the caller.
- * Later operations on the null-node "sys" will repeat this
- * process when constructing other vnode stacks.
- *
- *
- * CREATING OTHER FILE SYSTEM LAYERS
- *
- * One of the easiest ways to construct new file system layers is to make
- * a copy of the null layer, rename all files and variables, and
- * then begin modifing the copy.  Sed can be used to easily rename
- * all variables.
- *
- * The umap layer is an example of a layer descended from the
- * null layer.
- *
- *
- * INVOKING OPERATIONS ON LOWER LAYERS
- *
- * There are two techniques to invoke operations on a lower layer
- * when the operation cannot be completely bypassed.  Each method
- * is appropriate in different situations.  In both cases,
- * it is the responsibility of the aliasing layer to make
- * the operation arguments "correct" for the lower layer
- * by mapping an vnode arguments to the lower layer.
- *
- * The first approach is to call the aliasing layer's bypass routine.
- * This method is most suitable when you wish to invoke the operation
- * currently being handled on the lower layer.  It has the advantage
- * that the bypass routine already must do argument mapping.
- * An example of this is null_getattrs in the null layer.
- *
- * A second approach is to directly invoke vnode operations on
- * the lower layer with the VOP_OPERATIONNAME interface.
- * The advantage of this method is that it is easy to invoke
- * arbitrary operations on the lower layer.  The disadvantage
- * is that vnode arguments must be manualy mapped.
- *
- */
-
-#include <sys/param.h>
-#include <sys/systm.h>
-#include <sys/conf.h>
-#include <sys/kernel.h>
-#include <sys/lock.h>
-#include <sys/malloc.h>
-#include <sys/mount.h>
-#include <sys/mutex.h>
-#include <sys/namei.h>
-#include <sys/sysctl.h>
-#include <sys/vnode.h>
-
-#include <miscfs/nullfs/null.h>
-
-#include <vm/vm.h>
-#include <vm/vm_extern.h>
-#include <vm/vm_object.h>
-#include <vm/vnode_pager.h>
-
-static int null_bug_bypass = 0;   /* for debugging: enables bypass printf'ing */
-SYSCTL_INT(_debug, OID_AUTO, nullfs_bug_bypass, CTLFLAG_RW, 
-	&null_bug_bypass, 0, "");
-
-static int	null_access(struct vop_access_args *ap);
-static int	null_createvobject(struct vop_createvobject_args *ap);
-static int	null_destroyvobject(struct vop_destroyvobject_args *ap);
-static int	null_getattr(struct vop_getattr_args *ap);
-static int	null_getvobject(struct vop_getvobject_args *ap);
-static int	null_inactive(struct vop_inactive_args *ap);
-static int	null_islocked(struct vop_islocked_args *ap);
-static int	null_lock(struct vop_lock_args *ap);
-static int	null_lookup(struct vop_lookup_args *ap);
-static int	null_open(struct vop_open_args *ap);
-static int	null_print(struct vop_print_args *ap);
-static int	null_reclaim(struct vop_reclaim_args *ap);
-static int	null_rename(struct vop_rename_args *ap);
-static int	null_setattr(struct vop_setattr_args *ap);
-static int	null_unlock(struct vop_unlock_args *ap);
-
-/*
- * This is the 10-Apr-92 bypass routine.
- *    This version has been optimized for speed, throwing away some
- * safety checks.  It should still always work, but it's not as
- * robust to programmer errors.
- *
- * In general, we map all vnodes going down and unmap them on the way back.
- * As an exception to this, vnodes can be marked "unmapped" by setting
- * the Nth bit in operation's vdesc_flags.
- *
- * Also, some BSD vnode operations have the side effect of vrele'ing
- * their arguments.  With stacking, the reference counts are held
- * by the upper node, not the lower one, so we must handle these
- * side-effects here.  This is not of concern in Sun-derived systems
- * since there are no such side-effects.
- *
- * This makes the following assumptions:
- * - only one returned vpp
- * - no INOUT vpp's (Sun's vop_open has one of these)
- * - the vnode operation vector of the first vnode should be used
- *   to determine what implementation of the op should be invoked
- * - all mapped vnodes are of our vnode-type (NEEDSWORK:
- *   problems on rmdir'ing mount points and renaming?)
- */
-int
-null_bypass(ap)
-	struct vop_generic_args /* {
-		struct vnodeop_desc *a_desc;
-		<other random data follows, presumably>
-	} */ *ap;
-{
-	register struct vnode **this_vp_p;
-	int error;
-	struct vnode *old_vps[VDESC_MAX_VPS];
-	struct vnode **vps_p[VDESC_MAX_VPS];
-	struct vnode ***vppp;
-	struct vnodeop_desc *descp = ap->a_desc;
-	int reles, i;
-
-	if (null_bug_bypass)
-		printf ("null_bypass: %s\n", descp->vdesc_name);
-
-#ifdef DIAGNOSTIC
-	/*
-	 * We require at least one vp.
-	 */
-	if (descp->vdesc_vp_offsets == NULL ||
-	    descp->vdesc_vp_offsets[0] == VDESC_NO_OFFSET)
-		panic ("null_bypass: no vp's in map");
-#endif
-
-	/*
-	 * Map the vnodes going in.
-	 * Later, we'll invoke the operation based on
-	 * the first mapped vnode's operation vector.
-	 */
-	reles = descp->vdesc_flags;
-	for (i = 0; i < VDESC_MAX_VPS; reles >>= 1, i++) {
-		if (descp->vdesc_vp_offsets[i] == VDESC_NO_OFFSET)
-			break;   /* bail out at end of list */
-		vps_p[i] = this_vp_p =
-			VOPARG_OFFSETTO(struct vnode**,descp->vdesc_vp_offsets[i],ap);
-		/*
-		 * We're not guaranteed that any but the first vnode
-		 * are of our type.  Check for and don't map any
-		 * that aren't.  (We must always map first vp or vclean fails.)
-		 */
-		if (i && (*this_vp_p == NULLVP ||
-		    (*this_vp_p)->v_op != null_vnodeop_p)) {
-			old_vps[i] = NULLVP;
-		} else {
-			old_vps[i] = *this_vp_p;
-			*(vps_p[i]) = NULLVPTOLOWERVP(*this_vp_p);
-			/*
-			 * XXX - Several operations have the side effect
-			 * of vrele'ing their vp's.  We must account for
-			 * that.  (This should go away in the future.)
-			 */
-			if (reles & VDESC_VP0_WILLRELE)
-				VREF(*this_vp_p);
-		}
-
-	}
-
-	/*
-	 * Call the operation on the lower layer
-	 * with the modified argument structure.
-	 */
-	if (vps_p[0] && *vps_p[0])
-		error = VCALL(*(vps_p[0]), descp->vdesc_offset, ap);
-	else {
-		printf("null_bypass: no map for %s\n", descp->vdesc_name);
-		error = EINVAL;
-	}
-
-	/*
-	 * Maintain the illusion of call-by-value
-	 * by restoring vnodes in the argument structure
-	 * to their original value.
-	 */
-	reles = descp->vdesc_flags;
-	for (i = 0; i < VDESC_MAX_VPS; reles >>= 1, i++) {
-		if (descp->vdesc_vp_offsets[i] == VDESC_NO_OFFSET)
-			break;   /* bail out at end of list */
-		if (old_vps[i]) {
-			*(vps_p[i]) = old_vps[i];
-#if 0
-			if (reles & VDESC_VP0_WILLUNLOCK)
-				VOP_UNLOCK(*(vps_p[i]), LK_THISLAYER, curproc);
-#endif
-			if (reles & VDESC_VP0_WILLRELE)
-				vrele(*(vps_p[i]));
-		}
-	}
-
-	/*
-	 * Map the possible out-going vpp
-	 * (Assumes that the lower layer always returns
-	 * a VREF'ed vpp unless it gets an error.)
-	 */
-	if (descp->vdesc_vpp_offset != VDESC_NO_OFFSET &&
-	    !(descp->vdesc_flags & VDESC_NOMAP_VPP) &&
-	    !error) {
-		/*
-		 * XXX - even though some ops have vpp returned vp's,
-		 * several ops actually vrele this before returning.
-		 * We must avoid these ops.
-		 * (This should go away when these ops are regularized.)
-		 */
-		if (descp->vdesc_flags & VDESC_VPP_WILLRELE)
-			goto out;
-		vppp = VOPARG_OFFSETTO(struct vnode***,
-				 descp->vdesc_vpp_offset,ap);
-		if (*vppp)
-			error = null_node_create(old_vps[0]->v_mount, **vppp, *vppp);
-	}
-
- out:
-	return (error);
-}
-
-/*
- * We have to carry on the locking protocol on the null layer vnodes
- * as we progress through the tree. We also have to enforce read-only
- * if this layer is mounted read-only.
- */
-static int
-null_lookup(ap)
-	struct vop_lookup_args /* {
-		struct vnode * a_dvp;
-		struct vnode ** a_vpp;
-		struct componentname * a_cnp;
-	} */ *ap;
-{
-	struct componentname *cnp = ap->a_cnp;
-	struct vnode *dvp = ap->a_dvp;
-	struct proc *p = cnp->cn_proc;
-	int flags = cnp->cn_flags;
-	struct vnode *vp, *ldvp, *lvp;
-	int error;
-
-	if ((flags & ISLASTCN) && (dvp->v_mount->mnt_flag & MNT_RDONLY) &&
-	    (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME))
-		return (EROFS);
-	/*
-	 * Although it is possible to call null_bypass(), we'll do
-	 * a direct call to reduce overhead
-	 */
-	ldvp = NULLVPTOLOWERVP(dvp);
-	vp = lvp = NULL;
-	error = VOP_LOOKUP(ldvp, &lvp, cnp);
-	if (error == EJUSTRETURN && (flags & ISLASTCN) &&
-	    (dvp->v_mount->mnt_flag & MNT_RDONLY) &&
-	    (cnp->cn_nameiop == CREATE || cnp->cn_nameiop == RENAME))
-		error = EROFS;
-
-	/*
-	 * Rely only on the PDIRUNLOCK flag which should be carefully
-	 * tracked by underlying filesystem.
-	 */
-	if (cnp->cn_flags & PDIRUNLOCK)
-		VOP_UNLOCK(dvp, LK_THISLAYER, p);
-	if ((error == 0 || error == EJUSTRETURN) && lvp != NULL) {
-		if (ldvp == lvp) {
-			*ap->a_vpp = dvp;
-			VREF(dvp);
-			vrele(lvp);
-		} else {
-			error = null_node_create(dvp->v_mount, lvp, &vp);
-			if (error == 0)
-				*ap->a_vpp = vp;
-		}
-	}
-	return (error);
-}
-
-/*
- * Setattr call. Disallow write attempts if the layer is mounted read-only.
- */
-int
-null_setattr(ap)
-	struct vop_setattr_args /* {
-		struct vnodeop_desc *a_desc;
-		struct vnode *a_vp;
-		struct vattr *a_vap;
-		struct ucred *a_cred;
-		struct proc *a_p;
-	} */ *ap;
-{
-	struct vnode *vp = ap->a_vp;
-	struct vattr *vap = ap->a_vap;
-
-  	if ((vap->va_flags != VNOVAL || vap->va_uid != (uid_t)VNOVAL ||
-	    vap->va_gid != (gid_t)VNOVAL || vap->va_atime.tv_sec != VNOVAL ||
-	    vap->va_mtime.tv_sec != VNOVAL || vap->va_mode != (mode_t)VNOVAL) &&
-	    (vp->v_mount->mnt_flag & MNT_RDONLY))
-		return (EROFS);
-	if (vap->va_size != VNOVAL) {
- 		switch (vp->v_type) {
- 		case VDIR:
- 			return (EISDIR);
- 		case VCHR:
- 		case VBLK:
- 		case VSOCK:
- 		case VFIFO:
-			if (vap->va_flags != VNOVAL)
-				return (EOPNOTSUPP);
-			return (0);
-		case VREG:
-		case VLNK:
- 		default:
-			/*
-			 * Disallow write attempts if the filesystem is
-			 * mounted read-only.
-			 */
-			if (vp->v_mount->mnt_flag & MNT_RDONLY)
-				return (EROFS);
-		}
-	}
-
-	return (null_bypass((struct vop_generic_args *)ap));
-}
-
-/*
- *  We handle getattr only to change the fsid.
- */
-static int
-null_getattr(ap)
-	struct vop_getattr_args /* {
-		struct vnode *a_vp;
-		struct vattr *a_vap;
-		struct ucred *a_cred;
-		struct proc *a_p;
-	} */ *ap;
-{
-	int error;
-
-	if ((error = null_bypass((struct vop_generic_args *)ap)) != 0)
-		return (error);
-
-	ap->a_vap->va_fsid = ap->a_vp->v_mount->mnt_stat.f_fsid.val[0];
-	return (0);
-}
-
-/*
- * Handle to disallow write access if mounted read-only.
- */
-static int
-null_access(ap)
-	struct vop_access_args /* {
-		struct vnode *a_vp;
-		int  a_mode;
-		struct ucred *a_cred;
-		struct proc *a_p;
-	} */ *ap;
-{
-	struct vnode *vp = ap->a_vp;
-	mode_t mode = ap->a_mode;
-
-	/*
-	 * Disallow write attempts on read-only layers;
-	 * unless the file is a socket, fifo, or a block or
-	 * character device resident on the file system.
-	 */
-	if (mode & VWRITE) {
-		switch (vp->v_type) {
-		case VDIR:
-		case VLNK:
-		case VREG:
-			if (vp->v_mount->mnt_flag & MNT_RDONLY)
-				return (EROFS);
-			break;
-		default:
-			break;
-		}
-	}
-	return (null_bypass((struct vop_generic_args *)ap));
-}
-
-/*
- * We must handle open to be able to catch MNT_NODEV and friends.
- */
-static int
-null_open(ap)
-	struct vop_open_args /* {
-		struct vnode *a_vp;
-		int  a_mode;
-		struct ucred *a_cred;
-		struct proc *a_p;
-	} */ *ap;
-{
-	struct vnode *vp = ap->a_vp;
-	struct vnode *lvp = NULLVPTOLOWERVP(ap->a_vp);
-
-	if ((vp->v_mount->mnt_flag & MNT_NODEV) &&
-	    (lvp->v_type == VBLK || lvp->v_type == VCHR))
-		return ENXIO;
-
-	return (null_bypass((struct vop_generic_args *)ap));
-}
-
-/*
- * We handle this to eliminate null FS to lower FS
- * file moving. Don't know why we don't allow this,
- * possibly we should.
- */
-static int
-null_rename(ap)
-	struct vop_rename_args /* {
-		struct vnode *a_fdvp;
-		struct vnode *a_fvp;
-		struct componentname *a_fcnp;
-		struct vnode *a_tdvp;
-		struct vnode *a_tvp;
-		struct componentname *a_tcnp;
-	} */ *ap;
-{
-	struct vnode *tdvp = ap->a_tdvp;
-	struct vnode *fvp = ap->a_fvp;
-	struct vnode *fdvp = ap->a_fdvp;
-	struct vnode *tvp = ap->a_tvp;
-
-	/* Check for cross-device rename. */
-	if ((fvp->v_mount != tdvp->v_mount) ||
-	    (tvp && (fvp->v_mount != tvp->v_mount))) {
-		if (tdvp == tvp)
-			vrele(tdvp);
-		else
-			vput(tdvp);
-		if (tvp)
-			vput(tvp);
-		vrele(fdvp);
-		vrele(fvp);
-		return (EXDEV);
-	}
-	
-	return (null_bypass((struct vop_generic_args *)ap));
-}
-
-/*
- * We need to process our own vnode lock and then clear the
- * interlock flag as it applies only to our vnode, not the
- * vnodes below us on the stack.
- */
-static int
-null_lock(ap)
-	struct vop_lock_args /* {
-		struct vnode *a_vp;
-		int a_flags;
-		struct proc *a_p;
-	} */ *ap;
-{
-	struct vnode *vp = ap->a_vp;
-	int flags = ap->a_flags;
-	struct proc *p = ap->a_p;
-	struct vnode *lvp;
-	int error;
-
-	if (flags & LK_THISLAYER) {
-		if (vp->v_vnlock != NULL)
-			return 0;	/* lock is shared across layers */
-		error = lockmgr(&vp->v_lock, flags & ~LK_THISLAYER,
-		    &vp->v_interlock, p);
-		return (error);
-	}
-
-	if (vp->v_vnlock != NULL) {
-		/*
-		 * The lower level has exported a struct lock to us. Use
-		 * it so that all vnodes in the stack lock and unlock
-		 * simultaneously. Note: we don't DRAIN the lock as DRAIN
-		 * decommissions the lock - just because our vnode is
-		 * going away doesn't mean the struct lock below us is.
-		 * LK_EXCLUSIVE is fine.
-		 */
-		if ((flags & LK_TYPE_MASK) == LK_DRAIN) {
-			NULLFSDEBUG("null_lock: avoiding LK_DRAIN\n");
-			return(lockmgr(vp->v_vnlock,
-				(flags & ~LK_TYPE_MASK) | LK_EXCLUSIVE,
-				&vp->v_interlock, p));
-		}
-		return(lockmgr(vp->v_vnlock, flags, &vp->v_interlock, p));
-	} else {
-		/*
-		 * To prevent race conditions involving doing a lookup
-		 * on "..", we have to lock the lower node, then lock our
-		 * node. Most of the time it won't matter that we lock our
-		 * node (as any locking would need the lower one locked
-		 * first). But we can LK_DRAIN the upper lock as a step
-		 * towards decomissioning it.
-		 */
-		lvp = NULLVPTOLOWERVP(vp);
-		if (lvp == NULL)
-			return (lockmgr(&vp->v_lock, flags, &vp->v_interlock, p));
-		if (flags & LK_INTERLOCK) {
-			mtx_unlock(&vp->v_interlock);
-			flags &= ~LK_INTERLOCK;
-		}
-		if ((flags & LK_TYPE_MASK) == LK_DRAIN) {
-			error = VOP_LOCK(lvp,
-				(flags & ~LK_TYPE_MASK) | LK_EXCLUSIVE, p);
-		} else
-			error = VOP_LOCK(lvp, flags, p);
-		if (error)
-			return (error);	
-		error = lockmgr(&vp->v_lock, flags, &vp->v_interlock, p);
-		if (error)
-			VOP_UNLOCK(lvp, 0, p);
-		return (error);
-	}
-}
-
-/*
- * We need to process our own vnode unlock and then clear the
- * interlock flag as it applies only to our vnode, not the
- * vnodes below us on the stack.
- */
-static int
-null_unlock(ap)
-	struct vop_unlock_args /* {
-		struct vnode *a_vp;
-		int a_flags;
-		struct proc *a_p;
-	} */ *ap;
-{
-	struct vnode *vp = ap->a_vp;
-	int flags = ap->a_flags;
-	struct proc *p = ap->a_p;
-	struct vnode *lvp;
-
-	if (vp->v_vnlock != NULL) {
-		if (flags & LK_THISLAYER)
-			return 0;	/* the lock is shared across layers */
-		flags &= ~LK_THISLAYER;
-		return (lockmgr(vp->v_vnlock, flags | LK_RELEASE,
-			&vp->v_interlock, p));
-	}
-	lvp = NULLVPTOLOWERVP(vp);
-	if (lvp == NULL)
-		return (lockmgr(&vp->v_lock, flags | LK_RELEASE, &vp->v_interlock, p));
-	if ((flags & LK_THISLAYER) == 0) {
-		if (flags & LK_INTERLOCK) {
-			mtx_unlock(&vp->v_interlock);
-			flags &= ~LK_INTERLOCK;
-		}
-		VOP_UNLOCK(lvp, flags & ~LK_INTERLOCK, p);
-	} else
-		flags &= ~LK_THISLAYER;
-	return (lockmgr(&vp->v_lock, flags | LK_RELEASE, &vp->v_interlock, p));
-}
-
-static int
-null_islocked(ap)
-	struct vop_islocked_args /* {
-		struct vnode *a_vp;
-		struct proc *a_p;
-	} */ *ap;
-{
-	struct vnode *vp = ap->a_vp;
-	struct proc *p = ap->a_p;
-
-	if (vp->v_vnlock != NULL)
-		return (lockstatus(vp->v_vnlock, p));
-	return (lockstatus(&vp->v_lock, p));
-}
-
-/*
- * There is no way to tell that someone issued remove/rmdir operation
- * on the underlying filesystem. For now we just have to release lowevrp
- * as soon as possible.
- */
-static int
-null_inactive(ap)
-	struct vop_inactive_args /* {
-		struct vnode *a_vp;
-		struct proc *a_p;
-	} */ *ap;
-{
-	struct vnode *vp = ap->a_vp;
-	struct proc *p = ap->a_p;
-	struct null_node *xp = VTONULL(vp);
-	struct vnode *lowervp = xp->null_lowervp;
-
-	lockmgr(&null_hashlock, LK_EXCLUSIVE, NULL, p);
-	LIST_REMOVE(xp, null_hash);
-	lockmgr(&null_hashlock, LK_RELEASE, NULL, p);
-
-	xp->null_lowervp = NULLVP;
-	if (vp->v_vnlock != NULL) {
-		vp->v_vnlock = &vp->v_lock;	/* we no longer share the lock */
-	} else
-		VOP_UNLOCK(vp, LK_THISLAYER, p);
-
-	vput(lowervp);
-	/*
-	 * Now it is safe to drop references to the lower vnode.
-	 * VOP_INACTIVE() will be called by vrele() if necessary.
-	 */
-	vrele (lowervp);
-
-	return (0);
-}
-
-/*
- * We can free memory in null_inactive, but we do this
- * here. (Possible to guard vp->v_data to point somewhere)
- */
-static int
-null_reclaim(ap)
-	struct vop_reclaim_args /* {
-		struct vnode *a_vp;
-		struct proc *a_p;
-	} */ *ap;
-{
-	struct vnode *vp = ap->a_vp;
-	void *vdata = vp->v_data;
-
-	vp->v_data = NULL;
-	FREE(vdata, M_NULLFSNODE);
-
-	return (0);
-}
-
-static int
-null_print(ap)
-	struct vop_print_args /* {
-		struct vnode *a_vp;
-	} */ *ap;
-{
-	register struct vnode *vp = ap->a_vp;
-	printf ("\ttag VT_NULLFS, vp=%p, lowervp=%p\n", vp, NULLVPTOLOWERVP(vp));
-	return (0);
-}
-
-/*
- * Let an underlying filesystem do the work
- */
-static int
-null_createvobject(ap)
-	struct vop_createvobject_args /* {
-		struct vnode *vp;
-		struct ucred *cred;
-		struct proc *p;
-	} */ *ap;
-{
-	struct vnode *vp = ap->a_vp;
-	struct vnode *lowervp = VTONULL(vp) ? NULLVPTOLOWERVP(vp) : NULL;
-	int error;
-
-	if (vp->v_type == VNON || lowervp == NULL)
-		return 0;
-	error = VOP_CREATEVOBJECT(lowervp, ap->a_cred, ap->a_p);
-	if (error)
-		return (error);
-	vp->v_flag |= VOBJBUF;
-	return (0);
-}
-
-/*
- * We have nothing to destroy and this operation shouldn't be bypassed.
- */
-static int
-null_destroyvobject(ap)
-	struct vop_destroyvobject_args /* {
-		struct vnode *vp;
-	} */ *ap;
-{
-	struct vnode *vp = ap->a_vp;
-
-	vp->v_flag &= ~VOBJBUF;
-	return (0);
-}
-
-static int
-null_getvobject(ap)
-	struct vop_getvobject_args /* {
-		struct vnode *vp;
-		struct vm_object **objpp;
-	} */ *ap;
-{
-	struct vnode *lvp = NULLVPTOLOWERVP(ap->a_vp);
-
-	if (lvp == NULL)
-		return EINVAL;
-	return (VOP_GETVOBJECT(lvp, ap->a_objpp));
-}
-
-/*
- * Global vfs data structures
- */
-vop_t **null_vnodeop_p;
-static struct vnodeopv_entry_desc null_vnodeop_entries[] = {
-	{ &vop_default_desc,		(vop_t *) null_bypass },
-
-	{ &vop_access_desc,		(vop_t *) null_access },
-	{ &vop_bmap_desc,		(vop_t *) vop_eopnotsupp },
-	{ &vop_createvobject_desc,	(vop_t *) null_createvobject },
-	{ &vop_destroyvobject_desc,	(vop_t *) null_destroyvobject },
-	{ &vop_getattr_desc,		(vop_t *) null_getattr },
-	{ &vop_getvobject_desc,		(vop_t *) null_getvobject },
-	{ &vop_getwritemount_desc,	(vop_t *) vop_stdgetwritemount},
-	{ &vop_inactive_desc,		(vop_t *) null_inactive },
-	{ &vop_islocked_desc,		(vop_t *) null_islocked },
-	{ &vop_lock_desc,		(vop_t *) null_lock },
-	{ &vop_lookup_desc,		(vop_t *) null_lookup },
-	{ &vop_open_desc,		(vop_t *) null_open },
-	{ &vop_print_desc,		(vop_t *) null_print },
-	{ &vop_reclaim_desc,		(vop_t *) null_reclaim },
-	{ &vop_rename_desc,		(vop_t *) null_rename },
-	{ &vop_setattr_desc,		(vop_t *) null_setattr },
-	{ &vop_strategy_desc,		(vop_t *) vop_eopnotsupp },
-	{ &vop_unlock_desc,		(vop_t *) null_unlock },
-	{ NULL, NULL }
-};
-static struct vnodeopv_desc null_vnodeop_opv_desc =
-	{ &null_vnodeop_p, null_vnodeop_entries };
-
-VNODEOP_SET(null_vnodeop_opv_desc);
diff --git a/sys/miscfs/portal/portal.h b/sys/miscfs/portal/portal.h
deleted file mode 100644
index ec46662..0000000
--- a/sys/miscfs/portal/portal.h
+++ /dev/null
@@ -1,71 +0,0 @@
-/*
- * Copyright (c) 1992, 1993
- *	The Regents of the University of California.  All rights reserved.
- *
- * This code is derived from software donated to Berkeley by
- * Jan-Simon Pendry.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)portal.h	8.4 (Berkeley) 1/21/94
- *
- * $FreeBSD$
- */
-
-struct portal_args {
-	char		*pa_config;	/* Config file */
-	int		pa_socket;	/* Socket to server */
-};
-
-struct portal_cred {
-	int		pcr_flag;		/* File open mode */
-	uid_t		pcr_uid;		/* From ucred */
-	short		pcr_ngroups;		/* From ucred */
-	gid_t		pcr_groups[NGROUPS];	/* From ucred */
-};
-
-#ifdef _KERNEL
-struct portalmount {
-	struct vnode	*pm_root;	/* Root node */
-	struct file	*pm_server;	/* Held reference to server socket */
-};
-
-struct portalnode {
-	int		pt_size;	/* Length of Arg */
-	char		*pt_arg;	/* Arg to send to server */
-	int		pt_fileid;	/* cookie */
-};
-
-#define VFSTOPORTAL(mp)	((struct portalmount *)((mp)->mnt_data))
-#define	VTOPORTAL(vp) ((struct portalnode *)(vp)->v_data)
-
-#define PORTAL_ROOTFILEID	2
-
-extern vop_t **portal_vnodeop_p;
-#endif /* _KERNEL */
diff --git a/sys/miscfs/portal/portal_vfsops.c b/sys/miscfs/portal/portal_vfsops.c
deleted file mode 100644
index 423cd38..0000000
--- a/sys/miscfs/portal/portal_vfsops.c
+++ /dev/null
@@ -1,257 +0,0 @@
-/*
- * Copyright (c) 1992, 1993, 1995
- *	The Regents of the University of California.  All rights reserved.
- *
- * This code is derived from software donated to Berkeley by
- * Jan-Simon Pendry.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)portal_vfsops.c	8.11 (Berkeley) 5/14/95
- *
- * $FreeBSD$
- */
-
-/*
- * Portal Filesystem
- */
-
-#include <sys/param.h>
-#include <sys/systm.h>
-#include <sys/domain.h>
-#include <sys/filedesc.h>
-#include <sys/kernel.h>
-#include <sys/lock.h>
-#include <sys/malloc.h>
-#include <sys/file.h>		/* Must come after sys/malloc.h */
-#include <sys/mount.h>
-#include <sys/proc.h>
-#include <sys/protosw.h>
-#include <sys/socket.h>
-#include <sys/socketvar.h>
-#include <sys/vnode.h>
-
-#include <miscfs/portal/portal.h>
-
-static MALLOC_DEFINE(M_PORTALFSMNT, "PORTAL mount", "PORTAL mount structure");
-
-static int	portal_mount __P((struct mount *mp, char *path, caddr_t data,
-				  struct nameidata *ndp, struct proc *p));
-static int	portal_unmount __P((struct mount *mp, int mntflags,
-				    struct proc *p));
-static int	portal_root __P((struct mount *mp, struct vnode **vpp));
-static int	portal_statfs __P((struct mount *mp, struct statfs *sbp,
-				   struct proc *p));
-
-/*
- * Mount the per-process file descriptors (/dev/fd)
- */
-static int
-portal_mount(mp, path, data, ndp, p)
-	struct mount *mp;
-	char *path;
-	caddr_t data;
-	struct nameidata *ndp;
-	struct proc *p;
-{
-	struct file *fp;
-	struct portal_args args;
-	struct portalmount *fmp;
-	struct socket *so;
-	struct vnode *rvp;
-	struct portalnode *pn;
-	u_int size;
-	int error;
-
-	/*
-	 * Update is a no-op
-	 */
-	if (mp->mnt_flag & MNT_UPDATE)
-		return (EOPNOTSUPP);
-
-	error = copyin(data, (caddr_t) &args, sizeof(struct portal_args));
-	if (error)
-		return (error);
-
-	error = holdsock(p->p_fd, args.pa_socket, &fp);
-	if (error)
-		return (error);
-	so = (struct socket *) fp->f_data;
-	if (so->so_proto->pr_domain->dom_family != AF_UNIX) {
-		fdrop(fp, p);
-		return (ESOCKTNOSUPPORT);
-	}
-
-	MALLOC(pn, struct portalnode *, sizeof(struct portalnode),
-		M_TEMP, M_WAITOK);
-
-	MALLOC(fmp, struct portalmount *, sizeof(struct portalmount),
-		M_PORTALFSMNT, M_WAITOK);	/* XXX */
-
-	error = getnewvnode(VT_PORTAL, mp, portal_vnodeop_p, &rvp); /* XXX */
-	if (error) {
-		FREE(fmp, M_PORTALFSMNT);
-		FREE(pn, M_TEMP);
-		fdrop(fp, p);
-		return (error);
-	}
-
-	rvp->v_data = pn;
-	rvp->v_type = VDIR;
-	rvp->v_flag |= VROOT;
-	VTOPORTAL(rvp)->pt_arg = 0;
-	VTOPORTAL(rvp)->pt_size = 0;
-	VTOPORTAL(rvp)->pt_fileid = PORTAL_ROOTFILEID;
-	fmp->pm_root = rvp;
-	fmp->pm_server = fp; fp->f_count++;
-
-	mp->mnt_flag |= MNT_LOCAL;
-	mp->mnt_data = (qaddr_t) fmp;
-	vfs_getnewfsid(mp);
-
-	(void)copyinstr(args.pa_config,
-	    mp->mnt_stat.f_mntfromname, MNAMELEN - 1, &size);
-	bzero(mp->mnt_stat.f_mntfromname + size, MNAMELEN - size);
-
-#ifdef notdef
-	bzero(mp->mnt_stat.f_mntfromname, MNAMELEN);
-	bcopy("portal", mp->mnt_stat.f_mntfromname, sizeof("portal"));
-#endif
-
-	(void)portal_statfs(mp, &mp->mnt_stat, p);
-	fdrop(fp, p);
-	return (0);
-}
-
-static int
-portal_unmount(mp, mntflags, p)
-	struct mount *mp;
-	int mntflags;
-	struct proc *p;
-{
-	int error, flags = 0;
-
-
-	if (mntflags & MNT_FORCE)
-		flags |= FORCECLOSE;
-
-	/*
-	 * Clear out buffer cache.  I don't think we
-	 * ever get anything cached at this level at the
-	 * moment, but who knows...
-	 */
-#ifdef notyet
-	mntflushbuf(mp, 0);
-	if (mntinvalbuf(mp, 1))
-		return (EBUSY);
-#endif
-	/* There is 1 extra root vnode reference (pm_root). */
-	error = vflush(mp, 1, flags);
-	if (error)
-		return (error);
-
-	/*
-	 * Shutdown the socket.  This will cause the select in the
-	 * daemon to wake up, and then the accept will get ECONNABORTED
-	 * which it interprets as a request to go and bury itself.
-	 */
-	soshutdown((struct socket *) VFSTOPORTAL(mp)->pm_server->f_data, 2);
-	/*
-	 * Discard reference to underlying file.  Must call closef because
-	 * this may be the last reference.
-	 */
-	closef(VFSTOPORTAL(mp)->pm_server, (struct proc *) 0);
-	/*
-	 * Finally, throw away the portalmount structure
-	 */
-	free(mp->mnt_data, M_PORTALFSMNT);	/* XXX */
-	mp->mnt_data = 0;
-	return (0);
-}
-
-static int
-portal_root(mp, vpp)
-	struct mount *mp;
-	struct vnode **vpp;
-{
-	struct proc *p = curproc;	/* XXX */
-	struct vnode *vp;
-
-	/*
-	 * Return locked reference to root.
-	 */
-	vp = VFSTOPORTAL(mp)->pm_root;
-	VREF(vp);
-	vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
-	*vpp = vp;
-	return (0);
-}
-
-static int
-portal_statfs(mp, sbp, p)
-	struct mount *mp;
-	struct statfs *sbp;
-	struct proc *p;
-{
-
-	sbp->f_flags = 0;
-	sbp->f_bsize = DEV_BSIZE;
-	sbp->f_iosize = DEV_BSIZE;
-	sbp->f_blocks = 2;		/* 1K to keep df happy */
-	sbp->f_bfree = 0;
-	sbp->f_bavail = 0;
-	sbp->f_files = 1;		/* Allow for "." */
-	sbp->f_ffree = 0;		/* See comments above */
-	if (sbp != &mp->mnt_stat) {
-		sbp->f_type = mp->mnt_vfc->vfc_typenum;
-		bcopy(&mp->mnt_stat.f_fsid, &sbp->f_fsid, sizeof(sbp->f_fsid));
-		bcopy(mp->mnt_stat.f_mntonname, sbp->f_mntonname, MNAMELEN);
-		bcopy(mp->mnt_stat.f_mntfromname, sbp->f_mntfromname, MNAMELEN);
-	}
-	return (0);
-}
-
-static struct vfsops portal_vfsops = {
-	portal_mount,
-	vfs_stdstart,
-	portal_unmount,
-	portal_root,
-	vfs_stdquotactl,
-	portal_statfs,
-	vfs_stdsync,
-	vfs_stdvget,
-	vfs_stdfhtovp,
-	vfs_stdcheckexp,
-	vfs_stdvptofh,
-	vfs_stdinit,
-	vfs_stduninit,
-	vfs_stdextattrctl,
-};
-
-VFS_SET(portal_vfsops, portal, VFCF_SYNTHETIC);
diff --git a/sys/miscfs/portal/portal_vnops.c b/sys/miscfs/portal/portal_vnops.c
deleted file mode 100644
index b53c4ca..0000000
--- a/sys/miscfs/portal/portal_vnops.c
+++ /dev/null
@@ -1,591 +0,0 @@
-/*
- * Copyright (c) 1992, 1993
- *	The Regents of the University of California.  All rights reserved.
- *
- * This code is derived from software donated to Berkeley by
- * Jan-Simon Pendry.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)portal_vnops.c	8.14 (Berkeley) 5/21/95
- *
- * $FreeBSD$
- */
-
-/*
- * Portal Filesystem
- */
-
-#include <sys/param.h>
-#include <sys/systm.h>
-#include <sys/sysproto.h>
-#include <sys/kernel.h>
-#include <sys/time.h>
-#include <sys/proc.h>
-#include <sys/filedesc.h>
-#include <sys/vnode.h>
-#include <sys/fcntl.h>
-#include <sys/file.h>
-#include <sys/stat.h>
-#include <sys/mount.h>
-#include <sys/malloc.h>
-#include <sys/namei.h>
-#include <sys/mbuf.h>
-#include <sys/socket.h>
-#include <sys/socketvar.h>
-#include <sys/un.h>
-#include <sys/unpcb.h>
-#include <miscfs/portal/portal.h>
-
-static int portal_fileid = PORTAL_ROOTFILEID+1;
-
-static int	portal_badop __P((void));
-static void	portal_closefd __P((struct proc *p, int fd));
-static int	portal_connect __P((struct socket *so, struct socket *so2));
-static int	portal_getattr __P((struct vop_getattr_args *ap));
-static int	portal_lookup __P((struct vop_lookup_args *ap));
-static int	portal_open __P((struct vop_open_args *ap));
-static int	portal_print __P((struct vop_print_args *ap));
-static int	portal_readdir __P((struct vop_readdir_args *ap));
-static int	portal_reclaim __P((struct vop_reclaim_args *ap));
-static int	portal_setattr __P((struct vop_setattr_args *ap));
-
-static void
-portal_closefd(p, fd)
-	struct proc *p;
-	int fd;
-{
-	int error;
-	struct close_args ua;
-
-	ua.fd = fd;
-	error = close(p, &ua);
-	/*
-	 * We should never get an error, and there isn't anything
-	 * we could do if we got one, so just print a message.
-	 */
-	if (error)
-		printf("portal_closefd: error = %d\n", error);
-}
-
-/*
- * vp is the current namei directory
- * cnp is the name to locate in that directory...
- */
-static int
-portal_lookup(ap)
-	struct vop_lookup_args /* {
-		struct vnode * a_dvp;
-		struct vnode ** a_vpp;
-		struct componentname * a_cnp;
-	} */ *ap;
-{
-	struct componentname *cnp = ap->a_cnp;
-	struct vnode **vpp = ap->a_vpp;
-	struct vnode *dvp = ap->a_dvp;
-	char *pname = cnp->cn_nameptr;
-	struct portalnode *pt;
-	int error;
-	struct vnode *fvp = 0;
-	char *path;
-	int size;
-
-	*vpp = NULLVP;
-
-	if (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME)
-		return (EROFS);
-
-	if (cnp->cn_namelen == 1 && *pname == '.') {
-		*vpp = dvp;
-		VREF(dvp);
-		/*VOP_LOCK(dvp);*/
-		return (0);
-	}
-
-	/*
-	 * Do the MALLOC before the getnewvnode since doing so afterward
-	 * might cause a bogus v_data pointer to get dereferenced
-	 * elsewhere if MALLOC should block.
-	 */
-	MALLOC(pt, struct portalnode *, sizeof(struct portalnode),
-		M_TEMP, M_WAITOK);
-
-	error = getnewvnode(VT_PORTAL, dvp->v_mount, portal_vnodeop_p, &fvp);
-	if (error) {
-		FREE(pt, M_TEMP);
-		goto bad;
-	}
-	fvp->v_type = VREG;
-	fvp->v_data = pt;
-	/*
-	 * Save all of the remaining pathname and
-	 * advance the namei next pointer to the end
-	 * of the string.
-	 */
-	for (size = 0, path = pname; *path; path++)
-		size++;
-	cnp->cn_consume = size - cnp->cn_namelen;
-
-	pt->pt_arg = malloc(size+1, M_TEMP, M_WAITOK);
-	pt->pt_size = size+1;
-	bcopy(pname, pt->pt_arg, pt->pt_size);
-	pt->pt_fileid = portal_fileid++;
-
-	*vpp = fvp;
-	/*VOP_LOCK(fvp);*/
-	return (0);
-
-bad:;
-	if (fvp)
-		vrele(fvp);
-	return (error);
-}
-
-static int
-portal_connect(so, so2)
-	struct socket *so;
-	struct socket *so2;
-{
-	/* from unp_connect, bypassing the namei stuff... */
-	struct socket *so3;
-	struct unpcb *unp2;
-	struct unpcb *unp3;
-
-	if (so2 == 0)
-		return (ECONNREFUSED);
-
-	if (so->so_type != so2->so_type)
-		return (EPROTOTYPE);
-
-	if ((so2->so_options & SO_ACCEPTCONN) == 0)
-		return (ECONNREFUSED);
-
-	if ((so3 = sonewconn(so2, 0)) == 0)
-		return (ECONNREFUSED);
-
-	unp2 = sotounpcb(so2);
-	unp3 = sotounpcb(so3);
-	if (unp2->unp_addr)
-		unp3->unp_addr = (struct sockaddr_un *)
-			dup_sockaddr((struct sockaddr *)unp2->unp_addr, 0);
-	so2 = so3;
-
-	return (unp_connect2(so, so2));
-}
-
-static int
-portal_open(ap)
-	struct vop_open_args /* {
-		struct vnode *a_vp;
-		int  a_mode;
-		struct ucred *a_cred;
-		struct proc *a_p;
-	} */ *ap;
-{
-	struct socket *so = 0;
-	struct portalnode *pt;
-	struct proc *p = ap->a_p;
-	struct vnode *vp = ap->a_vp;
-	int s;
-	struct uio auio;
-	struct iovec aiov[2];
-	int res;
-	struct mbuf *cm = 0;
-	struct cmsghdr *cmsg;
-	int newfds;
-	int *ip;
-	int fd;
-	int error;
-	int len;
-	struct portalmount *fmp;
-	struct file *fp;
-	struct portal_cred pcred;
-
-	/*
-	 * Nothing to do when opening the root node.
-	 */
-	if (vp->v_flag & VROOT)
-		return (0);
-
-	/*
-	 * Can't be opened unless the caller is set up
-	 * to deal with the side effects.  Check for this
-	 * by testing whether the p_dupfd has been set.
-	 */
-	if (p->p_dupfd >= 0)
-		return (ENODEV);
-
-	pt = VTOPORTAL(vp);
-	fmp = VFSTOPORTAL(vp->v_mount);
-
-	/*
-	 * Create a new socket.
-	 */
-	error = socreate(AF_UNIX, &so, SOCK_STREAM, 0, ap->a_p);
-	if (error)
-		goto bad;
-
-	/*
-	 * Reserve some buffer space
-	 */
-	res = pt->pt_size + sizeof(pcred) + 512;	/* XXX */
-	error = soreserve(so, res, res);
-	if (error)
-		goto bad;
-
-	/*
-	 * Kick off connection
-	 */
-	error = portal_connect(so, (struct socket *)fmp->pm_server->f_data);
-	if (error)
-		goto bad;
-
-	/*
-	 * Wait for connection to complete
-	 */
-	/*
-	 * XXX: Since the mount point is holding a reference on the
-	 * underlying server socket, it is not easy to find out whether
-	 * the server process is still running.  To handle this problem
-	 * we loop waiting for the new socket to be connected (something
-	 * which will only happen if the server is still running) or for
-	 * the reference count on the server socket to drop to 1, which
-	 * will happen if the server dies.  Sleep for 5 second intervals
-	 * and keep polling the reference count.   XXX.
-	 */
-	s = splnet();
-	while ((so->so_state & SS_ISCONNECTING) && so->so_error == 0) {
-		if (fmp->pm_server->f_count == 1) {
-			error = ECONNREFUSED;
-			splx(s);
-			goto bad;
-		}
-		(void) tsleep((caddr_t) &so->so_timeo, PSOCK, "portalcon", 5 * hz);
-	}
-	splx(s);
-
-	if (so->so_error) {
-		error = so->so_error;
-		goto bad;
-	}
-
-	/*
-	 * Set miscellaneous flags
-	 */
-	so->so_rcv.sb_timeo = 0;
-	so->so_snd.sb_timeo = 0;
-	so->so_rcv.sb_flags |= SB_NOINTR;
-	so->so_snd.sb_flags |= SB_NOINTR;
-
-
-	pcred.pcr_flag = ap->a_mode;
-	pcred.pcr_uid = ap->a_cred->cr_uid;
-	pcred.pcr_ngroups = ap->a_cred->cr_ngroups;
-	bcopy(ap->a_cred->cr_groups, pcred.pcr_groups, NGROUPS * sizeof(gid_t));
-	aiov[0].iov_base = (caddr_t) &pcred;
-	aiov[0].iov_len = sizeof(pcred);
-	aiov[1].iov_base = pt->pt_arg;
-	aiov[1].iov_len = pt->pt_size;
-	auio.uio_iov = aiov;
-	auio.uio_iovcnt = 2;
-	auio.uio_rw = UIO_WRITE;
-	auio.uio_segflg = UIO_SYSSPACE;
-	auio.uio_procp = p;
-	auio.uio_offset = 0;
-	auio.uio_resid = aiov[0].iov_len + aiov[1].iov_len;
-
-	error = sosend(so, (struct sockaddr *) 0, &auio,
-			(struct mbuf *) 0, (struct mbuf *) 0, 0, p);
-	if (error)
-		goto bad;
-
-	len = auio.uio_resid = sizeof(int);
-	do {
-		struct mbuf *m = 0;
-		int flags = MSG_WAITALL;
-		error = soreceive(so, (struct sockaddr **) 0, &auio,
-					&m, &cm, &flags);
-		if (error)
-			goto bad;
-
-		/*
-		 * Grab an error code from the mbuf.
-		 */
-		if (m) {
-			m = m_pullup(m, sizeof(int));	/* Needed? */
-			if (m) {
-				error = *(mtod(m, int *));
-				m_freem(m);
-			} else {
-				error = EINVAL;
-			}
-		} else {
-			if (cm == 0) {
-				error = ECONNRESET;	 /* XXX */
-#ifdef notdef
-				break;
-#endif
-			}
-		}
-	} while (cm == 0 && auio.uio_resid == len && !error);
-
-	if (cm == 0)
-		goto bad;
-
-	if (auio.uio_resid) {
-		error = 0;
-#ifdef notdef
-		error = EMSGSIZE;
-		goto bad;
-#endif
-	}
-
-	/*
-	 * XXX: Break apart the control message, and retrieve the
-	 * received file descriptor.  Note that more than one descriptor
-	 * may have been received, or that the rights chain may have more
-	 * than a single mbuf in it.  What to do?
-	 */
-	cmsg = mtod(cm, struct cmsghdr *);
-	newfds = (cmsg->cmsg_len - sizeof(*cmsg)) / sizeof (int);
-	if (newfds == 0) {
-		error = ECONNREFUSED;
-		goto bad;
-	}
-	/*
-	 * At this point the rights message consists of a control message
-	 * header, followed by a data region containing a vector of
-	 * integer file descriptors.  The fds were allocated by the action
-	 * of receiving the control message.
-	 */
-	ip = (int *) (cmsg + 1);
-	fd = *ip++;
-	if (newfds > 1) {
-		/*
-		 * Close extra fds.
-		 */
-		int i;
-		printf("portal_open: %d extra fds\n", newfds - 1);
-		for (i = 1; i < newfds; i++) {
-			portal_closefd(p, *ip);
-			ip++;
-		}
-	}
-
-	/*
-	 * Check that the mode the file is being opened for is a subset
-	 * of the mode of the existing descriptor.
-	 */
- 	fp = p->p_fd->fd_ofiles[fd];
-	if (((ap->a_mode & (FREAD|FWRITE)) | fp->f_flag) != fp->f_flag) {
-		portal_closefd(p, fd);
-		error = EACCES;
-		goto bad;
-	}
-
-	/*
-	 * Save the dup fd in the proc structure then return the
-	 * special error code (ENXIO) which causes magic things to
-	 * happen in vn_open.  The whole concept is, well, hmmm.
-	 */
-	p->p_dupfd = fd;
-	error = ENXIO;
-
-bad:;
-	/*
-	 * And discard the control message.
-	 */
-	if (cm) {
-		m_freem(cm);
-	}
-
-	if (so) {
-		soshutdown(so, 2);
-		soclose(so);
-	}
-	return (error);
-}
-
-static int
-portal_getattr(ap)
-	struct vop_getattr_args /* {
-		struct vnode *a_vp;
-		struct vattr *a_vap;
-		struct ucred *a_cred;
-		struct proc *a_p;
-	} */ *ap;
-{
-	struct vnode *vp = ap->a_vp;
-	struct vattr *vap = ap->a_vap;
-
-	bzero(vap, sizeof(*vap));
-	vattr_null(vap);
-	vap->va_uid = 0;
-	vap->va_gid = 0;
-	vap->va_size = DEV_BSIZE;
-	vap->va_blocksize = DEV_BSIZE;
-	nanotime(&vap->va_atime);
-	vap->va_mtime = vap->va_atime;
-	vap->va_ctime = vap->va_mtime;
-	vap->va_gen = 0;
-	vap->va_flags = 0;
-	vap->va_rdev = 0;
-	/* vap->va_qbytes = 0; */
-	vap->va_bytes = 0;
-	/* vap->va_qsize = 0; */
-	if (vp->v_flag & VROOT) {
-		vap->va_type = VDIR;
-		vap->va_mode = S_IRUSR|S_IWUSR|S_IXUSR|
-				S_IRGRP|S_IWGRP|S_IXGRP|
-				S_IROTH|S_IWOTH|S_IXOTH;
-		vap->va_nlink = 2;
-		vap->va_fileid = 2;
-	} else {
-		vap->va_type = VREG;
-		vap->va_mode = S_IRUSR|S_IWUSR|
-				S_IRGRP|S_IWGRP|
-				S_IROTH|S_IWOTH;
-		vap->va_nlink = 1;
-		vap->va_fileid = VTOPORTAL(vp)->pt_fileid;
-	}
-	return (0);
-}
-
-static int
-portal_setattr(ap)
-	struct vop_setattr_args /* {
-		struct vnode *a_vp;
-		struct vattr *a_vap;
-		struct ucred *a_cred;
-		struct proc *a_p;
-	} */ *ap;
-{
-
-	/*
-	 * Can't mess with the root vnode
-	 */
-	if (ap->a_vp->v_flag & VROOT)
-		return (EACCES);
-
-	if (ap->a_vap->va_flags != VNOVAL)
-		return (EOPNOTSUPP);
-
-	return (0);
-}
-
-/*
- * Fake readdir, just return empty directory.
- * It is hard to deal with '.' and '..' so don't bother.
- */
-static int
-portal_readdir(ap)
-	struct vop_readdir_args /* {
-		struct vnode *a_vp;
-		struct uio *a_uio;
-		struct ucred *a_cred;
-		int *a_eofflag;
-		u_long *a_cookies;
-		int a_ncookies;
-	} */ *ap;
-{
-
-	/*
-	 * We don't allow exporting portal mounts, and currently local
-	 * requests do not need cookies.
-	 */
-	if (ap->a_ncookies)
-		panic("portal_readdir: not hungry");
-
-	return (0);
-}
-
-static int
-portal_reclaim(ap)
-	struct vop_reclaim_args /* {
-		struct vnode *a_vp;
-	} */ *ap;
-{
-	struct portalnode *pt = VTOPORTAL(ap->a_vp);
-
-	if (pt->pt_arg) {
-		free((caddr_t) pt->pt_arg, M_TEMP);
-		pt->pt_arg = 0;
-	}
-	FREE(ap->a_vp->v_data, M_TEMP);
-	ap->a_vp->v_data = 0;
-
-	return (0);
-}
-
-
-/*
- * Print out the contents of a Portal vnode.
- */
-/* ARGSUSED */
-static int
-portal_print(ap)
-	struct vop_print_args /* {
-		struct vnode *a_vp;
-	} */ *ap;
-{
-
-	printf("tag VT_PORTAL, portal vnode\n");
-	return (0);
-}
-
-
-/*
- * Portal "should never get here" operation
- */
-static int
-portal_badop()
-{
-
-	panic("portal: bad op");
-	/* NOTREACHED */
-}
-
-vop_t **portal_vnodeop_p;
-static struct vnodeopv_entry_desc portal_vnodeop_entries[] = {
-	{ &vop_default_desc,		(vop_t *) vop_defaultop },
-	{ &vop_access_desc,		(vop_t *) vop_null },
-	{ &vop_getattr_desc,		(vop_t *) portal_getattr },
-	{ &vop_lookup_desc,		(vop_t *) portal_lookup },
-	{ &vop_open_desc,		(vop_t *) portal_open },
-	{ &vop_pathconf_desc,		(vop_t *) vop_stdpathconf },
-	{ &vop_print_desc,		(vop_t *) portal_print },
-	{ &vop_readdir_desc,		(vop_t *) portal_readdir },
-	{ &vop_reclaim_desc,		(vop_t *) portal_reclaim },
-	{ &vop_setattr_desc,		(vop_t *) portal_setattr },
-	{ NULL, NULL }
-};
-static struct vnodeopv_desc portal_vnodeop_opv_desc =
-	{ &portal_vnodeop_p, portal_vnodeop_entries };
-
-VNODEOP_SET(portal_vnodeop_opv_desc);
diff --git a/sys/miscfs/procfs/README b/sys/miscfs/procfs/README
deleted file mode 100644
index f816b32..0000000
--- a/sys/miscfs/procfs/README
+++ /dev/null
@@ -1,113 +0,0 @@
-saute procfs lyonnais
-
-procfs supports two levels of directory.  the filesystem root
-directory contains a representation of the system process table.
-this consists of an entry for each active and zombie process, and
-an additional entry "curproc" which always represents the process
-making the lookup request.
-
-each of the sub-directories contains several files.  these files
-are used to control and interrogate processes.  the files implemented
-are:
-
-	file	- xxx.  the exec'ed file.
-
-	status  - r/o.  returns process status.
-
-	ctl	- w/o.  sends a control message to the process.
-			for example:
-				echo hup > /proc/curproc/note
-			will send a SIGHUP to the shell.
-			whereas
-				echo attach > /proc/1293/ctl
-			would set up process 1293 for debugging.
-			see below for more details.
-
-	mem	- r/w.  virtual memory image of the process.
-			parts of the address space are readable
-			only if they exist in the target process.
-			a more reasonable alternative might be
-			to return zero pages instead of an error.
-			comments?
-
-	note	- w/o.  writing a string here sends the
-			equivalent note to the process.
-			[ not implemented. ]
-
-	notepg	- w/o.  the same as note, but sends to all
-			members of the process group.
-			[ not implemented. ]
-
-	regs	- r/w.	process register set.  this can be read
-			or written any time even if the process
-			is not stopped.  since the bsd kernel
-			is single-processor, this implementation
-			will get the "right" register values.
-			a multi-proc kernel would need to do some
-			synchronisation.
-
-this then looks like:
-
-% ls -li /proc
-total 0
-   9 dr-xr-xr-x  2 root  wheel  0 Sep 21 15:06 0
-  17 dr-xr-xr-x  2 root  wheel  0 Sep 21 15:06 1
-  89 dr-xr-xr-x  2 root  wheel  0 Sep 21 15:06 10
-  25 dr-xr-xr-x  2 root  wheel  0 Sep 21 15:06 2
-2065 dr-xr-xr-x  2 root  wheel  0 Sep 21 15:06 257
-2481 dr-xr-xr-x  2 jsp   staff  0 Sep 21 15:06 309
- 265 dr-xr-xr-x  2 root  wheel  0 Sep 21 15:06 32
-3129 dr-xr-xr-x  2 jsp   staff  0 Sep 21 15:06 390
-3209 dr-xr-xr-x  2 jsp   staff  0 Sep 21 15:06 400
-3217 dr-xr-xr-x  2 jsp   staff  0 Sep 21 15:06 401
-3273 dr-xr-xr-x  2 jsp   staff  0 Sep 21 15:06 408
- 393 dr-xr-xr-x  2 root  wheel  0 Sep 21 15:06 48
- 409 dr-xr-xr-x  2 root  wheel  0 Sep 21 15:06 50
- 465 dr-xr-xr-x  2 root  wheel  0 Sep 21 15:06 57
- 481 dr-xr-xr-x  2 root  wheel  0 Sep 21 15:06 59
- 537 dr-xr-xr-x  2 root  kmem   0 Sep 21 15:06 66
- 545 dr-xr-xr-x  2 root  wheel  0 Sep 21 15:06 67
- 657 dr-xr-xr-x  2 jsp   staff  0 Sep 21 15:06 81
- 665 dr-xr-xr-x  2 jsp   staff  0 Sep 21 15:06 82
- 673 dr-xr-xr-x  2 jsp   staff  0 Sep 21 15:06 83
- 681 dr-xr-xr-x  2 root  wheel  0 Sep 21 15:06 84
-3273 dr-xr-xr-x  2 jsp   staff  0 Sep 21 15:06 curproc
-% ls -li /proc/curproc
-total 408
-3341 --w-------  1 jsp  staff       0 Sep 21 15:06 ctl
-1554 -r-xr-xr-x  1 bin  bin     90112 Mar 29 04:52 file
-3339 -rw-------  1 jsp  staff  118784 Sep 21 15:06 mem
-3343 --w-------  1 jsp  staff       0 Sep 21 15:06 note
-3344 --w-------  1 jsp  staff       0 Sep 21 15:06 notepg
-3340 -rw-------  1 jsp  staff       0 Sep 21 15:06 regs
-3342 -r--r--r--  1 jsp  staff       0 Sep 21 15:06 status
-% df /proc/curproc /proc/curproc/file
-Filesystem  512-blocks    Used   Avail Capacity  Mounted on
-proc                 2       2       0   100%    /proc
-/dev/wd0a        16186   13548    1018    93%    /
-% cat /proc/curproc/status
-cat 446 439 400 81 12,0 ctty 748620684 270000 0 0 0 20000 nochan 11 20 20 20 0 21 117
-
-
-
-the basic sequence of commands written to "ctl" would be
-
-	attach		- this stops the target process and
-			  arranges for the sending process
-			  to become the debug control process
-	wait		- wait for the target process to come to
-			  a steady state ready for debugging.
-	step		- single step, with no signal delivery.
-	run		- continue running, with no signal delivery,
-			  until next trap or breakpoint.
-	<signame>	- deliver signal <signame> and continue running.
-	detach		- continue execution of the target process
-			  and remove it from control by the debug process
-
-in a normal debugging environment, where the target is fork/exec'd by
-the debugger, the debugger should fork and the child should stop itself
-(with a self-inflicted SIGSTOP).  the parent should do a "wait" then an
-"attach".  as before, the child will hit a breakpoint on the first
-instruction in any newly exec'd image.
-
-$FreeBSD$
diff --git a/sys/miscfs/procfs/procfs.h b/sys/miscfs/procfs/procfs.h
deleted file mode 100644
index 1c8e5e1..0000000
--- a/sys/miscfs/procfs/procfs.h
+++ /dev/null
@@ -1,162 +0,0 @@
-/*
- * Copyright (c) 1993 Jan-Simon Pendry
- * Copyright (c) 1993
- *	The Regents of the University of California.  All rights reserved.
- *
- * This code is derived from software contributed to Berkeley by
- * Jan-Simon Pendry.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)procfs.h	8.9 (Berkeley) 5/14/95
- *
- * From:
- * $FreeBSD$
- */
-
-/*
- * The different types of node in a procfs filesystem
- */
-typedef enum {
-	Proot,		/* the filesystem root */
-	Pcurproc,	/* symbolic link for curproc */
-	Pproc,		/* a process-specific sub-directory */
-	Pfile,		/* the executable file */
-	Pmem,		/* the process's memory image */
-	Pregs,		/* the process's register set */
-	Pfpregs,	/* the process's FP register set */
-	Pdbregs,	/* the process's debug register set */
-	Pctl,		/* process control */
-	Pstatus,	/* process status */
-	Pnote,		/* process notifier */
-	Pnotepg,	/* process group notifier */
-	Pmap,		/* memory map */
-	Ptype,		/* executable type */
-	Pcmdline,	/* command line */
-	Prlimit		/* resource limits */
-} pfstype;
-
-/*
- * control data for the proc file system.
- */
-struct pfsnode {
-	struct pfsnode	*pfs_next;	/* next on list */
-	struct vnode	*pfs_vnode;	/* vnode associated with this pfsnode */
-	pfstype		pfs_type;	/* type of procfs node */
-	pid_t		pfs_pid;	/* associated process */
-	u_short		pfs_mode;	/* mode bits for stat() */
-	u_long		pfs_flags;	/* open flags */
-	u_long		pfs_fileno;	/* unique file id */
-	pid_t		pfs_lockowner;	/* pfs lock owner */
-};
-
-#define PROCFS_NOTELEN	64	/* max length of a note (/proc/$pid/note) */
-#define PROCFS_CTLLEN 	8	/* max length of a ctl msg (/proc/$pid/ctl */
-#define PROCFS_NAMELEN 	8	/* max length of a filename component */
-
-/*
- * Kernel stuff follows
- */
-#ifdef _KERNEL
-#define CNEQ(cnp, s, len) \
-	 ((cnp)->cn_namelen == (len) && \
-	  (bcmp((s), (cnp)->cn_nameptr, (len)) == 0))
-
-#define KMEM_GROUP 2
-
-#define PROCFS_FILENO(pid, type) \
-	(((type) < Pproc) ? \
-			((type) + 2) : \
-			((((pid)+1) << 4) + ((int) (type))))
-
-/*
- * Convert between pfsnode vnode
- */
-#define VTOPFS(vp)	((struct pfsnode *)(vp)->v_data)
-#define PFSTOV(pfs)	((pfs)->pfs_vnode)
-
-typedef struct vfs_namemap vfs_namemap_t;
-struct vfs_namemap {
-	const char *nm_name;
-	int nm_val;
-};
-
-int vfs_getuserstr __P((struct uio *, char *, int *));
-vfs_namemap_t *vfs_findname __P((vfs_namemap_t *, char *, int));
-
-/* <machine/reg.h> */
-struct reg;
-struct fpreg;
-struct dbreg;
-
-#define PFIND(pid) (pfind(pid))
-
-void procfs_exit __P((struct proc *));
-int procfs_freevp __P((struct vnode *));
-int procfs_allocvp __P((struct mount *, struct vnode **, long, pfstype));
-struct vnode *procfs_findtextvp __P((struct proc *));
-int procfs_sstep __P((struct proc *));
-void procfs_fix_sstep __P((struct proc *));
-int procfs_read_regs __P((struct proc *, struct reg *));
-int procfs_write_regs __P((struct proc *, struct reg *));
-int procfs_read_fpregs __P((struct proc *, struct fpreg *));
-int procfs_write_fpregs __P((struct proc *, struct fpreg *));
-int procfs_read_dbregs __P((struct proc *, struct dbreg *));
-int procfs_write_dbregs __P((struct proc *, struct dbreg *));
-int procfs_donote __P((struct proc *, struct proc *, struct pfsnode *pfsp, struct uio *uio));
-int procfs_doregs __P((struct proc *, struct proc *, struct pfsnode *pfsp, struct uio *uio));
-int procfs_dofpregs __P((struct proc *, struct proc *, struct pfsnode *pfsp, struct uio *uio));
-int procfs_dodbregs __P((struct proc *, struct proc *, struct pfsnode *pfsp, struct uio *uio));
-int procfs_domem __P((struct proc *, struct proc *, struct pfsnode *pfsp, struct uio *uio));
-int procfs_doctl __P((struct proc *, struct proc *, struct pfsnode *pfsp, struct uio *uio));
-int procfs_dostatus __P((struct proc *, struct proc *, struct pfsnode *pfsp, struct uio *uio));
-int procfs_domap __P((struct proc *, struct proc *, struct pfsnode *pfsp, struct uio *uio));
-int procfs_dotype __P((struct proc *, struct proc *, struct pfsnode *pfsp, struct uio *uio));
-int procfs_docmdline __P((struct proc *, struct proc *, struct pfsnode *pfsp, struct uio *uio));
-int procfs_dorlimit __P((struct proc *, struct proc *, struct pfsnode *pfsp, struct uio *uio));
-
-/* Return 1 if process has special kernel digging privileges */
-int procfs_kmemaccess __P((struct proc *));
-
-/* functions to check whether or not files should be displayed */
-int procfs_validfile __P((struct proc *));
-int procfs_validfpregs __P((struct proc *));
-int procfs_validregs __P((struct proc *));
-int procfs_validdbregs __P((struct proc *));
-int procfs_validmap __P((struct proc *));
-int procfs_validtype __P((struct proc *));
-
-#define PROCFS_LOCKED	0x01
-#define PROCFS_WANT	0x02
-
-extern vop_t **procfs_vnodeop_p;
-
-int	procfs_root __P((struct mount *, struct vnode **));
-int	procfs_rw __P((struct vop_read_args *));
-#endif /* _KERNEL */
diff --git a/sys/miscfs/procfs/procfs_ctl.c b/sys/miscfs/procfs/procfs_ctl.c
deleted file mode 100644
index 5818758..0000000
--- a/sys/miscfs/procfs/procfs_ctl.c
+++ /dev/null
@@ -1,364 +0,0 @@
-/*
- * Copyright (c) 1993 Jan-Simon Pendry
- * Copyright (c) 1993
- *	The Regents of the University of California.  All rights reserved.
- *
- * This code is derived from software contributed to Berkeley by
- * Jan-Simon Pendry.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)procfs_ctl.c	8.4 (Berkeley) 6/15/94
- * $FreeBSD$
- */
-
-#include <sys/param.h>
-#include <sys/systm.h>
-#include <sys/lock.h>
-#include <sys/mutex.h>
-#include <sys/proc.h>
-#include <sys/ptrace.h>
-#include <sys/signalvar.h>
-#include <sys/sx.h>
-#include <sys/vnode.h>
-
-#include <miscfs/procfs/procfs.h>
-
-#include <vm/vm.h>
-
-#ifndef FIX_SSTEP
-#define FIX_SSTEP(p)
-#endif
-
-/*
- * True iff process (p) is in trace wait state
- * relative to process (curp)
- */
-#define TRACE_WAIT_P(curp, p) \
-	((p)->p_stat == SSTOP && \
-	 (p)->p_pptr == (curp) && \
-	 ((p)->p_flag & P_TRACED))
-
-#define PROCFS_CTL_ATTACH	1
-#define PROCFS_CTL_DETACH	2
-#define PROCFS_CTL_STEP		3
-#define PROCFS_CTL_RUN		4
-#define PROCFS_CTL_WAIT		5
-
-static vfs_namemap_t ctlnames[] = {
-	/* special /proc commands */
-	{ "attach",	PROCFS_CTL_ATTACH },
-	{ "detach",	PROCFS_CTL_DETACH },
-	{ "step",	PROCFS_CTL_STEP },
-	{ "run",	PROCFS_CTL_RUN },
-	{ "wait",	PROCFS_CTL_WAIT },
-	{ 0 },
-};
-
-static vfs_namemap_t signames[] = {
-	/* regular signal names */
-	{ "hup",	SIGHUP },	{ "int",	SIGINT },
-	{ "quit",	SIGQUIT },	{ "ill",	SIGILL },
-	{ "trap",	SIGTRAP },	{ "abrt",	SIGABRT },
-	{ "iot",	SIGIOT },	{ "emt",	SIGEMT },
-	{ "fpe",	SIGFPE },	{ "kill",	SIGKILL },
-	{ "bus",	SIGBUS },	{ "segv",	SIGSEGV },
-	{ "sys",	SIGSYS },	{ "pipe",	SIGPIPE },
-	{ "alrm",	SIGALRM },	{ "term",	SIGTERM },
-	{ "urg",	SIGURG },	{ "stop",	SIGSTOP },
-	{ "tstp",	SIGTSTP },	{ "cont",	SIGCONT },
-	{ "chld",	SIGCHLD },	{ "ttin",	SIGTTIN },
-	{ "ttou",	SIGTTOU },	{ "io",		SIGIO },
-	{ "xcpu",	SIGXCPU },	{ "xfsz",	SIGXFSZ },
-	{ "vtalrm",	SIGVTALRM },	{ "prof",	SIGPROF },
-	{ "winch",	SIGWINCH },	{ "info",	SIGINFO },
-	{ "usr1",	SIGUSR1 },	{ "usr2",	SIGUSR2 },
-	{ 0 },
-};
-
-static int	procfs_control __P((struct proc *curp, struct proc *p, int op));
-
-static int
-procfs_control(curp, p, op)
-	struct proc *curp;
-	struct proc *p;
-	int op;
-{
-	int error = 0;
-
-	/*
-	 * Authorization check: rely on normal debugging protection, except
-	 * allow processes to disengage debugging on a process onto which
-	 * they have previously attached, but no longer have permission to
-	 * debug.
-	 */
-	if (op != PROCFS_CTL_DETACH &&
-	    ((error = p_can(curp, p, P_CAN_DEBUG, NULL))))
-		return (error);
-
-	/*
-	 * Attach - attaches the target process for debugging
-	 * by the calling process.
-	 */
-	if (op == PROCFS_CTL_ATTACH) {
-		sx_xlock(&proctree_lock);
-		PROC_LOCK(p);
-		if (p->p_flag & P_TRACED) {
-			error = EBUSY;
-			goto out;
-		}
-
-		/* Can't trace yourself! */
-		if (p->p_pid == curp->p_pid) {
-			error = EINVAL;
-			goto out;
-		}
-
-		/*
-		 * Go ahead and set the trace flag.
-		 * Save the old parent (it's reset in
-		 *   _DETACH, and also in kern_exit.c:wait4()
-		 * Reparent the process so that the tracing
-		 *   proc gets to see all the action.
-		 * Stop the target.
-		 */
-		p->p_flag |= P_TRACED;
-		faultin(p);
-		p->p_xstat = 0;		/* XXX ? */
-		if (p->p_pptr != curp) {
-			p->p_oppid = p->p_pptr->p_pid;
-			proc_reparent(p, curp);
-		}
-		psignal(p, SIGSTOP);
-out:
-		PROC_UNLOCK(p);
-		sx_xunlock(&proctree_lock);
-		return (error);
-	}
-
-	/*
-	 * Target process must be stopped, owned by (curp) and
-	 * be set up for tracing (P_TRACED flag set).
-	 * Allow DETACH to take place at any time for sanity.
-	 * Allow WAIT any time, of course.
-	 */
-	switch (op) {
-	case PROCFS_CTL_DETACH:
-	case PROCFS_CTL_WAIT:
-		break;
-
-	default:
-		PROC_LOCK(p);
-		mtx_lock_spin(&sched_lock);
-		if (!TRACE_WAIT_P(curp, p)) {
-			mtx_unlock_spin(&sched_lock);
-			PROC_UNLOCK(p);
-			return (EBUSY);
-		}
-		mtx_unlock_spin(&sched_lock);
-		PROC_UNLOCK(p);
-	}
-
-
-#ifdef FIX_SSTEP
-	/*
-	 * do single-step fixup if needed
-	 */
-	FIX_SSTEP(p);
-#endif
-
-	/*
-	 * Don't deliver any signal by default.
-	 * To continue with a signal, just send
-	 * the signal name to the ctl file
-	 */
-	PROC_LOCK(p);
-	p->p_xstat = 0;
-
-	switch (op) {
-	/*
-	 * Detach.  Cleans up the target process, reparent it if possible
-	 * and set it running once more.
-	 */
-	case PROCFS_CTL_DETACH:
-		/* if not being traced, then this is a painless no-op */
-		if ((p->p_flag & P_TRACED) == 0) {
-			PROC_UNLOCK(p);
-			return (0);
-		}
-
-		/* not being traced any more */
-		p->p_flag &= ~P_TRACED;
-
-		/* remove pending SIGTRAP, else the process will die */
-		SIGDELSET(p->p_siglist, SIGTRAP);
-		PROC_UNLOCK(p);
-
-		/* give process back to original parent */
-		sx_xlock(&proctree_lock);
-		if (p->p_oppid != p->p_pptr->p_pid) {
-			struct proc *pp;
-
-			pp = pfind(p->p_oppid);
-			PROC_LOCK(p);
-			if (pp)
-				proc_reparent(p, pp);
-		} else
-			PROC_LOCK(p);
-		p->p_oppid = 0;
-		p->p_flag &= ~P_WAITED;	/* XXX ? */
-		PROC_UNLOCK(p);
-		sx_xunlock(&proctree_lock);
-
-		wakeup((caddr_t) curp);	/* XXX for CTL_WAIT below ? */
-
-		break;
-
-	/*
-	 * Step.  Let the target process execute a single instruction.
-	 */
-	case PROCFS_CTL_STEP:
-		_PHOLD(p);
-		PROC_UNLOCK(p);
-		error = procfs_sstep(p);
-		PRELE(p);
-		if (error)
-			return (error);
-		break;
-
-	/*
-	 * Run.  Let the target process continue running until a breakpoint
-	 * or some other trap.
-	 */
-	case PROCFS_CTL_RUN:
-		PROC_UNLOCK(p);
-		break;
-
-	/*
-	 * Wait for the target process to stop.
-	 * If the target is not being traced then just wait
-	 * to enter
-	 */
-	case PROCFS_CTL_WAIT:
-		if (p->p_flag & P_TRACED) {
-			mtx_lock_spin(&sched_lock);
-			while (error == 0 &&
-					(p->p_stat != SSTOP) &&
-					(p->p_flag & P_TRACED) &&
-					(p->p_pptr == curp)) {
-				mtx_unlock_spin(&sched_lock);
-				error = msleep((caddr_t) p, &p->p_mtx,
-						PWAIT|PCATCH, "procfsx", 0);
-				mtx_lock_spin(&sched_lock);
-			}
-			if (error == 0 && !TRACE_WAIT_P(curp, p))
-				error = EBUSY;
-			mtx_unlock_spin(&sched_lock);
-			PROC_UNLOCK(p);
-		} else {
-			PROC_UNLOCK(p);
-			mtx_lock_spin(&sched_lock);
-			while (error == 0 && p->p_stat != SSTOP) {
-				mtx_unlock_spin(&sched_lock);
-				error = tsleep((caddr_t) p,
-						PWAIT|PCATCH, "procfs", 0);
-				mtx_lock_spin(&sched_lock);
-			}
-			mtx_unlock_spin(&sched_lock);
-		}
-		return (error);
-
-	default:
-		panic("procfs_control");
-	}
-
-	mtx_lock_spin(&sched_lock);
-	if (p->p_stat == SSTOP)
-		setrunnable(p);
-	mtx_unlock_spin(&sched_lock);
-	return (0);
-}
-
-int
-procfs_doctl(curp, p, pfs, uio)
-	struct proc *curp;
-	struct pfsnode *pfs;
-	struct uio *uio;
-	struct proc *p;
-{
-	int xlen;
-	int error;
-	char msg[PROCFS_CTLLEN+1];
-	vfs_namemap_t *nm;
-
-	if (uio->uio_rw != UIO_WRITE)
-		return (EOPNOTSUPP);
-
-	xlen = PROCFS_CTLLEN;
-	error = vfs_getuserstr(uio, msg, &xlen);
-	if (error)
-		return (error);
-
-	/*
-	 * Map signal names into signal generation
-	 * or debug control.  Unknown commands and/or signals
-	 * return EOPNOTSUPP.
-	 *
-	 * Sending a signal while the process is being debugged
-	 * also has the side effect of letting the target continue
-	 * to run.  There is no way to single-step a signal delivery.
-	 */
-	error = EOPNOTSUPP;
-
-	nm = vfs_findname(ctlnames, msg, xlen);
-	if (nm) {
-		error = procfs_control(curp, p, nm->nm_val);
-	} else {
-		nm = vfs_findname(signames, msg, xlen);
-		if (nm) {
-			PROC_LOCK(p);
-			mtx_lock_spin(&sched_lock);
-			if (TRACE_WAIT_P(curp, p)) {
-				p->p_xstat = nm->nm_val;
-#ifdef FIX_SSTEP
-				FIX_SSTEP(p);
-#endif
-				setrunnable(p);
-				mtx_unlock_spin(&sched_lock);
-			} else {
-				mtx_unlock_spin(&sched_lock);
-				psignal(p, nm->nm_val);
-			}
-			PROC_UNLOCK(p);
-			error = 0;
-		}
-	}
-
-	return (error);
-}
diff --git a/sys/miscfs/procfs/procfs_dbregs.c b/sys/miscfs/procfs/procfs_dbregs.c
deleted file mode 100644
index d80e28c..0000000
--- a/sys/miscfs/procfs/procfs_dbregs.c
+++ /dev/null
@@ -1,107 +0,0 @@
-/*-
- * Copyright (c) 1999 Brian Scott Dean, brdean@unx.sas.com.
- *                    All rights reserved.
- *
- * This code is derived from software contributed to Berkeley by
- * Jan-Simon Pendry under the following copyrights and conditions:
- *
- * Copyright (c) 1993 Jan-Simon Pendry
- * Copyright (c) 1993
- *	The Regents of the University of California.  All rights reserved.
- *
- * This code is derived from software contributed to Berkeley by
- * Jan-Simon Pendry.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * $FreeBSD$
- */
-
-#include <sys/param.h>
-#include <sys/systm.h>
-#include <sys/lock.h>
-#include <sys/mutex.h>
-#include <sys/proc.h>
-#include <sys/vnode.h>
-
-#include <machine/reg.h>
-
-#include <miscfs/procfs/procfs.h>
-
-#include <vm/vm.h>
-
-int
-procfs_dodbregs(curp, p, pfs, uio)
-	struct proc *curp;
-	struct proc *p;
-	struct pfsnode *pfs;
-	struct uio *uio;
-{
-	int error;
-	struct dbreg r;
-	char *kv;
-	int kl;
-
-	if (p_can(curp, p, P_CAN_DEBUG, NULL))
-		return (EPERM);
-	kl = sizeof(r);
-	kv = (char *) &r;
-
-	kv += uio->uio_offset;
-	kl -= uio->uio_offset;
-	if (kl > uio->uio_resid)
-		kl = uio->uio_resid;
-
-	PHOLD(p);
-
-	if (kl < 0)
-		error = EINVAL;
-	else
-		error = procfs_read_dbregs(p, &r);
-	if (error == 0)
-		error = uiomove(kv, kl, uio);
-	if (error == 0 && uio->uio_rw == UIO_WRITE) {
-		if (p->p_stat != SSTOP)
-			error = EBUSY;
-		else
-			error = procfs_write_dbregs(p, &r);
-	}
-	PRELE(p);
-
-	uio->uio_offset = 0;
-	return (error);
-}
-
-int
-procfs_validdbregs(p)
-	struct proc *p;
-{
-
-	return ((p->p_flag & P_SYSTEM) == 0);
-}
diff --git a/sys/miscfs/procfs/procfs_fpregs.c b/sys/miscfs/procfs/procfs_fpregs.c
deleted file mode 100644
index 7e2ff52..0000000
--- a/sys/miscfs/procfs/procfs_fpregs.c
+++ /dev/null
@@ -1,104 +0,0 @@
-/*
- * Copyright (c) 1993 Jan-Simon Pendry
- * Copyright (c) 1993
- *	The Regents of the University of California.  All rights reserved.
- *
- * This code is derived from software contributed to Berkeley by
- * Jan-Simon Pendry.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)procfs_fpregs.c	8.2 (Berkeley) 6/15/94
- *
- * From:
- * $FreeBSD$
- */
-
-#include <sys/param.h>
-#include <sys/systm.h>
-#include <sys/lock.h>
-#include <sys/mutex.h>
-#include <sys/proc.h>
-#include <sys/vnode.h>
-
-#include <machine/reg.h>
-
-#include <miscfs/procfs/procfs.h>
-
-#include <vm/vm.h>
-
-int
-procfs_dofpregs(curp, p, pfs, uio)
-	struct proc *curp;
-	struct proc *p;
-	struct pfsnode *pfs;
-	struct uio *uio;
-{
-	int error;
-	struct fpreg r;
-	char *kv;
-	int kl;
-
-	if (p_can(curp, p, P_CAN_DEBUG, NULL))
-		return EPERM;
-	kl = sizeof(r);
-	kv = (char *) &r;
-
-	kv += uio->uio_offset;
-	kl -= uio->uio_offset;
-	if (kl > uio->uio_resid)
-		kl = uio->uio_resid;
-
-	PHOLD(p);
-
-	if (kl < 0)
-		error = EINVAL;
-	else
-		error = procfs_read_fpregs(p, &r);
-	if (error == 0)
-		error = uiomove(kv, kl, uio);
-	if (error == 0 && uio->uio_rw == UIO_WRITE) {
-		if (p->p_stat != SSTOP)
-			error = EBUSY;
-		else
-			error = procfs_write_fpregs(p, &r);
-	}
-	PRELE(p);
-
-	uio->uio_offset = 0;
-	return (error);
-}
-
-int
-procfs_validfpregs(p)
-	struct proc *p;
-{
-
-	return ((p->p_flag & P_SYSTEM) == 0);
-}
diff --git a/sys/miscfs/procfs/procfs_map.c b/sys/miscfs/procfs/procfs_map.c
deleted file mode 100644
index 5c21993..0000000
--- a/sys/miscfs/procfs/procfs_map.c
+++ /dev/null
@@ -1,186 +0,0 @@
-/*
- * Copyright (c) 1993 Jan-Simon Pendry
- * Copyright (c) 1993
- *	The Regents of the University of California.  All rights reserved.
- *
- * This code is derived from software contributed to Berkeley by
- * Jan-Simon Pendry.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)procfs_status.c	8.3 (Berkeley) 2/17/94
- *
- * $FreeBSD$
- */
-
-#include <sys/param.h>
-#include <sys/systm.h>
-#include <sys/lock.h>
-#include <sys/mutex.h>
-#include <sys/proc.h>
-#include <sys/vnode.h>
-
-#include <miscfs/procfs/procfs.h>
-
-#include <vm/vm.h>
-#include <vm/pmap.h>
-#include <vm/vm_map.h>
-#include <vm/vm_page.h>
-#include <vm/vm_object.h>
-
-
-#define MEBUFFERSIZE 256
-
-/*
- * The map entries can *almost* be read with programs like cat.  However,
- * large maps need special programs to read.  It is not easy to implement
- * a program that can sense the required size of the buffer, and then
- * subsequently do a read with the appropriate size.  This operation cannot
- * be atomic.  The best that we can do is to allow the program to do a read
- * with an arbitrarily large buffer, and return as much as we can.  We can
- * return an error code if the buffer is too small (EFBIG), then the program
- * can try a bigger buffer.
- */
-int
-procfs_domap(curp, p, pfs, uio)
-	struct proc *curp;
-	struct proc *p;
-	struct pfsnode *pfs;
-	struct uio *uio;
-{
-	int len;
-	int error;
-	vm_map_t map = &p->p_vmspace->vm_map;
-	pmap_t pmap = vmspace_pmap(p->p_vmspace);
-	vm_map_entry_t entry;
-	char mebuffer[MEBUFFERSIZE];
-
-	if (uio->uio_rw != UIO_READ)
-		return (EOPNOTSUPP);
-
-	if (uio->uio_offset != 0)
-		return (0);
-	
-	error = 0;
-	if (map != &curproc->p_vmspace->vm_map)
-		vm_map_lock_read(map);
-	for (entry = map->header.next;
-		((uio->uio_resid > 0) && (entry != &map->header));
-		entry = entry->next) {
-		vm_object_t obj, tobj, lobj;
-		int ref_count, shadow_count, flags;
-		vm_offset_t addr;
-		int resident, privateresident;
-		char *type;
-
-		if (entry->eflags & MAP_ENTRY_IS_SUB_MAP)
-			continue;
-
-		obj = entry->object.vm_object;
-		if (obj && (obj->shadow_count == 1))
-			privateresident = obj->resident_page_count;
-		else
-			privateresident = 0;
-
-		resident = 0;
-		addr = entry->start;
-		while (addr < entry->end) {
-			if (pmap_extract( pmap, addr))
-				resident++;
-			addr += PAGE_SIZE;
-		}
-
-		for( lobj = tobj = obj; tobj; tobj = tobj->backing_object)
-			lobj = tobj;
-
-		if (lobj) {
-			switch(lobj->type) {
-
-default:
-case OBJT_DEFAULT:
-				type = "default";
-				break;
-case OBJT_VNODE:
-				type = "vnode";
-				break;
-case OBJT_SWAP:
-				type = "swap";
-				break;
-case OBJT_DEVICE:
-				type = "device";
-				break;
-			}
-			
-			flags = obj->flags;
-			ref_count = obj->ref_count;
-			shadow_count = obj->shadow_count;
-		} else {
-			type = "none";
-			flags = 0;
-			ref_count = 0;
-			shadow_count = 0;
-		}
-			
-
-		/*
-		 * format:
-		 *  start, end, resident, private resident, cow, access, type.
-		 */
-		snprintf(mebuffer, sizeof(mebuffer),
-		    "0x%lx 0x%lx %d %d %p %s%s%s %d %d 0x%x %s %s %s\n",
-			(u_long)entry->start, (u_long)entry->end,
-			resident, privateresident, obj,
-			(entry->protection & VM_PROT_READ)?"r":"-",
-			(entry->protection & VM_PROT_WRITE)?"w":"-",
-			(entry->protection & VM_PROT_EXECUTE)?"x":"-",
-			ref_count, shadow_count, flags,
-			(entry->eflags & MAP_ENTRY_COW)?"COW":"NCOW",
-			(entry->eflags & MAP_ENTRY_NEEDS_COPY)?"NC":"NNC",
-			type);
-
-		len = strlen(mebuffer);
-		if (len > uio->uio_resid) {
-			error = EFBIG;
-			break;
-		}
-		error = uiomove(mebuffer, len, uio);
-		if (error)
-			break;
-	}
-	if (map != &curproc->p_vmspace->vm_map)
-		vm_map_unlock_read(map);
-	return error;
-}
-
-int
-procfs_validmap(p)
-	struct proc *p;
-{
-	return ((p->p_flag & P_SYSTEM) == 0);
-}
diff --git a/sys/miscfs/procfs/procfs_mem.c b/sys/miscfs/procfs/procfs_mem.c
deleted file mode 100644
index 1e28870..0000000
--- a/sys/miscfs/procfs/procfs_mem.c
+++ /dev/null
@@ -1,328 +0,0 @@
-/*
- * Copyright (c) 1993 Jan-Simon Pendry
- * Copyright (c) 1993 Sean Eric Fagan
- * Copyright (c) 1993
- *	The Regents of the University of California.  All rights reserved.
- *
- * This code is derived from software contributed to Berkeley by
- * Jan-Simon Pendry and Sean Eric Fagan.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)procfs_mem.c	8.5 (Berkeley) 6/15/94
- *
- * $FreeBSD$
- */
-
-/*
- * This is a lightly hacked and merged version
- * of sef's pread/pwrite functions
- */
-
-#include <sys/param.h>
-#include <sys/systm.h>
-#include <sys/lock.h>
-#include <sys/mutex.h>
-#include <sys/proc.h>
-#include <sys/ptrace.h>
-#include <sys/user.h>
-#include <sys/vnode.h>
-
-#include <miscfs/procfs/procfs.h>
-
-#include <vm/vm.h>
-#include <vm/vm_param.h>
-#include <vm/pmap.h>
-#include <vm/vm_extern.h>
-#include <vm/vm_map.h>
-#include <vm/vm_kern.h>
-#include <vm/vm_object.h>
-#include <vm/vm_page.h>
-
-static int	procfs_rwmem __P((struct proc *curp,
-				  struct proc *p, struct uio *uio));
-
-static int
-procfs_rwmem(curp, p, uio)
-	struct proc *curp;
-	struct proc *p;
-	struct uio *uio;
-{
-	int error;
-	int writing;
-	struct vmspace *vm;
-	vm_map_t map;
-	vm_object_t object = NULL;
-	vm_offset_t pageno = 0;		/* page number */
-	vm_prot_t reqprot;
-	vm_offset_t kva;
-
-	/*
-	 * if the vmspace is in the midst of being deallocated or the
-	 * process is exiting, don't try to grab anything.  The page table
-	 * usage in that process can be messed up.
-	 */
-	vm = p->p_vmspace;
-	if ((p->p_flag & P_WEXIT))
-		return EFAULT;
-
-	mtx_lock(&vm_mtx);
-	if (vm->vm_refcnt < 1) {
-		mtx_unlock(&vm_mtx);
-		return EFAULT;
-	}
-	++vm->vm_refcnt;
-	/*
-	 * The map we want...
-	 */
-	map = &vm->vm_map;
-
-	writing = uio->uio_rw == UIO_WRITE;
-	reqprot = writing ? (VM_PROT_WRITE | VM_PROT_OVERRIDE_WRITE) : VM_PROT_READ;
-
-	kva = kmem_alloc_pageable(kernel_map, PAGE_SIZE);
-
-	/*
-	 * Only map in one page at a time.  We don't have to, but it
-	 * makes things easier.  This way is trivial - right?
-	 */
-	do {
-		vm_map_t tmap;
-		vm_offset_t uva;
-		int page_offset;		/* offset into page */
-		vm_map_entry_t out_entry;
-		vm_prot_t out_prot;
-		boolean_t wired;
-		vm_pindex_t pindex;
-		u_int len;
-		vm_page_t m;
-
-		object = NULL;
-
-		uva = (vm_offset_t) uio->uio_offset;
-
-		/*
-		 * Get the page number of this segment.
-		 */
-		pageno = trunc_page(uva);
-		page_offset = uva - pageno;
-
-		/*
-		 * How many bytes to copy
-		 */
-		len = min(PAGE_SIZE - page_offset, uio->uio_resid);
-
-		/*
-		 * Fault the page on behalf of the process
-		 */
-		error = vm_fault(map, pageno, reqprot, VM_FAULT_NORMAL);
-		if (error) {
-			error = EFAULT;
-			break;
-		}
-
-		/*
-		 * Now we need to get the page.  out_entry, out_prot, wired,
-		 * and single_use aren't used.  One would think the vm code
-		 * would be a *bit* nicer...  We use tmap because
-		 * vm_map_lookup() can change the map argument.
-		 */
-		tmap = map;
-		error = vm_map_lookup(&tmap, pageno, reqprot,
-			      &out_entry, &object, &pindex, &out_prot,
-			      &wired);
-
-		if (error) {
-			error = EFAULT;
-
-			/*
-			 * Make sure that there is no residue in 'object' from
-			 * an error return on vm_map_lookup.
-			 */
-			object = NULL;
-
-			break;
-		}
-
-		m = vm_page_lookup(object, pindex);
-
-		/* Allow fallback to backing objects if we are reading */
-
-		while (m == NULL && !writing && object->backing_object) {
-
-		  pindex += OFF_TO_IDX(object->backing_object_offset);
-		  object = object->backing_object;
-
-		  m = vm_page_lookup(object, pindex);
-		}
-
-		if (m == NULL) {
-			error = EFAULT;
-
-			/*
-			 * Make sure that there is no residue in 'object' from
-			 * an error return on vm_map_lookup.
-			 */
-			object = NULL;
-
-			vm_map_lookup_done(tmap, out_entry);
-
-			break;
-		}
-
-		/*
-		 * Wire the page into memory
-		 */
-		vm_page_wire(m);
-
-		/*
-		 * We're done with tmap now.
-		 * But reference the object first, so that we won't loose
-		 * it.
-		 */
-		vm_object_reference(object);
-		vm_map_lookup_done(tmap, out_entry);
-
-		pmap_kenter(kva, VM_PAGE_TO_PHYS(m));
-
-		/*
-		 * Now do the i/o move.
-		 */
-		mtx_unlock(&vm_mtx);
-		error = uiomove((caddr_t)(kva + page_offset), len, uio);
-		mtx_lock(&vm_mtx);
-
-		pmap_kremove(kva);
-
-		/*
-		 * release the page and the object
-		 */
-		vm_page_unwire(m, 1);
-		vm_object_deallocate(object);
-
-		object = NULL;
-
-	} while (error == 0 && uio->uio_resid > 0);
-
-	if (object)
-		vm_object_deallocate(object);
-
-	kmem_free(kernel_map, kva, PAGE_SIZE);
-	vmspace_free(vm);
-	mtx_unlock(&vm_mtx);
-	return (error);
-}
-
-/*
- * Copy data in and out of the target process.
- * We do this by mapping the process's page into
- * the kernel and then doing a uiomove direct
- * from the kernel address space.
- */
-int
-procfs_domem(curp, p, pfs, uio)
-	struct proc *curp;
-	struct proc *p;
-	struct pfsnode *pfs;
-	struct uio *uio;
-{
-
-	if (uio->uio_resid == 0)
-		return (0);
-
- 	/*
- 	 * XXX
- 	 * We need to check for KMEM_GROUP because ps is sgid kmem;
- 	 * not allowing it here causes ps to not work properly.  Arguably,
- 	 * this is a bug with what ps does.  We only need to do this
- 	 * for Pmem nodes, and only if it's reading.  This is still not
- 	 * good, as it may still be possible to grab illicit data if
- 	 * a process somehow gets to be KMEM_GROUP.  Note that this also
- 	 * means that KMEM_GROUP can't change without editing procfs.h!
- 	 * All in all, quite yucky.
- 	 */
- 
- 	if (p_can(curp, p, P_CAN_DEBUG, NULL) &&
-	    !(uio->uio_rw == UIO_READ &&
-	      procfs_kmemaccess(curp)))
- 		return EPERM;
-
-	return (procfs_rwmem(curp, p, uio));
-}
-
-/*
- * Given process (p), find the vnode from which
- * its text segment is being executed.
- *
- * It would be nice to grab this information from
- * the VM system, however, there is no sure-fire
- * way of doing that.  Instead, fork(), exec() and
- * wait() all maintain the p_textvp field in the
- * process proc structure which contains a held
- * reference to the exec'ed vnode.
- *
- * XXX - Currently, this is not not used, as the
- * /proc/pid/file object exposes an information leak
- * that shouldn't happen.  Using a mount option would
- * make it configurable on a per-system (or, at least,
- * per-mount) basis; however, that's not really best.
- * The best way to do it, I think, would be as an
- * ioctl; this would restrict it to the uid running
- * program, or root, which seems a reasonable compromise.
- * However, the number of applications for this is
- * minimal, if it can't be seen in the filesytem space,
- * and doint it as an ioctl makes it somewhat less
- * useful due to the, well, inelegance.
- *
- */
-struct vnode *
-procfs_findtextvp(p)
-	struct proc *p;
-{
-
-	return (p->p_textvp);
-}
-
-int procfs_kmemaccess(curp)
-	struct proc *curp;
-{
-	int i;
-	struct ucred *cred;
-
-	cred = curp->p_ucred;
-	if (suser(curp))
-		return 1;
-
-	/* XXX: Why isn't this done with file-perms ??? */
-	for (i = 0; i < cred->cr_ngroups; i++)
-		if (cred->cr_groups[i] == KMEM_GROUP)	
-			return 1;
-	
-	return 0;
-}
diff --git a/sys/miscfs/procfs/procfs_note.c b/sys/miscfs/procfs/procfs_note.c
deleted file mode 100644
index 273010b..0000000
--- a/sys/miscfs/procfs/procfs_note.c
+++ /dev/null
@@ -1,67 +0,0 @@
-/*
- * Copyright (c) 1993 Jan-Simon Pendry
- * Copyright (c) 1993
- *	The Regents of the University of California.  All rights reserved.
- *
- * This code is derived from software contributed to Berkeley by
- * Jan-Simon Pendry.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)procfs_note.c	8.2 (Berkeley) 1/21/94
- *
- * $FreeBSD$
- */
-
-#include <sys/param.h>
-#include <sys/vnode.h>
-#include <miscfs/procfs/procfs.h>
-
-int
-procfs_donote(curp, p, pfs, uio)
-	struct proc *curp;
-	struct proc *p;
-	struct pfsnode *pfs;
-	struct uio *uio;
-{
-	int xlen;
-	int error;
-	char note[PROCFS_NOTELEN+1];
-
-	if (uio->uio_rw != UIO_WRITE)
-		return (EINVAL);
-
-	xlen = PROCFS_NOTELEN;
-	error = vfs_getuserstr(uio, note, &xlen);
-	if (error)
-		return (error);
-
-	/* send to process's notify function */
-	return (EOPNOTSUPP);
-}
diff --git a/sys/miscfs/procfs/procfs_regs.c b/sys/miscfs/procfs/procfs_regs.c
deleted file mode 100644
index ba58517..0000000
--- a/sys/miscfs/procfs/procfs_regs.c
+++ /dev/null
@@ -1,105 +0,0 @@
-/*
- * Copyright (c) 1993 Jan-Simon Pendry
- * Copyright (c) 1993
- *	The Regents of the University of California.  All rights reserved.
- *
- * This code is derived from software contributed to Berkeley by
- * Jan-Simon Pendry.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)procfs_regs.c	8.4 (Berkeley) 6/15/94
- *
- * From:
- * $FreeBSD$
- */
-
-#include <sys/param.h>
-#include <sys/systm.h>
-#include <sys/lock.h>
-#include <sys/mutex.h>
-#include <sys/proc.h>
-#include <sys/vnode.h>
-
-#include <machine/reg.h>
-
-#include <vm/vm.h>
-#include <vm/vm_extern.h>
-
-#include <miscfs/procfs/procfs.h>
-
-int
-procfs_doregs(curp, p, pfs, uio)
-	struct proc *curp;
-	struct proc *p;
-	struct pfsnode *pfs;
-	struct uio *uio;
-{
-	int error;
-	struct reg r;
-	char *kv;
-	int kl;
-
-	if (p_can(curp, p, P_CAN_DEBUG, NULL))
-		return EPERM;
-	kl = sizeof(r);
-	kv = (char *) &r;
-
-	kv += uio->uio_offset;
-	kl -= uio->uio_offset;
-	if (kl > uio->uio_resid)
-		kl = uio->uio_resid;
-
-	PHOLD(p);
-
-	if (kl < 0)
-		error = EINVAL;
-	else
-		error = procfs_read_regs(p, &r);
-	if (error == 0)
-		error = uiomove(kv, kl, uio);
-	if (error == 0 && uio->uio_rw == UIO_WRITE) {
-		if (p->p_stat != SSTOP)
-			error = EBUSY;
-		else
-			error = procfs_write_regs(p, &r);
-	}
-	PRELE(p);
-
-	uio->uio_offset = 0;
-	return (error);
-}
-
-int
-procfs_validregs(p)
-	struct proc *p;
-{
-
-	return ((p->p_flag & P_SYSTEM) == 0);
-}
diff --git a/sys/miscfs/procfs/procfs_rlimit.c b/sys/miscfs/procfs/procfs_rlimit.c
deleted file mode 100644
index 361f6f6..0000000
--- a/sys/miscfs/procfs/procfs_rlimit.c
+++ /dev/null
@@ -1,128 +0,0 @@
-/*
- * Copyright (c) 1999 Adrian Chadd
- * Copyright (c) 1993
- *	The Regents of the University of California.  All rights reserved.
- *
- * This code is derived from software contributed to Berkeley by
- * Jan-Simon Pendry.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)procfs_status.c	8.4 (Berkeley) 6/15/94
- *
- * $FreeBSD$
- */
-
-/*
- * To get resource.h to include our rlimit_ident[] array of rlimit identifiers
- */
-
-#define _RLIMIT_IDENT
-
-#include <sys/param.h>
-#include <sys/systm.h>
-#include <sys/proc.h>
-#include <sys/vnode.h>
-#include <sys/resourcevar.h>
-#include <sys/resource.h>
-#include <sys/types.h>
-#include <miscfs/procfs/procfs.h>
-
-
-int
-procfs_dorlimit(curp, p, pfs, uio)
-	struct proc *curp;
-	struct proc *p;
-	struct pfsnode *pfs;
-	struct uio *uio;
-{
-	char *ps;
-	int i;
-	int xlen;
-	int error;
-	char psbuf[512];		/* XXX - conservative */
-
-	if (uio->uio_rw != UIO_READ)
-		return (EOPNOTSUPP);
-
-
-	ps = psbuf;
-
-	for (i = 0; i < RLIM_NLIMITS; i++) {
-
-		/*
-		 * Add the rlimit ident
-		 */
-
-		ps += sprintf(ps, "%s ", rlimit_ident[i]);
-
-		/* 
-		 * Replace RLIM_INFINITY with -1 in the string
-		 */
-
-		/*
-		 * current limit
-		 */
-
-		if (p->p_rlimit[i].rlim_cur == RLIM_INFINITY) {
-			ps += sprintf(ps, "-1 ");
-		} else {
-			ps += sprintf(ps, "%llu ",
-				(unsigned long long)p->p_rlimit[i].rlim_cur);
-		}
-
-		/*
-		 * maximum limit
-		 */
-
-		if (p->p_rlimit[i].rlim_max == RLIM_INFINITY) {
-			ps += sprintf(ps, "-1\n");
-		} else {
-			ps += sprintf(ps, "%llu\n",
-				(unsigned long long)p->p_rlimit[i].rlim_max);
-		}
-	}
-
-	/*
-	 * This logic is rather tasty - but its from procfs_status.c, so
-	 * I guess I'll use it here.
-	 */
-
-	xlen = ps - psbuf;
-	xlen -= uio->uio_offset;
-	ps = psbuf + uio->uio_offset;
-	xlen = imin(xlen, uio->uio_resid);
-	if (xlen <= 0)
-		error = 0;
-	else
-		error = uiomove(ps, xlen, uio);
-
-	return (error);
-}
-
diff --git a/sys/miscfs/procfs/procfs_status.c b/sys/miscfs/procfs/procfs_status.c
deleted file mode 100644
index b29b4a9..0000000
--- a/sys/miscfs/procfs/procfs_status.c
+++ /dev/null
@@ -1,265 +0,0 @@
-/*
- * Copyright (c) 1993 Jan-Simon Pendry
- * Copyright (c) 1993
- *	The Regents of the University of California.  All rights reserved.
- *
- * This code is derived from software contributed to Berkeley by
- * Jan-Simon Pendry.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)procfs_status.c	8.4 (Berkeley) 6/15/94
- *
- * From:
- * $FreeBSD$
- */
-
-#include <sys/param.h>
-#include <sys/systm.h>
-#include <sys/exec.h>
-#include <sys/jail.h>
-#include <sys/lock.h>
-#include <sys/malloc.h>
-#include <sys/mutex.h>
-#include <sys/proc.h>
-#include <sys/resourcevar.h>
-#include <sys/tty.h>
-#include <sys/vnode.h>
-
-#include <vm/vm.h>
-#include <vm/pmap.h>
-#include <vm/vm_param.h>
-
-#include <miscfs/procfs/procfs.h>
-
-#define DOCHECK() do { if (ps >= psbuf+sizeof(psbuf)) goto bailout; } while (0)
-int
-procfs_dostatus(curp, p, pfs, uio)
-	struct proc *curp;
-	struct proc *p;
-	struct pfsnode *pfs;
-	struct uio *uio;
-{
-	struct session *sess;
-	struct tty *tp;
-	struct ucred *cr;
-	char *ps;
-	char *sep;
-	int pid, ppid, pgid, sid;
-	int i;
-	int xlen;
-	int error;
-	char psbuf[256];	/* XXX - conservative */
-
-	if (uio->uio_rw != UIO_READ)
-		return (EOPNOTSUPP);
-
-	pid = p->p_pid;
-	PROC_LOCK(p);
-	ppid = p->p_pptr ? p->p_pptr->p_pid : 0;
-	PROC_UNLOCK(p);
-	pgid = p->p_pgrp->pg_id;
-	sess = p->p_pgrp->pg_session;
-	sid = sess->s_leader ? sess->s_leader->p_pid : 0;
-
-/* comm pid ppid pgid sid maj,min ctty,sldr start ut st wmsg 
-                                euid ruid rgid,egid,groups[1 .. NGROUPS]
-*/
-	KASSERT(sizeof(psbuf) > MAXCOMLEN,
-			("Too short buffer for new MAXCOMLEN"));
-
-	ps = psbuf;
-	bcopy(p->p_comm, ps, MAXCOMLEN);
-	ps[MAXCOMLEN] = '\0';
-	ps += strlen(ps);
-	DOCHECK();
-	ps += snprintf(ps, psbuf + sizeof(psbuf) - ps,
-	    " %d %d %d %d ", pid, ppid, pgid, sid);
-	DOCHECK();
-	if ((p->p_flag&P_CONTROLT) && (tp = sess->s_ttyp))
-		ps += snprintf(ps, psbuf + sizeof(psbuf) - ps,
-		    "%d,%d ", major(tp->t_dev), minor(tp->t_dev));
-	else
-		ps += snprintf(ps, psbuf + sizeof(psbuf) - ps,
-		    "%d,%d ", -1, -1);
-	DOCHECK();
-
-	sep = "";
-	if (sess->s_ttyvp) {
-		ps += snprintf(ps, psbuf + sizeof(psbuf) - ps, "%sctty", sep);
-		sep = ",";
-		DOCHECK();
-	}
-	if (SESS_LEADER(p)) {
-		ps += snprintf(ps, psbuf + sizeof(psbuf) - ps, "%ssldr", sep);
-		sep = ",";
-		DOCHECK();
-	}
-	if (*sep != ',') {
-		ps += snprintf(ps, psbuf + sizeof(psbuf) - ps, "noflags");
-		DOCHECK();
-	}
-
-	mtx_lock_spin(&sched_lock);
-	if (p->p_sflag & PS_INMEM) {
-		struct timeval ut, st;
-
-		calcru(p, &ut, &st, (struct timeval *) NULL);
-		mtx_unlock_spin(&sched_lock);
-		ps += snprintf(ps, psbuf + sizeof(psbuf) - ps,
-		    " %ld,%ld %ld,%ld %ld,%ld",
-		    p->p_stats->p_start.tv_sec,
-		    p->p_stats->p_start.tv_usec,
-		    ut.tv_sec, ut.tv_usec,
-		    st.tv_sec, st.tv_usec);
-	} else {
-		mtx_unlock_spin(&sched_lock);
-		ps += snprintf(ps, psbuf + sizeof(psbuf) - ps,
-		    " -1,-1 -1,-1 -1,-1");
-	}
-	DOCHECK();
-
-	ps += snprintf(ps, psbuf + sizeof(psbuf) - ps, " %s",
-		(p->p_wchan && p->p_wmesg) ? p->p_wmesg : "nochan");
-	DOCHECK();
-
-	cr = p->p_ucred;
-
-	ps += snprintf(ps, psbuf + sizeof(psbuf) - ps, " %lu %lu %lu", 
-		(u_long)cr->cr_uid,
-		(u_long)p->p_cred->p_ruid,
-		(u_long)p->p_cred->p_rgid);
-	DOCHECK();
-
-	/* egid (p->p_cred->p_svgid) is equal to cr_ngroups[0] 
-	   see also getegid(2) in /sys/kern/kern_prot.c */
-
-	for (i = 0; i < cr->cr_ngroups; i++) {
-		ps += snprintf(ps, psbuf + sizeof(psbuf) - ps,
-		    ",%lu", (u_long)cr->cr_groups[i]);
-		DOCHECK();
-	}
-
-	if (jailed(p->p_ucred))
-		ps += snprintf(ps, psbuf + sizeof(psbuf) - ps,
-		    " %s", p->p_ucred->cr_prison->pr_host);
-	else
-		ps += snprintf(ps, psbuf + sizeof(psbuf) - ps, " -");
-	DOCHECK();
-	ps += snprintf(ps, psbuf + sizeof(psbuf) - ps, "\n");
-	DOCHECK();
-
-	xlen = ps - psbuf;
-	xlen -= uio->uio_offset;
-	ps = psbuf + uio->uio_offset;
-	xlen = imin(xlen, uio->uio_resid);
-	if (xlen <= 0)
-		error = 0;
-	else
-		error = uiomove(ps, xlen, uio);
-
-	return (error);
-
-bailout:
-	return (ENOMEM);
-}
-
-int
-procfs_docmdline(curp, p, pfs, uio)
-	struct proc *curp;
-	struct proc *p;
-	struct pfsnode *pfs;
-	struct uio *uio;
-{
-	char *ps;
-	int xlen;
-	int error;
-	char *buf, *bp;
-	int buflen;
-	struct ps_strings pstr;
-	int i;
-	size_t bytes_left, done;
-
-	if (uio->uio_rw != UIO_READ)
-		return (EOPNOTSUPP);
-	
-	/*
-	 * If we are using the ps/cmdline caching, use that.  Otherwise
-	 * revert back to the old way which only implements full cmdline
-	 * for the currept process and just p->p_comm for all other
-	 * processes.
-	 * Note that if the argv is no longer available, we deliberately
-	 * don't fall back on p->p_comm or return an error: the authentic
-	 * Linux behaviour is to return zero-length in this case.
-	 */
-
-	if (p->p_args && (ps_argsopen || !p_can(curp, p, P_CAN_SEE, NULL))) {
-		bp = p->p_args->ar_args;
-		buflen = p->p_args->ar_length;
-		buf = 0;
-	} else if (p != curp) {
-		bp = p->p_comm;
-		buflen = MAXCOMLEN;
-		buf = 0;
-	} else {
-		buflen = 256;
-		MALLOC(buf, char *, buflen + 1, M_TEMP, M_WAITOK);
-		bp = buf;
-		ps = buf;
-		error = copyin((void*)PS_STRINGS, &pstr, sizeof(pstr));
-		if (error) {
-			FREE(buf, M_TEMP);
-			return (error);
-		}
-		bytes_left = buflen;
-		for (i = 0; bytes_left && (i < pstr.ps_nargvstr); i++) {
-			error = copyinstr(pstr.ps_argvstr[i], ps,
-					  bytes_left, &done);
-			/* If too long or malformed, just truncate */
-			if (error) {
-				error = 0;
-				break;
-			}
-			ps += done;
-			bytes_left -= done;
-		}
-		buflen = ps - buf;
-	}
-
-	buflen -= uio->uio_offset;
-	ps = bp + uio->uio_offset;
-	xlen = min(buflen, uio->uio_resid);
-	if (xlen <= 0)
-		error = 0;
-	else
-		error = uiomove(ps, xlen, uio);
-	if (buf)
-		FREE(buf, M_TEMP);
-	return (error);
-}
diff --git a/sys/miscfs/procfs/procfs_subr.c b/sys/miscfs/procfs/procfs_subr.c
deleted file mode 100644
index 64adecb..0000000
--- a/sys/miscfs/procfs/procfs_subr.c
+++ /dev/null
@@ -1,416 +0,0 @@
-/*
- * Copyright (c) 1993 Jan-Simon Pendry
- * Copyright (c) 1993
- *	The Regents of the University of California.  All rights reserved.
- *
- * This code is derived from software contributed to Berkeley by
- * Jan-Simon Pendry.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)procfs_subr.c	8.6 (Berkeley) 5/14/95
- *
- * $FreeBSD$
- */
-
-#include <sys/param.h>
-#include <sys/systm.h>
-#include <sys/lock.h>
-#include <sys/malloc.h>
-#include <sys/mount.h>
-#include <sys/mutex.h>
-#include <sys/proc.h>
-#include <sys/socket.h>
-#include <sys/sysctl.h>
-#include <sys/vnode.h>
-
-#include <miscfs/procfs/procfs.h>
-
-static struct pfsnode *pfshead;
-static int pfsvplock;
-
-/*
- * allocate a pfsnode/vnode pair.  the vnode is
- * referenced, but not locked.
- *
- * the pid, pfs_type, and mount point uniquely
- * identify a pfsnode.  the mount point is needed
- * because someone might mount this filesystem
- * twice.
- *
- * all pfsnodes are maintained on a singly-linked
- * list.  new nodes are only allocated when they cannot
- * be found on this list.  entries on the list are
- * removed when the vfs reclaim entry is called.
- *
- * a single lock is kept for the entire list.  this is
- * needed because the getnewvnode() function can block
- * waiting for a vnode to become free, in which case there
- * may be more than one process trying to get the same
- * vnode.  this lock is only taken if we are going to
- * call getnewvnode, since the kernel itself is single-threaded.
- *
- * if an entry is found on the list, then call vget() to
- * take a reference.  this is done because there may be
- * zero references to it and so it needs to removed from
- * the vnode free list.
- */
-int
-procfs_allocvp(mp, vpp, pid, pfs_type)
-	struct mount *mp;
-	struct vnode **vpp;
-	long pid;
-	pfstype pfs_type;
-{
-	struct proc *p = curproc;	/* XXX */
-	struct pfsnode *pfs;
-	struct vnode *vp;
-	struct pfsnode **pp;
-	int error;
-
-loop:
-	for (pfs = pfshead; pfs != 0; pfs = pfs->pfs_next) {
-		vp = PFSTOV(pfs);
-		if (pfs->pfs_pid == pid &&
-		    pfs->pfs_type == pfs_type &&
-		    vp->v_mount == mp) {
-			if (vget(vp, 0, p))
-				goto loop;
-			*vpp = vp;
-			return (0);
-		}
-	}
-
-	/*
-	 * otherwise lock the vp list while we call getnewvnode
-	 * since that can block.
-	 */
-	if (pfsvplock & PROCFS_LOCKED) {
-		pfsvplock |= PROCFS_WANT;
-		(void) tsleep((caddr_t) &pfsvplock, PINOD, "pfsavp", 0);
-		goto loop;
-	}
-	pfsvplock |= PROCFS_LOCKED;
-
-	/*
-	 * Do the MALLOC before the getnewvnode since doing so afterward
-	 * might cause a bogus v_data pointer to get dereferenced
-	 * elsewhere if MALLOC should block.
-	 */
-	MALLOC(pfs, struct pfsnode *, sizeof(struct pfsnode), M_TEMP, M_WAITOK);
-
-	if ((error = getnewvnode(VT_PROCFS, mp, procfs_vnodeop_p, vpp)) != 0) {
-		FREE(pfs, M_TEMP);
-		goto out;
-	}
-	vp = *vpp;
-
-	vp->v_data = pfs;
-
-	pfs->pfs_next = 0;
-	pfs->pfs_pid = (pid_t) pid;
-	pfs->pfs_type = pfs_type;
-	pfs->pfs_vnode = vp;
-	pfs->pfs_flags = 0;
-	pfs->pfs_lockowner = 0;
-	pfs->pfs_fileno = PROCFS_FILENO(pid, pfs_type);
-
-	switch (pfs_type) {
-	case Proot:	/* /proc = dr-xr-xr-x */
-		pfs->pfs_mode = (VREAD|VEXEC) |
-				(VREAD|VEXEC) >> 3 |
-				(VREAD|VEXEC) >> 6;
-		vp->v_type = VDIR;
-		vp->v_flag = VROOT;
-		break;
-
-	case Pcurproc:	/* /proc/curproc = lr--r--r-- */
-		pfs->pfs_mode = (VREAD) |
-				(VREAD >> 3) |
-				(VREAD >> 6);
-		vp->v_type = VLNK;
-		break;
-
-	case Pproc:
-		pfs->pfs_mode = (VREAD|VEXEC) |
-				(VREAD|VEXEC) >> 3 |
-				(VREAD|VEXEC) >> 6;
-		vp->v_type = VDIR;
-		break;
-
-	case Pfile:
-		pfs->pfs_mode = (VREAD|VEXEC) |
-				(VREAD|VEXEC) >> 3 |
-				(VREAD|VEXEC) >> 6;
-		vp->v_type = VLNK;
-		break;
-
-	case Pmem:
-		pfs->pfs_mode = (VREAD|VWRITE) |
-				(VREAD) >> 3;;
-		vp->v_type = VREG;
-		break;
-
-	case Pregs:
-	case Pfpregs:
-	case Pdbregs:
-		pfs->pfs_mode = (VREAD|VWRITE);
-		vp->v_type = VREG;
-		break;
-
-	case Pctl:
-	case Pnote:
-	case Pnotepg:
-		pfs->pfs_mode = (VWRITE);
-		vp->v_type = VREG;
-		break;
-
-	case Ptype:
-	case Pmap:
-	case Pstatus:
-	case Pcmdline:
-	case Prlimit:
-		pfs->pfs_mode = (VREAD) |
-				(VREAD >> 3) |
-				(VREAD >> 6);
-		vp->v_type = VREG;
-		break;
-
-	default:
-		panic("procfs_allocvp");
-	}
-
-	/* add to procfs vnode list */
-	for (pp = &pfshead; *pp; pp = &(*pp)->pfs_next)
-		continue;
-	*pp = pfs;
-
-out:
-	pfsvplock &= ~PROCFS_LOCKED;
-
-	if (pfsvplock & PROCFS_WANT) {
-		pfsvplock &= ~PROCFS_WANT;
-		wakeup((caddr_t) &pfsvplock);
-	}
-
-	return (error);
-}
-
-int
-procfs_freevp(vp)
-	struct vnode *vp;
-{
-	struct pfsnode **pfspp;
-	struct pfsnode *pfs = VTOPFS(vp);
-
-	for (pfspp = &pfshead; *pfspp != 0; pfspp = &(*pfspp)->pfs_next) {
-		if (*pfspp == pfs) {
-			*pfspp = pfs->pfs_next;
-			break;
-		}
-	}
-
-	FREE(vp->v_data, M_TEMP);
-	vp->v_data = 0;
-	return (0);
-}
-
-int
-procfs_rw(ap)
-	struct vop_read_args *ap;
-{
-	struct vnode *vp = ap->a_vp;
-	struct uio *uio = ap->a_uio;
-	struct proc *curp = uio->uio_procp;
-	struct pfsnode *pfs = VTOPFS(vp);
-	struct proc *p;
-	int rtval;
-
-	p = PFIND(pfs->pfs_pid);
-	if (p == NULL)
-		return (EINVAL);
-	PROC_UNLOCK(p);
-	if (p->p_pid == 1 && securelevel > 0 && uio->uio_rw == UIO_WRITE)
-		return (EACCES);
-
-	mp_fixme("pfs_lockowner needs a lock");
-	while (pfs->pfs_lockowner) {
-		tsleep(&pfs->pfs_lockowner, PRIBIO, "pfslck", 0);
-	}
-	pfs->pfs_lockowner = curproc->p_pid;
-
-	switch (pfs->pfs_type) {
-	case Pnote:
-	case Pnotepg:
-		rtval = procfs_donote(curp, p, pfs, uio);
-		break;
-
-	case Pregs:
-		rtval = procfs_doregs(curp, p, pfs, uio);
-		break;
-
-	case Pfpregs:
-		rtval = procfs_dofpregs(curp, p, pfs, uio);
-		break;
-
-        case Pdbregs:
-                rtval = procfs_dodbregs(curp, p, pfs, uio);
-                break;
-
-	case Pctl:
-		rtval = procfs_doctl(curp, p, pfs, uio);
-		break;
-
-	case Pstatus:
-		rtval = procfs_dostatus(curp, p, pfs, uio);
-		break;
-
-	case Pmap:
-		rtval = procfs_domap(curp, p, pfs, uio);
-		break;
-
-	case Pmem:
-		rtval = procfs_domem(curp, p, pfs, uio);
-		break;
-
-	case Ptype:
-		rtval = procfs_dotype(curp, p, pfs, uio);
-		break;
-
-	case Pcmdline:
-		rtval = procfs_docmdline(curp, p, pfs, uio);
-		break;
-
-	case Prlimit:
-		rtval = procfs_dorlimit(curp, p, pfs, uio);
-		break;
-
-	default:
-		rtval = EOPNOTSUPP;
-		break;
-	}
-	pfs->pfs_lockowner = 0;
-	wakeup(&pfs->pfs_lockowner);
-	return rtval;
-}
-
-/*
- * Get a string from userland into (buf).  Strip a trailing
- * nl character (to allow easy access from the shell).
- * The buffer should be *buflenp + 1 chars long.  vfs_getuserstr
- * will automatically add a nul char at the end.
- *
- * Returns 0 on success or the following errors
- *
- * EINVAL:    file offset is non-zero.
- * EMSGSIZE:  message is longer than kernel buffer
- * EFAULT:    user i/o buffer is not addressable
- */
-int
-vfs_getuserstr(uio, buf, buflenp)
-	struct uio *uio;
-	char *buf;
-	int *buflenp;
-{
-	int xlen;
-	int error;
-
-	if (uio->uio_offset != 0)
-		return (EINVAL);
-
-	xlen = *buflenp;
-
-	/* must be able to read the whole string in one go */
-	if (xlen < uio->uio_resid)
-		return (EMSGSIZE);
-	xlen = uio->uio_resid;
-
-	if ((error = uiomove(buf, xlen, uio)) != 0)
-		return (error);
-
-	/* allow multiple writes without seeks */
-	uio->uio_offset = 0;
-
-	/* cleanup string and remove trailing newline */
-	buf[xlen] = '\0';
-	xlen = strlen(buf);
-	if (xlen > 0 && buf[xlen-1] == '\n')
-		buf[--xlen] = '\0';
-	*buflenp = xlen;
-
-	return (0);
-}
-
-vfs_namemap_t *
-vfs_findname(nm, buf, buflen)
-	vfs_namemap_t *nm;
-	char *buf;
-	int buflen;
-{
-
-	for (; nm->nm_name; nm++)
-		if (bcmp(buf, nm->nm_name, buflen+1) == 0)
-			return (nm);
-
-	return (0);
-}
-
-void
-procfs_exit(struct proc *p)
-{
-	struct pfsnode *pfs;
-	pid_t pid = p->p_pid;
-
-	/*
-	 * The reason for this loop is not obvious -- basicly,
-	 * procfs_freevp(), which is called via vgone() (eventually),
-	 * removes the specified procfs node from the pfshead list.
-	 * It does this by *pfsp = pfs->pfs_next, meaning that it
-	 * overwrites the node.  So when we do pfs = pfs->next, we
-	 * end up skipping the node that replaces the one that was
-	 * vgone'd.  Since it may have been the last one on the list,
-	 * it may also have been set to null -- but *our* pfs pointer,
-	 * here, doesn't see this.  So the loop starts from the beginning
-	 * again.
-	 *
-	 * This is not a for() loop because the final event
-	 * would be "pfs = pfs->pfs_next"; in the case where
-	 * pfs is set to pfshead again, that would mean that
-	 * pfshead is skipped over.
-	 *
-	 */
-	pfs = pfshead;
-	while (pfs) {
-		if (pfs->pfs_pid == pid) {
-			vgone(PFSTOV(pfs));
-			pfs = pfshead;
-		} else
-			pfs = pfs->pfs_next;
-	}
-}
diff --git a/sys/miscfs/procfs/procfs_type.c b/sys/miscfs/procfs/procfs_type.c
deleted file mode 100644
index cb2a45f..0000000
--- a/sys/miscfs/procfs/procfs_type.c
+++ /dev/null
@@ -1,85 +0,0 @@
-/*
- * Copyright (c) 1993 Jan-Simon Pendry
- * Copyright (c) 1993
- *	The Regents of the University of California.  All rights reserved.
- *
- * This code is derived from software contributed to Berkeley by
- * Jan-Simon Pendry.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * $FreeBSD$
- */
-
-#include <sys/param.h>
-#include <sys/systm.h>
-#include <sys/proc.h>
-#include <sys/sysent.h>
-#include <sys/vnode.h>
-#include <miscfs/procfs/procfs.h>
-
-int
-procfs_dotype(curp, p, pfs, uio)
-	struct proc *curp;
-	struct proc *p;
-	struct pfsnode *pfs;
-	struct uio *uio;
-{
-	int len;
-	int error;
-	/*
-	 * buffer for emulation type
-	 */
-	char mebuffer[256];
-	char *none = "Not Available";
-
-	if (uio->uio_rw != UIO_READ)
-		return (EOPNOTSUPP);
-
-	if (uio->uio_offset != 0)
-		return (0);
-
-	if (p && p->p_sysent && p->p_sysent->sv_name) {
-		len = strlen(p->p_sysent->sv_name);
-		bcopy(p->p_sysent->sv_name, mebuffer, len);
-	} else {
-		len = strlen(none);
-		bcopy(none, mebuffer, len);
-	}
-	mebuffer[len++] = '\n';
-	error = uiomove(mebuffer, len, uio);
-	return error;
-}
-
-int
-procfs_validtype(p)
-	struct proc *p;
-{
-	return ((p->p_flag & P_SYSTEM) == 0);
-}
diff --git a/sys/miscfs/procfs/procfs_vfsops.c b/sys/miscfs/procfs/procfs_vfsops.c
deleted file mode 100644
index 91daf9d..0000000
--- a/sys/miscfs/procfs/procfs_vfsops.c
+++ /dev/null
@@ -1,177 +0,0 @@
-/*
- * Copyright (c) 1993 Jan-Simon Pendry
- * Copyright (c) 1993
- *	The Regents of the University of California.  All rights reserved.
- *
- * This code is derived from software contributed to Berkeley by
- * Jan-Simon Pendry.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)procfs_vfsops.c	8.7 (Berkeley) 5/10/95
- *
- * $FreeBSD$
- */
-
-/*
- * procfs VFS interface
- */
-
-#include <sys/param.h>
-#include <sys/systm.h>
-#include <sys/kernel.h>
-#include <sys/proc.h>
-#include <sys/mount.h>
-#include <sys/vnode.h>
-#include <miscfs/procfs/procfs.h>
-
-static int	procfs_mount __P((struct mount *mp, char *path, caddr_t data,
-				  struct nameidata *ndp, struct proc *p));
-static int	procfs_statfs __P((struct mount *mp, struct statfs *sbp,
-				   struct proc *p));
-static int	procfs_unmount __P((struct mount *mp, int mntflags,
-				    struct proc *p));
-
-/*
- * VFS Operations.
- *
- * mount system call
- */
-/* ARGSUSED */
-static int
-procfs_mount(mp, path, data, ndp, p)
-	struct mount *mp;
-	char *path;
-	caddr_t data;
-	struct nameidata *ndp;
-	struct proc *p;
-{
-	size_t size;
-	int error;
-
-	if (mp->mnt_flag & MNT_UPDATE)
-		return (EOPNOTSUPP);
-
-	if (mp->mnt_vfc->vfc_refcount == 1 && (error = at_exit(procfs_exit))) {
-		printf("procfs:  cannot register procfs_exit with at_exit\n");
-		return(error);
-	}
-
-	mp->mnt_flag |= MNT_LOCAL;
-	mp->mnt_data = 0;
-	vfs_getnewfsid(mp);
-
-	size = sizeof("procfs") - 1;
-	bcopy("procfs", mp->mnt_stat.f_mntfromname, size);
-	bzero(mp->mnt_stat.f_mntfromname + size, MNAMELEN - size);
-	(void)procfs_statfs(mp, &mp->mnt_stat, p);
-
-	return (0);
-}
-
-/*
- * unmount system call
- */
-static int
-procfs_unmount(mp, mntflags, p)
-	struct mount *mp;
-	int mntflags;
-	struct proc *p;
-{
-	int error;
-	int flags = 0;
-
-	if (mntflags & MNT_FORCE)
-		flags |= FORCECLOSE;
-
-	error = vflush(mp, 0, flags);
-	if (error)
-		return (error);
-
-	if (mp->mnt_vfc->vfc_refcount == 1)
-		rm_at_exit(procfs_exit);
-
-	return (0);
-}
-
-int
-procfs_root(mp, vpp)
-	struct mount *mp;
-	struct vnode **vpp;
-{
-
-	return (procfs_allocvp(mp, vpp, 0, Proot));
-}
-
-/*
- * Get file system statistics.
- */
-static int
-procfs_statfs(mp, sbp, p)
-	struct mount *mp;
-	struct statfs *sbp;
-	struct proc *p;
-{
-	sbp->f_bsize = PAGE_SIZE;
-	sbp->f_iosize = PAGE_SIZE;
-	sbp->f_blocks = 1;	/* avoid divide by zero in some df's */
-	sbp->f_bfree = 0;
-	sbp->f_bavail = 0;
-	sbp->f_files = maxproc;			/* approx */
-	sbp->f_ffree = maxproc - nprocs;	/* approx */
-
-	if (sbp != &mp->mnt_stat) {
-		sbp->f_type = mp->mnt_vfc->vfc_typenum;
-		bcopy(&mp->mnt_stat.f_fsid, &sbp->f_fsid, sizeof(sbp->f_fsid));
-		bcopy(mp->mnt_stat.f_mntonname, sbp->f_mntonname, MNAMELEN);
-		bcopy(mp->mnt_stat.f_mntfromname, sbp->f_mntfromname, MNAMELEN);
-	}
-
-	return (0);
-}
-
-static struct vfsops procfs_vfsops = {
-	procfs_mount,
-	vfs_stdstart,
-	procfs_unmount,
-	procfs_root,
-	vfs_stdquotactl,
-	procfs_statfs,
-	vfs_stdsync,
-	vfs_stdvget,
-	vfs_stdfhtovp,
-	vfs_stdcheckexp,
-	vfs_stdvptofh,
-	vfs_stdinit,
-	vfs_stduninit,
-	vfs_stdextattrctl,
-};
-
-VFS_SET(procfs_vfsops, procfs, VFCF_SYNTHETIC);
-MODULE_VERSION(procfs, 1);
diff --git a/sys/miscfs/procfs/procfs_vnops.c b/sys/miscfs/procfs/procfs_vnops.c
deleted file mode 100644
index dbdafc8..0000000
--- a/sys/miscfs/procfs/procfs_vnops.c
+++ /dev/null
@@ -1,1022 +0,0 @@
-/*
- * Copyright (c) 1993, 1995 Jan-Simon Pendry
- * Copyright (c) 1993, 1995
- *	The Regents of the University of California.  All rights reserved.
- *
- * This code is derived from software contributed to Berkeley by
- * Jan-Simon Pendry.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)procfs_vnops.c	8.18 (Berkeley) 5/21/95
- *
- * $FreeBSD$
- */
-
-/*
- * procfs vnode interface
- */
-
-#include <sys/param.h>
-#include <sys/systm.h>
-#include <sys/dirent.h>
-#include <sys/fcntl.h>
-#include <sys/kernel.h>
-#include <sys/lock.h>
-#include <sys/malloc.h>
-#include <sys/mount.h>
-#include <sys/mutex.h>
-#include <sys/namei.h>
-#include <sys/pioctl.h>
-#include <sys/proc.h>
-#include <sys/signalvar.h>
-#include <sys/socket.h>
-#include <sys/sx.h>
-#include <sys/time.h>
-#include <sys/uio.h>
-#include <sys/vnode.h>
-
-#include <machine/reg.h>
-
-#include <vm/vm_zone.h>
-
-#include <miscfs/procfs/procfs.h>
-
-static int	procfs_access __P((struct vop_access_args *));
-static int	procfs_badop __P((void));
-static int	procfs_close __P((struct vop_close_args *));
-static int	procfs_getattr __P((struct vop_getattr_args *));
-static int	procfs_ioctl __P((struct vop_ioctl_args *));
-static int	procfs_lookup __P((struct vop_lookup_args *));
-static int	procfs_open __P((struct vop_open_args *));
-static int	procfs_print __P((struct vop_print_args *));
-static int	procfs_readdir __P((struct vop_readdir_args *));
-static int	procfs_readlink __P((struct vop_readlink_args *));
-static int	procfs_reclaim __P((struct vop_reclaim_args *));
-static int	procfs_setattr __P((struct vop_setattr_args *));
-
-/*
- * This is a list of the valid names in the
- * process-specific sub-directories.  It is
- * used in procfs_lookup and procfs_readdir
- */
-static struct proc_target {
-	u_char	pt_type;
-	u_char	pt_namlen;
-	char	*pt_name;
-	pfstype	pt_pfstype;
-	int	(*pt_valid) __P((struct proc *p));
-} proc_targets[] = {
-#define N(s) sizeof(s)-1, s
-	/*	  name		type		validp */
-	{ DT_DIR, N("."),	Pproc,		NULL },
-	{ DT_DIR, N(".."),	Proot,		NULL },
-	{ DT_REG, N("mem"),	Pmem,		NULL },
-	{ DT_REG, N("regs"),	Pregs,		procfs_validregs },
-	{ DT_REG, N("fpregs"),	Pfpregs,	procfs_validfpregs },
-	{ DT_REG, N("dbregs"),	Pdbregs,	procfs_validdbregs },
-	{ DT_REG, N("ctl"),	Pctl,		NULL },
-	{ DT_REG, N("status"),	Pstatus,	NULL },
-	{ DT_REG, N("note"),	Pnote,		NULL },
-	{ DT_REG, N("notepg"),	Pnotepg,	NULL },
-	{ DT_REG, N("map"), 	Pmap,		procfs_validmap },
-	{ DT_REG, N("etype"),	Ptype,		procfs_validtype },
-	{ DT_REG, N("cmdline"),	Pcmdline,	NULL },
-	{ DT_REG, N("rlimit"),	Prlimit,	NULL },
-	{ DT_LNK, N("file"),	Pfile,		NULL },
-#undef N
-};
-static const int nproc_targets = sizeof(proc_targets) / sizeof(proc_targets[0]);
-
-static pid_t atopid __P((const char *, u_int));
-
-/*
- * set things up for doing i/o on
- * the pfsnode (vp).  (vp) is locked
- * on entry, and should be left locked
- * on exit.
- *
- * for procfs we don't need to do anything
- * in particular for i/o.  all that is done
- * is to support exclusive open on process
- * memory images.
- */
-static int
-procfs_open(ap)
-	struct vop_open_args /* {
-		struct vnode *a_vp;
-		int  a_mode;
-		struct ucred *a_cred;
-		struct proc *a_p;
-	} */ *ap;
-{
-	struct pfsnode *pfs = VTOPFS(ap->a_vp);
-	struct proc *p1, *p2;
-	int error = 0;
-
-	p2 = PFIND(pfs->pfs_pid);
-	if (p2 == NULL)
-		return (ENOENT);
-	if (pfs->pfs_pid && p_can(ap->a_p, p2, P_CAN_SEE, NULL)) {
-		error = ENOENT;
-		goto out;
-	}
-
-	switch (pfs->pfs_type) {
-	case Pmem:
-		if (((pfs->pfs_flags & FWRITE) && (ap->a_mode & O_EXCL)) ||
-		    ((pfs->pfs_flags & O_EXCL) && (ap->a_mode & FWRITE))) {
-			error = EBUSY;
-			goto out;
-		}
-
-		p1 = ap->a_p;
-		if (p_can(p1, p2, P_CAN_DEBUG, NULL) &&
-		    !procfs_kmemaccess(p1)) {
-			error = EPERM;
-		}
-
-		if (ap->a_mode & FWRITE)
-			pfs->pfs_flags = ap->a_mode & (FWRITE|O_EXCL);
-
-	default:
-		break;
-	}
-out:
-	PROC_UNLOCK(p2);
-	return (error);
-}
-
-/*
- * close the pfsnode (vp) after doing i/o.
- * (vp) is not locked on entry or exit.
- *
- * nothing to do for procfs other than undo
- * any exclusive open flag (see _open above).
- */
-static int
-procfs_close(ap)
-	struct vop_close_args /* {
-		struct vnode *a_vp;
-		int  a_fflag;
-		struct ucred *a_cred;
-		struct proc *a_p;
-	} */ *ap;
-{
-	struct pfsnode *pfs = VTOPFS(ap->a_vp);
-	struct proc *p;
-
-	switch (pfs->pfs_type) {
-	case Pmem:
-		if ((ap->a_fflag & FWRITE) && (pfs->pfs_flags & O_EXCL))
-			pfs->pfs_flags &= ~(FWRITE|O_EXCL);
-		/*
-		 * If this is the last close, then it checks to see if
-		 * the target process has PF_LINGER set in p_pfsflags,
-		 * if this is *not* the case, then the process' stop flags
-		 * are cleared, and the process is woken up.  This is
-		 * to help prevent the case where a process has been
-		 * told to stop on an event, but then the requesting process
-		 * has gone away or forgotten about it.
-		 */
-		if ((ap->a_vp->v_usecount < 2) && (p = pfind(pfs->pfs_pid))) {
-			if (!(p->p_pfsflags & PF_LINGER)) {
-				p->p_stops = 0;
-				p->p_step = 0;
-				wakeup(&p->p_step);
-			}
-			PROC_UNLOCK(p);
-		}
-		break;
-	default:
-		break;
-	}
-
-	return (0);
-}
-
-/*
- * do an ioctl operation on a pfsnode (vp).
- * (vp) is not locked on entry or exit.
- */
-static int
-procfs_ioctl(ap)
-	struct vop_ioctl_args *ap;
-{
-	struct pfsnode *pfs = VTOPFS(ap->a_vp);
-	struct proc *procp, *p;
-	int error;
-	int signo;
-	struct procfs_status *psp;
-	unsigned char flags;
-
-	p = ap->a_p;
-	procp = pfind(pfs->pfs_pid);
-	if (procp == NULL) {
-		return ENOTTY;
-	}
-
-	if ((error = p_can(p, procp, P_CAN_DEBUG, NULL))) {
-		PROC_UNLOCK(procp);
-		return (error == ESRCH ? ENOENT : error);
-	}
-
-	switch (ap->a_command) {
-	case PIOCBIS:
-	  procp->p_stops |= *(unsigned int*)ap->a_data;
-	  break;
-	case PIOCBIC:
-	  procp->p_stops &= ~*(unsigned int*)ap->a_data;
-	  break;
-	case PIOCSFL:
-	  /*
-	   * NFLAGS is "non-suser_xxx flags" -- currently, only
-	   * PFS_ISUGID ("ignore set u/g id");
-	   */
-#define NFLAGS	(PF_ISUGID)
-	  flags = (unsigned char)*(unsigned int*)ap->a_data;
-	  if (flags & NFLAGS && (error = suser(p))) {
-	    PROC_UNLOCK(procp);
-	    return error;
-	  }
-	  procp->p_pfsflags = flags;
-	  break;
-	case PIOCGFL:
-	  *(unsigned int*)ap->a_data = (unsigned int)procp->p_pfsflags;
-	  /* FALLTHROUGH */
-	case PIOCSTATUS:
-	  psp = (struct procfs_status *)ap->a_data;
-	  psp->state = (procp->p_step == 0);
-	  psp->flags = procp->p_pfsflags;
-	  psp->events = procp->p_stops;
-	  if (procp->p_step) {
-	    psp->why = procp->p_stype;
-	    psp->val = procp->p_xstat;
-	  } else {
-	    psp->why = psp->val = 0;	/* Not defined values */
-	  }
-	  break;
-	case PIOCWAIT:
-	  psp = (struct procfs_status *)ap->a_data;
-	  if (procp->p_step == 0) {
-	    error = msleep(&procp->p_stype, &procp->p_mtx, PWAIT | PCATCH,
-	      "piocwait", 0);
-	    if (error) {
-	      PROC_UNLOCK(procp);
-	      return error;
-	    }
-	  }
-	  psp->state = 1;	/* It stopped */
-	  psp->flags = procp->p_pfsflags;
-	  psp->events = procp->p_stops;
-	  psp->why = procp->p_stype;	/* why it stopped */
-	  psp->val = procp->p_xstat;	/* any extra info */
-	  break;
-	case PIOCCONT:	/* Restart a proc */
-	  if (procp->p_step == 0) {
-	    PROC_UNLOCK(procp);
-	    return EINVAL;	/* Can only start a stopped process */
-	  }
-	  if ((signo = *(int*)ap->a_data) != 0) {
-	    if (signo >= NSIG || signo <= 0) {
-	      PROC_UNLOCK(procp);
-	      return EINVAL;
-	    }
-	    psignal(procp, signo);
-	  }
-	  procp->p_step = 0;
-	  wakeup(&procp->p_step);
-	  break;
-	default:
-	  PROC_UNLOCK(procp);
-	  return (ENOTTY);
-	}
-	PROC_UNLOCK(procp);
-	return 0;
-}
-
-/*
- * _reclaim is called when getnewvnode()
- * wants to make use of an entry on the vnode
- * free list.  at this time the filesystem needs
- * to free any private data and remove the node
- * from any private lists.
- */
-static int
-procfs_reclaim(ap)
-	struct vop_reclaim_args /* {
-		struct vnode *a_vp;
-	} */ *ap;
-{
-
-	return (procfs_freevp(ap->a_vp));
-}
-
-/*
- * _print is used for debugging.
- * just print a readable description
- * of (vp).
- */
-static int
-procfs_print(ap)
-	struct vop_print_args /* {
-		struct vnode *a_vp;
-	} */ *ap;
-{
-	struct pfsnode *pfs = VTOPFS(ap->a_vp);
-
-	printf("tag VT_PROCFS, type %d, pid %ld, mode %x, flags %lx\n",
-	    pfs->pfs_type, (long)pfs->pfs_pid, pfs->pfs_mode, pfs->pfs_flags);
-	return (0);
-}
-
-/*
- * generic entry point for unsupported operations
- */
-static int
-procfs_badop()
-{
-
-	return (EIO);
-}
-
-/*
- * Invent attributes for pfsnode (vp) and store
- * them in (vap).
- * Directories lengths are returned as zero since
- * any real length would require the genuine size
- * to be computed, and nothing cares anyway.
- *
- * this is relatively minimal for procfs.
- */
-static int
-procfs_getattr(ap)
-	struct vop_getattr_args /* {
-		struct vnode *a_vp;
-		struct vattr *a_vap;
-		struct ucred *a_cred;
-		struct proc *a_p;
-	} */ *ap;
-{
-	struct pfsnode *pfs = VTOPFS(ap->a_vp);
-	struct vattr *vap = ap->a_vap;
-	struct proc *procp;
-	int error;
-
-	/*
-	 * First make sure that the process and its credentials 
-	 * still exist.
-	 */
-	switch (pfs->pfs_type) {
-	case Proot:
-	case Pcurproc:
-		procp = NULL;
-		break;
-
-	default:
-		procp = PFIND(pfs->pfs_pid);
-		if (procp == NULL)
-			return (ENOENT);
-		if (procp->p_cred == NULL || procp->p_ucred == NULL) {
-			PROC_UNLOCK(procp);
-			return (ENOENT);
-		}
-
-		if (p_can(ap->a_p, procp, P_CAN_SEE, NULL)) {
-			PROC_UNLOCK(procp);
-			return (ENOENT);
-		}
-		PROC_UNLOCK(procp);
-	}
-
-	error = 0;
-
-	/* start by zeroing out the attributes */
-	VATTR_NULL(vap);
-
-	/* next do all the common fields */
-	vap->va_type = ap->a_vp->v_type;
-	vap->va_mode = pfs->pfs_mode;
-	vap->va_fileid = pfs->pfs_fileno;
-	vap->va_flags = 0;
-	vap->va_blocksize = PAGE_SIZE;
-	vap->va_bytes = vap->va_size = 0;
-	vap->va_fsid = ap->a_vp->v_mount->mnt_stat.f_fsid.val[0];
-
-	/*
-	 * Make all times be current TOD.
-	 * It would be possible to get the process start
-	 * time from the p_stat structure, but there's
-	 * no "file creation" time stamp anyway, and the
-	 * p_stat structure is not addressible if u. gets
-	 * swapped out for that process.
-	 */
-	nanotime(&vap->va_ctime);
-	vap->va_atime = vap->va_mtime = vap->va_ctime;
-
-	/*
-	 * If the process has exercised some setuid or setgid
-	 * privilege, then rip away read/write permission so
-	 * that only root can gain access.
-	 */
-	switch (pfs->pfs_type) {
-	case Pctl:
-	case Pregs:
-	case Pfpregs:
-	case Pdbregs:
-		if (procp->p_flag & P_SUGID)
-			vap->va_mode &= ~((VREAD|VWRITE)|
-					  ((VREAD|VWRITE)>>3)|
-					  ((VREAD|VWRITE)>>6));
-		break;
-	case Pmem:
-		/* Retain group kmem readablity. */
-		PROC_LOCK(procp);
-		if (procp->p_flag & P_SUGID)
-			vap->va_mode &= ~(VREAD|VWRITE);
-		PROC_UNLOCK(procp);
-		break;
-	default:
-		break;
-	}
-
-	/*
-	 * now do the object specific fields
-	 *
-	 * The size could be set from struct reg, but it's hardly
-	 * worth the trouble, and it puts some (potentially) machine
-	 * dependent data into this machine-independent code.  If it
-	 * becomes important then this function should break out into
-	 * a per-file stat function in the corresponding .c file.
-	 */
-
-	vap->va_nlink = 1;
-	if (procp) {
-		PROC_LOCK(procp);
-		vap->va_uid = procp->p_ucred->cr_uid;
-		vap->va_gid = procp->p_ucred->cr_gid;
-		PROC_UNLOCK(procp);
-	}
-
-	switch (pfs->pfs_type) {
-	case Proot:
-		/*
-		 * Set nlink to 1 to tell fts(3) we don't actually know.
-		 */
-		vap->va_nlink = 1;
-		vap->va_uid = 0;
-		vap->va_gid = 0;
-		vap->va_size = vap->va_bytes = DEV_BSIZE;
-		break;
-
-	case Pcurproc: {
-		char buf[16];		/* should be enough */
-		vap->va_uid = 0;
-		vap->va_gid = 0;
-		vap->va_size = vap->va_bytes =
-		    snprintf(buf, sizeof(buf), "%ld", (long)curproc->p_pid);
-		break;
-	}
-
-	case Pproc:
-		vap->va_nlink = nproc_targets;
-		vap->va_size = vap->va_bytes = DEV_BSIZE;
-		break;
-
-	case Pfile: {
-		char *fullpath, *freepath;
-		error = textvp_fullpath(procp, &fullpath, &freepath);
-		if (error == 0) {
-			vap->va_size = strlen(fullpath);
-			free(freepath, M_TEMP);
-		} else {
-			vap->va_size = sizeof("unknown") - 1;
-			error = 0;
-		}
-		vap->va_bytes = vap->va_size;
-		break;
-	}
-
-	case Pmem:
-		/*
-		 * If we denied owner access earlier, then we have to
-		 * change the owner to root - otherwise 'ps' and friends
-		 * will break even though they are setgid kmem. *SIGH*
-		 */
-		PROC_LOCK(procp);
-		if (procp->p_flag & P_SUGID)
-			vap->va_uid = 0;
-		else
-			vap->va_uid = procp->p_ucred->cr_uid;
-		PROC_UNLOCK(procp);
-		vap->va_gid = KMEM_GROUP;
-		break;
-
-	case Pregs:
-		vap->va_bytes = vap->va_size = sizeof(struct reg);
-		break;
-
-	case Pfpregs:
-		vap->va_bytes = vap->va_size = sizeof(struct fpreg);
-		break;
-
-        case Pdbregs:
-                vap->va_bytes = vap->va_size = sizeof(struct dbreg);
-                break;
-
-	case Ptype:
-	case Pmap:
-	case Pctl:
-	case Pstatus:
-	case Pnote:
-	case Pnotepg:
-	case Pcmdline:
-	case Prlimit:
-		break;
-
-	default:
-		panic("procfs_getattr");
-	}
-
-	return (error);
-}
-
-static int
-procfs_setattr(ap)
-	struct vop_setattr_args /* {
-		struct vnode *a_vp;
-		struct vattr *a_vap;
-		struct ucred *a_cred;
-		struct proc *a_p;
-	} */ *ap;
-{
-
-	if (ap->a_vap->va_flags != VNOVAL)
-		return (EOPNOTSUPP);
-
-	/*
-	 * just fake out attribute setting
-	 * it's not good to generate an error
-	 * return, otherwise things like creat()
-	 * will fail when they try to set the
-	 * file length to 0.  worse, this means
-	 * that echo $note > /proc/$pid/note will fail.
-	 */
-
-	return (0);
-}
-
-/*
- * implement access checking.
- *
- * actually, the check for super-user is slightly
- * broken since it will allow read access to write-only
- * objects.  this doesn't cause any particular trouble
- * but does mean that the i/o entry points need to check
- * that the operation really does make sense.
- */
-static int
-procfs_access(ap)
-	struct vop_access_args /* {
-		struct vnode *a_vp;
-		int a_mode;
-		struct ucred *a_cred;
-		struct proc *a_p;
-	} */ *ap;
-{
-	struct pfsnode *pfs = VTOPFS(ap->a_vp);
-	struct vnode *vp = ap->a_vp;
-	struct proc *procp;
-	struct vattr *vap;
-	struct vattr vattr;
-	int error;
-
-	switch (pfs->pfs_type) {
-	case Proot:
-       	case Pcurproc:
-		break;
-	default:
-		procp = PFIND(pfs->pfs_pid);
-		if (procp == NULL)
-			return (ENOENT);
-		if (p_can(ap->a_p, procp, P_CAN_SEE, NULL)) {
-			PROC_UNLOCK(procp);
-			return (ENOENT);
-		}
-		PROC_UNLOCK(procp);
-        }
-
-	vap = &vattr;
-	error = VOP_GETATTR(vp, vap, ap->a_cred, ap->a_p);
-	if (error)
-		return (error);
-
-	return (vaccess(vp->v_type, vap->va_mode, vap->va_uid, vap->va_gid,
-	    ap->a_mode, ap->a_cred, NULL));
-}
-
-/*
- * lookup.  this is incredibly complicated in the
- * general case, however for most pseudo-filesystems
- * very little needs to be done.
- *
- * unless you want to get a migraine, just make sure your
- * filesystem doesn't do any locking of its own.  otherwise
- * read and inwardly digest ufs_lookup().
- */
-static int
-procfs_lookup(ap)
-	struct vop_lookup_args /* {
-		struct vnode * a_dvp;
-		struct vnode ** a_vpp;
-		struct componentname * a_cnp;
-	} */ *ap;
-{
-	struct componentname *cnp = ap->a_cnp;
-	struct vnode **vpp = ap->a_vpp;
-	struct vnode *dvp = ap->a_dvp;
-	char *pname = cnp->cn_nameptr;
-	struct proc *curp = cnp->cn_proc;
-	struct proc_target *pt;
-	pid_t pid;
-	struct pfsnode *pfs;
-	struct proc *p;
-	int i;
-
-	*vpp = NULL;
-
-	if (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME ||
-	    cnp->cn_nameiop == CREATE)
-		return (EROFS);
-
-	if (cnp->cn_namelen == 1 && *pname == '.') {
-		*vpp = dvp;
-		VREF(dvp);
-		/* vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY, curp); */
-		return (0);
-	}
-
-	pfs = VTOPFS(dvp);
-	switch (pfs->pfs_type) {
-	case Proot:
-		if (cnp->cn_flags & ISDOTDOT)
-			return (EIO);
-
-		if (CNEQ(cnp, "curproc", 7))
-			return (procfs_allocvp(dvp->v_mount, vpp, 0, Pcurproc));
-
-		pid = atopid(pname, cnp->cn_namelen);
-		if (pid == NO_PID)
-			break;
-
-		p = PFIND(pid);
-		if (p == NULL)
-			break;
-
-		if (p_can(curp, p, P_CAN_SEE, NULL)) {
-			PROC_UNLOCK(p);
-			break;
-		}
-		PROC_UNLOCK(p);
-
-		return (procfs_allocvp(dvp->v_mount, vpp, pid, Pproc));
-
-	case Pproc:
-		if (cnp->cn_flags & ISDOTDOT)
-			return (procfs_root(dvp->v_mount, vpp));
-
-		p = PFIND(pfs->pfs_pid);
-		if (p == NULL)
-			break;
-
-		for (pt = proc_targets, i = 0; i < nproc_targets; pt++, i++) {
-			if (cnp->cn_namelen == pt->pt_namlen &&
-			    bcmp(pt->pt_name, pname, cnp->cn_namelen) == 0 &&
-			    (pt->pt_valid == NULL || (*pt->pt_valid)(p)))
-				goto found;
-		}
-		PROC_UNLOCK(p);
-		break;
-	found:
-		PROC_UNLOCK(p);
-		return (procfs_allocvp(dvp->v_mount, vpp, pfs->pfs_pid,
-		    pt->pt_pfstype));
-
-	default:
-		return (ENOTDIR);
-	}
-
-	return (cnp->cn_nameiop == LOOKUP ? ENOENT : EROFS);
-}
-
-/*
- * Does this process have a text file?
- */
-int
-procfs_validfile(p)
-	struct proc *p;
-{
-
-	return (procfs_findtextvp(p) != NULLVP);
-}
-
-/*
- * readdir() returns directory entries from pfsnode (vp).
- *
- * We generate just one directory entry at a time, as it would probably
- * not pay off to buffer several entries locally to save uiomove calls.
- */
-static int
-procfs_readdir(ap)
-	struct vop_readdir_args /* {
-		struct vnode *a_vp;
-		struct uio *a_uio;
-		struct ucred *a_cred;
-		int *a_eofflag;
-		int *a_ncookies;
-		u_long **a_cookies;
-	} */ *ap;
-{
-	struct uio *uio = ap->a_uio;
-	struct dirent d;
-	struct dirent *dp = &d;
-	struct pfsnode *pfs;
-	int count, error, i, off;
-	static u_int delen;
-
-	if (!delen) {
-
-		d.d_namlen = PROCFS_NAMELEN;
-		delen = GENERIC_DIRSIZ(&d);
-	}
-
-	pfs = VTOPFS(ap->a_vp);
-
-	off = (int)uio->uio_offset;
-	if (off != uio->uio_offset || off < 0 || 
-	    off % delen != 0 || uio->uio_resid < delen)
-		return (EINVAL);
-
-	error = 0;
-	count = 0;
-	i = off / delen;
-
-	switch (pfs->pfs_type) {
-	/*
-	 * this is for the process-specific sub-directories.
-	 * all that is needed to is copy out all the entries
-	 * from the procent[] table (top of this file).
-	 */
-	case Pproc: {
-		struct proc *p;
-		struct proc_target *pt;
-
-		p = PFIND(pfs->pfs_pid);
-		if (p == NULL)
-			break;
-		if (p_can(curproc, p, P_CAN_SEE, NULL)) {
-			PROC_UNLOCK(p);
-			break;
-		}
-
-		for (pt = &proc_targets[i];
-		     uio->uio_resid >= delen && i < nproc_targets; pt++, i++) {
-			if (pt->pt_valid && (*pt->pt_valid)(p) == 0)
-				continue;
-
-			dp->d_reclen = delen;
-			dp->d_fileno = PROCFS_FILENO(pfs->pfs_pid, pt->pt_pfstype);
-			dp->d_namlen = pt->pt_namlen;
-			bcopy(pt->pt_name, dp->d_name, pt->pt_namlen + 1);
-			dp->d_type = pt->pt_type;
-
-			if ((error = uiomove((caddr_t)dp, delen, uio)) != 0)
-				break;
-		}
-		PROC_UNLOCK(p);
-
-	    	break;
-	    }
-
-	/*
-	 * this is for the root of the procfs filesystem
-	 * what is needed is a special entry for "curproc"
-	 * followed by an entry for each process on allproc
-#ifdef PROCFS_ZOMBIE
-	 * and zombproc.
-#endif
-	 */
-
-	case Proot: {
-#ifdef PROCFS_ZOMBIE
-		int doingzomb = 0;
-#endif
-		int pcnt = 0;
-		struct proc *p;
-
-		sx_slock(&allproc_lock);
-		p = LIST_FIRST(&allproc);
-		for (; p && uio->uio_resid >= delen; i++, pcnt++) {
-			bzero((char *) dp, delen);
-			dp->d_reclen = delen;
-
-			switch (i) {
-			case 0:		/* `.' */
-			case 1:		/* `..' */
-				dp->d_fileno = PROCFS_FILENO(0, Proot);
-				dp->d_namlen = i + 1;
-				bcopy("..", dp->d_name, dp->d_namlen);
-				dp->d_name[i + 1] = '\0';
-				dp->d_type = DT_DIR;
-				break;
-
-			case 2:
-				dp->d_fileno = PROCFS_FILENO(0, Pcurproc);
-				dp->d_namlen = 7;
-				bcopy("curproc", dp->d_name, 8);
-				dp->d_type = DT_LNK;
-				break;
-
-			default:
-				while (pcnt < i) {
-					p = LIST_NEXT(p, p_list);
-					if (p == NULL)
-						goto done;
-					if (p_can(curproc, p, P_CAN_SEE, NULL))
-						continue;
-					pcnt++;
-				}
-				while (p_can(curproc, p, P_CAN_SEE, NULL)) {
-					p = LIST_NEXT(p, p_list);
-					if (p == NULL)
-						goto done;
-				}
-				dp->d_fileno = PROCFS_FILENO(p->p_pid, Pproc);
-				dp->d_namlen = sprintf(dp->d_name, "%ld",
-				    (long)p->p_pid);
-				dp->d_type = DT_DIR;
-				p = LIST_NEXT(p, p_list);
-				break;
-			}
-
-			if ((error = uiomove((caddr_t)dp, delen, uio)) != 0)
-				break;
-		}
-	done:
-
-#ifdef PROCFS_ZOMBIE
-		if (p == NULL && doingzomb == 0) {
-			doingzomb = 1;
-			p = LIST_FIRST(&zombproc);
-			goto again;
-		}
-#endif
-
-		sx_sunlock(&allproc_lock);
-		break;
-
-	    }
-
-	default:
-		error = ENOTDIR;
-		break;
-	}
-
-	uio->uio_offset = i * delen;
-
-	return (error);
-}
-
-/*
- * readlink reads the link of `curproc' or `file'
- */
-static int
-procfs_readlink(ap)
-	struct vop_readlink_args *ap;
-{
-	char buf[16];		/* should be enough */
-	struct proc *procp;
-	struct vnode *vp = ap->a_vp;
-	struct pfsnode *pfs = VTOPFS(vp);
-	char *fullpath, *freepath;
-	int error, len;
-
-	switch (pfs->pfs_type) {
-	case Pcurproc:
-		if (pfs->pfs_fileno != PROCFS_FILENO(0, Pcurproc))
-			return (EINVAL);
-
-		len = snprintf(buf, sizeof(buf), "%ld", (long)curproc->p_pid);
-
-		return (uiomove(buf, len, ap->a_uio));
-	/*
-	 * There _should_ be no way for an entire process to disappear
-	 * from under us...
-	 */
-	case Pfile:
-		procp = PFIND(pfs->pfs_pid);
-		if (procp == NULL || procp->p_cred == NULL ||
-		    procp->p_ucred == NULL) {
-			if (procp != NULL)
-				PROC_UNLOCK(procp);
-			printf("procfs_readlink: pid %d disappeared\n",
-			    pfs->pfs_pid);
-			return (uiomove("unknown", sizeof("unknown") - 1,
-			    ap->a_uio));
-		}
-		PROC_UNLOCK(procp);
-		error = textvp_fullpath(procp, &fullpath, &freepath);
-		if (error != 0)
-			return (uiomove("unknown", sizeof("unknown") - 1,
-			    ap->a_uio));
-		error = uiomove(fullpath, strlen(fullpath), ap->a_uio);
-		free(freepath, M_TEMP);
-		return (error);
-	default:
-		return (EINVAL);
-	}
-}
-
-/*
- * convert decimal ascii to pid_t
- */
-static pid_t
-atopid(b, len)
-	const char *b;
-	u_int len;
-{
-	pid_t p = 0;
-
-	while (len--) {
-		char c = *b++;
-		if (c < '0' || c > '9')
-			return (NO_PID);
-		p = 10 * p + (c - '0');
-		if (p > PID_MAX)
-			return (NO_PID);
-	}
-
-	return (p);
-}
-
-/*
- * procfs vnode operations.
- */
-vop_t **procfs_vnodeop_p;
-static struct vnodeopv_entry_desc procfs_vnodeop_entries[] = {
-	{ &vop_default_desc,		(vop_t *) vop_defaultop },
-	{ &vop_access_desc,		(vop_t *) procfs_access },
-	{ &vop_advlock_desc,		(vop_t *) procfs_badop },
-	{ &vop_close_desc,		(vop_t *) procfs_close },
-	{ &vop_create_desc,		(vop_t *) procfs_badop },
-	{ &vop_getattr_desc,		(vop_t *) procfs_getattr },
-	{ &vop_link_desc,		(vop_t *) procfs_badop },
-	{ &vop_lookup_desc,		(vop_t *) procfs_lookup },
-	{ &vop_mkdir_desc,		(vop_t *) procfs_badop },
-	{ &vop_mknod_desc,		(vop_t *) procfs_badop },
-	{ &vop_open_desc,		(vop_t *) procfs_open },
-	{ &vop_pathconf_desc,		(vop_t *) vop_stdpathconf },
-	{ &vop_print_desc,		(vop_t *) procfs_print },
-	{ &vop_read_desc,		(vop_t *) procfs_rw },
-	{ &vop_readdir_desc,		(vop_t *) procfs_readdir },
-	{ &vop_readlink_desc,		(vop_t *) procfs_readlink },
-	{ &vop_reclaim_desc,		(vop_t *) procfs_reclaim },
-	{ &vop_remove_desc,		(vop_t *) procfs_badop },
-	{ &vop_rename_desc,		(vop_t *) procfs_badop },
-	{ &vop_rmdir_desc,		(vop_t *) procfs_badop },
-	{ &vop_setattr_desc,		(vop_t *) procfs_setattr },
-	{ &vop_symlink_desc,		(vop_t *) procfs_badop },
-	{ &vop_write_desc,		(vop_t *) procfs_rw },
-	{ &vop_ioctl_desc,		(vop_t *) procfs_ioctl },
-	{ NULL, NULL }
-};
-static struct vnodeopv_desc procfs_vnodeop_opv_desc =
-	{ &procfs_vnodeop_p, procfs_vnodeop_entries };
-
-VNODEOP_SET(procfs_vnodeop_opv_desc);
diff --git a/sys/miscfs/specfs/spec_vnops.c b/sys/miscfs/specfs/spec_vnops.c
deleted file mode 100644
index ba81229..0000000
--- a/sys/miscfs/specfs/spec_vnops.c
+++ /dev/null
@@ -1,838 +0,0 @@
-/*
- * Copyright (c) 1989, 1993, 1995
- *	The Regents of the University of California.  All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)spec_vnops.c	8.14 (Berkeley) 5/21/95
- * $FreeBSD$
- */
-
-#include <sys/param.h>
-#include <sys/proc.h>
-#include <sys/systm.h>
-#include <sys/kernel.h>
-#include <sys/conf.h>
-#include <sys/bio.h>
-#include <sys/buf.h>
-#include <sys/mount.h>
-#include <sys/vnode.h>
-#include <sys/stat.h>
-#include <sys/fcntl.h>
-#include <sys/vmmeter.h>
-#include <sys/tty.h>
-
-#include <vm/vm.h>
-#include <vm/vm_object.h>
-#include <vm/vm_page.h>
-#include <vm/vm_pager.h>
-
-static int	spec_advlock __P((struct vop_advlock_args *));  
-static int	spec_bmap __P((struct vop_bmap_args *));
-static int	spec_close __P((struct vop_close_args *));
-static int	spec_freeblks __P((struct vop_freeblks_args *));
-static int	spec_fsync __P((struct  vop_fsync_args *));
-static int	spec_getpages __P((struct vop_getpages_args *));
-static int	spec_ioctl __P((struct vop_ioctl_args *));
-static int	spec_open __P((struct vop_open_args *));
-static int	spec_poll __P((struct vop_poll_args *));
-static int	spec_kqfilter __P((struct vop_kqfilter_args *));
-static int	spec_print __P((struct vop_print_args *));
-static int	spec_read __P((struct vop_read_args *));  
-static int	spec_strategy __P((struct vop_strategy_args *));
-static int	spec_write __P((struct vop_write_args *));
-
-vop_t **spec_vnodeop_p;
-static struct vnodeopv_entry_desc spec_vnodeop_entries[] = {
-	{ &vop_default_desc,		(vop_t *) vop_defaultop },
-	{ &vop_access_desc,		(vop_t *) vop_ebadf },
-	{ &vop_advlock_desc,		(vop_t *) spec_advlock },
-	{ &vop_bmap_desc,		(vop_t *) spec_bmap },
-	{ &vop_close_desc,		(vop_t *) spec_close },
-	{ &vop_create_desc,		(vop_t *) vop_panic },
-	{ &vop_freeblks_desc,		(vop_t *) spec_freeblks },
-	{ &vop_fsync_desc,		(vop_t *) spec_fsync },
-	{ &vop_getpages_desc,		(vop_t *) spec_getpages },
-	{ &vop_getwritemount_desc, 	(vop_t *) vop_stdgetwritemount },
-	{ &vop_ioctl_desc,		(vop_t *) spec_ioctl },
-	{ &vop_lease_desc,		(vop_t *) vop_null },
-	{ &vop_link_desc,		(vop_t *) vop_panic },
-	{ &vop_mkdir_desc,		(vop_t *) vop_panic },
-	{ &vop_mknod_desc,		(vop_t *) vop_panic },
-	{ &vop_open_desc,		(vop_t *) spec_open },
-	{ &vop_pathconf_desc,		(vop_t *) vop_stdpathconf },
-	{ &vop_poll_desc,		(vop_t *) spec_poll },
-	{ &vop_kqfilter_desc,		(vop_t *) spec_kqfilter },
-	{ &vop_print_desc,		(vop_t *) spec_print },
-	{ &vop_read_desc,		(vop_t *) spec_read },
-	{ &vop_readdir_desc,		(vop_t *) vop_panic },
-	{ &vop_readlink_desc,		(vop_t *) vop_panic },
-	{ &vop_reallocblks_desc,	(vop_t *) vop_panic },
-	{ &vop_reclaim_desc,		(vop_t *) vop_null },
-	{ &vop_remove_desc,		(vop_t *) vop_panic },
-	{ &vop_rename_desc,		(vop_t *) vop_panic },
-	{ &vop_rmdir_desc,		(vop_t *) vop_panic },
-	{ &vop_setattr_desc,		(vop_t *) vop_ebadf },
-	{ &vop_strategy_desc,		(vop_t *) spec_strategy },
-	{ &vop_symlink_desc,		(vop_t *) vop_panic },
-	{ &vop_write_desc,		(vop_t *) spec_write },
-	{ NULL, NULL }
-};
-static struct vnodeopv_desc spec_vnodeop_opv_desc =
-	{ &spec_vnodeop_p, spec_vnodeop_entries };
-
-VNODEOP_SET(spec_vnodeop_opv_desc);
-
-int
-spec_vnoperate(ap)
-	struct vop_generic_args /* {
-		struct vnodeop_desc *a_desc;
-		<other random data follows, presumably>
-	} */ *ap;
-{
-	return (VOCALL(spec_vnodeop_p, ap->a_desc->vdesc_offset, ap));
-}
-
-static void spec_getpages_iodone __P((struct buf *bp));
-
-/*
- * Open a special file.
- */
-/* ARGSUSED */
-static int
-spec_open(ap)
-	struct vop_open_args /* {
-		struct vnode *a_vp;
-		int  a_mode;
-		struct ucred *a_cred;
-		struct proc *a_p;
-	} */ *ap;
-{
-	struct proc *p = ap->a_p;
-	struct vnode *vp = ap->a_vp;
-	dev_t dev = vp->v_rdev;
-	int error;
-	struct cdevsw *dsw;
-	const char *cp;
-
-	if (vp->v_type == VBLK) 
-		return ENXIO;
-	/*
-	 * Don't allow open if fs is mounted -nodev.
-	 */
-	if (vp->v_mount && (vp->v_mount->mnt_flag & MNT_NODEV))
-		return (ENXIO);
-
-	dsw = devsw(dev);
-	if ( (dsw == NULL) || (dsw->d_open == NULL))
-		return ENXIO;
-
-	/* Make this field valid before any I/O in ->d_open */
-	if (!dev->si_iosize_max)
-		dev->si_iosize_max = DFLTPHYS;
-
-	/*
-	 * XXX: Disks get special billing here, but it is mostly wrong.
-	 * XXX: diskpartitions can overlap and the real checks should
-	 * XXX: take this into account, and consequently they need to
-	 * XXX: live in the diskslicing code.  Some checks do.
-	 */
-	if (vn_isdisk(vp, NULL) && ap->a_cred != FSCRED && 
-	    (ap->a_mode & FWRITE)) {
-		/*
-		 * Never allow opens for write if the device is mounted R/W
-		 */
-		if (vp->v_rdev->si_mountpoint != NULL &&
-		    !(vp->v_rdev->si_mountpoint->mnt_flag & MNT_RDONLY))
-				return (EBUSY);
-
-		/*
-		 * When running in secure mode, do not allow opens
-		 * for writing if the device is mounted
-		 */
-		if (securelevel >= 1 && vfs_mountedon(vp))
-			return (EPERM);
-
-		/*
-		 * When running in very secure mode, do not allow
-		 * opens for writing of any devices.
-		 */
-		if (securelevel >= 2)
-			return (EPERM);
-	}
-
-	/* XXX: Special casing of ttys for deadfs.  Probably redundant */
-	if (dsw->d_flags & D_TTY)
-		vp->v_flag |= VISTTY;
-
-	VOP_UNLOCK(vp, 0, p);
-	error = (*dsw->d_open)(dev, ap->a_mode, S_IFCHR, p);
-	vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
-
-	if (error)
-		return (error);
-
-	if (dsw->d_flags & D_TTY) {
-		if (dev->si_tty) {
-			struct tty *tp;
-			tp = dev->si_tty;
-			if (!tp->t_stop) {
-				printf("Warning:%s: no t_stop, using nottystop\n", devtoname(dev));
-				tp->t_stop = nottystop;
-			}
-		}
-	}
-
-	if (vn_isdisk(vp, NULL)) {
-		if (!dev->si_bsize_phys)
-			dev->si_bsize_phys = DEV_BSIZE;
-	}
-	if ((dsw->d_flags & D_DISK) == 0) {
-		cp = devtoname(dev);
-		if (*cp == '#' && (dsw->d_flags & D_NAGGED) == 0) {
-			printf("WARNING: driver %s should register devices with make_dev() (dev_t = \"%s\")\n",
-			    dsw->d_name, cp);
-			dsw->d_flags |= D_NAGGED;	
-		}
-	}
-	return (error);
-}
-
-/*
- * Vnode op for read
- */
-/* ARGSUSED */
-static int
-spec_read(ap)
-	struct vop_read_args /* {
-		struct vnode *a_vp;
-		struct uio *a_uio;
-		int a_ioflag;
-		struct ucred *a_cred;
-	} */ *ap;
-{
-	struct vnode *vp;
-	struct proc *p;
-	struct uio *uio;
-	dev_t dev;
-	int error, resid;
-
-	vp = ap->a_vp;
-	dev = vp->v_rdev;
-	uio = ap->a_uio;
-	p = uio->uio_procp;
-	resid = uio->uio_resid;
-
-	if (resid == 0)
-		return (0);
-
-	VOP_UNLOCK(vp, 0, p);
-	error = (*devsw(dev)->d_read) (dev, uio, ap->a_ioflag);
-	vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
-	if (uio->uio_resid != resid || (error == 0 && resid != 0))
-		getnanotime(&dev->si_atime);
-	return (error);
-}
-
-/*
- * Vnode op for write
- */
-/* ARGSUSED */
-static int
-spec_write(ap)
-	struct vop_write_args /* {
-		struct vnode *a_vp;
-		struct uio *a_uio;
-		int a_ioflag;
-		struct ucred *a_cred;
-	} */ *ap;
-{
-	struct vnode *vp;
-	struct proc *p;
-	struct uio *uio;
-	dev_t dev;
-	int error, resid;
-
-	vp = ap->a_vp;
-	dev = vp->v_rdev;
-	uio = ap->a_uio;
-	p = uio->uio_procp;
-	resid = uio->uio_resid;
-
-	VOP_UNLOCK(vp, 0, p);
-	error = (*devsw(dev)->d_write) (dev, uio, ap->a_ioflag);
-	vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
-	if (uio->uio_resid != resid || (error == 0 && resid != 0)) {
-		getnanotime(&dev->si_ctime);
-		dev->si_mtime = dev->si_ctime;
-	}
-	return (error);
-}
-
-/*
- * Device ioctl operation.
- */
-/* ARGSUSED */
-static int
-spec_ioctl(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;
-	} */ *ap;
-{
-	dev_t dev;
-
-	dev = ap->a_vp->v_rdev;
-	return ((*devsw(dev)->d_ioctl)(dev, ap->a_command, 
-	    ap->a_data, ap->a_fflag, ap->a_p));
-}
-
-/* ARGSUSED */
-static int
-spec_poll(ap)
-	struct vop_poll_args /* {
-		struct vnode *a_vp;
-		int  a_events;
-		struct ucred *a_cred;
-		struct proc *a_p;
-	} */ *ap;
-{
-	dev_t dev;
-
-	dev = ap->a_vp->v_rdev;
-	return (*devsw(dev)->d_poll)(dev, ap->a_events, ap->a_p);
-}
-
-/* ARGSUSED */
-static int
-spec_kqfilter(ap)
-	struct vop_kqfilter_args /* {
-		struct vnode *a_vp;
-		struct knote *a_kn;
-	} */ *ap;
-{
-	dev_t dev;
-
-	dev = ap->a_vp->v_rdev;
-	if (devsw(dev)->d_flags & D_KQFILTER)
-		return (*devsw(dev)->d_kqfilter)(dev, ap->a_kn);
-	return (1);
-}
-
-/*
- * Synch buffers associated with a block device
- */
-/* ARGSUSED */
-static int
-spec_fsync(ap)
-	struct vop_fsync_args /* {
-		struct vnode *a_vp;
-		struct ucred *a_cred;
-		int  a_waitfor;
-		struct proc *a_p;
-	} */ *ap;
-{
-	struct vnode *vp = ap->a_vp;
-	struct buf *bp;
-	struct buf *nbp;
-	int s;
-	int maxretry = 10000;	/* large, arbitrarily chosen */
-
-	if (!vn_isdisk(vp, NULL))
-		return (0);
-
-loop1:
-	/*
-	 * MARK/SCAN initialization to avoid infinite loops
-	 */
-	s = splbio();
-        TAILQ_FOREACH(bp, &vp->v_dirtyblkhd, b_vnbufs) {
-                bp->b_flags &= ~B_SCANNED;
-	}
-	splx(s);
-
-	/*
-	 * Flush all dirty buffers associated with a block device.
-	 */
-loop2:
-	s = splbio();
-	for (bp = TAILQ_FIRST(&vp->v_dirtyblkhd); bp; bp = nbp) {
-		nbp = TAILQ_NEXT(bp, b_vnbufs);
-		if ((bp->b_flags & B_SCANNED) != 0)
-			continue;
-		bp->b_flags |= B_SCANNED;
-		if (BUF_LOCK(bp, LK_EXCLUSIVE | LK_NOWAIT))
-			continue;
-		if ((bp->b_flags & B_DELWRI) == 0)
-			panic("spec_fsync: not dirty");
-		if ((vp->v_flag & VOBJBUF) && (bp->b_flags & B_CLUSTEROK)) {
-			BUF_UNLOCK(bp);
-			vfs_bio_awrite(bp);
-			splx(s);
-		} else {
-			bremfree(bp);
-			splx(s);
-			bawrite(bp);
-		}
-		goto loop2;
-	}
-
-	/*
-	 * If synchronous the caller expects us to completely resolve all
-	 * dirty buffers in the system.  Wait for in-progress I/O to
-	 * complete (which could include background bitmap writes), then
-	 * retry if dirty blocks still exist.
-	 */
-	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);
-		}
-		if (!TAILQ_EMPTY(&vp->v_dirtyblkhd)) {
-			if (--maxretry != 0) {
-				splx(s);
-				goto loop1;
-			}
-			vprint("spec_fsync: giving up on dirty", vp);
-		}
-	}
-	splx(s);
-	return (0);
-}
-
-/*
- * Just call the device strategy routine
- */
-static int
-spec_strategy(ap)
-	struct vop_strategy_args /* {
-		struct vnode *a_vp;
-		struct buf *a_bp;
-	} */ *ap;
-{
-	struct buf *bp;
-	struct vnode *vp;
-	struct mount *mp;
-	int error;
-
-	bp = ap->a_bp;
-	vp = ap->a_vp;
-	if ((bp->b_iocmd == BIO_WRITE)) {
-		if ((bp->b_flags & B_VALIDSUSPWRT) == 0 &&
-		    bp->b_vp != NULL && bp->b_vp->v_mount != NULL &&
-		    (bp->b_vp->v_mount->mnt_kern_flag & MNTK_SUSPENDED) != 0)
-			panic("spec_strategy: bad I/O");
-		bp->b_flags &= ~B_VALIDSUSPWRT;
-		if (LIST_FIRST(&bp->b_dep) != NULL)
-			buf_start(bp);
-		if ((vp->v_flag & VCOPYONWRITE) && vp->v_rdev->si_copyonwrite &&
-		    (error = (*vp->v_rdev->si_copyonwrite)(vp, bp)) != 0 &&
-		    error != EOPNOTSUPP) {
-			bp->b_io.bio_error = error;
-			bp->b_io.bio_flags |= BIO_ERROR;
-			biodone(&bp->b_io);
-			return (0);
-		}
-	}
-	/*
-	 * Collect statistics on synchronous and asynchronous read
-	 * and write counts for disks that have associated filesystems.
-	 */
-	if (vn_isdisk(vp, NULL) && (mp = vp->v_rdev->si_mountpoint) != NULL) {
-		if (bp->b_iocmd == BIO_WRITE) {
-			if (bp->b_lock.lk_lockholder == LK_KERNPROC)
-				mp->mnt_stat.f_asyncwrites++;
-			else
-				mp->mnt_stat.f_syncwrites++;
-		} else {
-			if (bp->b_lock.lk_lockholder == LK_KERNPROC)
-				mp->mnt_stat.f_asyncreads++;
-			else
-				mp->mnt_stat.f_syncreads++;
-		}
-	}
-	KASSERT(devsw(bp->b_dev) != NULL, 
-	   ("No devsw on dev %s responsible for buffer %p\n", 
-	   devtoname(bp->b_dev), bp));
-	KASSERT(devsw(bp->b_dev)->d_strategy != NULL, 
-	   ("No strategy on dev %s responsible for buffer %p\n", 
-	   devtoname(bp->b_dev), bp));
-	DEV_STRATEGY(bp, 0);
-	return (0);
-}
-
-static int
-spec_freeblks(ap)
-	struct vop_freeblks_args /* {
-		struct vnode *a_vp;
-		daddr_t a_addr;
-		daddr_t a_length;
-	} */ *ap;
-{
-	struct cdevsw *bsw;
-	struct buf *bp;
-
-	/*
-	 * XXX: This assumes that strategy does the deed right away.
-	 * XXX: this may not be TRTTD.
-	 */
-	bsw = devsw(ap->a_vp->v_rdev);
-	if ((bsw->d_flags & D_CANFREE) == 0)
-		return (0);
-	bp = geteblk(ap->a_length);
-	bp->b_iocmd = BIO_DELETE;
-	bp->b_dev = ap->a_vp->v_rdev;
-	bp->b_blkno = ap->a_addr;
-	bp->b_offset = dbtob(ap->a_addr);
-	bp->b_bcount = ap->a_length;
-	BUF_KERNPROC(bp);
-	DEV_STRATEGY(bp, 0);
-	return (0);
-}
-
-/*
- * Implement degenerate case where the block requested is the block
- * returned, and assume that the entire device is contiguous in regards
- * to the contiguous block range (runp and runb).
- */
-static int
-spec_bmap(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;
-	} */ *ap;
-{
-	struct vnode *vp = ap->a_vp;
-	int runp = 0;
-	int runb = 0;
-
-	if (ap->a_vpp != NULL)
-		*ap->a_vpp = vp;
-	if (ap->a_bnp != NULL)
-		*ap->a_bnp = ap->a_bn;
-	if (vp->v_mount != NULL)
-		runp = runb = MAXBSIZE / vp->v_mount->mnt_stat.f_iosize;
-	if (ap->a_runp != NULL)
-		*ap->a_runp = runp;
-	if (ap->a_runb != NULL)
-		*ap->a_runb = runb;
-	return (0);
-}
-
-/*
- * Device close routine
- */
-/* ARGSUSED */
-static int
-spec_close(ap)
-	struct vop_close_args /* {
-		struct vnode *a_vp;
-		int  a_fflag;
-		struct ucred *a_cred;
-		struct proc *a_p;
-	} */ *ap;
-{
-	struct vnode *vp = ap->a_vp;
-	struct proc *p = ap->a_p;
-	dev_t dev = vp->v_rdev;
-
-	/*
-	 * 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 && p && (vp->v_flag & VXLOCK) == 0 &&
-	    vp == p->p_session->s_ttyvp) {
-		vrele(vp);
-		p->p_session->s_ttyvp = NULL;
-	}
-	/*
-	 * 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 (vp->v_flag & VXLOCK) {
-		/* Forced close */
-	} else if (devsw(dev)->d_flags & D_TRACKCLOSE) {
-		/* Keep device updated on status */
-	} else if (vcount(vp) > 1) {
-		return (0);
-	}
-	return (devsw(dev)->d_close(dev, ap->a_fflag, S_IFCHR, p));
-}
-
-/*
- * Print out the contents of a special device vnode.
- */
-static int
-spec_print(ap)
-	struct vop_print_args /* {
-		struct vnode *a_vp;
-	} */ *ap;
-{
-
-	printf("tag VT_NON, dev %s\n", devtoname(ap->a_vp->v_rdev));
-	return (0);
-}
-
-/*
- * Special device advisory byte-level locks.
- */
-/* ARGSUSED */
-static int
-spec_advlock(ap)
-	struct vop_advlock_args /* {
-		struct vnode *a_vp;
-		caddr_t  a_id;
-		int  a_op;
-		struct flock *a_fl;
-		int  a_flags;
-	} */ *ap;
-{
-
-	return (ap->a_flags & F_FLOCK ? EOPNOTSUPP : EINVAL);
-}
-
-static void
-spec_getpages_iodone(bp)
-	struct buf *bp;
-{
-
-	bp->b_flags |= B_DONE;
-	wakeup(bp);
-}
-
-static int
-spec_getpages(ap)
-	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 and do sanity check.
-	 * FreeBSD currently only supports an 8 TB range due to b_blkno
-	 * being in DEV_BSIZE ( usually 512 ) byte chunks on call to
-	 * VOP_STRATEGY.  XXX
-	 */
-	offset = IDX_TO_OFF(ap->a_m[0]->pindex) + ap->a_offset;
-
-#define	DADDR_T_BIT	(sizeof(daddr_t)*8)
-#define	OFFSET_MAX	((1LL << (DADDR_T_BIT + DEV_BSHIFT)) - 1)
-
-	if (offset < 0 || offset > OFFSET_MAX) {
-		/* XXX still no %q in kernel. */
-		printf("spec_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.  We cannot round using
-	 * v_mount's block size data because v_mount has nothing to do with
-	 * the device.  i.e. it's usually '/dev'.  We need the physical block
-	 * size for the device itself.
-	 *
-	 * We can't use v_rdev->si_mountpoint because it only exists when the
-	 * block device is mounted.  However, we can use v_rdev.
-	 */
-
-	if (vn_isdisk(vp, NULL))
-		blksiz = vp->v_rdev->si_bsize_phys;
-	else
-		blksiz = DEV_BSIZE;
-
-	size = (ap->a_count + blksiz - 1) & ~(blksiz - 1);
-
-	bp = getpbuf(NULL);
-	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_iocmd = BIO_READ;
-	bp->b_iodone = spec_getpages_iodone;
-
-	/* B_PHYS is not set, but it is nice to fill this in. */
-	bp->b_rcred = bp->b_wcred = curproc->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;
-	bp->b_runningbufspace = bp->b_bufsize;
-	runningbufspace += bp->b_runningbufspace;
-
-	cnt.v_vnodein++;
-	cnt.v_vnodepgsin += pcount;
-
-	mtx_unlock(&vm_mtx);
-	mtx_lock(&Giant);
-	/* Do the input. */
-	BUF_STRATEGY(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);
-	mtx_unlock(&Giant);
-	mtx_lock(&vm_mtx);
-
-	if ((bp->b_ioflags & BIO_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;
-			vm_page_undirty(m);
-		} else if (toff < nread) {
-			/*
-			 * Since this is a VM request, we have to supply the
-			 * unaligned offset to allow vm_page_set_validclean()
-			 * to zero sub-DEV_BSIZE'd portions of the page.
-			 */
-			vm_page_set_validclean(m, 0, nread - toff);
-		} else {
-			m->valid = 0;
-			vm_page_undirty(m);
-		}
-
-		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);
-					}
-					vm_page_wakeup(m);
-				} else {
-					vm_page_free(m);
-				}
-			} else {
-				vm_page_free(m);
-			}
-		} else if (m->valid) {
-			gotreqpage = 1;
-			/*
-			 * Since this is a VM request, we need to make the
-			 * entire page presentable by zeroing invalid sections.
-			 */
-			if (m->valid != VM_PAGE_BITS_ALL)
-			    vm_page_zero_invalid(m, FALSE);
-		}
-	}
-	if (!gotreqpage) {
-		m = ap->a_m[ap->a_reqpage];
-		printf(
-	    "spec_getpages:(%s) I/O read failure: (error=%d) bp %p vp %p\n",
-			devtoname(bp->b_dev), error, bp, bp->b_vp);
-		printf(
-	    "               size: %d, resid: %ld, a_count: %d, valid: 0x%x\n",
-		    size, bp->b_resid, ap->a_count, m->valid);
-		printf(
-	    "               nread: %d, reqpage: %d, pindex: %lu, pcount: %d\n",
-		    nread, ap->a_reqpage, (u_long)m->pindex, pcount);
-		/*
-		 * Free the buffer header back to the swap buffer pool.
-		 */
-		relpbuf(bp, NULL);
-		return VM_PAGER_ERROR;
-	}
-	/*
-	 * Free the buffer header back to the swap buffer pool.
-	 */
-	relpbuf(bp, NULL);
-	return VM_PAGER_OK;
-}
diff --git a/sys/miscfs/umapfs/umap.h b/sys/miscfs/umapfs/umap.h
deleted file mode 100644
index eb562ed..0000000
--- a/sys/miscfs/umapfs/umap.h
+++ /dev/null
@@ -1,91 +0,0 @@
-/*
- * Copyright (c) 1992, 1993
- *	The Regents of the University of California.  All rights reserved.
- *
- * This code is derived from software donated to Berkeley by
- * the UCLA Ficus project.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)umap.h	8.4 (Berkeley) 8/20/94
- *
- * $FreeBSD$
- */
-
-#define MAPFILEENTRIES 64
-#define GMAPFILEENTRIES 16
-#define NOBODY 32767
-#define NULLGROUP 65534
-
-struct umap_args {
-	char		*target;	/* Target of loopback  */
-	int 		nentries;       /* # of entries in user map array */
-	int 		gnentries;	/* # of entries in group map array */
-	u_long 		(*mapdata)[2];	/* pointer to array of user mappings */
-	u_long 		(*gmapdata)[2];	/* pointer to array of group mappings */
-};
-
-struct umap_mount {
-	struct mount	*umapm_vfs;
-	struct vnode	*umapm_rootvp;	/* Reference to root umap_node */
-	int             info_nentries;  /* number of uid mappings */
-	int		info_gnentries;	/* number of gid mappings */
-	u_long		info_mapdata[MAPFILEENTRIES][2]; /* mapping data for
-	    user mapping in ficus */
-	u_long		info_gmapdata[GMAPFILEENTRIES][2]; /*mapping data for
-	    group mapping in ficus */
-};
-
-#ifdef _KERNEL
-/*
- * A cache of vnode references
- */
-struct umap_node {
-	LIST_ENTRY(umap_node) umap_hash;	/* Hash list */
-	struct vnode	*umap_lowervp;	/* Aliased vnode - VREFed once */
-	struct vnode	*umap_vnode;	/* Back pointer to vnode/umap_node */
-};
-
-extern int umapfs_init __P((struct vfsconf *vfsp));
-extern int umap_node_create __P((struct mount *mp, struct vnode *target, struct vnode **vpp));
-extern u_long umap_reverse_findid __P((u_long id, u_long map[][2], int nentries));
-extern void umap_mapids __P((struct mount *v_mount, struct ucred *credp));
-
-#define	MOUNTTOUMAPMOUNT(mp) ((struct umap_mount *)((mp)->mnt_data))
-#define	VTOUMAP(vp) ((struct umap_node *)(vp)->v_data)
-#define UMAPTOV(xp) ((xp)->umap_vnode)
-#ifdef DIAGNOSTIC
-extern struct vnode *umap_checkvp __P((struct vnode *vp, char *fil, int lno));
-#define	UMAPVPTOLOWERVP(vp) umap_checkvp((vp), __FILE__, __LINE__)
-#else
-#define	UMAPVPTOLOWERVP(vp) (VTOUMAP(vp)->umap_lowervp)
-#endif
-
-extern vop_t **umap_vnodeop_p;
-#endif /* _KERNEL */
diff --git a/sys/miscfs/umapfs/umap_subr.c b/sys/miscfs/umapfs/umap_subr.c
deleted file mode 100644
index 1f94d50..0000000
--- a/sys/miscfs/umapfs/umap_subr.c
+++ /dev/null
@@ -1,405 +0,0 @@
-/*
- * Copyright (c) 1992, 1993, 1995
- *	The Regents of the University of California.  All rights reserved.
- *
- * This code is derived from software donated to Berkeley by
- * Jan-Simon Pendry.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)umap_subr.c	8.9 (Berkeley) 5/14/95
- *
- * $FreeBSD$
- */
-
-#include <sys/param.h>
-#include <sys/systm.h>
-#include <sys/malloc.h>
-#include <sys/mount.h>
-#include <sys/proc.h>
-#include <sys/vnode.h>
-
-#include <miscfs/umapfs/umap.h>
-
-#define LOG2_SIZEVNODE 7		/* log2(sizeof struct vnode) */
-#define	NUMAPNODECACHE 16
-
-/*
- * Null layer cache:
- * Each cache entry holds a reference to the target vnode
- * along with a pointer to the alias vnode.  When an
- * entry is added the target vnode is VREF'd.  When the
- * alias is removed the target vnode is vrele'd.
- */
-
-#define	UMAP_NHASH(vp) \
-	(&umap_node_hashtbl \
-	[((uintptr_t)(void *)(vp) >> LOG2_SIZEVNODE) & umap_node_hash])
-static LIST_HEAD(umap_node_hashhead, umap_node) *umap_node_hashtbl;
-static u_long umap_node_hash;
-
-static u_long	umap_findid __P((u_long id, u_long map[][2], int nentries));
-static int	umap_node_alloc __P((struct mount *mp, struct vnode *lowervp,
-				     struct vnode **vpp));
-static struct vnode *
-		umap_node_find __P((struct mount *mp, struct vnode *targetvp));
-
-/*
- * Initialise cache headers
- */
-int
-umapfs_init(vfsp)
-	struct vfsconf *vfsp;
-{
-
-#ifdef DEBUG
-	printf("umapfs_init\n");		/* printed during system boot */
-#endif
-	umap_node_hashtbl = hashinit(NUMAPNODECACHE, M_CACHE, &umap_node_hash);
-	return (0);
-}
-
-/*
- * umap_findid is called by various routines in umap_vnodeops.c to
- * find a user or group id in a map.
- */
-static u_long
-umap_findid(id, map, nentries)
-	u_long id;
-	u_long map[][2];
-	int nentries;
-{
-	int i;
-
-	/* Find uid entry in map */
-	i = 0;
-	while ((i<nentries) && ((map[i][0]) != id))
-		i++;
-
-	if (i < nentries)
-		return (map[i][1]);
-	else
-		return (-1);
-
-}
-
-/*
- * umap_reverse_findid is called by umap_getattr() in umap_vnodeops.c to
- * find a user or group id in a map, in reverse.
- */
-u_long
-umap_reverse_findid(id, map, nentries)
-	u_long id;
-	u_long map[][2];
-	int nentries;
-{
-	int i;
-
-	/* Find uid entry in map */
-	i = 0;
-	while ((i<nentries) && ((map[i][1]) != id))
-		i++;
-
-	if (i < nentries)
-		return (map[i][0]);
-	else
-		return (-1);
-
-}
-
-/*
- * Return alias for target vnode if already exists, else 0.
- */
-static struct vnode *
-umap_node_find(mp, targetvp)
-	struct mount *mp;
-	struct vnode *targetvp;
-{
-	struct proc *p = curproc;		/* XXX */
-	struct umap_node_hashhead *hd;
-	struct umap_node *a;
-	struct vnode *vp;
-
-#ifdef DEBUG
-	printf("umap_node_find(mp = %p, target = %p)\n",
-	    (void *)mp, (void *)targetvp);
-#endif
-
-	/*
-	 * Find hash base, and then search the (two-way) linked
-	 * list looking for a umap_node structure which is referencing
-	 * the target vnode.  If found, the increment the umap_node
-	 * reference count (but NOT the target vnode's VREF counter).
-	 */
-	hd = UMAP_NHASH(targetvp);
-loop:
-	LIST_FOREACH(a, hd, umap_hash) {
-		if (a->umap_lowervp == targetvp &&
-		    a->umap_vnode->v_mount == mp) {
-			vp = UMAPTOV(a);
-			/*
-			 * We need vget for the VXLOCK
-			 * stuff, but we don't want to lock
-			 * the lower node.
-			 */
-			if (vget(vp, 0, p)) {
-#ifdef DEBUG
-				printf ("umap_node_find: vget failed.\n");
-#endif
-				goto loop;
-			}
-			return (vp);
-		}
-	}
-
-#ifdef DEBUG
-	printf("umap_node_find(%p, %p): NOT found\n",
-	    (void *)mp, (void *)targetvp);
-#endif
-
-	return (0);
-}
-
-/*
- * Make a new umap_node node.
- * Vp is the alias vnode, lofsvp is the target vnode.
- * Maintain a reference to (targetvp).
- */
-static int
-umap_node_alloc(mp, lowervp, vpp)
-	struct mount *mp;
-	struct vnode *lowervp;
-	struct vnode **vpp;
-{
-	struct umap_node_hashhead *hd;
-	struct umap_node *xp;
-	struct vnode *othervp, *vp;
-	int error;
-
-	/* XXX This routine probably needs a node_alloc lock */
-
-	/*
-	 * Do the MALLOC before the getnewvnode since doing so afterward
-	 * might cause a bogus v_data pointer to get dereferenced
-	 * elsewhere if MALLOC should block.
-	 */
-	MALLOC(xp, struct umap_node *, sizeof(struct umap_node),
-	    M_TEMP, M_WAITOK);
-
-	error = getnewvnode(VT_UMAP, mp, umap_vnodeop_p, vpp);
-	if (error) {
-		FREE(xp, M_TEMP);
-		return (error);
-	}
-	vp = *vpp;
-
-	vp->v_type = lowervp->v_type;
-	xp->umap_vnode = vp;
-	vp->v_data = xp;
-	xp->umap_lowervp = lowervp;
-	/*
-	 * Before we insert our new node onto the hash chains,
-	 * check to see if someone else has beaten us to it.
-	 * (We could have slept in MALLOC.)
-	 */
-	othervp = umap_node_find(mp, lowervp);
-	if (othervp) {
-		FREE(xp, M_TEMP);
-		vp->v_type = VBAD;	/* node is discarded */
-		vp->v_usecount = 0;	/* XXX */
-		*vpp = othervp;
-		return (0);
-	}
-	VREF(lowervp);   /* Extra VREF will be vrele'd in umap_node_create */
-	hd = UMAP_NHASH(lowervp);
-	LIST_INSERT_HEAD(hd, xp, umap_hash);
-	return (0);
-}
-
-
-/*
- * Try to find an existing umap_node vnode refering
- * to it, otherwise make a new umap_node vnode which
- * contains a reference to the target vnode.
- */
-int
-umap_node_create(mp, targetvp, newvpp)
-	struct mount *mp;
-	struct vnode *targetvp;
-	struct vnode **newvpp;
-{
-	struct vnode *aliasvp;
-
-	aliasvp = umap_node_find(mp, targetvp);
-	if (aliasvp) {
-		/*
-		 * Take another reference to the alias vnode
-		 */
-#ifdef DEBUG
-		vprint("umap_node_create: exists", aliasvp);
-#endif
-		/* VREF(aliasvp); */
-	} else {
-		int error;
-
-		/*
-		 * Get new vnode.
-		 */
-#ifdef DEBUG
-		printf("umap_node_create: create new alias vnode\n");
-#endif
-		/*
-		 * Make new vnode reference the umap_node.
-		 */
-		error = umap_node_alloc(mp, targetvp, &aliasvp);
-		if (error)
-			return (error);
-
-		/*
-		 * aliasvp is already VREF'd by getnewvnode()
-		 */
-	}
-
-	vrele(targetvp);
-
-#ifdef DEBUG
-	vprint("umap_node_create: alias", aliasvp);
-	vprint("umap_node_create: target", targetvp);
-#endif
-
-	*newvpp = aliasvp;
-	return (0);
-}
-
-#ifdef DIAGNOSTIC
-int umap_checkvp_barrier = 1;
-struct vnode *
-umap_checkvp(vp, fil, lno)
-	struct vnode *vp;
-	char *fil;
-	int lno;
-{
-	struct umap_node *a = VTOUMAP(vp);
-#if 0
-	/*
-	 * Can't do this check because vop_reclaim runs
-	 * with funny vop vector.
-	 */
-	if (vp->v_op != umap_vnodeop_p) {
-		printf ("umap_checkvp: on non-umap-node\n");
-		while (umap_checkvp_barrier) /*WAIT*/ ;
-		panic("umap_checkvp");
-	}
-#endif
-	if (a->umap_lowervp == NULL) {
-		/* Should never happen */
-		int i; u_long *p;
-		printf("vp = %p, ZERO ptr\n", (void *)vp);
-		for (p = (u_long *) a, i = 0; i < 8; i++)
-			printf(" %p", (void *)p[i]);
-		printf("\n");
-		/* wait for debugger */
-		while (umap_checkvp_barrier) /*WAIT*/ ;
-		panic("umap_checkvp");
-	}
-	if (a->umap_lowervp->v_usecount < 1) {
-		int i; u_long *p;
-		printf("vp = %p, unref'ed lowervp\n", (void *)vp);
-		for (p = (u_long *) a, i = 0; i < 8; i++)
-			printf(" %p", (void *)p[i]);
-		printf("\n");
-		/* wait for debugger */
-		while (umap_checkvp_barrier) /*WAIT*/ ;
-		panic ("umap with unref'ed lowervp");
-	}
-#if 0
-	printf("umap %x/%d -> %x/%d [%s, %d]\n",
-	        a->umap_vnode, a->umap_vnode->v_usecount,
-		a->umap_lowervp, a->umap_lowervp->v_usecount,
-		fil, lno);
-#endif
-	return (a->umap_lowervp);
-}
-#endif /* DIAGNOSTIC */
-
-/* umap_mapids maps all of the ids in a credential, both user and group. */
-
-void
-umap_mapids(v_mount, credp)
-	struct mount *v_mount;
-	struct ucred *credp;
-{
-	int i;
-	uid_t uid;
-	gid_t gid;
-
-	if (credp == NOCRED)
-		return;
-
-	/* Find uid entry in map */
-
-	uid = (uid_t) umap_findid(credp->cr_uid,
-				MOUNTTOUMAPMOUNT(v_mount)->info_mapdata,
-				MOUNTTOUMAPMOUNT(v_mount)->info_nentries);
-
-	if (uid != -1)
-		credp->cr_uid = uid;
-	else
-		credp->cr_uid = (uid_t) NOBODY;
-
-#ifdef notdef
-	/* cr_gid is the same as cr_groups[0] in 4BSD */
-
-	/* Find gid entry in map */
-
-	gid = (gid_t) umap_findid(credp->cr_gid,
-				MOUNTTOUMAPMOUNT(v_mount)->info_gmapdata,
-				MOUNTTOUMAPMOUNT(v_mount)->info_gnentries);
-
-	if (gid != -1)
-		credp->cr_gid = gid;
-	else
-		credp->cr_gid = NULLGROUP;
-#endif
-
-	/* Now we must map each of the set of groups in the cr_groups
-		structure. */
-
-	i = 0;
-	while (credp->cr_groups[i] != 0) {
-		gid = (gid_t) umap_findid(credp->cr_groups[i],
-				MOUNTTOUMAPMOUNT(v_mount)->info_gmapdata,
-				MOUNTTOUMAPMOUNT(v_mount)->info_gnentries);
-
-		if (gid != -1)
-			credp->cr_groups[i++] = gid;
-		else
-			credp->cr_groups[i++] = NULLGROUP;
-	}
-}
diff --git a/sys/miscfs/umapfs/umap_vfsops.c b/sys/miscfs/umapfs/umap_vfsops.c
deleted file mode 100644
index 280ded9..0000000
--- a/sys/miscfs/umapfs/umap_vfsops.c
+++ /dev/null
@@ -1,454 +0,0 @@
-/*
- * Copyright (c) 1992, 1993, 1995
- *	The Regents of the University of California.  All rights reserved.
- *
- * This code is derived from software donated to Berkeley by
- * the UCLA Ficus project.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)umap_vfsops.c	8.8 (Berkeley) 5/14/95
- *
- * $FreeBSD$
- */
-
-/*
- * Umap Layer
- * (See mount_umap(8) for a description of this layer.)
- */
-
-#include <sys/param.h>
-#include <sys/systm.h>
-#include <sys/kernel.h>
-#include <sys/lock.h>
-#include <sys/malloc.h>
-#include <sys/mount.h>
-#include <sys/mutex.h>
-#include <sys/namei.h>
-#include <sys/vnode.h>
-
-#include <miscfs/umapfs/umap.h>
-
-static MALLOC_DEFINE(M_UMAPFSMNT, "UMAP mount", "UMAP mount structure");
-
-static int	umapfs_fhtovp __P((struct mount *mp, struct fid *fidp,
-				   struct vnode **vpp));
-static int	umapfs_checkexp __P((struct mount *mp, struct sockaddr *nam,
-				    int *extflagsp, struct ucred **credanonp));
-static int	umapfs_mount __P((struct mount *mp, char *path, caddr_t data,
-				  struct nameidata *ndp, struct proc *p));
-static int	umapfs_quotactl __P((struct mount *mp, int cmd, uid_t uid,
-				     caddr_t arg, struct proc *p));
-static int	umapfs_root __P((struct mount *mp, struct vnode **vpp));
-static int	umapfs_start __P((struct mount *mp, int flags, struct proc *p));
-static int	umapfs_statfs __P((struct mount *mp, struct statfs *sbp,
-				   struct proc *p));
-static int	umapfs_sync __P((struct mount *mp, int waitfor,
-				 struct ucred *cred, struct proc *p));
-static int	umapfs_unmount __P((struct mount *mp, int mntflags,
-				    struct proc *p));
-static int	umapfs_vget __P((struct mount *mp, ino_t ino,
-				 struct vnode **vpp));
-static int	umapfs_vptofh __P((struct vnode *vp, struct fid *fhp));
-static int	umapfs_extattrctl __P((struct mount *mp, int cmd,
-				       struct vnode *filename_vp,
-				       int namespace, const char *attrname,
-				       struct proc *p));
-
-/*
- * Mount umap layer
- */
-static int
-umapfs_mount(mp, path, data, ndp, p)
-	struct mount *mp;
-	char *path;
-	caddr_t data;
-	struct nameidata *ndp;
-	struct proc *p;
-{
-	struct umap_args args;
-	struct vnode *lowerrootvp, *vp;
-	struct vnode *umapm_rootvp;
-	struct umap_mount *amp;
-	u_int size;
-	int error;
-#ifdef DEBUG
-	int	i;
-#endif
-
-	/*
-	 * Only for root
-	 */
-	if ((error = suser(p)) != 0)
-		return (error);
-
-#ifdef DEBUG
-	printf("umapfs_mount(mp = %p)\n", (void *)mp);
-#endif
-
-	/*
-	 * Update is a no-op
-	 */
-	if (mp->mnt_flag & MNT_UPDATE) {
-		return (EOPNOTSUPP);
-		/* return (VFS_MOUNT(MOUNTTOUMAPMOUNT(mp)->umapm_vfs, path, data, ndp, p));*/
-	}
-
-	/*
-	 * Get argument
-	 */
-	error = copyin(data, (caddr_t)&args, sizeof(struct umap_args));
-	if (error)
-		return (error);
-
-	/*
-	 * Find lower node
-	 */
-	NDINIT(ndp, LOOKUP, FOLLOW|WANTPARENT|LOCKLEAF,
-		UIO_USERSPACE, args.target, p);
-	error = namei(ndp);
-	if (error)
-		return (error);
-	NDFREE(ndp, NDF_ONLY_PNBUF);
-
-	/*
-	 * Sanity check on lower vnode
-	 */
-	lowerrootvp = ndp->ni_vp;
-#ifdef DEBUG
-	printf("vp = %p, check for VDIR...\n", (void *)lowerrootvp);
-#endif
-	vrele(ndp->ni_dvp);
-	ndp->ni_dvp = 0;
-
-	if (lowerrootvp->v_type != VDIR) {
-		vput(lowerrootvp);
-		return (EINVAL);
-	}
-
-#ifdef DEBUG
-	printf("mp = %p\n", (void *)mp);
-#endif
-
-	amp = (struct umap_mount *) malloc(sizeof(struct umap_mount),
-				M_UMAPFSMNT, M_WAITOK);	/* XXX */
-
-	/*
-	 * Save reference to underlying FS
-	 */
-	amp->umapm_vfs = lowerrootvp->v_mount;
-
-	/*
-	 * Now copy in the number of entries and maps for umap mapping.
-	 */
-	amp->info_nentries = args.nentries;
-	amp->info_gnentries = args.gnentries;
-	error = copyin(args.mapdata, (caddr_t)amp->info_mapdata,
-	    2*sizeof(u_long)*args.nentries);
-	if (error)
-		return (error);
-
-#ifdef DEBUG
-	printf("umap_mount:nentries %d\n",args.nentries);
-	for (i = 0; i < args.nentries; i++)
-		printf("   %lu maps to %lu\n", amp->info_mapdata[i][0],
-	 	    amp->info_mapdata[i][1]);
-#endif
-
-	error = copyin(args.gmapdata, (caddr_t)amp->info_gmapdata,
-	    2*sizeof(u_long)*args.gnentries);
-	if (error)
-		return (error);
-
-#ifdef DEBUG
-	printf("umap_mount:gnentries %d\n",args.gnentries);
-	for (i = 0; i < args.gnentries; i++)
-		printf("	group %lu maps to %lu\n",
-		    amp->info_gmapdata[i][0],
-	 	    amp->info_gmapdata[i][1]);
-#endif
-
-
-	/*
-	 * Save reference.  Each mount also holds
-	 * a reference on the root vnode.
-	 */
-	error = umap_node_create(mp, lowerrootvp, &vp);
-	/*
-	 * Unlock the node (either the lower or the alias)
-	 */
-	VOP_UNLOCK(vp, 0, p);
-	/*
-	 * Make sure the node alias worked
-	 */
-	if (error) {
-		vrele(lowerrootvp);
-		free(amp, M_UMAPFSMNT);	/* XXX */
-		return (error);
-	}
-
-	/*
-	 * Keep a held reference to the root vnode.
-	 * It is vrele'd in umapfs_unmount.
-	 */
-	umapm_rootvp = vp;
-	umapm_rootvp->v_flag |= VROOT;
-	amp->umapm_rootvp = umapm_rootvp;
-	if (UMAPVPTOLOWERVP(umapm_rootvp)->v_mount->mnt_flag & MNT_LOCAL)
-		mp->mnt_flag |= MNT_LOCAL;
-	mp->mnt_data = (qaddr_t) amp;
-	vfs_getnewfsid(mp);
-
-	(void) copyinstr(args.target, mp->mnt_stat.f_mntfromname, MNAMELEN - 1,
-	    &size);
-	bzero(mp->mnt_stat.f_mntfromname + size, MNAMELEN - size);
-	(void)umapfs_statfs(mp, &mp->mnt_stat, p);
-#ifdef DEBUG
-	printf("umapfs_mount: lower %s, alias at %s\n",
-		mp->mnt_stat.f_mntfromname, mp->mnt_stat.f_mntonname);
-#endif
-	return (0);
-}
-
-/*
- * VFS start.  Nothing needed here - the start routine
- * on the underlying filesystem will have been called
- * when that filesystem was mounted.
- */
-static int
-umapfs_start(mp, flags, p)
-	struct mount *mp;
-	int flags;
-	struct proc *p;
-{
-	return (0);
-	/* return (VFS_START(MOUNTTOUMAPMOUNT(mp)->umapm_vfs, flags, p)); */
-}
-
-/*
- * Free reference to umap layer
- */
-static int
-umapfs_unmount(mp, mntflags, p)
-	struct mount *mp;
-	int mntflags;
-	struct proc *p;
-{
-	int error;
-	int flags = 0;
-
-#ifdef DEBUG
-	printf("umapfs_unmount(mp = %p)\n", (void *)mp);
-#endif
-
-	if (mntflags & MNT_FORCE)
-		flags |= FORCECLOSE;
-
-	/*
-	 * Clear out buffer cache.  I don't think we
-	 * ever get anything cached at this level at the
-	 * moment, but who knows...
-	 */
-#ifdef notyet
-	mntflushbuf(mp, 0);
-	if (mntinvalbuf(mp, 1))
-		return (EBUSY);
-#endif
-	/* There is 1 extra root vnode reference (umapm_rootvp). */
-	error = vflush(mp, 1, flags);
-	if (error)
-		return (error);
-
-	/*
-	 * Finally, throw away the umap_mount structure
-	 */
-	free(mp->mnt_data, M_UMAPFSMNT);	/* XXX */
-	mp->mnt_data = 0;
-	return (0);
-}
-
-static int
-umapfs_root(mp, vpp)
-	struct mount *mp;
-	struct vnode **vpp;
-{
-	struct proc *p = curproc;	/* XXX */
-	struct vnode *vp;
-
-#ifdef DEBUG
-	printf("umapfs_root(mp = %p, vp = %p->%p)\n",
-	    (void *)mp, (void *)MOUNTTOUMAPMOUNT(mp)->umapm_rootvp,
-	    (void *)UMAPVPTOLOWERVP(MOUNTTOUMAPMOUNT(mp)->umapm_rootvp));
-#endif
-
-	/*
-	 * Return locked reference to root.
-	 */
-	vp = MOUNTTOUMAPMOUNT(mp)->umapm_rootvp;
-	VREF(vp);
-	vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
-	*vpp = vp;
-	return (0);
-}
-
-static int
-umapfs_quotactl(mp, cmd, uid, arg, p)
-	struct mount *mp;
-	int cmd;
-	uid_t uid;
-	caddr_t arg;
-	struct proc *p;
-{
-	return (VFS_QUOTACTL(MOUNTTOUMAPMOUNT(mp)->umapm_vfs, cmd, uid, arg, p));
-}
-
-static int
-umapfs_statfs(mp, sbp, p)
-	struct mount *mp;
-	struct statfs *sbp;
-	struct proc *p;
-{
-	int error;
-	struct statfs mstat;
-
-#ifdef DEBUG
-	printf("umapfs_statfs(mp = %p, vp = %p->%p)\n",
-	    (void *)mp, (void *)MOUNTTOUMAPMOUNT(mp)->umapm_rootvp,
-	    (void *)UMAPVPTOLOWERVP(MOUNTTOUMAPMOUNT(mp)->umapm_rootvp));
-#endif
-
-	bzero(&mstat, sizeof(mstat));
-
-	error = VFS_STATFS(MOUNTTOUMAPMOUNT(mp)->umapm_vfs, &mstat, p);
-	if (error)
-		return (error);
-
-	/* now copy across the "interesting" information and fake the rest */
-	sbp->f_type = mstat.f_type;
-	sbp->f_flags = mstat.f_flags;
-	sbp->f_bsize = mstat.f_bsize;
-	sbp->f_iosize = mstat.f_iosize;
-	sbp->f_blocks = mstat.f_blocks;
-	sbp->f_bfree = mstat.f_bfree;
-	sbp->f_bavail = mstat.f_bavail;
-	sbp->f_files = mstat.f_files;
-	sbp->f_ffree = mstat.f_ffree;
-	if (sbp != &mp->mnt_stat) {
-		bcopy(&mp->mnt_stat.f_fsid, &sbp->f_fsid, sizeof(sbp->f_fsid));
-		bcopy(mp->mnt_stat.f_mntonname, sbp->f_mntonname, MNAMELEN);
-		bcopy(mp->mnt_stat.f_mntfromname, sbp->f_mntfromname, MNAMELEN);
-	}
-	return (0);
-}
-
-static int
-umapfs_sync(mp, waitfor, cred, p)
-	struct mount *mp;
-	int waitfor;
-	struct ucred *cred;
-	struct proc *p;
-{
-	/*
-	 * XXX - Assumes no data cached at umap layer.
-	 */
-	return (0);
-}
-
-static int
-umapfs_vget(mp, ino, vpp)
-	struct mount *mp;
-	ino_t ino;
-	struct vnode **vpp;
-{
-
-	return (VFS_VGET(MOUNTTOUMAPMOUNT(mp)->umapm_vfs, ino, vpp));
-}
-
-static int
-umapfs_fhtovp(mp, fidp, vpp)
-	struct mount *mp;
-	struct fid *fidp;
-	struct vnode **vpp;
-{
-	
-	return (VFS_FHTOVP(MOUNTTOUMAPMOUNT(mp)->umapm_vfs, fidp, vpp));
-}
-
-static int
-umapfs_checkexp(mp, nam, exflagsp, credanonp)
-	struct mount *mp;
-	struct sockaddr *nam;
-	int *exflagsp;
-	struct ucred **credanonp;
-{
-
-	return (VFS_CHECKEXP(MOUNTTOUMAPMOUNT(mp)->umapm_vfs, nam, 
-		exflagsp, credanonp));
-}
-
-static int
-umapfs_vptofh(vp, fhp)
-	struct vnode *vp;
-	struct fid *fhp;
-{
-	return (VFS_VPTOFH(UMAPVPTOLOWERVP(vp), fhp));
-}
-
-static int
-umapfs_extattrctl(mp, cmd, filename_vp, namespace, attrname, p)
-	struct mount *mp;
-	int cmd;
-	struct vnode *filename_vp;
-	int namespace;
-	const char *attrname;
-	struct proc *p;
-{
-	return (VFS_EXTATTRCTL(MOUNTTOUMAPMOUNT(mp)->umapm_vfs, cmd,
-	    filename_vp, namespace, attrname, p));
-} 
-
-
-static struct vfsops umap_vfsops = {
-	umapfs_mount,
-	umapfs_start,
-	umapfs_unmount,
-	umapfs_root,
-	umapfs_quotactl,
-	umapfs_statfs,
-	umapfs_sync,
-	umapfs_vget,
-	umapfs_fhtovp,
-	umapfs_checkexp,
-	umapfs_vptofh,
-	umapfs_init,
-	vfs_stduninit,
-	umapfs_extattrctl,
-};
-
-VFS_SET(umap_vfsops, umap, VFCF_LOOPBACK);
diff --git a/sys/miscfs/umapfs/umap_vnops.c b/sys/miscfs/umapfs/umap_vnops.c
deleted file mode 100644
index 5bf29c8..0000000
--- a/sys/miscfs/umapfs/umap_vnops.c
+++ /dev/null
@@ -1,519 +0,0 @@
-/*
- * Copyright (c) 1992, 1993
- *	The Regents of the University of California.  All rights reserved.
- *
- * This code is derived from software donated to Berkeley by
- * the UCLA Ficus project.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)umap_vnops.c	8.6 (Berkeley) 5/22/95
- * $FreeBSD$
- */
-
-/*
- * Umap Layer
- */
-
-#include <sys/param.h>
-#include <sys/systm.h>
-#include <sys/kernel.h>
-#include <sys/lock.h>
-#include <sys/malloc.h>
-#include <sys/mount.h>
-#include <sys/namei.h>
-#include <sys/sysctl.h>
-#include <sys/vnode.h>
-
-#include <miscfs/umapfs/umap.h>
-#include <miscfs/nullfs/null.h>
-
-static int umap_bug_bypass = 0;   /* for debugging: enables bypass printf'ing */
-SYSCTL_INT(_debug, OID_AUTO, umapfs_bug_bypass, CTLFLAG_RW,
-	&umap_bug_bypass, 0, "");
-
-static int	umap_bypass __P((struct vop_generic_args *ap));
-static int	umap_getattr __P((struct vop_getattr_args *ap));
-static int	umap_inactive __P((struct vop_inactive_args *ap));
-static int	umap_lock __P((struct vop_lock_args *ap));
-static int	umap_print __P((struct vop_print_args *ap));
-static int	umap_reclaim __P((struct vop_reclaim_args *ap));
-static int	umap_rename __P((struct vop_rename_args *ap));
-static int	umap_unlock __P((struct vop_unlock_args *ap));
-
-/*
- * This is the 10-Apr-92 bypass routine.
- * See null_vnops.c:null_bypass for more details.
- */
-static int
-umap_bypass(ap)
-	struct vop_generic_args /* {
-		struct vnodeop_desc *a_desc;
-		<other random data follows, presumably>
-	} */ *ap;
-{
-	struct ucred **credpp = 0, *credp = 0;
-	struct ucred *savecredp = 0, *savecompcredp = 0;
-	struct ucred *compcredp = 0;
-	struct vnode **this_vp_p;
-	int error;
-	struct vnode *old_vps[VDESC_MAX_VPS];
-	struct vnode *vp1 = 0;
-	struct vnode **vps_p[VDESC_MAX_VPS];
-	struct vnode ***vppp;
-	struct vnodeop_desc *descp = ap->a_desc;
-	int reles, i;
-	struct componentname **compnamepp = 0;
-
-	if (umap_bug_bypass)
-		printf ("umap_bypass: %s\n", descp->vdesc_name);
-
-#ifdef DIAGNOSTIC
-	/*
-	 * We require at least one vp.
-	 */
-	if (descp->vdesc_vp_offsets == NULL ||
-	    descp->vdesc_vp_offsets[0] == VDESC_NO_OFFSET)
-		panic ("umap_bypass: no vp's in map");
-#endif
-
-	/*
-	 * Map the vnodes going in.
-	 * Later, we'll invoke the operation based on
-	 * the first mapped vnode's operation vector.
-	 */
-	reles = descp->vdesc_flags;
-	for (i = 0; i < VDESC_MAX_VPS; reles >>= 1, i++) {
-		if (descp->vdesc_vp_offsets[i] == VDESC_NO_OFFSET)
-			break;   /* bail out at end of list */
-		vps_p[i] = this_vp_p =
-			VOPARG_OFFSETTO(struct vnode**, descp->vdesc_vp_offsets[i], ap);
-
-		if (i == 0) {
-			vp1 = *vps_p[0];
-		}
-
-		/*
-		 * We're not guaranteed that any but the first vnode
-		 * are of our type.  Check for and don't map any
-		 * that aren't.  (Must map first vp or vclean fails.)
-		 */
-
-		if (i && (*this_vp_p)->v_op != umap_vnodeop_p) {
-			old_vps[i] = NULL;
-		} else {
-			old_vps[i] = *this_vp_p;
-			*(vps_p[i]) = UMAPVPTOLOWERVP(*this_vp_p);
-			if (reles & 1)
-				VREF(*this_vp_p);
-		}
-
-	}
-
-	/*
-	 * Fix the credentials.  (That's the purpose of this layer.)
-	 */
-
-	if (descp->vdesc_cred_offset != VDESC_NO_OFFSET) {
-
-		credpp = VOPARG_OFFSETTO(struct ucred**,
-		    descp->vdesc_cred_offset, ap);
-
-		/* Save old values */
-
-		savecredp = (*credpp);
-		if (savecredp != NOCRED)
-			(*credpp) = crdup(savecredp);
-		credp = *credpp;
-
-		if (umap_bug_bypass && credp->cr_uid != 0)
-			printf("umap_bypass: user was %lu, group %lu\n",
-			    (u_long)credp->cr_uid, (u_long)credp->cr_gid);
-
-		/* Map all ids in the credential structure. */
-
-		umap_mapids(vp1->v_mount, credp);
-
-		if (umap_bug_bypass && credp->cr_uid != 0)
-			printf("umap_bypass: user now %lu, group %lu\n",
-			    (u_long)credp->cr_uid, (u_long)credp->cr_gid);
-	}
-
-	/* BSD often keeps a credential in the componentname structure
-	 * for speed.  If there is one, it better get mapped, too.
-	 */
-
-	if (descp->vdesc_componentname_offset != VDESC_NO_OFFSET) {
-
-		compnamepp = VOPARG_OFFSETTO(struct componentname**,
-		    descp->vdesc_componentname_offset, ap);
-
-		compcredp = (*compnamepp)->cn_cred;
-		savecompcredp = compcredp;
-		if (savecompcredp != NOCRED)
-			(*compnamepp)->cn_cred = crdup(savecompcredp);
-		compcredp = (*compnamepp)->cn_cred;
-
-		if (umap_bug_bypass && compcredp->cr_uid != 0)
-			printf(
-		    "umap_bypass: component credit user was %lu, group %lu\n",
-			    (u_long)compcredp->cr_uid,
-			    (u_long)compcredp->cr_gid);
-
-		/* Map all ids in the credential structure. */
-
-		umap_mapids(vp1->v_mount, compcredp);
-
-		if (umap_bug_bypass && compcredp->cr_uid != 0)
-			printf(
-		    "umap_bypass: component credit user now %lu, group %lu\n",
-			    (u_long)compcredp->cr_uid,
-			    (u_long)compcredp->cr_gid);
-	}
-
-	/*
-	 * Call the operation on the lower layer
-	 * with the modified argument structure.
-	 */
-	error = VCALL(*(vps_p[0]), descp->vdesc_offset, ap);
-
-	/*
-	 * Maintain the illusion of call-by-value
-	 * by restoring vnodes in the argument structure
-	 * to their original value.
-	 */
-	reles = descp->vdesc_flags;
-	for (i = 0; i < VDESC_MAX_VPS; reles >>= 1, i++) {
-		if (descp->vdesc_vp_offsets[i] == VDESC_NO_OFFSET)
-			break;   /* bail out at end of list */
-		if (old_vps[i]) {
-			*(vps_p[i]) = old_vps[i];
-			if (reles & 1)
-				vrele(*(vps_p[i]));
-		};
-	};
-
-	/*
-	 * Map the possible out-going vpp
-	 * (Assumes that the lower layer always returns
-	 * a VREF'ed vpp unless it gets an error.)
-	 */
-	if (descp->vdesc_vpp_offset != VDESC_NO_OFFSET &&
-	    !(descp->vdesc_flags & VDESC_NOMAP_VPP) &&
-	    !error) {
-		if (descp->vdesc_flags & VDESC_VPP_WILLRELE)
-			goto out;
-		vppp = VOPARG_OFFSETTO(struct vnode***,
-				 descp->vdesc_vpp_offset, ap);
-		if (*vppp)
-			error = umap_node_create(old_vps[0]->v_mount, **vppp, *vppp);
-	};
-
- out:
-	/*
-	 * Free duplicate cred structure and restore old one.
-	 */
-	if (descp->vdesc_cred_offset != VDESC_NO_OFFSET) {
-		if (umap_bug_bypass && credp && credp->cr_uid != 0)
-			printf("umap_bypass: returning-user was %lu\n",
-			    (u_long)credp->cr_uid);
-
-		if (savecredp != NOCRED) {
-			crfree(credp);
-			(*credpp) = savecredp;
-			if (umap_bug_bypass && credpp && (*credpp)->cr_uid != 0)
-				printf(
-				    "umap_bypass: returning-user now %lu\n\n",
-				    (u_long)(*credpp)->cr_uid);
-		}
-	}
-
-	if (descp->vdesc_componentname_offset != VDESC_NO_OFFSET) {
-		if (umap_bug_bypass && compcredp && compcredp->cr_uid != 0)
-			printf(
-			    "umap_bypass: returning-component-user was %lu\n",
-			    (u_long)compcredp->cr_uid);
-
-		if (savecompcredp != NOCRED) {
-			crfree(compcredp);
-			(*compnamepp)->cn_cred = savecompcredp;
-			if (umap_bug_bypass && credpp && (*credpp)->cr_uid != 0)
-				printf(
-			    "umap_bypass: returning-component-user now %lu\n",
-				    (u_long)compcredp->cr_uid);
-		}
-	}
-
-	return (error);
-}
-
-
-/*
- *  We handle getattr to change the fsid.
- */
-static int
-umap_getattr(ap)
-	struct vop_getattr_args /* {
-		struct vnode *a_vp;
-		struct vattr *a_vap;
-		struct ucred *a_cred;
-		struct proc *a_p;
-	} */ *ap;
-{
-	short uid, gid;
-	int error, tmpid, nentries, gnentries;
-	u_long (*mapdata)[2], (*gmapdata)[2];
-	struct vnode **vp1p;
-	struct vnodeop_desc *descp = ap->a_desc;
-
-	error = umap_bypass((struct vop_generic_args *)ap);
-	if (error)
-		return (error);
-
-	/*
-	 * Umap needs to map the uid and gid returned by a stat
-	 * into the proper values for this site.  This involves
-	 * finding the returned uid in the mapping information,
-	 * translating it into the uid on the other end,
-	 * and filling in the proper field in the vattr
-	 * structure pointed to by ap->a_vap.  The group
-	 * is easier, since currently all groups will be
-	 * translate to the NULLGROUP.
-	 */
-
-	/* Find entry in map */
-
-	uid = ap->a_vap->va_uid;
-	gid = ap->a_vap->va_gid;
-	if (umap_bug_bypass)
-		printf("umap_getattr: mapped uid = %d, mapped gid = %d\n", uid,
-		    gid);
-
-	vp1p = VOPARG_OFFSETTO(struct vnode**, descp->vdesc_vp_offsets[0], ap);
-	nentries =  MOUNTTOUMAPMOUNT((*vp1p)->v_mount)->info_nentries;
-	mapdata =  (MOUNTTOUMAPMOUNT((*vp1p)->v_mount)->info_mapdata);
-	gnentries =  MOUNTTOUMAPMOUNT((*vp1p)->v_mount)->info_gnentries;
-	gmapdata =  (MOUNTTOUMAPMOUNT((*vp1p)->v_mount)->info_gmapdata);
-
-	/* Reverse map the uid for the vnode.  Since it's a reverse
-		map, we can't use umap_mapids() to do it. */
-
-	tmpid = umap_reverse_findid(uid, mapdata, nentries);
-
-	if (tmpid != -1) {
-
-		ap->a_vap->va_uid = (uid_t) tmpid;
-		if (umap_bug_bypass)
-			printf("umap_getattr: original uid = %d\n", uid);
-	} else
-		ap->a_vap->va_uid = (uid_t) NOBODY;
-
-	/* Reverse map the gid for the vnode. */
-
-	tmpid = umap_reverse_findid(gid, gmapdata, gnentries);
-
-	if (tmpid != -1) {
-
-		ap->a_vap->va_gid = (gid_t) tmpid;
-		if (umap_bug_bypass)
-			printf("umap_getattr: original gid = %d\n", gid);
-	} else
-		ap->a_vap->va_gid = (gid_t) NULLGROUP;
-
-	return (0);
-}
-
-/*
- * We need to process our own vnode lock and then clear the
- * interlock flag as it applies only to our vnode, not the
- * vnodes below us on the stack.
- */
-static int
-umap_lock(ap)
-	struct vop_lock_args /* {
-		struct vnode *a_vp;
-		int a_flags;
-		struct proc *a_p;
-	} */ *ap;
-{
-
-	vop_nolock(ap);
-	if ((ap->a_flags & LK_TYPE_MASK) == LK_DRAIN)
-		return (0);
-	ap->a_flags &= ~LK_INTERLOCK;
-	return (null_bypass((struct vop_generic_args *)ap));
-}
-
-/*
- * We need to process our own vnode unlock and then clear the
- * interlock flag as it applies only to our vnode, not the
- * vnodes below us on the stack.
- */
-int
-umap_unlock(ap)
-	struct vop_unlock_args /* {
-		struct vnode *a_vp;
-		int a_flags;
-		struct proc *a_p;
-	} */ *ap;
-{
-	vop_nounlock(ap);
-	ap->a_flags &= ~LK_INTERLOCK;
-	return (null_bypass((struct vop_generic_args *)ap));
-}
-
-static int
-umap_inactive(ap)
-	struct vop_inactive_args /* {
-		struct vnode *a_vp;
-		struct proc *a_p;
-	} */ *ap;
-{
-	struct vnode *vp = ap->a_vp;
-	struct umap_node *xp = VTOUMAP(vp);
-	struct vnode *lowervp = xp->umap_lowervp;
-	/*
-	 * Do nothing (and _don't_ bypass).
-	 * Wait to vrele lowervp until reclaim,
-	 * so that until then our umap_node is in the
-	 * cache and reusable.
-	 *
-	 */
-	VOP_INACTIVE(lowervp, ap->a_p);
-	VOP_UNLOCK(ap->a_vp, 0, ap->a_p);
-	return (0);
-}
-
-static int
-umap_reclaim(ap)
-	struct vop_reclaim_args /* {
-		struct vnode *a_vp;
-	} */ *ap;
-{
-	struct vnode *vp = ap->a_vp;
-	struct umap_node *xp = VTOUMAP(vp);
-	struct vnode *lowervp = xp->umap_lowervp;
-
-	/* After this assignment, this node will not be re-used. */
-	xp->umap_lowervp = NULL;
-	LIST_REMOVE(xp, umap_hash);
-	FREE(vp->v_data, M_TEMP);
-	vp->v_data = NULL;
-	vrele(lowervp);
-	return (0);
-}
-
-static int
-umap_print(ap)
-	struct vop_print_args /* {
-		struct vnode *a_vp;
-	} */ *ap;
-{
-	struct vnode *vp = ap->a_vp;
-	printf("\ttag VT_UMAPFS, vp=%p, lowervp=%p\n", vp, UMAPVPTOLOWERVP(vp));
-	return (0);
-}
-
-static int
-umap_rename(ap)
-	struct vop_rename_args  /* {
-		struct vnode *a_fdvp;
-		struct vnode *a_fvp;
-		struct componentname *a_fcnp;
-		struct vnode *a_tdvp;
-		struct vnode *a_tvp;
-		struct componentname *a_tcnp;
-	} */ *ap;
-{
-	int error;
-	struct componentname *compnamep;
-	struct ucred *compcredp, *savecompcredp;
-	struct vnode *vp;
-
-	/*
-	 * Rename is irregular, having two componentname structures.
-	 * We need to map the cre in the second structure,
-	 * and then bypass takes care of the rest.
-	 */
-
-	vp = ap->a_fdvp;
-	compnamep = ap->a_tcnp;
-	compcredp = compnamep->cn_cred;
-
-	savecompcredp = compcredp;
-	compcredp = compnamep->cn_cred = crdup(savecompcredp);
-
-	if (umap_bug_bypass && compcredp->cr_uid != 0)
-		printf(
-	    "umap_rename: rename component credit user was %lu, group %lu\n",
-		    (u_long)compcredp->cr_uid, (u_long)compcredp->cr_gid);
-
-	/* Map all ids in the credential structure. */
-
-	umap_mapids(vp->v_mount, compcredp);
-
-	if (umap_bug_bypass && compcredp->cr_uid != 0)
-		printf(
-	    "umap_rename: rename component credit user now %lu, group %lu\n",
-		    (u_long)compcredp->cr_uid, (u_long)compcredp->cr_gid);
-
-	error = umap_bypass((struct vop_generic_args *)ap);
-
-	/* Restore the additional mapped componentname cred structure. */
-
-	crfree(compcredp);
-	compnamep->cn_cred = savecompcredp;
-
-	return error;
-}
-
-/*
- * Global vfs data structures
- */
-/*
- * XXX - strategy, bwrite are hand coded currently.  They should
- * go away with a merged buffer/block cache.
- *
- */
-vop_t **umap_vnodeop_p;
-static struct vnodeopv_entry_desc umap_vnodeop_entries[] = {
-	{ &vop_default_desc,		(vop_t *) umap_bypass },
-	{ &vop_getattr_desc,		(vop_t *) umap_getattr },
-	{ &vop_inactive_desc,		(vop_t *) umap_inactive },
-	{ &vop_lock_desc,		(vop_t *) umap_lock },
-	{ &vop_print_desc,		(vop_t *) umap_print },
-	{ &vop_reclaim_desc,		(vop_t *) umap_reclaim },
-	{ &vop_rename_desc,		(vop_t *) umap_rename },
-	{ &vop_unlock_desc,		(vop_t *) umap_unlock },
-	{ NULL, NULL }
-};
-static struct vnodeopv_desc umap_vnodeop_opv_desc =
-	{ &umap_vnodeop_p, umap_vnodeop_entries };
-
-VNODEOP_SET(umap_vnodeop_opv_desc);
diff --git a/sys/miscfs/union/union.h b/sys/miscfs/union/union.h
deleted file mode 100644
index 63a881c..0000000
--- a/sys/miscfs/union/union.h
+++ /dev/null
@@ -1,154 +0,0 @@
-/*
- * Copyright (c) 1994 The Regents of the University of California.
- * Copyright (c) 1994 Jan-Simon Pendry.
- * All rights reserved.
- *
- * This code is derived from software donated to Berkeley by
- * Jan-Simon Pendry.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)union.h	8.9 (Berkeley) 12/10/94
- * $FreeBSD$
- */
-
-struct union_args {
-	char		*target;	/* Target of loopback  */
-	int		mntflags;	/* Options on the mount */
-};
-
-#define UNMNT_ABOVE	0x0001		/* Target appears below mount point */
-#define UNMNT_BELOW	0x0002		/* Target appears below mount point */
-#define UNMNT_REPLACE	0x0003		/* Target replaces mount point */
-#define UNMNT_OPMASK	0x0003
-
-struct union_mount {
-	struct vnode	*um_uppervp;	/* UN_ULOCK holds locking state */
-	struct vnode	*um_lowervp;	/* Left unlocked */
-	struct ucred	*um_cred;	/* Credentials of user calling mount */
-	int		um_cmode;	/* cmask from mount process */
-	int		um_op;		/* Operation mode */
-};
-
-#ifdef _KERNEL
-
-#ifndef DIAGNOSTIC
-#define DIAGNOSTIC
-#endif
-
-/*
- * DEFDIRMODE is the mode bits used to create a shadow directory.
- */
-#define VRWXMODE (VREAD|VWRITE|VEXEC)
-#define VRWMODE (VREAD|VWRITE)
-#define UN_DIRMODE ((VRWXMODE)|(VRWXMODE>>3)|(VRWXMODE>>6))
-#define UN_FILEMODE ((VRWMODE)|(VRWMODE>>3)|(VRWMODE>>6))
-
-/*
- * A cache of vnode references	(hangs off v_data)
- *
- * Placing un_lock as the first elements theoretically allows us to
- * use the vop_stdlock functions.  However, we need to make sure of
- * certain side effects so we will still punch in our own code.
- */
-struct union_node {
-	struct lock		un_lock;
-	LIST_ENTRY(union_node)	un_cache;	/* Hash chain */
-	struct vnode		*un_vnode;	/* Back pointer */
-	struct vnode	        *un_uppervp;	/* overlaying object */
-	struct vnode	        *un_lowervp;	/* underlying object */
-	struct vnode		*un_dirvp;	/* Parent dir of uppervp */
-	struct vnode		*un_pvp;	/* Parent vnode */
-	char			*un_path;	/* saved component name */
-	int			un_openl;	/* # of opens on lowervp */
-	int			un_exclcnt;	/* exclusive count */
-	unsigned int		un_flags;
-	struct vnode		**un_dircache;	/* cached union stack */
-	off_t			un_uppersz;	/* size of upper object */
-	off_t			un_lowersz;	/* size of lower object */
-#ifdef DIAGNOSTIC
-	pid_t			un_pid;
-#endif
-};
-
-/*
- * XXX UN_ULOCK -	indicates that the uppervp is locked
- *
- * UN_CACHED -	node is in the union cache
- */
-
-/*#define UN_ULOCK	0x04*/	/* Upper node is locked */
-#define UN_CACHED	0x10	/* In union cache */
-
-/*
- * Hash table locking flags
- */
-
-#define UNVP_WANT	0x01
-#define UNVP_LOCKED	0x02
-
-extern int union_allocvp __P((struct vnode **, struct mount *,
-				struct vnode *, 
-				struct vnode *, 
-				struct componentname *, struct vnode *,
-				struct vnode *, int));
-extern int union_freevp __P((struct vnode *));
-extern struct vnode *union_dircache __P((struct vnode *, struct proc *));
-extern int union_copyup __P((struct union_node *, int, struct ucred *,
-				struct proc *));
-extern int union_dowhiteout __P((struct union_node *, struct ucred *,
-					struct proc *));
-extern int union_mkshadow __P((struct union_mount *, struct vnode *,
-				struct componentname *, struct vnode **));
-extern int union_mkwhiteout __P((struct union_mount *, struct vnode *,
-				struct componentname *, char *));
-extern int union_cn_close __P((struct vnode *, int, struct ucred *,
-				struct proc *));
-extern void union_removed_upper __P((struct union_node *un));
-extern struct vnode *union_lowervp __P((struct vnode *));
-extern void union_newsize __P((struct vnode *, off_t, off_t));
-
-extern int (*union_dircheckp) __P((struct proc *, struct vnode **,
-				 struct file *));
-
-#define	MOUNTTOUNIONMOUNT(mp) ((struct union_mount *)((mp)->mnt_data))
-#define	VTOUNION(vp) ((struct union_node *)(vp)->v_data)
-#define	UNIONTOV(un) ((un)->un_vnode)
-#define	LOWERVP(vp) (VTOUNION(vp)->un_lowervp)
-#define	UPPERVP(vp) (VTOUNION(vp)->un_uppervp)
-#define OTHERVP(vp) (UPPERVP(vp) ? UPPERVP(vp) : LOWERVP(vp))
-
-#define UDEBUG(x)	if (uniondebug) printf x
-#define UDEBUG_ENABLED	1
-
-extern vop_t **union_vnodeop_p;
-extern struct vfsops union_vfsops;
-extern int uniondebug;
-
-#endif /* _KERNEL */
diff --git a/sys/miscfs/union/union_subr.c b/sys/miscfs/union/union_subr.c
deleted file mode 100644
index ce38e2d..0000000
--- a/sys/miscfs/union/union_subr.c
+++ /dev/null
@@ -1,1360 +0,0 @@
-/*
- * Copyright (c) 1994 Jan-Simon Pendry
- * Copyright (c) 1994
- *	The Regents of the University of California.  All rights reserved.
- *
- * This code is derived from software contributed to Berkeley by
- * Jan-Simon Pendry.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)union_subr.c	8.20 (Berkeley) 5/20/95
- * $FreeBSD$
- */
-
-#include <sys/param.h>
-#include <sys/systm.h>
-#include <sys/fcntl.h>
-#include <sys/file.h>
-#include <sys/filedesc.h>
-#include <sys/kernel.h>
-#include <sys/lock.h>
-#include <sys/malloc.h>
-#include <sys/module.h>
-#include <sys/mount.h>
-#include <sys/mutex.h>
-#include <sys/namei.h>
-#include <sys/stat.h>
-#include <sys/vnode.h>
-
-#include <vm/vm.h>
-#include <vm/vm_extern.h>	/* for vnode_pager_setsize */
-#include <vm/vm_zone.h>
-#include <vm/vm_object.h>	/* for vm cache coherency */
-
-#include <miscfs/union/union.h>
-
-#include <sys/proc.h>
-
-extern int	union_init __P((void));
-
-/* must be power of two, otherwise change UNION_HASH() */
-#define NHASH 32
-
-/* unsigned int ... */
-#define UNION_HASH(u, l) \
-	(((((uintptr_t) (u)) + ((uintptr_t) l)) >> 8) & (NHASH-1))
-
-static LIST_HEAD(unhead, union_node) unhead[NHASH];
-static int unvplock[NHASH];
-
-static void	union_dircache_r __P((struct vnode *vp, struct vnode ***vppp,
-				      int *cntp));
-static int	union_list_lock __P((int ix));
-static void	union_list_unlock __P((int ix));
-static int	union_relookup __P((struct union_mount *um, struct vnode *dvp,
-				    struct vnode **vpp,
-				    struct componentname *cnp,
-				    struct componentname *cn, char *path,
-				    int pathlen));
-static void	union_updatevp __P((struct union_node *un,
-				    struct vnode *uppervp,
-				    struct vnode *lowervp));
-static void union_newlower __P((struct union_node *, struct vnode *));
-static void union_newupper __P((struct union_node *, struct vnode *));
-static int union_copyfile __P((struct vnode *, struct vnode *,
-					struct ucred *, struct proc *));
-static int union_vn_create __P((struct vnode **, struct union_node *,
-				struct proc *));
-static int union_vn_close __P((struct vnode *, int, struct ucred *,
-				struct proc *));
-
-int
-union_init()
-{
-	int i;
-
-	for (i = 0; i < NHASH; i++)
-		LIST_INIT(&unhead[i]);
-	bzero((caddr_t)unvplock, sizeof(unvplock));
-	return (0);
-}
-
-static int
-union_list_lock(ix)
-	int ix;
-{
-	if (unvplock[ix] & UNVP_LOCKED) {
-		unvplock[ix] |= UNVP_WANT;
-		(void) tsleep((caddr_t) &unvplock[ix], PINOD, "unllck", 0);
-		return (1);
-	}
-	unvplock[ix] |= UNVP_LOCKED;
-	return (0);
-}
-
-static void
-union_list_unlock(ix)
-	int ix;
-{
-	unvplock[ix] &= ~UNVP_LOCKED;
-
-	if (unvplock[ix] & UNVP_WANT) {
-		unvplock[ix] &= ~UNVP_WANT;
-		wakeup((caddr_t) &unvplock[ix]);
-	}
-}
-
-/*
- *	union_updatevp:
- *
- *	The uppervp, if not NULL, must be referenced and not locked by us
- *	The lowervp, if not NULL, must be referenced.
- *
- *	if uppervp and lowervp match pointers already installed, nothing
- *	happens. The passed vp's (when matching) are not adjusted.  This
- *	routine may only be called by union_newupper() and union_newlower().
- */
-
-static void
-union_updatevp(un, uppervp, lowervp)
-	struct union_node *un;
-	struct vnode *uppervp;
-	struct vnode *lowervp;
-{
-	int ohash = UNION_HASH(un->un_uppervp, un->un_lowervp);
-	int nhash = UNION_HASH(uppervp, lowervp);
-	int docache = (lowervp != NULLVP || uppervp != NULLVP);
-	int lhash, uhash;
-
-	/*
-	 * Ensure locking is ordered from lower to higher
-	 * to avoid deadlocks.
-	 */
-	if (nhash < ohash) {
-		lhash = nhash;
-		uhash = ohash;
-	} else {
-		lhash = ohash;
-		uhash = nhash;
-	}
-
-	if (lhash != uhash) {
-		while (union_list_lock(lhash))
-			continue;
-	}
-
-	while (union_list_lock(uhash))
-		continue;
-
-	if (ohash != nhash || !docache) {
-		if (un->un_flags & UN_CACHED) {
-			un->un_flags &= ~UN_CACHED;
-			LIST_REMOVE(un, un_cache);
-		}
-	}
-
-	if (ohash != nhash)
-		union_list_unlock(ohash);
-
-	if (un->un_lowervp != lowervp) {
-		if (un->un_lowervp) {
-			vrele(un->un_lowervp);
-			if (un->un_path) {
-				free(un->un_path, M_TEMP);
-				un->un_path = 0;
-			}
-		}
-		un->un_lowervp = lowervp;
-		un->un_lowersz = VNOVAL;
-	}
-
-	if (un->un_uppervp != uppervp) {
-		if (un->un_uppervp)
-			vrele(un->un_uppervp);
-		un->un_uppervp = uppervp;
-		un->un_uppersz = VNOVAL;
-	}
-
-	if (docache && (ohash != nhash)) {
-		LIST_INSERT_HEAD(&unhead[nhash], un, un_cache);
-		un->un_flags |= UN_CACHED;
-	}
-
-	union_list_unlock(nhash);
-}
-
-/*
- * Set a new lowervp.  The passed lowervp must be referenced and will be
- * stored in the vp in a referenced state. 
- */
-
-static void
-union_newlower(un, lowervp)
-	struct union_node *un;
-	struct vnode *lowervp;
-{
-	union_updatevp(un, un->un_uppervp, lowervp);
-}
-
-/*
- * Set a new uppervp.  The passed uppervp must be locked and will be 
- * stored in the vp in a locked state.  The caller should not unlock
- * uppervp.
- */
-
-static void
-union_newupper(un, uppervp)
-	struct union_node *un;
-	struct vnode *uppervp;
-{
-	union_updatevp(un, uppervp, un->un_lowervp);
-}
-
-/*
- * Keep track of size changes in the underlying vnodes.
- * If the size changes, then callback to the vm layer
- * giving priority to the upper layer size.
- */
-void
-union_newsize(vp, uppersz, lowersz)
-	struct vnode *vp;
-	off_t uppersz, lowersz;
-{
-	struct union_node *un;
-	off_t sz;
-
-	/* only interested in regular files */
-	if (vp->v_type != VREG)
-		return;
-
-	un = VTOUNION(vp);
-	sz = VNOVAL;
-
-	if ((uppersz != VNOVAL) && (un->un_uppersz != uppersz)) {
-		un->un_uppersz = uppersz;
-		if (sz == VNOVAL)
-			sz = un->un_uppersz;
-	}
-
-	if ((lowersz != VNOVAL) && (un->un_lowersz != lowersz)) {
-		un->un_lowersz = lowersz;
-		if (sz == VNOVAL)
-			sz = un->un_lowersz;
-	}
-
-	if (sz != VNOVAL) {
-		UDEBUG(("union: %s size now %ld\n",
-			(uppersz != VNOVAL ? "upper" : "lower"), (long)sz));
-		/*
-		 * There is no need to change size of non-existent object
-		 */
-		/* vnode_pager_setsize(vp, sz); */
-	}
-}
-
-/*
- *	union_allocvp:	allocate a union_node and associate it with a
- *			parent union_node and one or two vnodes.
- *
- *	vpp	Holds the returned vnode locked and referenced if no 
- *		error occurs.
- *
- *	mp	Holds the mount point.  mp may or may not be busied. 
- *		allocvp makes no changes to mp.
- *
- *	dvp	Holds the parent union_node to the one we wish to create.
- *		XXX may only be used to traverse an uncopied lowervp-based
- *		tree?  XXX
- *
- *		dvp may or may not be locked.  allocvp makes no changes
- *		to dvp.
- *
- *	upperdvp Holds the parent vnode to uppervp, generally used along
- *		with path component information to create a shadow of
- *		lowervp when uppervp does not exist.
- *
- *		upperdvp is referenced but unlocked on entry, and will be
- *		dereferenced on return.
- *
- *	uppervp	Holds the new uppervp vnode to be stored in the 
- *		union_node we are allocating.  uppervp is referenced but
- *		not locked, and will be dereferenced on return.
- *
- *	lowervp	Holds the new lowervp vnode to be stored in the
- *		union_node we are allocating.  lowervp is referenced but
- *		not locked, and will be dereferenced on return.
- * 
- *	cnp	Holds path component information to be coupled with
- *		lowervp and upperdvp to allow unionfs to create an uppervp
- *		later on.  Only used if lowervp is valid.  The conents
- *		of cnp is only valid for the duration of the call.
- *
- *	docache	Determine whether this node should be entered in the
- *		cache or whether it should be destroyed as soon as possible.
- *
- * all union_nodes are maintained on a singly-linked
- * list.  new nodes are only allocated when they cannot
- * be found on this list.  entries on the list are
- * removed when the vfs reclaim entry is called.
- *
- * a single lock is kept for the entire list.  this is
- * needed because the getnewvnode() function can block
- * waiting for a vnode to become free, in which case there
- * may be more than one process trying to get the same
- * vnode.  this lock is only taken if we are going to
- * call getnewvnode, since the kernel itself is single-threaded.
- *
- * if an entry is found on the list, then call vget() to
- * take a reference.  this is done because there may be
- * zero references to it and so it needs to removed from
- * the vnode free list.
- */
-
-int
-union_allocvp(vpp, mp, dvp, upperdvp, cnp, uppervp, lowervp, docache)
-	struct vnode **vpp;
-	struct mount *mp;
-	struct vnode *dvp;		/* parent union vnode */
-	struct vnode *upperdvp;		/* parent vnode of uppervp */
-	struct componentname *cnp;	/* may be null */
-	struct vnode *uppervp;		/* may be null */
-	struct vnode *lowervp;		/* may be null */
-	int docache;
-{
-	int error;
-	struct union_node *un = 0;
-	struct union_mount *um = MOUNTTOUNIONMOUNT(mp);
-	struct proc *p = (cnp) ? cnp->cn_proc : curproc;
-	int hash = 0;
-	int vflag;
-	int try;
-
-	if (uppervp == NULLVP && lowervp == NULLVP)
-		panic("union: unidentifiable allocation");
-
-	if (uppervp && lowervp && (uppervp->v_type != lowervp->v_type)) {
-		vrele(lowervp);
-		lowervp = NULLVP;
-	}
-
-	/* detect the root vnode (and aliases) */
-	vflag = 0;
-	if ((uppervp == um->um_uppervp) &&
-	    ((lowervp == NULLVP) || lowervp == um->um_lowervp)) {
-		if (lowervp == NULLVP) {
-			lowervp = um->um_lowervp;
-			if (lowervp != NULLVP)
-				VREF(lowervp);
-		}
-		vflag = VROOT;
-	}
-
-loop:
-	if (!docache) {
-		un = 0;
-	} else for (try = 0; try < 3; try++) {
-		switch (try) {
-		case 0:
-			if (lowervp == NULLVP)
-				continue;
-			hash = UNION_HASH(uppervp, lowervp);
-			break;
-
-		case 1:
-			if (uppervp == NULLVP)
-				continue;
-			hash = UNION_HASH(uppervp, NULLVP);
-			break;
-
-		case 2:
-			if (lowervp == NULLVP)
-				continue;
-			hash = UNION_HASH(NULLVP, lowervp);
-			break;
-		}
-
-		while (union_list_lock(hash))
-			continue;
-
-		LIST_FOREACH(un, &unhead[hash], un_cache) {
-			if ((un->un_lowervp == lowervp ||
-			     un->un_lowervp == NULLVP) &&
-			    (un->un_uppervp == uppervp ||
-			     un->un_uppervp == NULLVP) &&
-			    (UNIONTOV(un)->v_mount == mp)) {
-				if (vget(UNIONTOV(un), 0,
-				    cnp ? cnp->cn_proc : NULL)) {
-					union_list_unlock(hash);
-					goto loop;
-				}
-				break;
-			}
-		}
-
-		union_list_unlock(hash);
-
-		if (un)
-			break;
-	}
-
-	if (un) {
-		/*
-		 * Obtain a lock on the union_node.  Everything is unlocked
-		 * except for dvp, so check that case.  If they match, our
-		 * new un is already locked.  Otherwise we have to lock our
-		 * new un.
-		 *
-		 * A potential deadlock situation occurs when we are holding
-		 * one lock while trying to get another.  We must follow 
-		 * strict ordering rules to avoid it.  We try to locate dvp
-		 * by scanning up from un_vnode, since the most likely 
-		 * scenario is un being under dvp.
-		 */
-
-		if (dvp && un->un_vnode != dvp) {
-			struct vnode *scan = un->un_vnode;
-
-			do {
-				scan = VTOUNION(scan)->un_pvp;
-			} while (scan && scan->v_tag == VT_UNION && scan != dvp);
-			if (scan != dvp) {
-				/*
-				 * our new un is above dvp (we never saw dvp
-				 * while moving up the tree).
-				 */
-				VREF(dvp);
-				VOP_UNLOCK(dvp, 0, p);
-				error = vn_lock(un->un_vnode, LK_EXCLUSIVE, p);
-				vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY, p);
-				vrele(dvp);
-			} else {
-				/*
-				 * our new un is under dvp
-				 */
-				error = vn_lock(un->un_vnode, LK_EXCLUSIVE, p);
-			}
-		} else if (dvp == NULLVP) {
-			/*
-			 * dvp is NULL, we need to lock un.
-			 */
-			error = vn_lock(un->un_vnode, LK_EXCLUSIVE, p);
-		} else {
-			/*
-			 * dvp == un->un_vnode, we are already locked.
-			 */
-			error = 0;
-		}
-
-		if (error)
-			goto loop;
-
-		/*
-		 * At this point, the union_node is locked and referenced.
-		 *
-		 * uppervp is locked and referenced or NULL, lowervp is
-		 * referenced or NULL.
-		 */
-		UDEBUG(("Modify existing un %p vn %p upper %p(refs %d) -> %p(refs %d)\n",
-			un, un->un_vnode, un->un_uppervp, 
-			(un->un_uppervp ? un->un_uppervp->v_usecount : -99),
-			uppervp,
-			(uppervp ? uppervp->v_usecount : -99)
-		));
-
-		if (uppervp != un->un_uppervp) {
-			KASSERT(uppervp == NULL || uppervp->v_usecount > 0, ("union_allocvp: too few refs %d (at least 1 required) on uppervp", uppervp->v_usecount));
-			union_newupper(un, uppervp);
-		} else if (uppervp) {
-			KASSERT(uppervp->v_usecount > 1, ("union_allocvp: too few refs %d (at least 2 required) on uppervp", uppervp->v_usecount));
-			vrele(uppervp);
-		}
-
-		/*
-		 * Save information about the lower layer.
-		 * This needs to keep track of pathname
-		 * and directory information which union_vn_create
-		 * might need.
-		 */
-		if (lowervp != un->un_lowervp) {
-			union_newlower(un, lowervp);
-			if (cnp && (lowervp != NULLVP)) {
-				un->un_path = malloc(cnp->cn_namelen+1,
-						M_TEMP, M_WAITOK);
-				bcopy(cnp->cn_nameptr, un->un_path,
-						cnp->cn_namelen);
-				un->un_path[cnp->cn_namelen] = '\0';
-			}
-		} else if (lowervp) {
-			vrele(lowervp);
-		}
-
-		/*
-		 * and upperdvp
-		 */
-		if (upperdvp != un->un_dirvp) {
-			if (un->un_dirvp)
-				vrele(un->un_dirvp);
-			un->un_dirvp = upperdvp;
-		} else if (upperdvp) {
-			vrele(upperdvp);
-		}
-
-		*vpp = UNIONTOV(un);
-		return (0);
-	}
-
-	if (docache) {
-		/*
-		 * otherwise lock the vp list while we call getnewvnode
-		 * since that can block.
-		 */ 
-		hash = UNION_HASH(uppervp, lowervp);
-
-		if (union_list_lock(hash))
-			goto loop;
-	}
-
-	/*
-	 * Create new node rather then replace old node
-	 */
-
-	error = getnewvnode(VT_UNION, mp, union_vnodeop_p, vpp);
-	if (error) {
-		/*
-		 * If an error occurs clear out vnodes.
-		 */
-		if (lowervp)
-			vrele(lowervp);
-		if (uppervp) 
-			vrele(uppervp);
-		if (upperdvp)
-			vrele(upperdvp);
-		*vpp = NULL;
-		goto out;
-	}
-
-	MALLOC((*vpp)->v_data, void *, sizeof(struct union_node),
-		M_TEMP, M_WAITOK);
-
-	(*vpp)->v_flag |= vflag;
-	if (uppervp)
-		(*vpp)->v_type = uppervp->v_type;
-	else
-		(*vpp)->v_type = lowervp->v_type;
-
-	un = VTOUNION(*vpp);
-	bzero(un, sizeof(*un));
-
-	lockinit(&un->un_lock, PVFS, "unlock", 0, 0);
-	vn_lock(*vpp, LK_EXCLUSIVE | LK_RETRY, p);
-
-	un->un_vnode = *vpp;
-	un->un_uppervp = uppervp;
-	un->un_uppersz = VNOVAL;
-	un->un_lowervp = lowervp;
-	un->un_lowersz = VNOVAL;
-	un->un_dirvp = upperdvp;
-	un->un_pvp = dvp;		/* only parent dir in new allocation */
-	if (dvp != NULLVP)
-		VREF(dvp);
-	un->un_dircache = 0;
-	un->un_openl = 0;
-
-	if (cnp && (lowervp != NULLVP)) {
-		un->un_path = malloc(cnp->cn_namelen+1, M_TEMP, M_WAITOK);
-		bcopy(cnp->cn_nameptr, un->un_path, cnp->cn_namelen);
-		un->un_path[cnp->cn_namelen] = '\0';
-	} else {
-		un->un_path = 0;
-		un->un_dirvp = NULL;
-	}
-
-	if (docache) {
-		LIST_INSERT_HEAD(&unhead[hash], un, un_cache);
-		un->un_flags |= UN_CACHED;
-	}
-
-out:
-	if (docache)
-		union_list_unlock(hash);
-
-	return (error);
-}
-
-int
-union_freevp(vp)
-	struct vnode *vp;
-{
-	struct union_node *un = VTOUNION(vp);
-
-	if (un->un_flags & UN_CACHED) {
-		un->un_flags &= ~UN_CACHED;
-		LIST_REMOVE(un, un_cache);
-	}
-
-	if (un->un_pvp != NULLVP) {
-		vrele(un->un_pvp);
-		un->un_pvp = NULL;
-	}
-	if (un->un_uppervp != NULLVP) {
-		vrele(un->un_uppervp);
-		un->un_uppervp = NULL;
-	}
-	if (un->un_lowervp != NULLVP) {
-		vrele(un->un_lowervp);
-		un->un_lowervp = NULL;
-	}
-	if (un->un_dirvp != NULLVP) {
-		vrele(un->un_dirvp);
-		un->un_dirvp = NULL;
-	}
-	if (un->un_path) {
-		free(un->un_path, M_TEMP);
-		un->un_path = NULL;
-	}
-	lockdestroy(&un->un_lock);
-
-	FREE(vp->v_data, M_TEMP);
-	vp->v_data = 0;
-
-	return (0);
-}
-
-/*
- * copyfile.  copy the vnode (fvp) to the vnode (tvp)
- * using a sequence of reads and writes.  both (fvp)
- * and (tvp) are locked on entry and exit.
- *
- * fvp and tvp are both exclusive locked on call, but their refcount's
- * haven't been bumped at all.
- */
-static int
-union_copyfile(fvp, tvp, cred, p)
-	struct vnode *fvp;
-	struct vnode *tvp;
-	struct ucred *cred;
-	struct proc *p;
-{
-	char *buf;
-	struct uio uio;
-	struct iovec iov;
-	int error = 0;
-
-	/*
-	 * strategy:
-	 * allocate a buffer of size MAXBSIZE.
-	 * loop doing reads and writes, keeping track
-	 * of the current uio offset.
-	 * give up at the first sign of trouble.
-	 */
-
-	bzero(&uio, sizeof(uio));
-
-	uio.uio_procp = p;
-	uio.uio_segflg = UIO_SYSSPACE;
-	uio.uio_offset = 0;
-
-	VOP_LEASE(fvp, p, cred, LEASE_READ);
-	VOP_LEASE(tvp, p, cred, LEASE_WRITE);
-
-	buf = malloc(MAXBSIZE, M_TEMP, M_WAITOK);
-
-	/* ugly loop follows... */
-	do {
-		off_t offset = uio.uio_offset;
-		int count;
-		int bufoffset;
-
-		/*
-		 * Setup for big read
-		 */
-		uio.uio_iov = &iov;
-		uio.uio_iovcnt = 1;
-		iov.iov_base = buf;
-		iov.iov_len = MAXBSIZE;
-		uio.uio_resid = iov.iov_len;
-		uio.uio_rw = UIO_READ;
-
-		if ((error = VOP_READ(fvp, &uio, 0, cred)) != 0)
-			break;
-
-		/*
-		 * Get bytes read, handle read eof case and setup for
-		 * write loop
-		 */
-		if ((count = MAXBSIZE - uio.uio_resid) == 0)
-			break;
-		bufoffset = 0;
-
-		/*
-		 * Write until an error occurs or our buffer has been
-		 * exhausted, then update the offset for the next read.
-		 */
-		while (bufoffset < count) {
-			uio.uio_iov = &iov;
-			uio.uio_iovcnt = 1;
-			iov.iov_base = buf + bufoffset;
-			iov.iov_len = count - bufoffset;
-			uio.uio_offset = offset + bufoffset;
-			uio.uio_rw = UIO_WRITE;
-			uio.uio_resid = iov.iov_len;
-
-			if ((error = VOP_WRITE(tvp, &uio, 0, cred)) != 0)
-				break;
-			bufoffset += (count - bufoffset) - uio.uio_resid;
-		}
-		uio.uio_offset = offset + bufoffset;
-	} while (error == 0);
-
-	free(buf, M_TEMP);
-	return (error);
-}
-
-/*
- *
- * un's vnode is assumed to be locked on entry and remains locked on exit.
- */
-
-int
-union_copyup(un, docopy, cred, p)
-	struct union_node *un;
-	int docopy;
-	struct ucred *cred;
-	struct proc *p;
-{
-	int error;
-	struct mount *mp;
-	struct vnode *lvp, *uvp;
-
-	/*
-	 * If the user does not have read permission, the vnode should not
-	 * be copied to upper layer.
-	 */
-	vn_lock(un->un_lowervp, LK_EXCLUSIVE | LK_RETRY, p);
-	error = VOP_ACCESS(un->un_lowervp, VREAD, cred, p);
-	VOP_UNLOCK(un->un_lowervp, 0, p);
-	if (error)
-		return (error);
-
-	if ((error = vn_start_write(un->un_dirvp, &mp, V_WAIT | PCATCH)) != 0)
-		return (error);
-	if ((error = union_vn_create(&uvp, un, p)) != 0) {
-		vn_finished_write(mp);
-		return (error);
-	}
-
-	lvp = un->un_lowervp;
-
-	KASSERT(uvp->v_usecount > 0, ("copy: uvp refcount 0: %d", uvp->v_usecount));
-	if (docopy) {
-		/*
-		 * XX - should not ignore errors
-		 * from VOP_CLOSE
-		 */
-		vn_lock(lvp, LK_EXCLUSIVE | LK_RETRY, p);
-		error = VOP_OPEN(lvp, FREAD, cred, p);
-		if (error == 0 && vn_canvmio(lvp) == TRUE)
-			error = vfs_object_create(lvp, p, cred);
-		if (error == 0) {
-			error = union_copyfile(lvp, uvp, cred, p);
-			VOP_UNLOCK(lvp, 0, p);
-			(void) VOP_CLOSE(lvp, FREAD, cred, p);
-		}
-		if (error == 0)
-			UDEBUG(("union: copied up %s\n", un->un_path));
-
-	}
-	VOP_UNLOCK(uvp, 0, p);
-	vn_finished_write(mp);
-	union_newupper(un, uvp);
-	KASSERT(uvp->v_usecount > 0, ("copy: uvp refcount 0: %d", uvp->v_usecount));
-	union_vn_close(uvp, FWRITE, cred, p);
-	KASSERT(uvp->v_usecount > 0, ("copy: uvp refcount 0: %d", uvp->v_usecount));
-	/*
-	 * Subsequent IOs will go to the top layer, so
-	 * call close on the lower vnode and open on the
-	 * upper vnode to ensure that the filesystem keeps
-	 * its references counts right.  This doesn't do
-	 * the right thing with (cred) and (FREAD) though.
-	 * Ignoring error returns is not right, either.
-	 */
-	if (error == 0) {
-		int i;
-
-		for (i = 0; i < un->un_openl; i++) {
-			(void) VOP_CLOSE(lvp, FREAD, cred, p);
-			(void) VOP_OPEN(uvp, FREAD, cred, p);
-		}
-		if (un->un_openl) {
-			if (vn_canvmio(uvp) == TRUE)
-				error = vfs_object_create(uvp, p, cred);
-		}
-		un->un_openl = 0;
-	}
-
-	return (error);
-
-}
-
-/*
- *	union_relookup:
- *
- *	dvp should be locked on entry and will be locked on return.  No
- *	net change in the ref count will occur.
- *
- *	If an error is returned, *vpp will be invalid, otherwise it
- *	will hold a locked, referenced vnode.  If *vpp == dvp then
- *	remember that only one exclusive lock is held.
- */
-
-static int
-union_relookup(um, dvp, vpp, cnp, cn, path, pathlen)
-	struct union_mount *um;
-	struct vnode *dvp;
-	struct vnode **vpp;
-	struct componentname *cnp;
-	struct componentname *cn;
-	char *path;
-	int pathlen;
-{
-	int error;
-
-	/*
-	 * A new componentname structure must be faked up because
-	 * there is no way to know where the upper level cnp came
-	 * from or what it is being used for.  This must duplicate
-	 * some of the work done by NDINIT, some of the work done
-	 * by namei, some of the work done by lookup and some of
-	 * the work done by VOP_LOOKUP when given a CREATE flag.
-	 * Conclusion: Horrible.
-	 */
-	cn->cn_namelen = pathlen;
-	cn->cn_pnbuf = zalloc(namei_zone);
-	bcopy(path, cn->cn_pnbuf, cn->cn_namelen);
-	cn->cn_pnbuf[cn->cn_namelen] = '\0';
-
-	cn->cn_nameiop = CREATE;
-	cn->cn_flags = (LOCKPARENT|LOCKLEAF|HASBUF|SAVENAME|ISLASTCN);
-	cn->cn_proc = cnp->cn_proc;
-	if (um->um_op == UNMNT_ABOVE)
-		cn->cn_cred = cnp->cn_cred;
-	else
-		cn->cn_cred = um->um_cred;
-	cn->cn_nameptr = cn->cn_pnbuf;
-	cn->cn_consume = cnp->cn_consume;
-
-	VREF(dvp);
-	VOP_UNLOCK(dvp, 0, cnp->cn_proc);
-
-	/*
-	 * Pass dvp unlocked and referenced on call to relookup().
-	 *
-	 * If an error occurs, dvp will be returned unlocked and dereferenced.
-	 */
-
-	if ((error = relookup(dvp, vpp, cn)) != 0) {
-		vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY, cnp->cn_proc);
-		return(error);
-	}
-
-	/*
-	 * If no error occurs, dvp will be returned locked with the reference
-	 * left as before, and vpp will be returned referenced and locked.
-	 *
-	 * We want to return with dvp as it was passed to us, so we get
-	 * rid of our reference.
-	 */
-	vrele(dvp);
-	return (0);
-}
-
-/*
- * Create a shadow directory in the upper layer.
- * The new vnode is returned locked.
- *
- * (um) points to the union mount structure for access to the
- * the mounting process's credentials.
- * (dvp) is the directory in which to create the shadow directory,
- * it is locked (but not ref'd) on entry and return.
- * (cnp) is the componentname to be created.
- * (vpp) is the returned newly created shadow directory, which
- * is returned locked and ref'd
- */
-int
-union_mkshadow(um, dvp, cnp, vpp)
-	struct union_mount *um;
-	struct vnode *dvp;
-	struct componentname *cnp;
-	struct vnode **vpp;
-{
-	int error;
-	struct vattr va;
-	struct proc *p = cnp->cn_proc;
-	struct componentname cn;
-	struct mount *mp;
-
-	if ((error = vn_start_write(dvp, &mp, V_WAIT | PCATCH)) != 0)
-		return (error);
-	if ((error = union_relookup(um, dvp, vpp, cnp, &cn,
-			cnp->cn_nameptr, cnp->cn_namelen)) != 0) {
-		vn_finished_write(mp);
-		return (error);
-	}
-
-	if (*vpp) {
-		if (cn.cn_flags & HASBUF) {
-			zfree(namei_zone, cn.cn_pnbuf);
-			cn.cn_flags &= ~HASBUF;
-		}
-		if (dvp == *vpp)
-			vrele(*vpp);
-		else
-			vput(*vpp);
-		vn_finished_write(mp);
-		*vpp = NULLVP;
-		return (EEXIST);
-	}
-
-	/*
-	 * policy: when creating the shadow directory in the
-	 * upper layer, create it owned by the user who did
-	 * the mount, group from parent directory, and mode
-	 * 777 modified by umask (ie mostly identical to the
-	 * mkdir syscall).  (jsp, kb)
-	 */
-
-	VATTR_NULL(&va);
-	va.va_type = VDIR;
-	va.va_mode = um->um_cmode;
-
-	/* VOP_LEASE: dvp is locked */
-	VOP_LEASE(dvp, p, cn.cn_cred, LEASE_WRITE);
-
-	error = VOP_MKDIR(dvp, vpp, &cn, &va);
-	if (cn.cn_flags & HASBUF) {
-		zfree(namei_zone, cn.cn_pnbuf);
-		cn.cn_flags &= ~HASBUF;
-	}
-	/*vput(dvp);*/
-	vn_finished_write(mp);
-	return (error);
-}
-
-/*
- * Create a whiteout entry in the upper layer.
- *
- * (um) points to the union mount structure for access to the
- * the mounting process's credentials.
- * (dvp) is the directory in which to create the whiteout.
- * it is locked on entry and return.
- * (cnp) is the componentname to be created.
- */
-int
-union_mkwhiteout(um, dvp, cnp, path)
-	struct union_mount *um;
-	struct vnode *dvp;
-	struct componentname *cnp;
-	char *path;
-{
-	int error;
-	struct proc *p = cnp->cn_proc;
-	struct vnode *wvp;
-	struct componentname cn;
-	struct mount *mp;
-
-	if ((error = vn_start_write(dvp, &mp, V_WAIT | PCATCH)) != 0)
-		return (error);
-	error = union_relookup(um, dvp, &wvp, cnp, &cn, path, strlen(path));
-	if (error) {
-		vn_finished_write(mp);
-		return (error);
-	}
-
-	if (wvp) {
-		if (cn.cn_flags & HASBUF) {
-			zfree(namei_zone, cn.cn_pnbuf);
-			cn.cn_flags &= ~HASBUF;
-		}
-		if (wvp == dvp)
-			vrele(wvp);
-		else
-			vput(wvp);
-		vn_finished_write(mp);
-		return (EEXIST);
-	}
-
-	/* VOP_LEASE: dvp is locked */
-	VOP_LEASE(dvp, p, p->p_ucred, LEASE_WRITE);
-
-	error = VOP_WHITEOUT(dvp, &cn, CREATE);
-	if (cn.cn_flags & HASBUF) {
-		zfree(namei_zone, cn.cn_pnbuf);
-		cn.cn_flags &= ~HASBUF;
-	}
-	vn_finished_write(mp);
-	return (error);
-}
-
-/*
- * union_vn_create: creates and opens a new shadow file
- * on the upper union layer.  this function is similar
- * in spirit to calling vn_open but it avoids calling namei().
- * the problem with calling namei is that a) it locks too many
- * things, and b) it doesn't start at the "right" directory,
- * whereas relookup is told where to start.
- *
- * On entry, the vnode associated with un is locked.  It remains locked
- * on return.
- *
- * If no error occurs, *vpp contains a locked referenced vnode for your
- * use.  If an error occurs *vpp iis undefined.
- */
-static int
-union_vn_create(vpp, un, p)
-	struct vnode **vpp;
-	struct union_node *un;
-	struct proc *p;
-{
-	struct vnode *vp;
-	struct ucred *cred = p->p_ucred;
-	struct vattr vat;
-	struct vattr *vap = &vat;
-	int fmode = FFLAGS(O_WRONLY|O_CREAT|O_TRUNC|O_EXCL);
-	int error;
-	int cmode = UN_FILEMODE & ~p->p_fd->fd_cmask;
-	struct componentname cn;
-
-	*vpp = NULLVP;
-
-	/*
-	 * Build a new componentname structure (for the same
-	 * reasons outlines in union_mkshadow).
-	 * The difference here is that the file is owned by
-	 * the current user, rather than by the person who
-	 * did the mount, since the current user needs to be
-	 * able to write the file (that's why it is being
-	 * copied in the first place).
-	 */
-	cn.cn_namelen = strlen(un->un_path);
-	cn.cn_pnbuf = zalloc(namei_zone);
-	bcopy(un->un_path, cn.cn_pnbuf, cn.cn_namelen+1);
-	cn.cn_nameiop = CREATE;
-	cn.cn_flags = (LOCKPARENT|LOCKLEAF|HASBUF|SAVENAME|ISLASTCN);
-	cn.cn_proc = p;
-	cn.cn_cred = p->p_ucred;
-	cn.cn_nameptr = cn.cn_pnbuf;
-	cn.cn_consume = 0;
-
-	/*
-	 * Pass dvp unlocked and referenced on call to relookup().
-	 *
-	 * If an error occurs, dvp will be returned unlocked and dereferenced.
-	 */
-	VREF(un->un_dirvp);
-	error = relookup(un->un_dirvp, &vp, &cn);
-	if (error)
-		return (error);
-
-	/*
-	 * If no error occurs, dvp will be returned locked with the reference
-	 * left as before, and vpp will be returned referenced and locked.
-	 */
-	if (vp) {
-		vput(un->un_dirvp);
-		if (cn.cn_flags & HASBUF) {
-			zfree(namei_zone, cn.cn_pnbuf);
-			cn.cn_flags &= ~HASBUF;
-		}
-		if (vp == un->un_dirvp)
-			vrele(vp);
-		else
-			vput(vp);
-		return (EEXIST);
-	}
-
-	/*
-	 * Good - there was no race to create the file
-	 * so go ahead and create it.  The permissions
-	 * on the file will be 0666 modified by the
-	 * current user's umask.  Access to the file, while
-	 * it is unioned, will require access to the top *and*
-	 * bottom files.  Access when not unioned will simply
-	 * require access to the top-level file.
-	 * TODO: confirm choice of access permissions.
-	 */
-	VATTR_NULL(vap);
-	vap->va_type = VREG;
-	vap->va_mode = cmode;
-	VOP_LEASE(un->un_dirvp, p, cred, LEASE_WRITE);
-	error = VOP_CREATE(un->un_dirvp, &vp, &cn, vap);
-	if (cn.cn_flags & HASBUF) {
-		zfree(namei_zone, cn.cn_pnbuf);
-		cn.cn_flags &= ~HASBUF;
-	}
-	vput(un->un_dirvp);
-	if (error)
-		return (error);
-
-	error = VOP_OPEN(vp, fmode, cred, p);
-	if (error == 0 && vn_canvmio(vp) == TRUE)
-		error = vfs_object_create(vp, p, cred);
-	if (error) {
-		vput(vp);
-		return (error);
-	}
-	vp->v_writecount++;
-	*vpp = vp;
-	return (0);
-}
-
-static int
-union_vn_close(vp, fmode, cred, p)
-	struct vnode *vp;
-	int fmode;
-	struct ucred *cred;
-	struct proc *p;
-{
-
-	if (fmode & FWRITE)
-		--vp->v_writecount;
-	return (VOP_CLOSE(vp, fmode, cred, p));
-}
-
-#if 0
-
-/*
- *	union_removed_upper:
- *
- *	called with union_node unlocked. XXX
- */
-
-void
-union_removed_upper(un)
-	struct union_node *un;
-{
-	struct proc *p = curproc;	/* XXX */
-	struct vnode **vpp;
-
-	/*
-	 * Do not set the uppervp to NULLVP.  If lowervp is NULLVP,
-	 * union node will have neither uppervp nor lowervp.  We remove
-	 * the union node from cache, so that it will not be referrenced.
-	 */
-	union_newupper(un, NULLVP);
-	if (un->un_dircache != 0) {
-		for (vpp = un->un_dircache; *vpp != NULLVP; vpp++)
-			vrele(*vpp);
-		free(un->un_dircache, M_TEMP);
-		un->un_dircache = 0;
-	}
-
-	if (un->un_flags & UN_CACHED) {
-		un->un_flags &= ~UN_CACHED;
-		LIST_REMOVE(un, un_cache);
-	}
-}
-
-#endif
-
-/*
- * determine whether a whiteout is needed
- * during a remove/rmdir operation.
- */
-int
-union_dowhiteout(un, cred, p)
-	struct union_node *un;
-	struct ucred *cred;
-	struct proc *p;
-{
-	struct vattr va;
-
-	if (un->un_lowervp != NULLVP)
-		return (1);
-
-	if (VOP_GETATTR(un->un_uppervp, &va, cred, p) == 0 &&
-	    (va.va_flags & OPAQUE))
-		return (1);
-
-	return (0);
-}
-
-static void
-union_dircache_r(vp, vppp, cntp)
-	struct vnode *vp;
-	struct vnode ***vppp;
-	int *cntp;
-{
-	struct union_node *un;
-
-	if (vp->v_op != union_vnodeop_p) {
-		if (vppp) {
-			VREF(vp);
-			*(*vppp)++ = vp;
-			if (--(*cntp) == 0)
-				panic("union: dircache table too small");
-		} else {
-			(*cntp)++;
-		}
-
-		return;
-	}
-
-	un = VTOUNION(vp);
-	if (un->un_uppervp != NULLVP)
-		union_dircache_r(un->un_uppervp, vppp, cntp);
-	if (un->un_lowervp != NULLVP)
-		union_dircache_r(un->un_lowervp, vppp, cntp);
-}
-
-struct vnode *
-union_dircache(vp, p)
-	struct vnode *vp;
-	struct proc *p;
-{
-	int cnt;
-	struct vnode *nvp;
-	struct vnode **vpp;
-	struct vnode **dircache;
-	struct union_node *un;
-	int error;
-
-	vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
-	dircache = VTOUNION(vp)->un_dircache;
-
-	nvp = NULLVP;
-
-	if (dircache == NULL) {
-		cnt = 0;
-		union_dircache_r(vp, 0, &cnt);
-		cnt++;
-		dircache = malloc(cnt * sizeof(struct vnode *),
-				M_TEMP, M_WAITOK);
-		vpp = dircache;
-		union_dircache_r(vp, &vpp, &cnt);
-		*vpp = NULLVP;
-		vpp = dircache + 1;
-	} else {
-		vpp = dircache;
-		do {
-			if (*vpp++ == VTOUNION(vp)->un_uppervp)
-				break;
-		} while (*vpp != NULLVP);
-	}
-
-	if (*vpp == NULLVP)
-		goto out;
-
-	/*vn_lock(*vpp, LK_EXCLUSIVE | LK_RETRY, p);*/
-	UDEBUG(("ALLOCVP-3 %p ref %d\n", *vpp, (*vpp ? (*vpp)->v_usecount : -99)));
-	VREF(*vpp);
-	error = union_allocvp(&nvp, vp->v_mount, NULLVP, NULLVP, NULL, *vpp, NULLVP, 0);
-	UDEBUG(("ALLOCVP-3B %p ref %d\n", nvp, (*vpp ? (*vpp)->v_usecount : -99)));
-	if (error)
-		goto out;
-
-	VTOUNION(vp)->un_dircache = 0;
-	un = VTOUNION(nvp);
-	un->un_dircache = dircache;
-
-out:
-	VOP_UNLOCK(vp, 0, p);
-	return (nvp);
-}
-
-/*
- * Module glue to remove #ifdef UNION from vfs_syscalls.c
- */
-static int
-union_dircheck(struct proc *p, struct vnode **vp, struct file *fp)
-{
-	int error = 0;
-
-	if ((*vp)->v_op == union_vnodeop_p) {
-		struct vnode *lvp;
-
-		lvp = union_dircache(*vp, p);
-		if (lvp != NULLVP) {
-			struct vattr va;
-
-			/*
-			 * If the directory is opaque,
-			 * then don't show lower entries
-			 */
-			error = VOP_GETATTR(*vp, &va, fp->f_cred, p);
-			if (va.va_flags & OPAQUE) {
-				vput(lvp);
-				lvp = NULL;
-			}
-		}
-
-		if (lvp != NULLVP) {
-			error = VOP_OPEN(lvp, FREAD, fp->f_cred, p);
-			if (error == 0 && vn_canvmio(lvp) == TRUE)
-				error = vfs_object_create(lvp, p, fp->f_cred);
-			if (error) {
-				vput(lvp);
-				return (error);
-			}
-			VOP_UNLOCK(lvp, 0, p);
-			fp->f_data = (caddr_t) lvp;
-			fp->f_offset = 0;
-			error = vn_close(*vp, FREAD, fp->f_cred, p);
-			if (error)
-				return (error);
-			*vp = lvp;
-			return -1;	/* goto unionread */
-		}
-	}
-	return error;
-}
-
-static int
-union_modevent(module_t mod, int type, void *data)
-{
-	switch (type) {
-	case MOD_LOAD:
-		union_dircheckp = union_dircheck;
-		break;
-	case MOD_UNLOAD:
-		union_dircheckp = NULL;
-		break;
-	default:
-		break;
-	}
-	return 0;
-}
-
-static moduledata_t union_mod = {
-	"union_dircheck",
-	union_modevent,
-	NULL
-};
-
-DECLARE_MODULE(union_dircheck, union_mod, SI_SUB_VFS, SI_ORDER_ANY);
diff --git a/sys/miscfs/union/union_vfsops.c b/sys/miscfs/union/union_vfsops.c
deleted file mode 100644
index d38f31e..0000000
--- a/sys/miscfs/union/union_vfsops.c
+++ /dev/null
@@ -1,485 +0,0 @@
-/*
- * Copyright (c) 1994, 1995 The Regents of the University of California.
- * Copyright (c) 1994, 1995 Jan-Simon Pendry.
- * All rights reserved.
- *
- * This code is derived from software donated to Berkeley by
- * Jan-Simon Pendry.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)union_vfsops.c	8.20 (Berkeley) 5/20/95
- * $FreeBSD$
- */
-
-/*
- * Union Layer
- */
-
-#include <sys/param.h>
-#include <sys/systm.h>
-#include <sys/kernel.h>
-#include <sys/proc.h>
-#include <sys/vnode.h>
-#include <sys/mount.h>
-#include <sys/namei.h>
-#include <sys/malloc.h>
-#include <sys/filedesc.h>
-#include <miscfs/union/union.h>
-
-static MALLOC_DEFINE(M_UNIONFSMNT, "UNION mount", "UNION mount structure");
-
-extern int	union_init __P((struct vfsconf *));
-static int	union_mount __P((struct mount *mp, char *path, caddr_t data,
-				 struct nameidata *ndp, struct proc *p));
-static int	union_root __P((struct mount *mp, struct vnode **vpp));
-static int	union_statfs __P((struct mount *mp, struct statfs *sbp,
-				  struct proc *p));
-static int	union_unmount __P((struct mount *mp, int mntflags,
-				   struct proc *p));
-
-/*
- * Mount union filesystem
- */
-static int
-union_mount(mp, path, data, ndp, p)
-	struct mount *mp;
-	char *path;
-	caddr_t data;
-	struct nameidata *ndp;
-	struct proc *p;
-{
-	int error = 0;
-	struct union_args args;
-	struct vnode *lowerrootvp = NULLVP;
-	struct vnode *upperrootvp = NULLVP;
-	struct union_mount *um = 0;
-	struct ucred *cred = 0;
-	char *cp = 0;
-	int len;
-	u_int size;
-
-	UDEBUG(("union_mount(mp = %p)\n", (void *)mp));
-
-	/*
-	 * Disable clustered write, otherwise system becomes unstable.
-	 */
-	mp->mnt_flag |= MNT_NOCLUSTERW;
-
-	/*
-	 * Update is a no-op
-	 */
-	if (mp->mnt_flag & MNT_UPDATE) {
-		/*
-		 * Need to provide.
-		 * 1. a way to convert between rdonly and rdwr mounts.
-		 * 2. support for nfs exports.
-		 */
-		error = EOPNOTSUPP;
-		goto bad;
-	}
-
-	/*
-	 * Get argument
-	 */
-	error = copyin(data, (caddr_t)&args, sizeof(struct union_args));
-	if (error)
-		goto bad;
-
-	/*
-	 * Obtain lower vnode.  Vnode is stored in mp->mnt_vnodecovered.
-	 * We need to reference it but not lock it.
-	 */
-
-	lowerrootvp = mp->mnt_vnodecovered;
-	VREF(lowerrootvp);
-
-#if 0
-	/*
-	 * Unlock lower node to avoid deadlock.
-	 */
-	if (lowerrootvp->v_op == union_vnodeop_p)
-		VOP_UNLOCK(lowerrootvp, 0, p);
-#endif
-
-	/*
-	 * Obtain upper vnode by calling namei() on the path.  The
-	 * upperrootvp will be turned referenced but not locked.
-	 */
-	NDINIT(ndp, LOOKUP, FOLLOW|WANTPARENT,
-	       UIO_USERSPACE, args.target, p);
-
-	error = namei(ndp);
-
-#if 0
-	if (lowerrootvp->v_op == union_vnodeop_p)
-		vn_lock(lowerrootvp, LK_EXCLUSIVE | LK_RETRY, p);
-#endif
-	if (error)
-		goto bad;
-
-	NDFREE(ndp, NDF_ONLY_PNBUF);
-	upperrootvp = ndp->ni_vp;
-	vrele(ndp->ni_dvp);
-	ndp->ni_dvp = NULL;
-
-	UDEBUG(("mount_root UPPERVP %p locked = %d\n", upperrootvp,
-	    VOP_ISLOCKED(upperrootvp, NULL)));
-
-	/*
-	 * Check multi union mount to avoid `lock myself again' panic.
-	 * Also require that it be a directory.
-	 */
-	if (upperrootvp == VTOUNION(lowerrootvp)->un_uppervp) {
-#ifdef DIAGNOSTIC
-		printf("union_mount: multi union mount?\n");
-#endif
-		error = EDEADLK;
-		goto bad;
-	}
-
-	if (upperrootvp->v_type != VDIR) {
-		error = EINVAL;
-		goto bad;
-	}
-
-	/*
-	 * Allocate our union_mount structure and populate the fields.
-	 * The vnode references are stored in the union_mount as held,
-	 * unlocked references.  Depending on the _BELOW flag, the
-	 * filesystems are viewed in a different order.  In effect this
-	 * is the same as providing a mount-under option to the mount
-	 * syscall.
-	 */
-
-	um = (struct union_mount *) malloc(sizeof(struct union_mount),
-				M_UNIONFSMNT, M_WAITOK | M_ZERO);
-
-	um->um_op = args.mntflags & UNMNT_OPMASK;
-
-	switch (um->um_op) {
-	case UNMNT_ABOVE:
-		um->um_lowervp = lowerrootvp;
-		um->um_uppervp = upperrootvp;
-		upperrootvp = NULL;
-		lowerrootvp = NULL;
-		break;
-
-	case UNMNT_BELOW:
-		um->um_lowervp = upperrootvp;
-		um->um_uppervp = lowerrootvp;
-		upperrootvp = NULL;
-		lowerrootvp = NULL;
-		break;
-
-	case UNMNT_REPLACE:
-		vrele(lowerrootvp);
-		lowerrootvp = NULL;
-		um->um_uppervp = upperrootvp;
-		um->um_lowervp = lowerrootvp;
-		upperrootvp = NULL;
-		break;
-
-	default:
-		error = EINVAL;
-		goto bad;
-	}
-
-	/*
-	 * Unless the mount is readonly, ensure that the top layer
-	 * supports whiteout operations
-	 */
-	if ((mp->mnt_flag & MNT_RDONLY) == 0) {
-		error = VOP_WHITEOUT(um->um_uppervp, NULL, LOOKUP);
-		if (error)
-			goto bad;
-	}
-
-	um->um_cred = p->p_ucred;
-	crhold(um->um_cred);
-	um->um_cmode = UN_DIRMODE &~ p->p_fd->fd_cmask;
-
-	/*
-	 * Depending on what you think the MNT_LOCAL flag might mean,
-	 * you may want the && to be || on the conditional below.
-	 * At the moment it has been defined that the filesystem is
-	 * only local if it is all local, ie the MNT_LOCAL flag implies
-	 * that the entire namespace is local.  If you think the MNT_LOCAL
-	 * flag implies that some of the files might be stored locally
-	 * then you will want to change the conditional.
-	 */
-	if (um->um_op == UNMNT_ABOVE) {
-		if (((um->um_lowervp == NULLVP) ||
-		     (um->um_lowervp->v_mount->mnt_flag & MNT_LOCAL)) &&
-		    (um->um_uppervp->v_mount->mnt_flag & MNT_LOCAL))
-			mp->mnt_flag |= MNT_LOCAL;
-	}
-
-	/*
-	 * Copy in the upper layer's RDONLY flag.  This is for the benefit
-	 * of lookup() which explicitly checks the flag, rather than asking
-	 * the filesystem for its own opinion.  This means, that an update
-	 * mount of the underlying filesystem to go from rdonly to rdwr
-	 * will leave the unioned view as read-only.
-	 */
-	mp->mnt_flag |= (um->um_uppervp->v_mount->mnt_flag & MNT_RDONLY);
-
-	mp->mnt_data = (qaddr_t) um;
-	vfs_getnewfsid(mp);
-
-	switch (um->um_op) {
-	case UNMNT_ABOVE:
-		cp = "<above>:";
-		break;
-	case UNMNT_BELOW:
-		cp = "<below>:";
-		break;
-	case UNMNT_REPLACE:
-		cp = "";
-		break;
-	}
-	len = strlen(cp);
-	bcopy(cp, mp->mnt_stat.f_mntfromname, len);
-
-	cp = mp->mnt_stat.f_mntfromname + len;
-	len = MNAMELEN - len;
-
-	(void) copyinstr(args.target, cp, len - 1, &size);
-	bzero(cp + size, len - size);
-
-	(void)union_statfs(mp, &mp->mnt_stat, p);
-
-	UDEBUG(("union_mount: from %s, on %s\n",
-		mp->mnt_stat.f_mntfromname, mp->mnt_stat.f_mntonname));
-	return (0);
-
-bad:
-	if (um) {
-		if (um->um_uppervp)
-			vrele(um->um_uppervp);
-		if (um->um_lowervp)
-			vrele(um->um_lowervp);
-		/* XXX other fields */
-		free(um, M_UNIONFSMNT);
-	}
-	if (cred)
-		crfree(cred);
-	if (upperrootvp)
-		vrele(upperrootvp);
-	if (lowerrootvp)
-		vrele(lowerrootvp);
-	return (error);
-}
-
-/*
- * Free reference to union layer
- */
-static int
-union_unmount(mp, mntflags, p)
-	struct mount *mp;
-	int mntflags;
-	struct proc *p;
-{
-	struct union_mount *um = MOUNTTOUNIONMOUNT(mp);
-	int error;
-	int freeing;
-	int flags = 0;
-
-	UDEBUG(("union_unmount(mp = %p)\n", (void *)mp));
-
-	if (mntflags & MNT_FORCE)
-		flags |= FORCECLOSE;
-
-	/*
-	 * Keep flushing vnodes from the mount list.
-	 * This is needed because of the un_pvp held
-	 * reference to the parent vnode.
-	 * If more vnodes have been freed on a given pass,
-	 * the try again.  The loop will iterate at most
-	 * (d) times, where (d) is the maximum tree depth
-	 * in the filesystem.
-	 */
-	for (freeing = 0; (error = vflush(mp, 0, flags)) != 0;) {
-		struct vnode *vp;
-		int n;
-
-		/* count #vnodes held on mount list */
-		n = 0;
-		LIST_FOREACH(vp, &mp->mnt_vnodelist, v_mntvnodes)
-			n++;
-
-		/* if this is unchanged then stop */
-		if (n == freeing)
-			break;
-
-		/* otherwise try once more time */
-		freeing = n;
-	}
-
-	/* If the most recent vflush failed, the filesystem is still busy. */
-	if (error)
-		return (error);
-
-	/*
-	 * Discard references to upper and lower target vnodes.
-	 */
-	if (um->um_lowervp)
-		vrele(um->um_lowervp);
-	vrele(um->um_uppervp);
-	crfree(um->um_cred);
-	/*
-	 * Finally, throw away the union_mount structure
-	 */
-	free(mp->mnt_data, M_UNIONFSMNT);	/* XXX */
-	mp->mnt_data = 0;
-	return (0);
-}
-
-static int
-union_root(mp, vpp)
-	struct mount *mp;
-	struct vnode **vpp;
-{
-	struct union_mount *um = MOUNTTOUNIONMOUNT(mp);
-	int error;
-
-	/*
-	 * Supply an unlocked reference to um_uppervp and to um_lowervp.  It
-	 * is possible for um_uppervp to be locked without the associated
-	 * root union_node being locked.  We let union_allocvp() deal with
-	 * it.
-	 */
-	UDEBUG(("union_root UPPERVP %p locked = %d\n", um->um_uppervp,
-	    VOP_ISLOCKED(um->um_uppervp, NULL)));
-
-	VREF(um->um_uppervp);
-	if (um->um_lowervp)
-		VREF(um->um_lowervp);
-
-	error = union_allocvp(vpp, mp, NULLVP, NULLVP, NULL, 
-		    um->um_uppervp, um->um_lowervp, 1);
-	UDEBUG(("error %d\n", error));
-	UDEBUG(("union_root2 UPPERVP %p locked = %d\n", um->um_uppervp,
-	    VOP_ISLOCKED(um->um_uppervp, NULL)));
-
-	return (error);
-}
-
-static int
-union_statfs(mp, sbp, p)
-	struct mount *mp;
-	struct statfs *sbp;
-	struct proc *p;
-{
-	int error;
-	struct union_mount *um = MOUNTTOUNIONMOUNT(mp);
-	struct statfs mstat;
-	int lbsize;
-
-	UDEBUG(("union_statfs(mp = %p, lvp = %p, uvp = %p)\n",
-	    (void *)mp, (void *)um->um_lowervp, (void *)um->um_uppervp));
-
-	bzero(&mstat, sizeof(mstat));
-
-	if (um->um_lowervp) {
-		error = VFS_STATFS(um->um_lowervp->v_mount, &mstat, p);
-		if (error)
-			return (error);
-	}
-
-	/* now copy across the "interesting" information and fake the rest */
-#if 0
-	sbp->f_type = mstat.f_type;
-	sbp->f_flags = mstat.f_flags;
-	sbp->f_bsize = mstat.f_bsize;
-	sbp->f_iosize = mstat.f_iosize;
-#endif
-	lbsize = mstat.f_bsize;
-	sbp->f_blocks = mstat.f_blocks;
-	sbp->f_bfree = mstat.f_bfree;
-	sbp->f_bavail = mstat.f_bavail;
-	sbp->f_files = mstat.f_files;
-	sbp->f_ffree = mstat.f_ffree;
-
-	error = VFS_STATFS(um->um_uppervp->v_mount, &mstat, p);
-	if (error)
-		return (error);
-
-	sbp->f_flags = mstat.f_flags;
-	sbp->f_bsize = mstat.f_bsize;
-	sbp->f_iosize = mstat.f_iosize;
-
-	/*
-	 * if the lower and upper blocksizes differ, then frig the
-	 * block counts so that the sizes reported by df make some
-	 * kind of sense.  none of this makes sense though.
-	 */
-
-	if (mstat.f_bsize != lbsize)
-		sbp->f_blocks = ((off_t) sbp->f_blocks * lbsize) / mstat.f_bsize;
-
-	/*
-	 * The "total" fields count total resources in all layers,
-	 * the "free" fields count only those resources which are
-	 * free in the upper layer (since only the upper layer
-	 * is writeable).
-	 */
-	sbp->f_blocks += mstat.f_blocks;
-	sbp->f_bfree = mstat.f_bfree;
-	sbp->f_bavail = mstat.f_bavail;
-	sbp->f_files += mstat.f_files;
-	sbp->f_ffree = mstat.f_ffree;
-
-	if (sbp != &mp->mnt_stat) {
-		sbp->f_type = mp->mnt_vfc->vfc_typenum;
-		bcopy(&mp->mnt_stat.f_fsid, &sbp->f_fsid, sizeof(sbp->f_fsid));
-		bcopy(mp->mnt_stat.f_mntonname, sbp->f_mntonname, MNAMELEN);
-		bcopy(mp->mnt_stat.f_mntfromname, sbp->f_mntfromname, MNAMELEN);
-	}
-	return (0);
-}
-
-static struct vfsops union_vfsops = {
-	union_mount,
-	vfs_stdstart,	/* underlying start already done */
-	union_unmount,
-	union_root,
-	vfs_stdquotactl,
-	union_statfs,
-	vfs_stdsync,    /* XXX assumes no cached data on union level */
-	vfs_stdvget,
-	vfs_stdfhtovp,
-	vfs_stdcheckexp,
-	vfs_stdvptofh,
-	union_init,
-	vfs_stduninit,
-	vfs_stdextattrctl,
-};
-
-VFS_SET(union_vfsops, union, VFCF_LOOPBACK);
diff --git a/sys/miscfs/union/union_vnops.c b/sys/miscfs/union/union_vnops.c
deleted file mode 100644
index 3402825..0000000
--- a/sys/miscfs/union/union_vnops.c
+++ /dev/null
@@ -1,1966 +0,0 @@
-/*
- * Copyright (c) 1992, 1993, 1994, 1995 Jan-Simon Pendry.
- * Copyright (c) 1992, 1993, 1994, 1995
- *	The Regents of the University of California.  All rights reserved.
- *
- * This code is derived from software contributed to Berkeley by
- * Jan-Simon Pendry.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)union_vnops.c	8.32 (Berkeley) 6/23/95
- * $FreeBSD$
- */
-
-#include <sys/param.h>
-#include <sys/systm.h>
-#include <sys/fcntl.h>
-#include <sys/stat.h>
-#include <sys/kernel.h>
-#include <sys/vnode.h>
-#include <sys/mount.h>
-#include <sys/namei.h>
-#include <sys/malloc.h>
-#include <sys/bio.h>
-#include <sys/buf.h>
-#include <sys/lock.h>
-#include <sys/sysctl.h>
-#include <miscfs/union/union.h>
-
-#include <vm/vm.h>
-#include <vm/vnode_pager.h>
-
-#include <vm/vm_page.h>
-#include <vm/vm_object.h>
-
-int uniondebug = 0;
-
-#if UDEBUG_ENABLED
-SYSCTL_INT(_vfs, OID_AUTO, uniondebug, CTLFLAG_RW, &uniondebug, 0, "");
-#else
-SYSCTL_INT(_vfs, OID_AUTO, uniondebug, CTLFLAG_RD, &uniondebug, 0, "");
-#endif
-
-static int	union_access __P((struct vop_access_args *ap));
-static int	union_advlock __P((struct vop_advlock_args *ap));
-static int	union_close __P((struct vop_close_args *ap));
-static int	union_create __P((struct vop_create_args *ap));
-static int	union_createvobject __P((struct vop_createvobject_args *ap));
-static int	union_destroyvobject __P((struct vop_destroyvobject_args *ap));
-static int	union_fsync __P((struct vop_fsync_args *ap));
-static int	union_getattr __P((struct vop_getattr_args *ap));
-static int	union_getvobject __P((struct vop_getvobject_args *ap));
-static int	union_inactive __P((struct vop_inactive_args *ap));
-static int	union_ioctl __P((struct vop_ioctl_args *ap));
-static int	union_lease __P((struct vop_lease_args *ap));
-static int	union_link __P((struct vop_link_args *ap));
-static int	union_lock __P((struct vop_lock_args *ap));
-static int	union_lookup __P((struct vop_lookup_args *ap));
-static int	union_lookup1 __P((struct vnode *udvp, struct vnode **dvp,
-				   struct vnode **vpp,
-				   struct componentname *cnp));
-static int	union_mkdir __P((struct vop_mkdir_args *ap));
-static int	union_mknod __P((struct vop_mknod_args *ap));
-static int	union_open __P((struct vop_open_args *ap));
-static int	union_pathconf __P((struct vop_pathconf_args *ap));
-static int	union_print __P((struct vop_print_args *ap));
-static int	union_read __P((struct vop_read_args *ap));
-static int	union_readdir __P((struct vop_readdir_args *ap));
-static int	union_readlink __P((struct vop_readlink_args *ap));
-static int	union_getwritemount __P((struct vop_getwritemount_args *ap));
-static int	union_reclaim __P((struct vop_reclaim_args *ap));
-static int	union_remove __P((struct vop_remove_args *ap));
-static int	union_rename __P((struct vop_rename_args *ap));
-static int	union_revoke __P((struct vop_revoke_args *ap));
-static int	union_rmdir __P((struct vop_rmdir_args *ap));
-static int	union_poll __P((struct vop_poll_args *ap));
-static int	union_setattr __P((struct vop_setattr_args *ap));
-static int	union_strategy __P((struct vop_strategy_args *ap));
-static int	union_symlink __P((struct vop_symlink_args *ap));
-static int	union_unlock __P((struct vop_unlock_args *ap));
-static int	union_whiteout __P((struct vop_whiteout_args *ap));
-static int	union_write __P((struct vop_read_args *ap));
-
-static __inline
-struct vnode *
-union_lock_upper(struct union_node *un, struct proc *p)
-{
-	struct vnode *uppervp;
-
-	if ((uppervp = un->un_uppervp) != NULL) {
-		VREF(uppervp);
-		vn_lock(uppervp, LK_EXCLUSIVE | LK_CANRECURSE | LK_RETRY, p);
-	}
-	KASSERT((uppervp == NULL || uppervp->v_usecount > 0), ("uppervp usecount is 0"));
-	return(uppervp);
-}
-
-static __inline
-void
-union_unlock_upper(struct vnode *uppervp, struct proc *p)
-{
-	vput(uppervp);
-}
-
-static __inline
-struct vnode *
-union_lock_other(struct union_node *un, struct proc *p)
-{
-	struct vnode *vp;
-
-	if (un->un_uppervp != NULL) {
-		vp = union_lock_upper(un, p);
-	} else if ((vp = un->un_lowervp) != NULL) {
-		VREF(vp);
-		vn_lock(vp, LK_EXCLUSIVE | LK_CANRECURSE | LK_RETRY, p);
-	}
-	return(vp);
-}
-
-static __inline
-void
-union_unlock_other(struct vnode *vp, struct proc *p)
-{
-	vput(vp);
-}
-
-/*
- *	union_lookup:
- *
- *	udvp	must be exclusively locked on call and will remain 
- *		exclusively locked on return.  This is the mount point 
- *		for out filesystem.
- *
- *	dvp	Our base directory, locked and referenced.
- *		The passed dvp will be dereferenced and unlocked on return
- *		and a new dvp will be returned which is locked and 
- *		referenced in the same variable.
- *
- *	vpp	is filled in with the result if no error occured,
- *		locked and ref'd.
- *
- *		If an error is returned, *vpp is set to NULLVP.  If no
- *		error occurs, *vpp is returned with a reference and an
- *		exclusive lock.
- */
-
-static int
-union_lookup1(udvp, pdvp, vpp, cnp)
-	struct vnode *udvp;
-	struct vnode **pdvp;
-	struct vnode **vpp;
-	struct componentname *cnp;
-{
-	int error;
-	struct proc *p = cnp->cn_proc;
-	struct vnode *dvp = *pdvp;
-	struct vnode *tdvp;
-	struct mount *mp;
-
-	/*
-	 * If stepping up the directory tree, check for going
-	 * back across the mount point, in which case do what
-	 * lookup would do by stepping back down the mount
-	 * hierarchy.
-	 */
-	if (cnp->cn_flags & ISDOTDOT) {
-		while ((dvp != udvp) && (dvp->v_flag & VROOT)) {
-			/*
-			 * Don't do the NOCROSSMOUNT check
-			 * at this level.  By definition,
-			 * union fs deals with namespaces, not
-			 * filesystems.
-			 */
-			tdvp = dvp;
-			dvp = dvp->v_mount->mnt_vnodecovered;
-			VREF(dvp);
-			vput(tdvp);
-			vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY, p);
-		}
-	}
-
-	/*
-	 * Set return dvp to be the upperdvp 'parent directory.
-	 */
-	*pdvp = dvp;
-
-	/*
-	 * If the VOP_LOOKUP call generates an error, tdvp is invalid and no
-	 * changes will have been made to dvp, so we are set to return.
-	 */
-
-        error = VOP_LOOKUP(dvp, &tdvp, cnp);
-	if (error) {
-		UDEBUG(("dvp %p error %d flags %lx\n", dvp, error, cnp->cn_flags));
-		*vpp = NULL;
-		return (error);
-	}
-
-	/*
-	 * The parent directory will have been unlocked, unless lookup
-	 * found the last component or if dvp == tdvp (tdvp must be locked).
-	 *
-	 * We want our dvp to remain locked and ref'd.  We also want tdvp
-	 * to remain locked and ref'd.
-	 */
-	UDEBUG(("parentdir %p result %p flag %lx\n", dvp, tdvp, cnp->cn_flags));
-
-	if (dvp != tdvp && (cnp->cn_flags & ISLASTCN) == 0)
-		vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY, p);
-
-	/*
-	 * Lastly check if the current node is a mount point in
-	 * which case walk up the mount hierarchy making sure not to
-	 * bump into the root of the mount tree (ie. dvp != udvp).
-	 *
-	 * We use dvp as a temporary variable here, it is no longer related
-	 * to the dvp above.  However, we have to ensure that both *pdvp and
-	 * tdvp are locked on return.
-	 */
-
-	dvp = tdvp;
-	while (
-	    dvp != udvp && 
-	    (dvp->v_type == VDIR) &&
-	    (mp = dvp->v_mountedhere)
-	) {
-		int relock_pdvp = 0;
-
-		if (vfs_busy(mp, 0, 0, p))
-			continue;
-
-		if (dvp == *pdvp)
-			relock_pdvp = 1;
-		vput(dvp);
-		dvp = NULL;
-		error = VFS_ROOT(mp, &dvp);
-
-		vfs_unbusy(mp, p);
-
-		if (relock_pdvp)
-			vn_lock(*pdvp, LK_EXCLUSIVE | LK_RETRY, p);
-
-		if (error) {
-			*vpp = NULL;
-			return (error);
-		}
-	}
-	*vpp = dvp;
-	return (0);
-}
-
-static int
-union_lookup(ap)
-	struct vop_lookup_args /* {
-		struct vnodeop_desc *a_desc;
-		struct vnode *a_dvp;
-		struct vnode **a_vpp;
-		struct componentname *a_cnp;
-	} */ *ap;
-{
-	int error;
-	int uerror, lerror;
-	struct vnode *uppervp, *lowervp;
-	struct vnode *upperdvp, *lowerdvp;
-	struct vnode *dvp = ap->a_dvp;		/* starting dir */
-	struct union_node *dun = VTOUNION(dvp);	/* associated union node */
-	struct componentname *cnp = ap->a_cnp;
-	struct proc *p = cnp->cn_proc;
-	int lockparent = cnp->cn_flags & LOCKPARENT;
-	struct union_mount *um = MOUNTTOUNIONMOUNT(dvp->v_mount);
-	struct ucred *saved_cred = NULL;
-	int iswhiteout;
-	struct vattr va;
-
-	*ap->a_vpp = NULLVP;
-
-	/*
-	 * Disallow write attemps to the filesystem mounted read-only.
-	 */
-	if ((cnp->cn_flags & ISLASTCN) && 
-	    (dvp->v_mount->mnt_flag & MNT_RDONLY) &&
-	    (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME)) {
-		return (EROFS);
-	}
-
-	/*
-	 * For any lookup's we do, always return with the parent locked
-	 */
-	cnp->cn_flags |= LOCKPARENT;
-
-	lowerdvp = dun->un_lowervp;
-	uppervp = NULLVP;
-	lowervp = NULLVP;
-	iswhiteout = 0;
-
-	uerror = ENOENT;
-	lerror = ENOENT;
-
-	/*
-	 * Get a private lock on uppervp and a reference, effectively 
-	 * taking it out of the union_node's control.
-	 *
-	 * We must lock upperdvp while holding our lock on dvp
-	 * to avoid a deadlock.
-	 */
-	upperdvp = union_lock_upper(dun, p);
-
-	/*
-	 * do the lookup in the upper level.
-	 * if that level comsumes additional pathnames,
-	 * then assume that something special is going
-	 * on and just return that vnode.
-	 */
-	if (upperdvp != NULLVP) {
-		/*
-		 * We do not have to worry about the DOTDOT case, we've
-		 * already unlocked dvp.
-		 */
-		UDEBUG(("A %p\n", upperdvp));
-
-		/*
-		 * Do the lookup.   We must supply a locked and referenced
-		 * upperdvp to the function and will get a new locked and
-		 * referenced upperdvp back with the old having been 
-		 * dereferenced.
-		 *
-		 * If an error is returned, uppervp will be NULLVP.  If no
-		 * error occurs, uppervp will be the locked and referenced
-		 * return vnode or possibly NULL, depending on what is being
-		 * requested.  It is possible that the returned uppervp
-		 * will be the same as upperdvp.
-		 */
-		uerror = union_lookup1(um->um_uppervp, &upperdvp, &uppervp, cnp);
-		UDEBUG((
-		    "uerror %d upperdvp %p %d/%d, uppervp %p ref=%d/lck=%d\n",
-		    uerror,
-		    upperdvp,
-		    upperdvp->v_usecount,
-		    VOP_ISLOCKED(upperdvp, NULL),
-		    uppervp,
-		    (uppervp ? uppervp->v_usecount : -99),
-		    (uppervp ? VOP_ISLOCKED(uppervp, NULL) : -99)
-		));
-
-		/*
-		 * Disallow write attemps to the filesystem mounted read-only.
-		 */
-		if (uerror == EJUSTRETURN && (cnp->cn_flags & ISLASTCN) &&
-		    (dvp->v_mount->mnt_flag & MNT_RDONLY) &&
-		    (cnp->cn_nameiop == CREATE || cnp->cn_nameiop == RENAME)) {
-			error = EROFS;
-			goto out;
-		}
-
-		/*
-		 * Special case.  If cn_consume != 0 skip out.  The result
-		 * of the lookup is transfered to our return variable.  If
-		 * an error occured we have to throw away the results.
-		 */
-
-		if (cnp->cn_consume != 0) {
-			if ((error = uerror) == 0) {
-				*ap->a_vpp = uppervp;
-				uppervp = NULL;
-			}
-			goto out;
-		}
-
-		/*
-		 * Calculate whiteout, fall through
-		 */
-
-		if (uerror == ENOENT || uerror == EJUSTRETURN) {
-			if (cnp->cn_flags & ISWHITEOUT) {
-				iswhiteout = 1;
-			} else if (lowerdvp != NULLVP) {
-				int terror;
-
-				terror = VOP_GETATTR(upperdvp, &va,
-					cnp->cn_cred, cnp->cn_proc);
-				if (terror == 0 && (va.va_flags & OPAQUE))
-					iswhiteout = 1;
-			}
-		}
-	}
-
-	/*
-	 * in a similar way to the upper layer, do the lookup
-	 * in the lower layer.   this time, if there is some
-	 * component magic going on, then vput whatever we got
-	 * back from the upper layer and return the lower vnode
-	 * instead.
-	 */
-
-	if (lowerdvp != NULLVP && !iswhiteout) {
-		int nameiop;
-
-		UDEBUG(("B %p\n", lowerdvp));
-
-		/*
-		 * Force only LOOKUPs on the lower node, since
-		 * we won't be making changes to it anyway.
-		 */
-		nameiop = cnp->cn_nameiop;
-		cnp->cn_nameiop = LOOKUP;
-		if (um->um_op == UNMNT_BELOW) {
-			saved_cred = cnp->cn_cred;
-			cnp->cn_cred = um->um_cred;
-		}
-
-		/*
-		 * We shouldn't have to worry about locking interactions
-		 * between the lower layer and our union layer (w.r.t.
-		 * `..' processing) because we don't futz with lowervp
-		 * locks in the union-node instantiation code path.
-		 *
-		 * union_lookup1() requires lowervp to be locked on entry,
-		 * and it will be unlocked on return.  The ref count will
-		 * not change.  On return lowervp doesn't represent anything
-		 * to us so we NULL it out.
-		 */
-		VREF(lowerdvp);
-		vn_lock(lowerdvp, LK_EXCLUSIVE | LK_RETRY, p);
-		lerror = union_lookup1(um->um_lowervp, &lowerdvp, &lowervp, cnp);
-		if (lowerdvp == lowervp)
-			vrele(lowerdvp);
-		else
-			vput(lowerdvp);
-		lowerdvp = NULL;	/* lowerdvp invalid after vput */
-
-		if (um->um_op == UNMNT_BELOW)
-			cnp->cn_cred = saved_cred;
-		cnp->cn_nameiop = nameiop;
-
-		if (cnp->cn_consume != 0 || lerror == EACCES) {
-			if ((error = lerror) == 0) {
-				*ap->a_vpp = lowervp;
-				lowervp = NULL;
-			}
-			goto out;
-		}
-	} else {
-		UDEBUG(("C %p\n", lowerdvp));
-		if ((cnp->cn_flags & ISDOTDOT) && dun->un_pvp != NULLVP) {
-			if ((lowervp = LOWERVP(dun->un_pvp)) != NULL) {
-				VREF(lowervp);
-				vn_lock(lowervp, LK_EXCLUSIVE | LK_RETRY, p);
-				lerror = 0;
-			}
-		}
-	}
-
-	/*
-	 * Ok.  Now we have uerror, uppervp, upperdvp, lerror, and lowervp.
-	 *
-	 * 1. If both layers returned an error, select the upper layer.
-	 *
-	 * 2. If the upper layer faile and the bottom layer succeeded,
-	 *    two subcases occur:
-	 *
-	 *	a.  The bottom vnode is not a directory, in which case
-	 *	    just return a new union vnode referencing an
-	 *	    empty top layer and the existing bottom layer.
-	 *
-	 *	b.  The button vnode is a directory, in which case
-	 *	    create a new directory in the top layer and
-	 *	    and fall through to case 3.
-	 *
-	 * 3. If the top layer succeeded then return a new union
-	 *    vnode referencing whatever the new top layer and
-	 *    whatever the bottom layer returned.
-	 */
-
-	/* case 1. */
-	if ((uerror != 0) && (lerror != 0)) {
-		error = uerror;
-		goto out;
-	}
-
-	/* case 2. */
-	if (uerror != 0 /* && (lerror == 0) */ ) {
-		if (lowervp->v_type == VDIR) { /* case 2b. */
-			KASSERT(uppervp == NULL, ("uppervp unexpectedly non-NULL"));
-			/*
-			 * oops, uppervp has a problem, we may have to shadow.
-			 */
-			uerror = union_mkshadow(um, upperdvp, cnp, &uppervp);
-			if (uerror) {
-				error = uerror;
-				goto out;
-			}
-		}
-	}
-
-	/*
-	 * Must call union_allocvp with both the upper and lower vnodes
-	 * referenced and the upper vnode locked.   ap->a_vpp is returned 
-	 * referenced and locked.  lowervp, uppervp, and upperdvp are 
-	 * absorbed by union_allocvp() whether it succeeds or fails.
-	 *
-	 * upperdvp is the parent directory of uppervp which may be
-	 * different, depending on the path, from dvp->un_uppervp.  That's
-	 * why it is a separate argument.  Note that it must be unlocked.
-	 *
-	 * dvp must be locked on entry to the call and will be locked on
-	 * return.
-	 */
-
-	if (uppervp && uppervp != upperdvp)
-		VOP_UNLOCK(uppervp, 0, p);
-	if (lowervp)
-		VOP_UNLOCK(lowervp, 0, p);
-	if (upperdvp)
-		VOP_UNLOCK(upperdvp, 0, p);
-
-	error = union_allocvp(ap->a_vpp, dvp->v_mount, dvp, upperdvp, cnp,
-			      uppervp, lowervp, 1);
-
-	UDEBUG(("Create %p = %p %p refs=%d\n", *ap->a_vpp, uppervp, lowervp, (*ap->a_vpp) ? ((*ap->a_vpp)->v_usecount) : -99));
-
-	uppervp = NULL;
-	upperdvp = NULL;
-	lowervp = NULL;
-
-	/* 
-	 *	Termination Code
-	 *
-	 *	- put away any extra junk laying around.  Note that lowervp
-	 *	  (if not NULL) will never be the same as *ap->a_vp and 
-	 *	  neither will uppervp, because when we set that state we 
-	 *	  NULL-out lowervp or uppervp.  On the otherhand, upperdvp
-	 *	  may match uppervp or *ap->a_vpp.
-	 *
-	 *	- relock/unlock dvp if appropriate.
-	 */
-
-out:
-	if (upperdvp) {
-		if (upperdvp == uppervp || upperdvp == *ap->a_vpp)
-			vrele(upperdvp);
-		else
-			vput(upperdvp);
-	}
-
-	if (uppervp)
-		vput(uppervp);
-
-	if (lowervp)
-		vput(lowervp);
-
-	/*
-	 * Restore LOCKPARENT state
-	 */
-
-	if (!lockparent)
-		cnp->cn_flags &= ~LOCKPARENT;
-
-	UDEBUG(("Out %d vpp %p/%d lower %p upper %p\n", error, *ap->a_vpp,
-		((*ap->a_vpp) ? (*ap->a_vpp)->v_usecount : -99),
-		lowervp, uppervp));
-
-	/*
-	 * dvp lock state, determine whether to relock dvp.  dvp is expected
-	 * to be locked on return if:
-	 *
-	 *	- there was an error (except not EJUSTRETURN), or
-	 *	- we hit the last component and lockparent is true
-	 *
-	 * dvp_is_locked is the current state of the dvp lock, not counting
-	 * the possibility that *ap->a_vpp == dvp (in which case it is locked
-	 * anyway).  Note that *ap->a_vpp == dvp only if no error occured.
-	 */
-
-	if (*ap->a_vpp != dvp) {
-		if ((error == 0 || error == EJUSTRETURN) &&
-		    (!lockparent || (cnp->cn_flags & ISLASTCN) == 0)) {
-			VOP_UNLOCK(dvp, 0, p);
-		}
-	}
-
-	/*
-	 * Diagnostics
-	 */
-
-#ifdef DIAGNOSTIC
-	if (cnp->cn_namelen == 1 &&
-	    cnp->cn_nameptr[0] == '.' &&
-	    *ap->a_vpp != dvp) {
-		panic("union_lookup returning . (%p) not same as startdir (%p)", ap->a_vpp, dvp);
-	}
-#endif
-
-	return (error);
-}
-
-/*
- * 	union_create:
- *
- * a_dvp is locked on entry and remains locked on return.  a_vpp is returned
- * locked if no error occurs, otherwise it is garbage.
- */
-
-static int
-union_create(ap)
-	struct vop_create_args /* {
-		struct vnode *a_dvp;
-		struct vnode **a_vpp;
-		struct componentname *a_cnp;
-		struct vattr *a_vap;
-	} */ *ap;
-{
-	struct union_node *dun = VTOUNION(ap->a_dvp);
-	struct componentname *cnp = ap->a_cnp;
-	struct proc *p = cnp->cn_proc;
-	struct vnode *dvp;
-	int error = EROFS;
-
-	if ((dvp = union_lock_upper(dun, p)) != NULL) {
-		struct vnode *vp;
-		struct mount *mp;
-
-		error = VOP_CREATE(dvp, &vp, cnp, ap->a_vap);
-		if (error == 0) {
-			mp = ap->a_dvp->v_mount;
-			VOP_UNLOCK(vp, 0, p);
-			UDEBUG(("ALLOCVP-1 FROM %p REFS %d\n", vp, vp->v_usecount));
-			error = union_allocvp(ap->a_vpp, mp, NULLVP, NULLVP,
-				cnp, vp, NULLVP, 1);
-			UDEBUG(("ALLOCVP-2B FROM %p REFS %d\n", *ap->a_vpp, vp->v_usecount));
-		}
-		union_unlock_upper(dvp, p);
-	}
-	return (error);
-}
-
-static int
-union_whiteout(ap)
-	struct vop_whiteout_args /* {
-		struct vnode *a_dvp;
-		struct componentname *a_cnp;
-		int a_flags;
-	} */ *ap;
-{
-	struct union_node *un = VTOUNION(ap->a_dvp);
-	struct componentname *cnp = ap->a_cnp;
-	struct vnode *uppervp;
-	int error = EOPNOTSUPP;
-
-	if ((uppervp = union_lock_upper(un, cnp->cn_proc)) != NULLVP) {
-		error = VOP_WHITEOUT(un->un_uppervp, cnp, ap->a_flags);
-		union_unlock_upper(uppervp, cnp->cn_proc);
-	}
-	return(error);
-}
-
-/*
- * 	union_mknod:
- *
- *	a_dvp is locked on entry and should remain locked on return.
- *	a_vpp is garbagre whether an error occurs or not.
- */
-
-static int
-union_mknod(ap)
-	struct vop_mknod_args /* {
-		struct vnode *a_dvp;
-		struct vnode **a_vpp;
-		struct componentname *a_cnp;
-		struct vattr *a_vap;
-	} */ *ap;
-{
-	struct union_node *dun = VTOUNION(ap->a_dvp);
-	struct componentname *cnp = ap->a_cnp;
-	struct vnode *dvp;
-	int error = EROFS;
-
-	if ((dvp = union_lock_upper(dun, cnp->cn_proc)) != NULL) {
-		error = VOP_MKNOD(dvp, ap->a_vpp, cnp, ap->a_vap);
-		union_unlock_upper(dvp, cnp->cn_proc);
-	}
-	return (error);
-}
-
-/*
- *	union_open:
- *
- *	run open VOP.  When opening the underlying vnode we have to mimic
- *	vn_open.  What we *really* need to do to avoid screwups if the
- *	open semantics change is to call vn_open().  For example, ufs blows
- *	up if you open a file but do not vmio it prior to writing.
- */
-
-static int
-union_open(ap)
-	struct vop_open_args /* {
-		struct vnodeop_desc *a_desc;
-		struct vnode *a_vp;
-		int a_mode;
-		struct ucred *a_cred;
-		struct proc *a_p;
-	} */ *ap;
-{
-	struct union_node *un = VTOUNION(ap->a_vp);
-	struct vnode *tvp;
-	int mode = ap->a_mode;
-	struct ucred *cred = ap->a_cred;
-	struct proc *p = ap->a_p;
-	int error = 0;
-	int tvpisupper = 1;
-
-	/*
-	 * If there is an existing upper vp then simply open that.
-	 * The upper vp takes precedence over the lower vp.  When opening
-	 * a lower vp for writing copy it to the uppervp and then open the
-	 * uppervp.
-	 *
-	 * At the end of this section tvp will be left locked.
-	 */
-	if ((tvp = union_lock_upper(un, p)) == NULLVP) {
-		/*
-		 * If the lower vnode is being opened for writing, then
-		 * copy the file contents to the upper vnode and open that,
-		 * otherwise can simply open the lower vnode.
-		 */
-		tvp = un->un_lowervp;
-		if ((ap->a_mode & FWRITE) && (tvp->v_type == VREG)) {
-			int docopy = !(mode & O_TRUNC);
-			error = union_copyup(un, docopy, cred, p);
-			tvp = union_lock_upper(un, p);
-		} else {
-			un->un_openl++;
-			VREF(tvp);
-			vn_lock(tvp, LK_EXCLUSIVE | LK_RETRY, p);
-			tvpisupper = 0;
-		}
-	}
-
-	/*
-	 * We are holding the correct vnode, open it
-	 */
-
-	if (error == 0)
-		error = VOP_OPEN(tvp, mode, cred, p);
-
-	/*
-	 * Absolutely necessary or UFS will blowup
-	 */
-        if (error == 0 && vn_canvmio(tvp) == TRUE) {
-                error = vfs_object_create(tvp, p, cred);
-        }
-
-	/*
-	 * Release any locks held
-	 */
-	if (tvpisupper) {
-		if (tvp)
-			union_unlock_upper(tvp, p);
-	} else {
-		vput(tvp);
-	}
-	return (error);
-}
-
-/*
- *	union_close:
- *
- *	It is unclear whether a_vp is passed locked or unlocked.  Whatever
- *	the case we do not change it.
- */
-
-static int
-union_close(ap)
-	struct vop_close_args /* {
-		struct vnode *a_vp;
-		int  a_fflag;
-		struct ucred *a_cred;
-		struct proc *a_p;
-	} */ *ap;
-{
-	struct union_node *un = VTOUNION(ap->a_vp);
-	struct vnode *vp;
-
-	if ((vp = un->un_uppervp) == NULLVP) {
-#ifdef UNION_DIAGNOSTIC
-		if (un->un_openl <= 0)
-			panic("union: un_openl cnt");
-#endif
-		--un->un_openl;
-		vp = un->un_lowervp;
-	}
-	ap->a_vp = vp;
-	return (VCALL(vp, VOFFSET(vop_close), ap));
-}
-
-/*
- * Check access permission on the union vnode.
- * The access check being enforced is to check
- * against both the underlying vnode, and any
- * copied vnode.  This ensures that no additional
- * file permissions are given away simply because
- * the user caused an implicit file copy.
- */
-static int
-union_access(ap)
-	struct vop_access_args /* {
-		struct vnodeop_desc *a_desc;
-		struct vnode *a_vp;
-		int a_mode;
-		struct ucred *a_cred;
-		struct proc *a_p;
-	} */ *ap;
-{
-	struct union_node *un = VTOUNION(ap->a_vp);
-	struct proc *p = ap->a_p;
-	int error = EACCES;
-	struct vnode *vp;
-
-	/*
-	 * Disallow write attempts on filesystems mounted read-only.
-	 */
-	if ((ap->a_mode & VWRITE) && 
-	    (ap->a_vp->v_mount->mnt_flag & MNT_RDONLY)) {
-		switch (ap->a_vp->v_type) {
-		case VREG: 
-		case VDIR:
-		case VLNK:
-			return (EROFS);
-		default:
-			break;
-		}
-	}
-
-	if ((vp = union_lock_upper(un, p)) != NULLVP) {
-		ap->a_vp = vp;
-		error = VCALL(vp, VOFFSET(vop_access), ap);
-		union_unlock_upper(vp, p);
-		return(error);
-	}
-
-	if ((vp = un->un_lowervp) != NULLVP) {
-		vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
-		ap->a_vp = vp;
-
-		/*
-		 * Remove VWRITE from a_mode if our mount point is RW, because
-		 * we want to allow writes and lowervp may be read-only.
-		 */
-		if ((un->un_vnode->v_mount->mnt_flag & MNT_RDONLY) == 0)
-			ap->a_mode &= ~VWRITE;
-
-		error = VCALL(vp, VOFFSET(vop_access), ap);
-		if (error == 0) {
-			struct union_mount *um;
-
-			um = MOUNTTOUNIONMOUNT(un->un_vnode->v_mount);
-
-			if (um->um_op == UNMNT_BELOW) {
-				ap->a_cred = um->um_cred;
-				error = VCALL(vp, VOFFSET(vop_access), ap);
-			}
-		}
-		VOP_UNLOCK(vp, 0, p);
-	}
-	return(error);
-}
-
-/*
- * We handle getattr only to change the fsid and
- * track object sizes
- *
- * It's not clear whether VOP_GETATTR is to be
- * called with the vnode locked or not.  stat() calls
- * it with (vp) locked, and fstat calls it with
- * (vp) unlocked. 
- *
- * Because of this we cannot use our normal locking functions
- * if we do not intend to lock the main a_vp node.  At the moment
- * we are running without any specific locking at all, but beware
- * to any programmer that care must be taken if locking is added
- * to this function.
- */
-
-static int
-union_getattr(ap)
-	struct vop_getattr_args /* {
-		struct vnode *a_vp;
-		struct vattr *a_vap;
-		struct ucred *a_cred;
-		struct proc *a_p;
-	} */ *ap;
-{
-	int error;
-	struct union_node *un = VTOUNION(ap->a_vp);
-	struct vnode *vp;
-	struct vattr *vap;
-	struct vattr va;
-
-	/*
-	 * Some programs walk the filesystem hierarchy by counting
-	 * links to directories to avoid stat'ing all the time.
-	 * This means the link count on directories needs to be "correct".
-	 * The only way to do that is to call getattr on both layers
-	 * and fix up the link count.  The link count will not necessarily
-	 * be accurate but will be large enough to defeat the tree walkers.
-	 */
-
-	vap = ap->a_vap;
-
-	if ((vp = un->un_uppervp) != NULLVP) {
-		error = VOP_GETATTR(vp, vap, ap->a_cred, ap->a_p);
-		if (error)
-			return (error);
-		/* XXX isn't this dangerouso without a lock? */
-		union_newsize(ap->a_vp, vap->va_size, VNOVAL);
-	}
-
-	if (vp == NULLVP) {
-		vp = un->un_lowervp;
-	} else if (vp->v_type == VDIR && un->un_lowervp != NULLVP) {
-		vp = un->un_lowervp;
-		vap = &va;
-	} else {
-		vp = NULLVP;
-	}
-
-	if (vp != NULLVP) {
-		error = VOP_GETATTR(vp, vap, ap->a_cred, ap->a_p);
-		if (error)
-			return (error);
-		/* XXX isn't this dangerous without a lock? */
-		union_newsize(ap->a_vp, VNOVAL, vap->va_size);
-	}
-
-	if ((vap != ap->a_vap) && (vap->va_type == VDIR))
-		ap->a_vap->va_nlink += vap->va_nlink;
-	return (0);
-}
-
-static int
-union_setattr(ap)
-	struct vop_setattr_args /* {
-		struct vnode *a_vp;
-		struct vattr *a_vap;
-		struct ucred *a_cred;
-		struct proc *a_p;
-	} */ *ap;
-{
-	struct union_node *un = VTOUNION(ap->a_vp);
-	struct proc *p = ap->a_p;
-	struct vattr *vap = ap->a_vap;
-	struct vnode *uppervp;
-	int error;
-
-	/*
-	 * Disallow write attempts on filesystems mounted read-only.
-	 */
-	if ((ap->a_vp->v_mount->mnt_flag & MNT_RDONLY) &&
-	    (vap->va_flags != VNOVAL || vap->va_uid != (uid_t)VNOVAL ||
-	     vap->va_gid != (gid_t)VNOVAL || vap->va_atime.tv_sec != VNOVAL ||
-	     vap->va_mtime.tv_sec != VNOVAL || 
-	     vap->va_mode != (mode_t)VNOVAL)) {
-		return (EROFS);
-	}
-
-	/*
-	 * Handle case of truncating lower object to zero size,
-	 * by creating a zero length upper object.  This is to
-	 * handle the case of open with O_TRUNC and O_CREAT.
-	 */
-	if (un->un_uppervp == NULLVP && (un->un_lowervp->v_type == VREG)) {
-		error = union_copyup(un, (ap->a_vap->va_size != 0),
-			    ap->a_cred, ap->a_p);
-		if (error)
-			return (error);
-	}
-
-	/*
-	 * Try to set attributes in upper layer,
-	 * otherwise return read-only filesystem error.
-	 */
-	error = EROFS;
-	if ((uppervp = union_lock_upper(un, p)) != NULLVP) {
-		error = VOP_SETATTR(un->un_uppervp, ap->a_vap,
-					ap->a_cred, ap->a_p);
-		if ((error == 0) && (ap->a_vap->va_size != VNOVAL))
-			union_newsize(ap->a_vp, ap->a_vap->va_size, VNOVAL);
-		union_unlock_upper(uppervp, p);
-	}
-	return (error);
-}
-
-static int
-union_read(ap)
-	struct vop_read_args /* {
-		struct vnode *a_vp;
-		struct uio *a_uio;
-		int  a_ioflag;
-		struct ucred *a_cred;
-	} */ *ap;
-{
-	struct union_node *un = VTOUNION(ap->a_vp);
-	struct proc *p = ap->a_uio->uio_procp;
-	struct vnode *uvp;
-	int error;
-
-	uvp = union_lock_other(un, p);
-	KASSERT(uvp != NULL, ("union_read: backing vnode missing!"));
-
-	error = VOP_READ(uvp, ap->a_uio, ap->a_ioflag, ap->a_cred);
-	union_unlock_other(uvp, p);
-
-	/*
-	 * XXX
-	 * perhaps the size of the underlying object has changed under
-	 * our feet.  take advantage of the offset information present
-	 * in the uio structure.
-	 */
-	if (error == 0) {
-		struct union_node *un = VTOUNION(ap->a_vp);
-		off_t cur = ap->a_uio->uio_offset;
-
-		if (uvp == un->un_uppervp) {
-			if (cur > un->un_uppersz)
-				union_newsize(ap->a_vp, cur, VNOVAL);
-		} else {
-			if (cur > un->un_lowersz)
-				union_newsize(ap->a_vp, VNOVAL, cur);
-		}
-	}
-	return (error);
-}
-
-static int
-union_write(ap)
-	struct vop_read_args /* {
-		struct vnode *a_vp;
-		struct uio *a_uio;
-		int  a_ioflag;
-		struct ucred *a_cred;
-	} */ *ap;
-{
-	struct union_node *un = VTOUNION(ap->a_vp);
-	struct proc *p = ap->a_uio->uio_procp;
-	struct vnode *uppervp;
-	int error;
-
-	if ((uppervp = union_lock_upper(un, p)) == NULLVP)
-		panic("union: missing upper layer in write");
-
-	error = VOP_WRITE(uppervp, ap->a_uio, ap->a_ioflag, ap->a_cred);
-
-	/*
-	 * the size of the underlying object may be changed by the
-	 * write.
-	 */
-	if (error == 0) {
-		off_t cur = ap->a_uio->uio_offset;
-
-		if (cur > un->un_uppersz)
-			union_newsize(ap->a_vp, cur, VNOVAL);
-	}
-	union_unlock_upper(uppervp, p);
-	return (error);
-}
-
-static int
-union_lease(ap)
-	struct vop_lease_args /* {
-		struct vnode *a_vp;
-		struct proc *a_p;
-		struct ucred *a_cred;
-		int a_flag;
-	} */ *ap;
-{
-	struct vnode *ovp = OTHERVP(ap->a_vp);
-
-	ap->a_vp = ovp;
-	return (VCALL(ovp, VOFFSET(vop_lease), ap));
-}
-
-static int
-union_ioctl(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;
-	} */ *ap;
-{
-	struct vnode *ovp = OTHERVP(ap->a_vp);
-
-	ap->a_vp = ovp;
-	return (VCALL(ovp, VOFFSET(vop_ioctl), ap));
-}
-
-static int
-union_poll(ap)
-	struct vop_poll_args /* {
-		struct vnode *a_vp;
-		int  a_events;
-		struct ucred *a_cred;
-		struct proc *a_p;
-	} */ *ap;
-{
-	struct vnode *ovp = OTHERVP(ap->a_vp);
-
-	ap->a_vp = ovp;
-	return (VCALL(ovp, VOFFSET(vop_poll), ap));
-}
-
-static int
-union_revoke(ap)
-	struct vop_revoke_args /* {
-		struct vnode *a_vp;
-		int a_flags;
-		struct proc *a_p;
-	} */ *ap;
-{
-	struct vnode *vp = ap->a_vp;
-
-	if (UPPERVP(vp))
-		VOP_REVOKE(UPPERVP(vp), ap->a_flags);
-	if (LOWERVP(vp))
-		VOP_REVOKE(LOWERVP(vp), ap->a_flags);
-	vgone(vp);
-	return (0);
-}
-
-static int
-union_fsync(ap)
-	struct vop_fsync_args /* {
-		struct vnode *a_vp;
-		struct ucred *a_cred;
-		int  a_waitfor;
-		struct proc *a_p;
-	} */ *ap;
-{
-	int error = 0;
-	struct proc *p = ap->a_p;
-	struct vnode *targetvp;
-	struct union_node *un = VTOUNION(ap->a_vp);
-
-	if ((targetvp = union_lock_other(un, p)) != NULLVP) {
-		error = VOP_FSYNC(targetvp, ap->a_cred, ap->a_waitfor, p);
-		union_unlock_other(targetvp, p);
-	}
-
-	return (error);
-}
-
-/*
- *	union_remove:
- *
- *	Remove the specified cnp.  The dvp and vp are passed to us locked
- *	and must remain locked on return.
- */
-
-static int
-union_remove(ap)
-	struct vop_remove_args /* {
-		struct vnode *a_dvp;
-		struct vnode *a_vp;
-		struct componentname *a_cnp;
-	} */ *ap;
-{
-	struct union_node *dun = VTOUNION(ap->a_dvp);
-	struct union_node *un = VTOUNION(ap->a_vp);
-	struct componentname *cnp = ap->a_cnp;
-	struct proc *p = cnp->cn_proc;
-	struct vnode *uppervp;
-	struct vnode *upperdvp;
-	int error;
-
-	if ((upperdvp = union_lock_upper(dun, p)) == NULLVP)
-		panic("union remove: null upper vnode");
-
-	if ((uppervp = union_lock_upper(un, p)) != NULLVP) {
-		if (union_dowhiteout(un, cnp->cn_cred, p))
-			cnp->cn_flags |= DOWHITEOUT;
-		error = VOP_REMOVE(upperdvp, uppervp, cnp);
-#if 0
-		/* XXX */
-		if (!error)
-			union_removed_upper(un);
-#endif
-		union_unlock_upper(uppervp, p);
-	} else {
-		error = union_mkwhiteout(
-			    MOUNTTOUNIONMOUNT(ap->a_dvp->v_mount),
-			    upperdvp, ap->a_cnp, un->un_path);
-	}
-	union_unlock_upper(upperdvp, p);
-	return (error);
-}
-
-/*
- *	union_link:
- *
- *	tdvp will be locked on entry, vp will not be locked on entry.
- *	tdvp should remain locked on return and vp should remain unlocked
- *	on return.
- */
-
-static int
-union_link(ap)
-	struct vop_link_args /* {
-		struct vnode *a_tdvp;
-		struct vnode *a_vp;
-		struct componentname *a_cnp;
-	} */ *ap;
-{
-	struct componentname *cnp = ap->a_cnp;
-	struct proc *p = cnp->cn_proc;
-	struct union_node *dun = VTOUNION(ap->a_tdvp);
-	struct vnode *vp;
-	struct vnode *tdvp;
-	int error = 0;
-
-	if (ap->a_tdvp->v_op != ap->a_vp->v_op) {
-		vp = ap->a_vp;
-	} else {
-		struct union_node *tun = VTOUNION(ap->a_vp);
-
-		if (tun->un_uppervp == NULLVP) {
-			vn_lock(ap->a_vp, LK_EXCLUSIVE | LK_RETRY, p);
-#if 0
-			if (dun->un_uppervp == tun->un_dirvp) {
-				if (dun->un_flags & UN_ULOCK) {
-					dun->un_flags &= ~UN_ULOCK;
-					VOP_UNLOCK(dun->un_uppervp, 0, p);
-				}
-			}
-#endif
-			error = union_copyup(tun, 1, cnp->cn_cred, p);
-#if 0
-			if (dun->un_uppervp == tun->un_dirvp) {
-				vn_lock(dun->un_uppervp,
-					    LK_EXCLUSIVE | LK_RETRY, p);
-				dun->un_flags |= UN_ULOCK;
-			}
-#endif
-			VOP_UNLOCK(ap->a_vp, 0, p);
-		}
-		vp = tun->un_uppervp;
-	}
-
-	if (error)
-		return (error);
-
-	/*
-	 * Make sure upper is locked, then unlock the union directory we were 
-	 * called with to avoid a deadlock while we are calling VOP_LINK on 
-	 * the upper (with tdvp locked and vp not locked).  Our ap->a_tdvp
-	 * is expected to be locked on return.
-	 */
-
-	if ((tdvp = union_lock_upper(dun, p)) == NULLVP)
-		return (EROFS);
-
-	VOP_UNLOCK(ap->a_tdvp, 0, p);		/* unlock calling node */
-	error = VOP_LINK(tdvp, vp, cnp);	/* call link on upper */
-
-	/*
-	 * We have to unlock tdvp prior to relocking our calling node in
-	 * order to avoid a deadlock.
-	 */
-	union_unlock_upper(tdvp, p);
-	vn_lock(ap->a_tdvp, LK_EXCLUSIVE | LK_RETRY, p);
-	return (error);
-}
-
-static int
-union_rename(ap)
-	struct vop_rename_args  /* {
-		struct vnode *a_fdvp;
-		struct vnode *a_fvp;
-		struct componentname *a_fcnp;
-		struct vnode *a_tdvp;
-		struct vnode *a_tvp;
-		struct componentname *a_tcnp;
-	} */ *ap;
-{
-	int error;
-	struct vnode *fdvp = ap->a_fdvp;
-	struct vnode *fvp = ap->a_fvp;
-	struct vnode *tdvp = ap->a_tdvp;
-	struct vnode *tvp = ap->a_tvp;
-
-	/*
-	 * Figure out what fdvp to pass to our upper or lower vnode.  If we
-	 * replace the fdvp, release the original one and ref the new one.
-	 */
-
-	if (fdvp->v_op == union_vnodeop_p) {	/* always true */
-		struct union_node *un = VTOUNION(fdvp);
-		if (un->un_uppervp == NULLVP) {
-			/*
-			 * this should never happen in normal
-			 * operation but might if there was
-			 * a problem creating the top-level shadow
-			 * directory.
-			 */
-			error = EXDEV;
-			goto bad;
-		}
-		fdvp = un->un_uppervp;
-		VREF(fdvp);
-		vrele(ap->a_fdvp);
-	}
-
-	/*
-	 * Figure out what fvp to pass to our upper or lower vnode.  If we
-	 * replace the fvp, release the original one and ref the new one.
-	 */
-
-	if (fvp->v_op == union_vnodeop_p) {	/* always true */
-		struct union_node *un = VTOUNION(fvp);
-#if 0
-		struct union_mount *um = MOUNTTOUNIONMOUNT(fvp->v_mount);
-#endif
-
-		if (un->un_uppervp == NULLVP) {
-			switch(fvp->v_type) {
-			case VREG:
-				vn_lock(un->un_vnode, LK_EXCLUSIVE | LK_RETRY, ap->a_fcnp->cn_proc);
-				error = union_copyup(un, 1, ap->a_fcnp->cn_cred, ap->a_fcnp->cn_proc);
-				VOP_UNLOCK(un->un_vnode, 0, ap->a_fcnp->cn_proc);
-				if (error)
-					goto bad;
-				break;
-			case VDIR:
-				/*
-				 * XXX not yet.
-				 *
-				 * There is only one way to rename a directory
-				 * based in the lowervp, and that is to copy
-				 * the entire directory hierarchy.  Otherwise
-				 * it would not last across a reboot.
-				 */
-#if 0
-				vrele(fvp);
-				fvp = NULL;
-				vn_lock(fdvp, LK_EXCLUSIVE | LK_RETRY, ap->a_fcnp->cn_proc);
-				error = union_mkshadow(um, fdvp, 
-					    ap->a_fcnp, &un->un_uppervp);
-				VOP_UNLOCK(fdvp, 0, ap->a_fcnp->cn_proc);
-				if (un->un_uppervp)
-					VOP_UNLOCK(un->un_uppervp, 0, ap->a_fcnp->cn_proc);
-				if (error)
-					goto bad;
-				break;
-#endif
-			default:
-				error = EXDEV;
-				goto bad;
-			}
-		}
-
-		if (un->un_lowervp != NULLVP)
-			ap->a_fcnp->cn_flags |= DOWHITEOUT;
-		fvp = un->un_uppervp;
-		VREF(fvp);
-		vrele(ap->a_fvp);
-	}
-
-	/*
-	 * Figure out what tdvp (destination directory) to pass to the
-	 * lower level.  If we replace it with uppervp, we need to vput the 
-	 * old one.  The exclusive lock is transfered to what we will pass
-	 * down in the VOP_RENAME and we replace uppervp with a simple
-	 * reference.
-	 */
-
-	if (tdvp->v_op == union_vnodeop_p) {
-		struct union_node *un = VTOUNION(tdvp);
-
-		if (un->un_uppervp == NULLVP) {
-			/*
-			 * this should never happen in normal
-			 * operation but might if there was
-			 * a problem creating the top-level shadow
-			 * directory.
-			 */
-			error = EXDEV;
-			goto bad;
-		}
-
-		/*
-		 * new tdvp is a lock and reference on uppervp, put away
-		 * the old tdvp.
-		 */
-		tdvp = union_lock_upper(un, ap->a_tcnp->cn_proc);
-		vput(ap->a_tdvp);
-	}
-
-	/*
-	 * Figure out what tvp (destination file) to pass to the
-	 * lower level.
-	 *
-	 * If the uppervp file does not exist put away the (wrong)
-	 * file and change tvp to NULL.
-	 */
-
-	if (tvp != NULLVP && tvp->v_op == union_vnodeop_p) {
-		struct union_node *un = VTOUNION(tvp);
-
-		tvp = union_lock_upper(un, ap->a_tcnp->cn_proc);
-		vput(ap->a_tvp);
-		/* note: tvp may be NULL */
-	}
-
-	/*
-	 * VOP_RENAME releases/vputs prior to returning, so we have no
-	 * cleanup to do.
-	 */
-
-	return (VOP_RENAME(fdvp, fvp, ap->a_fcnp, tdvp, tvp, ap->a_tcnp));
-
-	/*
-	 * Error.  We still have to release / vput the various elements.
-	 */
-
-bad:
-	vrele(fdvp);
-	if (fvp)
-		vrele(fvp);
-	vput(tdvp);
-	if (tvp != NULLVP) {
-		if (tvp != tdvp)
-			vput(tvp);
-		else
-			vrele(tvp);
-	}
-	return (error);
-}
-
-static int
-union_mkdir(ap)
-	struct vop_mkdir_args /* {
-		struct vnode *a_dvp;
-		struct vnode **a_vpp;
-		struct componentname *a_cnp;
-		struct vattr *a_vap;
-	} */ *ap;
-{
-	struct union_node *dun = VTOUNION(ap->a_dvp);
-	struct componentname *cnp = ap->a_cnp;
-	struct proc *p = cnp->cn_proc;
-	struct vnode *upperdvp;
-	int error = EROFS;
-
-	if ((upperdvp = union_lock_upper(dun, p)) != NULLVP) {
-		struct vnode *vp;
-
-		error = VOP_MKDIR(upperdvp, &vp, cnp, ap->a_vap);
-		union_unlock_upper(upperdvp, p);
-
-		if (error == 0) {
-			VOP_UNLOCK(vp, 0, p);
-			UDEBUG(("ALLOCVP-2 FROM %p REFS %d\n", vp, vp->v_usecount));
-			error = union_allocvp(ap->a_vpp, ap->a_dvp->v_mount,
-				ap->a_dvp, NULLVP, cnp, vp, NULLVP, 1);
-			UDEBUG(("ALLOCVP-2B FROM %p REFS %d\n", *ap->a_vpp, vp->v_usecount));
-		}
-	}
-	return (error);
-}
-
-static int
-union_rmdir(ap)
-	struct vop_rmdir_args /* {
-		struct vnode *a_dvp;
-		struct vnode *a_vp;
-		struct componentname *a_cnp;
-	} */ *ap;
-{
-	struct union_node *dun = VTOUNION(ap->a_dvp);
-	struct union_node *un = VTOUNION(ap->a_vp);
-	struct componentname *cnp = ap->a_cnp;
-	struct proc *p = cnp->cn_proc;
-	struct vnode *upperdvp;
-	struct vnode *uppervp;
-	int error;
-
-	if ((upperdvp = union_lock_upper(dun, p)) == NULLVP)
-		panic("union rmdir: null upper vnode");
-
-	if ((uppervp = union_lock_upper(un, p)) != NULLVP) {
-		if (union_dowhiteout(un, cnp->cn_cred, p))
-			cnp->cn_flags |= DOWHITEOUT;
-		error = VOP_RMDIR(upperdvp, uppervp, ap->a_cnp);
-		union_unlock_upper(uppervp, p);
-	} else {
-		error = union_mkwhiteout(
-			    MOUNTTOUNIONMOUNT(ap->a_dvp->v_mount),
-			    dun->un_uppervp, ap->a_cnp, un->un_path);
-	}
-	union_unlock_upper(upperdvp, p);
-	return (error);
-}
-
-/*
- *	union_symlink:
- *
- *	dvp is locked on entry and remains locked on return.  a_vpp is garbage
- *	(unused).
- */
-
-static int
-union_symlink(ap)
-	struct vop_symlink_args /* {
-		struct vnode *a_dvp;
-		struct vnode **a_vpp;
-		struct componentname *a_cnp;
-		struct vattr *a_vap;
-		char *a_target;
-	} */ *ap;
-{
-	struct union_node *dun = VTOUNION(ap->a_dvp);
-	struct componentname *cnp = ap->a_cnp;
-	struct proc *p = cnp->cn_proc;
-	struct vnode *dvp;
-	int error = EROFS;
-
-	if ((dvp = union_lock_upper(dun, p)) != NULLVP) {
-		error = VOP_SYMLINK(dvp, ap->a_vpp, cnp, ap->a_vap,
-			    ap->a_target);
-		union_unlock_upper(dvp, p);
-	}
-	return (error);
-}
-
-/*
- * union_readdir works in concert with getdirentries and
- * readdir(3) to provide a list of entries in the unioned
- * directories.  getdirentries is responsible for walking
- * down the union stack.  readdir(3) is responsible for
- * eliminating duplicate names from the returned data stream.
- */
-static int
-union_readdir(ap)
-	struct vop_readdir_args /* {
-		struct vnode *a_vp;
-		struct uio *a_uio;
-		struct ucred *a_cred;
-		int *a_eofflag;
-		u_long *a_cookies;
-		int a_ncookies;
-	} */ *ap;
-{
-	struct union_node *un = VTOUNION(ap->a_vp);
-	struct proc *p = ap->a_uio->uio_procp;
-	struct vnode *uvp;
-	int error = 0;
-
-	if ((uvp = union_lock_upper(un, p)) != NULLVP) {
-		ap->a_vp = uvp;
-		error = VCALL(uvp, VOFFSET(vop_readdir), ap);
-		union_unlock_upper(uvp, p);
-	}
-	return(error);
-}
-
-static int
-union_readlink(ap)
-	struct vop_readlink_args /* {
-		struct vnode *a_vp;
-		struct uio *a_uio;
-		struct ucred *a_cred;
-	} */ *ap;
-{
-	int error;
-	struct union_node *un = VTOUNION(ap->a_vp);
-	struct uio *uio = ap->a_uio;
-	struct proc *p = uio->uio_procp;
-	struct vnode *vp;
-
-	vp = union_lock_other(un, p);
-	KASSERT(vp != NULL, ("union_readlink: backing vnode missing!"));
-
-	ap->a_vp = vp;
-	error = VCALL(vp, VOFFSET(vop_readlink), ap);
-	union_unlock_other(vp, p);
-
-	return (error);
-}
-
-static int
-union_getwritemount(ap)
-	struct vop_getwritemount_args /* {
-		struct vnode *a_vp;
-		struct mount **a_mpp;
-	} */ *ap;
-{
-	struct vnode *vp = ap->a_vp;
-	struct vnode *uvp = UPPERVP(vp);
-
-	if (uvp == NULL) {
-		VI_LOCK(vp);
-		if (vp->v_flag & VFREE) {
-			VI_UNLOCK(vp);
-			return (EOPNOTSUPP);
-		}
-		VI_UNLOCK(vp);
-		return (EACCES);
-	}
-	return(VOP_GETWRITEMOUNT(uvp, ap->a_mpp));
-}
-
-/*
- *	union_inactive:
- *
- *	Called with the vnode locked.  We are expected to unlock the vnode.
- */
-
-static int
-union_inactive(ap)
-	struct vop_inactive_args /* {
-		struct vnode *a_vp;
-		struct proc *a_p;
-	} */ *ap;
-{
-	struct vnode *vp = ap->a_vp;
-	struct proc *p = ap->a_p;
-	struct union_node *un = VTOUNION(vp);
-	struct vnode **vpp;
-
-	/*
-	 * Do nothing (and _don't_ bypass).
-	 * Wait to vrele lowervp until reclaim,
-	 * so that until then our union_node is in the
-	 * cache and reusable.
-	 *
-	 * NEEDSWORK: Someday, consider inactive'ing
-	 * the lowervp and then trying to reactivate it
-	 * with capabilities (v_id)
-	 * like they do in the name lookup cache code.
-	 * That's too much work for now.
-	 */
-
-	if (un->un_dircache != 0) {
-		for (vpp = un->un_dircache; *vpp != NULLVP; vpp++)
-			vrele(*vpp);
-		free (un->un_dircache, M_TEMP);
-		un->un_dircache = 0;
-	}
-
-#if 0
-	if ((un->un_flags & UN_ULOCK) && un->un_uppervp) {
-		un->un_flags &= ~UN_ULOCK;
-		VOP_UNLOCK(un->un_uppervp, 0, p);
-	}
-#endif
-
-	VOP_UNLOCK(vp, 0, p);
-
-	if ((un->un_flags & UN_CACHED) == 0)
-		vgone(vp);
-
-	return (0);
-}
-
-static int
-union_reclaim(ap)
-	struct vop_reclaim_args /* {
-		struct vnode *a_vp;
-	} */ *ap;
-{
-	union_freevp(ap->a_vp);
-
-	return (0);
-}
-
-static int
-union_lock(ap)
-	struct vop_lock_args *ap;
-{
-#if 0
-	struct vnode *vp = ap->a_vp;
-	struct proc *p = ap->a_p;
-	int flags = ap->a_flags;
-	struct union_node *un;
-#endif
-	int error;
-
-	error = vop_stdlock(ap);
-#if 0
-	un = VTOUNION(vp);
-
-	if (error == 0) {
-		/*
-		 * Lock the upper if it exists and this is an exclusive lock
-		 * request.
-		 */
-		if (un->un_uppervp != NULLVP && 
-		    (flags & LK_TYPE_MASK) == LK_EXCLUSIVE) {
-			if ((un->un_flags & UN_ULOCK) == 0 && vp->v_usecount) {
-				error = vn_lock(un->un_uppervp, flags, p);
-				if (error) {
-					struct vop_unlock_args uap = { 0 };
-					uap.a_vp = ap->a_vp;
-					uap.a_flags = ap->a_flags;
-					uap.a_p = ap->a_p;
-					vop_stdunlock(&uap);
-					return (error);
-				}
-				un->un_flags |= UN_ULOCK;
-			}
-		}
-	}
-#endif
-	return (error);
-}
-
-/*
- *	union_unlock:
- *
- *	Unlock our union node.  This also unlocks uppervp.  
- */
-static int
-union_unlock(ap)
-	struct vop_unlock_args /* {
-		struct vnode *a_vp;
-		int a_flags;
-		struct proc *a_p;
-	} */ *ap;
-{
-#if 0
-	struct union_node *un = VTOUNION(ap->a_vp);
-#endif
-	int error;
-
-#if 0
-	KASSERT((un->un_uppervp == NULL || un->un_uppervp->v_usecount > 0), ("uppervp usecount is 0"));
-#endif
-
-	error = vop_stdunlock(ap);
-#if 0
-
-	/*
-	 * If no exclusive locks remain and we are holding an uppervp lock,
-	 * remove the uppervp lock.
-	 */
-
-	if ((un->un_flags & UN_ULOCK) && 
-	    lockstatus(&un->un_lock, NULL) != LK_EXCLUSIVE) {
-		un->un_flags &= ~UN_ULOCK;
-		VOP_UNLOCK(un->un_uppervp, LK_EXCLUSIVE, p);
-	}
-#endif
-	return(error);
-}
-
-/*
- * unionvp do not hold a VM object and there is no need to create one for
- * upper or lower vp because it is done in the union_open()
- */
-static int
-union_createvobject(ap)
-	struct vop_createvobject_args /* {
-		struct vnode *vp;
-		struct ucred *cred;
-		struct proc *p;
-	} */ *ap;
-{
-	struct vnode *vp = ap->a_vp;
-
-	vp->v_flag |= VOBJBUF;
-	return (0);
-}
-
-/*
- * We have nothing to destroy and this operation shouldn't be bypassed.
- */
-static int
-union_destroyvobject(ap)
-	struct vop_destroyvobject_args /* {
-		struct vnode *vp;
-	} */ *ap;
-{
-	struct vnode *vp = ap->a_vp;
-
-	vp->v_flag &= ~VOBJBUF;
-	return (0);
-}
-
-/*
- * Get VM object from the upper or lower vp
- */
-static int
-union_getvobject(ap)
-	struct vop_getvobject_args /* {
-		struct vnode *vp;
-		struct vm_object **objpp;
-	} */ *ap;
-{
-	struct vnode *ovp = OTHERVP(ap->a_vp);
-
-	if (ovp == NULL)
-		return EINVAL;
-	return (VOP_GETVOBJECT(ovp, ap->a_objpp));
-}
-
-static int
-union_print(ap)
-	struct vop_print_args /* {
-		struct vnode *a_vp;
-	} */ *ap;
-{
-	struct vnode *vp = ap->a_vp;
-
-	printf("\ttag VT_UNION, vp=%p, uppervp=%p, lowervp=%p\n",
-			vp, UPPERVP(vp), LOWERVP(vp));
-	if (UPPERVP(vp) != NULLVP)
-		vprint("union: upper", UPPERVP(vp));
-	if (LOWERVP(vp) != NULLVP)
-		vprint("union: lower", LOWERVP(vp));
-
-	return (0);
-}
-
-static int
-union_pathconf(ap)
-	struct vop_pathconf_args /* {
-		struct vnode *a_vp;
-		int a_name;
-		int *a_retval;
-	} */ *ap;
-{
-	int error;
-	struct proc *p = curproc;		/* XXX */
-	struct union_node *un = VTOUNION(ap->a_vp);
-	struct vnode *vp;
-
-	vp = union_lock_other(un, p);
-	KASSERT(vp != NULL, ("union_pathconf: backing vnode missing!"));
-
-	ap->a_vp = vp;
-	error = VCALL(vp, VOFFSET(vop_pathconf), ap);
-	union_unlock_other(vp, p);
-
-	return (error);
-}
-
-static int
-union_advlock(ap)
-	struct vop_advlock_args /* {
-		struct vnode *a_vp;
-		caddr_t  a_id;
-		int  a_op;
-		struct flock *a_fl;
-		int  a_flags;
-	} */ *ap;
-{
-	register struct vnode *ovp = OTHERVP(ap->a_vp);
-
-	ap->a_vp = ovp;
-	return (VCALL(ovp, VOFFSET(vop_advlock), ap));
-}
-
-
-/*
- * XXX - vop_strategy must be hand coded because it has no
- * YYY - and it is not coherent with anything
- *
- * vnode in its arguments.
- * This goes away with a merged VM/buffer cache.
- */
-static int
-union_strategy(ap)
-	struct vop_strategy_args /* {
-		struct vnode *a_vp;
-		struct buf *a_bp;
-	} */ *ap;
-{
-	struct buf *bp = ap->a_bp;
-	struct vnode *othervp = OTHERVP(bp->b_vp);
-
-#ifdef DIAGNOSTIC
-	if (othervp == NULLVP)
-		panic("union_strategy: nil vp");
-	if ((bp->b_iocmd == BIO_WRITE) &&
-	    (othervp == LOWERVP(bp->b_vp)))
-		panic("union_strategy: writing to lowervp");
-#endif
-	return (VOP_STRATEGY(othervp, bp));
-}
-
-/*
- * Global vfs data structures
- */
-vop_t **union_vnodeop_p;
-static struct vnodeopv_entry_desc union_vnodeop_entries[] = {
-	{ &vop_default_desc,		(vop_t *) vop_defaultop },
-	{ &vop_access_desc,		(vop_t *) union_access },
-	{ &vop_advlock_desc,		(vop_t *) union_advlock },
-	{ &vop_bmap_desc,		(vop_t *) vop_eopnotsupp },
-	{ &vop_close_desc,		(vop_t *) union_close },
-	{ &vop_create_desc,		(vop_t *) union_create },
-	{ &vop_createvobject_desc,	(vop_t *) union_createvobject },
-	{ &vop_destroyvobject_desc,	(vop_t *) union_destroyvobject },
-	{ &vop_fsync_desc,		(vop_t *) union_fsync },
-	{ &vop_getattr_desc,		(vop_t *) union_getattr },
-	{ &vop_getvobject_desc,		(vop_t *) union_getvobject },
-	{ &vop_inactive_desc,		(vop_t *) union_inactive },
-	{ &vop_ioctl_desc,		(vop_t *) union_ioctl },
-	{ &vop_islocked_desc,		(vop_t *) vop_stdislocked },
-	{ &vop_lease_desc,		(vop_t *) union_lease },
-	{ &vop_link_desc,		(vop_t *) union_link },
-	{ &vop_lock_desc,		(vop_t *) union_lock },
-	{ &vop_lookup_desc,		(vop_t *) union_lookup },
-	{ &vop_mkdir_desc,		(vop_t *) union_mkdir },
-	{ &vop_mknod_desc,		(vop_t *) union_mknod },
-	{ &vop_open_desc,		(vop_t *) union_open },
-	{ &vop_pathconf_desc,		(vop_t *) union_pathconf },
-	{ &vop_poll_desc,		(vop_t *) union_poll },
-	{ &vop_print_desc,		(vop_t *) union_print },
-	{ &vop_read_desc,		(vop_t *) union_read },
-	{ &vop_readdir_desc,		(vop_t *) union_readdir },
-	{ &vop_readlink_desc,		(vop_t *) union_readlink },
-	{ &vop_getwritemount_desc,	(vop_t *) union_getwritemount },
-	{ &vop_reclaim_desc,		(vop_t *) union_reclaim },
-	{ &vop_remove_desc,		(vop_t *) union_remove },
-	{ &vop_rename_desc,		(vop_t *) union_rename },
-	{ &vop_revoke_desc,		(vop_t *) union_revoke },
-	{ &vop_rmdir_desc,		(vop_t *) union_rmdir },
-	{ &vop_setattr_desc,		(vop_t *) union_setattr },
-	{ &vop_strategy_desc,		(vop_t *) union_strategy },
-	{ &vop_symlink_desc,		(vop_t *) union_symlink },
-	{ &vop_unlock_desc,		(vop_t *) union_unlock },
-	{ &vop_whiteout_desc,		(vop_t *) union_whiteout },
-	{ &vop_write_desc,		(vop_t *) union_write },
-	{ NULL, NULL }
-};
-static struct vnodeopv_desc union_vnodeop_opv_desc =
-	{ &union_vnodeop_p, union_vnodeop_entries };
-
-VNODEOP_SET(union_vnodeop_opv_desc);
diff --git a/sys/modules/Makefile b/sys/modules/Makefile
index eac6ea8..f93f393 100644
--- a/sys/modules/Makefile
+++ b/sys/modules/Makefile
@@ -7,12 +7,12 @@ _random=	random
 .endif
 
 SUBDIR=	3dfx accf_data accf_http agp aha amr an aue \
-	cam ccd cd9660 coda cue dc de dgm digi ed fdesc fxp if_disc if_ef \
+	cam ccd cd9660 coda cue dc de dgm digi ed fdescfs fxp if_disc if_ef \
 	if_ppp if_sl if_tap if_tun ip6fw ipfilter ipfw ispfw joy kue \
 	libmchain linux lnc md mfs mii mlx msdos ncp netgraph nfs nge ntfs \
-	nullfs nwfs pcn portal procfs ${_random}  \
+	nullfs nwfs pcn portalfs procfs ${_random}  \
 	rl rp sf sis sk sn sound sppp ste sym syscons sysvipc ti tl twe tx \
-	udbp ugen uhid ukbd ulpt umapfs umass umodem ums union urio usb \
+	udbp ugen uhid ukbd ulpt umapfs umass umodem ums unionfs urio usb \
 	uscanner \
 	vinum vpo vr vx wb wx xl
 
diff --git a/sys/modules/fdesc/Makefile b/sys/modules/fdesc/Makefile
deleted file mode 100644
index 4344517..0000000
--- a/sys/modules/fdesc/Makefile
+++ /dev/null
@@ -1,10 +0,0 @@
-# $FreeBSD$
-
-.PATH: ${.CURDIR}/../../miscfs/fdesc
-
-KMOD=	fdesc
-SRCS=	vnode_if.h \
-	fdesc_vfsops.c fdesc_vnops.c
-NOMAN=
-
-.include <bsd.kmod.mk>
diff --git a/sys/modules/fdescfs/Makefile b/sys/modules/fdescfs/Makefile
index 4344517..dc8b6db 100644
--- a/sys/modules/fdescfs/Makefile
+++ b/sys/modules/fdescfs/Makefile
@@ -1,8 +1,8 @@
 # $FreeBSD$
 
-.PATH: ${.CURDIR}/../../miscfs/fdesc
+.PATH: ${.CURDIR}/../../fs/fdescfs
 
-KMOD=	fdesc
+KMOD=	fdescfs
 SRCS=	vnode_if.h \
 	fdesc_vfsops.c fdesc_vnops.c
 NOMAN=
diff --git a/sys/modules/nullfs/Makefile b/sys/modules/nullfs/Makefile
index 3df3d26..d41ac21 100644
--- a/sys/modules/nullfs/Makefile
+++ b/sys/modules/nullfs/Makefile
@@ -1,6 +1,6 @@
 # $FreeBSD$
 
-.PATH: ${.CURDIR}/../../miscfs/nullfs
+.PATH: ${.CURDIR}/../../fs/nullfs
 
 KMOD=	nullfs
 SRCS=	vnode_if.h \
diff --git a/sys/modules/portal/Makefile b/sys/modules/portal/Makefile
deleted file mode 100644
index a14a8fa..0000000
--- a/sys/modules/portal/Makefile
+++ /dev/null
@@ -1,10 +0,0 @@
-# $FreeBSD$
-
-.PATH: ${.CURDIR}/../../miscfs/portal
-
-KMOD=	portal
-SRCS=	vnode_if.h \
-	portal_vfsops.c portal_vnops.c
-NOMAN=
-
-.include <bsd.kmod.mk>
diff --git a/sys/modules/portalfs/Makefile b/sys/modules/portalfs/Makefile
index a14a8fa..f23e69e 100644
--- a/sys/modules/portalfs/Makefile
+++ b/sys/modules/portalfs/Makefile
@@ -1,8 +1,8 @@
 # $FreeBSD$
 
-.PATH: ${.CURDIR}/../../miscfs/portal
+.PATH: ${.CURDIR}/../../fs/portalfs
 
-KMOD=	portal
+KMOD=	portalfs
 SRCS=	vnode_if.h \
 	portal_vfsops.c portal_vnops.c
 NOMAN=
diff --git a/sys/modules/procfs/Makefile b/sys/modules/procfs/Makefile
index d132b0d..3d9338e 100644
--- a/sys/modules/procfs/Makefile
+++ b/sys/modules/procfs/Makefile
@@ -1,6 +1,6 @@
 # $FreeBSD$
 
-.PATH: ${.CURDIR}/../../miscfs/procfs
+.PATH: ${.CURDIR}/../../fs/procfs
 
 KMOD=	procfs
 SRCS=	vnode_if.h \
diff --git a/sys/modules/umapfs/Makefile b/sys/modules/umapfs/Makefile
index 279a3a4..346f903 100644
--- a/sys/modules/umapfs/Makefile
+++ b/sys/modules/umapfs/Makefile
@@ -1,6 +1,6 @@
 # $FreeBSD$
 
-.PATH: ${.CURDIR}/../../miscfs/umapfs
+.PATH: ${.CURDIR}/../../fs/umapfs
 
 KMOD=	umap
 SRCS=	vnode_if.h \
diff --git a/sys/modules/union/Makefile b/sys/modules/union/Makefile
deleted file mode 100644
index 8f3f852..0000000
--- a/sys/modules/union/Makefile
+++ /dev/null
@@ -1,10 +0,0 @@
-# $FreeBSD$
-
-.PATH: ${.CURDIR}/../../miscfs/union
-
-KMOD=	union
-SRCS=	vnode_if.h \
-	union_subr.c union_vfsops.c union_vnops.c
-NOMAN=
-
-.include <bsd.kmod.mk>
diff --git a/sys/modules/unionfs/Makefile b/sys/modules/unionfs/Makefile
index 8f3f852..2f80909 100644
--- a/sys/modules/unionfs/Makefile
+++ b/sys/modules/unionfs/Makefile
@@ -1,8 +1,8 @@
 # $FreeBSD$
 
-.PATH: ${.CURDIR}/../../miscfs/union
+.PATH: ${.CURDIR}/../../fs/unionfs
 
-KMOD=	union
+KMOD=	unionfs
 SRCS=	vnode_if.h \
 	union_subr.c union_vfsops.c union_vnops.c
 NOMAN=
diff --git a/sys/nfs/nfs_vnops.c b/sys/nfs/nfs_vnops.c
index 61fb9e2..d37615a 100644
--- a/sys/nfs/nfs_vnops.c
+++ b/sys/nfs/nfs_vnops.c
@@ -66,7 +66,7 @@
 #include <vm/vm.h>
 #include <vm/vm_extern.h>
 
-#include <miscfs/fifofs/fifo.h>
+#include <fs/fifofs/fifo.h>
 
 #include <nfs/rpcv2.h>
 #include <nfs/nfsproto.h>
diff --git a/sys/nfsclient/nfs_vnops.c b/sys/nfsclient/nfs_vnops.c
index 61fb9e2..d37615a 100644
--- a/sys/nfsclient/nfs_vnops.c
+++ b/sys/nfsclient/nfs_vnops.c
@@ -66,7 +66,7 @@
 #include <vm/vm.h>
 #include <vm/vm_extern.h>
 
-#include <miscfs/fifofs/fifo.h>
+#include <fs/fifofs/fifo.h>
 
 #include <nfs/rpcv2.h>
 #include <nfs/nfsproto.h>
diff --git a/sys/powerpc/powerpc/procfs_machdep.c b/sys/powerpc/powerpc/procfs_machdep.c
index 06869b0..96fd0e5 100644
--- a/sys/powerpc/powerpc/procfs_machdep.c
+++ b/sys/powerpc/powerpc/procfs_machdep.c
@@ -75,7 +75,7 @@
 
 #include <machine/md_var.h>
 #include <machine/reg.h>
-#include <miscfs/procfs/procfs.h>
+#include <fs/procfs/procfs.h>
 
 #include <vm/vm.h>
 #include <vm/pmap.h>
diff --git a/sys/ufs/ufs/ufs_vnops.c b/sys/ufs/ufs/ufs_vnops.c
index eae3707..7afeca4 100644
--- a/sys/ufs/ufs/ufs_vnops.c
+++ b/sys/ufs/ufs/ufs_vnops.c
@@ -68,7 +68,7 @@
 #include <vm/vm.h>
 #include <vm/vm_extern.h>
 
-#include <miscfs/fifofs/fifo.h>
+#include <fs/fifofs/fifo.h>
 
 #include <ufs/ufs/acl.h>
 #include <ufs/ufs/extattr.h>
diff --git a/usr.sbin/mount_portalfs/Makefile b/usr.sbin/mount_portalfs/Makefile
index 00b96dc..fc332ee 100644
--- a/usr.sbin/mount_portalfs/Makefile
+++ b/usr.sbin/mount_portalfs/Makefile
@@ -7,7 +7,7 @@ SRCS=	mount_portal.c activate.c conf.c getmntopts.c pt_conf.c \
 MAN=	mount_portal.8
 
 MOUNT=	${.CURDIR}/../mount
-CFLAGS+= -I${.CURDIR}/../../sys -I${MOUNT}
+CFLAGS+=-I${MOUNT}
 .PATH:	${MOUNT}
 
 .include <bsd.prog.mk>
diff --git a/usr.sbin/mount_portalfs/portald.h b/usr.sbin/mount_portalfs/portald.h
index 4131834..5837bd7 100644
--- a/usr.sbin/mount_portalfs/portald.h
+++ b/usr.sbin/mount_portalfs/portald.h
@@ -40,7 +40,7 @@
  */
 
 #include <sys/cdefs.h>
-#include <miscfs/portal/portal.h>
+#include <fs/portalfs/portal.h>
 
 /*
  * Meta-chars in an RE.  Paths in the config file containing
diff --git a/usr.sbin/pstat/Makefile b/usr.sbin/pstat/Makefile
index 72a86aa..b96e391 100644
--- a/usr.sbin/pstat/Makefile
+++ b/usr.sbin/pstat/Makefile
@@ -2,7 +2,6 @@
 # $FreeBSD$
 
 PROG=	pstat
-CFLAGS+=-I${.CURDIR}/../../sys
 BINGRP=	kmem
 BINMODE=2555
 DPADD=	${LIBKVM}
diff --git a/usr.sbin/pstat/pstat.c b/usr.sbin/pstat/pstat.c
index 7ac83fb..d8ddfbf 100644
--- a/usr.sbin/pstat/pstat.c
+++ b/usr.sbin/pstat/pstat.c
@@ -56,7 +56,7 @@ static const char rcsid[] =
 #include <sys/mount.h>
 #include <sys/uio.h>
 #include <sys/namei.h>
-#include <miscfs/union/union.h>
+#include <fs/unionfs/union.h>
 #undef _KERNEL
 #include <sys/stat.h>
 #include <nfs/rpcv2.h>