From 2020eb84b5bf565c049698439f1a8ae76de985c6 Mon Sep 17 00:00:00 2001
From: Tomohiro Kusumi <tkusumi@netbsd.org>
Date: Mon, 6 Dec 2021 01:23:39 +0900
Subject: [PATCH] ext2fs: Remove sys/gnu/vfs/ext2fs and make sys/vfs/ext2fs the
 default

This commit removes the old+unstable GPL ext2 implementation,
and makes the new FreeBSD based ext2 implementation the default.

- Remove sys/gnu/vfs.
- Rename sys/vfs/ext2fs/ext2fs_freebsd.ko -> ext2fs.ko.
- Modify unusual userspace program which includes kernel struct.
- Bump __DragonFly_version to 600107.
---
 etc/mtree/BSD.include.dist             |    8 +-
 include/Makefile                       |    3 +-
 lib/libfsid/ext2.c                     |   28 +-
 sys/conf/files                         |   28 +-
 sys/gnu/Makefile                       |    2 +-
 sys/gnu/vfs/Makefile                   |    3 -
 sys/gnu/vfs/ext2fs/COPYRIGHT.INFO      |   54 -
 sys/gnu/vfs/ext2fs/Makefile            |   10 -
 sys/gnu/vfs/ext2fs/dinode.h            |  133 --
 sys/gnu/vfs/ext2fs/dir.h               |  157 --
 sys/gnu/vfs/ext2fs/ext2_alloc.c        |  535 ------
 sys/gnu/vfs/ext2fs/ext2_balloc.c       |  311 ----
 sys/gnu/vfs/ext2fs/ext2_bitops.h       |  114 --
 sys/gnu/vfs/ext2fs/ext2_bmap.c         |  336 ----
 sys/gnu/vfs/ext2fs/ext2_extern.h       |  121 --
 sys/gnu/vfs/ext2fs/ext2_fs.h           |  634 --------
 sys/gnu/vfs/ext2fs/ext2_fs_sb.h        |   84 -
 sys/gnu/vfs/ext2fs/ext2_ihash.c        |  210 ---
 sys/gnu/vfs/ext2fs/ext2_inode.c        |  573 -------
 sys/gnu/vfs/ext2fs/ext2_inode_cnv.c    |  136 --
 sys/gnu/vfs/ext2fs/ext2_linux_balloc.c |  622 -------
 sys/gnu/vfs/ext2fs/ext2_linux_ialloc.c |  515 ------
 sys/gnu/vfs/ext2fs/ext2_linux_super.c  |  133 --
 sys/gnu/vfs/ext2fs/ext2_lookup.c       | 1045 ------------
 sys/gnu/vfs/ext2fs/ext2_mount.h        |  120 --
 sys/gnu/vfs/ext2fs/ext2_quota.c        |  925 -----------
 sys/gnu/vfs/ext2fs/ext2_readwrite.c    |  291 ----
 sys/gnu/vfs/ext2fs/ext2_subr.c         |   83 -
 sys/gnu/vfs/ext2fs/ext2_vfsops.c       | 1241 --------------
 sys/gnu/vfs/ext2fs/ext2_vnops.c        | 2079 ------------------------
 sys/gnu/vfs/ext2fs/fs.h                |  198 ---
 sys/gnu/vfs/ext2fs/inode.h             |  159 --
 sys/gnu/vfs/ext2fs/quota.h             |  200 ---
 sys/sys/param.h                        |    3 +-
 sys/vfs/ext2fs/Makefile                |    2 +-
 usr.bin/fstat/ext2fs.c                 |    6 +-
 36 files changed, 40 insertions(+), 11062 deletions(-)
 delete mode 100644 sys/gnu/vfs/Makefile
 delete mode 100644 sys/gnu/vfs/ext2fs/COPYRIGHT.INFO
 delete mode 100644 sys/gnu/vfs/ext2fs/Makefile
 delete mode 100644 sys/gnu/vfs/ext2fs/dinode.h
 delete mode 100644 sys/gnu/vfs/ext2fs/dir.h
 delete mode 100644 sys/gnu/vfs/ext2fs/ext2_alloc.c
 delete mode 100644 sys/gnu/vfs/ext2fs/ext2_balloc.c
 delete mode 100644 sys/gnu/vfs/ext2fs/ext2_bitops.h
 delete mode 100644 sys/gnu/vfs/ext2fs/ext2_bmap.c
 delete mode 100644 sys/gnu/vfs/ext2fs/ext2_extern.h
 delete mode 100644 sys/gnu/vfs/ext2fs/ext2_fs.h
 delete mode 100644 sys/gnu/vfs/ext2fs/ext2_fs_sb.h
 delete mode 100644 sys/gnu/vfs/ext2fs/ext2_ihash.c
 delete mode 100644 sys/gnu/vfs/ext2fs/ext2_inode.c
 delete mode 100644 sys/gnu/vfs/ext2fs/ext2_inode_cnv.c
 delete mode 100644 sys/gnu/vfs/ext2fs/ext2_linux_balloc.c
 delete mode 100644 sys/gnu/vfs/ext2fs/ext2_linux_ialloc.c
 delete mode 100644 sys/gnu/vfs/ext2fs/ext2_linux_super.c
 delete mode 100644 sys/gnu/vfs/ext2fs/ext2_lookup.c
 delete mode 100644 sys/gnu/vfs/ext2fs/ext2_mount.h
 delete mode 100644 sys/gnu/vfs/ext2fs/ext2_quota.c
 delete mode 100644 sys/gnu/vfs/ext2fs/ext2_readwrite.c
 delete mode 100644 sys/gnu/vfs/ext2fs/ext2_subr.c
 delete mode 100644 sys/gnu/vfs/ext2fs/ext2_vfsops.c
 delete mode 100644 sys/gnu/vfs/ext2fs/ext2_vnops.c
 delete mode 100644 sys/gnu/vfs/ext2fs/fs.h
 delete mode 100644 sys/gnu/vfs/ext2fs/inode.h
 delete mode 100644 sys/gnu/vfs/ext2fs/quota.h

diff --git a/etc/mtree/BSD.include.dist b/etc/mtree/BSD.include.dist
index b6db5dadbc..8393b342a2 100644
--- a/etc/mtree/BSD.include.dist
+++ b/etc/mtree/BSD.include.dist
@@ -235,12 +235,6 @@
             ..
         ..
     ..
-    gnu
-        vfs
-            ext2fs
-            ..
-        ..
-    ..
     libprop
     ..
     lzma
@@ -444,6 +438,8 @@
     vfs
         autofs
         ..
+        ext2fs
+        ..
         hammer
         ..
         hammer2
diff --git a/include/Makefile b/include/Makefile
index 27f27f7311..ef8db61450 100644
--- a/include/Makefile
+++ b/include/Makefile
@@ -65,7 +65,6 @@ LSUBDIRS= \
 	dev/smbus/smb \
 	dev/video/bktr dev/video/meteor \
 	dev/virtual/nvmm dev/virtual/nvmm/x86 \
-	gnu/vfs/ext2fs \
 	libprop \
 	net/bridge net/tap net/tun net/ppp_layer net/sl \
 	net/pf net/altq \
@@ -92,7 +91,7 @@ LSUBDIRS= \
 	vfs/isofs/cd9660 \
 	vfs/msdosfs vfs/nfs vfs/ntfs \
 	vfs/smbfs vfs/udf vfs/ufs vfs/hammer vfs/hammer2 \
-	vfs/autofs vfs/fuse vfs/tmpfs
+	vfs/autofs vfs/fuse vfs/tmpfs vfs/ext2fs
 
 # For SHARED=symlinks, adjust LSYMSUBDIRS to remove subdirectories whos
 # parent directory is also symlinked, avoiding the source tree being
diff --git a/lib/libfsid/ext2.c b/lib/libfsid/ext2.c
index 68391f3824..6ac90668e4 100644
--- a/lib/libfsid/ext2.c
+++ b/lib/libfsid/ext2.c
@@ -32,24 +32,28 @@
  * SUCH DAMAGE.
  */
 
-#include <gnu/vfs/ext2fs/ext2_fs.h>
-#include <gnu/vfs/ext2fs/fs.h>
-
 #include "libfsid.h"
 
-static char buffer[sizeof(struct ext2_super_block)*2];
+#include <vfs/ext2fs/ext2fs.h>
+#include <vfs/ext2fs/fs.h>
+
+/*
+ * struct ext2fs is actually ext4 compatible,
+ * whereas it used to be using the real ext2 superblock struct.
+ */
+static char buffer[sizeof(struct ext2fs)*2];
 
 fsid_t
 ext2_probe(const char *dev)
 {
-	static struct ext2_super_block *fs;
+	static struct ext2fs *fs;
 
 	if (fsid_dev_read(dev, SBOFF, sizeof(buffer), buffer) != 0)
 		return FSID_UNKNOWN;
 
-	fs = (struct ext2_super_block *)&buffer;
+	fs = (struct ext2fs *)&buffer;
 
-	if (fs->s_magic == EXT2_SUPER_MAGIC)
+	if (fs->e2fs_magic == E2FS_MAGIC)
 		return FSID_EXT2;
 
 	return FSID_UNKNOWN;
@@ -58,17 +62,17 @@ ext2_probe(const char *dev)
 char *
 ext2_volname(const char *dev)
 {
-	static struct ext2_super_block *fs;
+	static struct ext2fs *fs;
 
 	if (fsid_dev_read(dev, SBOFF, sizeof(buffer), buffer) != 0)
 		return NULL;
 
-	fs = (struct ext2_super_block *)&buffer;
+	fs = (struct ext2fs *)&buffer;
 
-	if (fs->s_magic != EXT2_SUPER_MAGIC || fs->s_volume_name[0] == '\0')
+	if (fs->e2fs_magic != E2FS_MAGIC || fs->e2fs_vname[0] == '\0')
 		return NULL;
 
-	fs->s_volume_name[sizeof(fs->s_volume_name) - 1] = '\0';
+	fs->e2fs_vname[sizeof(fs->e2fs_vname) - 1] = '\0';
 
-	return fs->s_volume_name;
+	return fs->e2fs_vname;
 }
diff --git a/sys/conf/files b/sys/conf/files
index 7df20ff711..180698d801 100644
--- a/sys/conf/files
+++ b/sys/conf/files
@@ -1309,20 +1309,20 @@ wpi.fw			optional wpifw					\
 	clean		"wpi.fw"
 dev/netif/xe/if_xe.c			optional xe
 dev/netif/xe/if_xe_pccard.c		optional xe pccard
-gnu/vfs/ext2fs/ext2_alloc.c		optional ext2fs
-gnu/vfs/ext2fs/ext2_balloc.c		optional ext2fs
-gnu/vfs/ext2fs/ext2_bmap.c		optional ext2fs
-gnu/vfs/ext2fs/ext2_inode.c		optional ext2fs
-gnu/vfs/ext2fs/ext2_inode_cnv.c		optional ext2fs
-gnu/vfs/ext2fs/ext2_linux_balloc.c	optional ext2fs
-gnu/vfs/ext2fs/ext2_linux_ialloc.c	optional ext2fs
-gnu/vfs/ext2fs/ext2_linux_super.c	optional ext2fs
-gnu/vfs/ext2fs/ext2_lookup.c		optional ext2fs
-gnu/vfs/ext2fs/ext2_subr.c		optional ext2fs
-gnu/vfs/ext2fs/ext2_vfsops.c		optional ext2fs
-gnu/vfs/ext2fs/ext2_vnops.c		optional ext2fs
-gnu/vfs/ext2fs/ext2_ihash.c		optional ext2fs
-gnu/vfs/ext2fs/ext2_quota.c		optional ext2fs
+vfs/ext2fs/ext2_alloc.c			optional ext2fs
+vfs/ext2fs/ext2_balloc.c		optional ext2fs
+vfs/ext2fs/ext2_bmap.c			optional ext2fs
+vfs/ext2fs/ext2_inode.c			optional ext2fs
+vfs/ext2fs/ext2_inode_cnv.c		optional ext2fs
+vfs/ext2fs/ext2_linux_balloc.c		optional ext2fs
+vfs/ext2fs/ext2_linux_ialloc.c		optional ext2fs
+vfs/ext2fs/ext2_linux_super.c		optional ext2fs
+vfs/ext2fs/ext2_lookup.c		optional ext2fs
+vfs/ext2fs/ext2_subr.c			optional ext2fs
+vfs/ext2fs/ext2_vfsops.c		optional ext2fs
+vfs/ext2fs/ext2_vnops.c			optional ext2fs
+vfs/ext2fs/ext2_ihash.c			optional ext2fs
+vfs/ext2fs/ext2_quota.c			optional ext2fs
 vfs/isofs/cd9660/cd9660_bmap.c	optional cd9660
 vfs/isofs/cd9660/cd9660_lookup.c	optional cd9660
 vfs/isofs/cd9660/cd9660_node.c	optional cd9660
diff --git a/sys/gnu/Makefile b/sys/gnu/Makefile
index 4ac270dcf1..c5d1770f9a 100644
--- a/sys/gnu/Makefile
+++ b/sys/gnu/Makefile
@@ -1,3 +1,3 @@
-SUBDIR=	dev vfs
+SUBDIR=	dev
 
 .include <bsd.subdir.mk>
diff --git a/sys/gnu/vfs/Makefile b/sys/gnu/vfs/Makefile
deleted file mode 100644
index e09e815b38..0000000000
--- a/sys/gnu/vfs/Makefile
+++ /dev/null
@@ -1,3 +0,0 @@
-SUBDIR=ext2fs
-
-.include <bsd.subdir.mk>
diff --git a/sys/gnu/vfs/ext2fs/COPYRIGHT.INFO b/sys/gnu/vfs/ext2fs/COPYRIGHT.INFO
deleted file mode 100644
index 99ed9812e3..0000000000
--- a/sys/gnu/vfs/ext2fs/COPYRIGHT.INFO
+++ /dev/null
@@ -1,54 +0,0 @@
-$FreeBSD: src/sys/gnu/ext2fs/COPYRIGHT.INFO,v 1.3 2000/01/01 11:27:50 bde Exp $
-
-Most of the files in this directory are written by Godmar Back or modified
-by him using the CSRG sources.  Those files are covered by the Berkeley-style
-copyright.  However the following files are covered by GPL.  Since the policy
-of the FreeBSD project is to keep the files with the more restrictive
-copyright in the gnu tree and it is a good idea to keep the filesystem code
-all together, the EXT2FS in its entirety resides under the gnu tree.  Note
-that only the files below are under the GPL.  In the eventuality that these
-files are redesigned or rewritten, this tree can be moved back into the less
-restrictive FreeBSD tree.
-
-	ext2_bitmap.c		(in the cvs attic)
-	ext2_fs.h
-	ext2_fs_i.h
-	ext2_fs_sb.h
-	ext2_linux_balloc.c
-	ext2_linux_ialloc.c
-	ext2_linux_super.c
-	ext2_super.c		(in the cvs attic)
-
-PS.
-	THANKS GODMAR!!!
-
-Note that this port has been modified by John Dyson and others on
-the FreeBSD team, and it is best to send the bug reports to the FreeBSD
-team.  If there are any non-FreeBSD specific bugs, fixes will be sent to
-Godmar to help him fix the original code base.  It is also our intention
-to send Godmar any FreeBSD specific porting changes so that he can keep
-control of his code....
-
-John
-dyson@freebsd.org
-
-		-----------------------------------------
-				04 April 2006
-
-    EXT2 has been divorced from UFS.  The following files have been copied
-    from the UFS tree and renamed:
-
-	dinode.h
-	dir.h
-	ext2_bmap.c
-	ext2_ihash.c
-	ext2_quota.c
-	ext2_mount.h
-	inode.h
-	quota.h
-
-    In addition, all other UFS procedures that EXT2 used to call,
-    especially in ext2_vnops.c and ext2_vfsops.c, have been copied from
-    the UFS tree into the EXT2 tree and renamed.
-
-				Matthew Dillon <dillon@apollo.backplane.com>
diff --git a/sys/gnu/vfs/ext2fs/Makefile b/sys/gnu/vfs/ext2fs/Makefile
deleted file mode 100644
index de6bc29981..0000000000
--- a/sys/gnu/vfs/ext2fs/Makefile
+++ /dev/null
@@ -1,10 +0,0 @@
-# $FreeBSD: src/sys/modules/ext2fs/Makefile,v 1.4.2.1 2002/08/06 14:14:25 mdodd Exp $
-
-KMOD=	ext2fs
-SRCS=	opt_quota.h opt_suiddir.h \
-	ext2_alloc.c ext2_balloc.c ext2_inode.c ext2_inode_cnv.c \
-	ext2_linux_balloc.c ext2_linux_ialloc.c ext2_lookup.c \
-	ext2_subr.c ext2_vfsops.c ext2_vnops.c ext2_bmap.c \
-	ext2_ihash.c ext2_quota.c ext2_linux_super.c
-
-.include <bsd.kmod.mk>
diff --git a/sys/gnu/vfs/ext2fs/dinode.h b/sys/gnu/vfs/ext2fs/dinode.h
deleted file mode 100644
index c84ffd8238..0000000000
--- a/sys/gnu/vfs/ext2fs/dinode.h
+++ /dev/null
@@ -1,133 +0,0 @@
-/*-
- * Copyright (c) 1982, 1989, 1993
- *	The Regents of the University of California.  All rights reserved.
- * (c) UNIX System Laboratories, Inc.
- * All or some portions of this file are derived from material licensed
- * to the University of California by American Telephone and Telegraph
- * Co. or Unix System Laboratories, Inc. and are reproduced herein with
- * the permission of UNIX System Laboratories, Inc.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. 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.
- *
- *	@(#)dinode.h	8.3 (Berkeley) 1/21/94
- * $FreeBSD: src/sys/ufs/ufs/dinode.h,v 1.7 1999/08/28 00:52:27 peter Exp $
- */
-
-#ifndef _VFS_GNU_EXT2FS_DINODE_H_
-#define _VFS_GNU_EXT2FS_DINODE_H_
-
-#include "ext2_fs.h"
-
-/*
- * The root inode is the root of the filesystem.  Inode 0 can't be used for
- * normal purposes and historically bad blocks were linked to inode 1, thus
- * the root inode is 2.  (Inode 1 is no longer used for this purpose, however
- * numerous dump tapes make this assumption, so we are stuck with it).
- */
-#define	EXT2_ROOTINO	((ino_t)EXT2_ROOT_INO)
-
-/*
- * The Whiteout inode# is a dummy non-zero inode number which will
- * never be allocated to a real file.  It is used as a place holder
- * in the directory entry which has been tagged as a DT_W entry.
- * See the comments about EXT2_ROOTINO above.
- *
- * Note that ext2 ondisk specification defines 1 as EXT2_BAD_INO.
- */
-#define	WINO	((ino_t)1)
-
-/*
- * A dinode contains all the meta-data associated with a EXT2 file.
- * This structure defines the on-disk format of a dinode. Since
- * this structure describes an on-disk structure, all its fields
- * are defined by types with precise widths.
- */
-
-typedef __int32_t       ext2_daddr_t;
-
-/* Direct addresses in inode */
-#define	NDADDR	EXT2_NDIR_BLOCKS
-
-/* Indirect addresses in inode */
-#define	NIADDR	(EXT2_N_BLOCKS - EXT2_NDIR_BLOCKS)
-
-struct ext2_dinode {
-	uint16_t	di_mode;	/*   0: IFMT, permissions; see below. */
-	int16_t		di_nlink;	/*   2: File link count. */
-	union {
-		uint16_t oldids[2];	/*   4: Ffs: old user and group ids. */
-		int32_t	  inumber;	/*   4: Lfs: inode number. */
-	} di_u;
-	uint64_t	di_size;	/*   8: File byte count. */
-	int32_t		di_atime;	/*  16: Last access time. */
-	int32_t		di_atimensec;	/*  20: Last access time. */
-	int32_t		di_mtime;	/*  24: Last modified time. */
-	int32_t		di_mtimensec;	/*  28: Last modified time. */
-	int32_t		di_ctime;	/*  32: Last inode change time. */
-	int32_t		di_ctimensec;	/*  36: Last inode change time. */
-	ext2_daddr_t	di_db[NDADDR];	/*  40: Direct disk blocks. */
-	ext2_daddr_t	di_ib[NIADDR];	/*  88: Indirect disk blocks. */
-	uint32_t	di_flags;	/* 100: Status flags (chflags). */
-	int32_t		di_blocks;	/* 104: Blocks actually held. */
-	int32_t		di_gen;		/* 108: Generation number. */
-	uint32_t	di_uid;		/* 112: File owner. */
-	uint32_t	di_gid;		/* 116: File group. */
-	int32_t		di_spare[2];	/* 120: used by ext2fs */
-};
-
-/*
- * The di_db fields may be overlaid with other information for
- * file types that do not have associated disk storage. Block
- * and character devices overlay the first data block with their
- * cdev_t value. Short symbolic links place their path in the
- * di_db area.
- */
-#define	di_inumber	di_u.inumber
-#define	di_ogid		di_u.oldids[1]
-#define	di_ouid		di_u.oldids[0]
-#define	di_rdev		di_db[0]
-#define	di_shortlink	di_db
-#define	MAXSYMLINKLEN	EXT2_MAXSYMLINKLEN
-
-/* File permissions. */
-#define	IEXEC		0000100		/* Executable. */
-#define	IWRITE		0000200		/* Writeable. */
-#define	IREAD		0000400		/* Readable. */
-#define	ISVTX		0001000		/* Sticky bit. */
-#define	ISGID		0002000		/* Set-gid. */
-#define	ISUID		0004000		/* Set-uid. */
-
-/* File types. */
-#define	IFMT		0170000		/* Mask of file type. */
-#define	IFIFO		0010000		/* Named pipe (fifo). */
-#define	IFCHR		0020000		/* Character device. */
-#define	IFDIR		0040000		/* Directory file. */
-#define	IFBLK		0060000		/* Block device. */
-#define	IFREG		0100000		/* Regular file. */
-#define	IFLNK		0120000		/* Symbolic link. */
-#define	IFSOCK		0140000		/* UNIX domain socket. */
-#define	IFWHT		0160000		/* Whiteout. */
-
-#endif /* !_VFS_GNU_EXT2FS_DINODE_H_ */
diff --git a/sys/gnu/vfs/ext2fs/dir.h b/sys/gnu/vfs/ext2fs/dir.h
deleted file mode 100644
index 37f35ce9fe..0000000000
--- a/sys/gnu/vfs/ext2fs/dir.h
+++ /dev/null
@@ -1,157 +0,0 @@
-/*-
- * Copyright (c) 1982, 1986, 1989, 1993
- *	The Regents of the University of California.  All rights reserved.
- * (c) UNIX System Laboratories, Inc.
- * All or some portions of this file are derived from material licensed
- * to the University of California by American Telephone and Telegraph
- * Co. or Unix System Laboratories, Inc. and are reproduced herein with
- * the permission of UNIX System Laboratories, Inc.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. 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.
- *
- *	@(#)dir.h	8.2 (Berkeley) 1/21/94
- * $FreeBSD: src/sys/ufs/ufs/dir.h,v 1.9 1999/08/28 00:52:27 peter Exp $
- */
-
-#ifndef _VFS_GNU_EXT2FS_DIR_H_
-#define	_VFS_GNU_EXT2FS_DIR_H_
-
-#include "ext2_fs.h"
-
-/*
- * Theoretically, directories can be more than 2Gb in length, however, in
- * practice this seems unlikely. So, we define the type doff_t as a 32-bit
- * quantity to keep down the cost of doing lookup on a 32-bit machine.
- */
-#define	doff_t		int32_t
-#define MAXDIRSIZE	(0x7fffffff)
-
-/*
- * A directory consists of some number of blocks of DIRBLKSIZ
- * bytes, where DIRBLKSIZ is chosen such that it can be transferred
- * to disk in a single atomic operation (e.g. 512 bytes on most machines).
- *
- * Each DIRBLKSIZ byte block contains some number of directory entry
- * structures, which are of variable length.  Each directory entry has
- * a struct direct at the front of it, containing its inode number,
- * the length of the entry, and the length of the name contained in
- * the entry.  These are followed by the name padded to a 4 byte boundary
- * with null bytes.  All names are guaranteed null terminated.
- * The maximum length of a name in a directory is MAXNAMLEN.
- *
- * The macro DIRSIZ(fmt, dp) gives the amount of space required to represent
- * a directory entry.  Free space in a directory is represented by
- * entries which have dp->d_reclen > DIRSIZ(fmt, dp).  All DIRBLKSIZ bytes
- * in a directory block are claimed by the directory entries.  This
- * usually results in the last entry in a directory having a large
- * dp->d_reclen.  When entries are deleted from a directory, the
- * space is returned to the previous entry in the same directory
- * block by increasing its dp->d_reclen.  If the first entry of
- * a directory block is free, then its dp->d_ino is set to 0.
- * Entries other than the first in a directory do not normally have
- * dp->d_ino set to 0.
- */
-#define DIRBLKSIZ	DEV_BSIZE
-#define MAXNAMLEN	EXT2_NAME_LEN
-
-struct	direct {
-	uint32_t d_ino;		/* inode number of entry */
-	uint16_t d_reclen;		/* length of this record */
-	uint8_t  d_type; 		/* file type, see below */
-	uint8_t  d_namlen;		/* length of string in d_name */
-	char	  d_name[MAXNAMLEN + 1];/* name with length <= MAXNAMLEN */
-};
-
-/*
- * File types
- */
-#define	DT_UNKNOWN	 0
-#define	DT_FIFO		 1
-#define	DT_CHR		 2
-#define	DT_DIR		 4
-#define	DT_BLK		 6
-#define	DT_REG		 8
-#define	DT_LNK		10
-#define	DT_SOCK		12
-#define	DT_WHT		14
-
-/*
- * Convert between stat structure types and directory types.
- */
-#define	IFTODT(mode)	(((mode) & 0170000) >> 12)
-#define	DTTOIF(dirtype)	((dirtype) << 12)
-
-/*
- * The DIRSIZ macro gives the minimum record length which will hold
- * the directory entry.  This requires the amount of space in struct direct
- * without the d_name field, plus enough space for the name with a terminating
- * null byte (dp->d_namlen+1), rounded up to a 4 byte boundary.
- *
- *
- */
-#define	DIRECTSIZ(namlen)						\
-	((__offsetof(struct direct, d_name) +				\
-	  ((namlen)+1)*sizeof(((struct direct *)0)->d_name[0]) + 3) & ~3)
-#if (BYTE_ORDER == LITTLE_ENDIAN)
-#define DIRSIZ(oldfmt, dp) \
-    ((oldfmt) ? DIRECTSIZ((dp)->d_type) : DIRECTSIZ((dp)->d_namlen))
-#else
-#define DIRSIZ(oldfmt, dp) \
-    DIRECTSIZ((dp)->d_namlen)
-#endif
-#define OLDDIRFMT	1
-#define NEWDIRFMT	0
-
-/*
- * Template for manipulating directories.  Should use struct direct's,
- * but the name field is MAXNAMLEN - 1, and this just won't do.
- */
-struct dirtemplate {
-	uint32_t	dot_ino;
-	int16_t		dot_reclen;
-	uint8_t	dot_type;
-	uint8_t	dot_namlen;
-	char		dot_name[4];	/* must be multiple of 4 */
-	uint32_t	dotdot_ino;
-	int16_t		dotdot_reclen;
-	uint8_t	dotdot_type;
-	uint8_t	dotdot_namlen;
-	char		dotdot_name[4];	/* ditto */
-};
-
-/*
- * This is the old format of directories, sanz type element.
- */
-struct odirtemplate {
-	uint32_t	dot_ino;
-	int16_t		dot_reclen;
-	uint16_t	dot_namlen;
-	char		dot_name[4];	/* must be multiple of 4 */
-	uint32_t	dotdot_ino;
-	int16_t		dotdot_reclen;
-	uint16_t	dotdot_namlen;
-	char		dotdot_name[4];	/* ditto */
-};
-#endif /* _VFS_GNU_EXT2FS_DIR_H_ */
diff --git a/sys/gnu/vfs/ext2fs/ext2_alloc.c b/sys/gnu/vfs/ext2fs/ext2_alloc.c
deleted file mode 100644
index 8e7c07135c..0000000000
--- a/sys/gnu/vfs/ext2fs/ext2_alloc.c
+++ /dev/null
@@ -1,535 +0,0 @@
-/*
- *  modified for Lites 1.1
- *
- *  Aug 1995, Godmar Back (gback@cs.utah.edu)
- *  University of Utah, Department of Computer Science
- */
-/*
- * Copyright (c) 1982, 1986, 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. 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.
- *
- *	@(#)ext2_alloc.c	8.8 (Berkeley) 2/21/94
- * $FreeBSD: src/sys/gnu/ext2fs/ext2_alloc.c,v 1.28.2.2 2002/07/01 00:18:51 iedowse Exp $
- */
-
-#include "opt_quota.h"
-
-#include <sys/param.h>
-#include <sys/systm.h>
-#include <sys/conf.h>
-#include <sys/vnode.h>
-#include <sys/stat.h>
-#include <sys/mount.h>
-#include <sys/syslog.h>
-
-#include <machine/inttypes.h>
-
-#include <sys/buf2.h>
-
-#include "quota.h"
-#include "inode.h"
-#include "ext2_mount.h"
-
-#include "ext2_fs.h"
-#include "ext2_fs_sb.h"
-#include "fs.h"
-#include "ext2_extern.h"
-
-static void	ext2_fserr (struct ext2_sb_info *, u_int, char *);
-
-/*
- * Linux calls this functions at the following locations:
- * (1) the inode is freed
- * (2) a preallocation miss occurs
- * (3) truncate is called
- * (4) release_file is called and f_mode & 2
- *
- * I call it in ext2_inactive, ext2_truncate, ext2_vfree and in (2)
- * the call in vfree might be redundant
- */
-void
-ext2_discard_prealloc(struct inode *ip)
-{
-#ifdef EXT2_PREALLOCATE
-        if (ip->i_prealloc_count) {
-                int i = ip->i_prealloc_count;
-                ip->i_prealloc_count = 0;
-                ext2_free_blocks (ITOV(ip)->v_mount,
-                                  ip->i_prealloc_block,
-                                  i);
-        }
-#endif
-}
-
-/*
- * Allocate a block in the file system.
- *
- * this takes the framework from ffs_alloc. To implement the
- * actual allocation, it calls ext2_new_block, the ported version
- * of the same Linux routine.
- *
- * we note that this is always called in connection with ext2_blkpref
- *
- * preallocation is done as Linux does it
- */
-int
-ext2_alloc(struct inode *ip, daddr_t lbn, daddr_t bpref, int size,
-	   struct ucred *cred, daddr_t *bnp)
-{
-	struct ext2_sb_info *fs;
-	daddr_t bno;
-#ifdef QUOTA
-	int error;
-#endif
-
-	*bnp = 0;
-	fs = ip->i_e2fs;
-#ifdef DIAGNOSTIC
-	if ((u_int)size > fs->s_blocksize || blkoff(fs, size) != 0) {
-		kprintf("dev = %s, bsize = %lu, size = %d, fs = %s\n",
-		    devtoname(ip->i_dev), fs->s_blocksize, size, fs->fs_fsmnt);
-		panic("ext2_alloc: bad size");
-	}
-	if (cred == NOCRED)
-		panic("ext2_alloc: missing credential");
-#endif /* DIAGNOSTIC */
-	if (size == fs->s_blocksize && fs->s_es->s_free_blocks_count == 0)
-		goto nospace;
-	if (cred->cr_uid != 0 &&
-		fs->s_es->s_free_blocks_count < fs->s_es->s_r_blocks_count)
-		goto nospace;
-#ifdef QUOTA
-	if ((error = ext2_chkdq(ip, (long)btodb(size), cred, 0)) != 0)
-		return (error);
-#endif
-	if (bpref >= fs->s_es->s_blocks_count)
-		bpref = 0;
-	/* call the Linux code */
-#ifdef EXT2_PREALLOCATE
-	/* To have a preallocation hit, we must
-	 * - have at least one block preallocated
-	 * - and our preferred block must have that block number or one below
-	 */
-        if (ip->i_prealloc_count &&
-            (bpref == ip->i_prealloc_block ||
-             bpref + 1 == ip->i_prealloc_block))
-        {
-                bno = ip->i_prealloc_block++;
-                ip->i_prealloc_count--;
-                /* ext2_debug ("preallocation hit (%lu/%lu).\n",
-                            ++alloc_hits, ++alloc_attempts); */
-
-		/* Linux gets, clears, and releases the buffer at this
-		   point - we don't have to that; we leave it to the caller
-		 */
-        } else {
-                ext2_discard_prealloc (ip);
-                /* ext2_debug ("preallocation miss (%lu/%lu).\n",
-                            alloc_hits, ++alloc_attempts); */
-                if (S_ISREG(ip->i_mode))
-                        bno = ext2_new_block
-                                (ITOV(ip)->v_mount, bpref,
-                                 &ip->i_prealloc_count,
-                                 &ip->i_prealloc_block);
-                else
-			bno = (daddr_t)ext2_new_block(ITOV(ip)->v_mount,
-					bpref, 0, 0);
-        }
-#else
-	bno = (daddr_t)ext2_new_block(ITOV(ip)->v_mount, bpref, 0, 0);
-#endif
-
-	if (bno > 0) {
-		/* set next_alloc fields as done in block_getblk */
-		ip->i_next_alloc_block = lbn;
-		ip->i_next_alloc_goal = bno;
-
-		ip->i_blocks += btodb(size);
-		ip->i_flag |= IN_CHANGE | IN_UPDATE;
-		*bnp = bno;
-		return (0);
-	}
-#ifdef QUOTA
-	/*
-	 * Restore user's disk quota because allocation failed.
-	 */
-	ext2_chkdq(ip, (long)-btodb(size), cred, FORCE);
-#endif
-nospace:
-	ext2_fserr(fs, cred->cr_uid, "file system full");
-	uprintf("\n%s: write failed, file system is full\n", fs->fs_fsmnt);
-	return (ENOSPC);
-}
-
-/*
- * Reallocate a sequence of blocks into a contiguous sequence of blocks.
- *
- * The vnode and an array of buffer pointers for a range of sequential
- * logical blocks to be made contiguous is given. The allocator attempts
- * to find a range of sequential blocks starting as close as possible to
- * an fs_rotdelay offset from the end of the allocation for the logical
- * block immediately preceeding the current range. If successful, the
- * physical block numbers in the buffer pointers and in the inode are
- * changed to reflect the new allocation. If unsuccessful, the allocation
- * is left unchanged. The success in doing the reallocation is returned.
- * Note that the error return is not reflected back to the user. Rather
- * the previous block allocation will be used.
- */
-
-#ifdef FANCY_REALLOC
-#include <sys/sysctl.h>
-static int doasyncfree = 1;
-#ifdef	OPT_DEBUG
-SYSCTL_INT(_debug, 14, doasyncfree, CTLFLAG_RW, &doasyncfree, 0, "");
-#endif	/* OPT_DEBUG */
-#endif
-
-/*
- * ext2_reallocblks(struct vnode *a_vp, struct cluster_save *a_buflist)
- */
-int
-ext2_reallocblks(struct vop_reallocblks_args *ap)
-{
-#ifndef FANCY_REALLOC
-/* kprintf("ext2_reallocblks not implemented\n"); */
-return ENOSPC;
-#else
-
-	struct ext2_sb_info *fs;
-	struct inode *ip;
-	struct vnode *vp;
-	struct buf *sbp, *ebp;
-	daddr_t *bap, *sbap, *ebap;
-	struct cluster_save *buflist;
-	daddr_t start_lbn, end_lbn, soff, eoff, newblk, blkno;
-	struct indir start_ap[NIADDR + 1], end_ap[NIADDR + 1], *idp;
-	int i, len, start_lvl, end_lvl, pref, ssize;
-
-	vp = ap->a_vp;
-	ip = VTOI(vp);
-	fs = ip->i_e2fs;
-#ifdef UNKLAR
-	if (fs->fs_contigsumsize <= 0)
-		return (ENOSPC);
-#endif
-	buflist = ap->a_buflist;
-	len = buflist->bs_nchildren;
-	start_lbn = lblkno(fs, buflist->bs_children[0]->b_loffset);
-	end_lbn = start_lbn + len - 1;
-#ifdef DIAGNOSTIC
-	for (i = 1; i < len; i++) {
-		if (buflist->bs_children[i]->b_loffset != lblktodoff(fs, start_lbn) + lblktodoff(fs, i))
-			panic("ext2_reallocblks: non-cluster");
-	}
-#endif
-	/*
-	 * If the latest allocation is in a new block group, assume that
-	 * the filesystem has decided to move and do not force it back to
-	 * the previous block group.
-	 */
-	if (dtog(fs, dofftofsb(fs, buflist->bs_children[0]->b_bio2.bio_offset)) !=
-	    dtog(fs, dofftofsb(fs, buflist->bs_children[len - 1]->b_bio2.bio_offset)))
-		return (ENOSPC);
-	if (ext2_getlbns(vp, start_lbn, start_ap, &start_lvl) ||
-	    ext2_getlbns(vp, end_lbn, end_ap, &end_lvl))
-		return (ENOSPC);
-	/*
-	 * Get the starting offset and block map for the first block.
-	 */
-	if (start_lvl == 0) {
-		sbap = &ip->i_db[0];
-		soff = start_lbn;
-	} else {
-		idp = &start_ap[start_lvl - 1];
-		if (bread(vp, lblktodoff(fs, idp->in_lbn), (int)fs->s_blocksize, NOCRED, &sbp)) {
-			brelse(sbp);
-			return (ENOSPC);
-		}
-		sbap = (daddr_t *)sbp->b_data;
-		soff = idp->in_off;
-	}
-	/*
-	 * Find the preferred location for the cluster.
-	 */
-	pref = ext2_blkpref(ip, start_lbn, soff, sbap);
-	/*
-	 * If the block range spans two block maps, get the second map.
-	 */
-	if (end_lvl == 0 || (idp = &end_ap[end_lvl - 1])->in_off + 1 >= len) {
-		ssize = len;
-	} else {
-#ifdef DIAGNOSTIC
-		if (start_ap[start_lvl-1].in_lbn == idp->in_lbn)
-			panic("ext2_reallocblk: start == end");
-#endif
-		ssize = len - (idp->in_off + 1);
-		if (bread(vp, lblktodoff(fs, idp->in_lbn), (int)fs->s_blocksize, NOCRED, &ebp))
-			goto fail;
-		ebap = (daddr_t *)ebp->b_data;
-	}
-	/*
-	 * Search the block map looking for an allocation of the desired size.
-	 */
-	if ((newblk = (daddr_t)ext2_hashalloc(ip, dtog(fs, pref), (long)pref,
-	    len, (u_long (*)())ext2_clusteralloc)) == 0)
-		goto fail;
-	/*
-	 * We have found a new contiguous block.
-	 *
-	 * First we have to replace the old block pointers with the new
-	 * block pointers in the inode and indirect blocks associated
-	 * with the file.
-	 */
-	blkno = newblk;
-	for (bap = &sbap[soff], i = 0; i < len; i++, blkno += fs->s_frags_per_block) {
-		if (i == ssize)
-			bap = ebap;
-#ifdef DIAGNOSTIC
-		if (buflist->bs_children[i]->b_bio2.bio_offset != fsbtodoff(fs, *bap))
-			panic("ext2_reallocblks: alloc mismatch");
-#endif
-		*bap++ = blkno;
-	}
-	/*
-	 * Next we must write out the modified inode and indirect blocks.
-	 * For strict correctness, the writes should be synchronous since
-	 * the old block values may have been written to disk. In practise
-	 * they are almost never written, but if we are concerned about
-	 * strict correctness, the `doasyncfree' flag should be set to zero.
-	 *
-	 * The test on `doasyncfree' should be changed to test a flag
-	 * that shows whether the associated buffers and inodes have
-	 * been written. The flag should be set when the cluster is
-	 * started and cleared whenever the buffer or inode is flushed.
-	 * We can then check below to see if it is set, and do the
-	 * synchronous write only when it has been cleared.
-	 */
-	if (sbap != &ip->i_db[0]) {
-		if (doasyncfree)
-			bdwrite(sbp);
-		else
-			bwrite(sbp);
-	} else {
-		ip->i_flag |= IN_CHANGE | IN_UPDATE;
-		if (!doasyncfree)
-			EXT2_UPDATE(vp, 1);
-	}
-	if (ssize < len)
-		if (doasyncfree)
-			bdwrite(ebp);
-		else
-			bwrite(ebp);
-	/*
-	 * Last, free the old blocks and assign the new blocks to the buffers.
-	 */
-	for (blkno = newblk, i = 0; i < len; i++, blkno += fs->s_frags_per_block) {
-		ext2_blkfree(ip, dofftofsb(fs, buflist->bs_children[i]->b_bio2.bio_offset),
-		    fs->s_blocksize);
-		buflist->bs_children[i]->b_bio2.bio_offset = fsbtodoff(fs, blkno);
-	}
-	return (0);
-
-fail:
-	if (ssize < len)
-		brelse(ebp);
-	if (sbap != &ip->i_db[0])
-		brelse(sbp);
-	return (ENOSPC);
-
-#endif /* FANCY_REALLOC */
-}
-
-/*
- * Allocate an inode in the file system.
- *
- * we leave the actual allocation strategy to the (modified)
- * ext2_new_inode(), to make sure we get the policies right
- */
-int
-ext2_valloc(struct vnode *pvp, int mode, struct ucred *cred, struct vnode **vpp)
-{
-	struct inode *pip;
-	struct ext2_sb_info *fs;
-	struct inode *ip;
-	ino_t ino;
-	int i, error;
-
-	*vpp = NULL;
-	pip = VTOI(pvp);
-	fs = pip->i_e2fs;
-	if (fs->s_es->s_free_inodes_count == 0)
-		goto noinodes;
-
-	/* call the Linux routine - it returns the inode number only */
-	ino = ext2_new_inode(pip, mode);
-
-	if (ino == 0)
-		goto noinodes;
-	error = VFS_VGET(pvp->v_mount, NULL, ino, vpp);
-	if (error) {
-		EXT2_VFREE(pvp, ino, mode);
-		return (error);
-	}
-	ip = VTOI(*vpp);
-
-	/*
-	  the question is whether using VGET was such good idea at all -
-	  Linux doesn't read the old inode in when it's allocating a
-	  new one. I will set at least i_size & i_blocks the zero.
-	*/
-	ip->i_mode = 0;
-	ip->i_size = 0;
-	ip->i_blocks = 0;
-	ip->i_flags = 0;
-        /* now we want to make sure that the block pointers are zeroed out */
-        for (i = 0; i < NDADDR; i++)
-                ip->i_db[i] = 0;
-        for (i = 0; i < NIADDR; i++)
-                ip->i_ib[i] = 0;
-
-	/*
-	 * Set up a new generation number for this inode.
-	 * XXX check if this makes sense in ext2
-	 */
-	if (ip->i_gen == 0 || ++ip->i_gen == 0)
-		ip->i_gen = krandom() / 2 + 1;
-/*
-kprintf("ext2_valloc: allocated inode %d\n", ino);
-*/
-	return (0);
-noinodes:
-	ext2_fserr(fs, cred->cr_uid, "out of inodes");
-	uprintf("\n%s: create/symlink failed, no inodes free\n", fs->fs_fsmnt);
-	return (ENOSPC);
-}
-
-/*
- * Select the desired position for the next block in a file.
- *
- * we try to mimic what Remy does in inode_getblk/block_getblk
- *
- * we note: blocknr == 0 means that we're about to allocate either
- * a direct block or a pointer block at the first level of indirection
- * (In other words, stuff that will go in i_db[] or i_ib[])
- *
- * blocknr != 0 means that we're allocating a block that is none
- * of the above. Then, blocknr tells us the number of the block
- * that will hold the pointer
- */
-daddr_t
-ext2_blkpref(struct inode *ip, daddr_t lbn, int indx, daddr_t *bap,
-	     daddr_t blocknr)
-{
-	int	tmp;
-
-	/*
-	 * if the next block is actually what we thought it is,
-	 * then set the goal to what we thought it should be
-	 */
-	if (ip->i_next_alloc_block == lbn && ip->i_next_alloc_goal != 0)
-		return ip->i_next_alloc_goal;
-
-	/* now check whether we were provided with an array that basically
-	   tells us previous blocks to which we want to stay closeby
-	*/
-	if(bap)
-                for (tmp = indx - 1; tmp >= 0; tmp--)
-			if (bap[tmp])
-				return bap[tmp];
-
-	/*
-	 * else let's fall back to the blocknr, or, if there is none,
-	 * follow the rule that a block should be allocated near its inode
-	 */
-	return blocknr ? blocknr :
-			(daddr_t)(ip->i_block_group *
-			EXT2_BLOCKS_PER_GROUP(ip->i_e2fs)) +
-			ip->i_e2fs->s_es->s_first_data_block;
-}
-
-/*
- * Free a block or fragment.
- *
- * pass on to the Linux code
- */
-void
-ext2_blkfree(struct inode *ip, daddr_t bno, long size)
-{
-	struct ext2_sb_info *fs;
-
-	fs = ip->i_e2fs;
-	/*
-	 *	call Linux code with mount *, block number, count
-	 */
-	ext2_free_blocks(ITOV(ip)->v_mount, bno, size / fs->s_frag_size);
-}
-
-/*
- * Free an inode.
- *
- * the maintenance of the actual bitmaps is again up to the linux code
- */
-int
-ext2_vfree(struct vnode *pvp, ino_t ino, int mode)
-{
-	struct ext2_sb_info *fs;
-	struct inode *pip;
-	mode_t save_i_mode;
-
-	pip = VTOI(pvp);
-	fs = pip->i_e2fs;
-	if ((u_int)ino > fs->s_inodes_per_group * fs->s_groups_count)
-		panic("ext2_vfree: range: dev = (%d, %d), ino = %"PRId64", fs = %s",
-		    major(pip->i_dev), minor(pip->i_dev), ino, fs->fs_fsmnt);
-
-/* ext2_debug("ext2_vfree (%d, %d) called\n", pip->i_number, mode);
- */
-	ext2_discard_prealloc(pip);
-
-	/* we need to make sure that ext2_free_inode can adjust the
-	   used_dir_counts in the group summary information - I'd
-	   really like to know what the rationale behind this
-	   'set i_mode to zero to denote an unused inode' is
-	 */
-	save_i_mode = pip->i_mode;
-	pip->i_mode = mode;
-	ext2_free_inode(pip);
-	pip->i_mode = save_i_mode;
-	return (0);
-}
-
-/*
- * Fserr prints the name of a file system with an error diagnostic.
- *
- * The form of the error message is:
- *	fs: error message
- */
-static void
-ext2_fserr(struct ext2_sb_info *fs, u_int uid, char *cp)
-{
-	log(LOG_ERR, "uid %d on %s: %s\n", uid, fs->fs_fsmnt, cp);
-}
diff --git a/sys/gnu/vfs/ext2fs/ext2_balloc.c b/sys/gnu/vfs/ext2fs/ext2_balloc.c
deleted file mode 100644
index d9f058f187..0000000000
--- a/sys/gnu/vfs/ext2fs/ext2_balloc.c
+++ /dev/null
@@ -1,311 +0,0 @@
-/*
- *  modified for Lites 1.1
- *
- *  Aug 1995, Godmar Back (gback@cs.utah.edu)
- *  University of Utah, Department of Computer Science
- */
-/*
- * Copyright (c) 1982, 1986, 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. 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.
- *
- *	@(#)ffs_balloc.c	8.4 (Berkeley) 9/23/93
- * $FreeBSD: src/sys/gnu/ext2fs/ext2_balloc.c,v 1.9.2.1 2000/08/03 00:52:57 peter Exp $
- */
-
-#include <sys/param.h>
-#include <sys/systm.h>
-#include <sys/buf.h>
-#include <sys/lock.h>
-#include <sys/ucred.h>
-#include <sys/vnode.h>
-
-#include <sys/buf2.h>
-
-#include "quota.h"
-#include "inode.h"
-#include "ext2_fs.h"
-#include "ext2_fs_sb.h"
-#include "fs.h"
-#include "ext2_extern.h"
-
-/*
- * Balloc defines the structure of file system storage
- * by allocating the physical blocks on a device given
- * the inode and the logical block number in a file.
- */
-int
-ext2_balloc(struct inode *ip, daddr_t bn, int size, struct ucred *cred,
-	    struct buf **bpp, int flags)
-{
-	struct ext2_sb_info *fs;
-	daddr_t nb;
-	struct buf *bp, *nbp;
-	struct vnode *vp = ITOV(ip);
-	struct indir indirs[NIADDR + 2];
-	daddr_t newb, lbn, *bap, pref;
-	int osize, nsize, num, i, error;
-/*
-ext2_debug("ext2_balloc called (%d, %d, %d)\n",
-	ip->i_number, (int)bn, (int)size);
-*/
-	*bpp = NULL;
-	if (bn < 0)
-		return (EFBIG);
-	fs = ip->i_e2fs;
-	lbn = bn;
-
-	/*
-	 * check if this is a sequential block allocation.
-	 * If so, increment next_alloc fields to allow ext2_blkpref
-	 * to make a good guess
-	 */
-        if (lbn == ip->i_next_alloc_block + 1) {
-		ip->i_next_alloc_block++;
-		ip->i_next_alloc_goal++;
-	}
-
-	/*
-	 * The first NDADDR blocks are direct blocks
-	 */
-	if (bn < NDADDR) {
-		nb = ip->i_db[bn];
-		/* no new block is to be allocated, and no need to expand
-		   the file */
-		if (nb != 0 && ip->i_size >= (bn + 1) * fs->s_blocksize) {
-			error = bread(vp, lblktodoff(fs, bn),
-				      fs->s_blocksize, &bp);
-			if (error) {
-				brelse(bp);
-				return (error);
-			}
-			*bpp = bp;
-			return (0);
-		}
-		if (nb != 0) {
-			/*
-			 * Consider need to reallocate a fragment.
-			 */
-			osize = fragroundup(fs, blkoff(fs, ip->i_size));
-			nsize = fragroundup(fs, size);
-			if (nsize <= osize) {
-				error = bread(vp, lblktodoff(fs, bn),
-					      osize, &bp);
-				if (error) {
-					brelse(bp);
-					return (error);
-				}
-			} else {
-			/* Godmar thinks: this shouldn't happen w/o fragments */
-				kprintf("nsize %d(%d) > osize %d(%d) nb %d\n",
-					nsize, size, osize,
-					(int)ip->i_size, (int)nb);
-				panic(
-				    "ext2_balloc: Something is terribly wrong");
-/*
- * please note there haven't been any changes from here on -
- * FFS seems to work.
- */
-			}
-		} else {
-			if (ip->i_size < (bn + 1) * fs->s_blocksize)
-				nsize = fragroundup(fs, size);
-			else
-				nsize = fs->s_blocksize;
-			error = ext2_alloc(ip, bn,
-			    ext2_blkpref(ip, bn, (int)bn, &ip->i_db[0], 0),
-			    nsize, cred, &newb);
-			if (error)
-				return (error);
-			bp = getblk(vp, lblktodoff(fs, bn), nsize, 0, 0);
-			bp->b_bio2.bio_offset = fsbtodoff(fs, newb);
-			if (flags & B_CLRBUF)
-				vfs_bio_clrbuf(bp);
-		}
-		ip->i_db[bn] = dofftofsb(fs, bp->b_bio2.bio_offset);
-		ip->i_flag |= IN_CHANGE | IN_UPDATE;
-		*bpp = bp;
-		return (0);
-	}
-	/*
-	 * Determine the number of levels of indirection.
-	 */
-	pref = 0;
-	if ((error = ext2_getlbns(vp, bn, indirs, &num)) != 0)
-		return(error);
-#ifdef DIAGNOSTIC
-	if (num < 1)
-		panic ("ext2_balloc: ext2_bmaparray returned indirect block");
-#endif
-	/*
-	 * Fetch the first indirect block allocating if necessary.
-	 */
-	--num;
-	nb = ip->i_ib[indirs[0].in_off];
-	if (nb == 0) {
-#if 0
-		pref = ext2_blkpref(ip, lbn, 0, NULL, 0);
-#else
-		/* see the comment by ext2_blkpref. What we do here is
-		   to pretend that it'd be good for a block holding indirect
-		   pointers to be allocated near its predecessor in terms
-		   of indirection, or the last direct block.
-		   We shamelessly exploit the fact that i_ib immediately
-		   follows i_db.
-		   Godmar thinks it make sense to allocate i_ib[0] immediately
-		   after i_db[11], but it's not utterly clear whether this also
-		   applies to i_ib[1] and i_ib[0]
-		*/
-
-		pref = ext2_blkpref(ip, lbn, indirs[0].in_off +
-					     EXT2_NDIR_BLOCKS, &ip->i_db[0], 0);
-#endif
-	        if ((error = ext2_alloc(ip, lbn, pref, (int)fs->s_blocksize,
-		    cred, &newb)) != 0)
-			return (error);
-		nb = newb;
-		bp = getblk(vp, lblktodoff(fs, indirs[1].in_lbn),
-			    fs->s_blocksize, 0, 0);
-		bp->b_bio2.bio_offset = fsbtodoff(fs, newb);
-		vfs_bio_clrbuf(bp);
-		/*
-		 * Write synchronously so that indirect blocks
-		 * never point at garbage.
-		 */
-		if ((error = bwrite(bp)) != 0) {
-			ext2_blkfree(ip, nb, fs->s_blocksize);
-			return (error);
-		}
-		ip->i_ib[indirs[0].in_off] = newb;
-		ip->i_flag |= IN_CHANGE | IN_UPDATE;
-	}
-	/*
-	 * Fetch through the indirect blocks, allocating as necessary.
-	 */
-	for (i = 1;;) {
-		error = bread(vp,
-			      lblktodoff(fs, indirs[i].in_lbn),
-			      (int)fs->s_blocksize, &bp);
-		if (error) {
-			brelse(bp);
-			return (error);
-		}
-		bap = (daddr_t *)bp->b_data;
-		nb = bap[indirs[i].in_off];
-		if (i == num)
-			break;
-		i += 1;
-		if (nb != 0) {
-			brelse(bp);
-			continue;
-		}
-		if (pref == 0)
-#if 1
-			/* see the comment above and by ext2_blkpref
-			 * I think this implements Linux policy, but
-			 * does it really make sense to allocate to
-			 * block containing pointers together ?
-			 * Also, will it ever succeed ?
-			 */
-			pref = ext2_blkpref(ip, lbn, indirs[i].in_off, bap,
-						lblkno(fs, bp->b_loffset));
-#else
-			pref = ext2_blkpref(ip, lbn, 0, NULL, 0);
-#endif
-		if ((error =
-		    ext2_alloc(ip, lbn, pref, (int)fs->s_blocksize, cred, &newb)) != 0) {
-			brelse(bp);
-			return (error);
-		}
-		nb = newb;
-		nbp = getblk(vp, lblktodoff(fs, indirs[i].in_lbn),
-			     fs->s_blocksize, 0, 0);
-		nbp->b_bio2.bio_offset = fsbtodoff(fs, nb);
-		vfs_bio_clrbuf(nbp);
-		/*
-		 * Write synchronously so that indirect blocks
-		 * never point at garbage.
-		 */
-		if ((error = bwrite(nbp)) != 0) {
-			ext2_blkfree(ip, nb, fs->s_blocksize);
-			brelse(bp);
-			return (error);
-		}
-		bap[indirs[i - 1].in_off] = nb;
-		/*
-		 * If required, write synchronously, otherwise use
-		 * delayed write.
-		 */
-		if (flags & B_SYNC) {
-			bwrite(bp);
-		} else {
-			bdwrite(bp);
-		}
-	}
-	/*
-	 * Get the data block, allocating if necessary.
-	 */
-	if (nb == 0) {
-		pref = ext2_blkpref(ip, lbn, indirs[i].in_off, &bap[0],
-				lblkno(fs, bp->b_loffset));
-		if ((error = ext2_alloc(ip,
-		    lbn, pref, (int)fs->s_blocksize, cred, &newb)) != 0) {
-			brelse(bp);
-			return (error);
-		}
-		nb = newb;
-		nbp = getblk(vp, lblktodoff(fs, lbn), fs->s_blocksize, 0, 0);
-		nbp->b_bio2.bio_offset = fsbtodoff(fs, nb);
-		if (flags & B_CLRBUF)
-			vfs_bio_clrbuf(nbp);
-		bap[indirs[i].in_off] = nb;
-		/*
-		 * If required, write synchronously, otherwise use
-		 * delayed write.
-		 */
-		if (flags & B_SYNC) {
-			bwrite(bp);
-		} else {
-			bdwrite(bp);
-		}
-		*bpp = nbp;
-		return (0);
-	}
-	brelse(bp);
-	if (flags & B_CLRBUF) {
-		error = bread(vp, lblktodoff(fs, lbn),
-			      (int)fs->s_blocksize, &nbp);
-		if (error) {
-			brelse(nbp);
-			return (error);
-		}
-	} else {
-		nbp = getblk(vp, lblktodoff(fs, lbn), fs->s_blocksize, 0, 0);
-		nbp->b_bio2.bio_offset = fsbtodoff(fs, nb);
-	}
-	*bpp = nbp;
-	return (0);
-}
diff --git a/sys/gnu/vfs/ext2fs/ext2_bitops.h b/sys/gnu/vfs/ext2fs/ext2_bitops.h
deleted file mode 100644
index bc8317432b..0000000000
--- a/sys/gnu/vfs/ext2fs/ext2_bitops.h
+++ /dev/null
@@ -1,114 +0,0 @@
-/*-
- * Copyright (c) 2003 Marcel Moolenaar
- * 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.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
- * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
- * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
- * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
- * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- * $FreeBSD: src/sys/gnu/fs/ext2fs/ext2_bitops.h,v 1.3 2006/04/13 19:37:32 cracauer Exp $
- */
-
-#ifndef _SYS_GNU_EXT2FS_EXT2_BITOPS_H_
-#define _SYS_GNU_EXT2FS_EXT2_BITOPS_H_
-
-#define	find_first_zero_bit(data, sz)		find_next_zero_bit(data, sz, 0)
-
-static __inline int
-clear_bit(int no, void *data)
-{
-	uint32_t *p;
-	uint32_t mask, new, old;
-
-	p = (uint32_t*)data + (no >> 5);
-	mask = (1U << (no & 31));
-	do {
-		old = *p;
-		new = old & ~mask;
-	} while (!atomic_cmpset_32(p, old, new));
-	return (old & mask);
-}
-
-static __inline int
-set_bit(int no, void *data)
-{
-	uint32_t *p;
-	uint32_t mask, new, old;
-
-	p = (uint32_t*)data + (no >> 5);
-	mask = (1U << (no & 31));
-	do {
-		old = *p;
-		new = old | mask;
-	} while (!atomic_cmpset_32(p, old, new));
-	return (old & mask);
-}
-
-static __inline int
-test_bit(int no, void *data)
-{
-	uint32_t *p;
-	uint32_t mask;
-
-	p = (uint32_t*)data + (no >> 5);
-	mask = (1U << (no & 31));
-	return (*p & mask);
-}
-
-static __inline size_t
-find_next_zero_bit(void *data, size_t sz, size_t ofs)
-{
-	uint32_t *p;
-	uint32_t mask;
-	int bit;
-
-	p = (uint32_t*)data + (ofs >> 5);
-	if (ofs & 31) {
-		mask = ~0U << (ofs & 31);
-		bit = *p | ~mask;
-		if (bit != ~0U)
-			return (ffs(~bit) + ofs - 1);
-		p++;
-		ofs = (ofs + 31U) & ~31U;
-	}
-	while(ofs < sz && *p == ~0U) {
-		p++;
-		ofs += 32;
-	}
-	if (ofs == sz)
-		return (ofs);
-	bit = *p;
-	return (ffs(~bit) + ofs - 1);
-}
-
-static __inline void *
-memscan(void *data, int c, size_t sz)
-{
-	uint8_t *p;
-
-	p = data;
-	while (sz && *p != c) {
-		p++;
-		sz--;
-	}
-	return (p);
-}
-
-#endif /* _SYS_GNU_EXT2FS_EXT2_BITOPS_H_ */
diff --git a/sys/gnu/vfs/ext2fs/ext2_bmap.c b/sys/gnu/vfs/ext2fs/ext2_bmap.c
deleted file mode 100644
index 11fecee0dc..0000000000
--- a/sys/gnu/vfs/ext2fs/ext2_bmap.c
+++ /dev/null
@@ -1,336 +0,0 @@
-/*
- * Copyright (c) 1989, 1991, 1993
- *	The Regents of the University of California.  All rights reserved.
- * (c) UNIX System Laboratories, Inc.
- * All or some portions of this file are derived from material licensed
- * to the University of California by American Telephone and Telegraph
- * Co. or Unix System Laboratories, Inc. and are reproduced herein with
- * the permission of UNIX System Laboratories, Inc.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. 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.
- *
- * @(#)ufs_bmap.c	8.7 (Berkeley) 3/21/95
- * $FreeBSD: src/sys/ufs/ufs/ufs_bmap.c,v 1.34.2.1 2000/03/17 10:12:14 ps Exp $
- */
-
-#include <sys/param.h>
-#include <sys/systm.h>
-#include <sys/buf.h>
-#include <sys/proc.h>
-#include <sys/vnode.h>
-#include <sys/mount.h>
-#include <sys/resourcevar.h>
-#include <sys/conf.h>
-
-#include "quota.h"
-#include "dinode.h"
-#include "inode.h"
-#include "ext2_fs_sb.h"
-#include "ext2_mount.h"
-#include "ext2_extern.h"
-#include "fs.h"
-
-static int ext2_bmaparray(struct vnode *vp, ext2_daddr_t bn,
-			  ext2_daddr_t *bnp, struct indir *ap, int *nump,
-			  int *runp, int *runb);
-
-/*
- * Bmap converts the logical block number of a file to its physical block
- * number on the disk. The conversion is done by using the logical block
- * number to index into the array of block pointers described by the dinode.
- *
- * BMAP must return the contiguous before and after run in bytes, inclusive
- * of the returned block.
- *
- * ext2_bmap(struct vnode *a_vp, off_t a_loffset,
- *	    off_t *a_doffsetp, int *a_runp, int *a_runb)
- */
-int
-ext2_bmap(struct vop_bmap_args *ap)
-{
-	struct ext2_sb_info *fs;
-	ext2_daddr_t lbn;
-	ext2_daddr_t dbn;
-	int error;
-
-	/*
-	 * Check for underlying vnode requests and ensure that logical
-	 * to physical mapping is requested.
-	 */
-	if (ap->a_doffsetp == NULL)
-		return (0);
-
-	fs = VTOI(ap->a_vp)->i_e2fs;
-	KKASSERT(((int)ap->a_loffset & ((1 << fs->s_bshift) - 1)) == 0);
-	lbn = ap->a_loffset >> fs->s_bshift;
-
-	error = ext2_bmaparray(ap->a_vp, lbn, &dbn, NULL, NULL,
-			      ap->a_runp, ap->a_runb);
-
-	if (error || dbn == (ext2_daddr_t)-1) {
-		*ap->a_doffsetp = NOOFFSET;
-	} else {
-		*ap->a_doffsetp = dbtodoff(fs, dbn);
-		if (ap->a_runp)
-			*ap->a_runp = (*ap->a_runp + 1) << fs->s_bshift;
-		if (ap->a_runb)
-			*ap->a_runb = *ap->a_runb << fs->s_bshift;
-	}
-	return (error);
-}
-
-/*
- * Indirect blocks are now on the vnode for the file.  They are given negative
- * logical block numbers.  Indirect blocks are addressed by the negative
- * address of the first data block to which they point.  Double indirect blocks
- * are addressed by one less than the address of the first indirect block to
- * which they point.  Triple indirect blocks are addressed by one less than
- * the address of the first double indirect block to which they point.
- *
- * ext2_bmaparray does the bmap conversion, and if requested returns the
- * array of logical blocks which must be traversed to get to a block.
- * Each entry contains the offset into that block that gets you to the
- * next block and the disk address of the block (if it is assigned).
- */
-static
-int
-ext2_bmaparray(struct vnode *vp, ext2_daddr_t bn, ext2_daddr_t *bnp,
-	      struct indir *ap, int *nump, int *runp, int *runb)
-{
-	struct inode *ip;
-	struct buf *bp;
-	struct ext2_mount *ump;
-	struct mount *mp;
-	struct ext2_sb_info *fs;
-	struct indir a[NIADDR+1], *xap;
-	ext2_daddr_t daddr;
-	long metalbn;
-	int error, maxrun, num;
-
-	ip = VTOI(vp);
-	mp = vp->v_mount;
-	ump = VFSTOEXT2(mp);
-	fs = ip->i_e2fs;
-#ifdef DIAGNOSTIC
-	if ((ap != NULL && nump == NULL) || (ap == NULL && nump != NULL))
-		panic("ext2_bmaparray: invalid arguments");
-#endif
-
-	if (runp) {
-		*runp = 0;
-	}
-
-	if (runb) {
-		*runb = 0;
-	}
-
-	maxrun = mp->mnt_iosize_max / mp->mnt_stat.f_iosize - 1;
-
-	xap = ap == NULL ? a : ap;
-	if (!nump)
-		nump = &num;
-	error = ext2_getlbns(vp, bn, xap, nump);
-	if (error)
-		return (error);
-
-	num = *nump;
-	if (num == 0) {
-		*bnp = blkptrtodb(ump, ip->i_db[bn]);
-		if (*bnp == 0)
-			*bnp = -1;
-		else if (runp) {
-			daddr_t bnb = bn;
-			for (++bn; bn < NDADDR && *runp < maxrun &&
-			    is_sequential(ump, ip->i_db[bn - 1], ip->i_db[bn]);
-			    ++bn, ++*runp);
-			bn = bnb;
-			if (runb && (bn > 0)) {
-				for (--bn; (bn >= 0) && (*runb < maxrun) &&
-					is_sequential(ump, ip->i_db[bn],
-						ip->i_db[bn+1]);
-						--bn, ++*runb);
-			}
-		}
-		return (0);
-	}
-
-
-	/* Get disk address out of indirect block array */
-	daddr = ip->i_ib[xap->in_off];
-
-	for (bp = NULL, ++xap; --num; ++xap) {
-		/*
-		 * Exit the loop if there is no disk address assigned yet and
-		 * the indirect block isn't in the cache, or if we were
-		 * looking for an indirect block and we've found it.
-		 */
-
-		metalbn = xap->in_lbn;
-		if ((daddr == 0 &&
-		     !findblk(vp, dbtodoff(fs, metalbn), FINDBLK_TEST)) ||
-		    metalbn == bn) {
-			break;
-		}
-		/*
-		 * If we get here, we've either got the block in the cache
-		 * or we have a disk address for it, go fetch it.
-		 */
-		if (bp)
-			bqrelse(bp);
-
-		bp = getblk(vp, lblktodoff(fs, metalbn),
-			    mp->mnt_stat.f_iosize, 0, 0);
-		if ((bp->b_flags & B_CACHE) == 0) {
-#ifdef DIAGNOSTIC
-			if (!daddr)
-				panic("ext2_bmaparray: indirect block not in cache");
-#endif
-			/*
-			 * This runs through ext2_strategy using bio2 to
-			 * cache the disk offset, then comes back through
-			 * bio1.  So we want to wait on bio1
-			 */
-			bp->b_bio1.bio_done = biodone_sync;
-			bp->b_bio1.bio_flags |= BIO_SYNC;
-			bp->b_bio2.bio_offset = fsbtodoff(fs, daddr);
-			bp->b_flags &= ~(B_INVAL|B_ERROR);
-			bp->b_cmd = BUF_CMD_READ;
-			vfs_busy_pages(bp->b_vp, bp);
-			vn_strategy(bp->b_vp, &bp->b_bio1);
-			error = biowait(&bp->b_bio1, "biord");
-			if (error) {
-				brelse(bp);
-				return (error);
-			}
-		}
-
-		daddr = ((ext2_daddr_t *)bp->b_data)[xap->in_off];
-		if (num == 1 && daddr && runp) {
-			for (bn = xap->in_off + 1;
-			    bn < MNINDIR(ump) && *runp < maxrun &&
-			    is_sequential(ump,
-			    ((ext2_daddr_t *)bp->b_data)[bn - 1],
-			    ((ext2_daddr_t *)bp->b_data)[bn]);
-			    ++bn, ++*runp);
-			bn = xap->in_off;
-			if (runb && bn) {
-				for(--bn; bn >= 0 && *runb < maxrun &&
-					is_sequential(ump, ((daddr_t *)bp->b_data)[bn],
-					    ((daddr_t *)bp->b_data)[bn+1]);
-					--bn, ++*runb);
-			}
-		}
-	}
-	if (bp)
-		bqrelse(bp);
-
-	daddr = blkptrtodb(ump, daddr);
-	*bnp = daddr == 0 ? -1 : daddr;
-	return (0);
-}
-
-/*
- * Create an array of logical block number/offset pairs which represent the
- * path of indirect blocks required to access a data block.  The first "pair"
- * contains the logical block number of the appropriate single, double or
- * triple indirect block and the offset into the inode indirect block array.
- * Note, the logical block number of the inode single/double/triple indirect
- * block appears twice in the array, once with the offset into the i_ib and
- * once with the offset into the page itself.
- */
-int
-ext2_getlbns(struct vnode *vp, ext2_daddr_t bn, struct indir *ap, int *nump)
-{
-	long blockcnt, metalbn, realbn;
-	struct ext2_mount *ump;
-	int i, numlevels, off;
-	int64_t qblockcnt;
-
-	ump = VFSTOEXT2(vp->v_mount);
-	if (nump)
-		*nump = 0;
-	numlevels = 0;
-	realbn = bn;
-	if ((long)bn < 0)
-		bn = -(long)bn;
-
-	/* The first NDADDR blocks are direct blocks. */
-	if (bn < NDADDR)
-		return (0);
-
-	/*
-	 * Determine the number of levels of indirection.  After this loop
-	 * is done, blockcnt indicates the number of data blocks possible
-	 * at the previous level of indirection, and NIADDR - i is the number
-	 * of levels of indirection needed to locate the requested block.
-	 */
-	for (blockcnt = 1, i = NIADDR, bn -= NDADDR;; i--, bn -= blockcnt) {
-		if (i == 0)
-			return (EFBIG);
-		/*
-		 * Use int64_t's here to avoid overflow for triple indirect
-		 * blocks when longs have 32 bits and the block size is more
-		 * than 4K.
-		 */
-		qblockcnt = (int64_t)blockcnt * MNINDIR(ump);
-		if (bn < qblockcnt)
-			break;
-		blockcnt = qblockcnt;
-	}
-
-	/* Calculate the address of the first meta-block. */
-	if (realbn >= 0)
-		metalbn = -(realbn - bn + NIADDR - i);
-	else
-		metalbn = -(-realbn - bn + NIADDR - i);
-
-	/*
-	 * At each iteration, off is the offset into the bap array which is
-	 * an array of disk addresses at the current level of indirection.
-	 * The logical block number and the offset in that block are stored
-	 * into the argument array.
-	 */
-	ap->in_lbn = metalbn;
-	ap->in_off = off = NIADDR - i;
-	ap++;
-	for (++numlevels; i <= NIADDR; i++) {
-		/* If searching for a meta-data block, quit when found. */
-		if (metalbn == realbn)
-			break;
-
-		off = (bn / blockcnt) % MNINDIR(ump);
-
-		++numlevels;
-		ap->in_lbn = metalbn;
-		ap->in_off = off;
-		++ap;
-
-		metalbn -= -1 + off * blockcnt;
-		blockcnt /= MNINDIR(ump);
-	}
-	if (nump)
-		*nump = numlevels;
-	return (0);
-}
diff --git a/sys/gnu/vfs/ext2fs/ext2_extern.h b/sys/gnu/vfs/ext2fs/ext2_extern.h
deleted file mode 100644
index 005c2f034f..0000000000
--- a/sys/gnu/vfs/ext2fs/ext2_extern.h
+++ /dev/null
@@ -1,121 +0,0 @@
-/*
- *  modified for EXT2FS support in Lites 1.1
- *
- *  Aug 1995, Godmar Back (gback@cs.utah.edu)
- *  University of Utah, Department of Computer Science
- */
-/*-
- * Copyright (c) 1991, 1993, 1994
- *	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. 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.
- *
- *	@(#)ffs_extern.h	8.3 (Berkeley) 4/16/94
- * $FreeBSD: src/sys/gnu/ext2fs/ext2_extern.h,v 1.22.6.1 2000/11/05 19:17:40 bde Exp $
- */
-
-#ifndef _VFS_GNU_EXT2FS_EXT2_EXTERN_H_
-#define	_VFS_GNU_EXT2FS_EXT2_EXTERN_H_
-
-struct ext2_dinode;
-struct ext2_inode;
-struct inode;
-struct mount;
-struct vfsconf;
-struct vnode;
-struct indir;
-struct statfs;
-struct sockaddr;
-
-int	ext2_alloc (struct inode *,
-	    daddr_t, daddr_t, int, struct ucred *, daddr_t *);
-int	ext2_balloc (struct inode *,
-	    daddr_t, int, struct ucred *, struct buf **, int);
-int	ext2_blkatoff (struct vnode *, off_t, char **, struct buf **);
-void	ext2_blkfree (struct inode *, daddr_t, long);
-daddr_t	ext2_blkpref (struct inode *, daddr_t, int, daddr_t *, daddr_t);
-int	ext2_bmap (struct vop_bmap_args *);
-int	ext2_reallocblks (struct vop_reallocblks_args *);
-int	ext2_reclaim (struct vop_reclaim_args *);
-void	ext2_setblock (struct ext2_sb_info *, u_char *, daddr_t);
-int	ext2_truncate (struct vnode *, off_t, int, struct ucred *);
-int	ext2_update (struct vnode *, int);
-int	ext2_valloc (struct vnode *, int, struct ucred *, struct vnode **);
-int	ext2_vfree (struct vnode *, ino_t, int);
-int 	ext2_lookup (struct vop_old_lookup_args *);
-int 	ext2_readdir (struct vop_readdir_args *);
-void	ext2_print_dinode (struct ext2_dinode *);
-void	ext2_print_inode (struct inode *);
-int	ext2_direnter (struct inode *,
-		struct vnode *, struct componentname *);
-int	ext2_dirremove (struct vnode *, struct componentname *);
-int	ext2_dirrewrite (struct inode *,
-		struct inode *, struct componentname *);
-int	ext2_dirempty (struct inode *, ino_t, struct ucred *);
-int	ext2_checkpath (struct inode *, struct inode *, struct ucred *);
-struct  ext2_group_desc *get_group_desc (struct mount *,
-		unsigned int, struct buf **);
-int	ext2_group_sparse (int group);
-void	ext2_discard_prealloc (struct inode *);
-int	ext2_inactive (struct vop_inactive_args *);
-int	ext2_new_block (struct mount *mp, unsigned long goal,
-			    u_int32_t *prealloc_count,
-			    u_int32_t *prealloc_block);
-ino_t	ext2_new_inode (const struct inode *dir, int mode);
-unsigned long ext2_count_free (struct buf *map, unsigned int numchars);
-void	ext2_free_blocks (struct mount *mp, unsigned long block,
-			      unsigned long count);
-void	ext2_free_inode (struct inode *inode);
-void	ext2_ei2di (struct ext2_inode *ei, struct ext2_dinode *di);
-void	ext2_di2ei (struct ext2_dinode *di, struct ext2_inode *ei);
-void	mark_buffer_dirty (struct buf *bh);
-
-int	ext2_getlbns(struct vnode *, ext2_daddr_t, struct indir *, int *);
-void	ext2_itimes(struct vnode *vp);
-struct vnode *ext2_ihashget(cdev_t, ino_t);
-int	ext2_ihashins(struct inode *);
-void	ext2_ihashrem(struct inode *);
-void	ext2_dirbad(struct inode *, doff_t, char *);
-int	ext2_check_export(struct mount *, struct sockaddr *, int *,
-			struct ucred **);
-int	ext2_vinit(struct mount *, struct vnode **);
-int	ext2_vnoperate(struct vop_generic_args *);
-int	ext2_vnoperatefifo(struct vop_generic_args *);
-int	ext2_vnoperatespec(struct vop_generic_args *);
-int	ext2_uninit(struct vfsconf *);
-void	ext2_ihashinit(void);
-struct vnode *ext2_ihashlookup(cdev_t dev, ino_t inum);
-int	ext2_ihashcheck(cdev_t dev, ino_t inum);
-
-int	ext2_check_descriptors(struct ext2_sb_info *sb);
-int	ext2_statfs(struct mount *mp, struct statfs *sbp, struct ucred *cred);
-
-/*
- * This macro allows the ufs code to distinguish between an EXT2 and a
- * non-ext2(FFS/LFS) vnode.
- */
-#define  IS_EXT2_VNODE(vp) (vp->v_mount->mnt_stat.f_type == MOUNT_EXT2FS)
-
-#endif /* !_VFS_GNU_EXT2FS_EXT2_EXTERN_H_ */
diff --git a/sys/gnu/vfs/ext2fs/ext2_fs.h b/sys/gnu/vfs/ext2fs/ext2_fs.h
deleted file mode 100644
index 0a5ca16d43..0000000000
--- a/sys/gnu/vfs/ext2fs/ext2_fs.h
+++ /dev/null
@@ -1,634 +0,0 @@
-/*
- *  modified for EXT2FS support in Lites 1.1
- *
- *  Aug 1995, Godmar Back (gback@cs.utah.edu)
- *  University of Utah, Department of Computer Science
- *
- * $FreeBSD: src/sys/gnu/ext2fs/ext2_fs.h,v 1.8.2.2 2001/09/29 12:52:47 iedowse Exp $
- */
-/*
- *  linux/include/linux/ext2_fs.h
- *
- * Copyright (C) 1992, 1993, 1994, 1995
- * Remy Card (card@masi.ibp.fr)
- * Laboratoire MASI - Institut Blaise Pascal
- * Universite Pierre et Marie Curie (Paris VI)
- *
- *  from
- *
- *  linux/include/linux/minix_fs.h
- *
- *  Copyright (C) 1991, 1992  Linus Torvalds
- */
-
-#ifndef _LINUX_EXT2_FS_H
-#define _LINUX_EXT2_FS_H
-
-#include <sys/types.h>
-#include <sys/ioccom.h>
-
-#define __u32 u_int32_t
-#define u32   u_int32_t
-#define __u16 u_int16_t
-#define __u8  u_int8_t
-
-#define __s32 int32_t
-#define __s16 int16_t
-#define __s8  int8_t
-
-#define umode_t mode_t
-#define loff_t  off_t
-
-/* the Linux implementation of EXT2 stores some information about
- * an inode in a ext2_inode_info structure which is part of the incore
- * inode in Linux
- * I decided to use the "spare" fields instead - we'll see how this
- * works out
- */
-
-#define i_block_group		i_spare[0]
-#define i_next_alloc_block	i_spare[1]
-#define i_next_alloc_goal	i_spare[2]
-#define i_prealloc_block	i_din.di_spare[0]
-#define i_prealloc_count	i_din.di_spare[1]
-
-/*
- * The second extended filesystem constants/structures
- */
-
-/*
- * Define EXT2FS_DEBUG to produce debug messages
- */
-#undef EXT2FS_DEBUG
-
-/*
- * Define EXT2_PREALLOCATE to preallocate data blocks for expanding files
- */
-#define EXT2_PREALLOCATE
-#define EXT2_DEFAULT_PREALLOC_BLOCKS	8
-
-/*
- * The second extended file system version
- */
-#define EXT2FS_DATE		"95/08/09"
-#define EXT2FS_VERSION		"0.5b"
-
-/*
- * Debug code
- */
-#ifdef EXT2FS_DEBUG
-#define ext2_debug(f, a...)	{ \
-					kprintf ("EXT2-fs DEBUG (%s, %d): %s:", \
-						__FILE__, __LINE__, __func__); \
-					kprintf (f, ## a); \
-				}
-#else
-#define ext2_debug(f, a...)	/**/
-#endif
-
-/*
- * Special inodes numbers
- */
-#define	EXT2_BAD_INO		 1	/* Bad blocks inode */
-#define EXT2_ROOT_INO		 2	/* Root inode, but rather use EXT2_ROOTINO */
-#define EXT2_ACL_IDX_INO	 3	/* ACL inode */
-#define EXT2_ACL_DATA_INO	 4	/* ACL inode */
-#define EXT2_BOOT_LOADER_INO	 5	/* Boot loader inode */
-#define EXT2_UNDEL_DIR_INO	 6	/* Undelete directory inode */
-
-/* First non-reserved inode for old ext2 filesystems */
-#define EXT2_GOOD_OLD_FIRST_INO	11
-
-/*
- * The second extended file system magic number
- */
-#define EXT2_SUPER_MAGIC	0xEF53
-
-/*
- * Maximal count of links to a file
- */
-#define EXT2_LINK_MAX		32000
-
-/*
- * Note: under FreeBSD, the "user" versions of the following macros are
- * used (and must be used) in most cases, because ((s)->u.ext2_sb.s_es is
- * not accessible.  This depends on __KERNEL__ not being defined for
- * kernel builds under FreeBSD.
- */
-/*
- * Arguments s of the following EXT2_XXX(s) macros in Linux kernel take
- * generic (non-ext2 specific) inmemory superblock structure.  On DragonFly,
- * the type of s is either generic inmemory, ext2 inmemory, or ext2 ondisk
- * superblock structure.  These macro definitions are actually taken from
- * e2fsprogs and made to work.
- *
- * Also note that on DragonFly, the macro EXT2_SB(s) takes ext2 ondisk
- * superblock structure and does nothing (see the comment on EXT2_SB(s),
- * it's for userspace to access ondisk superblock structure for testings,
- * etc, originally introduced by e2fsprogs).
- */
-
-/*
- * Macro-instructions used to manage several block sizes
- */
-#define EXT2_MIN_BLOCK_SIZE		1024
-#define	EXT2_MAX_BLOCK_SIZE		4096
-#define EXT2_MIN_BLOCK_LOG_SIZE		  10
-#if (defined(__DragonFly__) && defined(_KERNEL))
-#define EXT2_BLOCK_SIZE(s)		((s)->s_blocksize)
-#else
-#define EXT2_BLOCK_SIZE(s)		(EXT2_MIN_BLOCK_SIZE << (s)->s_log_block_size)
-#endif
-#define EXT2_ACLE_PER_BLOCK(s)		(EXT2_BLOCK_SIZE(s) / sizeof (struct ext2_acl_entry))
-#define	EXT2_ADDR_PER_BLOCK(s)		(EXT2_BLOCK_SIZE(s) / sizeof (__u32))
-/*
- * XXX DragonFly's inmemory superblock has no s_addr_per_block_bits.
- */
-/* #define EXT2_ADDR_PER_BLOCK_BITS(s)	((s)->s_addr_per_block_bits) */
-/*
- * XXX The first one takes ext2 inmemory superblock structure and the
- * second one takes ext2 ondisk superblock structure.  The second one
- * has been used on DragonFly to compute ((s)->s_blocksize_bits).
- */
-/* #define EXT2_BLOCK_SIZE_BITS(s)	((s)->s_blocksize_bits) */
-#define EXT2_BLOCK_SIZE_BITS(s)	((s)->s_log_block_size + 10)  /* log2(siz)-10 + log2(1024) */
-#if defined _KERNEL
-#define EXT2_INODE_SIZE(s)		((s)->s_inode_size)
-#define EXT2_FIRST_INO(s)		((s)->s_first_ino)
-#else
-#define EXT2_INODE_SIZE(s)	(((s)->s_rev_level == EXT2_GOOD_OLD_REV) ? \
-				 EXT2_GOOD_OLD_INODE_SIZE : \
-				 (s)->s_inode_size)
-#define EXT2_FIRST_INO(s)	(((s)->s_rev_level == EXT2_GOOD_OLD_REV) ? \
-				 EXT2_GOOD_OLD_FIRST_INO : \
-				 (s)->s_first_ino)
-#endif
-#define	EXT2_INODES_PER_BLOCK(s)	((s)->s_inodes_per_block)
-/*
- * Macro-instructions used to manage fragments
- */
-#define EXT2_MIN_FRAG_SIZE		1024
-#define	EXT2_MAX_FRAG_SIZE		4096
-#define EXT2_MIN_FRAG_LOG_SIZE		  10
-#if defined(_KERNEL) && defined(__DragonFly__)
-#define EXT2_FRAG_SIZE(s)		((s)->s_frag_size)
-/*
- * XXX The second one has been used on DragonFly, but the first one
- * with properly initialized s_frags_per_block is probably a better way.
- * Also note that ext2 does not support block fragmentation.
- */
-/* #define EXT2_FRAGS_PER_BLOCK(s)         ((s)->s_frags_per_block) */
-#define EXT2_FRAGS_PER_BLOCK(s)	(EXT2_BLOCK_SIZE(s) / EXT2_FRAG_SIZE(s))
-#else
-#define EXT2_FRAG_SIZE(s)		(EXT2_MIN_FRAG_SIZE << (s)->s_log_frag_size)
-#define EXT2_FRAGS_PER_BLOCK(s)	(EXT2_BLOCK_SIZE(s) / EXT2_FRAG_SIZE(s))
-#endif
-
-/*
- * ACL structures
- */
-struct ext2_acl_header	/* Header of Access Control Lists */
-{
-	__u32	aclh_size;
-	__u32	aclh_file_count;
-	__u32	aclh_acle_count;
-	__u32	aclh_first_acle;
-};
-
-struct ext2_acl_entry	/* Access Control List Entry */
-{
-	__u32	acle_size;
-	__u16	acle_perms;	/* Access permissions */
-	__u16	acle_type;	/* Type of entry */
-	__u16	acle_tag;	/* User or group identity */
-	__u16	acle_pad1;
-	__u32	acle_next;	/* Pointer on next entry for the */
-					/* same inode or on next free entry */
-};
-
-/*
- * Structure of a blocks group descriptor
- */
-struct ext2_group_desc
-{
-	__u32	bg_block_bitmap;		/* Blocks bitmap block */
-	__u32	bg_inode_bitmap;		/* Inodes bitmap block */
-	__u32	bg_inode_table;		/* Inodes table block */
-	__u16	bg_free_blocks_count;	/* Free blocks count */
-	__u16	bg_free_inodes_count;	/* Free inodes count */
-	__u16	bg_used_dirs_count;	/* Directories count */
-	__u16	bg_pad;
-	__u32	bg_reserved[3];
-};
-
-/*
- * Macro-instructions used to manage group descriptors
- */
-#define EXT2_BLOCKS_PER_GROUP(s)	((s)->s_blocks_per_group)
-#define EXT2_DESC_PER_BLOCK(s)		(EXT2_BLOCK_SIZE(s) / sizeof (struct ext2_group_desc))
-#define EXT2_INODES_PER_GROUP(s)	((s)->s_inodes_per_group)
-
-/*
- * Constants relative to the data blocks
- */
-#define	EXT2_NDIR_BLOCKS		12
-#define	EXT2_IND_BLOCK			EXT2_NDIR_BLOCKS
-#define	EXT2_DIND_BLOCK			(EXT2_IND_BLOCK + 1)
-#define	EXT2_TIND_BLOCK			(EXT2_DIND_BLOCK + 1)
-#define	EXT2_N_BLOCKS			(EXT2_TIND_BLOCK + 1)
-#define EXT2_MAXSYMLINKLEN		(EXT2_N_BLOCKS * sizeof (__u32))
-
-/*
- * Inode flags
- */
-#define	EXT2_SECRM_FL			0x00000001 /* Secure deletion */
-#define	EXT2_UNRM_FL			0x00000002 /* Undelete */
-#define	EXT2_COMPR_FL			0x00000004 /* Compress file */
-#define EXT2_SYNC_FL			0x00000008 /* Synchronous updates */
-#define EXT2_IMMUTABLE_FL		0x00000010 /* Immutable file */
-#define EXT2_APPEND_FL			0x00000020 /* writes to file may only append */
-#define EXT2_NODUMP_FL			0x00000040 /* do not dump file */
-#define EXT2_NOATIME_FL			0x00000080 /* do not update atime */
-/* Reserved for compression usage... */
-#define EXT2_DIRTY_FL			0x00000100
-#define EXT2_COMPRBLK_FL		0x00000200 /* One or more compressed clusters */
-#define EXT2_NOCOMP_FL			0x00000400 /* Don't compress */
-#define EXT2_ECOMPR_FL			0x00000800 /* Compression error */
-/* End compression flags --- maybe not all used */
-#define EXT2_BTREE_FL			0x00001000 /* btree format dir */
-#define EXT2_RESERVED_FL		0x80000000 /* reserved for ext2 lib */
-
-#define EXT2_FL_USER_VISIBLE		0x00001FFF /* User visible flags */
-#define EXT2_FL_USER_MODIFIABLE		0x000000FF /* User modifiable flags */
-
-/*
- * ioctl commands
- */
-#define	EXT2_IOC_GETFLAGS		_IOR('f', 1, long)
-#define	EXT2_IOC_SETFLAGS		_IOW('f', 2, long)
-#define	EXT2_IOC_GETVERSION		_IOR('v', 1, long)
-#define	EXT2_IOC_SETVERSION		_IOW('v', 2, long)
-
-/*
- * Only declare `struct ext2_inode' if <vfs/ufs/inode.h> hasn't made things
- * difficult by #defining i_mode and other struct members.  The details of
- * the struct are only needed in ext2_inode_cnv.c where the ext2fs on-disk
- * inode is converted to a ufs in-core inode.
- */
-#ifndef i_mode
-
-/*
- * Structure of an inode on the disk
- */
-struct ext2_inode {
-	__u16	i_mode;		/* File mode */
-	__u16	i_uid;		/* Owner Uid */
-	__u32	i_size;		/* Size in bytes */
-	__u32	i_atime;	/* Access time */
-	__u32	i_ctime;	/* Creation time */
-	__u32	i_mtime;	/* Modification time */
-	__u32	i_dtime;	/* Deletion Time */
-	__u16	i_gid;		/* Group Id */
-	__u16	i_links_count;	/* Links count */
-	__u32	i_blocks;	/* Blocks count */
-	__u32	i_flags;	/* File flags */
-	union {
-		struct {
-			__u32  l_i_reserved1;
-		} linux1;
-		struct {
-			__u32  h_i_translator;
-		} hurd1;
-		struct {
-			__u32  m_i_reserved1;
-		} masix1;
-	} osd1;				/* OS dependent 1 */
-	__u32	i_block[EXT2_N_BLOCKS];/* Pointers to blocks */
-	__u32	i_generation;	/* File version (for NFS) */
-	__u32	i_file_acl;	/* File ACL */
-	__u32	i_dir_acl;	/* Directory ACL */
-	__u32	i_faddr;	/* Fragment address */
-	union {
-		struct {
-			__u8	l_i_frag;	/* Fragment number */
-			__u8	l_i_fsize;	/* Fragment size */
-			__u16	i_pad1;
-			__u16	l_i_uid_high;	/* these 2 fields    */
-			__u16	l_i_gid_high;	/* were reserved2[0] */
-			__u32	l_i_reserved2;
-		} linux2;
-		struct {
-			__u8	h_i_frag;	/* Fragment number */
-			__u8	h_i_fsize;	/* Fragment size */
-			__u16	h_i_mode_high;
-			__u16	h_i_uid_high;
-			__u16	h_i_gid_high;
-			__u32	h_i_author;
-		} hurd2;
-		struct {
-			__u8	m_i_frag;	/* Fragment number */
-			__u8	m_i_fsize;	/* Fragment size */
-			__u16	m_pad1;
-			__u32	m_i_reserved2[2];
-		} masix2;
-	} osd2;				/* OS dependent 2 */
-};
-
-#define i_size_high	i_dir_acl
-
-#if defined(__KERNEL__) || defined(__linux__)
-#define i_reserved1	osd1.linux1.l_i_reserved1
-#define i_frag		osd2.linux2.l_i_frag
-#define i_fsize		osd2.linux2.l_i_fsize
-#define i_uid_low	i_uid
-#define i_gid_low	i_gid
-#define i_uid_high	osd2.linux2.l_i_uid_high
-#define i_gid_high	osd2.linux2.l_i_gid_high
-#define i_reserved2	osd2.linux2.l_i_reserved2
-#endif
-
-#ifdef	__hurd__
-#define i_translator	osd1.hurd1.h_i_translator
-#define i_frag		osd2.hurd2.h_i_frag;
-#define i_fsize		osd2.hurd2.h_i_fsize;
-#define i_uid_high	osd2.hurd2.h_i_uid_high
-#define i_gid_high	osd2.hurd2.h_i_gid_high
-#define i_author	osd2.hurd2.h_i_author
-#endif
-
-#ifdef	__masix__
-#define i_reserved1	osd1.masix1.m_i_reserved1
-#define i_frag		osd2.masix2.m_i_frag
-#define i_fsize		osd2.masix2.m_i_fsize
-#define i_reserved2	osd2.masix2.m_i_reserved2
-#endif
-
-#endif /* i_mode */
-
-/*
- * File system states
- */
-#define	EXT2_VALID_FS			0x0001	/* Unmounted cleanly */
-#define	EXT2_ERROR_FS			0x0002	/* Errors detected */
-
-/*
- * Mount flags
- */
-#define EXT2_MOUNT_CHECK_NORMAL		0x0001	/* Do some more checks */
-#define EXT2_MOUNT_CHECK_STRICT		0x0002	/* Do again more checks */
-#define EXT2_MOUNT_CHECK		(EXT2_MOUNT_CHECK_NORMAL | \
-					 EXT2_MOUNT_CHECK_STRICT)
-#define EXT2_MOUNT_GRPID		0x0004	/* Create files with directory's group */
-#define EXT2_MOUNT_DEBUG		0x0008	/* Some debugging messages */
-#define EXT2_MOUNT_ERRORS_CONT		0x0010	/* Continue on errors */
-#define EXT2_MOUNT_ERRORS_RO		0x0020	/* Remount fs ro on errors */
-#define EXT2_MOUNT_ERRORS_PANIC		0x0040	/* Panic on errors */
-#define EXT2_MOUNT_MINIX_DF		0x0080	/* Mimics the Minix statfs */
-#define EXT2_MOUNT_NOBH			0x000100  /* No buffer_heads */
-#define EXT2_MOUNT_NO_UID32		0x000200  /* Disable 32-bit UIDs */
-#define EXT2_MOUNT_XATTR_USER		0x004000  /* Extended user attributes */
-#define EXT2_MOUNT_POSIX_ACL		0x008000  /* POSIX Access Control Lists */
-#define EXT2_MOUNT_XIP			0x010000  /* Obsolete, use DAX */
-#define EXT2_MOUNT_USRQUOTA		0x020000  /* user quota */
-#define EXT2_MOUNT_GRPQUOTA		0x040000  /* group quota */
-#define EXT2_MOUNT_RESERVATION		0x080000  /* Preallocation */
-
-#define clear_opt(o, opt)		o &= ~EXT2_MOUNT_##opt
-#define set_opt(o, opt)			o |= EXT2_MOUNT_##opt
-#define test_opt(sb, opt)		((sb)->u.ext2_sb.s_mount_opt & \
-					 EXT2_MOUNT_##opt)
-/*
- * Maximal mount counts between two filesystem checks
- */
-#define EXT2_DFL_MAX_MNT_COUNT		20	/* Allow 20 mounts */
-#define EXT2_DFL_CHECKINTERVAL		0	/* Don't use interval check */
-
-/*
- * Behaviour when detecting errors
- */
-#define EXT2_ERRORS_CONTINUE		1	/* Continue execution */
-#define EXT2_ERRORS_RO			2	/* Remount fs read-only */
-#define EXT2_ERRORS_PANIC		3	/* Panic */
-#define EXT2_ERRORS_DEFAULT		EXT2_ERRORS_CONTINUE
-
-/*
- * Structure of the super block
- */
-struct ext2_super_block {
-	__u32	s_inodes_count;		/* Inodes count */
-	__u32	s_blocks_count;		/* Blocks count */
-	__u32	s_r_blocks_count;	/* Reserved blocks count */
-	__u32	s_free_blocks_count;	/* Free blocks count */
-	__u32	s_free_inodes_count;	/* Free inodes count */
-	__u32	s_first_data_block;	/* First Data Block */
-	__u32	s_log_block_size;	/* Block size */
-	__s32	s_log_frag_size;	/* Fragment size */
-	__u32	s_blocks_per_group;	/* # Blocks per group */
-	__u32	s_frags_per_group;	/* # Fragments per group */
-	__u32	s_inodes_per_group;	/* # Inodes per group */
-	__u32	s_mtime;		/* Mount time */
-	__u32	s_wtime;		/* Write time */
-	__u16	s_mnt_count;		/* Mount count */
-	__s16	s_max_mnt_count;	/* Maximal mount count */
-	__u16	s_magic;		/* Magic signature */
-	__u16	s_state;		/* File system state */
-	__u16	s_errors;		/* Behaviour when detecting errors */
-	__u16	s_minor_rev_level; 	/* minor revision level */
-	__u32	s_lastcheck;		/* time of last check */
-	__u32	s_checkinterval;	/* max. time between checks */
-	__u32	s_creator_os;		/* OS */
-	__u32	s_rev_level;		/* Revision level */
-	__u16	s_def_resuid;		/* Default uid for reserved blocks */
-	__u16	s_def_resgid;		/* Default gid for reserved blocks */
-	/*
-	 * These fields are for EXT2_DYNAMIC_REV superblocks only.
-	 *
-	 * Note: the difference between the compatible feature set and
-	 * the incompatible feature set is that if there is a bit set
-	 * in the incompatible feature set that the kernel doesn't
-	 * know about, it should refuse to mount the filesystem.
-	 *
-	 * e2fsck's requirements are more strict; if it doesn't know
-	 * about a feature in either the compatible or incompatible
-	 * feature set, it must abort and not try to meddle with
-	 * things it doesn't understand...
-	 */
-	__u32	s_first_ino; 		/* First non-reserved inode */
-	__u16   s_inode_size; 		/* size of inode structure */
-	__u16	s_block_group_nr; 	/* block group # of this superblock */
-	__u32	s_feature_compat; 	/* compatible feature set */
-	__u32	s_feature_incompat; 	/* incompatible feature set */
-	__u32	s_feature_ro_compat; 	/* readonly-compatible feature set */
-	__u8	s_uuid[16];		/* 128-bit uuid for volume */
-	char	s_volume_name[16]; 	/* volume name */
-	char	s_last_mounted[64]; 	/* directory where last mounted */
-	__u32	s_algorithm_usage_bitmap; /* For compression */
-	/*
-	 * Performance hints.  Directory preallocation should only
-	 * happen if the EXT2_COMPAT_PREALLOC flag is on.
-	 */
-	__u8	s_prealloc_blocks;	/* Nr of blocks to try to preallocate*/
-	__u8	s_prealloc_dir_blocks;	/* Nr to preallocate for dirs */
-	__u16	s_padding1;
-	/*
-	 * Journaling support for ext3.
-	 */
-	__u8	s_journal_uuid[16];	/* uuid of journal superblock */
-	__u32	s_journal_inum;		/* inode number of journal file */
-	__u32	s_journal_dev;		/* device number of journal file */
-	__u32	s_last_orphan;		/* start of list of inodes to delete */
-	__u32	s_hash_seed[4];		/* HTREE hash seed */
-	__u8	s_def_hash_version;	/* Default hash version to use */
-	__u8	s_reserved_char_pad;
-	__u16	s_reserved_word_pad;
-	__u32	s_default_mount_opts;
-	__u32	s_first_meta_bg; 	/* First metablock block group */
-	__u32	s_reserved[190];	/* Padding to the end of the block */
-};
-
-/* Assume that user mode programs are passing in an ext2fs superblock, not
- * a kernel struct super_block.  This will allow us to call the feature-test
- * macros from user land. */
-#define EXT2_SB(sb)	(sb)
-
-/*
- * Codes for operating systems
- */
-#define EXT2_OS_LINUX		0
-#define EXT2_OS_HURD		1
-#define EXT2_OS_MASIX		2
-#define EXT2_OS_FREEBSD		3
-#define EXT2_OS_LITES		4
-
-/*
- * Revision levels
- */
-#define EXT2_GOOD_OLD_REV	0	/* The good old (original) format */
-#define EXT2_DYNAMIC_REV	1 	/* V2 format w/ dynamic inode sizes */
-
-#define EXT2_CURRENT_REV	EXT2_GOOD_OLD_REV
-#define EXT2_MAX_SUPP_REV	EXT2_DYNAMIC_REV
-
-#define EXT2_GOOD_OLD_INODE_SIZE 128
-
-/*
- * Feature set definitions
- */
-
-#define EXT2_HAS_COMPAT_FEATURE(sb,mask)			\
-	( EXT2_SB(sb)->s_feature_compat & (mask) )
-#define EXT2_HAS_RO_COMPAT_FEATURE(sb,mask)			\
-	( EXT2_SB(sb)->s_feature_ro_compat & (mask) )
-#define EXT2_HAS_INCOMPAT_FEATURE(sb,mask)			\
-	( EXT2_SB(sb)->s_feature_incompat & (mask) )
-#define EXT2_SET_COMPAT_FEATURE(sb,mask)			\
-	EXT2_SB(sb)->s_es->s_feature_compat |= (mask)
-#define EXT2_SET_RO_COMPAT_FEATURE(sb,mask)			\
-	EXT2_SB(sb)->s_es->s_feature_ro_compat |= (mask)
-#define EXT2_SET_INCOMPAT_FEATURE(sb,mask)			\
-	EXT2_SB(sb)->s_es->s_feature_incompat |= (mask)
-#define EXT2_CLEAR_COMPAT_FEATURE(sb,mask)			\
-	EXT2_SB(sb)->s_es->s_feature_compat &= ~(mask)
-#define EXT2_CLEAR_RO_COMPAT_FEATURE(sb,mask)			\
-	EXT2_SB(sb)->s_es->s_feature_ro_compat &= ~(mask)
-#define EXT2_CLEAR_INCOMPAT_FEATURE(sb,mask)			\
-	EXT2_SB(sb)->s_es->s_feature_incompat &= ~(mask)
-
-#define EXT2_FEATURE_COMPAT_DIR_PREALLOC	0x0001
-#define EXT2_FEATURE_COMPAT_IMAGIC_INODES	0x0002
-#define EXT3_FEATURE_COMPAT_HAS_JOURNAL		0x0004
-#define EXT2_FEATURE_COMPAT_EXT_ATTR		0x0008
-#define EXT2_FEATURE_COMPAT_RESIZE_INO		0x0010
-#define EXT2_FEATURE_COMPAT_DIR_INDEX		0x0020
-#define EXT2_FEATURE_COMPAT_ANY			0xffffffff
-
-#define EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER	0x0001
-#define EXT2_FEATURE_RO_COMPAT_LARGE_FILE	0x0002
-#define EXT2_FEATURE_RO_COMPAT_BTREE_DIR	0x0004
-#define EXT2_FEATURE_RO_COMPAT_ANY		0xffffffff
-
-#define EXT2_FEATURE_INCOMPAT_COMPRESSION	0x0001
-#define EXT2_FEATURE_INCOMPAT_FILETYPE		0x0002
-#define EXT3_FEATURE_INCOMPAT_RECOVER		0x0004
-#define EXT3_FEATURE_INCOMPAT_JOURNAL_DEV	0x0008
-#define EXT2_FEATURE_INCOMPAT_META_BG		0x0010
-#define EXT2_FEATURE_INCOMPAT_ANY		0xffffffff
-
-#if 1
-#define EXT2_FEATURE_COMPAT_SUPP       0
-#define EXT2_FEATURE_INCOMPAT_SUPP     EXT2_FEATURE_INCOMPAT_FILETYPE
-#else
-#define EXT2_FEATURE_COMPAT_SUPP	EXT2_FEATURE_COMPAT_EXT_ATTR
-#define EXT2_FEATURE_INCOMPAT_SUPP	(EXT2_FEATURE_INCOMPAT_FILETYPE| \
-					 EXT2_FEATURE_INCOMPAT_META_BG)
-#endif
-
-#ifdef notyet
-#define EXT2_FEATURE_RO_COMPAT_SUPP	(EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER| \
-					 EXT2_FEATURE_RO_COMPAT_LARGE_FILE| \
-					 EXT2_FEATURE_RO_COMPAT_BTREE_DIR)
-#else
-#define EXT2_FEATURE_RO_COMPAT_SUPP	EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER
-#endif
-#define EXT2_FEATURE_RO_COMPAT_UNSUPPORTED	~EXT2_FEATURE_RO_COMPAT_SUPP
-#define EXT2_FEATURE_INCOMPAT_UNSUPPORTED	~EXT2_FEATURE_INCOMPAT_SUPP
-
-/*
- * Default values for user and/or group using reserved blocks
- */
-#define	EXT2_DEF_RESUID		0
-#define	EXT2_DEF_RESGID		0
-
-/*
- * Structure of a directory entry
- */
-#define EXT2_NAME_LEN 255
-
-struct ext2_dir_entry {
-	__u32	inode;			/* Inode number */
-	__u16	rec_len;		/* Directory entry length */
-	__u16	name_len;		/* Name length */
-	char	name[EXT2_NAME_LEN];	/* File name */
-};
-
-/*
- * The new version of the directory entry.  Since EXT2 structures are
- * stored in intel byte order, and the name_len field could never be
- * bigger than 255 chars, it's safe to reclaim the extra byte for the
- * file_type field.
- */
-struct ext2_dir_entry_2 {
-	__u32	inode;			/* Inode number */
-	__u16	rec_len;		/* Directory entry length */
-	__u8	name_len;		/* Name length */
-	__u8	file_type;
-	char	name[EXT2_NAME_LEN];	/* File name */
-};
-
-/*
- * Ext2 directory file types.  Only the low 3 bits are used.  The
- * other bits are reserved for now.
- */
-#define EXT2_FT_UNKNOWN		0
-#define EXT2_FT_REG_FILE	1
-#define EXT2_FT_DIR		2
-#define EXT2_FT_CHRDEV		3
-#define EXT2_FT_BLKDEV 		4
-#define EXT2_FT_FIFO		5
-#define EXT2_FT_SOCK		6
-#define EXT2_FT_SYMLINK		7
-
-#define EXT2_FT_MAX		8
-
-/*
- * EXT2_DIR_PAD defines the directory entries boundaries
- *
- * NOTE: It must be a multiple of 4
- */
-#define EXT2_DIR_PAD		 	4
-#define EXT2_DIR_ROUND 			(EXT2_DIR_PAD - 1)
-#define EXT2_DIR_REC_LEN(name_len)	(((name_len) + 8 + EXT2_DIR_ROUND) & \
-					 ~EXT2_DIR_ROUND)
-#define EXT2_MAX_REC_LEN		((1<<16)-1)
-
-#endif	/* _LINUX_EXT2_FS_H */
diff --git a/sys/gnu/vfs/ext2fs/ext2_fs_sb.h b/sys/gnu/vfs/ext2fs/ext2_fs_sb.h
deleted file mode 100644
index 0bc77130a0..0000000000
--- a/sys/gnu/vfs/ext2fs/ext2_fs_sb.h
+++ /dev/null
@@ -1,84 +0,0 @@
-/*
- *  modified for EXT2FS support in Lites 1.1
- *
- *  Aug 1995, Godmar Back (gback@cs.utah.edu)
- *  University of Utah, Department of Computer Science
- */
-/*
- *  linux/include/linux/ext2_fs_sb.h
- *
- * Copyright (C) 1992, 1993, 1994, 1995
- * Remy Card (card@masi.ibp.fr)
- * Laboratoire MASI - Institut Blaise Pascal
- * Universite Pierre et Marie Curie (Paris VI)
- *
- *  from
- *
- *  linux/include/linux/minix_fs_sb.h
- *
- *  Copyright (C) 1991, 1992  Linus Torvalds
- */
-
-#ifndef _LINUX_EXT2_FS_SB
-#define _LINUX_EXT2_FS_SB
-
-#include "fs.h"
-
-/*
- * The following is not needed anymore since the descriptors buffer
- * heads are now dynamically allocated
- */
-/* #define EXT2_MAX_GROUP_DESC	8 */
-
-#define EXT2_MAX_GROUP_LOADED	8
-
-/*
- * second extended-fs super-block data in memory
- */
-struct ext2_sb_info {
-	unsigned long s_frag_size;	/* Size of a fragment in bytes */
-	unsigned long s_frags_per_block;/* Number of fragments per block */
-	unsigned long s_inodes_per_block;/* Number of inodes per block */
-	unsigned long s_frags_per_group;/* Number of fragments in a group */
-	unsigned long s_blocks_per_group;/* Number of blocks in a group */
-	unsigned long s_inodes_per_group;/* Number of inodes in a group */
-	unsigned long s_itb_per_group;	/* Number of inode table blocks per group */
-	unsigned long s_db_per_group;	/* Number of descriptor blocks per group */
-	unsigned long s_desc_per_block;	/* Number of group descriptors per block */
-	unsigned long s_groups_count;	/* Number of groups in the fs */
-	struct buf *s_sbh;		/* Buffer containing the super block */
-	struct ext2_super_block *s_es;	/* Pointer to the super block in the buffer */
-	struct buf **s_group_desc;
-	unsigned short s_loaded_inode_bitmaps;
-	unsigned short s_loaded_block_bitmaps;
-	unsigned long s_inode_bitmap_number[EXT2_MAX_GROUP_LOADED];
-	struct buf *s_inode_bitmap[EXT2_MAX_GROUP_LOADED];
-	unsigned long s_block_bitmap_number[EXT2_MAX_GROUP_LOADED];
-	struct buf *s_block_bitmap[EXT2_MAX_GROUP_LOADED];
-	int s_rename_lock;
-	unsigned long  s_mount_opt;
-#ifdef notyet
-	unsigned short s_resuid;
-	unsigned short s_resgid;
-#endif
-    unsigned short s_inode_size;
-    unsigned int s_first_ino;
-	unsigned short s_mount_state;
-	/*
-	   stuff that FFS keeps in its super block or that linux
-	   has in its non-ext2 specific super block and which is
-	   generally considered useful
-	*/
-	unsigned long s_blocksize;
-	unsigned long s_blocksize_bits;
-	unsigned int  s_bshift;			/* = log2(s_blocksize) */
-	quad_t	 s_qbmask;			/* = s_blocksize - 1 */
-	unsigned int  s_fsbtodb;		/* shift to get disk block */
-	char    s_rd_only;                      /* read-only 		*/
-	char    s_dirt;                         /* fs modified flag */
-	char	s_wasvalid;			/* valid at mount time */
-
-	char    fs_fsmnt[MAXMNTLEN];            /* name mounted on */
-};
-
-#endif	/* _LINUX_EXT2_FS_SB */
diff --git a/sys/gnu/vfs/ext2fs/ext2_ihash.c b/sys/gnu/vfs/ext2fs/ext2_ihash.c
deleted file mode 100644
index b5ddc89d3e..0000000000
--- a/sys/gnu/vfs/ext2fs/ext2_ihash.c
+++ /dev/null
@@ -1,210 +0,0 @@
-/*
- * Copyright (c) 1982, 1986, 1989, 1991, 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. 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.
- *
- * @(#)ufs_ihash.c	8.7 (Berkeley) 5/17/95
- * $FreeBSD: src/sys/ufs/ufs/ufs_ihash.c,v 1.20 1999/08/28 00:52:29 peter Exp $
- */
-
-#include <sys/param.h>
-#include <sys/systm.h>
-#include <sys/kernel.h>
-#include <sys/lock.h>
-#include <sys/vnode.h>
-#include <sys/malloc.h>
-#include <sys/proc.h>
-
-#include "quota.h"
-#include "dinode.h"
-#include "inode.h"
-#include "ext2_extern.h"
-
-static MALLOC_DEFINE(M_EXT2IHASH, "EXT2 ihash", "EXT2 Inode hash tables");
-/*
- * Structures associated with inode cacheing.
- */
-static struct inode **ext2_ihashtbl;
-static u_long	ext2_ihash;		/* size of hash table - 1 */
-static struct lwkt_token ext2_ihash_token;
-
-#define	INOHASH(device, inum)	(&ext2_ihashtbl[(minor(device) + (inum)) & ext2_ihash])
-
-/*
- * Initialize inode hash table.
- */
-void
-ext2_ihashinit(void)
-{
-	ext2_ihash = vfs_inodehashsize();
-	ext2_ihashtbl = kmalloc(sizeof(void *) * ext2_ihash,
-				M_EXT2IHASH,
-				M_WAITOK|M_ZERO);
-	--ext2_ihash;
-	lwkt_token_init(&ext2_ihash_token, "ext2ihash");
-}
-
-int
-ext2_uninit(struct vfsconf *vfc)
-{
-    lwkt_gettoken(&ext2_ihash_token);
-    if (ext2_ihashtbl)
-		kfree(ext2_ihashtbl, M_EXT2IHASH);
-    lwkt_reltoken(&ext2_ihash_token);
-
-    return (0);
-}
-/*
- * Use the device/inum pair to find the incore inode, and return a pointer
- * to it. If it is in core, return it, even if it is locked.
- */
-struct vnode *
-ext2_ihashlookup(cdev_t dev, ino_t inum)
-{
-	struct inode *ip;
-
-	lwkt_gettoken(&ext2_ihash_token);
-	for (ip = *INOHASH(dev, inum); ip; ip = ip->i_next) {
-		if (inum == ip->i_number && dev == ip->i_dev)
-			break;
-	}
-	lwkt_reltoken(&ext2_ihash_token);
-	if (ip)
-		return (ITOV(ip));
-	return (NULLVP);
-}
-
-/*
- * Use the device/inum pair to find the incore inode, and return a pointer
- * to it. If it is in core, but locked, wait for it.
- *
- * Note that the serializing tokens do not prevent other processes from
- * playing with the data structure being protected while we are blocked.
- * They do protect us from preemptive interrupts which might try to
- * play with the protected data structure.
- */
-struct vnode *
-ext2_ihashget(cdev_t dev, ino_t inum)
-{
-	struct inode *ip;
-	struct vnode *vp;
-
-	lwkt_gettoken(&ext2_ihash_token);
-loop:
-	for (ip = *INOHASH(dev, inum); ip; ip = ip->i_next) {
-		if (inum != ip->i_number || dev != ip->i_dev)
-			continue;
-		vp = ITOV(ip);
-		if (vget(vp, LK_EXCLUSIVE))
-			goto loop;
-		/*
-		 * We must check to see if the inode has been ripped
-		 * out from under us after blocking.
-		 */
-		for (ip = *INOHASH(dev, inum); ip; ip = ip->i_next) {
-			if (inum == ip->i_number && dev == ip->i_dev)
-				break;
-		}
-		if (ip == NULL || ITOV(ip) != vp) {
-			vput(vp);
-			goto loop;
-		}
-		lwkt_reltoken(&ext2_ihash_token);
-		return (vp);
-	}
-	lwkt_reltoken(&ext2_ihash_token);
-	return (NULL);
-}
-
-/*
- * Check to see if an inode is in the hash table.  This is used to interlock
- * file free operations to ensure that the vnode is not reused due to a
- * reallocate of its inode number before we have had a chance to recycle it.
- */
-int
-ext2_ihashcheck(cdev_t dev, ino_t inum)
-{
-	struct inode *ip;
-
-	lwkt_gettoken(&ext2_ihash_token);
-	for (ip = *INOHASH(dev, inum); ip; ip = ip->i_next) {
-		if (inum == ip->i_number && dev == ip->i_dev)
-			break;
-	}
-	lwkt_reltoken(&ext2_ihash_token);
-	return(ip ? 1 : 0);
-}
-
-/*
- * Insert the inode into the hash table, and return it locked.
- */
-int
-ext2_ihashins(struct inode *ip)
-{
-	struct inode **ipp;
-	struct inode *iq;
-
-	KKASSERT((ip->i_flag & IN_HASHED) == 0);
-	lwkt_gettoken(&ext2_ihash_token);
-	ipp = INOHASH(ip->i_dev, ip->i_number);
-	while ((iq = *ipp) != NULL) {
-		if (ip->i_dev == iq->i_dev && ip->i_number == iq->i_number) {
-			lwkt_reltoken(&ext2_ihash_token);
-			return(EBUSY);
-		}
-		ipp = &iq->i_next;
-	}
-	ip->i_next = NULL;
-	*ipp = ip;
-	ip->i_flag |= IN_HASHED;
-	lwkt_reltoken(&ext2_ihash_token);
-	return(0);
-}
-
-/*
- * Remove the inode from the hash table.
- */
-void
-ext2_ihashrem(struct inode *ip)
-{
-	struct inode **ipp;
-	struct inode *iq;
-
-	lwkt_gettoken(&ext2_ihash_token);
-	if (ip->i_flag & IN_HASHED) {
-		ipp = INOHASH(ip->i_dev, ip->i_number);
-		while ((iq = *ipp) != NULL) {
-			if (ip == iq)
-				break;
-			ipp = &iq->i_next;
-		}
-		KKASSERT(ip == iq);
-		*ipp = ip->i_next;
-		ip->i_next = NULL;
-		ip->i_flag &= ~IN_HASHED;
-	}
-	lwkt_reltoken(&ext2_ihash_token);
-}
diff --git a/sys/gnu/vfs/ext2fs/ext2_inode.c b/sys/gnu/vfs/ext2fs/ext2_inode.c
deleted file mode 100644
index 4f02f18b9d..0000000000
--- a/sys/gnu/vfs/ext2fs/ext2_inode.c
+++ /dev/null
@@ -1,573 +0,0 @@
-/*
- *  modified for Lites 1.1
- *
- *  Aug 1995, Godmar Back (gback@cs.utah.edu)
- *  University of Utah, Department of Computer Science
- */
-/*
- * Copyright (c) 1982, 1986, 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. 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.
- *
- *	@(#)ext2_inode.c	8.5 (Berkeley) 12/30/93
- * $FreeBSD: src/sys/gnu/ext2fs/ext2_inode.c,v 1.24.2.1 2000/08/03 00:52:57 peter Exp $
- */
-
-#include "opt_quota.h"
-
-#include <sys/param.h>
-#include <sys/systm.h>
-#include <sys/mount.h>
-#include <sys/buf.h>
-#include <sys/vnode.h>
-#include <sys/malloc.h>
-
-#include <vm/vm.h>
-#include <vm/vm_extern.h>
-
-#include <sys/buf2.h>
-
-#include "quota.h"
-#include "inode.h"
-#include "ext2_mount.h"
-
-#include "ext2_fs.h"
-#include "ext2_fs_sb.h"
-#include "fs.h"
-#include "ext2_extern.h"
-
-static int ext2_indirtrunc (struct inode *, daddr_t, off_t, daddr_t,
-			    int, long *);
-
-/*
- * Update the access, modified, and inode change times as specified by the
- * IN_ACCESS, IN_UPDATE, and IN_CHANGE flags respectively.  Write the inode
- * to disk if the IN_MODIFIED flag is set (it may be set initially, or by
- * the timestamp update).  The IN_LAZYMOD flag is set to force a write
- * later if not now.  If we write now, then clear both IN_MODIFIED and
- * IN_LAZYMOD to reflect the presumably successful write, and if waitfor is
- * set, then wait for the write to complete.
- */
-int
-ext2_update(struct vnode *vp, int waitfor)
-{
-	struct ext2_sb_info *fs;
-	struct buf *bp;
-	struct inode *ip;
-	int error;
-
-	ext2_itimes(vp);
-	ip = VTOI(vp);
-	if ((ip->i_flag & IN_MODIFIED) == 0)
-		return (0);
-	ip->i_flag &= ~(IN_LAZYMOD | IN_MODIFIED);
-	if (vp->v_mount->mnt_flag & MNT_RDONLY)
-		return (0);
-	fs = ip->i_e2fs;
-	error = bread(ip->i_devvp,
-		      fsbtodoff(fs, ino_to_fsba(fs, ip->i_number)),
-		      (int)fs->s_blocksize, &bp);
-	if (error) {
-		brelse(bp);
-		return (error);
-	}
-	ext2_di2ei( &ip->i_din, (struct ext2_inode *) ((char *)bp->b_data + EXT2_INODE_SIZE(fs) *
-	    ino_to_fsbo(fs, ip->i_number)));
-/*
-	if (waitfor && (vp->v_mount->mnt_flag & MNT_ASYNC) == 0)
-		return (bwrite(bp));
-	else {
-*/
-		bdwrite(bp);
-		return (0);
-/*
-	}
-*/
-}
-
-#define	SINGLE	0	/* index of single indirect block */
-#define	DOUBLE	1	/* index of double indirect block */
-#define	TRIPLE	2	/* index of triple indirect block */
-/*
- * Truncate the inode oip to at most length size, freeing the
- * disk blocks.
- */
-int
-ext2_truncate(struct vnode *vp, off_t length, int flags, struct ucred *cred)
-{
-	struct vnode *ovp = vp;
-	daddr_t lastblock;
-	struct inode *oip;
-	daddr_t bn, lbn, lastiblock[NIADDR], indir_lbn[NIADDR];
-	daddr_t oldblks[NDADDR + NIADDR], newblks[NDADDR + NIADDR];
-	struct ext2_sb_info *fs;
-	struct buf *bp;
-	int offset, size, level;
-	long count, nblocks, blocksreleased = 0;
-	int i;
-	int aflags, error, allerror;
-	off_t osize;
-/*
-kprintf("ext2_truncate called %d to %d\n", VTOI(ovp)->i_number, length);
-*/	/*
-	 * negative file sizes will totally break the code below and
-	 * are not meaningful anyways.
-	 */
-	if (length < 0)
-	    return EFBIG;
-
-	oip = VTOI(ovp);
-	if (ovp->v_type == VLNK &&
-	    oip->i_size < ovp->v_mount->mnt_maxsymlinklen) {
-#ifdef DIAGNOSTIC
-		if (length != 0)
-			panic("ext2_truncate: partial truncate of symlink");
-#endif
-		bzero((char *)&oip->i_shortlink, (u_int)oip->i_size);
-		oip->i_size = 0;
-		oip->i_flag |= IN_CHANGE | IN_UPDATE;
-		return (EXT2_UPDATE(ovp, 1));
-	}
-	if (oip->i_size == length) {
-		oip->i_flag |= IN_CHANGE | IN_UPDATE;
-		return (EXT2_UPDATE(ovp, 0));
-	}
-#ifdef QUOTA
-	if ((error = ext2_getinoquota(oip)) != 0)
-		return (error);
-#endif
-	fs = oip->i_e2fs;
-	osize = oip->i_size;
-	ext2_discard_prealloc(oip);
-	/*
-	 * Lengthen the size of the file. We must ensure that the
-	 * last byte of the file is allocated. Since the smallest
-	 * value of osize is 0, length will be at least 1.
-	 */
-	if (osize < length) {
-		offset = blkoff(fs, length - 1);
-		lbn = lblkno(fs, length - 1);
-		aflags = B_CLRBUF;
-		if (flags & IO_SYNC)
-			aflags |= B_SYNC;
-		vnode_pager_setsize(ovp, length);
-		error = ext2_balloc(oip, lbn, offset + 1, cred, &bp, aflags);
-		if (error) {
-			vnode_pager_setsize(ovp, osize);
-			return (error);
-		}
-		oip->i_size = length;
-		if (aflags & IO_SYNC)
-			bwrite(bp);
-		else
-			bawrite(bp);
-		oip->i_flag |= IN_CHANGE | IN_UPDATE;
-		return (EXT2_UPDATE(ovp, 1));
-	}
-	/*
-	 * Shorten the size of the file. If the file is not being
-	 * truncated to a block boundry, the contents of the
-	 * partial block following the end of the file must be
-	 * zero'ed in case it ever become accessable again because
-	 * of subsequent file growth.
-	 */
-	/* I don't understand the comment above */
-	offset = blkoff(fs, length);
-	if (offset == 0) {
-		oip->i_size = length;
-	} else {
-		lbn = lblkno(fs, length);
-		aflags = B_CLRBUF;
-		if (flags & IO_SYNC)
-			aflags |= B_SYNC;
-		error = ext2_balloc(oip, lbn, offset, cred, &bp, aflags);
-		if (error)
-			return (error);
-		oip->i_size = length;
-		size = blksize(fs, oip, lbn);
-		bzero((char *)bp->b_data + offset, (u_int)(size - offset));
-		allocbuf(bp, size);
-		if (aflags & IO_SYNC)
-			bwrite(bp);
-		else
-			bawrite(bp);
-	}
-	/*
-	 * Calculate index into inode's block list of
-	 * last direct and indirect blocks (if any)
-	 * which we want to keep.  Lastblock is -1 when
-	 * the file is truncated to 0.
-	 */
-	lastblock = lblkno(fs, length + fs->s_blocksize - 1) - 1;
-	lastiblock[SINGLE] = lastblock - NDADDR;
-	lastiblock[DOUBLE] = lastiblock[SINGLE] - NINDIR(fs);
-	lastiblock[TRIPLE] = lastiblock[DOUBLE] - NINDIR(fs) * NINDIR(fs);
-	nblocks = btodb(fs->s_blocksize);
-	/*
-	 * Update file and block pointers on disk before we start freeing
-	 * blocks.  If we crash before free'ing blocks below, the blocks
-	 * will be returned to the free list.  lastiblock values are also
-	 * normalized to -1 for calls to ext2_indirtrunc below.
-	 */
-	bcopy((caddr_t)&oip->i_db[0], (caddr_t)oldblks, sizeof oldblks);
-	for (level = TRIPLE; level >= SINGLE; level--)
-		if (lastiblock[level] < 0) {
-			oip->i_ib[level] = 0;
-			lastiblock[level] = -1;
-		}
-	for (i = NDADDR - 1; i > lastblock; i--)
-		oip->i_db[i] = 0;
-	oip->i_flag |= IN_CHANGE | IN_UPDATE;
-	allerror = EXT2_UPDATE(ovp, 1);
-
-	/*
-	 * Having written the new inode to disk, save its new configuration
-	 * and put back the old block pointers long enough to process them.
-	 * Note that we save the new block configuration so we can check it
-	 * when we are done.
-	 */
-	bcopy((caddr_t)&oip->i_db[0], (caddr_t)newblks, sizeof newblks);
-	bcopy((caddr_t)oldblks, (caddr_t)&oip->i_db[0], sizeof oldblks);
-	oip->i_size = osize;
-	error = vtruncbuf(ovp, length, (int)fs->s_blocksize);
-	if (error && (allerror == 0))
-		allerror = error;
-
-	/*
-	 * Indirect blocks first.
-	 */
-	indir_lbn[SINGLE] = -NDADDR;
-	indir_lbn[DOUBLE] = indir_lbn[SINGLE] - NINDIR(fs) - 1;
-	indir_lbn[TRIPLE] = indir_lbn[DOUBLE] - NINDIR(fs) * NINDIR(fs) - 1;
-	for (level = TRIPLE; level >= SINGLE; level--) {
-		bn = oip->i_ib[level];
-		if (bn != 0) {
-			error = ext2_indirtrunc(oip, indir_lbn[level],
-			    fsbtodoff(fs, bn), lastiblock[level], level, &count);
-			if (error)
-				allerror = error;
-			blocksreleased += count;
-			if (lastiblock[level] < 0) {
-				oip->i_ib[level] = 0;
-				ext2_blkfree(oip, bn, fs->s_frag_size);
-				blocksreleased += nblocks;
-			}
-		}
-		if (lastiblock[level] >= 0)
-			goto done;
-	}
-
-	/*
-	 * All whole direct blocks or frags.
-	 */
-	for (i = NDADDR - 1; i > lastblock; i--) {
-		long bsize;
-
-		bn = oip->i_db[i];
-		if (bn == 0)
-			continue;
-		oip->i_db[i] = 0;
-		bsize = blksize(fs, oip, i);
-		ext2_blkfree(oip, bn, bsize);
-		blocksreleased += btodb(bsize);
-	}
-	if (lastblock < 0)
-		goto done;
-
-	/*
-	 * Finally, look for a change in size of the
-	 * last direct block; release any frags.
-	 */
-	bn = oip->i_db[lastblock];
-	if (bn != 0) {
-		long oldspace, newspace;
-
-		/*
-		 * Calculate amount of space we're giving
-		 * back as old block size minus new block size.
-		 */
-		oldspace = blksize(fs, oip, lastblock);
-		oip->i_size = length;
-		newspace = blksize(fs, oip, lastblock);
-		if (newspace == 0)
-			panic("itrunc: newspace");
-		if (oldspace - newspace > 0) {
-			/*
-			 * Block number of space to be free'd is
-			 * the old block # plus the number of frags
-			 * required for the storage we're keeping.
-			 */
-			bn += numfrags(fs, newspace);
-			ext2_blkfree(oip, bn, oldspace - newspace);
-			blocksreleased += btodb(oldspace - newspace);
-		}
-	}
-done:
-#ifdef DIAGNOSTIC
-	for (level = SINGLE; level <= TRIPLE; level++)
-		if (newblks[NDADDR + level] != oip->i_ib[level])
-			panic("itrunc1");
-	for (i = 0; i < NDADDR; i++)
-		if (newblks[i] != oip->i_db[i])
-			panic("itrunc2");
-	if (length == 0 && (!RB_EMPTY(&ovp->v_rbdirty_tree) ||
-			    !RB_EMPTY(&ovp->v_rbclean_tree)))
-		panic("itrunc3");
-#endif /* DIAGNOSTIC */
-	/*
-	 * Put back the real size.
-	 */
-	oip->i_size = length;
-	oip->i_blocks -= blocksreleased;
-	if (oip->i_blocks < 0)			/* sanity */
-		oip->i_blocks = 0;
-	oip->i_flag |= IN_CHANGE;
-	vnode_pager_setsize(ovp, length);
-#ifdef QUOTA
-	ext2_chkdq(oip, -blocksreleased, NOCRED, 0);
-#endif
-	return (allerror);
-}
-
-/*
- * Release blocks associated with the inode ip and stored in the indirect
- * block bn.  Blocks are free'd in LIFO order up to (but not including)
- * lastbn.  If level is greater than SINGLE, the block is an indirect block
- * and recursive calls to indirtrunc must be used to cleanse other indirect
- * blocks.
- *
- * NB: triple indirect blocks are untested.
- */
-
-static int
-ext2_indirtrunc(struct inode *ip, daddr_t lbn, off_t doffset, daddr_t lastbn,
-		int level, long *countp)
-{
-	int i;
-	struct buf *bp;
-	struct ext2_sb_info *fs = ip->i_e2fs;
-	daddr_t *bap;
-	struct vnode *vp;
-	daddr_t *copy, nb, nlbn, last;
-	long blkcount, factor;
-	int nblocks, blocksreleased = 0;
-	int error = 0, allerror = 0;
-
-	/*
-	 * Calculate index in current block of last
-	 * block to be kept.  -1 indicates the entire
-	 * block so we need not calculate the index.
-	 */
-	factor = 1;
-	for (i = SINGLE; i < level; i++)
-		factor *= NINDIR(fs);
-	last = lastbn;
-	if (lastbn > 0)
-		last /= factor;
-	nblocks = btodb(fs->s_blocksize);
-	/*
-	 * Get buffer of block pointers, zero those entries corresponding
-	 * to blocks to be free'd, and update on disk copy first.  Since
-	 * double(triple) indirect before single(double) indirect, calls
-	 * to bmap on these blocks will fail.  However, we already have
-	 * the on disk address, so we have to set the bio_offset field
-	 * explicitly instead of letting bread do everything for us.
-	 */
-	vp = ITOV(ip);
-	bp = getblk(vp, lblktodoff(fs, lbn), (int)fs->s_blocksize, 0, 0);
-	if ((bp->b_flags & B_CACHE) == 0) {
-		bp->b_flags &= ~(B_ERROR | B_INVAL);
-		bp->b_cmd = BUF_CMD_READ;
-		if (bp->b_bcount > bp->b_bufsize)
-			panic("ext2_indirtrunc: bad buffer size");
-		bp->b_bio2.bio_offset = doffset;
-		bp->b_bio1.bio_done = biodone_sync;
-		bp->b_bio1.bio_flags |= BIO_SYNC;
-		vfs_busy_pages(bp->b_vp, bp);
-		vn_strategy(vp, &bp->b_bio1);
-		error = biowait(&bp->b_bio1, "biord");
-	}
-	if (error) {
-		brelse(bp);
-		*countp = 0;
-		return (error);
-	}
-
-	bap = (daddr_t *)bp->b_data;
-	copy = kmalloc(fs->s_blocksize, M_TEMP, M_WAITOK);
-	bcopy((caddr_t)bap, (caddr_t)copy, (u_int)fs->s_blocksize);
-	bzero((caddr_t)&bap[last + 1],
-	  (u_int)(NINDIR(fs) - (last + 1)) * sizeof (daddr_t));
-	if (last == -1)
-		bp->b_flags |= B_INVAL;
-	error = bwrite(bp);
-	if (error)
-		allerror = error;
-	bap = copy;
-
-	/*
-	 * Recursively free totally unused blocks.
-	 */
-	for (i = NINDIR(fs) - 1, nlbn = lbn + 1 - i * factor; i > last;
-	    i--, nlbn += factor) {
-		nb = bap[i];
-		if (nb == 0)
-			continue;
-		if (level > SINGLE) {
-			if ((error = ext2_indirtrunc(ip, nlbn,
-			    fsbtodoff(fs, nb), (daddr_t)-1, level - 1, &blkcount)) != 0)
-				allerror = error;
-			blocksreleased += blkcount;
-		}
-		ext2_blkfree(ip, nb, fs->s_blocksize);
-		blocksreleased += nblocks;
-	}
-
-	/*
-	 * Recursively free last partial block.
-	 */
-	if (level > SINGLE && lastbn >= 0) {
-		last = lastbn % factor;
-		nb = bap[i];
-		if (nb != 0) {
-			error = ext2_indirtrunc(ip, nlbn, fsbtodoff(fs, nb),
-						last, level - 1, &blkcount);
-			if (error)
-				allerror = error;
-			blocksreleased += blkcount;
-		}
-	}
-	kfree(copy, M_TEMP);
-	*countp = blocksreleased;
-	return (allerror);
-}
-
-/*
- * Last reference to an inode.  If necessary, write or delete it.
- *
- * ext2_inactive(struct vnode *a_vp)
- */
-int
-ext2_inactive(struct vop_inactive_args *ap)
-{
-	struct vnode *vp = ap->a_vp;
-	struct inode *ip = VTOI(vp);
-	int mode, error = 0;
-
-	ext2_discard_prealloc(ip);
-	if (prtactive && VREFCNT(vp) > 1)
-		vprint("ext2_inactive: pushing active", vp);
-
-	/*
-	 * Ignore inodes related to stale file handles.
-	 */
-	if (ip == NULL || ip->i_mode == 0)
-		goto out;
-	if (ip->i_nlink <= 0 && (vp->v_mount->mnt_flag & MNT_RDONLY) == 0) {
-#ifdef QUOTA
-		if (!ext2_getinoquota(ip))
-			(void)ext2_chkiq(ip, -1, NOCRED, FORCE);
-#endif
-		error = EXT2_TRUNCATE(vp, (off_t)0, 0, NOCRED);
-		ip->i_rdev = 0;
-		mode = ip->i_mode;
-		ip->i_mode = 0;
-		ip->i_flag |= IN_CHANGE | IN_UPDATE;
-		EXT2_VFREE(vp, ip->i_number, mode);
-	}
-	if (ip->i_flag & (IN_ACCESS | IN_CHANGE | IN_MODIFIED | IN_UPDATE))
-		EXT2_UPDATE(vp, 0);
-out:
-	/*
-	 * If we are done with the inode, reclaim it
-	 * so that it can be reused immediately.
-	 */
-	if (ip == NULL || ip->i_mode == 0)
-		vrecycle(vp);
-	return (error);
-}
-
-/*
- * Reclaim an inode so that it can be used for other purposes.
- *
- * ext2_reclaim(struct vnode *a_vp)
- */
-int
-ext2_reclaim(struct vop_reclaim_args *ap)
-{
-	struct inode *ip;
-	struct vnode *vp = ap->a_vp;
-#ifdef QUOTA
-	int i;
-#endif
-
-	if (prtactive && VREFCNT(vp) > 1)
-		vprint("ext2_reclaim: pushing active", vp);
-	ip = VTOI(vp);
-
-	/*
-	 * Lazy updates.
-	 */
-	if (ip) {
-		if (ip->i_flag & IN_LAZYMOD) {
-			ip->i_flag |= IN_MODIFIED;
-			EXT2_UPDATE(vp, 0);
-		}
-	}
-#ifdef INVARIANTS
-	if (ip && (ip->i_flag & (IN_ACCESS | IN_CHANGE | IN_MODIFIED | IN_UPDATE))) {
-		kprintf("WARNING: INODE %ld flags %08x: modified inode being released!\n", (long)ip->i_number, (int)ip->i_flag);
-		ip->i_flag |= IN_MODIFIED;
-		EXT2_UPDATE(vp, 0);
-	}
-#endif
-	/*
-	 * Remove the inode from its hash chain and purge namecache
-	 * data associated with the vnode.
-	 */
-	vp->v_data = NULL;
-	if (ip) {
-		ext2_ihashrem(ip);
-		if (ip->i_devvp) {
-			vrele(ip->i_devvp);
-			ip->i_devvp = 0;
-		}
-#ifdef QUOTA
-		for (i = 0; i < MAXQUOTAS; i++) {
-			if (ip->i_dquot[i] != NODQUOT) {
-				ext2_dqrele(vp, ip->i_dquot[i]);
-				ip->i_dquot[i] = NODQUOT;
-			}
-		}
-#endif
-#ifdef UFS_DIRHASH
-		if (ip->i_dirhash != NULL)
-			ext2dirhash_free(ip);
-#endif
-		kfree(ip, VFSTOEXT2(vp->v_mount)->um_malloctype);
-	}
-	return (0);
-}
diff --git a/sys/gnu/vfs/ext2fs/ext2_inode_cnv.c b/sys/gnu/vfs/ext2fs/ext2_inode_cnv.c
deleted file mode 100644
index 0fede40751..0000000000
--- a/sys/gnu/vfs/ext2fs/ext2_inode_cnv.c
+++ /dev/null
@@ -1,136 +0,0 @@
-/*
- * Copyright (c) 1995 The University of Utah and
- * the Computer Systems Laboratory at the University of Utah (CSL).
- * All rights reserved.
- *
- * Permission to use, copy, modify and distribute this software is hereby
- * granted provided that (1) source code retains these copyright, permission,
- * and disclaimer notices, and (2) redistributions including binaries
- * reproduce the notices in supporting documentation, and (3) all advertising
- * materials mentioning features or use of this software display the following
- * acknowledgement: ``This product includes software developed by the
- * Computer Systems Laboratory at the University of Utah.''
- *
- * THE UNIVERSITY OF UTAH AND CSL ALLOW FREE USE OF THIS SOFTWARE IN ITS "AS
- * IS" CONDITION.  THE UNIVERSITY OF UTAH AND CSL DISCLAIM ANY LIABILITY OF
- * ANY KIND FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * CSL requests users of this software to return to csl-dist@cs.utah.edu any
- * improvements that they make and grant CSL redistribution rights.
- *
- *      Utah $Hdr$
- * $FreeBSD: src/sys/gnu/ext2fs/ext2_inode_cnv.c,v 1.11 2000/01/01 17:39:21 bde Exp $
- */
-
-/*
- * routines to convert on disk ext2 inodes in dinodes and back
- */
-#include <sys/param.h>
-#include <sys/systm.h>
-#include <sys/lock.h>
-#include <sys/stat.h>
-#include <sys/vnode.h>
-
-#include <machine/inttypes.h>
-
-#include "quota.h"
-
-#define NO_I_DEFINES
-#include "inode.h"
-#include "ext2_fs.h"
-#include "ext2_extern.h"
-
-void
-ext2_print_dinode(struct ext2_dinode *di)
-{
-	int i;
-	kprintf( /* "Inode: %5d" */
-		" Type: %10s Mode: 0x%o Flags: 0x%x  Version: %d\n",
-		"n/a", di->di_mode, di->di_flags, di->di_gen);
-	kprintf( "User: %5lu Group: %5lu  Size: %lu\n",
-		(unsigned long)di->di_uid, (unsigned long)di->di_gid,
-		(unsigned long)di->di_size);
-	kprintf( "Links: %3d Blockcount: %d\n",
-		di->di_nlink, di->di_blocks);
-	kprintf( "ctime: 0x%x", di->di_ctime);
-	kprintf( "atime: 0x%x", di->di_atime);
-	kprintf( "mtime: 0x%x", di->di_mtime);
-	kprintf( "BLOCKS: ");
-	for(i=0; i < (di->di_blocks <= 24 ? ((di->di_blocks+1)/2): 12); i++)
-		kprintf("%d ", di->di_db[i]);
-	kprintf("\n");
-}
-
-void
-ext2_print_inode(struct inode *in)
-{
-	kprintf( "Inode: %"PRId64, in->i_number);
-	ext2_print_dinode(&in->i_din);
-}
-
-/*
- *	raw ext2 inode to dinode
- */
-void
-ext2_ei2di(struct ext2_inode *ei, struct ext2_dinode *di)
-{
-        int     i;
-
-        di->di_nlink    = ei->i_links_count;
-	/* Godmar thinks - if the link count is zero, then the inode is
-	   unused - according to ext2 standards. Ufs marks this fact
-	   by setting i_mode to zero - why ?
-	   I can see that this might lead to problems in an undelete.
-	*/
-	di->di_mode     = ei->i_links_count ? ei->i_mode : 0;
-        di->di_size     = ei->i_size;
-        di->di_atime	= ei->i_atime;
-        di->di_mtime	= ei->i_mtime;
-        di->di_ctime	= ei->i_ctime;
-        di->di_flags    = 0;
-        di->di_flags    |= (ei->i_flags & EXT2_APPEND_FL) ? APPEND : 0;
-        di->di_flags    |= (ei->i_flags & EXT2_IMMUTABLE_FL) ? IMMUTABLE : 0;
-        di->di_blocks   = ei->i_blocks;
-        di->di_gen      = ei->i_generation;
-        di->di_uid      = ei->i_uid;
-        di->di_gid      = ei->i_gid;
-	/* XXX use memcpy */
-        for(i = 0; i < NDADDR; i++)
-                di->di_db[i] = ei->i_block[i];
-        for(i = 0; i < NIADDR; i++)
-                di->di_ib[i] = ei->i_block[EXT2_NDIR_BLOCKS + i];
-}
-
-/*
- *	dinode to raw ext2 inode
- */
-void
-ext2_di2ei(struct ext2_dinode *di, struct ext2_inode *ei)
-{
-        int     i;
-
-        ei->i_mode              = di->di_mode;
-        ei->i_links_count       = di->di_nlink;
-	/*
-	   Godmar thinks: if dtime is nonzero, ext2 says this inode
-	   has been deleted, this would correspond to a zero link count
-	 */
-        ei->i_dtime             = ei->i_links_count ? 0 : di->di_mtime;
-        ei->i_size              = di->di_size;
-        ei->i_atime             = di->di_atime;
-        ei->i_mtime             = di->di_mtime;
-        ei->i_ctime             = di->di_ctime;
-        ei->i_flags    		= 0;
-        ei->i_flags    		|= (di->di_flags & APPEND) ? EXT2_APPEND_FL: 0;
-        ei->i_flags    		|= (di->di_flags & IMMUTABLE)
-							? EXT2_IMMUTABLE_FL: 0;
-        ei->i_blocks            = di->di_blocks;
-        ei->i_generation        = di->di_gen;
-        ei->i_uid               = di->di_uid;
-        ei->i_gid               = di->di_gid;
-	/* XXX use memcpy */
-        for(i = 0; i < NDADDR; i++)
-                ei->i_block[i] = di->di_db[i];
-        for(i = 0; i < NIADDR; i++)
-                ei->i_block[EXT2_NDIR_BLOCKS + i] = di->di_ib[i];
-}
diff --git a/sys/gnu/vfs/ext2fs/ext2_linux_balloc.c b/sys/gnu/vfs/ext2fs/ext2_linux_balloc.c
deleted file mode 100644
index 0413e8f5c1..0000000000
--- a/sys/gnu/vfs/ext2fs/ext2_linux_balloc.c
+++ /dev/null
@@ -1,622 +0,0 @@
-/*
- *  modified for Lites 1.1
- *
- *  Aug 1995, Godmar Back (gback@cs.utah.edu)
- *  University of Utah, Department of Computer Science
- *
- * $FreeBSD: src/sys/gnu/ext2fs/ext2_linux_balloc.c,v 1.11.2.3 2001/08/14 18:03:19 gallatin Exp $
- */
-/*
- *  linux/fs/ext2/balloc.c
- *
- * Copyright (C) 1992, 1993, 1994, 1995
- * Remy Card (card@masi.ibp.fr)
- * Laboratoire MASI - Institut Blaise Pascal
- * Universite Pierre et Marie Curie (Paris VI)
- *
- *  Enhanced block allocation by Stephen Tweedie (sct@dcs.ed.ac.uk), 1993
- */
-
-/*
- * The free blocks are managed by bitmaps.  A file system contains several
- * blocks groups.  Each group contains 1 bitmap block for blocks, 1 bitmap
- * block for inodes, N blocks for the inode table and data blocks.
- *
- * The file system contains group descriptors which are located after the
- * super block.  Each descriptor contains the number of the bitmap block and
- * the free blocks count in the block.  The descriptors are loaded in memory
- * when a file system is mounted (see ext2_read_super).
- */
-
-#include <sys/param.h>
-#include <sys/systm.h>
-#include <sys/buf.h>
-#include <sys/proc.h>
-#include <sys/mount.h>
-#include <sys/vnode.h>
-#include <sys/thread2.h>
-
-#include <sys/buf2.h>
-
-#include "quota.h"
-#include "dinode.h"
-#include "inode.h"
-#include "ext2_mount.h"
-#include "ext2_extern.h"
-#include "ext2_fs.h"
-#include "ext2_fs_sb.h"
-#include "fs.h"
-
-#ifdef __x86_64__
-#include "ext2_bitops.h"
-#endif
-
-#define in_range(b, first, len)		((b) >= (first) && (b) <= (first) + (len) - 1)
-
-/* got rid of get_group_desc since it can already be found in
- * ext2_linux_ialloc.c
- */
-
-static void
-read_block_bitmap(struct mount *mp, unsigned int block_group,
-		  unsigned long bitmap_nr)
-{
-	struct ext2_sb_info *sb = VFSTOEXT2(mp)->um_e2fs;
-	struct ext2_group_desc *gdp;
-	struct buf *bh;
-	int    error;
-
-	gdp = get_group_desc (mp, block_group, NULL);
-	error = bread(VFSTOEXT2(mp)->um_devvp,
-		      fsbtodoff(sb, gdp->bg_block_bitmap),
-		      sb->s_blocksize, &bh);
-	if (error) {
-		panic ( "read_block_bitmap: "
-			    "Cannot read block bitmap - "
-			    "block_group = %d, block_bitmap = %lu",
-			    block_group, (unsigned long) gdp->bg_block_bitmap);
-	}
-	sb->s_block_bitmap_number[bitmap_nr] = block_group;
-	sb->s_block_bitmap[bitmap_nr] = bh;
-	LCK_BUF(bh)
-}
-
-/*
- * load_block_bitmap loads the block bitmap for a blocks group
- *
- * It maintains a cache for the last bitmaps loaded.  This cache is managed
- * with a LRU algorithm.
- *
- * Notes:
- * 1/ There is one cache per mounted file system.
- * 2/ If the file system contains less than EXT2_MAX_GROUP_LOADED groups,
- *    this function reads the bitmap without maintaining a LRU cache.
- */
-static int
-load__block_bitmap(struct mount *mp, unsigned int block_group)
-{
-	int i, j;
-	struct ext2_sb_info *sb = VFSTOEXT2(mp)->um_e2fs;
-	unsigned long block_bitmap_number;
-	struct buf *block_bitmap;
-
-	if (block_group >= sb->s_groups_count)
-		panic ( "load_block_bitmap: "
-			    "block_group >= groups_count - "
-			    "block_group = %d, groups_count = %lu",
-			    block_group, sb->s_groups_count);
-
-	if (sb->s_groups_count <= EXT2_MAX_GROUP_LOADED) {
-		if (sb->s_block_bitmap[block_group]) {
-			if (sb->s_block_bitmap_number[block_group] !=
-			    block_group)
-				panic ( "load_block_bitmap: "
-					    "block_group != block_bitmap_number");
-			else
-				return block_group;
-		} else {
-			read_block_bitmap (mp, block_group, block_group);
-			return block_group;
-		}
-	}
-
-	for (i = 0; i < sb->s_loaded_block_bitmaps &&
-		    sb->s_block_bitmap_number[i] != block_group; i++)
-		;
-	if (i < sb->s_loaded_block_bitmaps &&
-	    sb->s_block_bitmap_number[i] == block_group) {
-		block_bitmap_number = sb->s_block_bitmap_number[i];
-		block_bitmap = sb->s_block_bitmap[i];
-		for (j = i; j > 0; j--) {
-			sb->s_block_bitmap_number[j] =
-				sb->s_block_bitmap_number[j - 1];
-			sb->s_block_bitmap[j] =
-				sb->s_block_bitmap[j - 1];
-		}
-		sb->s_block_bitmap_number[0] = block_bitmap_number;
-		sb->s_block_bitmap[0] = block_bitmap;
-	} else {
-		if (sb->s_loaded_block_bitmaps < EXT2_MAX_GROUP_LOADED)
-			sb->s_loaded_block_bitmaps++;
-		else
-			ULCK_BUF(sb->s_block_bitmap[EXT2_MAX_GROUP_LOADED - 1])
-
-		for (j = sb->s_loaded_block_bitmaps - 1; j > 0;  j--) {
-			sb->s_block_bitmap_number[j] =
-				sb->s_block_bitmap_number[j - 1];
-			sb->s_block_bitmap[j] =
-				sb->s_block_bitmap[j - 1];
-		}
-		read_block_bitmap (mp, block_group, 0);
-	}
-	return 0;
-}
-
-static __inline int
-load_block_bitmap(struct mount *mp, unsigned int block_group)
-{
-	struct ext2_sb_info *sb = VFSTOEXT2(mp)->um_e2fs;
-	if (sb->s_loaded_block_bitmaps > 0 &&
-	    sb->s_block_bitmap_number[0] == block_group)
-		return 0;
-
-	if (sb->s_groups_count <= EXT2_MAX_GROUP_LOADED &&
-	    sb->s_block_bitmap_number[block_group] == block_group &&
-	    sb->s_block_bitmap[block_group])
-		return block_group;
-
-	return load__block_bitmap (mp, block_group);
-}
-
-void
-ext2_free_blocks(struct mount *mp, unsigned long block,
-		 unsigned long count)
-{
-	struct ext2_sb_info *sb = VFSTOEXT2(mp)->um_e2fs;
-	struct buf *bh;
-	struct buf *bh2;
-	unsigned long block_group;
-	unsigned long bit;
-	unsigned long i;
-	int bitmap_nr;
-	struct ext2_group_desc *gdp;
-	struct ext2_super_block *es;
-
-	if (!sb) {
-		kprintf ("ext2_free_blocks: nonexistent device");
-		return;
-	}
-	es = sb->s_es;
-	lock_super (VFSTOEXT2(mp)->um_devvp);
-	if (block < es->s_first_data_block ||
-	    (block + count) > es->s_blocks_count) {
-		kprintf ( "ext2_free_blocks: "
-			    "Freeing blocks not in datazone - "
-			    "block = %lu, count = %lu", block, count);
-		unlock_super (VFSTOEXT2(mp)->um_devvp);
-		return;
-	}
-
-	ext2_debug ("freeing blocks %lu to %lu\n", block, block+count-1);
-
-	block_group = (block - es->s_first_data_block) /
-		      EXT2_BLOCKS_PER_GROUP(sb);
-	bit = (block - es->s_first_data_block) % EXT2_BLOCKS_PER_GROUP(sb);
-	if (bit + count > EXT2_BLOCKS_PER_GROUP(sb))
-		panic ( "ext2_free_blocks: "
-			    "Freeing blocks across group boundary - "
-			    "Block = %lu, count = %lu",
-			    block, count);
-	bitmap_nr = load_block_bitmap (mp, block_group);
-	bh = sb->s_block_bitmap[bitmap_nr];
-	gdp = get_group_desc (mp, block_group, &bh2);
-
-	if (/* test_opt (sb, CHECK_STRICT) && 	assume always strict ! */
-	    (in_range (gdp->bg_block_bitmap, block, count) ||
-	     in_range (gdp->bg_inode_bitmap, block, count) ||
-	     in_range (block, gdp->bg_inode_table,
-		       sb->s_itb_per_group) ||
-	     in_range (block + count - 1, gdp->bg_inode_table,
-		       sb->s_itb_per_group)))
-		panic ( "ext2_free_blocks: "
-			    "Freeing blocks in system zones - "
-			    "Block = %lu, count = %lu",
-			    block, count);
-
-	for (i = 0; i < count; i++) {
-		if (!clear_bit (bit + i, bh->b_data))
-			kprintf ("ext2_free_blocks: "
-				      "bit already cleared for block %lu",
-				      block);
-		else {
-			gdp->bg_free_blocks_count++;
-			es->s_free_blocks_count++;
-		}
-	}
-
-	mark_buffer_dirty(bh2);
-	mark_buffer_dirty(bh);
-/****
-	if (sb->s_flags & MS_SYNCHRONOUS) {
-		ll_rw_block (WRITE, 1, &bh);
-		wait_on_buffer (bh);
-	}
-****/
-	sb->s_dirt = 1;
-	unlock_super (VFSTOEXT2(mp)->um_devvp);
-	return;
-}
-
-/*
- * ext2_new_block uses a goal block to assist allocation.  If the goal is
- * free, or there is a free block within 32 blocks of the goal, that block
- * is allocated.  Otherwise a forward search is made for a free block; within
- * each block group the search first looks for an entire free byte in the block
- * bitmap, and then for any free bit if that fails.
- */
-int
-ext2_new_block(struct mount *mp, unsigned long goal,
-	       u_int32_t *prealloc_count,
-	       u_int32_t *prealloc_block)
-{
-	struct ext2_sb_info *sb = VFSTOEXT2(mp)->um_e2fs;
-	struct buf *bh;
-	struct buf *bh2;
-	char *p, *r;
-	int i, j, k, tmp;
-	int bitmap_nr;
-	struct ext2_group_desc *gdp;
-	struct ext2_super_block *es;
-
-#ifdef EXT2FS_DEBUG
-	static int goal_hits = 0, goal_attempts = 0;
-#endif
-	if (!sb) {
-		kprintf ("ext2_new_block: nonexistent device");
-		return 0;
-	}
-	es = sb->s_es;
-	lock_super (VFSTOEXT2(mp)->um_devvp);
-
-        ext2_debug ("goal=%lu.\n", goal);
-
-repeat:
-	/*
-	 * First, test whether the goal block is free.
-	 */
-	if (goal < es->s_first_data_block || goal >= es->s_blocks_count)
-		goal = es->s_first_data_block;
-	i = (goal - es->s_first_data_block) / EXT2_BLOCKS_PER_GROUP(sb);
-	gdp = get_group_desc (mp, i, &bh2);
-	if (gdp->bg_free_blocks_count > 0) {
-		j = ((goal - es->s_first_data_block) % EXT2_BLOCKS_PER_GROUP(sb));
-#ifdef EXT2FS_DEBUG
-		if (j)
-			goal_attempts++;
-#endif
-		bitmap_nr = load_block_bitmap (mp, i);
-		bh = sb->s_block_bitmap[bitmap_nr];
-
-		ext2_debug ("goal is at %d:%d.\n", i, j);
-
-		if (!test_bit(j, bh->b_data)) {
-#ifdef EXT2FS_DEBUG
-			goal_hits++;
-			ext2_debug ("goal bit allocated.\n");
-#endif
-			goto got_block;
-		}
-		if (j) {
-			/*
-			 * The goal was occupied; search forward for a free
-			 * block within the next XX blocks.
-			 *
-			 * end_goal is more or less random, but it has to be
-			 * less than EXT2_BLOCKS_PER_GROUP. Aligning up to the
-			 * next 64-bit boundary is simple..
-			 */
-			int end_goal = (j + 63) & ~63;
-			j = find_next_zero_bit(bh->b_data, end_goal, j);
-			if (j < end_goal)
-				goto got_block;
-		}
-
-		ext2_debug ("Bit not found near goal\n");
-
-		/*
-		 * There has been no free block found in the near vicinity
-		 * of the goal: do a search forward through the block groups,
-		 * searching in each group first for an entire free byte in
-		 * the bitmap and then for any free bit.
-		 *
-		 * Search first in the remainder of the current group; then,
-		 * cyclicly search through the rest of the groups.
-		 */
-		p = ((char *) bh->b_data) + (j >> 3);
-		r = memscan(p, 0, (EXT2_BLOCKS_PER_GROUP(sb) - j + 7) >> 3);
-		k = (r - ((char *) bh->b_data)) << 3;
-		if (k < EXT2_BLOCKS_PER_GROUP(sb)) {
-			j = k;
-			goto search_back;
-		}
-		k = find_next_zero_bit ((unsigned long *) bh->b_data,
-					EXT2_BLOCKS_PER_GROUP(sb),
-					j);
-		if (k < EXT2_BLOCKS_PER_GROUP(sb)) {
-			j = k;
-			goto got_block;
-		}
-	}
-
-	ext2_debug ("Bit not found in block group %d.\n", i);
-
-	/*
-	 * Now search the rest of the groups.  We assume that
-	 * i and gdp correctly point to the last group visited.
-	 */
-	for (k = 0; k < sb->s_groups_count; k++) {
-		i++;
-		if (i >= sb->s_groups_count)
-			i = 0;
-		gdp = get_group_desc (mp, i, &bh2);
-		if (gdp->bg_free_blocks_count > 0)
-			break;
-	}
-	if (k >= sb->s_groups_count) {
-		unlock_super (VFSTOEXT2(mp)->um_devvp);
-		return 0;
-	}
-	bitmap_nr = load_block_bitmap (mp, i);
-	bh = sb->s_block_bitmap[bitmap_nr];
-	r = memscan(bh->b_data, 0, EXT2_BLOCKS_PER_GROUP(sb) >> 3);
-	j = (r - bh->b_data) << 3;
-
-	if (j < EXT2_BLOCKS_PER_GROUP(sb))
-		goto search_back;
-	else
-		j = find_first_zero_bit ((unsigned long *) bh->b_data,
-					 EXT2_BLOCKS_PER_GROUP(sb));
-	if (j >= EXT2_BLOCKS_PER_GROUP(sb)) {
-		kprintf ( "ext2_new_block: "
-			 "Free blocks count corrupted for block group %d", i);
-		unlock_super (VFSTOEXT2(mp)->um_devvp);
-		return 0;
-	}
-
-search_back:
-	/*
-	 * We have succeeded in finding a free byte in the block
-	 * bitmap.  Now search backwards up to 7 bits to find the
-	 * start of this group of free blocks.
-	 */
-	for (k = 0; k < 7 && j > 0 && !test_bit (j - 1, bh->b_data); k++, j--);
-
-got_block:
-
-	ext2_debug ("using block group %d(%d)\n", i, gdp->bg_free_blocks_count);
-
-	tmp = j + i * EXT2_BLOCKS_PER_GROUP(sb) + es->s_first_data_block;
-
-	if (/* test_opt (sb, CHECK_STRICT) && we are always strict. */
-	    (tmp == gdp->bg_block_bitmap ||
-	     tmp == gdp->bg_inode_bitmap ||
-	     in_range (tmp, gdp->bg_inode_table, sb->s_itb_per_group)))
-		panic ( "ext2_new_block: "
-			    "Allocating block in system zone - "
-			    "%dth block = %u in group %u", j, tmp, i);
-
-	if (set_bit (j, bh->b_data)) {
-		kprintf ( "ext2_new_block: "
-			 "bit already set for block %d", j);
-		goto repeat;
-	}
-
-	ext2_debug ("found bit %d\n", j);
-
-	/*
-	 * Do block preallocation now if required.
-	 */
-#ifdef EXT2_PREALLOCATE
-	if (prealloc_block) {
-		*prealloc_count = 0;
-		*prealloc_block = tmp + 1;
-		for (k = 1;
-		     k < 8 && (j + k) < EXT2_BLOCKS_PER_GROUP(sb); k++) {
-			if (set_bit (j + k, bh->b_data))
-				break;
-			(*prealloc_count)++;
-		}
-		gdp->bg_free_blocks_count -= *prealloc_count;
-		es->s_free_blocks_count -= *prealloc_count;
-		ext2_debug ("Preallocated a further %lu bits.\n",
-			    *prealloc_count);
-	}
-#endif
-
-	j = tmp;
-
-	mark_buffer_dirty(bh);
-/****
-	if (sb->s_flags & MS_SYNCHRONOUS) {
-		ll_rw_block (WRITE, 1, &bh);
-		wait_on_buffer (bh);
-	}
-****/
-	if (j >= es->s_blocks_count) {
-		kprintf ( "ext2_new_block: "
-			    "block >= blocks count - "
-			    "block_group = %d, block=%d", i, j);
-		unlock_super (VFSTOEXT2(mp)->um_devvp);
-		return 0;
-	}
-
-	ext2_debug ("allocating block %d. "
-		    "Goal hits %d of %d.\n", j, goal_hits, goal_attempts);
-
-	gdp->bg_free_blocks_count--;
-	mark_buffer_dirty(bh2);
-	es->s_free_blocks_count--;
-	sb->s_dirt = 1;
-	unlock_super (VFSTOEXT2(mp)->um_devvp);
-	return j;
-}
-
-#ifdef unused
-static unsigned long
-ext2_count_free_blocks(struct mount *mp)
-{
-	struct ext2_sb_info *sb = VFSTOEXT2(mp)->um_e2fs;
-#ifdef EXT2FS_DEBUG
-	struct ext2_super_block *es;
-	unsigned long desc_count, bitmap_count, x;
-	int bitmap_nr;
-	struct ext2_group_desc *gdp;
-	int i;
-
-	lock_super (VFSTOEXT2(mp)->um_devvp);
-	es = sb->s_es;
-	desc_count = 0;
-	bitmap_count = 0;
-	gdp = NULL;
-	for (i = 0; i < sb->s_groups_count; i++) {
-		gdp = get_group_desc (mp, i, NULL);
-		desc_count += gdp->bg_free_blocks_count;
-		bitmap_nr = load_block_bitmap (mp, i);
-		x = ext2_count_free (sb->s_block_bitmap[bitmap_nr],
-				     sb->s_blocksize);
-		ext2_debug ("group %d: stored = %d, counted = %lu\n",
-			i, gdp->bg_free_blocks_count, x);
-		bitmap_count += x;
-	}
-	ext2_debug( "stored = %lu, computed = %lu, %lu\n",
-	       es->s_free_blocks_count, desc_count, bitmap_count);
-	unlock_super (VFSTOEXT2(mp)->um_devvp);
-	return bitmap_count;
-#else
-	return sb->s_es->s_free_blocks_count;
-#endif
-}
-
-static __inline int
-block_in_use (unsigned long block, struct ext2_sb_info *sb,
-	      unsigned char *map)
-{
-	return test_bit ((block - sb->s_es->s_first_data_block) %
-			 EXT2_BLOCKS_PER_GROUP(sb), map);
-}
-#endif /* unused */
-
-static int
-test_root(int a, int b)
-{
-	if (a == 0)
-		return 1;
-	while (1) {
-		if (a == 1)
-			return 1;
-		if (a % b)
-			return 0;
-		a = a / b;
-	}
-}
-
-int
-ext2_group_sparse(int group)
-{
-	return (test_root(group, 3) || test_root(group, 5) ||
-		test_root(group, 7));
-}
-
-#ifdef unused
-static void
-ext2_check_blocks_bitmap(struct mount *mp)
-{
-	struct ext2_sb_info *sb = VFSTOEXT2(mp)->um_e2fs;
-	struct buf *bh;
-	struct ext2_super_block *es;
-	unsigned long desc_count, bitmap_count, x;
-	unsigned long desc_blocks;
-	int bitmap_nr;
-	struct ext2_group_desc *gdp;
-	int i, j;
-
-	lock_super (VFSTOEXT2(mp)->um_devvp);
-	es = sb->s_es;
-	desc_count = 0;
-	bitmap_count = 0;
-	gdp = NULL;
-	desc_blocks = (sb->s_groups_count + EXT2_DESC_PER_BLOCK(sb) - 1) /
-		      EXT2_DESC_PER_BLOCK(sb);
-	for (i = 0; i < sb->s_groups_count; i++) {
-		gdp = get_group_desc (mp, i, NULL);
-		desc_count += gdp->bg_free_blocks_count;
-		bitmap_nr = load_block_bitmap (mp, i);
-		bh = sb->s_block_bitmap[bitmap_nr];
-
-		if (!(es->s_feature_ro_compat &
-		     EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER) ||
-		    ext2_group_sparse(i)) {
-			if (!test_bit (0, bh->b_data))
-				kprintf ("ext2_check_blocks_bitmap: "
-					    "Superblock in group %d "
-					    "is marked free", i);
-
-			for (j = 0; j < desc_blocks; j++)
-				if (!test_bit (j + 1, bh->b_data))
-					kprintf ("ext2_check_blocks_bitmap: "
-					    "Descriptor block #%d in group "
-					    "%d is marked free", j, i);
-		}
-
-		if (!block_in_use (gdp->bg_block_bitmap, sb, bh->b_data))
-			kprintf ("ext2_check_blocks_bitmap: "
-				    "Block bitmap for group %d is marked free",
-				    i);
-
-		if (!block_in_use (gdp->bg_inode_bitmap, sb, bh->b_data))
-			kprintf ("ext2_check_blocks_bitmap: "
-				    "Inode bitmap for group %d is marked free",
-				    i);
-
-		for (j = 0; j < sb->s_itb_per_group; j++)
-			if (!block_in_use (gdp->bg_inode_table + j, sb, bh->b_data))
-				kprintf ("ext2_check_blocks_bitmap: "
-					    "Block #%d of the inode table in "
-					    "group %d is marked free", j, i);
-
-		x = ext2_count_free (bh, sb->s_blocksize);
-		if (gdp->bg_free_blocks_count != x)
-			kprintf ("ext2_check_blocks_bitmap: "
-				    "Wrong free blocks count for group %d, "
-				    "stored = %d, counted = %lu", i,
-				    gdp->bg_free_blocks_count, x);
-		bitmap_count += x;
-	}
-	if (es->s_free_blocks_count != bitmap_count)
-		kprintf ("ext2_check_blocks_bitmap: "
-			    "Wrong free blocks count in super block, "
-			    "stored = %lu, counted = %lu",
-			    (unsigned long) es->s_free_blocks_count, bitmap_count);
-	unlock_super (VFSTOEXT2(mp)->um_devvp);
-}
-#endif /* unused */
-
-/*
- *  this function is taken from
- *  linux/fs/ext2/bitmap.c
- */
-
-static int nibblemap[] = {4, 3, 3, 2, 3, 2, 2, 1, 3, 2, 2, 1, 2, 1, 1, 0};
-
-unsigned long ext2_count_free (struct buf *map, unsigned int numchars)
-{
-        unsigned int i;
-        unsigned long sum = 0;
-
-        if (!map)
-                return (0);
-        for (i = 0; i < numchars; i++)
-                sum += nibblemap[map->b_data[i] & 0xf] +
-                        nibblemap[(map->b_data[i] >> 4) & 0xf];
-        return (sum);
-}
diff --git a/sys/gnu/vfs/ext2fs/ext2_linux_ialloc.c b/sys/gnu/vfs/ext2fs/ext2_linux_ialloc.c
deleted file mode 100644
index ec6d11ddad..0000000000
--- a/sys/gnu/vfs/ext2fs/ext2_linux_ialloc.c
+++ /dev/null
@@ -1,515 +0,0 @@
-/*
- *  modified for Lites 1.1
- *
- *  Aug 1995, Godmar Back (gback@cs.utah.edu)
- *  University of Utah, Department of Computer Science
- *
- * $FreeBSD: src/sys/gnu/ext2fs/ext2_linux_ialloc.c,v 1.13.2.2 2001/08/14 18:03:19 gallatin Exp $
- */
-/*
- *  linux/fs/ext2/ialloc.c
- *
- * Copyright (C) 1992, 1993, 1994, 1995
- * Remy Card (card@masi.ibp.fr)
- * Laboratoire MASI - Institut Blaise Pascal
- * Universite Pierre et Marie Curie (Paris VI)
- *
- *  BSD ufs-inspired inode and directory allocation by
- *  Stephen Tweedie (sct@dcs.ed.ac.uk), 1993
- */
-
-/*
- * The free inodes are managed by bitmaps.  A file system contains several
- * blocks groups.  Each group contains 1 bitmap block for blocks, 1 bitmap
- * block for inodes, N blocks for the inode table and data blocks.
- *
- * The file system contains group descriptors which are located after the
- * super block.  Each descriptor contains the number of the bitmap block and
- * the free blocks count in the block.  The descriptors are loaded in memory
- * when a file system is mounted (see ext2_read_super).
- */
-
-#include <sys/param.h>
-#include <sys/systm.h>
-#include <sys/buf.h>
-#include <sys/proc.h>
-#include <sys/mount.h>
-#include <sys/vnode.h>
-
-#include "quota.h"
-#include "inode.h"
-#include "ext2_mount.h"
-#include "ext2_extern.h"
-#include "ext2_fs.h"
-#include "ext2_fs_sb.h"
-#include "fs.h"
-
-#include <sys/stat.h>
-#include <sys/buf2.h>
-#include <sys/thread2.h>
-
-#ifdef __x86_64__
-#include "ext2_bitops.h"
-#endif
-
-/* this is supposed to mark a buffer dirty on ready for delayed writing
- */
-void
-mark_buffer_dirty(struct buf *bh)
-{
-	crit_enter();
-	bh->b_flags |= B_DIRTY;
-	crit_exit();
-}
-
-struct ext2_group_desc *
-get_group_desc(struct mount *mp, unsigned int block_group,
-	       struct buf **bh)
-{
-	struct ext2_sb_info *sb = VFSTOEXT2(mp)->um_e2fs;
-	unsigned long group_desc;
-	unsigned long desc;
-	struct ext2_group_desc *gdp;
-
-	if (block_group >= sb->s_groups_count)
-		panic ("get_group_desc: "
-			    "block_group >= groups_count - "
-			    "block_group = %d, groups_count = %lu",
-			    block_group, sb->s_groups_count);
-
-	group_desc = block_group / EXT2_DESC_PER_BLOCK(sb);
-	desc = block_group % EXT2_DESC_PER_BLOCK(sb);
-	if (!sb->s_group_desc[group_desc])
-		panic ( "get_group_desc:"
-			    "Group descriptor not loaded - "
-			    "block_group = %d, group_desc = %lu, desc = %lu",
-			     block_group, group_desc, desc);
-	gdp = (struct ext2_group_desc *)
-		sb->s_group_desc[group_desc]->b_data;
-	if (bh)
-		*bh = sb->s_group_desc[group_desc];
-	return gdp + desc;
-}
-
-static void
-read_inode_bitmap(struct mount *mp, unsigned long block_group,
-		  unsigned int bitmap_nr)
-{
-	struct ext2_sb_info *sb = VFSTOEXT2(mp)->um_e2fs;
-	struct ext2_group_desc *gdp;
-	struct buf *bh;
-	int	error;
-
-	gdp = get_group_desc (mp, block_group, NULL);
-	if ((error = bread (VFSTOEXT2(mp)->um_devvp,
-			    fsbtodoff(sb, gdp->bg_inode_bitmap),
-			    sb->s_blocksize, &bh)) != 0)
-		panic ( "read_inode_bitmap:"
-			    "Cannot read inode bitmap - "
-			    "block_group = %lu, inode_bitmap = %lu",
-			    block_group, (unsigned long) gdp->bg_inode_bitmap);
-	sb->s_inode_bitmap_number[bitmap_nr] = block_group;
-	sb->s_inode_bitmap[bitmap_nr] = bh;
-	LCK_BUF(bh)
-}
-
-/*
- * load_inode_bitmap loads the inode bitmap for a blocks group
- *
- * It maintains a cache for the last bitmaps loaded.  This cache is managed
- * with a LRU algorithm.
- *
- * Notes:
- * 1/ There is one cache per mounted file system.
- * 2/ If the file system contains less than EXT2_MAX_GROUP_LOADED groups,
- *    this function reads the bitmap without maintaining a LRU cache.
- */
-static int
-load_inode_bitmap(struct mount *mp, unsigned int block_group)
-{
-	struct ext2_sb_info *sb = VFSTOEXT2(mp)->um_e2fs;
-	int i, j;
-	unsigned long inode_bitmap_number;
-	struct buf *inode_bitmap;
-
-	if (block_group >= sb->s_groups_count)
-		panic ("load_inode_bitmap:"
-			    "block_group >= groups_count - "
-			    "block_group = %d, groups_count = %lu",
-			     block_group, sb->s_groups_count);
-	if (sb->s_loaded_inode_bitmaps > 0 &&
-	    sb->s_inode_bitmap_number[0] == block_group)
-		return 0;
-	if (sb->s_groups_count <= EXT2_MAX_GROUP_LOADED) {
-		if (sb->s_inode_bitmap[block_group]) {
-			if (sb->s_inode_bitmap_number[block_group] !=
-				block_group)
-				panic ( "load_inode_bitmap:"
-				    "block_group != inode_bitmap_number");
-			else
-				return block_group;
-		} else {
-			read_inode_bitmap (mp, block_group, block_group);
-			return block_group;
-		}
-	}
-
-	for (i = 0; i < sb->s_loaded_inode_bitmaps &&
-		    sb->s_inode_bitmap_number[i] != block_group;
-	     i++)
-		;
-	if (i < sb->s_loaded_inode_bitmaps &&
-	    sb->s_inode_bitmap_number[i] == block_group) {
-		inode_bitmap_number = sb->s_inode_bitmap_number[i];
-		inode_bitmap = sb->s_inode_bitmap[i];
-		for (j = i; j > 0; j--) {
-			sb->s_inode_bitmap_number[j] =
-				sb->s_inode_bitmap_number[j - 1];
-			sb->s_inode_bitmap[j] =
-				sb->s_inode_bitmap[j - 1];
-		}
-		sb->s_inode_bitmap_number[0] = inode_bitmap_number;
-		sb->s_inode_bitmap[0] = inode_bitmap;
-	} else {
-		if (sb->s_loaded_inode_bitmaps < EXT2_MAX_GROUP_LOADED)
-			sb->s_loaded_inode_bitmaps++;
-		else
-			ULCK_BUF(sb->s_inode_bitmap[EXT2_MAX_GROUP_LOADED - 1])
-		for (j = sb->s_loaded_inode_bitmaps - 1; j > 0; j--) {
-			sb->s_inode_bitmap_number[j] =
-				sb->s_inode_bitmap_number[j - 1];
-			sb->s_inode_bitmap[j] =
-				sb->s_inode_bitmap[j - 1];
-		}
-		read_inode_bitmap (mp, block_group, 0);
-	}
-	return 0;
-}
-
-
-void
-ext2_free_inode(struct inode *inode)
-{
-	struct ext2_sb_info *sb;
-	struct buf *bh;
-	struct buf *bh2;
-	unsigned long block_group;
-	unsigned long bit;
-	int bitmap_nr;
-	struct ext2_group_desc *gdp;
-	struct ext2_super_block *es;
-
-	if (!inode)
-		return;
-
-	if (inode->i_nlink) {
-		kprintf ("ext2_free_inode: inode has nlink=%d\n",
-			inode->i_nlink);
-		return;
-	}
-
-	ext2_debug ("freeing inode %lu\n", inode->i_number);
-
-	sb = inode->i_e2fs;
-	lock_super (DEVVP(inode));
-	if (inode->i_number < EXT2_FIRST_INO(sb) ||
-	    inode->i_number > sb->s_es->s_inodes_count) {
-		kprintf ("free_inode reserved inode or nonexistent inode");
-		unlock_super (DEVVP(inode));
-		return;
-	}
-	es = sb->s_es;
-	block_group = (inode->i_number - 1) / EXT2_INODES_PER_GROUP(sb);
-	bit = (inode->i_number - 1) % EXT2_INODES_PER_GROUP(sb);
-	bitmap_nr = load_inode_bitmap (ITOV(inode)->v_mount, block_group);
-	bh = sb->s_inode_bitmap[bitmap_nr];
-	if (!clear_bit (bit, bh->b_data))
-		kprintf ( "ext2_free_inode:"
-		      "bit already cleared for inode %lu",
-		      (unsigned long)inode->i_number);
-	else {
-		gdp = get_group_desc (ITOV(inode)->v_mount, block_group, &bh2);
-		gdp->bg_free_inodes_count++;
-		if (S_ISDIR(inode->i_mode))
-			gdp->bg_used_dirs_count--;
-		mark_buffer_dirty(bh2);
-		es->s_free_inodes_count++;
-	}
-	mark_buffer_dirty(bh);
-/*** XXX
-	if (sb->s_flags & MS_SYNCHRONOUS) {
-		ll_rw_block (WRITE, 1, &bh);
-		wait_on_buffer (bh);
-	}
-***/
-	sb->s_dirt = 1;
-	unlock_super (DEVVP(inode));
-}
-
-#if 0 /* linux */
-/*
- * This function increments the inode version number
- *
- * This may be used one day by the NFS server
- */
-static void
-inc_inode_version(struct inode *inode, struct ext2_group_desc *gdp, int mode)
-{
-	unsigned long inode_block;
-	struct buf *bh;
-	struct ext2_inode *raw_inode;
-
-	inode_block = gdp->bg_inode_table + (((inode->i_number - 1) %
-			EXT2_INODES_PER_GROUP(inode->i_sb)) /
-			EXT2_INODES_PER_BLOCK(inode->i_sb));
-	bh = bread (inode->i_sb->s_dev, dbtob(inode_block), inode->i_sb->s_blocksize);
-	if (!bh) {
-		kprintf ("inc_inode_version Cannot load inode table block - "
-			    "inode=%lu, inode_block=%lu\n",
-			    inode->i_number, inode_block);
-		inode->u.ext2_i.i_version = 1;
-		return;
-	}
-	raw_inode = ((struct ext2_inode *) bh->b_data) +
-			(((inode->i_number - 1) %
-			EXT2_INODES_PER_GROUP(inode->i_sb)) %
-			EXT2_INODES_PER_BLOCK(inode->i_sb));
-	raw_inode->i_version++;
-	inode->u.ext2_i.i_version = raw_inode->i_version;
-	bdwrite (bh);
-}
-
-#endif /* linux */
-
-/*
- * There are two policies for allocating an inode.  If the new inode is
- * a directory, then a forward search is made for a block group with both
- * free space and a low directory-to-inode ratio; if that fails, then of
- * the groups with above-average free space, that group with the fewest
- * directories already is chosen.
- *
- * For other inodes, search forward from the parent directory\'s block
- * group to find a free inode.
- */
-/*
- * this functino has been reduced to the actual 'find the inode number' part
- */
-ino_t
-ext2_new_inode(const struct inode *dir, int mode)
-{
-	struct ext2_sb_info *sb;
-	struct buf *bh;
-	struct buf *bh2;
-	int i, j, avefreei;
-	int bitmap_nr;
-	struct ext2_group_desc *gdp;
-	struct ext2_group_desc *tmp;
-	struct ext2_super_block *es;
-
-	if (!dir)
-		return 0;
-	sb = dir->i_e2fs;
-
-        lock_super (DEVVP(dir));
-        es = sb->s_es;
-repeat:
-        gdp = NULL; i=0;
-
-        if (S_ISDIR(mode)) {
-		avefreei = es->s_free_inodes_count /
-			sb->s_groups_count;
-/* I am not yet convinced that this next bit is necessary.
-		i = dir->u.ext2_i.i_block_group;
-		for (j = 0; j < sb->u.ext2_sb.s_groups_count; j++) {
-			tmp = get_group_desc (sb, i, &bh2);
-			if ((tmp->bg_used_dirs_count << 8) <
-			    tmp->bg_free_inodes_count) {
-				gdp = tmp;
-				break;
-			}
-			else
-			i = ++i % sb->u.ext2_sb.s_groups_count;
-		}
-*/
-		if (!gdp) {
-			for (j = 0; j < sb->s_groups_count; j++) {
-				tmp = get_group_desc(ITOV(dir)->v_mount,j,&bh2);
-				if (tmp->bg_free_inodes_count &&
-					tmp->bg_free_inodes_count >= avefreei) {
-					if (!gdp ||
-					    (tmp->bg_free_blocks_count >
-					     gdp->bg_free_blocks_count)) {
-						i = j;
-						gdp = tmp;
-					}
-				}
-			}
-		}
-	}
-	else
-	{
-		/*
-		 * Try to place the inode in its parent directory
-		 */
-		i = dir->i_block_group;
-		tmp = get_group_desc (ITOV(dir)->v_mount, i, &bh2);
-		if (tmp->bg_free_inodes_count)
-			gdp = tmp;
-		else
-		{
-			/*
-			 * Use a quadratic hash to find a group with a
-			 * free inode
-			 */
-			for (j = 1; j < sb->s_groups_count; j <<= 1) {
-				i += j;
-				if (i >= sb->s_groups_count)
-					i -= sb->s_groups_count;
-				tmp = get_group_desc(ITOV(dir)->v_mount,i,&bh2);
-				if (tmp->bg_free_inodes_count) {
-					gdp = tmp;
-					break;
-				}
-			}
-		}
-		if (!gdp) {
-			/*
-			 * That failed: try linear search for a free inode
-			 */
-			i = dir->i_block_group + 1;
-			for (j = 2; j < sb->s_groups_count; j++) {
-				if (++i >= sb->s_groups_count)
-					i = 0;
-				tmp = get_group_desc(ITOV(dir)->v_mount,i,&bh2);
-				if (tmp->bg_free_inodes_count) {
-					gdp = tmp;
-					break;
-				}
-			}
-		}
-	}
-
-	if (!gdp) {
-		unlock_super (DEVVP(dir));
-		return 0;
-	}
-	bitmap_nr = load_inode_bitmap (ITOV(dir)->v_mount, i);
-	bh = sb->s_inode_bitmap[bitmap_nr];
-	if ((j = find_first_zero_bit ((unsigned long *) bh->b_data,
-				      EXT2_INODES_PER_GROUP(sb))) <
-	    EXT2_INODES_PER_GROUP(sb)) {
-		if (set_bit (j, bh->b_data)) {
-			kprintf ( "ext2_new_inode:"
-				      "bit already set for inode %d", j);
-			goto repeat;
-		}
-/* Linux now does the following:
-		mark_buffer_dirty(bh);
-		if (sb->s_flags & MS_SYNCHRONOUS) {
-			ll_rw_block (WRITE, 1, &bh);
-			wait_on_buffer (bh);
-		}
-*/
-		mark_buffer_dirty(bh);
-	} else {
-		if (gdp->bg_free_inodes_count != 0) {
-			kprintf ( "ext2_new_inode:"
-				    "Free inodes count corrupted in group %d",
-				    i);
-			unlock_super (DEVVP(dir));
-			return 0;
-		}
-		goto repeat;
-	}
-	j += i * EXT2_INODES_PER_GROUP(sb) + 1;
-	if (j < EXT2_FIRST_INO(sb) || j > es->s_inodes_count) {
-		kprintf ( "ext2_new_inode:"
-			    "reserved inode or inode > inodes count - "
-			    "block_group = %d,inode=%d", i, j);
-		unlock_super (DEVVP(dir));
-		return 0;
-	}
-	gdp->bg_free_inodes_count--;
-	if (S_ISDIR(mode))
-		gdp->bg_used_dirs_count++;
-	mark_buffer_dirty(bh2);
-	es->s_free_inodes_count--;
-	/* mark_buffer_dirty(sb->u.ext2_sb.s_sbh, 1); */
-	sb->s_dirt = 1;
-	unlock_super (DEVVP(dir));
-	return j;
-}
-
-#ifdef unused
-static unsigned long
-ext2_count_free_inodes(struct mount *mp)
-{
-#ifdef EXT2FS_DEBUG
-        struct ext2_sb_info *sb = VFSTOEXT2(mp)->um_e2fs;
-	struct ext2_super_block *es;
-	unsigned long desc_count, bitmap_count, x;
-	int bitmap_nr;
-	struct ext2_group_desc *gdp;
-	int i;
-
-	lock_super (VFSTOEXT2(mp)->um_devvp);
-	es = sb->s_es;
-	desc_count = 0;
-	bitmap_count = 0;
-	gdp = NULL;
-	for (i = 0; i < sb->s_groups_count; i++) {
-		gdp = get_group_desc (mp, i, NULL);
-		desc_count += gdp->bg_free_inodes_count;
-		bitmap_nr = load_inode_bitmap (mp, i);
-		x = ext2_count_free (sb->s_inode_bitmap[bitmap_nr],
-				     EXT2_INODES_PER_GROUP(sb) / 8);
-		ext2_debug ("group %d: stored = %d, counted = %lu\n",
-			i, gdp->bg_free_inodes_count, x);
-		bitmap_count += x;
-	}
-	ext2_debug("stored = %lu, computed = %lu, %lu\n",
-		es->s_free_inodes_count, desc_count, bitmap_count);
-	unlock_super (VFSTOEXT2(mp)->um_devvp);
-	return desc_count;
-#else
-	return VFSTOEXT2(mp)->um_e2fsb->s_free_inodes_count;
-#endif
-}
-#endif /* unused */
-
-#ifdef LATER
-void
-ext2_check_inodes_bitmap(struct mount *mp)
-{
-	struct ext2_super_block *es;
-	unsigned long desc_count, bitmap_count, x;
-	int bitmap_nr;
-	struct ext2_group_desc *gdp;
-	int i;
-
-	lock_super (sb);
-	es = sb->u.ext2_sb.s_es;
-	desc_count = 0;
-	bitmap_count = 0;
-	gdp = NULL;
-	for (i = 0; i < sb->u.ext2_sb.s_groups_count; i++) {
-		gdp = get_group_desc (sb, i, NULL);
-		desc_count += gdp->bg_free_inodes_count;
-		bitmap_nr = load_inode_bitmap (sb, i);
-		x = ext2_count_free (sb->u.ext2_sb.s_inode_bitmap[bitmap_nr],
-				     EXT2_INODES_PER_GROUP(sb) / 8);
-		if (gdp->bg_free_inodes_count != x)
-			kprintf ( "ext2_check_inodes_bitmap:"
-				    "Wrong free inodes count in group %d, "
-				    "stored = %d, counted = %lu", i,
-				    gdp->bg_free_inodes_count, x);
-		bitmap_count += x;
-	}
-	if (es->s_free_inodes_count != bitmap_count)
-		kprintf ( "ext2_check_inodes_bitmap:"
-			    "Wrong free inodes count in super block, "
-			    "stored = %lu, counted = %lu",
-			    (unsigned long) es->s_free_inodes_count, bitmap_count);
-	unlock_super (sb);
-}
-#endif
diff --git a/sys/gnu/vfs/ext2fs/ext2_linux_super.c b/sys/gnu/vfs/ext2fs/ext2_linux_super.c
deleted file mode 100644
index 8cdc2c380b..0000000000
--- a/sys/gnu/vfs/ext2fs/ext2_linux_super.c
+++ /dev/null
@@ -1,133 +0,0 @@
-/*
- * Copyright (c) 2015 The DragonFly Project.  All rights reserved.
- */
-/*
- *  linux/fs/ext2/super.c
- *
- * Copyright (C) 1992, 1993, 1994, 1995
- * Remy Card (card@masi.ibp.fr)
- * Laboratoire MASI - Institut Blaise Pascal
- * Universite Pierre et Marie Curie (Paris VI)
- *
- *  from
- *
- *  linux/fs/minix/inode.c
- *
- *  Copyright (C) 1991, 1992  Linus Torvalds
- */
-
-#include <sys/param.h>
-#include <sys/systm.h>
-#include <sys/mount.h>
-#include <sys/vnode.h>
-
-#include "dir.h"
-#include "dinode.h"
-#include "quota.h"
-#include "ext2_fs.h"
-#include "ext2_fs_sb.h"
-#include "ext2_mount.h"
-#include "ext2_extern.h"
-
-/*
- * Checks that the data in the descriptor blocks make sense.
- */
-int
-ext2_check_descriptors(struct ext2_sb_info *sb)
-{
-        int i;
-        int desc_block = 0;
-        unsigned long block = sb->s_es->s_first_data_block;
-        struct ext2_group_desc *gdp = NULL;
-
-        /* ext2_debug ("Checking group descriptors"); */
-
-        for (i = 0; i < sb->s_groups_count; i++)
-        {
-		/* examine next descriptor block */
-                if ((i % EXT2_DESC_PER_BLOCK(sb)) == 0)
-                        gdp = (struct ext2_group_desc *)
-				sb->s_group_desc[desc_block++]->b_data;
-                if (gdp->bg_block_bitmap < block ||
-                    gdp->bg_block_bitmap >= block + EXT2_BLOCKS_PER_GROUP(sb))
-                {
-                        kprintf ("ext2_check_descriptors: "
-                                    "Block bitmap for group %d"
-                                    " not in group (block %lu)!\n",
-                                    i, (unsigned long) gdp->bg_block_bitmap);
-                        return 0;
-                }
-                if (gdp->bg_inode_bitmap < block ||
-                    gdp->bg_inode_bitmap >= block + EXT2_BLOCKS_PER_GROUP(sb))
-                {
-                        kprintf ("ext2_check_descriptors: "
-                                    "Inode bitmap for group %d"
-                                    " not in group (block %lu)!\n",
-                                    i, (unsigned long) gdp->bg_inode_bitmap);
-                        return 0;
-                }
-                if (gdp->bg_inode_table < block ||
-                    gdp->bg_inode_table + sb->s_itb_per_group >=
-                    block + EXT2_BLOCKS_PER_GROUP(sb))
-                {
-                        kprintf ("ext2_check_descriptors: "
-                                    "Inode table for group %d"
-                                    " not in group (block %lu)!\n",
-                                    i, (unsigned long) gdp->bg_inode_table);
-                        return 0;
-                }
-                block += EXT2_BLOCKS_PER_GROUP(sb);
-                gdp++;
-        }
-        return 1;
-}
-
-/*
- * Get file system statistics.
- */
-int
-ext2_statfs(struct mount *mp, struct statfs *sbp, struct ucred *cred)
-{
-        unsigned long overhead;
-	struct ext2_mount *ump;
-	struct ext2_sb_info *fs;
-	struct ext2_super_block *es;
-	int i, nsb;
-
-	ump = VFSTOEXT2(mp);
-	fs = ump->um_e2fs;
-	es = fs->s_es;
-
-	if (es->s_magic != EXT2_SUPER_MAGIC)
-		panic("ext2_statfs - magic number spoiled");
-
-	/*
-	 * Compute the overhead (FS structures)
-	 */
-	if (es->s_feature_ro_compat & EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER) {
-		nsb = 0;
-		for (i = 0 ; i < fs->s_groups_count; i++)
-			if (ext2_group_sparse(i))
-				nsb++;
-	} else
-		nsb = fs->s_groups_count;
-	overhead = es->s_first_data_block +
-	    /* Superblocks and block group descriptors: */
-	    nsb * (1 + fs->s_db_per_group) +
-	    /* Inode bitmap, block bitmap, and inode table: */
-	    fs->s_groups_count * (1 + 1 + fs->s_itb_per_group);
-
-	sbp->f_bsize = EXT2_FRAG_SIZE(fs);
-	sbp->f_iosize = EXT2_BLOCK_SIZE(fs);
-	sbp->f_blocks = es->s_blocks_count - overhead;
-	sbp->f_bfree = es->s_free_blocks_count;
-	sbp->f_bavail = sbp->f_bfree - es->s_r_blocks_count;
-	sbp->f_files = es->s_inodes_count;
-	sbp->f_ffree = es->s_free_inodes_count;
-	if (sbp != &mp->mnt_stat) {
-		sbp->f_type = mp->mnt_vfc->vfc_typenum;
-		bcopy((caddr_t)mp->mnt_stat.f_mntfromname,
-			(caddr_t)&sbp->f_mntfromname[0], MNAMELEN);
-	}
-	return (0);
-}
diff --git a/sys/gnu/vfs/ext2fs/ext2_lookup.c b/sys/gnu/vfs/ext2fs/ext2_lookup.c
deleted file mode 100644
index d2d373c810..0000000000
--- a/sys/gnu/vfs/ext2fs/ext2_lookup.c
+++ /dev/null
@@ -1,1045 +0,0 @@
-/*
- *  modified for Lites 1.1
- *
- *  Aug 1995, Godmar Back (gback@cs.utah.edu)
- *  University of Utah, Department of Computer Science
- *
- * $FreeBSD: src/sys/gnu/ext2fs/ext2_lookup.c,v 1.21.2.3 2002/11/17 02:02:42 bde Exp $
- */
-/*
- * Copyright (c) 1989, 1993
- *	The Regents of the University of California.  All rights reserved.
- * (c) UNIX System Laboratories, Inc.
- * All or some portions of this file are derived from material licensed
- * to the University of California by American Telephone and Telegraph
- * Co. or Unix System Laboratories, Inc. and are reproduced herein with
- * the permission of UNIX System Laboratories, Inc.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. 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.
- *
- *	@(#)ufs_lookup.c	8.6 (Berkeley) 4/1/94
- */
-
-#include <sys/param.h>
-#include <sys/systm.h>
-#include <sys/uio.h>
-#include <sys/namei.h>
-#include <sys/buf.h>
-#include <sys/mount.h>
-#include <sys/vnode.h>
-#include <sys/malloc.h>
-#include <sys/dirent.h>
-
-#include "quota.h"
-#include "inode.h"
-#include "dir.h"
-#include "ext2_mount.h"
-#include "ext2_extern.h"
-#include "ext2_fs.h"
-#include "ext2_fs_sb.h"
-
-/*
-   DIRBLKSIZE in ffs is DEV_BSIZE (in most cases 512)
-   while it is the native blocksize in ext2fs - thus, a #define
-   is no longer appropriate
-*/
-#undef  DIRBLKSIZ
-
-extern	int dirchk;
-
-static u_char ext2_ft_to_dt[] = {
-	DT_UNKNOWN,		/* EXT2_FT_UNKNOWN */
-	DT_REG,			/* EXT2_FT_REG_FILE */
-	DT_DIR,			/* EXT2_FT_DIR */
-	DT_CHR,			/* EXT2_FT_CHRDEV */
-	DT_BLK,			/* EXT2_FT_BLKDEV */
-	DT_FIFO,		/* EXT2_FT_FIFO */
-	DT_SOCK,		/* EXT2_FT_SOCK */
-	DT_LNK,			/* EXT2_FT_SYMLINK */
-};
-#define	FTTODT(ft)						\
-    ((ft) > NELEM(ext2_ft_to_dt) ?	\
-    DT_UNKNOWN : ext2_ft_to_dt[(ft)])
-
-static u_char dt_to_ext2_ft[] = {
-	EXT2_FT_UNKNOWN,	/* DT_UNKNOWN */
-	EXT2_FT_FIFO,		/* DT_FIFO */
-	EXT2_FT_CHRDEV,		/* DT_CHR */
-	EXT2_FT_UNKNOWN,	/* unused */
-	EXT2_FT_DIR,		/* DT_DIR */
-	EXT2_FT_UNKNOWN,	/* unused */
-	EXT2_FT_BLKDEV,		/* DT_BLK */
-	EXT2_FT_UNKNOWN,	/* unused */
-	EXT2_FT_REG_FILE,	/* DT_REG */
-	EXT2_FT_UNKNOWN,	/* unused */
-	EXT2_FT_SYMLINK,	/* DT_LNK */
-	EXT2_FT_UNKNOWN,	/* unused */
-	EXT2_FT_SOCK,		/* DT_SOCK */
-	EXT2_FT_UNKNOWN,	/* unused */
-	EXT2_FT_UNKNOWN,	/* DT_WHT */
-};
-#define	DTTOFT(dt)						\
-    ((dt) > NELEM(dt_to_ext2_ft) ?	\
-    EXT2_FT_UNKNOWN : dt_to_ext2_ft[(dt)])
-
-static int	ext2_dirbadentry (struct vnode *dp,
-				      struct ext2_dir_entry_2 *de,
-				      int entryoffsetinblock);
-
-/*
- * Vnode op for reading directories.
- *
- * The routine below assumes that the on-disk format of a directory
- * is the same as that defined by <sys/dirent.h>. If the on-disk
- * format changes, then it will be necessary to do a conversion
- * from the on-disk format that read returns to the format defined
- * by <sys/dirent.h>.
- */
-/*
- * this is exactly what we do here - the problem is that the conversion
- * will blow up some entries by four bytes, so it can't be done in place.
- * This is too bad. Right now the conversion is done entry by entry, the
- * converted entry is sent via uiomove.
- *
- * XXX allocate a buffer, convert as many entries as possible, then send
- * the whole buffer to uiomove
- *
- * ext2_readdir(struct vnode *a_vp, struct uio *a_uio, struct ucred *a_cred)
- */
-int
-ext2_readdir(struct vop_readdir_args *ap)
-{
-        struct uio *uio = ap->a_uio;
-        int count, error;
-	struct ext2_dir_entry_2 *edp, *dp;
-	int ncookies;
-	struct uio auio;
-	struct iovec aiov;
-	caddr_t dirbuf;
-	int DIRBLKSIZ = VTOI(ap->a_vp)->i_e2fs->s_blocksize;
-	int readcnt, retval;
-	off_t startoffset = uio->uio_offset;
-
-	error = vn_lock(ap->a_vp, LK_EXCLUSIVE | LK_RETRY | LK_FAILRECLAIM);
-	if (error)
-		return(error);
-
-	count = uio->uio_resid;
-	/*
-	 * Avoid complications for partial directory entries by adjusting
-	 * the i/o to end at a block boundary.  Don't give up (like ufs
-	 * does) if the initial adjustment gives a negative count, since
-	 * many callers don't supply a large enough buffer.  The correct
-	 * size is a little larger than DIRBLKSIZ to allow for expansion
-	 * of directory entries, but some callers just use 512.
-	 */
-	count -= (uio->uio_offset + count) & (DIRBLKSIZ -1);
-	if (count <= 0)
-		count += DIRBLKSIZ;
-	if (count > MAXBSIZE)		/* limit to a reasonable size */
-		count = MAXBSIZE;
-
-#ifdef EXT2FS_DEBUG
-	kprintf("ext2_readdir: uio_offset = %lld, uio_resid = %d, count = %d\n",
-	    uio->uio_offset, uio->uio_resid, count);
-#endif
-
-	auio = *uio;
-	auio.uio_iov = &aiov;
-	auio.uio_iovcnt = 1;
-	auio.uio_resid = count;
-	auio.uio_segflg = UIO_SYSSPACE;
-	aiov.iov_len = count;
-	dirbuf = kmalloc(count, M_TEMP, M_WAITOK);
-	aiov.iov_base = dirbuf;
-	error = VOP_READ(ap->a_vp, &auio, 0, ap->a_cred);
-	if (error == 0) {
-		readcnt = count - auio.uio_resid;
-		edp = (struct ext2_dir_entry_2 *)&dirbuf[readcnt];
-		ncookies = 0;
-		for (dp = (struct ext2_dir_entry_2 *)dirbuf;
-		    !error && uio->uio_resid > 0 && dp < edp; ) {
-			/*-
-			 * "New" ext2fs directory entries differ in 3 ways
-			 * from ufs on-disk ones:
-			 * - the name is not necessarily NUL-terminated.
-			 * - the file type field always exists and always
-			 * follows the name length field.
-			 * - the file type is encoded in a different way.
-			 *
-			 * "Old" ext2fs directory entries need no special
-			 * conversions, since they binary compatible with
-			 * "new" entries having a file type of 0 (i.e.,
-			 * EXT2_FT_UNKNOWN).  Splitting the old name length
-			 * field didn't make a mess like it did in ufs,
-			 * because ext2fs uses a machine-dependent disk
-			 * layout.
-			 */
-			if (dp->rec_len <= 0) {
-				error = EIO;
-				break;
-			}
-			retval = vop_write_dirent(&error, uio, dp->inode,
-			    FTTODT(dp->file_type), dp->name_len, dp->name);
-
-			if (retval)
-				break;
-			/* advance dp */
-			dp = (struct ext2_dir_entry_2 *)((char *)dp + dp->rec_len);
-			if (!error)
-				ncookies++;
-		}
-		/* we need to correct uio_offset */
-		uio->uio_offset = startoffset + (caddr_t)dp - dirbuf;
-
-		if (!error && ap->a_ncookies != NULL) {
-			off_t *cookiep, *cookies, *ecookies;
-			off_t off;
-
-			if (uio->uio_segflg != UIO_SYSSPACE || uio->uio_iovcnt != 1)
-				panic("ext2fs_readdir: unexpected uio from NFS server");
-			if (ncookies) {
-				cookies = kmalloc(ncookies * sizeof(off_t),
-                                                  M_TEMP, M_WAITOK);
-			} else {
-				cookies = kmalloc(sizeof(off_t), M_TEMP,
-                                                  M_WAITOK);
-			}
-			off = startoffset;
-			for (dp = (struct ext2_dir_entry_2 *)dirbuf,
-			     cookiep = cookies, ecookies = cookies + ncookies;
-			     cookiep < ecookies;
-			     dp = (struct ext2_dir_entry_2 *)((caddr_t) dp + dp->rec_len)) {
-				off += dp->rec_len;
-				*cookiep++ = off;
-			}
-			*ap->a_ncookies = ncookies;
-			*ap->a_cookies = cookies;
-		}
-	}
-	kfree(dirbuf, M_TEMP);
-	if (ap->a_eofflag)
-		*ap->a_eofflag = VTOI(ap->a_vp)->i_size <= uio->uio_offset;
-	vn_unlock(ap->a_vp);
-        return (error);
-}
-
-/*
- * Convert a component of a pathname into a pointer to a locked inode.
- * This is a very central and rather complicated routine.
- * If the file system is not maintained in a strict tree hierarchy,
- * this can result in a deadlock situation (see comments in code below).
- *
- * The cnp->cn_nameiop argument is LOOKUP, CREATE, RENAME, or DELETE depending
- * on whether the name is to be looked up, created, renamed, or deleted.
- * When CREATE, RENAME, or DELETE is specified, information usable in
- * creating, renaming, or deleting a directory entry may be calculated.
- * If flag has LOCKPARENT or'ed into it and the target of the pathname
- * exists, lookup returns both the target and its parent directory locked.
- * When creating or renaming and LOCKPARENT is specified, the target may
- * not be ".".  When deleting and LOCKPARENT is specified, the target may
- * be "."., but the caller must check to ensure it does an vrele and vput
- * instead of two vputs.
- *
- * Overall outline of ufs_lookup:
- *
- *	search for name in directory, to found or notfound
- * notfound:
- *	if creating, return locked directory, leaving info on available slots
- *	else return error
- * found:
- *	if at end of path and deleting, return information to allow delete
- *	if at end of path and rewriting (RENAME and LOCKPARENT), lock target
- *	  inode and return info to allow rewrite
- *	if not at end, add name to cache; if at end and neither creating
- *	  nor deleting, add name to cache
- *
- * ext2_lookup(struct vnode *a_dvp, struct vnode **a_vpp,
- *	       struct componentname *a_cnp)
- */
-int
-ext2_lookup(struct vop_old_lookup_args *ap)
-{
-	struct vnode *vdp;	/* vnode for directory being searched */
-	struct inode *dp;	/* inode for directory being searched */
-	struct buf *bp;			/* a buffer of directory entries */
-	struct ext2_dir_entry_2 *ep; /* the current directory entry */
-	int entryoffsetinblock;		/* offset of ep in bp's buffer */
-	enum {NONE, COMPACT, FOUND} slotstatus;
-	doff_t slotoffset;		/* offset of area with free space */
-	int slotsize;			/* size of area at slotoffset */
-	int slotfreespace;		/* amount of space free in slot */
-	int slotneeded;			/* size of the entry we're seeking */
-	int numdirpasses;		/* strategy for directory search */
-	doff_t endsearch;		/* offset to end directory search */
-	doff_t prevoff;			/* prev entry dp->i_offset */
-	struct vnode *pdp;		/* saved dp during symlink work */
-	struct vnode *tdp;		/* returned by VFS_VGET */
-	doff_t enduseful;		/* pointer past last used dir slot */
-	u_long bmask;			/* block offset mask */
-	int lockparent;			/* 1 => lockparent flag is set */
-	int wantparent;			/* 1 => wantparent or lockparent flag */
-	int namlen, error;
-	struct vnode **vpp = ap->a_vpp;
-	struct componentname *cnp = ap->a_cnp;
-	struct ucred *cred = cnp->cn_cred;
-	int flags = cnp->cn_flags;
-	int nameiop = cnp->cn_nameiop;
-
-	int	DIRBLKSIZ = VTOI(ap->a_dvp)->i_e2fs->s_blocksize;
-
-	bp = NULL;
-	slotoffset = -1;
-	*vpp = NULL;
-	vdp = ap->a_dvp;
-	dp = VTOI(vdp);
-	lockparent = flags & CNP_LOCKPARENT;
-	wantparent = flags & (CNP_LOCKPARENT|CNP_WANTPARENT);
-
-	/*
-	 * We now have a segment name to search for, and a directory to search.
-	 */
-
-	/*
-	 * Suppress search for slots unless creating
-	 * file and at end of pathname, in which case
-	 * we watch for a place to put the new file in
-	 * case it doesn't already exist.
-	 */
-	slotstatus = FOUND;
-	slotfreespace = slotsize = slotneeded = 0;
-	if (nameiop == NAMEI_CREATE || nameiop == NAMEI_RENAME) {
-		slotstatus = NONE;
-		slotneeded = EXT2_DIR_REC_LEN(cnp->cn_namelen);
-		/* was
-		slotneeded = (sizeof(struct direct) - MAXNAMLEN +
-			cnp->cn_namelen + 3) &~ 3; */
-	}
-
-	/*
-	 * If there is cached information on a previous search of
-	 * this directory, pick up where we last left off.
-	 * We cache only lookups as these are the most common
-	 * and have the greatest payoff. Caching CREATE has little
-	 * benefit as it usually must search the entire directory
-	 * to determine that the entry does not exist. Caching the
-	 * location of the last DELETE or RENAME has not reduced
-	 * profiling time and hence has been removed in the interest
-	 * of simplicity.
-	 */
-	bmask = VFSTOEXT2(vdp->v_mount)->um_mountp->mnt_stat.f_iosize - 1;
-	if (nameiop != NAMEI_LOOKUP || dp->i_diroff == 0 ||
-	    dp->i_diroff > dp->i_size) {
-		entryoffsetinblock = 0;
-		dp->i_offset = 0;
-		numdirpasses = 1;
-	} else {
-		dp->i_offset = dp->i_diroff;
-		if ((entryoffsetinblock = dp->i_offset & bmask) &&
-		    (error = EXT2_BLKATOFF(vdp, (off_t)dp->i_offset, NULL, &bp)))
-			return (error);
-		numdirpasses = 2;
-	}
-	prevoff = dp->i_offset;
-	endsearch = roundup(dp->i_size, DIRBLKSIZ);
-	enduseful = 0;
-
-searchloop:
-	while (dp->i_offset < endsearch) {
-		/*
-		 * If necessary, get the next directory block.
-		 */
-		if ((dp->i_offset & bmask) == 0) {
-			if (bp != NULL)
-				brelse(bp);
-			if ((error =
-			    EXT2_BLKATOFF(vdp, (off_t)dp->i_offset, NULL, &bp)) != 0)
-				return (error);
-			entryoffsetinblock = 0;
-		}
-		/*
-		 * If still looking for a slot, and at a DIRBLKSIZE
-		 * boundary, have to start looking for free space again.
-		 */
-		if (slotstatus == NONE &&
-		    (entryoffsetinblock & (DIRBLKSIZ - 1)) == 0) {
-			slotoffset = -1;
-			slotfreespace = 0;
-		}
-		/*
-		 * Get pointer to next entry.
-		 * Full validation checks are slow, so we only check
-		 * enough to insure forward progress through the
-		 * directory. Complete checks can be run by patching
-		 * "dirchk" to be true.
-		 */
-		ep = (struct ext2_dir_entry_2 *)
-			((char *)bp->b_data + entryoffsetinblock);
-		if (ep->rec_len == 0 ||
-		    (dirchk && ext2_dirbadentry(vdp, ep, entryoffsetinblock))) {
-			int i;
-			ext2_dirbad(dp, dp->i_offset, "mangled entry");
-			i = DIRBLKSIZ - (entryoffsetinblock & (DIRBLKSIZ - 1));
-			dp->i_offset += i;
-			entryoffsetinblock += i;
-			continue;
-		}
-
-		/*
-		 * If an appropriate sized slot has not yet been found,
-		 * check to see if one is available. Also accumulate space
-		 * in the current block so that we can determine if
-		 * compaction is viable.
-		 */
-		if (slotstatus != FOUND) {
-			int size = ep->rec_len;
-
-			if (ep->inode != 0)
-				size -= EXT2_DIR_REC_LEN(ep->name_len);
-			if (size > 0) {
-				if (size >= slotneeded) {
-					slotstatus = FOUND;
-					slotoffset = dp->i_offset;
-					slotsize = ep->rec_len;
-				} else if (slotstatus == NONE) {
-					slotfreespace += size;
-					if (slotoffset == -1)
-						slotoffset = dp->i_offset;
-					if (slotfreespace >= slotneeded) {
-						slotstatus = COMPACT;
-						slotsize = dp->i_offset +
-						      ep->rec_len - slotoffset;
-					}
-				}
-			}
-		}
-
-		/*
-		 * Check for a name match.
-		 */
-		if (ep->inode) {
-			namlen = ep->name_len;
-			if (namlen == cnp->cn_namelen &&
-			    !bcmp(cnp->cn_nameptr, ep->name,
-				(unsigned)namlen)) {
-				/*
-				 * Save directory entry's inode number and
-				 * reclen in ndp->ni_ufs area, and release
-				 * directory buffer.
-				 */
-				dp->i_ino = ep->inode;
-				dp->i_reclen = ep->rec_len;
-				goto found;
-			}
-		}
-		prevoff = dp->i_offset;
-		dp->i_offset += ep->rec_len;
-		entryoffsetinblock += ep->rec_len;
-		if (ep->inode)
-			enduseful = dp->i_offset;
-	}
-/* notfound: */
-	/*
-	 * If we started in the middle of the directory and failed
-	 * to find our target, we must check the beginning as well.
-	 */
-	if (numdirpasses == 2) {
-		numdirpasses--;
-		dp->i_offset = 0;
-		endsearch = dp->i_diroff;
-		goto searchloop;
-	}
-	if (bp != NULL)
-		brelse(bp);
-	/*
-	 * If creating, and at end of pathname and current
-	 * directory has not been removed, then can consider
-	 * allowing file to be created.
-	 */
-	if ((nameiop == NAMEI_CREATE || nameiop == NAMEI_RENAME) &&
-	    dp->i_nlink != 0) {
-		/*
-		 * Access for write is interpreted as allowing
-		 * creation of files in the directory.
-		 */
-		if ((error = VOP_EACCESS(vdp, VWRITE, cred)) != 0)
-			return (error);
-		/*
-		 * Return an indication of where the new directory
-		 * entry should be put.  If we didn't find a slot,
-		 * then set dp->i_count to 0 indicating
-		 * that the new slot belongs at the end of the
-		 * directory. If we found a slot, then the new entry
-		 * can be put in the range from dp->i_offset to
-		 * dp->i_offset + dp->i_count.
-		 */
-		if (slotstatus == NONE) {
-			dp->i_offset = roundup(dp->i_size, DIRBLKSIZ);
-			dp->i_count = 0;
-			enduseful = dp->i_offset;
-		} else {
-			dp->i_offset = slotoffset;
-			dp->i_count = slotsize;
-			if (enduseful < slotoffset + slotsize)
-				enduseful = slotoffset + slotsize;
-		}
-		dp->i_endoff = roundup(enduseful, DIRBLKSIZ);
-		dp->i_flag |= IN_CHANGE | IN_UPDATE;
-		/*
-		 * We return with the directory locked, so that
-		 * the parameters we set up above will still be
-		 * valid if we actually decide to do a direnter().
-		 * We return ni_vp == NULL to indicate that the entry
-		 * does not currently exist; we leave a pointer to
-		 * the (locked) directory inode in ndp->ni_dvp.
-		 * The pathname buffer is saved so that the name
-		 * can be obtained later.
-		 *
-		 * NB - if the directory is unlocked, then this
-		 * information cannot be used.
-		 */
-		if (!lockparent)
-			vn_unlock(vdp);
-		return (EJUSTRETURN);
-	}
-	return (ENOENT);
-
-found:
-	/*
-	 * Check that directory length properly reflects presence
-	 * of this entry.
-	 */
-	if (entryoffsetinblock + EXT2_DIR_REC_LEN(ep->name_len)
-		> dp->i_size) {
-		ext2_dirbad(dp, dp->i_offset, "i_size too small");
-		dp->i_size = entryoffsetinblock+EXT2_DIR_REC_LEN(ep->name_len);
-		dp->i_flag |= IN_CHANGE | IN_UPDATE;
-	}
-	brelse(bp);
-
-	/*
-	 * Found component in pathname.
-	 * If the final component of path name, save information
-	 * in the cache as to where the entry was found.
-	 */
-	if (nameiop == NAMEI_LOOKUP)
-		dp->i_diroff = rounddown2(dp->i_offset, DIRBLKSIZ);
-
-	/*
-	 * If deleting, and at end of pathname, return
-	 * parameters which can be used to remove file.
-	 * If the wantparent flag isn't set, we return only
-	 * the directory (in ndp->ni_dvp), otherwise we go
-	 * on and lock the inode, being careful with ".".
-	 */
-	if (nameiop == NAMEI_DELETE) {
-		/*
-		 * Write access to directory required to delete files.
-		 */
-		if ((error = VOP_EACCESS(vdp, VWRITE, cred)) != 0)
-			return (error);
-		/*
-		 * Return pointer to current entry in dp->i_offset,
-		 * and distance past previous entry (if there
-		 * is a previous entry in this block) in dp->i_count.
-		 * Save directory inode pointer in ndp->ni_dvp for dirremove().
-		 */
-		if ((dp->i_offset & (DIRBLKSIZ - 1)) == 0)
-			dp->i_count = 0;
-		else
-			dp->i_count = dp->i_offset - prevoff;
-		if (dp->i_number == dp->i_ino) {
-			vref(vdp);
-			*vpp = vdp;
-			return (0);
-		}
-		if ((error = VFS_VGET(vdp->v_mount, NULL, dp->i_ino, &tdp)) != 0)
-			return (error);
-		/*
-		 * If directory is "sticky", then user must own
-		 * the directory, or the file in it, else she
-		 * may not delete it (unless she's root). This
-		 * implements append-only directories.
-		 */
-		if ((dp->i_mode & ISVTX) &&
-		    cred->cr_uid != 0 &&
-		    cred->cr_uid != dp->i_uid &&
-		    VTOI(tdp)->i_uid != cred->cr_uid) {
-			vput(tdp);
-			return (EPERM);
-		}
-		*vpp = tdp;
-		if (!lockparent)
-			vn_unlock(vdp);
-		return (0);
-	}
-
-	/*
-	 * If rewriting (RENAME), return the inode and the
-	 * information required to rewrite the present directory
-	 * Must get inode of directory entry to verify it's a
-	 * regular file, or empty directory.
-	 */
-	if (nameiop == NAMEI_RENAME && wantparent) {
-		if ((error = VOP_EACCESS(vdp, VWRITE, cred)) != 0)
-			return (error);
-		/*
-		 * Careful about locking second inode.
-		 * This can only occur if the target is ".".
-		 */
-		if (dp->i_number == dp->i_ino)
-			return (EISDIR);
-		if ((error = VFS_VGET(vdp->v_mount, NULL, dp->i_ino, &tdp)) != 0)
-			return (error);
-		*vpp = tdp;
-		if (!lockparent)
-			vn_unlock(vdp);
-		return (0);
-	}
-
-	/*
-	 * Step through the translation in the name.  We do not `vput' the
-	 * directory because we may need it again if a symbolic link
-	 * is relative to the current directory.  Instead we save it
-	 * unlocked as "pdp".  We must get the target inode before unlocking
-	 * the directory to insure that the inode will not be removed
-	 * before we get it.  We prevent deadlock by always fetching
-	 * inodes from the root, moving down the directory tree. Thus
-	 * when following backward pointers ".." we must unlock the
-	 * parent directory before getting the requested directory.
-	 * There is a potential race condition here if both the current
-	 * and parent directories are removed before the VFS_VGET for the
-	 * inode associated with ".." returns.  We hope that this occurs
-	 * infrequently since we cannot avoid this race condition without
-	 * implementing a sophisticated deadlock detection algorithm.
-	 * Note also that this simple deadlock detection scheme will not
-	 * work if the file system has any hard links other than ".."
-	 * that point backwards in the directory structure.
-	 */
-	pdp = vdp;
-	if (flags & CNP_ISDOTDOT) {
-		vn_unlock(pdp);	/* race to get the inode */
-		error = VFS_VGET(vdp->v_mount, NULL, dp->i_ino, &tdp);
-		if (error) {
-			vn_lock(pdp, LK_EXCLUSIVE | LK_RETRY);
-			return (error);
-		}
-		if (lockparent) {
-			error = vn_lock(pdp, LK_EXCLUSIVE | LK_FAILRECLAIM);
-			if (error) {
-				vput(tdp);
-				return (error);
-			}
-		}
-		*vpp = tdp;
-	} else if (dp->i_number == dp->i_ino) {
-		vref(vdp);	/* we want ourself, ie "." */
-		*vpp = vdp;
-	} else {
-		if ((error = VFS_VGET(vdp->v_mount, NULL, dp->i_ino, &tdp)) != 0)
-			return (error);
-		if (!lockparent) {
-			vn_unlock(pdp);
-			cnp->cn_flags |= CNP_PDIRUNLOCK;
-		}
-		*vpp = tdp;
-	}
-	return (0);
-}
-
-void
-ext2_dirbad(struct inode *ip, doff_t offset, char *how)
-{
-	struct mount *mp;
-
-	mp = ITOV(ip)->v_mount;
-	kprintf("%s: bad dir ino %lu at offset %ld: %s\n",
-	       mp->mnt_stat.f_mntfromname, (u_long)ip->i_number,
-	       (long)offset, how);
-	if ((mp->mnt_flag & MNT_RDONLY) == 0)
-		panic("ufs_dirbad: bad dir");
-}
-
-/*
- * Do consistency checking on a directory entry:
- *	record length must be multiple of 4
- *	entry must fit in rest of its DIRBLKSIZ block
- *	record must be large enough to contain entry
- *	name is not longer than MAXNAMLEN
- *	name must be as long as advertised, and null terminated
- */
-/*
- *	changed so that it confirms to ext2_check_dir_entry
- */
-static int
-ext2_dirbadentry(struct vnode *dp, struct ext2_dir_entry_2 *de,
-		 int entryoffsetinblock)
-{
-	int	DIRBLKSIZ = VTOI(dp)->i_e2fs->s_blocksize;
-
-        char *error_msg = NULL;
-
-        if (de->rec_len < EXT2_DIR_REC_LEN(1))
-                error_msg = "rec_len is smaller than minimal";
-        else if (de->rec_len % 4 != 0)
-                error_msg = "rec_len % 4 != 0";
-        else if (de->rec_len < EXT2_DIR_REC_LEN(de->name_len))
-                error_msg = "reclen is too small for name_len";
-        else if (entryoffsetinblock + de->rec_len > DIRBLKSIZ)
-                error_msg = "directory entry across blocks";
-        /* else LATER
-	     if (de->inode > dir->i_sb->u.ext2_sb.s_es->s_inodes_count)
-                error_msg = "inode out of bounds";
-	*/
-
-        if (error_msg != NULL) {
-                kprintf("bad directory entry: %s\n", error_msg);
-                kprintf("offset=%d, inode=%lu, rec_len=%u, name_len=%u\n",
-			entryoffsetinblock, (unsigned long)de->inode,
-			de->rec_len, de->name_len);
-        }
-        return error_msg == NULL ? 0 : 1;
-}
-
-/*
- * Write a directory entry after a call to namei, using the parameters
- * that it left in the directory inode.  The argument ip is the inode which
- * the new directory entry will refer to.  Dvp is a pointer to the directory
- * to be written, which was left locked by namei. Remaining parameters
- * (dp->i_offset, dp->i_count) indicate how the space for the new
- * entry is to be obtained.
- */
-int
-ext2_direnter(struct inode *ip, struct vnode *dvp, struct componentname *cnp)
-{
-	struct ext2_dir_entry_2 *ep, *nep;
-	struct inode *dp;
-	struct buf *bp;
-	struct ext2_dir_entry_2 newdir;
-	struct iovec aiov;
-	struct uio auio;
-	u_int dsize;
-	int error, loc, newentrysize, spacefree;
-	char *dirbuf;
-	int     DIRBLKSIZ = ip->i_e2fs->s_blocksize;
-
-
-	dp = VTOI(dvp);
-	newdir.inode = ip->i_number;
-	newdir.name_len = cnp->cn_namelen;
-	if (EXT2_HAS_INCOMPAT_FEATURE(ip->i_e2fs->s_es,
-	    EXT2_FEATURE_INCOMPAT_FILETYPE))
-		newdir.file_type = DTTOFT(IFTODT(ip->i_mode));
-	else
-		newdir.file_type = EXT2_FT_UNKNOWN;
-	bcopy(cnp->cn_nameptr, newdir.name, (unsigned)cnp->cn_namelen + 1);
-	newentrysize = EXT2_DIR_REC_LEN(newdir.name_len);
-	if (dp->i_count == 0) {
-		/*
-		 * If dp->i_count is 0, then namei could find no
-		 * space in the directory. Here, dp->i_offset will
-		 * be on a directory block boundary and we will write the
-		 * new entry into a fresh block.
-		 */
-		if (dp->i_offset & (DIRBLKSIZ - 1))
-			panic("ext2_direnter: newblk");
-		auio.uio_offset = dp->i_offset;
-		newdir.rec_len = DIRBLKSIZ;
-		auio.uio_resid = newentrysize;
-		aiov.iov_len = newentrysize;
-		aiov.iov_base = (caddr_t)&newdir;
-		auio.uio_iov = &aiov;
-		auio.uio_iovcnt = 1;
-		auio.uio_rw = UIO_WRITE;
-		auio.uio_segflg = UIO_SYSSPACE;
-		auio.uio_td = NULL;
-		error = VOP_WRITE(dvp, &auio, IO_SYNC, cnp->cn_cred);
-		if (DIRBLKSIZ >
-		    VFSTOEXT2(dvp->v_mount)->um_mountp->mnt_stat.f_bsize)
-			/* XXX should grow with balloc() */
-			panic("ext2_direnter: frag size");
-		else if (!error) {
-			dp->i_size = roundup(dp->i_size, DIRBLKSIZ);
-			dp->i_flag |= IN_CHANGE;
-		}
-		return (error);
-	}
-
-	/*
-	 * If dp->i_count is non-zero, then namei found space
-	 * for the new entry in the range dp->i_offset to
-	 * dp->i_offset + dp->i_count in the directory.
-	 * To use this space, we may have to compact the entries located
-	 * there, by copying them together towards the beginning of the
-	 * block, leaving the free space in one usable chunk at the end.
-	 */
-
-	/*
-	 * Increase size of directory if entry eats into new space.
-	 * This should never push the size past a new multiple of
-	 * DIRBLKSIZE.
-	 *
-	 * N.B. - THIS IS AN ARTIFACT OF 4.2 AND SHOULD NEVER HAPPEN.
-	 */
-	if (dp->i_offset + dp->i_count > dp->i_size)
-		dp->i_size = dp->i_offset + dp->i_count;
-	/*
-	 * Get the block containing the space for the new directory entry.
-	 */
-	if ((error = EXT2_BLKATOFF(dvp, (off_t)dp->i_offset, &dirbuf, &bp)) != 0)
-		return (error);
-	/*
-	 * Find space for the new entry. In the simple case, the entry at
-	 * offset base will have the space. If it does not, then namei
-	 * arranged that compacting the region dp->i_offset to
-	 * dp->i_offset + dp->i_count would yield the
-	 * space.
-	 */
-	ep = (struct ext2_dir_entry_2 *)dirbuf;
-	dsize = EXT2_DIR_REC_LEN(ep->name_len);
-	spacefree = ep->rec_len - dsize;
-	for (loc = ep->rec_len; loc < dp->i_count; ) {
-		nep = (struct ext2_dir_entry_2 *)(dirbuf + loc);
-		if (ep->inode) {
-			/* trim the existing slot */
-			ep->rec_len = dsize;
-			ep = (struct ext2_dir_entry_2 *)((char *)ep + dsize);
-		} else {
-			/* overwrite; nothing there; header is ours */
-			spacefree += dsize;
-		}
-		dsize = EXT2_DIR_REC_LEN(nep->name_len);
-		spacefree += nep->rec_len - dsize;
-		loc += nep->rec_len;
-		bcopy((caddr_t)nep, (caddr_t)ep, dsize);
-	}
-	/*
-	 * Update the pointer fields in the previous entry (if any),
-	 * copy in the new entry, and write out the block.
-	 */
-	if (ep->inode == 0) {
-		if (spacefree + dsize < newentrysize)
-			panic("ext2_direnter: compact1");
-		newdir.rec_len = spacefree + dsize;
-	} else {
-		if (spacefree < newentrysize)
-			panic("ext2_direnter: compact2");
-		newdir.rec_len = spacefree;
-		ep->rec_len = dsize;
-		ep = (struct ext2_dir_entry_2 *)((char *)ep + dsize);
-	}
-	bcopy((caddr_t)&newdir, (caddr_t)ep, (u_int)newentrysize);
-	error = bwrite(bp);
-	dp->i_flag |= IN_CHANGE | IN_UPDATE;
-	if (!error && dp->i_endoff && dp->i_endoff < dp->i_size)
-		error = EXT2_TRUNCATE(dvp, (off_t)dp->i_endoff, IO_SYNC,
-				      cnp->cn_cred);
-	return (error);
-}
-
-/*
- * Remove a directory entry after a call to namei, using
- * the parameters which it left in the directory inode. The entry
- * dp->i_offset contains the offset into the directory of the
- * entry to be eliminated.  The dp->i_count field contains the
- * size of the previous record in the directory.  If this
- * is 0, the first entry is being deleted, so we need only
- * zero the inode number to mark the entry as free.  If the
- * entry is not the first in the directory, we must reclaim
- * the space of the now empty record by adding the record size
- * to the size of the previous entry.
- */
-int
-ext2_dirremove(struct vnode *dvp, struct componentname *cnp)
-{
-	struct inode *dp;
-	struct ext2_dir_entry_2 *ep;
-	struct buf *bp;
-	int error;
-
-	dp = VTOI(dvp);
-	if (dp->i_count == 0) {
-		/*
-		 * First entry in block: set d_ino to zero.
-		 */
-		if ((error =
-		    EXT2_BLKATOFF(dvp, (off_t)dp->i_offset, (char **)&ep, &bp)) != 0)
-			return (error);
-		ep->inode = 0;
-		error = bwrite(bp);
-		dp->i_flag |= IN_CHANGE | IN_UPDATE;
-		return (error);
-	}
-	/*
-	 * Collapse new free space into previous entry.
-	 */
-	if ((error = EXT2_BLKATOFF(dvp, (off_t)(dp->i_offset - dp->i_count),
-	    (char **)&ep, &bp)) != 0)
-		return (error);
-	ep->rec_len += dp->i_reclen;
-	error = bwrite(bp);
-	dp->i_flag |= IN_CHANGE | IN_UPDATE;
-	return (error);
-}
-
-/*
- * Rewrite an existing directory entry to point at the inode
- * supplied.  The parameters describing the directory entry are
- * set up by a call to namei.
- */
-int
-ext2_dirrewrite(struct inode *dp, struct inode *ip, struct componentname *cnp)
-{
-	struct buf *bp;
-	struct ext2_dir_entry_2 *ep;
-	struct vnode *vdp = ITOV(dp);
-	int error;
-
-	if ((error = EXT2_BLKATOFF(vdp, (off_t)dp->i_offset, (char **)&ep, &bp)) != 0)
-		return (error);
-	ep->inode = ip->i_number;
-	if (EXT2_HAS_INCOMPAT_FEATURE(ip->i_e2fs->s_es,
-	    EXT2_FEATURE_INCOMPAT_FILETYPE))
-		ep->file_type = DTTOFT(IFTODT(ip->i_mode));
-	else
-		ep->file_type = EXT2_FT_UNKNOWN;
-	error = bwrite(bp);
-	dp->i_flag |= IN_CHANGE | IN_UPDATE;
-	return (error);
-}
-
-/*
- * Check if a directory is empty or not.
- * Inode supplied must be locked.
- *
- * Using a struct dirtemplate here is not precisely
- * what we want, but better than using a struct direct.
- *
- * NB: does not handle corrupted directories.
- */
-int
-ext2_dirempty(struct inode *ip, ino_t parentino, struct ucred *cred)
-{
-	off_t off;
-	struct dirtemplate dbuf;
-	struct ext2_dir_entry_2 *dp = (struct ext2_dir_entry_2 *)&dbuf;
-	int error, count, namlen;
-
-#define	MINDIRSIZ (sizeof (struct dirtemplate) / 2)
-
-	for (off = 0; off < ip->i_size; off += dp->rec_len) {
-		error = vn_rdwr(UIO_READ, ITOV(ip), (caddr_t)dp, MINDIRSIZ, off,
-			        UIO_SYSSPACE, IO_NODELOCKED, cred, &count);
-		/*
-		 * Since we read MINDIRSIZ, residual must
-		 * be 0 unless we're at end of file.
-		 */
-		if (error || count != 0)
-			return (0);
-		/* avoid infinite loops */
-		if (dp->rec_len == 0)
-			return (0);
-		/* skip empty entries */
-		if (dp->inode == 0)
-			continue;
-		/* accept only "." and ".." */
-		namlen = dp->name_len;
-		if (namlen > 2)
-			return (0);
-		if (dp->name[0] != '.')
-			return (0);
-		/*
-		 * At this point namlen must be 1 or 2.
-		 * 1 implies ".", 2 implies ".." if second
-		 * char is also "."
-		 */
-		if (namlen == 1)
-			continue;
-		if (dp->name[1] == '.' && dp->inode == parentino)
-			continue;
-		return (0);
-	}
-	return (1);
-}
-
-/*
- * Check if source directory is in the path of the target directory.
- * Target is supplied locked, source is unlocked.
- * The target is always vput before returning.
- */
-int
-ext2_checkpath(struct inode *source, struct inode *target, struct ucred *cred)
-{
-	struct vnode *vp;
-	int error, rootino, namlen;
-	struct dirtemplate dirbuf;
-
-	vp = ITOV(target);
-	if (target->i_number == source->i_number) {
-		error = EEXIST;
-		goto out;
-	}
-	rootino = EXT2_ROOTINO;
-	error = 0;
-	if (target->i_number == rootino)
-		goto out;
-
-	for (;;) {
-		if (vp->v_type != VDIR) {
-			error = ENOTDIR;
-			break;
-		}
-		error = vn_rdwr(UIO_READ, vp, (caddr_t)&dirbuf,
-				sizeof (struct dirtemplate), (off_t)0,
-				UIO_SYSSPACE, IO_NODELOCKED, cred, NULL);
-		if (error != 0)
-			break;
-		namlen = dirbuf.dotdot_type;	/* like ufs little-endian */
-		if (namlen != 2 ||
-		    dirbuf.dotdot_name[0] != '.' ||
-		    dirbuf.dotdot_name[1] != '.') {
-			error = ENOTDIR;
-			break;
-		}
-		if (dirbuf.dotdot_ino == source->i_number) {
-			error = EINVAL;
-			break;
-		}
-		if (dirbuf.dotdot_ino == rootino)
-			break;
-		vput(vp);
-		if ((error = VFS_VGET(vp->v_mount, NULL, dirbuf.dotdot_ino, &vp)) != 0) {
-			vp = NULL;
-			break;
-		}
-	}
-
-out:
-	if (error == ENOTDIR)
-		kprintf("checkpath: .. not a directory\n");
-	if (vp != NULL)
-		vput(vp);
-	return (error);
-}
diff --git a/sys/gnu/vfs/ext2fs/ext2_mount.h b/sys/gnu/vfs/ext2fs/ext2_mount.h
deleted file mode 100644
index 050395afa3..0000000000
--- a/sys/gnu/vfs/ext2fs/ext2_mount.h
+++ /dev/null
@@ -1,120 +0,0 @@
-/*-
- * Copyright (c) 1982, 1986, 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. 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.
- *
- *	@(#)ufsmount.h	8.6 (Berkeley) 3/30/95
- * $FreeBSD: src/sys/ufs/ufs/ufsmount.h,v 1.17 1999/12/29 04:55:06 peter Exp $
- */
-
-#ifndef _VFS_GNU_EXT2FS_EXT2MOUNT_H_
-#define _VFS_GNU_EXT2FS_EXT2MOUNT_H_
-
-/*
- * Arguments to mount UFS-based filesystems
- */
-struct ext2_args {
-	char	*fspec;			/* block special device to mount */
-	struct	export_args export;	/* network export information */
-};
-
-/*
- * Arguments to mount MFS
- */
-struct mfs_args {
-	char	*fspec;			/* name to export for statfs */
-	struct	export_args export;	/* if exported MFSes are supported */
-	caddr_t	base;			/* base of filesystem in memory */
-	u_long	size;			/* size of filesystem */
-};
-
-#ifdef _KERNEL
-
-#ifdef MALLOC_DECLARE
-MALLOC_DECLARE(M_EXT2MNT);
-#endif
-
-struct buf;
-struct inode;
-struct timeval;
-struct ucred;
-struct uio;
-struct vnode;
-struct netexport;
-
-/* This structure describes the UFS specific mount structure data. */
-struct ext2_mount {
-	struct	mount *um_mountp;		/* filesystem vfs structure */
-	cdev_t	um_dev;				/* device mounted */
-	struct	vnode *um_devvp;		/* block device mounted vnode */
-
-	struct	ext2_sb_info *um_e2fs;
-	struct	vnode *um_quotas[MAXQUOTAS];	/* pointer to quota files */
-	struct	ucred *um_cred[MAXQUOTAS];	/* quota file access cred */
-	u_long	um_nindir;			/* indirect ptrs per block */
-	u_long	um_bptrtodb;			/* indir ptr to disk block */
-	u_long	um_seqinc;			/* inc between seq blocks */
-	time_t	um_btime[MAXQUOTAS];		/* block quota time limit */
-	time_t	um_itime[MAXQUOTAS];		/* inode quota time limit */
-	char	um_qflags[MAXQUOTAS];		/* quota specific flags */
-	struct	netexport um_export;		/* export information */
-	int64_t	um_savedmaxfilesize;		/* XXX - limit maxfilesize */
-	struct malloc_type *um_malloctype;	/* The inodes malloctype */
-	int	um_i_effnlink_valid;		/* i_effnlink valid? */
-	int	(*um_blkatoff) (struct vnode *, off_t, char **, struct buf **);
-	int	(*um_truncate) (struct vnode *, off_t, int, struct ucred *);
-	int	(*um_update) (struct vnode *, int);
-	int	(*um_valloc) (struct vnode *, int, struct ucred *, struct vnode **);
-	int	(*um_vfree) (struct vnode *, ino_t, int);
-};
-
-#define	um_e2fsb um_e2fs->s_es
-
-#define EXT2_BLKATOFF(aa, bb, cc, dd) VFSTOEXT2((aa)->v_mount)->um_blkatoff(aa, bb, cc, dd)
-#define EXT2_TRUNCATE(aa, bb, cc, dd) VFSTOEXT2((aa)->v_mount)->um_truncate(aa, bb, cc, dd)
-#define EXT2_UPDATE(aa, bb) VFSTOEXT2((aa)->v_mount)->um_update(aa, bb)
-#define EXT2_VALLOC(aa, bb, cc, dd) VFSTOEXT2((aa)->v_mount)->um_valloc(aa, bb, cc, dd)
-#define EXT2_VFREE(aa, bb, cc) VFSTOEXT2((aa)->v_mount)->um_vfree(aa, bb, cc)
-
-/*
- * Flags describing the state of quotas.
- */
-#define	QTF_OPENING	0x01			/* Q_QUOTAON in progress */
-#define	QTF_CLOSING	0x02			/* Q_QUOTAOFF in progress */
-
-/* Convert mount ptr to ext2_mount ptr. */
-#define VFSTOEXT2(mp)	((struct ext2_mount *)((mp)->mnt_data))
-
-/*
- * Macros to access filesystem parameters in the ext2_mount structure.
- * Used by ext2_bmap.
- */
-#define MNINDIR(ump)			((ump)->um_nindir)
-#define	blkptrtodb(ump, b)		((b) << (ump)->um_bptrtodb)
-#define	is_sequential(ump, a, b)	((b) == (a) + ump->um_seqinc)
-#endif /* _KERNEL */
-
-#endif /* !_VFS_GNU_EXT2FS_EXT2MOUNT_H_ */
diff --git a/sys/gnu/vfs/ext2fs/ext2_quota.c b/sys/gnu/vfs/ext2fs/ext2_quota.c
deleted file mode 100644
index 7ac94ae371..0000000000
--- a/sys/gnu/vfs/ext2fs/ext2_quota.c
+++ /dev/null
@@ -1,925 +0,0 @@
-/*
- * Copyright (c) 1982, 1986, 1990, 1993, 1995
- *	The Regents of the University of California.  All rights reserved.
- *
- * This code is derived from software contributed to Berkeley by
- * Robert Elz at The University of Melbourne.
- *
- * 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. 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.
- *
- *	@(#)ufs_quota.c	8.5 (Berkeley) 5/20/95
- * $FreeBSD: src/sys/ufs/ufs/ufs_quota.c,v 1.27.2.3 2002/01/15 10:33:32 phk Exp $
- */
-
-#include <sys/param.h>
-#include <sys/systm.h>
-#include <sys/uio.h>
-#include <sys/kernel.h>
-#include <sys/malloc.h>
-#include <sys/fcntl.h>
-#include <sys/proc.h>
-#include <sys/nlookup.h>
-#include <sys/vnode.h>
-#include <sys/mount.h>
-#include <vm/vm_zone.h>
-
-#include "quota.h"
-#include "dinode.h"
-#include "inode.h"
-#include "ext2_mount.h"
-#include "ext2_extern.h"
-
-static MALLOC_DEFINE(M_EXT2DQUOT, "EXT2 quota", "EXT2 quota entries");
-
-/*
- * Quota name to error message mapping.
- */
-static char *quotatypes[] = INITQFNAMES;
-
-static int ext2_chkdqchg (struct inode *, long, struct ucred *, int);
-static int ext2_chkiqchg (struct inode *, long, struct ucred *, int);
-static int ext2_dqget (struct vnode *,
-		u_long, struct ext2_mount *, int, struct ext2_dquot **);
-static int ext2_dqsync (struct vnode *, struct ext2_dquot *);
-static void ext2_dqflush (struct vnode *);
-
-#ifdef DIAGNOSTIC
-static void ext2_dqref (struct ext2_dquot *);
-static void ext2_chkdquot (struct inode *);
-#endif
-
-/*
- * Set up the quotas for an inode.
- *
- * This routine completely defines the semantics of quotas.
- * If other criterion want to be used to establish quotas, the
- * MAXQUOTAS value in quotas.h should be increased, and the
- * additional dquots set up here.
- */
-int
-ext2_getinoquota(struct inode *ip)
-{
-	struct ext2_mount *ump;
-	struct vnode *vp = ITOV(ip);
-	int error;
-
-	ump = VFSTOEXT2(vp->v_mount);
-	/*
-	 * Set up the user quota based on file uid.
-	 * EINVAL means that quotas are not enabled.
-	 */
-	if (ip->i_dquot[USRQUOTA] == NODQUOT &&
-	    (error = ext2_dqget(vp, ip->i_uid, ump, USRQUOTA, &ip->i_dquot[USRQUOTA])) &&
-	    error != EINVAL)
-		return (error);
-	/*
-	 * Set up the group quota based on file gid.
-	 * EINVAL means that quotas are not enabled.
-	 */
-	if (ip->i_dquot[GRPQUOTA] == NODQUOT &&
-	    (error = ext2_dqget(vp, ip->i_gid, ump, GRPQUOTA, &ip->i_dquot[GRPQUOTA])) &&
-	    error != EINVAL)
-		return (error);
-	return (0);
-}
-
-/*
- * Update disk usage, and take corrective action.
- */
-int
-ext2_chkdq(struct inode *ip, long change, struct ucred *cred, int flags)
-{
-	struct ext2_dquot *dq;
-	int i;
-	int ncurblocks, error;
-
-#ifdef DIAGNOSTIC
-	if ((flags & CHOWN) == 0)
-		ext2_chkdquot(ip);
-#endif
-	if (change == 0)
-		return (0);
-	if (change < 0) {
-		for (i = 0; i < MAXQUOTAS; i++) {
-			if ((dq = ip->i_dquot[i]) == NODQUOT)
-				continue;
-			while (dq->dq_flags & DQ_LOCK) {
-				dq->dq_flags |= DQ_WANT;
-				(void) tsleep((caddr_t)dq, 0, "chkdq1", 0);
-			}
-			ncurblocks = dq->dq_curblocks + change;
-			if (ncurblocks >= 0)
-				dq->dq_curblocks = ncurblocks;
-			else
-				dq->dq_curblocks = 0;
-			dq->dq_flags &= ~DQ_BLKS;
-			dq->dq_flags |= DQ_MOD;
-		}
-		return (0);
-	}
-	if ((flags & FORCE) == 0 && cred->cr_uid != 0) {
-		for (i = 0; i < MAXQUOTAS; i++) {
-			if ((dq = ip->i_dquot[i]) == NODQUOT)
-				continue;
-			error = ext2_chkdqchg(ip, change, cred, i);
-			if (error)
-				return (error);
-		}
-	}
-	for (i = 0; i < MAXQUOTAS; i++) {
-		if ((dq = ip->i_dquot[i]) == NODQUOT)
-			continue;
-		while (dq->dq_flags & DQ_LOCK) {
-			dq->dq_flags |= DQ_WANT;
-			(void) tsleep((caddr_t)dq, 0, "chkdq2", 0);
-		}
-		/* Reset timer when crossing soft limit */
-		if (dq->dq_curblocks + change >= dq->dq_bsoftlimit &&
-		    dq->dq_curblocks < dq->dq_bsoftlimit)
-			dq->dq_btime = time_second +
-			    VFSTOEXT2(ITOV(ip)->v_mount)->um_btime[i];
-		dq->dq_curblocks += change;
-		dq->dq_flags |= DQ_MOD;
-	}
-	return (0);
-}
-
-/*
- * Check for a valid change to a users allocation.
- * Issue an error message if appropriate.
- */
-static int
-ext2_chkdqchg(struct inode *ip, long change, struct ucred *cred, int type)
-{
-	struct ext2_dquot *dq = ip->i_dquot[type];
-	long ncurblocks = dq->dq_curblocks + change;
-
-	/*
-	 * If user would exceed their hard limit, disallow space allocation.
-	 */
-	if (ncurblocks >= dq->dq_bhardlimit && dq->dq_bhardlimit) {
-		if ((dq->dq_flags & DQ_BLKS) == 0 &&
-		    ip->i_uid == cred->cr_uid) {
-			uprintf("\n%s: write failed, %s disk limit reached\n",
-			    ITOV(ip)->v_mount->mnt_stat.f_mntfromname,
-			    quotatypes[type]);
-			dq->dq_flags |= DQ_BLKS;
-		}
-		return (EDQUOT);
-	}
-	/*
-	 * If user is over their soft limit for too long, disallow space
-	 * allocation. Reset time limit as they cross their soft limit.
-	 */
-	if (ncurblocks >= dq->dq_bsoftlimit && dq->dq_bsoftlimit) {
-		if (dq->dq_curblocks < dq->dq_bsoftlimit) {
-			dq->dq_btime = time_second +
-			    VFSTOEXT2(ITOV(ip)->v_mount)->um_btime[type];
-			if (ip->i_uid == cred->cr_uid)
-				uprintf("\n%s: warning, %s %s\n",
-				    ITOV(ip)->v_mount->mnt_stat.f_mntfromname,
-				    quotatypes[type], "disk quota exceeded");
-			return (0);
-		}
-		if (time_second > dq->dq_btime) {
-			if ((dq->dq_flags & DQ_BLKS) == 0 &&
-			    ip->i_uid == cred->cr_uid) {
-				uprintf("\n%s: write failed, %s %s\n",
-				    ITOV(ip)->v_mount->mnt_stat.f_mntfromname,
-				    quotatypes[type],
-				    "disk quota exceeded for too long");
-				dq->dq_flags |= DQ_BLKS;
-			}
-			return (EDQUOT);
-		}
-	}
-	return (0);
-}
-
-/*
- * Check the inode limit, applying corrective action.
- */
-int
-ext2_chkiq(struct inode *ip, long change, struct ucred *cred, int flags)
-{
-	struct ext2_dquot *dq;
-	int i;
-	int ncurinodes, error;
-
-#ifdef DIAGNOSTIC
-	if ((flags & CHOWN) == 0)
-		ext2_chkdquot(ip);
-#endif
-	if (change == 0)
-		return (0);
-	if (change < 0) {
-		for (i = 0; i < MAXQUOTAS; i++) {
-			if ((dq = ip->i_dquot[i]) == NODQUOT)
-				continue;
-			while (dq->dq_flags & DQ_LOCK) {
-				dq->dq_flags |= DQ_WANT;
-				(void) tsleep((caddr_t)dq, 0, "chkiq1", 0);
-			}
-			ncurinodes = dq->dq_curinodes + change;
-			if (ncurinodes >= 0)
-				dq->dq_curinodes = ncurinodes;
-			else
-				dq->dq_curinodes = 0;
-			dq->dq_flags &= ~DQ_INODS;
-			dq->dq_flags |= DQ_MOD;
-		}
-		return (0);
-	}
-	if ((flags & FORCE) == 0 && cred->cr_uid != 0) {
-		for (i = 0; i < MAXQUOTAS; i++) {
-			if ((dq = ip->i_dquot[i]) == NODQUOT)
-				continue;
-			error = ext2_chkiqchg(ip, change, cred, i);
-			if (error)
-				return (error);
-		}
-	}
-	for (i = 0; i < MAXQUOTAS; i++) {
-		if ((dq = ip->i_dquot[i]) == NODQUOT)
-			continue;
-		while (dq->dq_flags & DQ_LOCK) {
-			dq->dq_flags |= DQ_WANT;
-			(void) tsleep((caddr_t)dq, 0, "chkiq2", 0);
-		}
-		/* Reset timer when crossing soft limit */
-		if (dq->dq_curinodes + change >= dq->dq_isoftlimit &&
-		    dq->dq_curinodes < dq->dq_isoftlimit)
-			dq->dq_itime = time_second +
-			    VFSTOEXT2(ITOV(ip)->v_mount)->um_itime[i];
-		dq->dq_curinodes += change;
-		dq->dq_flags |= DQ_MOD;
-	}
-	return (0);
-}
-
-/*
- * Check for a valid change to a users allocation.
- * Issue an error message if appropriate.
- */
-static int
-ext2_chkiqchg(struct inode *ip, long change, struct ucred *cred, int type)
-{
-	struct ext2_dquot *dq = ip->i_dquot[type];
-	long ncurinodes = dq->dq_curinodes + change;
-
-	/*
-	 * If user would exceed their hard limit, disallow inode allocation.
-	 */
-	if (ncurinodes >= dq->dq_ihardlimit && dq->dq_ihardlimit) {
-		if ((dq->dq_flags & DQ_INODS) == 0 &&
-		    ip->i_uid == cred->cr_uid) {
-			uprintf("\n%s: write failed, %s inode limit reached\n",
-			    ITOV(ip)->v_mount->mnt_stat.f_mntfromname,
-			    quotatypes[type]);
-			dq->dq_flags |= DQ_INODS;
-		}
-		return (EDQUOT);
-	}
-	/*
-	 * If user is over their soft limit for too long, disallow inode
-	 * allocation. Reset time limit as they cross their soft limit.
-	 */
-	if (ncurinodes >= dq->dq_isoftlimit && dq->dq_isoftlimit) {
-		if (dq->dq_curinodes < dq->dq_isoftlimit) {
-			dq->dq_itime = time_second +
-			    VFSTOEXT2(ITOV(ip)->v_mount)->um_itime[type];
-			if (ip->i_uid == cred->cr_uid)
-				uprintf("\n%s: warning, %s %s\n",
-				    ITOV(ip)->v_mount->mnt_stat.f_mntfromname,
-				    quotatypes[type], "inode quota exceeded");
-			return (0);
-		}
-		if (time_second > dq->dq_itime) {
-			if ((dq->dq_flags & DQ_INODS) == 0 &&
-			    ip->i_uid == cred->cr_uid) {
-				uprintf("\n%s: write failed, %s %s\n",
-				    ITOV(ip)->v_mount->mnt_stat.f_mntfromname,
-				    quotatypes[type],
-				    "inode quota exceeded for too long");
-				dq->dq_flags |= DQ_INODS;
-			}
-			return (EDQUOT);
-		}
-	}
-	return (0);
-}
-
-#ifdef DIAGNOSTIC
-/*
- * On filesystems with quotas enabled, it is an error for a file to change
- * size and not to have a dquot structure associated with it.
- */
-static void
-ext2_chkdquot(struct inode *ip)
-{
-	struct ext2_mount *ump = VFSTOEXT2(ITOV(ip)->v_mount);
-	int i;
-
-	for (i = 0; i < MAXQUOTAS; i++) {
-		if (ump->um_quotas[i] == NULLVP ||
-		    (ump->um_qflags[i] & (QTF_OPENING|QTF_CLOSING)))
-			continue;
-		if (ip->i_dquot[i] == NODQUOT) {
-			vprint("chkdquot: missing dquot", ITOV(ip));
-			panic("chkdquot: missing dquot");
-		}
-	}
-}
-#endif
-
-/*
- * Code to process quotactl commands.
- */
-
-struct scaninfo {
-	int rescan;
-	int type;
-};
-
-/*
- * Q_QUOTAON - set up a quota file for a particular filesystem.
- */
-static int ext2_quotaon_scan(struct mount *mp, struct vnode *vp, void *data);
-
-int
-ext2_quotaon(struct ucred *cred, struct mount *mp, int type, caddr_t fname)
-{
-	struct ext2_mount *ump = VFSTOEXT2(mp);
-	struct vnode *vp, **vpp;
-	struct ext2_dquot *dq;
-	int error;
-	struct nlookupdata nd;
-	struct scaninfo scaninfo;
-
-	vpp = &ump->um_quotas[type];
-	error = nlookup_init(&nd, fname, UIO_USERSPACE, NLC_FOLLOW|NLC_LOCKVP);
-	if (error == 0)
-		error = vn_open(&nd, NULL, FREAD|FWRITE, 0);
-	if (error == 0 && nd.nl_open_vp->v_type != VREG)
-		error = EACCES;
-	if (error) {
-		nlookup_done(&nd);
-		return (error);
-	}
-	vp = nd.nl_open_vp;
-	nd.nl_open_vp = NULL;
-	nlookup_done(&nd);
-
-	vn_unlock(vp);
-	if (*vpp != vp)
-		ext2_quotaoff(mp, type);
-	ump->um_qflags[type] |= QTF_OPENING;
-	mp->mnt_flag |= MNT_QUOTA;
-	vsetflags(vp, VSYSTEM);
-	*vpp = vp;
-	/* XXX release duplicate vp if *vpp == vp? */
-	/*
-	 * Save the credential of the process that turned on quotas.
-	 * Set up the time limits for this quota.
-	 */
-	ump->um_cred[type] = crhold(cred);
-	ump->um_btime[type] = MAX_DQ_TIME;
-	ump->um_itime[type] = MAX_IQ_TIME;
-	if (ext2_dqget(NULLVP, 0, ump, type, &dq) == 0) {
-		if (dq->dq_btime > 0)
-			ump->um_btime[type] = dq->dq_btime;
-		if (dq->dq_itime > 0)
-			ump->um_itime[type] = dq->dq_itime;
-		ext2_dqrele(NULLVP, dq);
-	}
-	/*
-	 * Search vnodes associated with this mount point,
-	 * adding references to quota file being opened.
-	 * NB: only need to add dquot's for inodes being modified.
-	 */
-	scaninfo.rescan = 1;
-	while (scaninfo.rescan) {
-		scaninfo.rescan = 0;
-		error = vmntvnodescan(mp, VMSC_GETVP,
-					NULL, ext2_quotaon_scan, &scaninfo);
-		if (error)
-			break;
-	}
-	ump->um_qflags[type] &= ~QTF_OPENING;
-	if (error)
-		ext2_quotaoff(mp, type);
-	return (error);
-}
-
-static int
-ext2_quotaon_scan(struct mount *mp, struct vnode *vp, void *data)
-{
-	int error;
-	/*struct scaninfo *info = data;*/
-
-	if (vp->v_writecount == 0)
-		return(0);
-	error = ext2_getinoquota(VTOI(vp));
-	return(error);
-}
-
-/*
- * Q_QUOTAOFF - turn off disk quotas for a filesystem.
- */
-
-static int ext2_quotaoff_scan(struct mount *mp, struct vnode *vp, void *data);
-
-int
-ext2_quotaoff(struct mount *mp, int type)
-{
-	struct vnode *qvp;
-	struct ext2_mount *ump = VFSTOEXT2(mp);
-	int error;
-	struct scaninfo scaninfo;
-
-	if ((qvp = ump->um_quotas[type]) == NULLVP)
-		return (0);
-	ump->um_qflags[type] |= QTF_CLOSING;
-
-	/*
-	 * Search vnodes associated with this mount point,
-	 * deleting any references to quota file being closed.
-	 */
-	scaninfo.rescan = 1;
-	scaninfo.type = type;
-	while (scaninfo.rescan) {
-		scaninfo.rescan = 0;
-		vmntvnodescan(mp, VMSC_GETVP, NULL, ext2_quotaoff_scan, &scaninfo);
-	}
-	ext2_dqflush(qvp);
-	vclrflags(qvp, VSYSTEM);
-	error = vn_close(qvp, FREAD|FWRITE, NULL);
-	ump->um_quotas[type] = NULLVP;
-	crfree(ump->um_cred[type]);
-	ump->um_cred[type] = NOCRED;
-	ump->um_qflags[type] &= ~QTF_CLOSING;
-	for (type = 0; type < MAXQUOTAS; type++) {
-		if (ump->um_quotas[type] != NULLVP)
-			break;
-	}
-	if (type == MAXQUOTAS)
-		mp->mnt_flag &= ~MNT_QUOTA;
-	return (error);
-}
-
-static int
-ext2_quotaoff_scan(struct mount *mp, struct vnode *vp, void *data)
-{
-	struct scaninfo *info = data;
-	struct ext2_dquot *dq;
-	struct inode *ip;
-
-	if (vp->v_type == VNON) {
-		return(0);
-	}
-	ip = VTOI(vp);
-	dq = ip->i_dquot[info->type];
-	ip->i_dquot[info->type] = NODQUOT;
-	ext2_dqrele(vp, dq);
-	return(0);
-}
-
-/*
- * Q_GETQUOTA - return current values in a dqblk structure.
- */
-int
-ext2_getquota(struct mount *mp, u_long id, int type, caddr_t addr)
-{
-	struct ext2_dquot *dq;
-	int error;
-
-	error = ext2_dqget(NULLVP, id, VFSTOEXT2(mp), type, &dq);
-	if (error)
-		return (error);
-	error = copyout((caddr_t)&dq->dq_dqb, addr, sizeof (struct ext2_dqblk));
-	ext2_dqrele(NULLVP, dq);
-	return (error);
-}
-
-/*
- * Q_SETQUOTA - assign an entire dqblk structure.
- */
-int
-ext2_setquota(struct mount *mp, u_long id, int type, caddr_t addr)
-{
-	struct ext2_dquot *dq;
-	struct ext2_dquot *ndq;
-	struct ext2_mount *ump = VFSTOEXT2(mp);
-	struct ext2_dqblk newlim;
-	int error;
-
-	error = copyin(addr, (caddr_t)&newlim, sizeof (struct ext2_dqblk));
-	if (error)
-		return (error);
-	error = ext2_dqget(NULLVP, id, ump, type, &ndq);
-	if (error)
-		return (error);
-	dq = ndq;
-	while (dq->dq_flags & DQ_LOCK) {
-		dq->dq_flags |= DQ_WANT;
-		(void) tsleep((caddr_t)dq, 0, "setqta", 0);
-	}
-	/*
-	 * Copy all but the current values.
-	 * Reset time limit if previously had no soft limit or were
-	 * under it, but now have a soft limit and are over it.
-	 */
-	newlim.dqb_curblocks = dq->dq_curblocks;
-	newlim.dqb_curinodes = dq->dq_curinodes;
-	if (dq->dq_id != 0) {
-		newlim.dqb_btime = dq->dq_btime;
-		newlim.dqb_itime = dq->dq_itime;
-	}
-	if (newlim.dqb_bsoftlimit &&
-	    dq->dq_curblocks >= newlim.dqb_bsoftlimit &&
-	    (dq->dq_bsoftlimit == 0 || dq->dq_curblocks < dq->dq_bsoftlimit))
-		newlim.dqb_btime = time_second + ump->um_btime[type];
-	if (newlim.dqb_isoftlimit &&
-	    dq->dq_curinodes >= newlim.dqb_isoftlimit &&
-	    (dq->dq_isoftlimit == 0 || dq->dq_curinodes < dq->dq_isoftlimit))
-		newlim.dqb_itime = time_second + ump->um_itime[type];
-	dq->dq_dqb = newlim;
-	if (dq->dq_curblocks < dq->dq_bsoftlimit)
-		dq->dq_flags &= ~DQ_BLKS;
-	if (dq->dq_curinodes < dq->dq_isoftlimit)
-		dq->dq_flags &= ~DQ_INODS;
-	if (dq->dq_isoftlimit == 0 && dq->dq_bsoftlimit == 0 &&
-	    dq->dq_ihardlimit == 0 && dq->dq_bhardlimit == 0)
-		dq->dq_flags |= DQ_FAKE;
-	else
-		dq->dq_flags &= ~DQ_FAKE;
-	dq->dq_flags |= DQ_MOD;
-	ext2_dqrele(NULLVP, dq);
-	return (0);
-}
-
-/*
- * Q_SETUSE - set current inode and block usage.
- */
-int
-ext2_setuse(struct mount *mp, u_long id, int type, caddr_t addr)
-{
-	struct ext2_dquot *dq;
-	struct ext2_mount *ump = VFSTOEXT2(mp);
-	struct ext2_dquot *ndq;
-	struct ext2_dqblk usage;
-	int error;
-
-	error = copyin(addr, (caddr_t)&usage, sizeof (struct ext2_dqblk));
-	if (error)
-		return (error);
-	error = ext2_dqget(NULLVP, id, ump, type, &ndq);
-	if (error)
-		return (error);
-	dq = ndq;
-	while (dq->dq_flags & DQ_LOCK) {
-		dq->dq_flags |= DQ_WANT;
-		(void) tsleep((caddr_t)dq, 0, "setuse", 0);
-	}
-	/*
-	 * Reset time limit if have a soft limit and were
-	 * previously under it, but are now over it.
-	 */
-	if (dq->dq_bsoftlimit && dq->dq_curblocks < dq->dq_bsoftlimit &&
-	    usage.dqb_curblocks >= dq->dq_bsoftlimit)
-		dq->dq_btime = time_second + ump->um_btime[type];
-	if (dq->dq_isoftlimit && dq->dq_curinodes < dq->dq_isoftlimit &&
-	    usage.dqb_curinodes >= dq->dq_isoftlimit)
-		dq->dq_itime = time_second + ump->um_itime[type];
-	dq->dq_curblocks = usage.dqb_curblocks;
-	dq->dq_curinodes = usage.dqb_curinodes;
-	if (dq->dq_curblocks < dq->dq_bsoftlimit)
-		dq->dq_flags &= ~DQ_BLKS;
-	if (dq->dq_curinodes < dq->dq_isoftlimit)
-		dq->dq_flags &= ~DQ_INODS;
-	dq->dq_flags |= DQ_MOD;
-	ext2_dqrele(NULLVP, dq);
-	return (0);
-}
-
-/*
- * Q_SYNC - sync quota files to disk.
- */
-
-static int ext2_qsync_scan(struct mount *mp, struct vnode *vp, void *data);
-
-int
-ext2_qsync(struct mount *mp)
-{
-	struct ext2_mount *ump = VFSTOEXT2(mp);
-	struct scaninfo scaninfo;
-	int i;
-
-	/*
-	 * Check if the mount point has any quotas.
-	 * If not, simply return.
-	 */
-	for (i = 0; i < MAXQUOTAS; i++)
-		if (ump->um_quotas[i] != NULLVP)
-			break;
-	if (i == MAXQUOTAS)
-		return (0);
-	/*
-	 * Search vnodes associated with this mount point,
-	 * synchronizing any modified ext2_dquot structures.
-	 */
-	scaninfo.rescan = 1;
-	while (scaninfo.rescan) {
-		scaninfo.rescan = 0;
-		vmntvnodescan(mp, VMSC_GETVP|VMSC_NOWAIT,
-				NULL, ext2_qsync_scan, &scaninfo);
-	}
-	return (0);
-}
-
-static int
-ext2_qsync_scan(struct mount *mp, struct vnode *vp, void *data)
-{
-	/*struct scaninfo *info = data;*/
-	struct ext2_dquot *dq;
-	/* int error;*/
-	int i;
-
-	for (i = 0; i < MAXQUOTAS; i++) {
-		dq = VTOI(vp)->i_dquot[i];
-		if (dq != NODQUOT && (dq->dq_flags & DQ_MOD))
-			ext2_dqsync(vp, dq);
-	}
-	return(0);
-}
-
-/*
- * Code pertaining to management of the in-core dquot data structures.
- */
-#define DQHASH(dqvp, id) \
-	(&ext2_dqhashtbl[((((intptr_t)(dqvp)) >> 8) + id) & ext2_dqhash])
-static LIST_HEAD(ext2_dqhash, ext2_dquot) *ext2_dqhashtbl;
-static u_long ext2_dqhash;
-
-/*
- * Dquot free list.
- */
-#define	DQUOTINC	5	/* minimum free dquots desired */
-static TAILQ_HEAD(ext2_dqfreelist, ext2_dquot) ext2_dqfreelist;
-static long ext2_numdquot, ext2_desireddquot = DQUOTINC;
-
-/*
- * Initialize the quota system.
- */
-void
-ext2_dqinit(void)
-{
-	int hsize = vfs_inodehashsize();
-
-	ext2_dqhashtbl = hashinit(hsize, M_EXT2DQUOT, &ext2_dqhash);
-	TAILQ_INIT(&ext2_dqfreelist);
-}
-
-/*
- * Obtain a dquot structure for the specified identifier and quota file
- * reading the information from the file if necessary.
- */
-static int
-ext2_dqget(struct vnode *vp, u_long id, struct ext2_mount *ump, int type,
-      struct ext2_dquot **dqp)
-{
-	struct ext2_dquot *dq;
-	struct ext2_dqhash *dqh;
-	struct vnode *dqvp;
-	struct iovec aiov;
-	struct uio auio;
-	int error;
-
-	dqvp = ump->um_quotas[type];
-	if (dqvp == NULLVP || (ump->um_qflags[type] & QTF_CLOSING)) {
-		*dqp = NODQUOT;
-		return (EINVAL);
-	}
-	/*
-	 * Check the cache first.
-	 */
-	dqh = DQHASH(dqvp, id);
-	LIST_FOREACH(dq, dqh, dq_hash) {
-		if (dq->dq_id != id ||
-		    dq->dq_ump->um_quotas[dq->dq_type] != dqvp)
-			continue;
-		/*
-		 * Cache hit with no references.  Take
-		 * the structure off the free list.
-		 */
-		if (dq->dq_cnt == 0)
-			TAILQ_REMOVE(&ext2_dqfreelist, dq, dq_freelist);
-		DQREF(dq);
-		*dqp = dq;
-		return (0);
-	}
-
-	/*
-	 * Not in cache, allocate a new one.
-	 */
-	if (TAILQ_EMPTY(&ext2_dqfreelist) &&
-	    ext2_numdquot < MAXQUOTAS * maxvnodes) {
-		ext2_desireddquot += DQUOTINC;
-	}
-	if (ext2_numdquot < ext2_desireddquot) {
-		dq = kmalloc(sizeof *dq, M_EXT2DQUOT, M_WAITOK | M_ZERO);
-		ext2_numdquot++;
-	} else {
-		if ((dq = TAILQ_FIRST(&ext2_dqfreelist)) == NULL) {
-			tablefull("dquot");
-			*dqp = NODQUOT;
-			return (EUSERS);
-		}
-		if (dq->dq_cnt || (dq->dq_flags & DQ_MOD))
-			panic("dqget: free dquot isn't");
-		TAILQ_REMOVE(&ext2_dqfreelist, dq, dq_freelist);
-		if (dq->dq_ump != NULL)
-			LIST_REMOVE(dq, dq_hash);
-	}
-	/*
-	 * Initialize the contents of the dquot structure.
-	 */
-	if (vp != dqvp)
-		vn_lock(dqvp, LK_EXCLUSIVE | LK_RETRY);
-	LIST_INSERT_HEAD(dqh, dq, dq_hash);
-	DQREF(dq);
-	dq->dq_flags = DQ_LOCK;
-	dq->dq_id = id;
-	dq->dq_ump = ump;
-	dq->dq_type = type;
-	auio.uio_iov = &aiov;
-	auio.uio_iovcnt = 1;
-	aiov.iov_base = (caddr_t)&dq->dq_dqb;
-	aiov.iov_len = sizeof (struct ext2_dqblk);
-	auio.uio_resid = sizeof (struct ext2_dqblk);
-	auio.uio_offset = (off_t)(id * sizeof (struct ext2_dqblk));
-	auio.uio_segflg = UIO_SYSSPACE;
-	auio.uio_rw = UIO_READ;
-	auio.uio_td = NULL;
-	error = VOP_READ(dqvp, &auio, 0, ump->um_cred[type]);
-	if (auio.uio_resid == sizeof(struct ext2_dqblk) && error == 0)
-		bzero((caddr_t)&dq->dq_dqb, sizeof(struct ext2_dqblk));
-	if (vp != dqvp)
-		vn_unlock(dqvp);
-	if (dq->dq_flags & DQ_WANT)
-		wakeup((caddr_t)dq);
-	dq->dq_flags = 0;
-	/*
-	 * I/O error in reading quota file, release
-	 * quota structure and reflect problem to caller.
-	 */
-	if (error) {
-		LIST_REMOVE(dq, dq_hash);
-		ext2_dqrele(vp, dq);
-		*dqp = NODQUOT;
-		return (error);
-	}
-	/*
-	 * Check for no limit to enforce.
-	 * Initialize time values if necessary.
-	 */
-	if (dq->dq_isoftlimit == 0 && dq->dq_bsoftlimit == 0 &&
-	    dq->dq_ihardlimit == 0 && dq->dq_bhardlimit == 0)
-		dq->dq_flags |= DQ_FAKE;
-	if (dq->dq_id != 0) {
-		if (dq->dq_btime == 0)
-			dq->dq_btime = time_second + ump->um_btime[type];
-		if (dq->dq_itime == 0)
-			dq->dq_itime = time_second + ump->um_itime[type];
-	}
-	*dqp = dq;
-	return (0);
-}
-
-#ifdef DIAGNOSTIC
-/*
- * Obtain a reference to a dquot.
- */
-static void
-ext2_dqref(struct ext2_dquot *dq)
-{
-	dq->dq_cnt++;
-}
-#endif
-
-/*
- * Release a reference to a dquot.
- */
-void
-ext2_dqrele(struct vnode *vp, struct ext2_dquot *dq)
-{
-	if (dq == NODQUOT)
-		return;
-	if (dq->dq_cnt > 1) {
-		dq->dq_cnt--;
-		return;
-	}
-	if (dq->dq_flags & DQ_MOD)
-		(void)ext2_dqsync(vp, dq);
-	if (--dq->dq_cnt > 0)
-		return;
-	TAILQ_INSERT_TAIL(&ext2_dqfreelist, dq, dq_freelist);
-}
-
-/*
- * Update the disk quota in the quota file.
- */
-static int
-ext2_dqsync(struct vnode *vp, struct ext2_dquot *dq)
-{
-	struct vnode *dqvp;
-	struct iovec aiov;
-	struct uio auio;
-	int error;
-
-	if (dq == NODQUOT)
-		panic("dqsync: dquot");
-	if ((dq->dq_flags & DQ_MOD) == 0)
-		return (0);
-	if ((dqvp = dq->dq_ump->um_quotas[dq->dq_type]) == NULLVP)
-		panic("dqsync: file");
-	if (vp != dqvp)
-		vn_lock(dqvp, LK_EXCLUSIVE | LK_RETRY);
-	while (dq->dq_flags & DQ_LOCK) {
-		dq->dq_flags |= DQ_WANT;
-		(void) tsleep((caddr_t)dq, 0, "dqsync", 0);
-		if ((dq->dq_flags & DQ_MOD) == 0) {
-			if (vp != dqvp)
-				vn_unlock(dqvp);
-			return (0);
-		}
-	}
-	dq->dq_flags |= DQ_LOCK;
-	auio.uio_iov = &aiov;
-	auio.uio_iovcnt = 1;
-	aiov.iov_base = (caddr_t)&dq->dq_dqb;
-	aiov.iov_len = sizeof (struct ext2_dqblk);
-	auio.uio_resid = sizeof (struct ext2_dqblk);
-	auio.uio_offset = (off_t)(dq->dq_id * sizeof (struct ext2_dqblk));
-	auio.uio_segflg = UIO_SYSSPACE;
-	auio.uio_rw = UIO_WRITE;
-	auio.uio_td = NULL;
-	error = VOP_WRITE(dqvp, &auio, 0, dq->dq_ump->um_cred[dq->dq_type]);
-	if (auio.uio_resid && error == 0)
-		error = EIO;
-	if (dq->dq_flags & DQ_WANT)
-		wakeup((caddr_t)dq);
-	dq->dq_flags &= ~(DQ_MOD|DQ_LOCK|DQ_WANT);
-	if (vp != dqvp)
-		vn_unlock(dqvp);
-	return (error);
-}
-
-/*
- * Flush all entries from the cache for a particular vnode.
- */
-static void
-ext2_dqflush(struct vnode *vp)
-{
-	struct ext2_dquot *dq, *nextdq;
-	struct ext2_dqhash *dqh;
-
-	/*
-	 * Move all dquot's that used to refer to this quota
-	 * file off their hash chains (they will eventually
-	 * fall off the head of the free list and be re-used).
-	 */
-	for (dqh = &ext2_dqhashtbl[ext2_dqhash]; dqh >= ext2_dqhashtbl; dqh--) {
-		for (dq = dqh->lh_first; dq; dq = nextdq) {
-			nextdq = dq->dq_hash.le_next;
-			if (dq->dq_ump->um_quotas[dq->dq_type] != vp)
-				continue;
-			if (dq->dq_cnt)
-				panic("dqflush: stray dquot");
-			LIST_REMOVE(dq, dq_hash);
-			dq->dq_ump = NULL;
-		}
-	}
-}
diff --git a/sys/gnu/vfs/ext2fs/ext2_readwrite.c b/sys/gnu/vfs/ext2fs/ext2_readwrite.c
deleted file mode 100644
index 2e52bca55f..0000000000
--- a/sys/gnu/vfs/ext2fs/ext2_readwrite.c
+++ /dev/null
@@ -1,291 +0,0 @@
-/*
- *  modified for Lites 1.1
- *
- *  Aug 1995, Godmar Back (gback@cs.utah.edu)
- *  University of Utah, Department of Computer Science
- */
-/*
- * Copyright (c) 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. 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.
- *
- *	@(#)ufs_readwrite.c	8.7 (Berkeley) 1/21/94
- * $FreeBSD: src/sys/gnu/ext2fs/ext2_readwrite.c,v 1.18.2.2 2000/12/22 18:44:33 dillon Exp $
- */
-
-#define	BLKSIZE(a, b, c)	blksize(a, b, c)
-
-/*
- * Vnode op for reading.
- *
- * ext2_read(struct vnode *a_vp, struct uio *a_uio, int a_ioflag,
- *	     struct ucred *a_cred)
- */
-/* ARGSUSED */
-static int
-ext2_read(struct vop_read_args *ap)
-{
-	struct vnode *vp;
-	struct inode *ip;
-	struct uio *uio;
-	struct ext2_sb_info *fs;
-	struct buf *bp;
-	daddr_t lbn, nextlbn;
-	off_t nextloffset;
-	off_t bytesinfile;
-	long size, xfersize, blkoffset;
-	int error, orig_resid;
-	int seqcount = ap->a_ioflag >> IO_SEQSHIFT;
-
-	vp = ap->a_vp;
-	ip = VTOI(vp);
-	uio = ap->a_uio;
-
-#ifdef DIAGNOSTIC
-	if (uio->uio_rw != UIO_READ)
-		panic("ext2_read: mode");
-
-	if (vp->v_type == VLNK) {
-		if ((int)ip->i_size < vp->v_mount->mnt_maxsymlinklen)
-			panic("ext2_read: short symlink");
-	} else if (vp->v_type != VREG && vp->v_type != VDIR)
-		panic("ext2_read: type %d", vp->v_type);
-#endif
-	fs = ip->i_e2fs;
-#if 0
-	if ((u_quad_t)uio->uio_offset > fs->fs_maxfilesize)
-		return (EFBIG);
-#endif
-
-	orig_resid = uio->uio_resid;
-	for (error = 0, bp = NULL; uio->uio_resid > 0; bp = NULL) {
-		if ((bytesinfile = ip->i_size - uio->uio_offset) <= 0)
-			break;
-		lbn = lblkno(fs, uio->uio_offset);
-		nextlbn = lbn + 1;
-		nextloffset = lblktodoff(fs, nextlbn);
-		size = BLKSIZE(fs, ip, lbn);
-		blkoffset = blkoff(fs, uio->uio_offset);
-
-		xfersize = fs->s_frag_size - blkoffset;
-		if (uio->uio_resid < xfersize)
-			xfersize = uio->uio_resid;
-		if (bytesinfile < xfersize)
-			xfersize = bytesinfile;
-
-		if (nextloffset >= ip->i_size) {
-			error = bread(vp, lblktodoff(fs, lbn), size, &bp);
-		} else if ((vp->v_mount->mnt_flag & MNT_NOCLUSTERR) == 0) {
-			error = cluster_read(vp, (off_t)ip->i_size,
-					     lblktodoff(fs, lbn), size,
-					     uio->uio_resid,
-					     (ap->a_ioflag >> IO_SEQSHIFT) * MAXBSIZE,
-					     &bp);
-		} else if (seqcount > 1) {
-			int nextsize = BLKSIZE(fs, ip, nextlbn);
-			error = breadn(vp, lblktodoff(fs, lbn),
-					size, &nextloffset, &nextsize, 1, &bp);
-		} else {
-			error = bread(vp, lblktodoff(fs, lbn), size, &bp);
-		}
-		if (error) {
-			brelse(bp);
-			bp = NULL;
-			break;
-		}
-
-		/*
-		 * We should only get non-zero b_resid when an I/O error
-		 * has occurred, which should cause us to break above.
-		 * However, if the short read did not cause an error,
-		 * then we want to ensure that we do not uiomove bad
-		 * or uninitialized data.
-		 */
-		size -= bp->b_resid;
-		if (size < xfersize) {
-			if (size == 0)
-				break;
-			xfersize = size;
-		}
-		error = uiomove((char *)bp->b_data + blkoffset,
-				(int)xfersize, uio);
-		if (error)
-			break;
-
-		bqrelse(bp);
-	}
-	if (bp != NULL)
-		bqrelse(bp);
-	if (orig_resid > 0 && (error == 0 || uio->uio_resid != orig_resid) &&
-	    (vp->v_mount->mnt_flag & MNT_NOATIME) == 0)
-		ip->i_flag |= IN_ACCESS;
-	return (error);
-}
-
-/*
- * Vnode op for writing.
- *
- * ext2_write(struct vnode *a_vp, struct uio *a_uio, int a_ioflag,
- *	      struct ucred *a_cred)
- */
-static int
-ext2_write(struct vop_write_args *ap)
-{
-	struct vnode *vp;
-	struct uio *uio;
-	struct inode *ip;
-	struct ext2_sb_info *fs;
-	struct buf *bp;
-	struct thread *td;
-	daddr_t lbn;
-	off_t osize;
-	int seqcount;
-	int blkoffset, error, flags, ioflag, resid, size, xfersize;
-
-	ioflag = ap->a_ioflag;
-	seqcount = ap->a_ioflag >> IO_SEQSHIFT;
-	uio = ap->a_uio;
-	vp = ap->a_vp;
-	ip = VTOI(vp);
-
-#ifdef DIAGNOSTIC
-	if (uio->uio_rw != UIO_WRITE)
-		panic("ext2_write: mode");
-#endif
-
-	switch (vp->v_type) {
-	case VREG:
-		if (ioflag & IO_APPEND)
-			uio->uio_offset = ip->i_size;
-		if ((ip->i_flags & APPEND) && uio->uio_offset != ip->i_size)
-			return (EPERM);
-		/* FALLTHROUGH */
-	case VLNK:
-		break;
-	case VDIR:
-		if ((ioflag & IO_SYNC) == 0)
-			panic("ext2_write: nonsync dir write");
-		break;
-	default:
-		panic("ext2_write: type");
-	}
-
-	fs = ip->i_e2fs;
-#if 0
-	if (uio->uio_offset < 0 ||
-	    (u_quad_t)uio->uio_offset + uio->uio_resid > fs->fs_maxfilesize)
-		return (EFBIG);
-#endif
-	/*
-	 * Maybe this should be above the vnode op call, but so long as
-	 * file servers have no limits, I don't think it matters.
-	 */
-	td = uio->uio_td;
-	if (vp->v_type == VREG && td && td->td_proc &&
-	    uio->uio_offset + uio->uio_resid >
-	    td->td_proc->p_rlimit[RLIMIT_FSIZE].rlim_cur) {
-		lwpsignal(td->td_proc, td->td_lwp, SIGXFSZ);
-		return (EFBIG);
-	}
-
-	resid = uio->uio_resid;
-	osize = ip->i_size;
-	flags = ioflag & IO_SYNC ? B_SYNC : 0;
-
-	for (error = 0; uio->uio_resid > 0;) {
-		lbn = lblkno(fs, uio->uio_offset);
-		blkoffset = blkoff(fs, uio->uio_offset);
-		xfersize = fs->s_frag_size - blkoffset;
-		if (uio->uio_resid < xfersize)
-			xfersize = uio->uio_resid;
-
-		if (uio->uio_offset + xfersize > ip->i_size)
-			vnode_pager_setsize(vp, uio->uio_offset + xfersize);
-
-		/*
-		 * Avoid a data-consistency race between write() and mmap()
-		 * by ensuring that newly allocated blocks are zerod.  The
-		 * race can occur even in the case where the write covers
-		 * the entire block.
-		 *
-		 * Just set B_CLRBUF unconditionally, even if the write
-		 * covers the whole block.  This also handles the UIO_NOCOPY
-		 * case.  See ffs_write() in ufs for a more sophisticated
-		 * version.
-		 */
-		flags |= B_CLRBUF;
-		error = ext2_balloc(ip, lbn, blkoffset + xfersize,
-				    ap->a_cred, &bp, flags);
-		if (error)
-			break;
-
-		if (uio->uio_offset + xfersize > ip->i_size) {
-			ip->i_size = uio->uio_offset + xfersize;
-		}
-
-		size = BLKSIZE(fs, ip, lbn) - bp->b_resid;
-		if (size < xfersize)
-			xfersize = size;
-
-		error = uiomove((char *)bp->b_data + blkoffset, xfersize, uio);
-		if ((ioflag & IO_VMIO) &&
-		    LIST_FIRST(&bp->b_dep) == NULL) /* in ext2fs? */
-			bp->b_flags |= B_RELBUF;
-
-		if (ioflag & IO_SYNC) {
-			bwrite(bp);
-		} else if (xfersize + blkoffset == fs->s_frag_size) {
-			if ((vp->v_mount->mnt_flag & MNT_NOCLUSTERW) == 0) {
-				bp->b_flags |= B_CLUSTEROK;
-				cluster_write(bp, (off_t)ip->i_size, vp->v_mount->mnt_stat.f_iosize, seqcount);
-			} else {
-				bawrite(bp);
-			}
-		} else {
-			bp->b_flags |= B_CLUSTEROK;
-			bdwrite(bp);
-		}
-		if (error || xfersize == 0)
-			break;
-		ip->i_flag |= IN_CHANGE | IN_UPDATE;
-	}
-	/*
-	 * If we successfully wrote any data, and we are not the superuser
-	 * we clear the setuid and setgid bits as a precaution against
-	 * tampering.
-	 */
-	if (resid > uio->uio_resid && ap->a_cred && ap->a_cred->cr_uid != 0)
-		ip->i_mode &= ~(ISUID | ISGID);
-	if (error) {
-		if (ioflag & IO_UNIT) {
-			EXT2_TRUNCATE(vp, osize, ioflag & IO_SYNC, ap->a_cred);
-			uio->uio_offset -= resid - uio->uio_resid;
-			uio->uio_resid = resid;
-		}
-	} else if (resid > uio->uio_resid && (ioflag & IO_SYNC))
-		error = EXT2_UPDATE(vp, 1);
-	return (error);
-}
diff --git a/sys/gnu/vfs/ext2fs/ext2_subr.c b/sys/gnu/vfs/ext2fs/ext2_subr.c
deleted file mode 100644
index 21148c5e07..0000000000
--- a/sys/gnu/vfs/ext2fs/ext2_subr.c
+++ /dev/null
@@ -1,83 +0,0 @@
-/*
- *  modified for Lites 1.1
- *
- *  Aug 1995, Godmar Back (gback@cs.utah.edu)
- *  University of Utah, Department of Computer Science
- */
-/*
- * Copyright (c) 1982, 1986, 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. 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.
- *
- *	@(#)ext2_subr.c	8.2 (Berkeley) 9/21/93
- * $FreeBSD: src/sys/gnu/ext2fs/ext2_subr.c,v 1.13.2.2 2000/08/03 18:48:27 peter Exp $
- */
-
-#include <sys/param.h>
-
-#include <sys/lock.h>
-#include <sys/systm.h>
-#include <sys/ucred.h>
-#include <sys/vnode.h>
-#include <sys/buf.h>
-
-#include <sys/buf2.h>
-
-#include "quota.h"
-#include "inode.h"
-#include "ext2_extern.h"
-#include "ext2_fs_sb.h"
-#include "fs.h"
-
-/*
- * Return buffer with the contents of block "offset" from the beginning of
- * directory "ip".  If "res" is non-zero, fill it in with a pointer to the
- * remaining space in the directory.
- */
-int
-ext2_blkatoff(struct vnode *vp, off_t offset, char **res, struct buf **bpp)
-{
-	struct inode *ip;
-	struct ext2_sb_info *fs;
-	struct buf *bp;
-	daddr_t lbn;
-	int bsize, error;
-
-	ip = VTOI(vp);
-	fs = ip->i_e2fs;
-	lbn = lblkno(fs, offset);
-	bsize = blksize(fs, ip, lbn);
-
-	*bpp = NULL;
-	if ((error = bread(vp, lblktodoff(fs, lbn), bsize, &bp)) != 0) {
-		brelse(bp);
-		return (error);
-	}
-	if (res)
-		*res = (char *)bp->b_data + blkoff(fs, offset);
-	*bpp = bp;
-	return (0);
-}
diff --git a/sys/gnu/vfs/ext2fs/ext2_vfsops.c b/sys/gnu/vfs/ext2fs/ext2_vfsops.c
deleted file mode 100644
index cb1efcc6e5..0000000000
--- a/sys/gnu/vfs/ext2fs/ext2_vfsops.c
+++ /dev/null
@@ -1,1241 +0,0 @@
-/*
- *  modified for EXT2FS support in Lites 1.1
- *
- *  Aug 1995, Godmar Back (gback@cs.utah.edu)
- *  University of Utah, Department of Computer Science
- */
-/*
- * Copyright (c) 1989, 1991, 1993, 1994
- *	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. 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.
- *
- *	@(#)ffs_vfsops.c	8.8 (Berkeley) 4/18/94
- *	$FreeBSD: src/sys/gnu/ext2fs/ext2_vfsops.c,v 1.63.2.7 2002/07/01 00:18:51 iedowse Exp $
- */
-
-#include "opt_quota.h"
-
-#include <sys/param.h>
-#include <sys/systm.h>
-#include <sys/nlookup.h>
-#include <sys/proc.h>
-#include <sys/priv.h>
-#include <sys/kernel.h>
-#include <sys/vnode.h>
-#include <sys/mount.h>
-#include <sys/buf.h>
-#include <sys/conf.h>
-#include <sys/fcntl.h>
-#include <sys/diskslice.h>
-#include <sys/malloc.h>
-#include <sys/stat.h>
-#include <vm/vm_zone.h>
-
-#include <sys/buf2.h>
-#include <sys/thread2.h>
-
-#include "quota.h"
-#include "dinode.h"
-#include "inode.h"
-#include "ext2_mount.h"
-#include "ext2_extern.h"
-
-#include "fs.h"
-#include "ext2_fs.h"
-#include "ext2_fs_sb.h"
-
-extern struct vop_ops ext2_vnode_vops;
-extern struct vop_ops ext2_spec_vops;
-extern struct vop_ops ext2_fifo_vops;
-
-static int ext2_fhtovp (struct mount *, struct vnode *,
-				struct fid *, struct vnode **);
-static int ext2_flushfiles (struct mount *mp, int flags);
-static int ext2_mount (struct mount *, char *, caddr_t, struct ucred *);
-static int ext2_mountfs (struct vnode *, struct mount *, struct ucred *);
-static int ext2_root(struct mount *, struct vnode **);
-static int ext2_reload (struct mount *mountp, struct ucred *cred);
-static int ext2_sbupdate (struct ext2_mount *, int);
-static int ext2_sync (struct mount *, int);
-static int ext2_unmount (struct mount *, int);
-static int ext2_vget (struct mount *, struct vnode *, ino_t, struct vnode **);
-static int ext2_init(struct vfsconf *);
-static int ext2_vptofh (struct vnode *, struct fid *);
-
-static MALLOC_DEFINE(M_EXT2NODE, "EXT2 node", "EXT2 vnode private part");
-MALLOC_DEFINE(M_EXT2MNT, "EXT2 mount", "EXT2 mount structure");
-
-static struct vfsops ext2fs_vfsops = {
-	.vfs_flags =		0,
-	.vfs_mount =    	ext2_mount,
-	.vfs_unmount =   	ext2_unmount,
-	.vfs_root =     	ext2_root,	/* root inode via vget */
-	.vfs_quotactl =   	ext2_quotactl,	/* quota operations */
-	.vfs_statfs =     	ext2_statfs,
-	.vfs_sync =     	ext2_sync,
-	.vfs_vget =      	ext2_vget,
-	.vfs_fhtovp =     	ext2_fhtovp,
-	.vfs_checkexp =    	ext2_check_export,
-	.vfs_vptofh =     	ext2_vptofh,
-	.vfs_init =     	ext2_init,
-	.vfs_uninit =    	ext2_uninit
-};
-
-VFS_SET(ext2fs_vfsops, ext2fs, 0);
-MODULE_VERSION(ext2fs, 1);
-
-static int ext2fs_inode_hash_lock;
-
-static int	ext2_check_sb_compat (struct ext2_super_block *es,
-					  cdev_t dev, int ronly);
-static int	compute_sb_data (struct vnode *devvp,
-				     struct ext2_super_block *es,
-				     struct ext2_sb_info *fs);
-
-static int
-ext2_root(struct mount *mp, struct vnode **vpp)
-{
-	struct vnode *nvp;
-	int error;
-
-	error = VFS_VGET(mp, NULL, (ino_t)EXT2_ROOTINO, &nvp);
-	if (error)
-		return (error);
-	*vpp = nvp;
-	return (0);
-}
-
-/*
- * Do operations associated with quotas
- */
-int
-ext2_quotactl(struct mount *mp, int cmds, uid_t uid, caddr_t arg,
-	     struct ucred *cred)
-{
-#ifndef QUOTA
-	return (EOPNOTSUPP);
-#else
-	int cmd, type, error;
-
-	type = cmds & SUBCMDMASK;
-	cmd = cmds >> SUBCMDSHIFT;
-
-	if (uid == -1) {
-		switch(type) {
-			case USRQUOTA:
-				uid = cred->cr_ruid;
-				break;
-			case GRPQUOTA:
-				uid = cred->cr_rgid;
-				break;
-			default:
-				return (EINVAL);
-		}
-	}
-
-	/*
-	 * Check permissions.
-	 */
-	switch (cmd) {
-
-	case Q_QUOTAON:
-		error = priv_check_cred(cred, PRIV_UFS_QUOTAON, 0);
-		break;
-
-	case Q_QUOTAOFF:
-		error = priv_check_cred(cred, PRIV_UFS_QUOTAOFF, 0);
-		break;
-
-	case Q_SETQUOTA:
-		error = priv_check_cred(cred, PRIV_VFS_SETQUOTA, 0);
-		break;
-
-	case Q_SETUSE:
-		error = priv_check_cred(cred, PRIV_UFS_SETUSE, 0);
-		break;
-
-	case Q_GETQUOTA:
-		if (uid == cred->cr_ruid)
-			error = 0;
-		else
-			error = priv_check_cred(cred, PRIV_VFS_GETQUOTA, 0);
-		break;
-
-	case Q_SYNC:
-		error = 0;
-		break;
-
-	default:
-		error = EINVAL;
-		break;
-	}
-
-	if (error)
-		return (error);
-
-
-	if ((uint)type >= MAXQUOTAS)
-		return (EINVAL);
-	if (vfs_busy(mp, LK_NOWAIT))
-		return (0);
-
-	switch (cmd) {
-
-	case Q_QUOTAON:
-		error = ext2_quotaon(cred, mp, type, arg);
-		break;
-
-	case Q_QUOTAOFF:
-		error = ext2_quotaoff(mp, type);
-		break;
-
-	case Q_SETQUOTA:
-		error = ext2_setquota(mp, uid, type, arg);
-		break;
-
-	case Q_SETUSE:
-		error = ext2_setuse(mp, uid, type, arg);
-		break;
-
-	case Q_GETQUOTA:
-		error = ext2_getquota(mp, uid, type, arg);
-		break;
-
-	case Q_SYNC:
-		error = ext2_qsync(mp);
-		break;
-
-	default:
-		error = EINVAL;
-		break;
-	}
-	vfs_unbusy(mp);
-	return (error);
-#endif
-}
-
-/*
- * Initial UFS filesystems, done only once.
- */
-static int
-ext2_init(struct vfsconf *vfsp)
-{
-	static int done;
-
-	if (done)
-		return (0);
-	done = 1;
-	ext2_ihashinit();
-#ifdef QUOTA
-	ext2_dqinit();
-#endif
-	return (0);
-}
-
-/*
- * VFS Operations.
- *
- * mount system call
- *
- * Parameters:
- *	data:	this is actually a (struct ext2_args *)
- */
-static int
-ext2_mount(struct mount *mp, char *path, caddr_t data, struct ucred *cred)
-{
-	struct vnode *devvp;
-	struct ext2_args args;
-	struct ext2_mount *ump = NULL;
-	struct ext2_sb_info *fs;
-	size_t size;
-	int error, flags;
-	mode_t accessmode;
-	struct nlookupdata nd;
-
-	if ((error = copyin(data, (caddr_t)&args, sizeof (struct ext2_args))) != 0)
-		return (error);
-
-	/*
-	 * If updating, check whether changing from read-only to
-	 * read/write; if there is no device name, that's all we do.
-	 */
-	if (mp->mnt_flag & MNT_UPDATE) {
-		ump = VFSTOEXT2(mp);
-		fs = ump->um_e2fs;
-		devvp = ump->um_devvp;
-		error = 0;
-		if (fs->s_rd_only == 0 && (mp->mnt_flag & MNT_RDONLY)) {
-			flags = WRITECLOSE;
-			if (mp->mnt_flag & MNT_FORCE)
-				flags |= FORCECLOSE;
-			if (vfs_busy(mp, LK_NOWAIT))
-				return (EBUSY);
-			error = ext2_flushfiles(mp, flags);
-			vfs_unbusy(mp);
-			if (!error && fs->s_wasvalid) {
-				fs->s_es->s_state |= EXT2_VALID_FS;
-				ext2_sbupdate(ump, MNT_WAIT);
-			}
-			fs->s_rd_only = 1;
-			vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
-			VOP_OPEN(devvp, FREAD, FSCRED, NULL);
-			VOP_CLOSE(devvp, FREAD|FWRITE, NULL);
-			vn_unlock(devvp);
-		}
-		if (!error && (mp->mnt_flag & MNT_RELOAD))
-			error = ext2_reload(mp, cred);
-		if (error)
-			return (error);
-		if (ext2_check_sb_compat(fs->s_es, devvp->v_rdev,
-		    (mp->mnt_kern_flag & MNTK_WANTRDWR) == 0) != 0)
-			return (EPERM);
-		if (fs->s_rd_only && (mp->mnt_kern_flag & MNTK_WANTRDWR)) {
-			/*
-			 * If upgrade to read-write by non-root, then verify
-			 * that user has necessary permissions on the device.
-			 */
-			if (cred->cr_uid != 0) {
-				vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
-				error = VOP_EACCESS(devvp, VREAD | VWRITE, cred);
-				if (error) {
-					vn_unlock(devvp);
-					return (error);
-				}
-				vn_unlock(devvp);
-			}
-
-			if ((fs->s_es->s_state & EXT2_VALID_FS) == 0 ||
-			    (fs->s_es->s_state & EXT2_ERROR_FS)) {
-				if (mp->mnt_flag & MNT_FORCE) {
-					kprintf(
-"WARNING: %s was not properly dismounted\n",
-					    fs->fs_fsmnt);
-				} else {
-					kprintf(
-"WARNING: R/W mount of %s denied.  Filesystem is not clean - run fsck\n",
-					    fs->fs_fsmnt);
-					return (EPERM);
-				}
-			}
-			fs->s_es->s_state &= ~EXT2_VALID_FS;
-			ext2_sbupdate(ump, MNT_WAIT);
-			fs->s_rd_only = 0;
-			vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
-			VOP_OPEN(devvp, FREAD|FWRITE, FSCRED, NULL);
-			VOP_CLOSE(devvp, FREAD, NULL);
-			vn_unlock(devvp);
-		}
-		if (args.fspec == NULL) {
-			/*
-			 * Process export requests.
-			 */
-			return (vfs_export(mp, &ump->um_export, &args.export));
-		}
-	}
-	/*
-	 * Not an update, or updating the name: look up the name
-	 * and verify that it refers to a sensible block device.
-	 */
-	devvp = NULL;
-	error = nlookup_init(&nd, args.fspec, UIO_USERSPACE, NLC_FOLLOW);
-	if (error == 0)
-		error = nlookup(&nd);
-	if (error == 0)
-		error = cache_vref(&nd.nl_nch, nd.nl_cred, &devvp);
-	nlookup_done(&nd);
-	if (error)
-		return (error);
-
-	if (!vn_isdisk(devvp, &error)) {
-		vrele(devvp);
-		return (error);
-	}
-
-	/*
-	 * If mount by non-root, then verify that user has necessary
-	 * permissions on the device.
-	 */
-	if (cred->cr_uid != 0) {
-		accessmode = VREAD;
-		if ((mp->mnt_flag & MNT_RDONLY) == 0)
-			accessmode |= VWRITE;
-		vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
-		if ((error = VOP_EACCESS(devvp, accessmode, cred)) != 0) {
-			vput(devvp);
-			return (error);
-		}
-		vn_unlock(devvp);
-	}
-
-	if ((mp->mnt_flag & MNT_UPDATE) == 0) {
-		error = ext2_mountfs(devvp, mp, cred);
-	} else {
-		if (devvp != ump->um_devvp)
-			error = EINVAL;	/* needs translation */
-		else
-			vrele(devvp);
-	}
-	if (error) {
-		vrele(devvp);
-		return (error);
-	}
-	ump = VFSTOEXT2(mp);
-	fs = ump->um_e2fs;
-	copyinstr(path, fs->fs_fsmnt, sizeof(fs->fs_fsmnt) - 1, &size);
-	bzero(fs->fs_fsmnt + size, sizeof(fs->fs_fsmnt) - size);
-	copyinstr(args.fspec, mp->mnt_stat.f_mntfromname, MNAMELEN - 1, &size);
-	bzero(mp->mnt_stat.f_mntfromname + size, MNAMELEN - size);
-	ext2_statfs(mp, &mp->mnt_stat, cred);
-	return (0);
-}
-
-static int
-ext2_check_sb_compat(struct ext2_super_block *es, cdev_t dev, int ronly)
-{
-	if (es->s_magic != EXT2_SUPER_MAGIC) {
-		kprintf("ext2fs: %s: wrong magic number %#x (expected %#x)\n",
-		    devtoname(dev), es->s_magic, EXT2_SUPER_MAGIC);
-		return (1);
-	}
-	if (es->s_rev_level > EXT2_GOOD_OLD_REV) {
-		if (es->s_feature_incompat & ~EXT2_FEATURE_INCOMPAT_SUPP) {
-			kprintf(
-"WARNING: mount of %s denied due to unsupported optional features\n",
-			    devtoname(dev));
-			return (1);
-		}
-		if (!ronly &&
-		    (es->s_feature_ro_compat & ~EXT2_FEATURE_RO_COMPAT_SUPP)) {
-			kprintf(
-"WARNING: R/W mount of %s denied due to unsupported optional features\n",
-			    devtoname(dev));
-			return (1);
-		}
-	}
-	return (0);
-}
-
-/*
- * this computes the fields of the  ext2_sb_info structure from the
- * data in the ext2_super_block structure read in
- */
-static int
-compute_sb_data(struct vnode *devvp, struct ext2_super_block *es,
-		struct ext2_sb_info *fs)
-{
-	int db_count, error;
-	int i, j;
-	int logic_sb_block = 1;	/* XXX for now */
-
-#if 1
-#define V(v)
-#else
-#define V(v)  kprintf(#v"= %d\n", fs->v);
-#endif
-
-	fs->s_blocksize = EXT2_MIN_BLOCK_SIZE << es->s_log_block_size;
-	V(s_blocksize)
-	fs->s_bshift = EXT2_MIN_BLOCK_LOG_SIZE + es->s_log_block_size;
-	V(s_bshift)
-	fs->s_fsbtodb = es->s_log_block_size + 1;
-	V(s_fsbtodb)
-	fs->s_qbmask = fs->s_blocksize - 1;
-	V(s_bmask)
-	fs->s_blocksize_bits = EXT2_BLOCK_SIZE_BITS(es);
-	V(s_blocksize_bits)
-	fs->s_frag_size = EXT2_MIN_FRAG_SIZE << es->s_log_frag_size;
-	V(s_frag_size)
-	if (fs->s_frag_size)
-		fs->s_frags_per_block = fs->s_blocksize / fs->s_frag_size;
-	V(s_frags_per_block)
-	fs->s_blocks_per_group = es->s_blocks_per_group;
-	V(s_blocks_per_group)
-	fs->s_frags_per_group = es->s_frags_per_group;
-	V(s_frags_per_group)
-	fs->s_inodes_per_group = es->s_inodes_per_group;
-	V(s_inodes_per_group)
-	if (es->s_rev_level == EXT2_GOOD_OLD_REV) {
-		fs->s_first_ino = EXT2_GOOD_OLD_FIRST_INO;
-		fs->s_inode_size = EXT2_GOOD_OLD_INODE_SIZE;
-	} else {
-		fs->s_first_ino = es->s_first_ino;
-		fs->s_inode_size = es->s_inode_size;
-		/*
-		 * Simple sanity check for superblock inode size value.
-		 */
-		if (fs->s_inode_size < EXT2_GOOD_OLD_INODE_SIZE ||
-		    fs->s_inode_size > fs->s_blocksize ||
-		    (fs->s_inode_size & (fs->s_inode_size - 1)) != 0) {
-			kprintf("EXT2-fs: invalid inode size %d\n",
-			fs->s_inode_size);
-			return (EIO);
-		}
-        }
-	V(s_first_ino)
-	V(s_inode_size)
-	fs->s_inodes_per_block = fs->s_blocksize / EXT2_INODE_SIZE(fs);
-	V(s_inodes_per_block)
-	fs->s_itb_per_group = fs->s_inodes_per_group /fs->s_inodes_per_block;
-	V(s_itb_per_group)
-	fs->s_desc_per_block = fs->s_blocksize / sizeof (struct ext2_group_desc);
-	V(s_desc_per_block)
-	/* s_resuid / s_resgid ? */
-	fs->s_groups_count = (es->s_blocks_count - es->s_first_data_block +
-			      EXT2_BLOCKS_PER_GROUP(fs) - 1) /
-			      EXT2_BLOCKS_PER_GROUP(fs);
-	V(s_groups_count)
-	db_count = (fs->s_groups_count + EXT2_DESC_PER_BLOCK(fs) - 1) /
-					 EXT2_DESC_PER_BLOCK(fs);
-	fs->s_db_per_group = db_count;
-	V(s_db_per_group)
-
-	fs->s_group_desc = kmalloc(db_count * sizeof (struct buf *),
-				M_EXT2MNT, M_WAITOK);
-
-	/* adjust logic_sb_block */
-	if (fs->s_blocksize > SBSIZE)
-		/*
-		 * Godmar thinks: if the blocksize is greater than 1024,
-		 * then, the superblock is logically part of block zero.
-		 */
-		logic_sb_block = 0;
-
-	for (i = 0; i < db_count; i++) {
-		error = bread(devvp, fsbtodoff(fs, logic_sb_block + i + 1),
-				fs->s_blocksize, &fs->s_group_desc[i]);
-		if (error) {
-			for (j = 0; j < i; j++)
-				brelse(fs->s_group_desc[j]);
-			kfree(fs->s_group_desc, M_EXT2MNT);
-			kprintf("EXT2-fs: unable to read group descriptors (%d)\n", error);
-			return EIO;
-		}
-		/* Set the B_LOCKED flag on the buffer, then brelse() it */
-		LCK_BUF(fs->s_group_desc[i])
-	}
-	if (!ext2_check_descriptors(fs)) {
-		for (j = 0; j < db_count; j++)
-			ULCK_BUF(fs->s_group_desc[j])
-		kfree(fs->s_group_desc, M_EXT2MNT);
-		kprintf("EXT2-fs: (ext2_check_descriptors failure) "
-			"unable to read group descriptors\n");
-		return EIO;
-	}
-
-	for (i = 0; i < EXT2_MAX_GROUP_LOADED; i++) {
-		fs->s_inode_bitmap_number[i] = 0;
-		fs->s_inode_bitmap[i] = NULL;
-		fs->s_block_bitmap_number[i] = 0;
-		fs->s_block_bitmap[i] = NULL;
-	}
-	fs->s_loaded_inode_bitmaps = 0;
-	fs->s_loaded_block_bitmaps = 0;
-	return 0;
-}
-
-/*
- * Reload all incore data for a filesystem (used after running fsck on
- * the root filesystem and finding things to fix). The filesystem must
- * be mounted read-only.
- *
- * Things to do to update the mount:
- *	1) invalidate all cached meta-data.
- *	2) re-read superblock from disk.
- *	3) re-read summary information from disk.
- *	4) invalidate all inactive vnodes.
- *	5) invalidate all cached file data.
- *	6) re-read inode data for all active vnodes.
- */
-static int ext2_reload_scan(struct mount *mp, struct vnode *vp, void *rescan);
-
-struct scaninfo {
-	int rescan;
-	int allerror;
-	int waitfor;
-	struct vnode *devvp;
-	struct ext2_sb_info *fs;
-};
-
-static int
-ext2_reload(struct mount *mountp, struct ucred *cred)
-{
-	struct vnode *devvp;
-	struct buf *bp;
-	struct ext2_super_block *es;
-	struct ext2_sb_info *fs;
-	int error;
-	struct scaninfo scaninfo;
-
-	if ((mountp->mnt_flag & MNT_RDONLY) == 0)
-		return (EINVAL);
-	/*
-	 * Step 1: invalidate all cached meta-data.
-	 */
-	devvp = VFSTOEXT2(mountp)->um_devvp;
-	if (vinvalbuf(devvp, 0, 0, 0))
-		panic("ext2_reload: dirty1");
-	/*
-	 * Step 2: re-read superblock from disk.
-	 * constants have been adjusted for ext2
-	 */
-	if ((error = bread(devvp, SBOFF, SBSIZE, &bp)) != 0)
-		return (error);
-	es = (struct ext2_super_block *)bp->b_data;
-	if (ext2_check_sb_compat(es, devvp->v_rdev, 0) != 0) {
-		brelse(bp);
-		return (EIO);		/* XXX needs translation */
-	}
-	fs = VFSTOEXT2(mountp)->um_e2fs;
-	bcopy(bp->b_data, fs->s_es, sizeof(struct ext2_super_block));
-
-	if((error = compute_sb_data(devvp, es, fs)) != 0) {
-		brelse(bp);
-		return error;
-	}
-#ifdef UNKLAR
-	if (fs->fs_sbsize < SBSIZE)
-		bp->b_flags |= B_INVAL;
-#endif
-	brelse(bp);
-
-	scaninfo.rescan = 1;
-	scaninfo.devvp = devvp;
-	scaninfo.fs = fs;
-	while (error == 0 && scaninfo.rescan) {
-	    scaninfo.rescan = 0;
-	    error = vmntvnodescan(mountp, VMSC_GETVX,
-				  NULL, ext2_reload_scan, &scaninfo);
-	}
-	return(error);
-}
-
-static int
-ext2_reload_scan(struct mount *mp, struct vnode *vp, void *data)
-{
-	struct scaninfo *info = data;
-	struct inode *ip;
-	struct buf *bp;
-	int error;
-
-	/*
-	 * Try to recycle
-	 */
-	if (vrecycle(vp))
-		return(0);
-
-	/*
-	 * Step 1: invalidate all cached file data.
-	 */
-	if (vinvalbuf(vp, 0, 0, 0))
-		panic("ext2_reload: dirty2");
-	/*
-	 * Step 2: re-read inode data for all active vnodes.
-	 */
-	ip = VTOI(vp);
-	error = bread(info->devvp,
-		      fsbtodoff(info->fs, ino_to_fsba(info->fs, ip->i_number)),
-		      (int)info->fs->s_blocksize, &bp);
-	if (error)
-		return (error);
-	ext2_ei2di((struct ext2_inode *) ((char *)bp->b_data +
-	    EXT2_INODE_SIZE(info->fs) * ino_to_fsbo(info->fs, ip->i_number)),
-	    &ip->i_din);
-	brelse(bp);
-	return(0);
-}
-
-/*
- * Common code for mount and mountroot
- */
-static int
-ext2_mountfs(struct vnode *devvp, struct mount *mp, struct ucred *cred)
-{
-	struct ext2_mount *ump;
-	struct buf *bp;
-	struct ext2_sb_info *fs;
-	struct ext2_super_block *es;
-	cdev_t dev;
-	int error, i;
-	int ronly;
-
-	/*
-	 * Disallow multiple mounts of the same device.
-	 * Disallow mounting of a device that is currently in use
-	 * (except for root, which might share swap device for miniroot).
-	 * Flush out any old buffers remaining from a previous use.
-	 */
-	if ((error = vfs_mountedon(devvp)) != 0)
-		return (error);
-	if (vcount(devvp) > 0)
-		return (EBUSY);
-	if ((error = vinvalbuf(devvp, V_SAVE, 0, 0)) != 0)
-		return (error);
-#ifdef READONLY
-/* turn on this to force it to be read-only */
-	mp->mnt_flag |= MNT_RDONLY;
-#endif
-
-	ronly = (mp->mnt_flag & MNT_RDONLY) != 0;
-	vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
-	error = VOP_OPEN(devvp, ronly ? FREAD : FREAD|FWRITE, FSCRED, NULL);
-	vn_unlock(devvp);
-	if (error)
-		return (error);
-	dev = devvp->v_rdev;
-	if (dev->si_iosize_max != 0)
-		mp->mnt_iosize_max = dev->si_iosize_max;
-	if (mp->mnt_iosize_max > MAXPHYS)
-		mp->mnt_iosize_max = MAXPHYS;
-
-	bp = NULL;
-	ump = NULL;
-	if ((error = bread(devvp, SBOFF, SBSIZE, &bp)) != 0)
-		goto out;
-	es = (struct ext2_super_block *)bp->b_data;
-	if (ext2_check_sb_compat(es, dev, ronly) != 0) {
-		error = EINVAL;		/* XXX needs translation */
-		goto out;
-	}
-	if ((es->s_state & EXT2_VALID_FS) == 0 ||
-	    (es->s_state & EXT2_ERROR_FS)) {
-		if (ronly || (mp->mnt_flag & MNT_FORCE)) {
-			kprintf(
-"WARNING: Filesystem was not properly dismounted\n");
-		} else {
-			kprintf(
-"WARNING: R/W mount denied.  Filesystem is not clean - run fsck\n");
-			error = EPERM;
-			goto out;
-		}
-	}
-	ump = kmalloc(sizeof *ump, M_EXT2MNT, M_WAITOK | M_ZERO);
-	ump->um_malloctype = M_EXT2NODE;
-	ump->um_blkatoff = ext2_blkatoff;
-	ump->um_truncate = ext2_truncate;
-	ump->um_update = ext2_update;
-	ump->um_valloc = ext2_valloc;
-	ump->um_vfree = ext2_vfree;
-	/* I don't know whether this is the right strategy. Note that
-	   we dynamically allocate both a ext2_sb_info and a ext2_super_block
-	   while Linux keeps the super block in a locked buffer
-	 */
-	ump->um_e2fs = kmalloc(sizeof(struct ext2_sb_info),
-		M_EXT2MNT, M_WAITOK);
-	ump->um_e2fs->s_es = kmalloc(sizeof(struct ext2_super_block),
-		M_EXT2MNT, M_WAITOK);
-	bcopy(es, ump->um_e2fs->s_es, (u_int)sizeof(struct ext2_super_block));
-	if ((error = compute_sb_data(devvp, ump->um_e2fs->s_es, ump->um_e2fs)))
-		goto out;
-	/*
-	 * We don't free the group descriptors allocated by compute_sb_data()
-	 * until ext2_unmount().  This is OK since the mount will succeed.
-	 */
-	brelse(bp);
-	bp = NULL;
-	fs = ump->um_e2fs;
-	fs->s_rd_only = ronly;	/* ronly is set according to mnt_flags */
-	/* if the fs is not mounted read-only, make sure the super block is
-	   always written back on a sync()
-	 */
-	fs->s_wasvalid = fs->s_es->s_state & EXT2_VALID_FS ? 1 : 0;
-	if (ronly == 0) {
-		fs->s_dirt = 1;		/* mark it modified */
-		fs->s_es->s_state &= ~EXT2_VALID_FS;	/* set fs invalid */
-	}
-	mp->mnt_data = (qaddr_t)ump;
-	mp->mnt_stat.f_fsid.val[0] = devid_from_dev(dev);
-	mp->mnt_stat.f_fsid.val[1] = mp->mnt_vfc->vfc_typenum;
-	mp->mnt_maxsymlinklen = EXT2_MAXSYMLINKLEN;
-	mp->mnt_flag |= MNT_LOCAL;
-	ump->um_mountp = mp;
-	ump->um_dev = dev;
-	ump->um_devvp = devvp;
-	/* setting those two parameters allows us to use
-	   ext2_bmap w/o changse !
-	*/
-	ump->um_nindir = EXT2_ADDR_PER_BLOCK(fs);
-	ump->um_bptrtodb = fs->s_es->s_log_block_size + 1;
-	ump->um_seqinc = EXT2_FRAGS_PER_BLOCK(fs);
-	for (i = 0; i < MAXQUOTAS; i++)
-		ump->um_quotas[i] = NULLVP;
-	dev->si_mountpoint = mp;
-
-	vfs_add_vnodeops(mp, &ext2_vnode_vops, &mp->mnt_vn_norm_ops);
-	vfs_add_vnodeops(mp, &ext2_spec_vops, &mp->mnt_vn_spec_ops);
-	vfs_add_vnodeops(mp, &ext2_fifo_vops, &mp->mnt_vn_fifo_ops);
-
-	if (ronly == 0)
-		ext2_sbupdate(ump, MNT_WAIT);
-	return (0);
-out:
-	if (bp)
-		brelse(bp);
-	vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
-	VOP_CLOSE(devvp, ronly ? FREAD : FREAD|FWRITE, NULL);
-	vn_unlock(devvp);
-	if (ump) {
-		kfree(ump->um_e2fs->s_es, M_EXT2MNT);
-		kfree(ump->um_e2fs, M_EXT2MNT);
-		kfree(ump, M_EXT2MNT);
-		mp->mnt_data = (qaddr_t)0;
-	}
-	return (error);
-}
-
-/*
- * unmount system call
- */
-static int
-ext2_unmount(struct mount *mp, int mntflags)
-{
-	struct ext2_mount *ump;
-	struct ext2_sb_info *fs;
-	int error, flags, ronly, i;
-
-	flags = 0;
-	if (mntflags & MNT_FORCE) {
-		if (mp->mnt_flag & MNT_ROOTFS)
-			return (EINVAL);
-		flags |= FORCECLOSE;
-	}
-	if ((error = ext2_flushfiles(mp, flags)) != 0)
-		return (error);
-	ump = VFSTOEXT2(mp);
-	fs = ump->um_e2fs;
-	ronly = fs->s_rd_only;
-	if (ronly == 0) {
-		if (fs->s_wasvalid)
-			fs->s_es->s_state |= EXT2_VALID_FS;
-		ext2_sbupdate(ump, MNT_WAIT);
-	}
-
-	/* release buffers containing group descriptors */
-	for(i = 0; i < fs->s_db_per_group; i++)
-		ULCK_BUF(fs->s_group_desc[i])
-	kfree(fs->s_group_desc, M_EXT2MNT);
-
-	/* release cached inode/block bitmaps */
-        for (i = 0; i < EXT2_MAX_GROUP_LOADED; i++)
-                if (fs->s_inode_bitmap[i])
-			ULCK_BUF(fs->s_inode_bitmap[i])
-
-        for (i = 0; i < EXT2_MAX_GROUP_LOADED; i++)
-                if (fs->s_block_bitmap[i])
-			ULCK_BUF(fs->s_block_bitmap[i])
-
-	ump->um_devvp->v_rdev->si_mountpoint = NULL;
-
-	vn_lock(ump->um_devvp, LK_EXCLUSIVE | LK_RETRY);
-	error = VOP_CLOSE(ump->um_devvp, ronly ? FREAD : FREAD|FWRITE, NULL);
-	vn_unlock(ump->um_devvp);
-
-	vrele(ump->um_devvp);
-	kfree(fs->s_es, M_EXT2MNT);
-	kfree(fs, M_EXT2MNT);
-	kfree(ump, M_EXT2MNT);
-	mp->mnt_data = (qaddr_t)0;
-	mp->mnt_flag &= ~MNT_LOCAL;
-	return (error);
-}
-
-/*
- * Flush out all the files in a filesystem.
- */
-static int
-ext2_flushfiles(struct mount *mp, int flags)
-{
-	struct ext2_mount *ump;
-	int error;
-#ifdef QUOTA
-	int i;
-#endif
-
-	ump = VFSTOEXT2(mp);
-#ifdef QUOTA
-	if (mp->mnt_flag & MNT_QUOTA) {
-		if ((error = vflush(mp, 0, SKIPSYSTEM|flags)) != 0)
-			return (error);
-		for (i = 0; i < MAXQUOTAS; i++) {
-			if (ump->um_quotas[i] == NULLVP)
-				continue;
-			ext2_quotaoff(mp, i);
-		}
-		/*
-		 * Here we fall through to vflush again to ensure
-		 * that we have gotten rid of all the system vnodes.
-		 */
-	}
-#endif
-	error = vflush(mp, 0, flags);
-	return (error);
-}
-
-/*
- * Go through the disk queues to initiate sandbagged IO;
- * go through the inodes to write those that have been modified;
- * initiate the writing of the super block if it has been modified.
- *
- * Note: we are always called with the filesystem marked `MPBUSY'.
- */
-
-static int ext2_sync_scan(struct mount *mp, struct vnode *vp, void *data);
-
-static int
-ext2_sync(struct mount *mp, int waitfor)
-{
-	struct ext2_mount *ump = VFSTOEXT2(mp);
-	struct ext2_sb_info *fs;
-	struct scaninfo scaninfo;
-	int error;
-
-	fs = ump->um_e2fs;
-	if (fs->s_dirt != 0 && fs->s_rd_only != 0) {		/* XXX */
-		kprintf("fs = %s\n", fs->fs_fsmnt);
-		panic("ext2_sync: rofs mod");
-	}
-
-	/*
-	 * Write back each (modified) inode.
-	 */
-	scaninfo.allerror = 0;
-	scaninfo.rescan = 1;
-	scaninfo.waitfor = waitfor;
-	while (scaninfo.rescan) {
-		scaninfo.rescan = 0;
-		vmntvnodescan(mp, VMSC_GETVP|VMSC_NOWAIT,
-			      NULL, ext2_sync_scan, &scaninfo);
-	}
-
-	/*
-	 * Force stale file system control information to be flushed.
-	 */
-	if ((waitfor & MNT_LAZY) == 0) {
-		vn_lock(ump->um_devvp, LK_EXCLUSIVE | LK_RETRY);
-		if ((error = VOP_FSYNC(ump->um_devvp, waitfor, 0)) != 0)
-			scaninfo.allerror = error;
-		vn_unlock(ump->um_devvp);
-	}
-#ifdef QUOTA
-	ext2_qsync(mp);
-#endif
-	/*
-	 * Write back modified superblock.
-	 */
-	if (fs->s_dirt != 0) {
-		fs->s_dirt = 0;
-		fs->s_es->s_wtime = time_second;
-		if ((error = ext2_sbupdate(ump, waitfor)) != 0)
-			scaninfo.allerror = error;
-	}
-	return (scaninfo.allerror);
-}
-
-static int
-ext2_sync_scan(struct mount *mp, struct vnode *vp, void *data)
-{
-	struct scaninfo *info = data;
-	struct inode *ip;
-	int error;
-
-	ip = VTOI(vp);
-	if (vp->v_type == VNON ||
-	    ((ip->i_flag &
-	    (IN_ACCESS | IN_CHANGE | IN_MODIFIED | IN_UPDATE)) == 0 &&
-	    (RB_EMPTY(&vp->v_rbdirty_tree) || (info->waitfor & MNT_LAZY)))) {
-		return(0);
-	}
-	if ((error = VOP_FSYNC(vp, info->waitfor, 0)) != 0)
-		info->allerror = error;
-	return(0);
-}
-
-/*
- * Look up a EXT2FS dinode number to find its incore vnode, otherwise read it
- * in from disk.  If it is in core, wait for the lock bit to clear, then
- * return the inode locked.  Detection and handling of mount points must be
- * done by the calling routine.
- */
-static int
-ext2_vget(struct mount *mp, struct vnode *dvp, ino_t ino, struct vnode **vpp)
-{
-	struct ext2_sb_info *fs;
-	struct inode *ip;
-	struct ext2_mount *ump;
-	struct buf *bp;
-	struct vnode *vp;
-	cdev_t dev;
-	int i, error;
-	int used_blocks;
-
-	ump = VFSTOEXT2(mp);
-	dev = ump->um_dev;
-restart:
-	if ((*vpp = ext2_ihashget(dev, ino)) != NULL)
-		return (0);
-
-	/*
-	 * Lock out the creation of new entries in the FFS hash table in
-	 * case getnewvnode() or MALLOC() blocks, otherwise a duplicate
-	 * may occur!
-	 */
-	if (ext2fs_inode_hash_lock) {
-		while (ext2fs_inode_hash_lock) {
-			ext2fs_inode_hash_lock = -1;
-			tsleep(&ext2fs_inode_hash_lock, 0, "e2vget", 0);
-		}
-		goto restart;
-	}
-	ext2fs_inode_hash_lock = 1;
-
-	/*
-	 * If this MALLOC() is performed after the getnewvnode()
-	 * it might block, leaving a vnode with a NULL v_data to be
-	 * found by ext2_sync() if a sync happens to fire right then,
-	 * which will cause a panic because ext2_sync() blindly
-	 * dereferences vp->v_data (as well it should).
-	 */
-	ip = kmalloc(sizeof(struct inode), M_EXT2NODE, M_WAITOK);
-
-	/* Allocate a new vnode/inode. */
-	if ((error = getnewvnode(VT_EXT2FS, mp, &vp, 0, LK_CANRECURSE)) != 0) {
-		if (ext2fs_inode_hash_lock < 0)
-			wakeup(&ext2fs_inode_hash_lock);
-		ext2fs_inode_hash_lock = 0;
-		*vpp = NULL;
-		kfree(ip, M_EXT2NODE);
-		return (error);
-	}
-	bzero((caddr_t)ip, sizeof(struct inode));
-	vp->v_data = ip;
-	ip->i_vnode = vp;
-	ip->i_e2fs = fs = ump->um_e2fs;
-	ip->i_dev = dev;
-	ip->i_number = ino;
-#ifdef QUOTA
-	for (i = 0; i < MAXQUOTAS; i++)
-		ip->i_dquot[i] = NODQUOT;
-#endif
-	/*
-	 * Put it onto its hash chain.  Since our vnode is locked, other
-	 * requests for this inode will block if they arrive while we are
-	 * sleeping waiting for old data structures to be purged or for the
-	 * contents of the disk portion of this inode to be read.
-	 */
-	ext2_ihashins(ip);
-
-	if (ext2fs_inode_hash_lock < 0)
-		wakeup(&ext2fs_inode_hash_lock);
-	ext2fs_inode_hash_lock = 0;
-
-	/* Read in the disk contents for the inode, copy into the inode. */
-#if 0
-kprintf("ext2_vget(%d) dbn= %d ", ino, fsbtodb(fs, ino_to_fsba(fs, ino)));
-#endif
-	error = bread(ump->um_devvp, fsbtodoff(fs, ino_to_fsba(fs, ino)),
-		      (int)fs->s_blocksize, &bp);
-	if (error) {
-		/*
-		 * The inode does not contain anything useful, so it would
-		 * be misleading to leave it on its hash chain. With mode
-		 * still zero, it will be unlinked and returned to the free
-		 * list by vput().
-		 */
-		brelse(bp);
-		vx_put(vp);
-		*vpp = NULL;
-		return (error);
-	}
-	/* convert ext2 inode to dinode */
-	ext2_ei2di((struct ext2_inode *) ((char *)bp->b_data + EXT2_INODE_SIZE(fs) *
-			ino_to_fsbo(fs, ino)), &ip->i_din);
-	ip->i_block_group = ino_to_cg(fs, ino);
-	ip->i_next_alloc_block = 0;
-	ip->i_next_alloc_goal = 0;
-	ip->i_prealloc_count = 0;
-	ip->i_prealloc_block = 0;
-        /* now we want to make sure that block pointers for unused
-           blocks are zeroed out - ext2_balloc depends on this
-	   although for regular files and directories only
-	*/
-	if(S_ISDIR(ip->i_mode) || S_ISREG(ip->i_mode)) {
-		used_blocks = (ip->i_size+fs->s_blocksize-1) / fs->s_blocksize;
-		for(i = used_blocks; i < EXT2_NDIR_BLOCKS; i++)
-			ip->i_db[i] = 0;
-	}
-#if 0
-	ext2_print_inode(ip);
-#endif
-	bqrelse(bp);
-
-	/*
-	 * Initialize the vnode from the inode, check for aliases.
-	 * Note that the underlying vnode may have changed.
-	 */
-	if ((error = ext2_vinit(mp, &vp)) != 0) {
-		vx_put(vp);
-		*vpp = NULL;
-		return (error);
-	}
-
-	/*
-	 * Finish inode initialization now that aliasing has been resolved.
-	 */
-	ip->i_devvp = ump->um_devvp;
-	vref(ip->i_devvp);
-	/*
-	 * Set up a generation number for this inode if it does not
-	 * already have one. This should only happen on old filesystems.
-	 */
-	if (ip->i_gen == 0) {
-		ip->i_gen = krandom() / 2 + 1;
-		if ((vp->v_mount->mnt_flag & MNT_RDONLY) == 0)
-			ip->i_flag |= IN_MODIFIED;
-	}
-	/*
-	 * Return the locked and refd vnode.
-	 */
-	vx_downgrade(vp);	/* downgrade VX lock to VN lock */
-	*vpp = vp;
-
-	return (0);
-}
-
-/*
- * File handle to vnode
- *
- * Have to be really careful about stale file handles:
- * - check that the inode number is valid
- * - call ext2_vget() to get the locked inode
- * - check for an unallocated inode (i_mode == 0)
- * - check that the given client host has export rights and return
- *   those rights via. exflagsp and credanonp
- */
-static int
-ext2_fhtovp(struct mount *mp, struct vnode *rootvp,
-	    struct fid *fhp, struct vnode **vpp)
-{
-	struct ufid *ufhp;
-	struct ext2_sb_info *fs;
-	struct inode *ip;
-        struct vnode *nvp;
-        int error;
-
-	ufhp = (struct ufid *)fhp;
-	fs = VFSTOEXT2(mp)->um_e2fs;
-	if (ufhp->ufid_ino < EXT2_ROOTINO ||
-	    ufhp->ufid_ino > fs->s_groups_count * fs->s_es->s_inodes_per_group)
-		return (ESTALE);
-
-	error = VFS_VGET(mp, rootvp, ufhp->ufid_ino, &nvp);
-	if (error) {
-		*vpp = NULLVP;
-		return (error);
-	}
-	ip = VTOI(nvp);
-	if (ip->i_mode == 0 ||
-	    ip->i_gen != ufhp->ufid_gen ||
-	    (VFSTOEXT2(mp)->um_i_effnlink_valid ? ip->i_effnlink :
-	    ip->i_nlink) <= 0) {
-		vput(nvp);
-		*vpp = NULLVP;
-		return (ESTALE);
-	}
-	*vpp = nvp;
-	return (0);
-}
-
-/*
- * Vnode pointer to File handle
- */
-/* ARGSUSED */
-static int
-ext2_vptofh(struct vnode *vp, struct fid *fhp)
-{
-	struct inode *ip;
-	struct ufid *ufhp;
-
-	ip = VTOI(vp);
-	ufhp = (struct ufid *)fhp;
-	ufhp->ufid_len = sizeof(struct ufid);
-	ufhp->ufid_ino = ip->i_number;
-	ufhp->ufid_gen = ip->i_gen;
-	return (0);
-}
-
-/*
- * This is the generic part of fhtovp called after the underlying
- * filesystem has validated the file handle.
- *
- * Verify that a host should have access to a filesystem.
- */
-int
-ext2_check_export(struct mount *mp, struct sockaddr *nam, int *exflagsp,
-                 struct ucred **credanonp)
-{
-	struct netcred *np;
-	struct ext2_mount *ump;
-
-	ump = VFSTOEXT2(mp);
-	/*
-	 * Get the export permission structure for this <mp, client> tuple.
-	 */
-	np = vfs_export_lookup(mp, &ump->um_export, nam);
-	if (np == NULL)
-		return (EACCES);
-
-	*exflagsp = np->netc_exflags;
-	*credanonp = &np->netc_anon;
-	return (0);
-}
-
-/*
- * Write a superblock and associated information back to disk.
- */
-static int
-ext2_sbupdate(struct ext2_mount *mp, int waitfor)
-{
-	struct ext2_sb_info *fs = mp->um_e2fs;
-	struct ext2_super_block *es = fs->s_es;
-	struct buf *bp;
-	int error = 0;
-/*
-kprintf("\nupdating superblock, waitfor=%s\n", waitfor == MNT_WAIT ? "yes":"no");
-*/
-	bp = getblk(mp->um_devvp, SBOFF, SBSIZE, 0, 0);
-	bcopy((caddr_t)es, bp->b_data, (u_int)sizeof(struct ext2_super_block));
-	if (waitfor == MNT_WAIT)
-		error = bwrite(bp);
-	else
-		bawrite(bp);
-
-	/*
-	 * The buffers for group descriptors, inode bitmaps and block bitmaps
-	 * are not busy at this point and are (hopefully) written by the
-	 * usual sync mechanism. No need to write them here
-	 */
-
-	return (error);
-}
diff --git a/sys/gnu/vfs/ext2fs/ext2_vnops.c b/sys/gnu/vfs/ext2fs/ext2_vnops.c
deleted file mode 100644
index 2b81184b32..0000000000
--- a/sys/gnu/vfs/ext2fs/ext2_vnops.c
+++ /dev/null
@@ -1,2079 +0,0 @@
-/*
- *  modified for EXT2FS support in Lites 1.1
- *
- *  Aug 1995, Godmar Back (gback@cs.utah.edu)
- *  University of Utah, Department of Computer Science
- */
-/*
- * Copyright (c) 1982, 1986, 1989, 1993
- *	The Regents of the University of California.  All rights reserved.
- * (c) UNIX System Laboratories, Inc.
- * All or some portions of this file are derived from material licensed
- * to the University of California by American Telephone and Telegraph
- * Co. or Unix System Laboratories, Inc. and are reproduced herein with
- * the permission of UNIX System Laboratories, Inc.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. 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.
- *
- *	@(#)ufs_vnops.c 8.27 (Berkeley) 5/27/95
- *	@(#)ext2_vnops.c	8.7 (Berkeley) 2/3/94
- * $FreeBSD: src/sys/gnu/ext2fs/ext2_vnops.c,v 1.51.2.2 2003/01/02 17:26:18 bde Exp $
- */
-
-#include "opt_quota.h"
-#include "opt_suiddir.h"
-
-#include <sys/param.h>
-#include <sys/systm.h>
-#include <sys/uio.h>
-#include <sys/resourcevar.h>
-#include <sys/kernel.h>
-#include <sys/stat.h>
-#include <sys/fcntl.h>
-#include <sys/buf.h>
-#include <sys/proc.h>
-#include <sys/priv.h>
-#include <sys/mount.h>
-#include <sys/time.h>
-#include <sys/vnode.h>
-#include <sys/dirent.h>
-#include <sys/lockf.h>
-#include <sys/event.h>
-#include <sys/conf.h>
-#include <sys/file.h>
-#include <sys/jail.h>
-#include <sys/namei.h>
-#include <sys/signalvar.h>
-#include <sys/unistd.h>
-
-#include <vm/vm.h>
-#include <vm/vm_extern.h>
-#include <vm/vm_zone.h>
-#include <vm/vnode_pager.h>
-
-#include <sys/buf2.h>
-
-#include <vfs/fifofs/fifo.h>
-
-#include "dir.h"
-#include "quota.h"
-#include "inode.h"
-#include "ext2_mount.h"
-#include "ext2_fs_sb.h"
-#include "fs.h"
-#include "ext2_extern.h"
-#include "ext2_fs.h"
-
-static int ext2_access (struct vop_access_args *);
-static int ext2_advlock (struct vop_advlock_args *);
-static int ext2_chmod (struct vnode *, int, struct ucred *);
-static int ext2_chown (struct vnode *, uid_t, gid_t, struct ucred *);
-static int ext2_close (struct vop_close_args *);
-static int ext2_getattr (struct vop_getattr_args *);
-static int ext2_makeinode (int mode, struct vnode *, struct vnode **, struct componentname *);
-static int ext2_open (struct vop_open_args *);
-static int ext2_pathconf (struct vop_pathconf_args *);
-static int ext2_print (struct vop_print_args *);
-static int ext2_readlink (struct vop_readlink_args *);
-static int ext2_setattr (struct vop_setattr_args *);
-static int ext2_strategy (struct vop_strategy_args *);
-static int ext2_whiteout (struct vop_old_whiteout_args *);
-static int filt_ext2read (struct knote *kn, long hint);
-static int filt_ext2write (struct knote *kn, long hint);
-static int filt_ext2vnode (struct knote *kn, long hint);
-static void filt_ext2detach (struct knote *kn);
-static int ext2_kqfilter (struct vop_kqfilter_args *ap);
-static int ext2fifo_close (struct vop_close_args *);
-static int ext2fifo_kqfilter (struct vop_kqfilter_args *);
-static int ext2fifo_read (struct vop_read_args *);
-static int ext2fifo_write (struct vop_write_args *);
-
-static int ext2_fsync (struct vop_fsync_args *);
-static int ext2_read (struct vop_read_args *);
-static int ext2_write (struct vop_write_args *);
-static int ext2_remove (struct vop_old_remove_args *);
-static int ext2_link (struct vop_old_link_args *);
-static int ext2_rename (struct vop_old_rename_args *);
-static int ext2_mkdir (struct vop_old_mkdir_args *);
-static int ext2_rmdir (struct vop_old_rmdir_args *);
-static int ext2_create (struct vop_old_create_args *);
-static int ext2_mknod (struct vop_old_mknod_args *);
-static int ext2_symlink (struct vop_old_symlink_args *);
-
-#include "ext2_readwrite.c"
-
-#define VN_KNOTE(vp, b) \
-	KNOTE(&vp->v_pollinfo.vpi_kqinfo.ki_note, (b))
-
-#define OFSFMT(vp)		((vp)->v_mount->mnt_maxsymlinklen <= 0)
-
-/*
- * A virgin directory (no blushing please).
- * Note that the type and namlen fields are reversed relative to ufs.
- * Also, we don't use `struct odirtemplate', since it would just cause
- * endianness problems.
- */
-static struct dirtemplate ext2_mastertemplate = {
-	0, 12, 1, EXT2_FT_DIR, ".",
-	0, DIRBLKSIZ - 12, 2, EXT2_FT_DIR, ".."
-};
-static struct dirtemplate ext2_omastertemplate = {
-	0, 12, 1, EXT2_FT_UNKNOWN, ".",
-	0, DIRBLKSIZ - 12, 2, EXT2_FT_UNKNOWN, ".."
-};
-
-/*
- * Create a regular file
- *
- * ext2_create(struct vnode *a_dvp, struct vnode **a_vpp,
- *	       struct componentname *a_cnp, struct vattr *a_vap)
- */
-static int
-ext2_create(struct vop_old_create_args *ap)
-{
-	int error;
-
-	error =
-	    ext2_makeinode(MAKEIMODE(ap->a_vap->va_type, ap->a_vap->va_mode),
-	    ap->a_dvp, ap->a_vpp, ap->a_cnp);
-	if (error)
-		return (error);
-	return (0);
-}
-
-/*
- * Synch an open file.
- *
- * ext2_fsync(struct vnode *a_vp, struct ucred *a_cred, int a_waitfor,
- *	      struct proc *a_p)
- */
-/* ARGSUSED */
-
-static int ext2_fsync_bp(struct buf *bp, void *data);
-
-struct ext2_fsync_bp_info {
-	struct vnode *vp;
-	int waitfor;
-};
-
-static int
-ext2_fsync(struct vop_fsync_args *ap)
-{
-	struct ext2_fsync_bp_info info;
-	struct vnode *vp = ap->a_vp;
-	int count;
-
-	/*
-	 * XXX why is all this fs specific?
-	 */
-
-	/*
-	 * Flush all dirty buffers associated with a vnode.
-	 */
-	ext2_discard_prealloc(VTOI(vp));
-
-	lwkt_gettoken(&vp->v_token);
-	info.vp = vp;
-loop:
-	info.waitfor = ap->a_waitfor;
-	count = RB_SCAN(buf_rb_tree, &vp->v_rbdirty_tree, NULL,
-			ext2_fsync_bp, &info);
-	if (count)
-		goto loop;
-
-	if (ap->a_waitfor == MNT_WAIT) {
-		bio_track_wait(&vp->v_track_write, 0, 0);
-#ifdef DIAGNOSTIC
-		if (!RB_EMPTY(&vp->v_rbdirty_tree)) {
-			vprint("ext2_fsync: dirty", vp);
-			goto loop;
-		}
-#endif
-	}
-	lwkt_reltoken(&vp->v_token);
-	return (EXT2_UPDATE(ap->a_vp, ap->a_waitfor == MNT_WAIT));
-}
-
-static int
-ext2_fsync_bp(struct buf *bp, void *data)
-{
-	struct ext2_fsync_bp_info *info = data;
-
-	if (BUF_LOCK(bp, LK_EXCLUSIVE | LK_NOWAIT))
-		return(0);
-	if ((bp->b_flags & B_DELWRI) == 0)
-		panic("ext2_fsync: not dirty");
-	bremfree(bp);
-
-	/*
-	 * Wait for I/O associated with indirect blocks to complete,
-	 * since there is no way to quickly wait for them below.
-	 */
-	if (bp->b_vp == info->vp || (info->waitfor & MNT_NOWAIT))
-		bawrite(bp);
-	else
-		bwrite(bp);
-	return(1);
-}
-
-/*
- * Mknod vnode call
- *
- * ext2_mknod(struct vnode *a_dvp, struct vnode **a_vpp,
- *	      struct componentname *a_cnp, struct vattr *a_vap)
- */
-/* ARGSUSED */
-static int
-ext2_mknod(struct vop_old_mknod_args *ap)
-{
-	struct vattr *vap = ap->a_vap;
-	struct vnode **vpp = ap->a_vpp;
-	struct inode *ip;
-	ino_t ino;
-	int error;
-
-	if (vap->va_rmajor != VNOVAL &&
-	    makeudev(vap->va_rmajor, vap->va_rminor) == NOUDEV) {
-		return (EINVAL);
-	}
-
-	error = ext2_makeinode(MAKEIMODE(vap->va_type, vap->va_mode),
-	    ap->a_dvp, vpp, ap->a_cnp);
-	if (error)
-		return (error);
-	ip = VTOI(*vpp);
-	ip->i_flag |= IN_ACCESS | IN_CHANGE | IN_UPDATE;
-	if (vap->va_rmajor != VNOVAL) {
-		/*
-		 * Want to be able to use this to make badblock
-		 * inodes, so don't truncate the dev number.
-		 */
-		ip->i_rdev = makeudev(vap->va_rmajor, vap->va_rminor);
-	}
-	/*
-	 * Remove inode, then reload it through VFS_VGET so it is
-	 * checked to see if it is an alias of an existing entry in
-	 * the inode cache.
-	 */
-	(*vpp)->v_type = VNON;
-	ino = ip->i_number;	/* Save this before vgone() invalidates ip. */
-	vgone_vxlocked(*vpp);
-	vput(*vpp);
-	error = VFS_VGET(ap->a_dvp->v_mount, NULL, ino, vpp);
-	if (error) {
-		*vpp = NULL;
-		return (error);
-	}
-	return (0);
-}
-
-/*
- * ext2_remove(struct vnode *a_dvp, struct vnode *a_vp,
- *	       struct componentname *a_cnp)
- */
-static int
-ext2_remove(struct vop_old_remove_args *ap)
-{
-	struct inode *ip;
-	struct vnode *vp = ap->a_vp;
-	struct vnode *dvp = ap->a_dvp;
-	int error;
-
-	ip = VTOI(vp);
-	if ((ip->i_flags & (NOUNLINK | IMMUTABLE | APPEND)) ||
-	    (VTOI(dvp)->i_flags & APPEND)) {
-		error = EPERM;
-		goto out;
-	}
-	error = ext2_dirremove(dvp, ap->a_cnp);
-	if (error == 0) {
-		ip->i_nlink--;
-		ip->i_flag |= IN_CHANGE;
-	}
-out:
-	return (error);
-}
-
-/*
- * link vnode call
- *
- * ext2_link(struct vnode *a_tdvp, struct vnode *a_vp,
- *	     struct componentname *a_cnp)
- */
-static int
-ext2_link(struct vop_old_link_args *ap)
-{
-	struct vnode *vp = ap->a_vp;
-	struct vnode *tdvp = ap->a_tdvp;
-	struct componentname *cnp = ap->a_cnp;
-	struct inode *ip;
-	int error;
-
-	if (tdvp->v_mount != vp->v_mount) {
-		error = EXDEV;
-		goto out2;
-	}
-	if (tdvp != vp) {
-		error = vn_lock(vp, LK_EXCLUSIVE | LK_FAILRECLAIM);
-		if (error)
-			goto out2;
-	}
-	ip = VTOI(vp);
-	if ((nlink_t)ip->i_nlink >= LINK_MAX) {
-		error = EMLINK;
-		goto out1;
-	}
-	if (ip->i_flags & (IMMUTABLE | APPEND)) {
-		error = EPERM;
-		goto out1;
-	}
-	ip->i_nlink++;
-	ip->i_flag |= IN_CHANGE;
-	error = EXT2_UPDATE(vp, 1);
-	if (!error)
-		error = ext2_direnter(ip, tdvp, cnp);
-	if (error) {
-		ip->i_nlink--;
-		ip->i_flag |= IN_CHANGE;
-	}
-out1:
-	if (tdvp != vp)
-		vn_unlock(vp);
-out2:
-	return (error);
-}
-
-/*
- * Rename system call.  fdvp, fvp are ref'd.  tvp, tdvp are ref'd and locked.
- * all vp's are released and must be in an unlocked state on return.
- *
- * ext2_rename(struct vnode *a_fdvp, struct vnode *a_fvp,
- *		struct componentname *a_fcnp, struct vnode *a_tdvp,
- *		struct vnode *a_tvp, struct componentname *a_tcnp)
- */
-static int
-ext2_rename(struct vop_old_rename_args *ap)
-{
-	struct vnode *tvp = ap->a_tvp;
-	struct vnode *tdvp = ap->a_tdvp;
-	struct vnode *fvp = ap->a_fvp;
-	struct vnode *fdvp = ap->a_fdvp;
-	struct componentname *tcnp = ap->a_tcnp;
-	struct componentname *fcnp = ap->a_fcnp;
-	struct inode *ip, *xp, *dp;
-	struct dirtemplate dirbuf;
-	int doingdirectory = 0, oldparent = 0, newparent = 0;
-	int error = 0;
-	u_char namlen;
-
-	/*
-	 * Check for cross-device rename.
-	 */
-	if ((fvp->v_mount != tdvp->v_mount) ||
-	    (tvp && (fvp->v_mount != tvp->v_mount)) ||
-	    tvp == tdvp) {
-		error = EXDEV;
-abortit:
-		if (tdvp == tvp)
-			vrele(tdvp);
-		else
-			vput(tdvp);
-		if (tvp)
-			vput(tvp);
-		vrele(fdvp);
-		vrele(fvp);
-		return (error);
-	}
-
-	if (tvp && ((VTOI(tvp)->i_flags & (NOUNLINK | IMMUTABLE | APPEND)) ||
-	    (VTOI(tdvp)->i_flags & APPEND))) {
-		error = EPERM;
-		goto abortit;
-	}
-
-	/*
-	 * Renaming a file to itself has no effect.  The upper layers should
-	 * not call us in that case.  Temporarily just warn if they do.
-	 */
-	if (fvp == tvp) {
-		error = 0;
-		goto abortit;
-	}
-
-	error = vn_lock(fvp, LK_EXCLUSIVE | LK_FAILRECLAIM);
-	if (error)
-		goto abortit;
-
-	/*
-	 * fvp, tvp, tdvp locked.  fdvp not locked but note that fdvp may
-	 * be equal to tdvp.
-	 */
-	dp = VTOI(fdvp);
-	ip = VTOI(fvp);
-	if (ip->i_nlink >= LINK_MAX) {
-		vn_unlock(fvp);
-		error = EMLINK;
-		goto abortit;
-	}
-	if ((ip->i_flags & (NOUNLINK | IMMUTABLE | APPEND))
-	    || (dp->i_flags & APPEND)) {
-		vn_unlock(fvp);
-		error = EPERM;
-		goto abortit;
-	}
-	if ((ip->i_mode & IFMT) == IFDIR) {
-		/*
-		 * Avoid ".", "..", and aliases of "." for obvious reasons.
-		 */
-		if ((fcnp->cn_namelen == 1 && fcnp->cn_nameptr[0] == '.') ||
-		    dp == ip || (fcnp->cn_flags | tcnp->cn_flags) & CNP_ISDOTDOT ||
-		    (ip->i_flag & IN_RENAME)) {
-			vn_unlock(fvp);
-			error = EINVAL;
-			goto abortit;
-		}
-		ip->i_flag |= IN_RENAME;
-		oldparent = dp->i_number;
-		doingdirectory++;
-	}
-
-	/*
-	 * tvp is non-NULL if the target exists.   fvp is still locked but
-	 * we will unlock it soon.  The 'bad' goto target requires dp and
-	 * xp to be correctly assigned.
-	 */
-	dp = VTOI(tdvp);
-	if (tvp)
-		xp = VTOI(tvp);
-	else
-		xp = NULL;
-
-	/*
-	 * 1) Bump link count while we're moving stuff
-	 *    around.  If we crash somewhere before
-	 *    completing our work, the link count
-	 *    may be wrong, but correctable.
-	 */
-	ip->i_nlink++;
-	ip->i_flag |= IN_CHANGE;
-	if ((error = EXT2_UPDATE(fvp, 1)) != 0) {
-		vn_unlock(fvp);
-		goto bad;
-	}
-
-	/*
-	 * If ".." must be changed (ie the directory gets a new
-	 * parent) then the source directory must not be in the
-	 * directory heirarchy above the target, as this would
-	 * orphan everything below the source directory. Also
-	 * the user must have write permission in the source so
-	 * as to be able to change "..". We must repeat the call
-	 * to namei, as the parent directory is unlocked by the
-	 * call to checkpath().
-	 */
-	error = VOP_EACCESS(fvp, VWRITE, tcnp->cn_cred);
-	vn_unlock(fvp);
-
-	/*
-	 * tvp (if not NULL) and tdvp are locked.  fvp and fdvp are not.
-	 * dp and xp are set according to tdvp and tvp.
-	 */
-	if (oldparent != dp->i_number)
-		newparent = dp->i_number;
-	if (doingdirectory && newparent) {
-		if (error)	/* write access check above */
-			goto bad;
-
-		/*
-		 * Prepare for relookup, get rid of xp
-		 */
-		if (xp != NULL) {
-			vput(tvp);
-			xp = NULL;
-		}
-
-		/*
-		 * checkpath vput()'s tdvp (VTOI(dp)) on return no matter what,
-		 * get an extra ref so we wind up with just an unlocked, ref'd
-		 * tdvp.  The 'out' target skips xp and tdvp cleanups.  Our
-		 * tdvp is now unlocked so we have to clean it up ourselves.
-		 */
-		vref(tdvp);
-		error = ext2_checkpath(ip, dp, tcnp->cn_cred);
-		tcnp->cn_flags |= CNP_PDIRUNLOCK;
-		if (error) {
-			vrele(tdvp);
-			goto out;
-		}
-		/*
-		 * relookup no longer messes with the ref count.  An unlocked
-		 * tdvp must be passed and if no error occurs a locked tdvp
-		 * will be returned.  We have to use the out target again.
-		 */
-		error = relookup(tdvp, &tvp, tcnp);
-		if (error) {
-			if (tcnp->cn_flags & CNP_PDIRUNLOCK)
-				vrele(tdvp);
-			else
-				vput(tdvp);
-			goto out;
-		}
-
-		/*
-		 * tdvp is locked at this point.  in the RENAME case tvp may
-		 * be NULL without an error, assign xp accordingly.  The
-		 * 'bad' target can be used again after this.
-		 */
-		dp = VTOI(tdvp);
-		if (tvp)
-			xp = VTOI(tvp);
-	}
-	/*
-	 * 2) If target doesn't exist, link the target
-	 *    to the source and unlink the source.
-	 *    Otherwise, rewrite the target directory
-	 *    entry to reference the source inode and
-	 *    expunge the original entry's existence.
-	 *
-	 * tdvp and tvp are cleaned up by this code.  tvp is only good if
-	 * xp is not NULL.
-	 */
-	if (xp == NULL) {
-		if (dp->i_dev != ip->i_dev)
-			panic("ext2_rename: EXDEV");
-		/*
-		 * Account for ".." in new directory.
-		 * When source and destination have the same
-		 * parent we don't fool with the link count.
-		 */
-		if (doingdirectory && newparent) {
-			if ((nlink_t)dp->i_nlink >= LINK_MAX) {
-				error = EMLINK;
-				goto bad;
-			}
-			dp->i_nlink++;
-			dp->i_flag |= IN_CHANGE;
-			error = EXT2_UPDATE(tdvp, 1);
-			if (error)
-				goto bad;
-		}
-		error = ext2_direnter(ip, tdvp, tcnp);
-		if (error) {
-			if (doingdirectory && newparent) {
-				dp->i_nlink--;
-				dp->i_flag |= IN_CHANGE;
-				EXT2_UPDATE(tdvp, 1);
-			}
-			goto bad;
-		}
-
-		/*
-		 * manual cleanup, we can't use the bad or out target after
-		 * this.
-		 */
-		vput(tdvp);
-	} else {
-		if (xp->i_dev != dp->i_dev || xp->i_dev != ip->i_dev)
-			panic("ext2_rename: EXDEV");
-		/*
-		 * Short circuit rename(foo, foo).
-		 */
-		if (xp->i_number == ip->i_number)
-			panic("ext2_rename: same file");
-		/*
-		 * If the parent directory is "sticky", then the user must
-		 * own the parent directory, or the destination of the rename,
-		 * otherwise the destination may not be changed (except by
-		 * root). This implements append-only directories.
-		 */
-		if ((dp->i_mode & S_ISTXT) && tcnp->cn_cred->cr_uid != 0 &&
-		    tcnp->cn_cred->cr_uid != dp->i_uid &&
-		    xp->i_uid != tcnp->cn_cred->cr_uid) {
-			error = EPERM;
-			goto bad;
-		}
-		/*
-		 * Target must be empty if a directory and have no links
-		 * to it. Also, ensure source and target are compatible
-		 * (both directories, or both not directories).
-		 */
-		if ((xp->i_mode&IFMT) == IFDIR) {
-			if (! ext2_dirempty(xp, dp->i_number, tcnp->cn_cred) ||
-			    xp->i_nlink > 2) {
-				error = ENOTEMPTY;
-				goto bad;
-			}
-			if (!doingdirectory) {
-				error = ENOTDIR;
-				goto bad;
-			}
-		} else if (doingdirectory) {
-			error = EISDIR;
-			goto bad;
-		}
-		error = ext2_dirrewrite(dp, ip, tcnp);
-		if (error)
-			goto bad;
-		/*
-		 * If the target directory is in the same
-		 * directory as the source directory,
-		 * decrement the link count on the parent
-		 * of the target directory.
-		 */
-		if (doingdirectory && !newparent) {
-			dp->i_nlink--;
-			dp->i_flag |= IN_CHANGE;
-		}
-
-		/*
-		 * manual cleanup, we can't use the bad or out target after
-		 * this.
-		 */
-		vput(tdvp);
-
-		/*
-		 * Adjust the link count of the target to
-		 * reflect the dirrewrite above.  If this is
-		 * a directory it is empty and there are
-		 * no links to it, so we can squash the inode and
-		 * any space associated with it.  We disallowed
-		 * renaming over top of a directory with links to
-		 * it above, as the remaining link would point to
-		 * a directory without "." or ".." entries.
-		 */
-		xp->i_nlink--;
-		if (doingdirectory) {
-			if (--xp->i_nlink != 0)
-				panic("ext2_rename: linked directory");
-			error = EXT2_TRUNCATE(tvp, (off_t)0, IO_SYNC,
-					      tcnp->cn_cred);
-		}
-		xp->i_flag |= IN_CHANGE;
-		vput(tvp);
-		xp = NULL;
-	}
-
-	/*
-	 * tvp and tdvp have been cleaned up.  The bad and out targets may
-	 * not be used.  fvp and fdvp are ref'd but not locked.  ip
-	 * still represents the old fvp and ip->i_flag may still have IN_RENAME
-	 * set (if doingdirectory).
-	 */
-
-	/*
-	 * 3) Unlink the source.
-	 *
-	 * fdvp is locked and ref'd. ap->a_fvp holds the old lookup unlocked
-	 * and ref'd, fvp will hold the new lookup locked and ref'd.
-	 *
-	 * After the relookup ap->a_fvp must be released as part of our
-	 * cleanup, not just fdvp and fvp.  And, on success, fdvp and
-	 * fvp will be locked so the bad and out targets cannot be used.
-	 */
-	fcnp->cn_flags &= ~CNP_MODMASK;
-	fcnp->cn_flags |= CNP_LOCKPARENT;
-	KKASSERT(fcnp->cn_flags & CNP_PDIRUNLOCK);
-	error = relookup(fdvp, &fvp, fcnp);
-	if (error) {
-		/*
-		 * From name has disappeared.
-		 */
-		if (doingdirectory)
-			panic("ext2_rename: lost dir entry");
-		/* ip->i_flag only sets IN_RENAME if doingdirectory */
-		vrele(ap->a_fvp);
-		if (fcnp->cn_flags & CNP_PDIRUNLOCK)
-			vrele(fdvp);
-		else
-			vput(fdvp);
-		return (0);
-	}
-	KKASSERT((fcnp->cn_flags & CNP_PDIRUNLOCK) == 0);
-
-	/*
-	 * This case shouldn't occur
-	 */
-	if (fvp == NULL) {
-		/*
-		 * From name has disappeared.
-		 */
-		if (doingdirectory)
-			panic("ext2_rename: lost dir entry");
-		/* ip->i_flag only sets IN_RENAME if doingdirectory */
-		vrele(ap->a_fvp);
-		vput(fvp);
-		vput(fdvp);
-		return (0);
-	}
-
-	/*
-	 * fvp and fdvp are both ref'd and locked.
-	 */
-	xp = VTOI(fvp);
-	dp = VTOI(fdvp);
-
-	/*
-	 * Ensure that the directory entry still exists and has not
-	 * changed while the new name has been entered. If the source is
-	 * a file then the entry may have been unlinked or renamed. In
-	 * either case there is no further work to be done. If the source
-	 * is a directory then it cannot have been rmdir'ed; its link
-	 * count of three would cause a rmdir to fail with ENOTEMPTY.
-	 * The IN_RENAME flag ensures that it cannot be moved by another
-	 * rename.
-	 */
-	if (xp != ip) {
-		if (doingdirectory)
-			panic("ext2_rename: lost dir entry");
-		/* ip->i_flag only sets IN_RENAME if doingdirectory */
-	} else {
-		/*
-		 * If the source is a directory with a
-		 * new parent, the link count of the old
-		 * parent directory must be decremented
-		 * and ".." set to point to the new parent.
-		 */
-		if (doingdirectory && newparent) {
-			dp->i_nlink--;
-			dp->i_flag |= IN_CHANGE;
-			error = vn_rdwr(UIO_READ, fvp, (caddr_t)&dirbuf,
-					sizeof (struct dirtemplate), (off_t)0,
-					UIO_SYSSPACE, IO_NODELOCKED,
-					tcnp->cn_cred, NULL);
-			if (error == 0) {
-				/* Like ext2 little-endian: */
-				namlen = dirbuf.dotdot_type;
-				if (namlen != 2 ||
-				    dirbuf.dotdot_name[0] != '.' ||
-				    dirbuf.dotdot_name[1] != '.') {
-					ext2_dirbad(xp, (doff_t)12,
-					    "rename: mangled dir");
-				} else {
-					dirbuf.dotdot_ino = newparent;
-					vn_rdwr(UIO_WRITE, fvp,
-						(caddr_t)&dirbuf,
-						sizeof (struct dirtemplate),
-						(off_t)0, UIO_SYSSPACE,
-						IO_NODELOCKED|IO_SYNC,
-						tcnp->cn_cred, NULL);
-				}
-			}
-		}
-		error = ext2_dirremove(fdvp, fcnp);
-		if (!error) {
-			xp->i_nlink--;
-			xp->i_flag |= IN_CHANGE;
-		}
-		xp->i_flag &= ~IN_RENAME;
-	}
-	vput(fdvp);
-	vput(fvp);
-	vrele(ap->a_fvp);
-	return (error);
-
-bad:
-	if (xp)
-		vput(ITOV(xp));
-	if (dp)
-		vput(ITOV(dp));
-out:
-	if (doingdirectory)
-		ip->i_flag &= ~IN_RENAME;
-
-	error = vn_lock(fvp, LK_EXCLUSIVE);
-	if (error == 0) {
-		ip->i_nlink--;
-		ip->i_flag |= IN_CHANGE;
-		ip->i_flag &= ~IN_RENAME;
-		vput(fvp);
-	} else {
-		vrele(fvp);
-	}
-	return (error);
-}
-
-/*
- * Mkdir system call
- *
- * ext2_mkdir(struct vnode *a_dvp, struct vnode **a_vpp,
- *	      struct componentname *a_cnp, struct vattr *a_vap)
- */
-static int
-ext2_mkdir(struct vop_old_mkdir_args *ap)
-{
-	struct vnode *dvp = ap->a_dvp;
-	struct vattr *vap = ap->a_vap;
-	struct componentname *cnp = ap->a_cnp;
-	struct inode *ip, *dp;
-	struct vnode *tvp;
-	struct dirtemplate dirtemplate, *dtp;
-	int error, dmode;
-
-	dp = VTOI(dvp);
-	if ((nlink_t)dp->i_nlink >= LINK_MAX) {
-		error = EMLINK;
-		goto out;
-	}
-	dmode = vap->va_mode & 0777;
-	dmode |= IFDIR;
-	/*
-	 * Must simulate part of ext2_makeinode here to acquire the inode,
-	 * but not have it entered in the parent directory. The entry is
-	 * made later after writing "." and ".." entries.
-	 */
-	error = EXT2_VALLOC(dvp, dmode, cnp->cn_cred, &tvp);
-	if (error)
-		goto out;
-	ip = VTOI(tvp);
-	ip->i_gid = dp->i_gid;
-#ifdef SUIDDIR
-	{
-#ifdef QUOTA
-		struct ucred ucred, *ucp;
-		ucp = cnp->cn_cred;
-#endif
-		/*
-		 * if we are hacking owners here, (only do this where told to)
-		 * and we are not giving it TOO root, (would subvert quotas)
-		 * then go ahead and give it to the other user.
-		 * The new directory also inherits the SUID bit.
-		 * If user's UID and dir UID are the same,
-		 * 'give it away' so that the SUID is still forced on.
-		 */
-		if ( (dvp->v_mount->mnt_flag & MNT_SUIDDIR) &&
-		   (dp->i_mode & ISUID) && dp->i_uid) {
-			dmode |= ISUID;
-			ip->i_uid = dp->i_uid;
-#ifdef QUOTA
-			if (dp->i_uid != cnp->cn_cred->cr_uid) {
-				/*
-				 * make sure the correct user gets charged
-				 * for the space.
-				 * Make a dummy credential for the victim.
-				 * XXX This seems to never be accessed out of
-				 * our context so a stack variable is ok.
-				 */
-				ucred.cr_ref = 1;
-				ucred.cr_uid = ip->i_uid;
-				ucred.cr_ngroups = 1;
-				ucred.cr_groups[0] = dp->i_gid;
-				ucp = &ucred;
-			}
-#endif
-		} else {
-			ip->i_uid = cnp->cn_cred->cr_uid;
-		}
-#ifdef QUOTA
-		if ((error = ext2_getinoquota(ip)) ||
-		(error = ext2_chkiq(ip, 1, ucp, 0))) {
-			EXT2_VFREE(tvp, ip->i_number, dmode);
-			vput(tvp);
-			return (error);
-		}
-#endif
-	}
-#else
-	ip->i_uid = cnp->cn_cred->cr_uid;
-#ifdef QUOTA
-	if ((error = ext2_getinoquota(ip)) ||
-	    (error = ext2_chkiq(ip, 1, cnp->cn_cred, 0))) {
-		EXT2_VFREE(tvp, ip->i_number, dmode);
-		vput(tvp);
-		return (error);
-	}
-#endif
-#endif
-	ip->i_flag |= IN_ACCESS | IN_CHANGE | IN_UPDATE;
-	ip->i_mode = dmode;
-	tvp->v_type = VDIR;	/* Rest init'd in getnewvnode(). */
-	ip->i_nlink = 2;
-	if (cnp->cn_flags & CNP_ISWHITEOUT)
-		ip->i_flags |= UF_OPAQUE;
-	error = EXT2_UPDATE(tvp, 1);
-
-	/*
-	 * The vnode must have a VM object in order to issue buffer cache
-	 * ops on it.
-	 */
-	vinitvmio(tvp, 0, PAGE_SIZE, -1);
-
-	/*
-	 * Bump link count in parent directory
-	 * to reflect work done below.  Should
-	 * be done before reference is created
-	 * so reparation is possible if we crash.
-	 */
-	dp->i_nlink++;
-	dp->i_flag |= IN_CHANGE;
-	error = EXT2_UPDATE(dvp, 1);
-	if (error)
-		goto bad;
-
-	/* Initialize directory with "." and ".." from static template. */
-	if (EXT2_HAS_INCOMPAT_FEATURE(ip->i_e2fs->s_es,
-	    EXT2_FEATURE_INCOMPAT_FILETYPE))
-		dtp = &ext2_mastertemplate;
-	else
-		dtp = &ext2_omastertemplate;
-	dirtemplate = *dtp;
-	dirtemplate.dot_ino = ip->i_number;
-	dirtemplate.dotdot_ino = dp->i_number;
-	/* note that in ext2 DIRBLKSIZ == blocksize, not DEV_BSIZE
-	 * so let's just redefine it - for this function only
-	 */
-#undef  DIRBLKSIZ
-#define DIRBLKSIZ  VTOI(dvp)->i_e2fs->s_blocksize
-	dirtemplate.dotdot_reclen = DIRBLKSIZ - 12;
-	error = vn_rdwr(UIO_WRITE, tvp, (caddr_t)&dirtemplate,
-			sizeof (dirtemplate), (off_t)0, UIO_SYSSPACE,
-			IO_NODELOCKED|IO_SYNC, cnp->cn_cred, NULL);
-	if (error) {
-		dp->i_nlink--;
-		dp->i_flag |= IN_CHANGE;
-		goto bad;
-	}
-	if (DIRBLKSIZ > VFSTOEXT2(dvp->v_mount)->um_mountp->mnt_stat.f_bsize)
-		panic("ext2_mkdir: blksize"); /* XXX should grow with balloc() */
-	else {
-		ip->i_size = DIRBLKSIZ;
-		ip->i_flag |= IN_CHANGE;
-	}
-
-	/* Directory set up, now install its entry in the parent directory. */
-	error = ext2_direnter(ip, dvp, cnp);
-	if (error) {
-		dp->i_nlink--;
-		dp->i_flag |= IN_CHANGE;
-	}
-bad:
-	/*
-	 * No need to do an explicit VOP_TRUNCATE here, vrele will do this
-	 * for us because we set the link count to 0.
-	 */
-	if (error) {
-		ip->i_nlink = 0;
-		ip->i_flag |= IN_CHANGE;
-		vput(tvp);
-	} else
-		*ap->a_vpp = tvp;
-out:
-	return (error);
-#undef  DIRBLKSIZ
-#define DIRBLKSIZ  DEV_BSIZE
-}
-
-/*
- * Rmdir system call.
- *
- * ext2_rmdir(struct vnode *a_dvp, struct vnode *a_vp,
- *	      struct componentname *a_cnp)
- */
-static int
-ext2_rmdir(struct vop_old_rmdir_args *ap)
-{
-	struct vnode *vp = ap->a_vp;
-	struct vnode *dvp = ap->a_dvp;
-	struct componentname *cnp = ap->a_cnp;
-	struct inode *ip, *dp;
-	int error;
-
-	ip = VTOI(vp);
-	dp = VTOI(dvp);
-
-	/*
-	 * Verify the directory is empty (and valid).
-	 * (Rmdir ".." won't be valid since
-	 *  ".." will contain a reference to
-	 *  the current directory and thus be
-	 *  non-empty.)
-	 */
-	error = 0;
-	if (ip->i_nlink != 2 || !ext2_dirempty(ip, dp->i_number, cnp->cn_cred)) {
-		error = ENOTEMPTY;
-		goto out;
-	}
-	if ((dp->i_flags & APPEND)
-	    || (ip->i_flags & (NOUNLINK | IMMUTABLE | APPEND))) {
-		error = EPERM;
-		goto out;
-	}
-	/*
-	 * Delete reference to directory before purging
-	 * inode.  If we crash in between, the directory
-	 * will be reattached to lost+found,
-	 */
-	error = ext2_dirremove(dvp, cnp);
-	if (error)
-		goto out;
-	dp->i_nlink--;
-	dp->i_flag |= IN_CHANGE;
-	vn_unlock(dvp);
-	/*
-	 * Truncate inode.  The only stuff left
-	 * in the directory is "." and "..".  The
-	 * "." reference is inconsequential since
-	 * we're quashing it.  The ".." reference
-	 * has already been adjusted above.  We've
-	 * removed the "." reference and the reference
-	 * in the parent directory, but there may be
-	 * other hard links so decrement by 2 and
-	 * worry about them later.
-	 */
-	ip->i_nlink -= 2;
-	error = EXT2_TRUNCATE(vp, (off_t)0, IO_SYNC, cnp->cn_cred);
-	vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY);
-out:
-	return (error);
-}
-
-/*
- * symlink -- make a symbolic link
- *
- * ext2_symlink(struct vnode *a_dvp, struct vnode **a_vpp,
- *		struct componentname *a_cnp, struct vattr *a_vap,
- *		char *a_target)
- */
-static int
-ext2_symlink(struct vop_old_symlink_args *ap)
-{
-	struct vnode *vp, **vpp = ap->a_vpp;
-	struct inode *ip;
-	int len, error;
-
-	error = ext2_makeinode(IFLNK | ap->a_vap->va_mode, ap->a_dvp,
-	    vpp, ap->a_cnp);
-	if (error)
-		return (error);
-	vp = *vpp;
-	len = strlen(ap->a_target);
-	if (len < vp->v_mount->mnt_maxsymlinklen) {
-		ip = VTOI(vp);
-		bcopy(ap->a_target, (char *)ip->i_shortlink, len);
-		ip->i_size = len;
-		ip->i_flag |= IN_CHANGE | IN_UPDATE;
-	} else {
-		/*
-		 * Make sure we have a VM object in order to use
-		 * the buffer cache.
-		 */
-		if (vp->v_object == NULL)
-			vinitvmio(vp, 0, PAGE_SIZE, -1);
-
-		error = vn_rdwr(UIO_WRITE, vp, ap->a_target, len, (off_t)0,
-				UIO_SYSSPACE, IO_NODELOCKED,
-				ap->a_cnp->cn_cred, NULL);
-
-		if (error)
-			vput(vp);
-	}
-
-	return (error);
-}
-
-/*
- * Allocate a new inode.
- */
-static int
-ext2_makeinode(int mode, struct vnode *dvp, struct vnode **vpp,
-	       struct componentname *cnp)
-{
-	struct inode *ip, *pdir;
-	struct vnode *tvp;
-	int error;
-
-	pdir = VTOI(dvp);
-	*vpp = NULL;
-	if ((mode & IFMT) == 0)
-		mode |= IFREG;
-
-	error = EXT2_VALLOC(dvp, mode, cnp->cn_cred, &tvp);
-	if (error) {
-		return (error);
-	}
-	ip = VTOI(tvp);
-	ip->i_gid = pdir->i_gid;
-#ifdef SUIDDIR
-	{
-#ifdef QUOTA
-		struct ucred ucred, *ucp;
-		ucp = cnp->cn_cred;
-#endif
-		/*
-		 * if we are
-		 * not the owner of the directory,
-		 * and we are hacking owners here, (only do this where told to)
-		 * and we are not giving it TOO root, (would subvert quotas)
-		 * then go ahead and give it to the other user.
-		 * Note that this drops off the execute bits for security.
-		 */
-		if ( (dvp->v_mount->mnt_flag & MNT_SUIDDIR) &&
-		     (pdir->i_mode & ISUID) &&
-		     (pdir->i_uid != cnp->cn_cred->cr_uid) && pdir->i_uid) {
-			ip->i_uid = pdir->i_uid;
-			mode &= ~07111;
-#ifdef QUOTA
-			/*
-			 * make sure the correct user gets charged
-			 * for the space.
-			 * Quickly knock up a dummy credential for the victim.
-			 * XXX This seems to never be accessed out of our
-			 * context so a stack variable is ok.
-			 */
-			ucred.cr_ref = 1;
-			ucred.cr_uid = ip->i_uid;
-			ucred.cr_ngroups = 1;
-			ucred.cr_groups[0] = pdir->i_gid;
-			ucp = &ucred;
-#endif
-		} else {
-			ip->i_uid = cnp->cn_cred->cr_uid;
-		}
-
-#ifdef QUOTA
-		if ((error = ext2_getinoquota(ip)) ||
-		(error = ext2_chkiq(ip, 1, ucp, 0))) {
-			EXT2_VFREE(tvp, ip->i_number, mode);
-			vput(tvp);
-			return (error);
-		}
-#endif
-	}
-#else
-	ip->i_uid = cnp->cn_cred->cr_uid;
-#ifdef QUOTA
-	if ((error = ext2_getinoquota(ip)) ||
-	    (error = ext2_chkiq(ip, 1, cnp->cn_cred, 0))) {
-		EXT2_VFREE(tvp, ip->i_number, mode);
-		vput(tvp);
-		return (error);
-	}
-#endif
-#endif
-	ip->i_flag |= IN_ACCESS | IN_CHANGE | IN_UPDATE;
-	ip->i_mode = mode;
-	tvp->v_type = IFTOVT(mode);	/* Rest init'd in getnewvnode(). */
-	ip->i_nlink = 1;
-	if ((ip->i_mode & ISGID) && !groupmember(ip->i_gid, cnp->cn_cred) &&
-	    priv_check_cred(cnp->cn_cred, PRIV_VFS_SETGID, 0))
-		ip->i_mode &= ~ISGID;
-
-	if (cnp->cn_flags & CNP_ISWHITEOUT)
-		ip->i_flags |= UF_OPAQUE;
-
-	/*
-	 * Regular files and directories need VM objects.  Softlinks do
-	 * not (not immediately anyway).
-	 */
-	if (tvp->v_type == VREG || tvp->v_type == VDIR)
-		vinitvmio(tvp, 0, PAGE_SIZE, -1);
-
-	/*
-	 * Make sure inode goes to disk before directory entry.
-	 */
-	error = EXT2_UPDATE(tvp, 1);
-	if (error)
-		goto bad;
-	error = ext2_direnter(ip, dvp, cnp);
-	if (error)
-		goto bad;
-
-	*vpp = tvp;
-	return (0);
-
-bad:
-	/*
-	 * Write error occurred trying to update the inode
-	 * or the directory so must deallocate the inode.
-	 */
-	ip->i_nlink = 0;
-	ip->i_flag |= IN_CHANGE;
-	vput(tvp);
-	return (error);
-}
-
-void
-ext2_itimes(struct vnode *vp)
-{
-	struct inode *ip;
-	struct timespec ts;
-
-	ip = VTOI(vp);
-	if ((ip->i_flag & (IN_ACCESS | IN_CHANGE | IN_UPDATE)) == 0)
-		return;
-	if ((vp->v_type == VBLK || vp->v_type == VCHR) && !DOINGSOFTDEP(vp))
-		ip->i_flag |= IN_LAZYMOD;
-	else
-		ip->i_flag |= IN_MODIFIED;
-	if ((vp->v_mount->mnt_flag & MNT_RDONLY) == 0) {
-		vfs_timestamp(&ts);
-		if (ip->i_flag & IN_ACCESS) {
-			ip->i_atime = ts.tv_sec;
-			ip->i_atimensec = ts.tv_nsec;
-		}
-		if (ip->i_flag & IN_UPDATE) {
-			ip->i_mtime = ts.tv_sec;
-			ip->i_mtimensec = ts.tv_nsec;
-			ip->i_modrev++;
-		}
-		if (ip->i_flag & IN_CHANGE) {
-			ip->i_ctime = ts.tv_sec;
-			ip->i_ctimensec = ts.tv_nsec;
-		}
-	}
-	ip->i_flag &= ~(IN_ACCESS | IN_CHANGE | IN_UPDATE);
-}
-
-/*
- * Open called.
- *
- * Nothing to do.
- *
- * ext2_open(struct vnode *a_vp, int a_mode, struct ucred *a_cred,
- *	     struct file *a_fp)
- */
-/* ARGSUSED */
-static
-int
-ext2_open(struct vop_open_args *ap)
-{
-	struct vnode *vp = ap->a_vp;
-
-	/*
-	 * Files marked append-only must be opened for appending.
-	 */
-	if ((VTOI(vp)->i_flags & APPEND) &&
-	    (ap->a_mode & (FWRITE | O_APPEND)) == FWRITE) {
-		return (EPERM);
-	}
-	return (vop_stdopen(ap));
-}
-
-/*
- * Close called.
- *
- * Update the times on the inode.
- *
- * ext2_close(struct vnode *a_vp, int a_fflag, struct ucred *a_cred)
- */
-/* ARGSUSED */
-static
-int
-ext2_close(struct vop_close_args *ap)
-{
-	struct vnode *vp = ap->a_vp;
-
-	if (VREFCNT(vp) > 1)
-		ext2_itimes(vp);
-	return (vop_stdclose(ap));
-}
-
-/*
- * ext2_access(struct vnode *a_vp, int a_mode, struct ucred *a_cred)
- */
-static
-int
-ext2_access(struct vop_access_args *ap)
-{
-	struct vnode *vp = ap->a_vp;
-	struct inode *ip = VTOI(vp);
-	int error;
-
-#ifdef QUOTA
-	if (ap->a_mode & VWRITE) {
-		switch (vp->v_type) {
-		case VDIR:
-		case VLNK:
-		case VREG:
-			if ((error = ext2_getinoquota(ip)) != 0)
-				return (error);
-			break;
-		default:
-			break;
-		}
-	}
-#endif
-
-	error = vop_helper_access(ap, ip->i_uid, ip->i_gid, ip->i_mode,
-				  ip->i_flags);
-	return (error);
-}
-
-/*
- * ext2_getattr(struct vnode *a_vp, struct vattr *a_vap)
- */
-/* ARGSUSED */
-static
-int
-ext2_getattr(struct vop_getattr_args *ap)
-{
-	struct vnode *vp = ap->a_vp;
-	struct inode *ip = VTOI(vp);
-	struct vattr *vap = ap->a_vap;
-
-	ext2_itimes(vp);
-	/*
-	 * Copy from inode table
-	 */
-	vap->va_fsid = devid_from_dev(ip->i_dev);
-	vap->va_fileid = ip->i_number;
-	vap->va_mode = ip->i_mode & ~IFMT;
-	vap->va_nlink = VFSTOEXT2(vp->v_mount)->um_i_effnlink_valid ?
-	    ip->i_effnlink : ip->i_nlink;
-	vap->va_uid = ip->i_uid;
-	vap->va_gid = ip->i_gid;
-	vap->va_rmajor = umajor(ip->i_rdev);
-	vap->va_rminor = uminor(ip->i_rdev);
-	vap->va_size = ip->i_din.di_size;
-	vap->va_atime.tv_sec = ip->i_atime;
-	vap->va_atime.tv_nsec = ip->i_atimensec;
-	vap->va_mtime.tv_sec = ip->i_mtime;
-	vap->va_mtime.tv_nsec = ip->i_mtimensec;
-	vap->va_ctime.tv_sec = ip->i_ctime;
-	vap->va_ctime.tv_nsec = ip->i_ctimensec;
-	vap->va_flags = ip->i_flags;
-	vap->va_gen = ip->i_gen;
-	vap->va_blocksize = vp->v_mount->mnt_stat.f_iosize;
-	vap->va_bytes = dbtob((u_quad_t)ip->i_blocks);
-	vap->va_type = IFTOVT(ip->i_mode);
-	vap->va_filerev = ip->i_modrev;
-	return (0);
-}
-
-/*
- * Set attribute vnode op. called from several syscalls
- *
- * ext2_setattr(struct vnode *a_vp, struct vattr *a_vap, struct ucred *a_cred)
- */
-static
-int
-ext2_setattr(struct vop_setattr_args *ap)
-{
-	struct vattr *vap = ap->a_vap;
-	struct vnode *vp = ap->a_vp;
-	struct inode *ip = VTOI(vp);
-	struct ucred *cred = ap->a_cred;
-	int error;
-
-	/*
-	 * Check for unsettable attributes.
-	 */
-	if ((vap->va_type != VNON) || (vap->va_nlink != VNOVAL) ||
-	    (vap->va_fsid != VNOVAL) || (vap->va_fileid != VNOVAL) ||
-	    (vap->va_blocksize != VNOVAL) || (vap->va_rmajor != VNOVAL) ||
-	    ((int)vap->va_bytes != VNOVAL) || (vap->va_gen != VNOVAL)) {
-		return (EINVAL);
-	}
-	if (vap->va_flags != VNOVAL) {
-		if (vp->v_mount->mnt_flag & MNT_RDONLY)
-			return (EROFS);
-		if (cred->cr_uid != ip->i_uid &&
-		    (error = priv_check_cred(cred, PRIV_VFS_SETATTR, 0)))
-			return (error);
-		/*
-		 * Note that a root chflags becomes a user chflags when
-		 * we are jailed, unless the jail vfs_chflags sysctl
-		 * is set.
-		 */
-		if (cred->cr_uid == 0 &&
-		    (!jailed(cred) ||
-			PRISON_CAP_ISSET(cred->cr_prison->pr_caps,
-			    PRISON_CAP_VFS_CHFLAGS))) {
-			if ((ip->i_flags
-			    & (SF_NOUNLINK | SF_IMMUTABLE | SF_APPEND)) &&
-			    securelevel > 0)
-				return (EPERM);
-			ip->i_flags = vap->va_flags;
-		} else {
-			if (ip->i_flags
-			    & (SF_NOUNLINK | SF_IMMUTABLE | SF_APPEND) ||
-			    (vap->va_flags & UF_SETTABLE) != vap->va_flags)
-				return (EPERM);
-			ip->i_flags &= SF_SETTABLE;
-			ip->i_flags |= (vap->va_flags & UF_SETTABLE);
-		}
-		ip->i_flag |= IN_CHANGE;
-		if (vap->va_flags & (IMMUTABLE | APPEND))
-			return (0);
-	}
-	if (ip->i_flags & (IMMUTABLE | APPEND))
-		return (EPERM);
-	/*
-	 * Go through the fields and update iff not VNOVAL.
-	 */
-	if (vap->va_uid != (uid_t)VNOVAL || vap->va_gid != (gid_t)VNOVAL) {
-		if (vp->v_mount->mnt_flag & MNT_RDONLY)
-			return (EROFS);
-		if ((error = ext2_chown(vp, vap->va_uid, vap->va_gid, cred)) != 0)
-			return (error);
-	}
-	if (vap->va_size != VNOVAL) {
-		/*
-		 * Disallow write attempts on read-only filesystems;
-		 * unless the file is a socket, fifo, or a block or
-		 * character device resident on the filesystem.
-		 */
-		switch (vp->v_type) {
-		case VDIR:
-			return (EISDIR);
-		case VLNK:
-		case VREG:
-			if (vp->v_mount->mnt_flag & MNT_RDONLY)
-				return (EROFS);
-			break;
-		default:
-			break;
-		}
-		if ((error = EXT2_TRUNCATE(vp, vap->va_size, 0, cred)) != 0)
-			return (error);
-	}
-	ip = VTOI(vp);
-	if (vap->va_atime.tv_sec != VNOVAL || vap->va_mtime.tv_sec != VNOVAL) {
-		if (vp->v_mount->mnt_flag & MNT_RDONLY)
-			return (EROFS);
-		if (cred->cr_uid != ip->i_uid &&
-		    (error = priv_check_cred(cred, PRIV_VFS_SETATTR, 0)) &&
-		    ((vap->va_vaflags & VA_UTIMES_NULL) == 0 ||
-		    (error = VOP_EACCESS(vp, VWRITE, cred))))
-			return (error);
-		if (vap->va_atime.tv_sec != VNOVAL)
-			ip->i_flag |= IN_ACCESS;
-		if (vap->va_mtime.tv_sec != VNOVAL)
-			ip->i_flag |= IN_CHANGE | IN_UPDATE;
-		ext2_itimes(vp);
-		if (vap->va_atime.tv_sec != VNOVAL) {
-			ip->i_atime = vap->va_atime.tv_sec;
-			ip->i_atimensec = vap->va_atime.tv_nsec;
-		}
-		if (vap->va_mtime.tv_sec != VNOVAL) {
-			ip->i_mtime = vap->va_mtime.tv_sec;
-			ip->i_mtimensec = vap->va_mtime.tv_nsec;
-		}
-		error = EXT2_UPDATE(vp, 0);
-		if (error)
-			return (error);
-	}
-	error = 0;
-	if (vap->va_mode != (mode_t)VNOVAL) {
-		if (vp->v_mount->mnt_flag & MNT_RDONLY)
-			return (EROFS);
-		error = ext2_chmod(vp, (int)vap->va_mode, cred);
-	}
-	VN_KNOTE(vp, NOTE_ATTRIB);
-	return (error);
-}
-
-/*
- * Change the mode on a file.
- * Inode must be locked before calling.
- */
-static int
-ext2_chmod(struct vnode *vp, int mode, struct ucred *cred)
-{
-	struct inode *ip = VTOI(vp);
-	int error;
-
-	if (cred->cr_uid != ip->i_uid) {
-	    error = priv_check_cred(cred, PRIV_VFS_CHMOD, 0);
-	    if (error)
-		return (error);
-	}
-	if (cred->cr_uid) {
-		if (vp->v_type != VDIR && (mode & S_ISTXT))
-			return (EFTYPE);
-		if (!groupmember(ip->i_gid, cred) && (mode & ISGID))
-			return (EPERM);
-	}
-	ip->i_mode &= ~ALLPERMS;
-	ip->i_mode |= (mode & ALLPERMS);
-	ip->i_flag |= IN_CHANGE;
-	return (0);
-}
-
-/*
- * Perform chown operation on inode ip;
- * inode must be locked prior to call.
- */
-static int
-ext2_chown(struct vnode *vp, uid_t uid, gid_t gid, struct ucred *cred)
-{
-	struct inode *ip = VTOI(vp);
-	uid_t ouid;
-	gid_t ogid;
-	int error = 0;
-#ifdef QUOTA
-	int i;
-	long change;
-#endif
-
-	if (uid == (uid_t)VNOVAL)
-		uid = ip->i_uid;
-	if (gid == (gid_t)VNOVAL)
-		gid = ip->i_gid;
-	/*
-	 * If we don't own the file, are trying to change the owner
-	 * of the file, or are not a member of the target group,
-	 * the caller must be superuser or the call fails.
-	 */
-	if ((cred->cr_uid != ip->i_uid || uid != ip->i_uid ||
-	    (gid != ip->i_gid && !(cred->cr_gid == gid ||
-	    groupmember(gid, cred)))) &&
-	    (error = priv_check_cred(cred, PRIV_VFS_CHOWN, 0)))
-		return (error);
-	ogid = ip->i_gid;
-	ouid = ip->i_uid;
-#ifdef QUOTA
-	if ((error = ext2_getinoquota(ip)) != 0)
-		return (error);
-	if (ouid == uid) {
-		ext2_dqrele(vp, ip->i_dquot[USRQUOTA]);
-		ip->i_dquot[USRQUOTA] = NODQUOT;
-	}
-	if (ogid == gid) {
-		ext2_dqrele(vp, ip->i_dquot[GRPQUOTA]);
-		ip->i_dquot[GRPQUOTA] = NODQUOT;
-	}
-	change = ip->i_blocks;
-	(void) ext2_chkdq(ip, -change, cred, CHOWN);
-	(void) ext2_chkiq(ip, -1, cred, CHOWN);
-	for (i = 0; i < MAXQUOTAS; i++) {
-		ext2_dqrele(vp, ip->i_dquot[i]);
-		ip->i_dquot[i] = NODQUOT;
-	}
-#endif
-	ip->i_gid = gid;
-	ip->i_uid = uid;
-#ifdef QUOTA
-	if ((error = ext2_getinoquota(ip)) == 0) {
-		if (ouid == uid) {
-			ext2_dqrele(vp, ip->i_dquot[USRQUOTA]);
-			ip->i_dquot[USRQUOTA] = NODQUOT;
-		}
-		if (ogid == gid) {
-			ext2_dqrele(vp, ip->i_dquot[GRPQUOTA]);
-			ip->i_dquot[GRPQUOTA] = NODQUOT;
-		}
-		if ((error = ext2_chkdq(ip, change, cred, CHOWN)) == 0) {
-			if ((error = ext2_chkiq(ip, 1, cred, CHOWN)) == 0)
-				goto good;
-			else
-				(void)ext2_chkdq(ip, -change, cred, CHOWN|FORCE);
-		}
-		for (i = 0; i < MAXQUOTAS; i++) {
-			ext2_dqrele(vp, ip->i_dquot[i]);
-			ip->i_dquot[i] = NODQUOT;
-		}
-	}
-	ip->i_gid = ogid;
-	ip->i_uid = ouid;
-	if (ext2_getinoquota(ip) == 0) {
-		if (ouid == uid) {
-			ext2_dqrele(vp, ip->i_dquot[USRQUOTA]);
-			ip->i_dquot[USRQUOTA] = NODQUOT;
-		}
-		if (ogid == gid) {
-			ext2_dqrele(vp, ip->i_dquot[GRPQUOTA]);
-			ip->i_dquot[GRPQUOTA] = NODQUOT;
-		}
-		(void) ext2_chkdq(ip, change, cred, FORCE|CHOWN);
-		(void) ext2_chkiq(ip, 1, cred, FORCE|CHOWN);
-		(void) ext2_getinoquota(ip);
-	}
-	return (error);
-good:
-	if (ext2_getinoquota(ip))
-		panic("ext2_chown: lost quota");
-#endif /* QUOTA */
-	ip->i_flag |= IN_CHANGE;
-	if (cred->cr_uid != 0 && (ouid != uid || ogid != gid))
-		ip->i_mode &= ~(ISUID | ISGID);
-	return (0);
-}
-
-/*
- * whiteout vnode call
- *
- * ext2_whiteout(struct vnode *a_dvp, struct componentname *a_cnp, int a_flags)
- */
-static
-int
-ext2_whiteout(struct vop_old_whiteout_args *ap)
-{
-	return (EOPNOTSUPP);
-}
-
-/*
- * Return target name of a symbolic link
- *
- * ext2_readlink(struct vnode *a_vp, struct uio *a_uio, struct ucred *a_cred)
- */
-static
-int
-ext2_readlink(struct vop_readlink_args *ap)
-{
-	struct vnode *vp = ap->a_vp;
-	struct inode *ip = VTOI(vp);
-	int isize;
-
-	isize = ip->i_size;
-	if ((isize < vp->v_mount->mnt_maxsymlinklen) ||
-	    (ip->i_din.di_blocks == 0)) {   /* XXX - for old fastlink support */
-		uiomove((char *)ip->i_shortlink, isize, ap->a_uio);
-		return (0);
-	}
-	return (VOP_READ(vp, ap->a_uio, 0, ap->a_cred));
-}
-
-/*
- * Calculate the logical to physical mapping if not done already,
- * then call the device strategy routine.
- *
- * In order to be able to swap to a file, the VOP_BMAP operation may not
- * deadlock on memory.  See ext2_bmap() for details.
- *
- * ext2_strategy(struct vnode *a_vp, struct bio *a_bio)
- */
-static
-int
-ext2_strategy(struct vop_strategy_args *ap)
-{
-	struct bio *bio = ap->a_bio;
-	struct bio *nbio;
-	struct buf *bp = bio->bio_buf;
-	struct vnode *vp = ap->a_vp;
-	struct inode *ip;
-	int error;
-
-	ip = VTOI(vp);
-	if (vp->v_type == VBLK || vp->v_type == VCHR)
-		panic("ext2_strategy: spec");
-	nbio = push_bio(bio);
-	if (nbio->bio_offset == NOOFFSET) {
-		error = VOP_BMAP(vp, bio->bio_offset, &nbio->bio_offset,
-				 NULL, NULL, bp->b_cmd);
-		if (error) {
-			bp->b_error = error;
-			bp->b_flags |= B_ERROR;
-			/* I/O was never started on nbio, must biodone(bio) */
-			biodone(bio);
-			return (error);
-		}
-		if (nbio->bio_offset == NOOFFSET)
-			vfs_bio_clrbuf(bp);
-	}
-	if (nbio->bio_offset == NOOFFSET) {
-		/* I/O was never started on nbio, must biodone(bio) */
-		biodone(bio);
-		return (0);
-	}
-	vn_strategy(ip->i_devvp, nbio);
-	return (0);
-}
-
-/*
- * Print out the contents of an inode.
- *
- * ext2_print(struct vnode *a_vp)
- */
-static
-int
-ext2_print(struct vop_print_args *ap)
-{
-	struct vnode *vp = ap->a_vp;
-	struct inode *ip = VTOI(vp);
-
-	kprintf("tag VT_EXT2FS, ino %lu, on dev %s (%d, %d)",
-	    (u_long)ip->i_number, devtoname(ip->i_dev), major(ip->i_dev),
-	    minor(ip->i_dev));
-	if (vp->v_type == VFIFO)
-		fifo_printinfo(vp);
-	lockmgr_printinfo(&vp->v_lock);
-	kprintf("\n");
-	return (0);
-}
-
-/*
- * Read wrapper for fifos.
- *
- * ext2fifo_read(struct vnode *a_vp, struct uio *a_uio, int a_ioflag,
- *		struct ucred *a_cred)
- */
-static
-int
-ext2fifo_read(struct vop_read_args *ap)
-{
-	int error, resid;
-	struct inode *ip;
-	struct uio *uio;
-
-	uio = ap->a_uio;
-	resid = uio->uio_resid;
-	error = VOCALL(&fifo_vnode_vops, &ap->a_head);
-	ip = VTOI(ap->a_vp);
-	if ((ap->a_vp->v_mount->mnt_flag & MNT_NOATIME) == 0 && ip != NULL &&
-	    (uio->uio_resid != resid || (error == 0 && resid != 0)))
-		VTOI(ap->a_vp)->i_flag |= IN_ACCESS;
-	return (error);
-}
-
-/*
- * Write wrapper for fifos.
- *
- * ext2fifo_write(struct vnode *a_vp, struct uio *a_uio, int a_ioflag,
- *		 struct ucred *a_cred)
- */
-static
-int
-ext2fifo_write(struct vop_write_args *ap)
-{
-	int error, resid;
-	struct inode *ip;
-	struct uio *uio;
-
-	uio = ap->a_uio;
-	resid = uio->uio_resid;
-	error = VOCALL(&fifo_vnode_vops, &ap->a_head);
-	ip = VTOI(ap->a_vp);
-	if (ip != NULL && (uio->uio_resid != resid || (error == 0 && resid != 0)))
-		VTOI(ap->a_vp)->i_flag |= IN_CHANGE | IN_UPDATE;
-	return (error);
-}
-
-/*
- * Close wrapper for fifos.
- *
- * Update the times on the inode then do device close.
- *
- * ext2fifo_close(struct vnode *a_vp, int a_fflag, struct ucred *a_cred)
- */
-static
-int
-ext2fifo_close(struct vop_close_args *ap)
-{
-	struct vnode *vp = ap->a_vp;
-
-	if (VREFCNT(vp) > 1)
-		ext2_itimes(vp);
-	return (VOCALL(&fifo_vnode_vops, &ap->a_head));
-}
-
-/*
- * Kqfilter wrapper for fifos.
- *
- * Fall through to ext2 kqfilter routines if needed
- */
-static
-int
-ext2fifo_kqfilter(struct vop_kqfilter_args *ap)
-{
-	int error;
-
-	error = VOCALL(&fifo_vnode_vops, &ap->a_head);
-	if (error)
-		error = ext2_kqfilter(ap);
-	return (error);
-}
-
-/*
- * Return POSIX pathconf information applicable to ext2 filesystems.
- *
- * ext2_pathconf(struct vnode *a_vp, int a_name, int *a_retval)
- */
-static
-int
-ext2_pathconf(struct vop_pathconf_args *ap)
-{
-	switch (ap->a_name) {
-	case _PC_LINK_MAX:
-		*ap->a_retval = LINK_MAX;
-		return (0);
-	case _PC_NAME_MAX:
-		*ap->a_retval = NAME_MAX;
-		return (0);
-	case _PC_PATH_MAX:
-		*ap->a_retval = PATH_MAX;
-		return (0);
-	case _PC_PIPE_BUF:
-		*ap->a_retval = PIPE_BUF;
-		return (0);
-	case _PC_CHOWN_RESTRICTED:
-		*ap->a_retval = 1;
-		return (0);
-	case _PC_NO_TRUNC:
-		*ap->a_retval = 1;
-		return (0);
-	default:
-		return (EINVAL);
-	}
-	/* NOTREACHED */
-}
-
-/*
- * Advisory record locking support
- *
- * ext2_advlock(struct vnode *a_vp, caddr_t a_id, int a_op, struct flock *a_fl,
- *	       int a_flags)
- */
-static
-int
-ext2_advlock(struct vop_advlock_args *ap)
-{
-	struct inode *ip = VTOI(ap->a_vp);
-
-	return (lf_advlock(ap, &(ip->i_lockf), ip->i_size));
-}
-
-/*
- * Initialize the vnode associated with a new inode, handle aliased
- * vnodes.
- */
-int
-ext2_vinit(struct mount *mntp, struct vnode **vpp)
-{
-	struct inode *ip;
-	struct vnode *vp;
-
-	vp = *vpp;
-	ip = VTOI(vp);
-
-	switch(vp->v_type = IFTOVT(ip->i_mode)) {
-	case VCHR:
-	case VBLK:
-		vp->v_ops = &mntp->mnt_vn_spec_ops;
-		addaliasu(vp, umajor(ip->i_rdev), uminor(ip->i_rdev));
-		break;
-	case VFIFO:
-		vp->v_ops = &mntp->mnt_vn_fifo_ops;
-		break;
-	case VDIR:
-	case VREG:
-		vinitvmio(vp, ip->i_size, PAGE_SIZE, -1); /* XXX */
-		break;
-	case VLNK:
-		if ((ip->i_size >= vp->v_mount->mnt_maxsymlinklen) &&
-		    ip->i_din.di_blocks != 0
-		) {
-			vinitvmio(vp, ip->i_size, PAGE_SIZE, -1);
-		}
-		break;
-	default:
-		break;
-
-	}
-
-	if (ip->i_number == EXT2_ROOTINO)
-		vp->v_flag |= VROOT;
-	/*
-	 * Initialize modrev times
-	 */
-	ip->i_modrev = init_va_filerev();
-	*vpp = vp;
-	return (0);
-}
-
-static struct filterops ext2read_filtops =
-	{ FILTEROP_ISFD, NULL, filt_ext2detach, filt_ext2read };
-static struct filterops ext2write_filtops =
-	{ FILTEROP_ISFD, NULL, filt_ext2detach, filt_ext2write };
-static struct filterops ext2vnode_filtops =
-	{ FILTEROP_ISFD, NULL, filt_ext2detach, filt_ext2vnode };
-
-/*
- * ext2_kqfilter(struct vnode *a_vp, struct knote *a_kn)
- */
-static int
-ext2_kqfilter(struct vop_kqfilter_args *ap)
-{
-	struct vnode *vp = ap->a_vp;
-	struct knote *kn = ap->a_kn;
-
-	switch (kn->kn_filter) {
-	case EVFILT_READ:
-		kn->kn_fop = &ext2read_filtops;
-		break;
-	case EVFILT_WRITE:
-		kn->kn_fop = &ext2write_filtops;
-		break;
-	case EVFILT_VNODE:
-		kn->kn_fop = &ext2vnode_filtops;
-		break;
-	default:
-		return (EOPNOTSUPP);
-	}
-
-	kn->kn_hook = (caddr_t)vp;
-
-	/* XXX: kq token actually protects the list */
-	lwkt_gettoken(&vp->v_token);
-	knote_insert(&vp->v_pollinfo.vpi_kqinfo.ki_note, kn);
-	lwkt_reltoken(&vp->v_token);
-
-	return (0);
-}
-
-static void
-filt_ext2detach(struct knote *kn)
-{
-	struct vnode *vp = (struct vnode *)kn->kn_hook;
-
-	lwkt_gettoken(&vp->v_token);
-	knote_remove(&vp->v_pollinfo.vpi_kqinfo.ki_note, kn);
-	lwkt_reltoken(&vp->v_token);
-}
-
-/*ARGSUSED*/
-static int
-filt_ext2read(struct knote *kn, long hint)
-{
-	struct vnode *vp = (struct vnode *)kn->kn_hook;
-	struct inode *ip = VTOI(vp);
-	off_t off;
-
-	/*
-	 * filesystem is gone, so set the EOF flag and schedule
-	 * the knote for deletion.
-	 */
-	if (hint == NOTE_REVOKE) {
-		kn->kn_flags |= (EV_EOF | EV_NODATA | EV_ONESHOT);
-		return (1);
-	}
-        off = ip->i_size - kn->kn_fp->f_offset;
-	kn->kn_data = (off < INTPTR_MAX) ? off : INTPTR_MAX;
-	if (kn->kn_sfflags & NOTE_OLDAPI)
-		return(1);
-        return (kn->kn_data != 0);
-}
-
-/*ARGSUSED*/
-static int
-filt_ext2write(struct knote *kn, long hint)
-{
-	/*
-	 * filesystem is gone, so set the EOF flag and schedule
-	 * the knote for deletion.
-	 */
-	if (hint == NOTE_REVOKE)
-		kn->kn_flags |= (EV_EOF | EV_NODATA | EV_ONESHOT);
-
-        kn->kn_data = 0;
-        return (1);
-}
-
-static int
-filt_ext2vnode(struct knote *kn, long hint)
-{
-	if (kn->kn_sfflags & hint)
-		kn->kn_fflags |= hint;
-	if (hint == NOTE_REVOKE) {
-		kn->kn_flags |= (EV_EOF | EV_NODATA);
-		return (1);
-	}
-	return (kn->kn_fflags != 0);
-}
-
-struct vop_ops ext2_vnode_vops = {
-	.vop_default =		vop_defaultop,
-	.vop_fsync =		ext2_fsync,
-	.vop_read =		ext2_read,
-	.vop_reallocblks =	ext2_reallocblks,
-	.vop_write =		ext2_write,
-	.vop_access =		ext2_access,
-	.vop_advlock =		ext2_advlock,
-	.vop_bmap =		ext2_bmap,
-	.vop_old_lookup =	ext2_lookup,
-	.vop_close =		ext2_close,
-	.vop_old_create =	ext2_create,
-	.vop_getattr =		ext2_getattr,
-	.vop_inactive =		ext2_inactive,
-	.vop_old_link =		ext2_link,
-	.vop_old_mkdir =	ext2_mkdir,
-	.vop_old_mknod =	ext2_mknod,
-	.vop_open =		ext2_open,
-	.vop_pathconf =		ext2_pathconf,
-	.vop_kqfilter =		ext2_kqfilter,
-	.vop_print =		ext2_print,
-	.vop_readdir =		ext2_readdir,
-	.vop_readlink =		ext2_readlink,
-	.vop_reclaim =		ext2_reclaim,
-	.vop_old_remove =	ext2_remove,
-	.vop_old_rename =	ext2_rename,
-	.vop_old_rmdir =	ext2_rmdir,
-	.vop_setattr =		ext2_setattr,
-	.vop_strategy =		ext2_strategy,
-	.vop_old_symlink =	ext2_symlink,
-	.vop_old_whiteout =	ext2_whiteout,
-	.vop_getpages =		vop_stdgetpages,
-	.vop_putpages =		vop_stdputpages
-};
-
-struct vop_ops ext2_spec_vops = {
-	.vop_default =		vop_defaultop,
-	.vop_fsync =		ext2_fsync,
-	.vop_access =		ext2_access,
-	.vop_close =		ext2_close,
-	.vop_getattr =		ext2_getattr,
-	.vop_inactive =		ext2_inactive,
-	.vop_print =		ext2_print,
-	.vop_read =		vop_stdnoread,
-	.vop_reclaim =		ext2_reclaim,
-	.vop_setattr =		ext2_setattr,
-	.vop_write =		vop_stdnowrite
-};
-
-struct vop_ops ext2_fifo_vops = {
-	.vop_default =		ext2_vnoperatefifo,
-	.vop_fsync =		ext2_fsync,
-	.vop_access =		ext2_access,
-	.vop_close =		ext2fifo_close,
-	.vop_getattr =		ext2_getattr,
-	.vop_inactive =		ext2_inactive,
-	.vop_kqfilter =		ext2fifo_kqfilter,
-	.vop_print =		ext2_print,
-	.vop_read =		ext2fifo_read,
-	.vop_reclaim =		ext2_reclaim,
-	.vop_setattr =		ext2_setattr,
-	.vop_write =		ext2fifo_write
-};
-
-VNODEOP_SET(ext2_vnode_vops);
-VNODEOP_SET(ext2_spec_vops);
-VNODEOP_SET(ext2_fifo_vops);
-
-/*
- * ext2_vnoperate()
- */
-int
-ext2_vnoperate(struct vop_generic_args *ap)
-{
-	return (VOCALL(&ext2_vnode_vops, ap));
-}
-
-/*
- * ext2_vnoperatefifo()
- */
-int
-ext2_vnoperatefifo(struct vop_generic_args *ap)
-{
-	return (VOCALL(&ext2_fifo_vops, ap));
-}
diff --git a/sys/gnu/vfs/ext2fs/fs.h b/sys/gnu/vfs/ext2fs/fs.h
deleted file mode 100644
index f00de47bfe..0000000000
--- a/sys/gnu/vfs/ext2fs/fs.h
+++ /dev/null
@@ -1,198 +0,0 @@
-/*
- *  modified for EXT2FS support in Lites 1.1
- *
- *  Aug 1995, Godmar Back (gback@cs.utah.edu)
- *  University of Utah, Department of Computer Science
- */
-/*
- * Copyright (c) 1982, 1986, 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. 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.
- *
- *	@(#)fs.h	8.7 (Berkeley) 4/19/94
- * $FreeBSD: src/sys/gnu/ext2fs/fs.h,v 1.5.2.1 2000/11/11 13:12:45 bde Exp $
- */
-
-/*
- * Each disk drive contains some number of file systems.
- * A file system consists of a number of block groups.
- * Each block group has inodes and data.
- *
- * A file system is described by its super-block, which in turn
- * describes the block groups.  The super-block is critical
- * data and is replicated in each block group to protect against
- * catastrophic loss.  This is done at `newfs' time and the critical
- * super-block data does not change, so the copies need not be
- * referenced further unless disaster strikes.
- *
- * The first boot and super blocks are given in absolute disk addresses.
- * The byte-offset forms are preferred, as they don't imply a sector size.
- */
-
-#ifndef _LINUX_EXT2_FS_FS
-#define _LINUX_EXT2_FS_FS
-
-#define BBSIZE		1024
-#define SBSIZE		1024
-#define	BBOFF		((off_t)(0))
-#define	SBOFF		((off_t)(BBOFF + BBSIZE))
-#define	BBLOCK		((daddr_t)(0))
-#define	SBLOCK		((daddr_t)(BBLOCK + BBSIZE / DEV_BSIZE))
-
-/*
- * The path name on which the file system is mounted is maintained
- * in fs_fsmnt. MAXMNTLEN defines the amount of space allocated in
- * the super block for this name.
- */
-#define MAXMNTLEN 512
-
-/*
- * Macros for access to superblock array structures
- */
-
-/*
- * Convert block group to base address of its global summary info.
- */
-#define fs_cs(fs, cgindx)      (((struct ext2_group_desc *) \
-        (fs->s_group_desc[cgindx / EXT2_DESC_PER_BLOCK(fs)]->b_data)) \
-		[cgindx % EXT2_DESC_PER_BLOCK(fs)])
-
-/*
- * Turn file system block numbers into disk block addresses.
- * This maps file system blocks to device size blocks.
- */
-#define fsbtodb(fs, b)	((b) << ((fs)->s_fsbtodb))
-#define	dbtofsb(fs, b)	((b) >> ((fs)->s_fsbtodb))
-
-/* get group containing inode */
-#define ino_to_cg(fs, x)	(((x) - 1) / EXT2_INODES_PER_GROUP(fs))
-
-/* get block containing inode from its number x */
-#define	ino_to_fsba(fs, x)	(fs_cs(fs, ino_to_cg(fs, x)).bg_inode_table + \
-	(((x)-1) % EXT2_INODES_PER_GROUP(fs))/EXT2_INODES_PER_BLOCK(fs))
-
-/* get offset for inode in block */
-#define	ino_to_fsbo(fs, x)	((x-1) % EXT2_INODES_PER_BLOCK(fs))
-
-/*
- * Give block group number for a file system block.
- * Give block group block number for a file system block.
- */
-#define	dtog(fs, d)	(((d) - fs->s_es->s_first_data_block) / \
-			EXT2_BLOCKS_PER_GROUP(fs))
-#define	dtogd(fs, d)	(((d) - fs->s_es->s_first_data_block) % \
-			EXT2_BLOCKS_PER_GROUP(fs))
-
-/*
- * The following macros optimize certain frequently calculated
- * quantities by using shifts and masks in place of divisions
- * modulos and multiplications.
- */
-#define blkoff(fs, loc)		/* calculates (loc % fs->fs_bsize) */ \
-	((loc) & (fs)->s_qbmask)
-
-#define lblktosize(fs, blk)	/* calculates (blk * fs->fs_bsize) */ \
-	((blk) << (fs->s_bshift))
-
-/*
- * Used when converting logical blocks to offsets for getblk, bread,
- * etc.
- */
-#define lblktodoff(fs, blk)	/* calculates (blk * fs->fs_bsize) */ \
-	((off_t)(blk) << (fs)->s_bshift)
-#define fsbtodoff(fs, blk)	/* calculates (blk * fs->fs_fsize) */ \
-	((off_t)(blk) * (fs)->s_frag_size)
-#define dofftofsb(fs, blk)	/* calculates blk / fs->fs_fsize */   \
-	((daddr_t)((blk) / (fs)->s_frag_size))
-#define dbtodoff(fs, b)		/* calculates diskblk * sectorsize */ \
-	((off_t)(b) * ((fs)->s_frag_size >> (fs)->s_fsbtodb))
-
-#define lblkno(fs, loc)		/* calculates (loc / fs->fs_bsize) */ \
-	((loc) >> (fs->s_bshift))
-
-/* no fragments -> logical block number equal # of frags */
-#define numfrags(fs, loc)	/* calculates (loc / fs->fs_fsize) */ \
-	((loc) >> (fs->s_bshift))
-
-#define fragroundup(fs, size)	/* calculates roundup(size, fs->fs_fsize) */ \
-	roundup(size, fs->s_frag_size)
-	/* was (((size) + (fs)->fs_qfmask) & (fs)->fs_fmask) */
-
-/*
- * Determining the size of a file block in the file system.
- * easy w/o fragments
- */
-#define blksize(fs, ip, lbn) ((fs)->s_frag_size)
-
-/*
- * INOPB is the number of inodes in a secondary storage block.
- */
-#define	INOPB(fs)	EXT2_INODES_PER_BLOCK(fs)
-
-/*
- * NINDIR is the number of indirects in a file system block.
- */
-#define	NINDIR(fs)	(EXT2_ADDR_PER_BLOCK(fs))
-
-extern int inside[], around[];
-extern u_char *fragtbl[];
-
-/* a few remarks about superblock locking/unlocking
- * Linux provides special routines for doing so
- * I haven't figured out yet what BSD does
- * I think I'll try a vn_lock/vn_unlock on the device vnode
- */
-#define  DEVVP(inode)		(VFSTOEXT2(ITOV(inode)->v_mount)->um_devvp)
-#define  lock_super(devvp)	\
-		vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY | LK_FAILRECLAIM)
-#define  unlock_super(devvp) 	vn_unlock(devvp)
-
-/*
- * To lock a buffer, set the B_LOCKED flag and then brelse() it. To unlock,
- * reset the B_LOCKED flag and brelse() the buffer back on the LRU list
- */
-#define LCK_BUF(bp) { \
-	crit_enter(); \
-	(bp)->b_flags |= B_LOCKED; \
-	crit_exit(); \
-	brelse(bp); \
-}
-
-#define ULCK_BUF(bp) { \
-	long flags; \
-	crit_enter(); \
-	flags = (bp)->b_flags; \
-	(bp)->b_flags &= ~(B_DIRTY | B_LOCKED); \
-	BUF_LOCK(bp, LK_EXCLUSIVE); \
-	bremfree(bp); \
-	crit_exit(); \
-	if (flags & B_DIRTY) \
-		bwrite(bp); \
-	else \
-		brelse(bp); \
-}
-
-#endif /* _LINUX_EXT2_FS_FS */
diff --git a/sys/gnu/vfs/ext2fs/inode.h b/sys/gnu/vfs/ext2fs/inode.h
deleted file mode 100644
index 95ed718f3e..0000000000
--- a/sys/gnu/vfs/ext2fs/inode.h
+++ /dev/null
@@ -1,159 +0,0 @@
-/*-
- * Copyright (c) 1982, 1989, 1993
- *	The Regents of the University of California.  All rights reserved.
- * (c) UNIX System Laboratories, Inc.
- * All or some portions of this file are derived from material licensed
- * to the University of California by American Telephone and Telegraph
- * Co. or Unix System Laboratories, Inc. and are reproduced herein with
- * the permission of UNIX System Laboratories, Inc.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. 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.
- *
- *	@(#)inode.h	8.9 (Berkeley) 5/14/95
- * $FreeBSD: src/sys/ufs/ufs/inode.h,v 1.28.2.2 2001/09/29 12:52:52 iedowse Exp $
- */
-
-#ifndef _VFS_GNU_EXT2FS_INODE_H_
-#define	_VFS_GNU_EXT2FS_INODE_H_
-
-#if defined(_KERNEL) || defined(_KERNEL_STRUCTURES)
-
-#ifndef _SYS_LOCK_H_
-#include <sys/lock.h>
-#endif
-#ifndef _SYS_LOCKF_H
-#include <sys/lockf.h>
-#endif
-
-#endif
-
-#ifndef _SYS_QUEUE_H_
-#include <sys/queue.h>
-#endif
-#include "dinode.h"
-#include "dir.h"
-
-#if defined(_KERNEL) || defined(_KERNEL_STRUCTURES)
-
-/*
- * An EXT2FS inode is basically a UFS inode with some spare fields
- * redefined and a different superblock structure.
- */
-struct inode {
-	struct inode	*i_next;/* Hash chain */
-	struct	vnode  *i_vnode;/* Vnode associated with this inode. */
-	struct	vnode  *i_devvp;/* Vnode for block I/O. */
-	uint32_t i_flag;	/* flags, see below */
-	cdev_t	  i_dev;	/* Device associated with the inode. */
-	ino_t	  i_number;	/* The identity of the inode. */
-	int	  i_effnlink;	/* i_nlink when I/O completes */
-
-	struct	ext2_sb_info *i_e2fs;	/* EXT2FS */
-	struct	 ext2_dquot *i_dquot[MAXQUOTAS]; /* Dquot structures. */
-	u_quad_t i_modrev;	/* Revision level for NFS lease. */
-	struct	 lockf i_lockf;/* Head of byte-level lock list. */
-	/*
-	 * Side effects; used during directory lookup.
-	 */
-	int32_t	  i_count;	/* Size of free slot in directory. */
-	doff_t	  i_endoff;	/* End of useful stuff in directory. */
-	doff_t	  i_diroff;	/* Offset in dir, where we found last entry. */
-	doff_t	  i_offset;	/* Offset of free space in directory. */
-	ino_t	  i_ino;	/* Inode number of found directory. */
-	uint32_t i_reclen;	/* Size of found directory entry. */
-	uint32_t i_spare[3];	/* XXX actually non-spare (for ext2fs). */
-
-	struct dirhash *i_dirhash; /* Hashing for large directories */
-	/*
-	 * The on-disk dinode itself (128 bytes)
-	 */
-	struct	ext2_dinode i_din;
-};
-
-#ifndef NO_I_DEFINES
-
-#define	i_atime		i_din.di_atime
-#define	i_atimensec	i_din.di_atimensec
-#define	i_blocks	i_din.di_blocks
-#define	i_ctime		i_din.di_ctime
-#define	i_ctimensec	i_din.di_ctimensec
-#define	i_db		i_din.di_db
-#define	i_flags		i_din.di_flags
-#define	i_gen		i_din.di_gen
-#define	i_gid		i_din.di_gid
-#define	i_ib		i_din.di_ib
-#define	i_mode		i_din.di_mode
-#define	i_mtime		i_din.di_mtime
-#define	i_mtimensec	i_din.di_mtimensec
-#define	i_nlink		i_din.di_nlink
-#define	i_rdev		i_din.di_rdev
-#define	i_shortlink	i_din.di_shortlink
-#define	i_size		i_din.di_size
-#define	i_uid		i_din.di_uid
-
-#endif
-
-#endif
-
-/* These flags are kept in i_flag. */
-#define	IN_ACCESS	0x0001		/* Access time update request. */
-#define	IN_CHANGE	0x0002		/* Inode change time update request. */
-#define	IN_UPDATE	0x0004		/* Modification time update request. */
-#define	IN_MODIFIED	0x0008		/* Inode has been modified. */
-#define	IN_RENAME	0x0010		/* Inode is being renamed. */
-#define	IN_SHLOCK	0x0020		/* File has shared lock. */
-#define	IN_EXLOCK	0x0040		/* File has exclusive lock. */
-#define	IN_HASHED	0x0080		/* Inode is on hash list */
-#define	IN_LAZYMOD	0x0100		/* Modified, but don't write yet. */
-
-#if defined(_KERNEL) || defined(_KERNEL_STRUCTURES)
-
-/*
- * Structure used to pass around logical block paths generated by
- * ext2_getlbns and used by truncate and bmap code.
- */
-struct indir {
-	ext2_daddr_t in_lbn;		/* Logical block number. */
-	int	in_off;			/* Offset in buffer. */
-};
-
-/* Convert between inode pointers and vnode pointers. */
-#define VTOI(vp)	((struct inode *)(vp)->v_data)
-#define ITOV(ip)	((ip)->i_vnode)
-
-/* Determine if soft dependencies are being done */
-#define DOINGSOFTDEP(vp)	((vp)->v_mount->mnt_flag & MNT_SOFTDEP)
-#define DOINGASYNC(vp)		((vp)->v_mount->mnt_flag & MNT_ASYNC)
-
-/* This overlays the fid structure (see mount.h). */
-struct ufid {
-	uint16_t ufid_len;	/* Length of structure. */
-	uint16_t ufid_pad;	/* Force 32-bit alignment. */
-	ino_t	  ufid_ino;	/* File number (ino). */
-	int32_t	  ufid_gen;	/* Generation number. */
-};
-#endif /* _KERNEL || _KERNEL_STRUCTURES */
-
-#endif /* !_VFS_GNU_EXT2FS_INODE_H_ */
diff --git a/sys/gnu/vfs/ext2fs/quota.h b/sys/gnu/vfs/ext2fs/quota.h
deleted file mode 100644
index af952d8d03..0000000000
--- a/sys/gnu/vfs/ext2fs/quota.h
+++ /dev/null
@@ -1,200 +0,0 @@
-/*-
- * Copyright (c) 1982, 1986, 1993
- *	The Regents of the University of California.  All rights reserved.
- *
- * This code is derived from software contributed to Berkeley by
- * Robert Elz at The University of Melbourne.
- *
- * 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. 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.
- *
- *	@(#)quota.h	8.3 (Berkeley) 8/19/94
- * $FreeBSD: src/sys/ufs/ufs/quota.h,v 1.15.2.1 2003/02/27 12:04:13 das Exp $
- */
-
-#ifndef _VFS_GNU_EXT2FS_QUOTA_H_
-#define	_VFS_GNU_EXT2FS_QUOTA_H_
-
-/*
- * Definitions for disk quotas imposed on the average user
- * (big brother finally hits UNIX).
- *
- * The following constants define the amount of time given a user before the
- * soft limits are treated as hard limits (usually resulting in an allocation
- * failure). The timer is started when the user crosses their soft limit, it
- * is reset when they go below their soft limit.
- */
-#define	MAX_IQ_TIME	(7*24*60*60)	/* seconds in 1 week */
-#define	MAX_DQ_TIME	(7*24*60*60)	/* seconds in 1 week */
-
-/*
- * The following constants define the usage of the quota file array in the
- * ext2_mount structure and dquot array in the inode structure.  The semantics
- * of the elements of these arrays are defined in the routine getinoquota;
- * the remainder of the quota code treats them generically and need not be
- * inspected when changing the size of the array.
- */
-#define	MAXQUOTAS	2
-#define	USRQUOTA	0	/* element used for user quotas */
-#define	GRPQUOTA	1	/* element used for group quotas */
-
-/*
- * Definitions for the default names of the quotas files.
- */
-#define INITQFNAMES { \
-	"user",		/* USRQUOTA */ \
-	"group",	/* GRPQUOTA */ \
-	"undefined", \
-}
-#define	QUOTAFILENAME	"quota"
-#define	QUOTAGROUP	"operator"
-
-/*
- * Command definitions for the 'quotactl' system call.  The commands are
- * broken into a main command defined below and a subcommand that is used
- * to convey the type of quota that is being manipulated (see above).
- */
-#define SUBCMDMASK	0x00ff
-#define SUBCMDSHIFT	8
-#define	QCMD(cmd, type)	(((cmd) << SUBCMDSHIFT) | ((type) & SUBCMDMASK))
-
-#define	Q_QUOTAON	0x0100	/* enable quotas */
-#define	Q_QUOTAOFF	0x0200	/* disable quotas */
-#define	Q_GETQUOTA	0x0300	/* get limits and usage */
-#define	Q_SETQUOTA	0x0400	/* set limits and usage */
-#define	Q_SETUSE	0x0500	/* set usage */
-#define	Q_SYNC		0x0600	/* sync disk copy of a filesystems quotas */
-
-/*
- * The following structure defines the format of the disk quota file
- * (as it appears on disk) - the file is an array of these structures
- * indexed by user or group number.  The setquota system call establishes
- * the vnode for each quota file (a pointer is retained in the ext2_mount
- * structure).
- */
-struct ext2_dqblk {
-	uint32_t dqb_bhardlimit;	/* absolute limit on disk blks alloc */
-	uint32_t dqb_bsoftlimit;	/* preferred limit on disk blks */
-	uint32_t dqb_curblocks;	/* current block count */
-	uint32_t dqb_ihardlimit;	/* maximum # allocated inodes + 1 */
-	uint32_t dqb_isoftlimit;	/* preferred inode limit */
-	uint32_t dqb_curinodes;	/* current # allocated inodes */
-	time_t	  dqb_btime;		/* time limit for excessive disk use */
-	time_t	  dqb_itime;		/* time limit for excessive files */
-};
-
-#ifdef _KERNEL
-
-#include <sys/queue.h>
-
-/*
- * The following structure records disk usage for a user or group on a
- * filesystem. There is one allocated for each quota that exists on any
- * filesystem for the current user or group. A cache is kept of recently
- * used entries.
- */
-struct ext2_dquot {
-	LIST_ENTRY(ext2_dquot) dq_hash;	/* hash list */
-	TAILQ_ENTRY(ext2_dquot) dq_freelist;	/* free list */
-	uint16_t dq_flags;		/* flags, see below */
-	uint16_t dq_type;		/* quota type of this dquot */
-	uint32_t dq_cnt;		/* count of active references */
-	uint32_t dq_id;		/* identifier this applies to */
-	struct	ext2_mount *dq_ump;	/* filesystem that this is taken from */
-	struct	ext2_dqblk dq_dqb;	/* actual usage & quotas */
-};
-/*
- * Flag values.
- */
-#define	DQ_LOCK		0x01		/* this quota locked (no MODS) */
-#define	DQ_WANT		0x02		/* wakeup on unlock */
-#define	DQ_MOD		0x04		/* this quota modified since read */
-#define	DQ_FAKE		0x08		/* no limits here, just usage */
-#define	DQ_BLKS		0x10		/* has been warned about blk limit */
-#define	DQ_INODS	0x20		/* has been warned about inode limit */
-/*
- * Shorthand notation.
- */
-#define	dq_bhardlimit	dq_dqb.dqb_bhardlimit
-#define	dq_bsoftlimit	dq_dqb.dqb_bsoftlimit
-#define	dq_curblocks	dq_dqb.dqb_curblocks
-#define	dq_ihardlimit	dq_dqb.dqb_ihardlimit
-#define	dq_isoftlimit	dq_dqb.dqb_isoftlimit
-#define	dq_curinodes	dq_dqb.dqb_curinodes
-#define	dq_btime	dq_dqb.dqb_btime
-#define	dq_itime	dq_dqb.dqb_itime
-
-/*
- * If the system has never checked for a quota for this file, then it is
- * set to NODQUOT.  Once a write attempt is made the inode pointer is set
- * to reference a dquot structure.
- */
-#define	NODQUOT		NULL
-
-/*
- * Flags to ext2_chkdq() and ext2_chkiq()
- */
-#define	FORCE	0x01	/* force usage changes independent of limits */
-#define	CHOWN	0x02	/* (advisory) change initiated by chown */
-
-/*
- * Macros to avoid subroutine calls to trivial functions.
- */
-#ifdef DIAGNOSTIC
-#define	DQREF(dq)	ext2_dqref(dq)
-#else
-#define	DQREF(dq)	(dq)->dq_cnt++
-#endif
-
-struct inode;
-struct mount;
-struct proc;
-struct thread;
-struct ucred;
-struct vnode;
-
-int	ext2_chkdq(struct inode *, long, struct ucred *, int);
-int	ext2_chkiq(struct inode *, long, struct ucred *, int);
-void	ext2_dqinit(void);
-void	ext2_dqrele(struct vnode *, struct ext2_dquot *);
-int	ext2_getinoquota(struct inode *);
-int	ext2_getquota(struct mount *, u_long, int, caddr_t);
-int	ext2_qsync(struct mount *mp);
-int	ext2_quotaoff(struct mount *, int);
-int	ext2_quotaon(struct ucred *, struct mount *, int, caddr_t);
-int	ext2_setquota(struct mount *, u_long, int, caddr_t);
-int	ext2_setuse(struct mount *, u_long, int, caddr_t);
-int	ext2_quotactl(struct mount *, int, uid_t, caddr_t, struct ucred *);
-
-#else /* !_KERNEL */
-
-#include <sys/cdefs.h>
-
-__BEGIN_DECLS
-int	quotactl(const char *, int, int, void *);
-__END_DECLS
-
-#endif /* _KERNEL */
-
-#endif /* !_VFS_GNU_EXT2FS_QUOTA_H_ */
diff --git a/sys/sys/param.h b/sys/sys/param.h
index d78e21ac9f..150b517347 100644
--- a/sys/sys/param.h
+++ b/sys/sys/param.h
@@ -235,9 +235,10 @@
  * 600104 - add posix_fallocate()
  * 600105 - add fdatasync()
  * 600106 - msdosfs support in makefs(8)
+ * 600107 - remove sys/gnu/vfs/ext2fs
  */
 #undef __DragonFly_version
-#define __DragonFly_version 600106	/* propagated to newvers */
+#define __DragonFly_version 600107	/* propagated to newvers */
 
 #include <sys/_null.h>
 
diff --git a/sys/vfs/ext2fs/Makefile b/sys/vfs/ext2fs/Makefile
index 53fa01a7da..f1beff9e2f 100644
--- a/sys/vfs/ext2fs/Makefile
+++ b/sys/vfs/ext2fs/Makefile
@@ -1,4 +1,4 @@
-KMOD=	ext2fs_freebsd
+KMOD=	ext2fs
 SRCS=	ext2_alloc.c ext2_balloc.c ext2_bmap.c ext2_csum.c ext2_extents.c ext2_hash.c ext2_htree.c ext2_ihash.c ext2_inode.c ext2_inode_cnv.c ext2_lookup.c ext2_subr.c ext2_vfsops.c ext2_vnops.c
 
 .include <bsd.kmod.mk>
diff --git a/usr.bin/fstat/ext2fs.c b/usr.bin/fstat/ext2fs.c
index 35dbdef02e..9045503d0c 100644
--- a/usr.bin/fstat/ext2fs.c
+++ b/usr.bin/fstat/ext2fs.c
@@ -32,8 +32,8 @@
 #define _KERNEL_STRUCTURES
 #include <sys/vnode.h>
 #include <sys/mount.h>
-#include <gnu/vfs/ext2fs/quota.h>
-#include <gnu/vfs/ext2fs/inode.h>
+#include <vfs/ext2fs/inode.h>
+#define VTOI(vp)	((struct inode *)(vp)->v_data)
 #undef _KERNEL_STRUCTURES
 
 #include <stdio.h>
@@ -53,7 +53,7 @@ ext2fs_filestat(struct vnode *vp, struct filestat *fsp)
 	}
 	fsp->mode = ino.i_mode | mtrans(vp->v_type);
 	fsp->rdev = fsp->fsid = fstat_dev2udev(ino.i_dev);
-	fsp->size = ino.i_din.di_size;
+	fsp->size = ino.i_size;
 	fsp->fileid = ino.i_number;
 
 	return 1;
-- 
2.28.0

