Home | History | Annotate | Line # | Download | only in ext2fs
ext2fs_vfsops.c revision 1.178
      1  1.178   hannken /*	$NetBSD: ext2fs_vfsops.c,v 1.178 2014/03/17 09:30:32 hannken Exp $	*/
      2    1.1    bouyer 
      3    1.1    bouyer /*
      4    1.1    bouyer  * Copyright (c) 1989, 1991, 1993, 1994
      5    1.1    bouyer  *	The Regents of the University of California.  All rights reserved.
      6    1.1    bouyer  *
      7    1.1    bouyer  * Redistribution and use in source and binary forms, with or without
      8    1.1    bouyer  * modification, are permitted provided that the following conditions
      9    1.1    bouyer  * are met:
     10    1.1    bouyer  * 1. Redistributions of source code must retain the above copyright
     11   1.18  christos  *    notice, this list of conditions and the following disclaimer.
     12    1.1    bouyer  * 2. Redistributions in binary form must reproduce the above copyright
     13   1.18  christos  *    notice, this list of conditions and the following disclaimer in the
     14   1.18  christos  *    documentation and/or other materials provided with the distribution.
     15   1.61       agc  * 3. Neither the name of the University nor the names of its contributors
     16   1.61       agc  *    may be used to endorse or promote products derived from this software
     17   1.61       agc  *    without specific prior written permission.
     18   1.61       agc  *
     19   1.61       agc  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     20   1.61       agc  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     21   1.61       agc  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     22   1.61       agc  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     23   1.61       agc  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     24   1.61       agc  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     25   1.61       agc  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     26   1.61       agc  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     27   1.61       agc  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     28   1.61       agc  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     29   1.61       agc  * SUCH DAMAGE.
     30   1.61       agc  *
     31   1.61       agc  *	@(#)ffs_vfsops.c	8.14 (Berkeley) 11/28/94
     32   1.61       agc  * Modified for ext2fs by Manuel Bouyer.
     33   1.61       agc  */
     34   1.61       agc 
     35   1.61       agc /*
     36   1.61       agc  * Copyright (c) 1997 Manuel Bouyer.
     37   1.61       agc  *
     38   1.61       agc  * Redistribution and use in source and binary forms, with or without
     39   1.61       agc  * modification, are permitted provided that the following conditions
     40   1.61       agc  * are met:
     41   1.61       agc  * 1. Redistributions of source code must retain the above copyright
     42   1.61       agc  *    notice, this list of conditions and the following disclaimer.
     43   1.61       agc  * 2. Redistributions in binary form must reproduce the above copyright
     44   1.61       agc  *    notice, this list of conditions and the following disclaimer in the
     45   1.61       agc  *    documentation and/or other materials provided with the distribution.
     46    1.1    bouyer  *
     47   1.65    bouyer  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
     48   1.65    bouyer  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
     49   1.65    bouyer  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
     50   1.65    bouyer  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
     51   1.65    bouyer  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
     52   1.65    bouyer  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
     53   1.65    bouyer  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
     54   1.65    bouyer  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     55   1.65    bouyer  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
     56   1.65    bouyer  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     57    1.1    bouyer  *
     58    1.1    bouyer  *	@(#)ffs_vfsops.c	8.14 (Berkeley) 11/28/94
     59    1.1    bouyer  * Modified for ext2fs by Manuel Bouyer.
     60    1.1    bouyer  */
     61   1.48     lukem 
     62   1.48     lukem #include <sys/cdefs.h>
     63  1.178   hannken __KERNEL_RCSID(0, "$NetBSD: ext2fs_vfsops.c,v 1.178 2014/03/17 09:30:32 hannken Exp $");
     64   1.15  jonathan 
     65   1.43       mrg #if defined(_KERNEL_OPT)
     66   1.15  jonathan #include "opt_compat_netbsd.h"
     67   1.15  jonathan #endif
     68   1.13  sommerfe 
     69    1.1    bouyer #include <sys/param.h>
     70    1.1    bouyer #include <sys/systm.h>
     71   1.64    atatat #include <sys/sysctl.h>
     72    1.1    bouyer #include <sys/namei.h>
     73    1.1    bouyer #include <sys/proc.h>
     74    1.1    bouyer #include <sys/kernel.h>
     75    1.1    bouyer #include <sys/vnode.h>
     76    1.1    bouyer #include <sys/socket.h>
     77    1.1    bouyer #include <sys/mount.h>
     78    1.1    bouyer #include <sys/buf.h>
     79    1.1    bouyer #include <sys/device.h>
     80    1.1    bouyer #include <sys/mbuf.h>
     81    1.1    bouyer #include <sys/file.h>
     82    1.1    bouyer #include <sys/disklabel.h>
     83    1.1    bouyer #include <sys/ioctl.h>
     84    1.1    bouyer #include <sys/errno.h>
     85    1.1    bouyer #include <sys/malloc.h>
     86   1.17   thorpej #include <sys/pool.h>
     87    1.3    bouyer #include <sys/lock.h>
     88   1.51   gehenna #include <sys/conf.h>
     89   1.97      elad #include <sys/kauth.h>
     90  1.135    rumble #include <sys/module.h>
     91    1.1    bouyer 
     92  1.129  dholland #include <miscfs/genfs/genfs.h>
     93    1.1    bouyer #include <miscfs/specfs/specdev.h>
     94    1.1    bouyer 
     95    1.1    bouyer #include <ufs/ufs/quota.h>
     96    1.1    bouyer #include <ufs/ufs/ufsmount.h>
     97    1.1    bouyer #include <ufs/ufs/inode.h>
     98    1.1    bouyer #include <ufs/ufs/dir.h>
     99    1.1    bouyer #include <ufs/ufs/ufs_extern.h>
    100    1.1    bouyer 
    101    1.1    bouyer #include <ufs/ext2fs/ext2fs.h>
    102   1.88  christos #include <ufs/ext2fs/ext2fs_dir.h>
    103    1.1    bouyer #include <ufs/ext2fs/ext2fs_extern.h>
    104    1.1    bouyer 
    105  1.139        ad MODULE(MODULE_CLASS_VFS, ext2fs, "ffs");
    106  1.135    rumble 
    107   1.89   xtraeme int ext2fs_sbupdate(struct ufsmount *, int);
    108   1.89   xtraeme static int ext2fs_checksb(struct ext2fs *, int);
    109    1.7   thorpej 
    110  1.137    rumble static struct sysctllog *ext2fs_sysctl_log;
    111  1.137    rumble 
    112   1.42  jdolecek extern const struct vnodeopv_desc ext2fs_vnodeop_opv_desc;
    113   1.42  jdolecek extern const struct vnodeopv_desc ext2fs_specop_opv_desc;
    114   1.42  jdolecek extern const struct vnodeopv_desc ext2fs_fifoop_opv_desc;
    115    1.7   thorpej 
    116   1.42  jdolecek const struct vnodeopv_desc * const ext2fs_vnodeopv_descs[] = {
    117    1.7   thorpej 	&ext2fs_vnodeop_opv_desc,
    118    1.7   thorpej 	&ext2fs_specop_opv_desc,
    119    1.7   thorpej 	&ext2fs_fifoop_opv_desc,
    120    1.7   thorpej 	NULL,
    121    1.7   thorpej };
    122    1.1    bouyer 
    123    1.1    bouyer struct vfsops ext2fs_vfsops = {
    124    1.1    bouyer 	MOUNT_EXT2FS,
    125  1.113       dsl 	sizeof (struct ufs_args),
    126    1.1    bouyer 	ext2fs_mount,
    127    1.1    bouyer 	ufs_start,
    128    1.1    bouyer 	ext2fs_unmount,
    129    1.1    bouyer 	ufs_root,
    130    1.1    bouyer 	ufs_quotactl,
    131   1.67  christos 	ext2fs_statvfs,
    132    1.1    bouyer 	ext2fs_sync,
    133    1.1    bouyer 	ext2fs_vget,
    134    1.1    bouyer 	ext2fs_fhtovp,
    135    1.1    bouyer 	ext2fs_vptofh,
    136    1.1    bouyer 	ext2fs_init,
    137   1.44       chs 	ext2fs_reinit,
    138   1.34  jdolecek 	ext2fs_done,
    139    1.1    bouyer 	ext2fs_mountroot,
    140   1.72   hannken 	(int (*)(struct mount *, struct vnode *, struct timespec *)) eopnotsupp,
    141   1.78   thorpej 	vfs_stdextattrctl,
    142  1.116     pooka 	(void *)eopnotsupp,	/* vfs_suspendctl */
    143  1.129  dholland 	genfs_renamelock_enter,
    144  1.129  dholland 	genfs_renamelock_exit,
    145  1.132        ad 	(void *)eopnotsupp,
    146    1.8  drochner 	ext2fs_vnodeopv_descs,
    147  1.101  christos 	0,
    148  1.101  christos 	{ NULL, NULL },
    149    1.1    bouyer };
    150    1.1    bouyer 
    151   1.86      yamt static const struct genfs_ops ext2fs_genfsops = {
    152   1.86      yamt 	.gop_size = genfs_size,
    153   1.86      yamt 	.gop_alloc = ext2fs_gop_alloc,
    154   1.86      yamt 	.gop_write = genfs_gop_write,
    155   1.87      yamt 	.gop_markupdate = ufs_gop_markupdate,
    156   1.45       chs };
    157   1.45       chs 
    158   1.92      yamt static const struct ufs_ops ext2fs_ufsops = {
    159   1.92      yamt 	.uo_itimes = ext2fs_itimes,
    160   1.93      yamt 	.uo_update = ext2fs_update,
    161  1.126        ad 	.uo_vfree = ext2fs_vfree,
    162   1.92      yamt };
    163   1.92      yamt 
    164  1.140       mrg /* Fill in the inode uid/gid from ext2 halves.  */
    165  1.152     pooka void
    166  1.140       mrg ext2fs_set_inode_guid(struct inode *ip)
    167  1.140       mrg {
    168  1.140       mrg 
    169  1.140       mrg 	ip->i_gid = ip->i_e2fs_gid;
    170  1.140       mrg 	ip->i_uid = ip->i_e2fs_uid;
    171  1.140       mrg 	if (ip->i_e2fs->e2fs.e2fs_rev > E2FS_REV0) {
    172  1.140       mrg 		ip->i_gid |= ip->i_e2fs_gid_high << 16;
    173  1.140       mrg 		ip->i_uid |= ip->i_e2fs_uid_high << 16;
    174  1.140       mrg 	}
    175  1.140       mrg }
    176  1.140       mrg 
    177  1.135    rumble static int
    178  1.135    rumble ext2fs_modcmd(modcmd_t cmd, void *arg)
    179  1.135    rumble {
    180  1.137    rumble 	int error;
    181  1.135    rumble 
    182  1.135    rumble 	switch (cmd) {
    183  1.135    rumble 	case MODULE_CMD_INIT:
    184  1.137    rumble 		error = vfs_attach(&ext2fs_vfsops);
    185  1.137    rumble 		if (error != 0)
    186  1.137    rumble 			break;
    187  1.137    rumble 		sysctl_createv(&ext2fs_sysctl_log, 0, NULL, NULL,
    188  1.137    rumble 			       CTLFLAG_PERMANENT,
    189  1.137    rumble 			       CTLTYPE_NODE, "ext2fs",
    190  1.137    rumble 			       SYSCTL_DESCR("Linux EXT2FS file system"),
    191  1.137    rumble 			       NULL, 0, NULL, 0,
    192  1.137    rumble 			       CTL_VFS, 17, CTL_EOL);
    193  1.137    rumble 		/*
    194  1.137    rumble 		 * XXX the "17" above could be dynamic, thereby eliminating
    195  1.137    rumble 		 * one more instance of the "number to vfs" mapping problem,
    196  1.137    rumble 		 * but "17" is the order as taken from sys/mount.h
    197  1.137    rumble 		 */
    198  1.137    rumble 		break;
    199  1.135    rumble 	case MODULE_CMD_FINI:
    200  1.137    rumble 		error = vfs_detach(&ext2fs_vfsops);
    201  1.137    rumble 		if (error != 0)
    202  1.137    rumble 			break;
    203  1.137    rumble 		sysctl_teardown(&ext2fs_sysctl_log);
    204  1.137    rumble 		break;
    205  1.135    rumble 	default:
    206  1.137    rumble 		error = ENOTTY;
    207  1.137    rumble 		break;
    208  1.135    rumble 	}
    209  1.137    rumble 
    210  1.137    rumble 	return (error);
    211  1.135    rumble }
    212  1.135    rumble 
    213   1.68    simonb /*
    214   1.68    simonb  * XXX Same structure as FFS inodes?  Should we share a common pool?
    215   1.68    simonb  */
    216  1.112     pooka struct pool ext2fs_inode_pool;
    217  1.112     pooka struct pool ext2fs_dinode_pool;
    218   1.17   thorpej 
    219    1.1    bouyer extern u_long ext2gennumber;
    220    1.1    bouyer 
    221    1.9      fvdl void
    222   1.89   xtraeme ext2fs_init(void)
    223    1.9      fvdl {
    224  1.112     pooka 
    225   1.70    atatat 	pool_init(&ext2fs_inode_pool, sizeof(struct inode), 0, 0, 0,
    226  1.110        ad 	    "ext2fsinopl", &pool_allocator_nointr, IPL_NONE);
    227   1.70    atatat 	pool_init(&ext2fs_dinode_pool, sizeof(struct ext2fs_dinode), 0, 0, 0,
    228  1.110        ad 	    "ext2dinopl", &pool_allocator_nointr, IPL_NONE);
    229   1.19    bouyer 	ufs_init();
    230   1.44       chs }
    231   1.44       chs 
    232   1.44       chs void
    233   1.89   xtraeme ext2fs_reinit(void)
    234   1.44       chs {
    235   1.44       chs 	ufs_reinit();
    236    1.9      fvdl }
    237    1.9      fvdl 
    238   1.34  jdolecek void
    239   1.89   xtraeme ext2fs_done(void)
    240   1.34  jdolecek {
    241  1.112     pooka 
    242   1.34  jdolecek 	ufs_done();
    243   1.34  jdolecek 	pool_destroy(&ext2fs_inode_pool);
    244   1.70    atatat 	pool_destroy(&ext2fs_dinode_pool);
    245   1.34  jdolecek }
    246    1.1    bouyer 
    247    1.1    bouyer /*
    248    1.1    bouyer  * Called by main() when ext2fs is going to be mounted as root.
    249    1.1    bouyer  *
    250    1.1    bouyer  * Name is updated by mount(8) after booting.
    251    1.1    bouyer  */
    252    1.1    bouyer #define ROOTNAME	"root_device"
    253    1.1    bouyer 
    254    1.1    bouyer int
    255   1.89   xtraeme ext2fs_mountroot(void)
    256    1.1    bouyer {
    257    1.1    bouyer 	extern struct vnode *rootvp;
    258    1.9      fvdl 	struct m_ext2fs *fs;
    259    1.9      fvdl 	struct mount *mp;
    260    1.1    bouyer 	struct ufsmount *ump;
    261    1.1    bouyer 	int error;
    262    1.1    bouyer 
    263   1.95   thorpej 	if (device_class(root_device) != DV_DISK)
    264    1.1    bouyer 		return (ENODEV);
    265   1.83     perry 
    266   1.27  wrstuden 	if ((error = vfs_rootmountalloc(MOUNT_EXT2FS, "root_device", &mp))) {
    267   1.27  wrstuden 		vrele(rootvp);
    268    1.9      fvdl 		return (error);
    269   1.27  wrstuden 	}
    270    1.9      fvdl 
    271  1.123     pooka 	if ((error = ext2fs_mountfs(rootvp, mp)) != 0) {
    272  1.133        ad 		vfs_unbusy(mp, false, NULL);
    273  1.134        ad 		vfs_destroy(mp);
    274    1.1    bouyer 		return (error);
    275    1.1    bouyer 	}
    276  1.175  christos 	mountlist_append(mp);
    277    1.1    bouyer 	ump = VFSTOUFS(mp);
    278    1.1    bouyer 	fs = ump->um_e2fs;
    279   1.16     perry 	memset(fs->e2fs_fsmnt, 0, sizeof(fs->e2fs_fsmnt));
    280    1.9      fvdl 	(void) copystr(mp->mnt_stat.f_mntonname, fs->e2fs_fsmnt,
    281   1.31    bouyer 	    sizeof(fs->e2fs_fsmnt) - 1, 0);
    282   1.31    bouyer 	if (fs->e2fs.e2fs_rev > E2FS_REV0) {
    283   1.31    bouyer 		memset(fs->e2fs.e2fs_fsmnt, 0, sizeof(fs->e2fs.e2fs_fsmnt));
    284   1.31    bouyer 		(void) copystr(mp->mnt_stat.f_mntonname, fs->e2fs.e2fs_fsmnt,
    285   1.31    bouyer 		    sizeof(fs->e2fs.e2fs_fsmnt) - 1, 0);
    286   1.31    bouyer 	}
    287  1.123     pooka 	(void)ext2fs_statvfs(mp, &mp->mnt_stat);
    288  1.133        ad 	vfs_unbusy(mp, false, NULL);
    289   1.73        pk 	setrootfstime((time_t)fs->e2fs.e2fs_wtime);
    290    1.1    bouyer 	return (0);
    291    1.1    bouyer }
    292    1.1    bouyer 
    293    1.1    bouyer /*
    294    1.1    bouyer  * VFS Operations.
    295    1.1    bouyer  *
    296    1.1    bouyer  * mount system call
    297    1.1    bouyer  */
    298    1.1    bouyer int
    299  1.123     pooka ext2fs_mount(struct mount *mp, const char *path, void *data, size_t *data_len)
    300    1.1    bouyer {
    301  1.123     pooka 	struct lwp *l = curlwp;
    302    1.1    bouyer 	struct vnode *devvp;
    303  1.113       dsl 	struct ufs_args *args = data;
    304    1.1    bouyer 	struct ufsmount *ump = NULL;
    305   1.35  augustss 	struct m_ext2fs *fs;
    306    1.1    bouyer 	size_t size;
    307  1.113       dsl 	int error = 0, flags, update;
    308    1.1    bouyer 	mode_t accessmode;
    309   1.52  christos 
    310  1.113       dsl 	if (*data_len < sizeof *args)
    311  1.113       dsl 		return EINVAL;
    312  1.113       dsl 
    313   1.52  christos 	if (mp->mnt_flag & MNT_GETARGS) {
    314   1.52  christos 		ump = VFSTOUFS(mp);
    315   1.52  christos 		if (ump == NULL)
    316   1.52  christos 			return EIO;
    317  1.113       dsl 		memset(args, 0, sizeof *args);
    318  1.113       dsl 		args->fspec = NULL;
    319  1.113       dsl 		*data_len = sizeof *args;
    320  1.113       dsl 		return 0;
    321   1.52  christos 	}
    322   1.80   mycroft 
    323   1.80   mycroft 	update = mp->mnt_flag & MNT_UPDATE;
    324   1.80   mycroft 
    325   1.81   mycroft 	/* Check arguments */
    326  1.113       dsl 	if (args->fspec != NULL) {
    327   1.80   mycroft 		/*
    328   1.80   mycroft 		 * Look up the name and verify that it's sane.
    329   1.80   mycroft 		 */
    330  1.144  dholland 		error = namei_simple_user(args->fspec,
    331  1.144  dholland 					NSM_FOLLOW_NOEMULROOT, &devvp);
    332  1.144  dholland 		if (error != 0)
    333   1.80   mycroft 			return (error);
    334   1.80   mycroft 
    335   1.80   mycroft 		if (!update) {
    336   1.80   mycroft 			/*
    337   1.80   mycroft 			 * Be sure this is a valid block device
    338   1.80   mycroft 			 */
    339   1.80   mycroft 			if (devvp->v_type != VBLK)
    340   1.80   mycroft 				error = ENOTBLK;
    341   1.80   mycroft 			else if (bdevsw_lookup(devvp->v_rdev) == NULL)
    342   1.80   mycroft 				error = ENXIO;
    343   1.80   mycroft 		} else {
    344   1.80   mycroft 		        /*
    345   1.80   mycroft 			 * Be sure we're still naming the same device
    346   1.80   mycroft 			 * used for our initial mount
    347   1.80   mycroft 			 */
    348   1.81   mycroft 			ump = VFSTOUFS(mp);
    349  1.146   tsutsui 			if (devvp != ump->um_devvp) {
    350  1.146   tsutsui 				if (devvp->v_rdev != ump->um_devvp->v_rdev)
    351  1.146   tsutsui 					error = EINVAL;
    352  1.146   tsutsui 				else {
    353  1.146   tsutsui 					vrele(devvp);
    354  1.146   tsutsui 					devvp = ump->um_devvp;
    355  1.146   tsutsui 					vref(devvp);
    356  1.146   tsutsui 				}
    357  1.146   tsutsui 			}
    358   1.80   mycroft 		}
    359   1.81   mycroft 	} else {
    360   1.81   mycroft 		if (!update) {
    361   1.81   mycroft 			/* New mounts must have a filename for the device */
    362   1.81   mycroft 			return (EINVAL);
    363   1.81   mycroft 		} else {
    364   1.81   mycroft 			ump = VFSTOUFS(mp);
    365   1.81   mycroft 			devvp = ump->um_devvp;
    366   1.81   mycroft 			vref(devvp);
    367   1.81   mycroft 		}
    368   1.80   mycroft 	}
    369   1.80   mycroft 
    370   1.80   mycroft 	/*
    371   1.80   mycroft 	 * If mount by non-root, then verify that user has necessary
    372   1.80   mycroft 	 * permissions on the device.
    373  1.143      elad 	 *
    374  1.143      elad 	 * Permission to update a mount is checked higher, so here we presume
    375  1.143      elad 	 * updating the mount is okay (for example, as far as securelevel goes)
    376  1.143      elad 	 * which leaves us with the normal check.
    377   1.80   mycroft 	 */
    378  1.145   tsutsui 	if (error == 0) {
    379  1.145   tsutsui 		accessmode = VREAD;
    380  1.145   tsutsui 		if (update ?
    381  1.145   tsutsui 		    (mp->mnt_iflag & IMNT_WANTRDWR) != 0 :
    382  1.145   tsutsui 		    (mp->mnt_flag & MNT_RDONLY) == 0)
    383  1.145   tsutsui 			accessmode |= VWRITE;
    384  1.145   tsutsui 		vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
    385  1.163      elad 		error = kauth_authorize_system(l->l_cred, KAUTH_SYSTEM_MOUNT,
    386  1.163      elad 		    KAUTH_REQ_SYSTEM_MOUNT_DEVICE, mp, devvp,
    387  1.163      elad 		    KAUTH_ARG(accessmode));
    388  1.157   hannken 		VOP_UNLOCK(devvp);
    389  1.145   tsutsui 	}
    390   1.80   mycroft 
    391   1.80   mycroft 	if (error) {
    392   1.80   mycroft 		vrele(devvp);
    393   1.80   mycroft 		return (error);
    394   1.80   mycroft 	}
    395   1.80   mycroft 
    396   1.80   mycroft 	if (!update) {
    397   1.85  christos 		int xflags;
    398   1.80   mycroft 
    399   1.80   mycroft 		if (mp->mnt_flag & MNT_RDONLY)
    400   1.85  christos 			xflags = FREAD;
    401   1.80   mycroft 		else
    402   1.85  christos 			xflags = FREAD|FWRITE;
    403  1.162   hannken 		vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
    404  1.123     pooka 		error = VOP_OPEN(devvp, xflags, FSCRED);
    405  1.162   hannken 		VOP_UNLOCK(devvp);
    406   1.80   mycroft 		if (error)
    407   1.80   mycroft 			goto fail;
    408  1.123     pooka 		error = ext2fs_mountfs(devvp, mp);
    409   1.80   mycroft 		if (error) {
    410   1.80   mycroft 			vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
    411  1.123     pooka 			(void)VOP_CLOSE(devvp, xflags, NOCRED);
    412  1.157   hannken 			VOP_UNLOCK(devvp);
    413   1.80   mycroft 			goto fail;
    414   1.80   mycroft 		}
    415   1.80   mycroft 
    416    1.1    bouyer 		ump = VFSTOUFS(mp);
    417    1.1    bouyer 		fs = ump->um_e2fs;
    418   1.80   mycroft 	} else {
    419   1.80   mycroft 		/*
    420   1.80   mycroft 		 * Update the mount.
    421   1.80   mycroft 		 */
    422   1.80   mycroft 
    423   1.80   mycroft 		/*
    424   1.80   mycroft 		 * The initial mount got a reference on this
    425   1.80   mycroft 		 * device, so drop the one obtained via
    426   1.80   mycroft 		 * namei(), above.
    427   1.80   mycroft 		 */
    428   1.80   mycroft 		vrele(devvp);
    429   1.80   mycroft 
    430   1.81   mycroft 		ump = VFSTOUFS(mp);
    431   1.80   mycroft 		fs = ump->um_e2fs;
    432    1.1    bouyer 		if (fs->e2fs_ronly == 0 && (mp->mnt_flag & MNT_RDONLY)) {
    433   1.80   mycroft 			/*
    434   1.80   mycroft 			 * Changing from r/w to r/o
    435   1.80   mycroft 			 */
    436    1.1    bouyer 			flags = WRITECLOSE;
    437    1.1    bouyer 			if (mp->mnt_flag & MNT_FORCE)
    438    1.1    bouyer 				flags |= FORCECLOSE;
    439  1.123     pooka 			error = ext2fs_flushfiles(mp, flags);
    440    1.1    bouyer 			if (error == 0 &&
    441   1.80   mycroft 			    ext2fs_cgupdate(ump, MNT_WAIT) == 0 &&
    442   1.80   mycroft 			    (fs->e2fs.e2fs_state & E2FS_ERRORS) == 0) {
    443    1.1    bouyer 				fs->e2fs.e2fs_state = E2FS_ISCLEAN;
    444    1.1    bouyer 				(void) ext2fs_sbupdate(ump, MNT_WAIT);
    445    1.1    bouyer 			}
    446    1.1    bouyer 			if (error)
    447    1.1    bouyer 				return (error);
    448    1.1    bouyer 			fs->e2fs_ronly = 1;
    449    1.1    bouyer 		}
    450   1.80   mycroft 
    451    1.1    bouyer 		if (mp->mnt_flag & MNT_RELOAD) {
    452  1.149   tsutsui 			error = ext2fs_reload(mp, l->l_cred, l);
    453    1.1    bouyer 			if (error)
    454    1.1    bouyer 				return (error);
    455    1.1    bouyer 		}
    456   1.80   mycroft 
    457   1.63       dbj 		if (fs->e2fs_ronly && (mp->mnt_iflag & IMNT_WANTRDWR)) {
    458    1.1    bouyer 			/*
    459   1.80   mycroft 			 * Changing from read-only to read/write
    460    1.1    bouyer 			 */
    461    1.1    bouyer 			fs->e2fs_ronly = 0;
    462    1.1    bouyer 			if (fs->e2fs.e2fs_state == E2FS_ISCLEAN)
    463    1.1    bouyer 				fs->e2fs.e2fs_state = 0;
    464    1.1    bouyer 			else
    465    1.1    bouyer 				fs->e2fs.e2fs_state = E2FS_ERRORS;
    466    1.1    bouyer 			fs->e2fs_fmod = 1;
    467    1.1    bouyer 		}
    468  1.113       dsl 		if (args->fspec == NULL)
    469  1.147   tsutsui 			return 0;
    470    1.1    bouyer 	}
    471    1.1    bouyer 
    472  1.113       dsl 	error = set_statvfs_info(path, UIO_USERSPACE, args->fspec,
    473  1.114     pooka 	    UIO_USERSPACE, mp->mnt_op->vfs_name, mp, l);
    474   1.57  christos 	(void) copystr(mp->mnt_stat.f_mntonname, fs->e2fs_fsmnt,
    475   1.57  christos 	    sizeof(fs->e2fs_fsmnt) - 1, &size);
    476   1.16     perry 	memset(fs->e2fs_fsmnt + size, 0, sizeof(fs->e2fs_fsmnt) - size);
    477   1.31    bouyer 	if (fs->e2fs.e2fs_rev > E2FS_REV0) {
    478   1.31    bouyer 		(void) copystr(mp->mnt_stat.f_mntonname, fs->e2fs.e2fs_fsmnt,
    479   1.31    bouyer 		    sizeof(fs->e2fs.e2fs_fsmnt) - 1, &size);
    480   1.31    bouyer 		memset(fs->e2fs.e2fs_fsmnt, 0,
    481   1.31    bouyer 		    sizeof(fs->e2fs.e2fs_fsmnt) - size);
    482   1.31    bouyer 	}
    483    1.1    bouyer 	if (fs->e2fs_fmod != 0) {	/* XXX */
    484    1.1    bouyer 		fs->e2fs_fmod = 0;
    485    1.1    bouyer 		if (fs->e2fs.e2fs_state == 0)
    486   1.98    kardel 			fs->e2fs.e2fs_wtime = time_second;
    487    1.1    bouyer 		else
    488    1.1    bouyer 			printf("%s: file system not clean; please fsck(8)\n",
    489    1.1    bouyer 				mp->mnt_stat.f_mntfromname);
    490    1.1    bouyer 		(void) ext2fs_cgupdate(ump, MNT_WAIT);
    491    1.1    bouyer 	}
    492   1.80   mycroft 	return (error);
    493   1.80   mycroft 
    494   1.80   mycroft fail:
    495   1.80   mycroft 	vrele(devvp);
    496   1.80   mycroft 	return (error);
    497    1.1    bouyer }
    498    1.1    bouyer 
    499    1.1    bouyer /*
    500    1.1    bouyer  * Reload all incore data for a filesystem (used after running fsck on
    501    1.1    bouyer  * the root filesystem and finding things to fix). The filesystem must
    502    1.1    bouyer  * be mounted read-only.
    503    1.1    bouyer  *
    504    1.1    bouyer  * Things to do to update the mount:
    505    1.1    bouyer  *	1) invalidate all cached meta-data.
    506    1.1    bouyer  *	2) re-read superblock from disk.
    507    1.1    bouyer  *	3) re-read summary information from disk.
    508    1.1    bouyer  *	4) invalidate all inactive vnodes.
    509    1.1    bouyer  *	5) invalidate all cached file data.
    510    1.1    bouyer  *	6) re-read inode data for all active vnodes.
    511    1.1    bouyer  */
    512    1.1    bouyer int
    513  1.149   tsutsui ext2fs_reload(struct mount *mp, kauth_cred_t cred, struct lwp *l)
    514    1.1    bouyer {
    515  1.177   hannken 	struct vnode *vp, *devvp;
    516    1.1    bouyer 	struct inode *ip;
    517    1.1    bouyer 	struct buf *bp;
    518    1.1    bouyer 	struct m_ext2fs *fs;
    519    1.1    bouyer 	struct ext2fs *newfs;
    520  1.154   mlelstv 	int i, error;
    521  1.109  christos 	void *cp;
    522  1.149   tsutsui 	struct ufsmount *ump;
    523  1.177   hannken 	struct vnode_iterator *marker;
    524    1.1    bouyer 
    525  1.149   tsutsui 	if ((mp->mnt_flag & MNT_RDONLY) == 0)
    526    1.1    bouyer 		return (EINVAL);
    527  1.126        ad 
    528  1.149   tsutsui 	ump = VFSTOUFS(mp);
    529    1.1    bouyer 	/*
    530    1.1    bouyer 	 * Step 1: invalidate all cached meta-data.
    531    1.1    bouyer 	 */
    532  1.149   tsutsui 	devvp = ump->um_devvp;
    533   1.38  jdolecek 	vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
    534   1.94  christos 	error = vinvalbuf(devvp, 0, cred, l, 0, 0);
    535  1.157   hannken 	VOP_UNLOCK(devvp);
    536   1.38  jdolecek 	if (error)
    537    1.1    bouyer 		panic("ext2fs_reload: dirty1");
    538    1.1    bouyer 	/*
    539    1.1    bouyer 	 * Step 2: re-read superblock from disk.
    540    1.1    bouyer 	 */
    541  1.155   mlelstv 	error = bread(devvp, SBLOCK, SBSIZE, NOCRED, 0, &bp);
    542   1.23    bouyer 	if (error) {
    543    1.1    bouyer 		return (error);
    544   1.23    bouyer 	}
    545    1.1    bouyer 	newfs = (struct ext2fs *)bp->b_data;
    546  1.149   tsutsui 	error = ext2fs_checksb(newfs, (mp->mnt_flag & MNT_RDONLY) != 0);
    547   1.31    bouyer 	if (error) {
    548  1.118        ad 		brelse(bp, 0);
    549   1.31    bouyer 		return (error);
    550    1.1    bouyer 	}
    551    1.1    bouyer 
    552  1.149   tsutsui 	fs = ump->um_e2fs;
    553   1.83     perry 	/*
    554    1.1    bouyer 	 * copy in new superblock, and compute in-memory values
    555    1.1    bouyer 	 */
    556    1.4    bouyer 	e2fs_sbload(newfs, &fs->e2fs);
    557   1.23    bouyer 	fs->e2fs_ncg =
    558   1.23    bouyer 	    howmany(fs->e2fs.e2fs_bcount - fs->e2fs.e2fs_first_dblock,
    559   1.23    bouyer 	    fs->e2fs.e2fs_bpg);
    560  1.155   mlelstv 	fs->e2fs_fsbtodb = fs->e2fs.e2fs_log_bsize + LOG_MINBSIZE - DEV_BSHIFT;
    561  1.122   tsutsui 	fs->e2fs_bsize = MINBSIZE << fs->e2fs.e2fs_log_bsize;
    562    1.1    bouyer 	fs->e2fs_bshift = LOG_MINBSIZE + fs->e2fs.e2fs_log_bsize;
    563    1.1    bouyer 	fs->e2fs_qbmask = fs->e2fs_bsize - 1;
    564    1.1    bouyer 	fs->e2fs_bmask = ~fs->e2fs_qbmask;
    565  1.122   tsutsui 	fs->e2fs_ngdb =
    566  1.122   tsutsui 	    howmany(fs->e2fs_ncg, fs->e2fs_bsize / sizeof(struct ext2_gd));
    567  1.142  christos 	fs->e2fs_ipb = fs->e2fs_bsize / EXT2_DINODE_SIZE(fs);
    568  1.122   tsutsui 	fs->e2fs_itpg = fs->e2fs.e2fs_ipg / fs->e2fs_ipb;
    569  1.148   tsutsui 	brelse(bp, 0);
    570    1.1    bouyer 
    571    1.1    bouyer 	/*
    572    1.1    bouyer 	 * Step 3: re-read summary information from disk.
    573    1.1    bouyer 	 */
    574    1.1    bouyer 
    575  1.122   tsutsui 	for (i = 0; i < fs->e2fs_ngdb; i++) {
    576   1.23    bouyer 		error = bread(devvp ,
    577  1.171  dholland 		    EXT2_FSBTODB(fs, fs->e2fs.e2fs_first_dblock +
    578  1.124   tsutsui 		    1 /* superblock */ + i),
    579  1.136   hannken 		    fs->e2fs_bsize, NOCRED, 0, &bp);
    580   1.23    bouyer 		if (error) {
    581    1.1    bouyer 			return (error);
    582   1.23    bouyer 		}
    583  1.122   tsutsui 		e2fs_cgload((struct ext2_gd *)bp->b_data,
    584  1.122   tsutsui 		    &fs->e2fs_gd[i * fs->e2fs_bsize / sizeof(struct ext2_gd)],
    585   1.23    bouyer 		    fs->e2fs_bsize);
    586  1.118        ad 		brelse(bp, 0);
    587    1.1    bouyer 	}
    588   1.83     perry 
    589  1.177   hannken 	vfs_vnode_iterator_init(mp, &marker);
    590  1.177   hannken 	while (vfs_vnode_iterator_next(marker, &vp)) {
    591    1.1    bouyer 		/*
    592    1.1    bouyer 		 * Step 4: invalidate all inactive vnodes.
    593    1.1    bouyer 		 */
    594  1.177   hannken 		if (vrecycle(vp))
    595  1.177   hannken 			continue;
    596    1.1    bouyer 		/*
    597    1.1    bouyer 		 * Step 5: invalidate all cached file data.
    598    1.1    bouyer 		 */
    599  1.177   hannken 		if (vn_lock(vp, LK_EXCLUSIVE)) {
    600  1.177   hannken 			vrele(vp);
    601  1.177   hannken 			continue;
    602  1.126        ad 		}
    603   1.94  christos 		if (vinvalbuf(vp, 0, cred, l, 0, 0))
    604    1.1    bouyer 			panic("ext2fs_reload: dirty2");
    605    1.1    bouyer 		/*
    606    1.1    bouyer 		 * Step 6: re-read inode data for all active vnodes.
    607    1.1    bouyer 		 */
    608    1.1    bouyer 		ip = VTOI(vp);
    609  1.171  dholland 		error = bread(devvp, EXT2_FSBTODB(fs, ino_to_fsba(fs, ip->i_number)),
    610  1.136   hannken 		    (int)fs->e2fs_bsize, NOCRED, 0, &bp);
    611    1.1    bouyer 		if (error) {
    612    1.1    bouyer 			vput(vp);
    613  1.126        ad 			break;
    614    1.1    bouyer 		}
    615  1.109  christos 		cp = (char *)bp->b_data +
    616  1.142  christos 		    (ino_to_fsbo(fs, ip->i_number) * EXT2_DINODE_SIZE(fs));
    617   1.55      fvdl 		e2fs_iload((struct ext2fs_dinode *)cp, ip->i_din.e2fs_din);
    618  1.140       mrg 		ext2fs_set_inode_guid(ip);
    619  1.118        ad 		brelse(bp, 0);
    620    1.1    bouyer 		vput(vp);
    621    1.1    bouyer 	}
    622  1.177   hannken 	vfs_vnode_iterator_destroy(marker);
    623  1.126        ad 	return (error);
    624    1.1    bouyer }
    625    1.1    bouyer 
    626    1.1    bouyer /*
    627    1.1    bouyer  * Common code for mount and mountroot
    628    1.1    bouyer  */
    629    1.1    bouyer int
    630  1.123     pooka ext2fs_mountfs(struct vnode *devvp, struct mount *mp)
    631    1.1    bouyer {
    632  1.123     pooka 	struct lwp *l = curlwp;
    633   1.35  augustss 	struct ufsmount *ump;
    634    1.1    bouyer 	struct buf *bp;
    635   1.35  augustss 	struct ext2fs *fs;
    636   1.35  augustss 	struct m_ext2fs *m_fs;
    637    1.1    bouyer 	dev_t dev;
    638  1.154   mlelstv 	int error, i, ronly;
    639   1.97      elad 	kauth_cred_t cred;
    640    1.1    bouyer 
    641    1.1    bouyer 	dev = devvp->v_rdev;
    642  1.100        ad 	cred = l ? l->l_cred : NOCRED;
    643   1.80   mycroft 
    644   1.80   mycroft 	/* Flush out any old buffers remaining from a previous use. */
    645   1.38  jdolecek 	vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
    646   1.94  christos 	error = vinvalbuf(devvp, V_SAVE, cred, l, 0, 0);
    647  1.157   hannken 	VOP_UNLOCK(devvp);
    648   1.38  jdolecek 	if (error)
    649    1.1    bouyer 		return (error);
    650    1.1    bouyer 
    651    1.1    bouyer 	ronly = (mp->mnt_flag & MNT_RDONLY) != 0;
    652    1.1    bouyer 
    653    1.1    bouyer 	bp = NULL;
    654    1.1    bouyer 	ump = NULL;
    655    1.1    bouyer 
    656    1.1    bouyer #ifdef DEBUG_EXT2
    657  1.159  jakllsch 	printf("ext2 sb size: %zu\n", sizeof(struct ext2fs));
    658    1.1    bouyer #endif
    659  1.155   mlelstv 	error = bread(devvp, SBLOCK, SBSIZE, cred, 0, &bp);
    660    1.1    bouyer 	if (error)
    661    1.1    bouyer 		goto out;
    662    1.1    bouyer 	fs = (struct ext2fs *)bp->b_data;
    663   1.31    bouyer 	error = ext2fs_checksb(fs, ronly);
    664   1.31    bouyer 	if (error)
    665    1.1    bouyer 		goto out;
    666  1.164     rmind 	ump = kmem_zalloc(sizeof(*ump), KM_SLEEP);
    667   1.55      fvdl 	ump->um_fstype = UFS1;
    668   1.92      yamt 	ump->um_ops = &ext2fs_ufsops;
    669  1.164     rmind 	ump->um_e2fs = kmem_zalloc(sizeof(struct m_ext2fs), KM_SLEEP);
    670  1.122   tsutsui 	e2fs_sbload((struct ext2fs *)bp->b_data, &ump->um_e2fs->e2fs);
    671  1.118        ad 	brelse(bp, 0);
    672    1.1    bouyer 	bp = NULL;
    673    1.1    bouyer 	m_fs = ump->um_e2fs;
    674    1.1    bouyer 	m_fs->e2fs_ronly = ronly;
    675  1.142  christos 
    676  1.142  christos #ifdef DEBUG_EXT2
    677  1.159  jakllsch 	printf("ext2 ino size %zu\n", EXT2_DINODE_SIZE(m_fs));
    678  1.142  christos #endif
    679    1.1    bouyer 	if (ronly == 0) {
    680    1.1    bouyer 		if (m_fs->e2fs.e2fs_state == E2FS_ISCLEAN)
    681    1.1    bouyer 			m_fs->e2fs.e2fs_state = 0;
    682    1.1    bouyer 		else
    683    1.1    bouyer 			m_fs->e2fs.e2fs_state = E2FS_ERRORS;
    684    1.1    bouyer 		m_fs->e2fs_fmod = 1;
    685    1.1    bouyer 	}
    686    1.1    bouyer 
    687    1.1    bouyer 	/* compute dynamic sb infos */
    688    1.1    bouyer 	m_fs->e2fs_ncg =
    689  1.122   tsutsui 	    howmany(m_fs->e2fs.e2fs_bcount - m_fs->e2fs.e2fs_first_dblock,
    690  1.122   tsutsui 	    m_fs->e2fs.e2fs_bpg);
    691  1.155   mlelstv 	m_fs->e2fs_fsbtodb = m_fs->e2fs.e2fs_log_bsize + LOG_MINBSIZE - DEV_BSHIFT;
    692  1.122   tsutsui 	m_fs->e2fs_bsize = MINBSIZE << m_fs->e2fs.e2fs_log_bsize;
    693    1.1    bouyer 	m_fs->e2fs_bshift = LOG_MINBSIZE + m_fs->e2fs.e2fs_log_bsize;
    694    1.1    bouyer 	m_fs->e2fs_qbmask = m_fs->e2fs_bsize - 1;
    695    1.1    bouyer 	m_fs->e2fs_bmask = ~m_fs->e2fs_qbmask;
    696  1.122   tsutsui 	m_fs->e2fs_ngdb =
    697  1.122   tsutsui 	    howmany(m_fs->e2fs_ncg, m_fs->e2fs_bsize / sizeof(struct ext2_gd));
    698  1.142  christos 	m_fs->e2fs_ipb = m_fs->e2fs_bsize / EXT2_DINODE_SIZE(m_fs);
    699  1.122   tsutsui 	m_fs->e2fs_itpg = m_fs->e2fs.e2fs_ipg / m_fs->e2fs_ipb;
    700    1.1    bouyer 
    701  1.164     rmind 	m_fs->e2fs_gd = kmem_alloc(m_fs->e2fs_ngdb * m_fs->e2fs_bsize, KM_SLEEP);
    702  1.122   tsutsui 	for (i = 0; i < m_fs->e2fs_ngdb; i++) {
    703   1.23    bouyer 		error = bread(devvp ,
    704  1.171  dholland 		    EXT2_FSBTODB(m_fs, m_fs->e2fs.e2fs_first_dblock +
    705  1.124   tsutsui 		    1 /* superblock */ + i),
    706  1.136   hannken 		    m_fs->e2fs_bsize, NOCRED, 0, &bp);
    707    1.1    bouyer 		if (error) {
    708  1.164     rmind 			kmem_free(m_fs->e2fs_gd,
    709  1.164     rmind 			    m_fs->e2fs_ngdb * m_fs->e2fs_bsize);
    710    1.1    bouyer 			goto out;
    711    1.1    bouyer 		}
    712  1.122   tsutsui 		e2fs_cgload((struct ext2_gd *)bp->b_data,
    713   1.23    bouyer 		    &m_fs->e2fs_gd[
    714   1.23    bouyer 			i * m_fs->e2fs_bsize / sizeof(struct ext2_gd)],
    715   1.23    bouyer 		    m_fs->e2fs_bsize);
    716  1.118        ad 		brelse(bp, 0);
    717    1.1    bouyer 		bp = NULL;
    718    1.1    bouyer 	}
    719    1.1    bouyer 
    720   1.50     soren 	mp->mnt_data = ump;
    721   1.67  christos 	mp->mnt_stat.f_fsidx.__fsid_val[0] = (long)dev;
    722   1.67  christos 	mp->mnt_stat.f_fsidx.__fsid_val[1] = makefstype(MOUNT_EXT2FS);
    723   1.67  christos 	mp->mnt_stat.f_fsid = mp->mnt_stat.f_fsidx.__fsid_val[0];
    724   1.88  christos 	mp->mnt_stat.f_namemax = EXT2FS_MAXNAMLEN;
    725    1.1    bouyer 	mp->mnt_flag |= MNT_LOCAL;
    726   1.40       chs 	mp->mnt_dev_bshift = DEV_BSHIFT;	/* XXX */
    727   1.40       chs 	mp->mnt_fs_bshift = m_fs->e2fs_bshift;
    728   1.75   mycroft 	mp->mnt_iflag |= IMNT_DTYPE;
    729   1.11    bouyer 	ump->um_flags = 0;
    730    1.1    bouyer 	ump->um_mountp = mp;
    731    1.1    bouyer 	ump->um_dev = dev;
    732    1.1    bouyer 	ump->um_devvp = devvp;
    733  1.170  dholland 	ump->um_nindir = EXT2_NINDIR(m_fs);
    734  1.170  dholland 	ump->um_lognindir = ffs(EXT2_NINDIR(m_fs)) - 1;
    735    1.1    bouyer 	ump->um_bptrtodb = m_fs->e2fs_fsbtodb;
    736    1.1    bouyer 	ump->um_seqinc = 1; /* no frags */
    737   1.75   mycroft 	ump->um_maxsymlinklen = EXT2_MAXSYMLINKLEN;
    738   1.75   mycroft 	ump->um_dirblksiz = m_fs->e2fs_bsize;
    739  1.122   tsutsui 	ump->um_maxfilesize = ((uint64_t)0x80000000 * m_fs->e2fs_bsize - 1);
    740  1.173   hannken 	spec_node_setmountedfs(devvp, mp);
    741    1.1    bouyer 	return (0);
    742   1.40       chs 
    743    1.1    bouyer out:
    744  1.168   hannken 	if (bp != NULL)
    745  1.168   hannken 		brelse(bp, 0);
    746    1.1    bouyer 	if (ump) {
    747  1.164     rmind 		kmem_free(ump->um_e2fs, sizeof(struct m_ext2fs));
    748  1.164     rmind 		kmem_free(ump, sizeof(*ump));
    749   1.50     soren 		mp->mnt_data = NULL;
    750    1.1    bouyer 	}
    751    1.1    bouyer 	return (error);
    752    1.1    bouyer }
    753    1.1    bouyer 
    754    1.1    bouyer /*
    755    1.1    bouyer  * unmount system call
    756    1.1    bouyer  */
    757    1.1    bouyer int
    758  1.123     pooka ext2fs_unmount(struct mount *mp, int mntflags)
    759    1.1    bouyer {
    760   1.35  augustss 	struct ufsmount *ump;
    761   1.35  augustss 	struct m_ext2fs *fs;
    762    1.1    bouyer 	int error, flags;
    763    1.1    bouyer 
    764    1.1    bouyer 	flags = 0;
    765    1.1    bouyer 	if (mntflags & MNT_FORCE)
    766    1.1    bouyer 		flags |= FORCECLOSE;
    767  1.123     pooka 	if ((error = ext2fs_flushfiles(mp, flags)) != 0)
    768    1.1    bouyer 		return (error);
    769    1.1    bouyer 	ump = VFSTOUFS(mp);
    770    1.1    bouyer 	fs = ump->um_e2fs;
    771    1.1    bouyer 	if (fs->e2fs_ronly == 0 &&
    772    1.1    bouyer 		ext2fs_cgupdate(ump, MNT_WAIT) == 0 &&
    773    1.1    bouyer 		(fs->e2fs.e2fs_state & E2FS_ERRORS) == 0) {
    774    1.1    bouyer 		fs->e2fs.e2fs_state = E2FS_ISCLEAN;
    775    1.1    bouyer 		(void) ext2fs_sbupdate(ump, MNT_WAIT);
    776    1.1    bouyer 	}
    777   1.29     enami 	if (ump->um_devvp->v_type != VBAD)
    778  1.173   hannken 		spec_node_setmountedfs(ump->um_devvp, NULL);
    779   1.28  wrstuden 	vn_lock(ump->um_devvp, LK_EXCLUSIVE | LK_RETRY);
    780    1.1    bouyer 	error = VOP_CLOSE(ump->um_devvp, fs->e2fs_ronly ? FREAD : FREAD|FWRITE,
    781  1.123     pooka 	    NOCRED);
    782   1.28  wrstuden 	vput(ump->um_devvp);
    783  1.164     rmind 	kmem_free(fs->e2fs_gd, fs->e2fs_ngdb * fs->e2fs_bsize);
    784  1.164     rmind 	kmem_free(fs, sizeof(*fs));
    785  1.164     rmind 	kmem_free(ump, sizeof(*ump));
    786   1.50     soren 	mp->mnt_data = NULL;
    787    1.1    bouyer 	mp->mnt_flag &= ~MNT_LOCAL;
    788    1.1    bouyer 	return (error);
    789    1.1    bouyer }
    790    1.1    bouyer 
    791    1.1    bouyer /*
    792    1.1    bouyer  * Flush out all the files in a filesystem.
    793    1.1    bouyer  */
    794    1.1    bouyer int
    795  1.123     pooka ext2fs_flushfiles(struct mount *mp, int flags)
    796    1.1    bouyer {
    797    1.1    bouyer 	extern int doforce;
    798    1.1    bouyer 	int error;
    799    1.1    bouyer 
    800    1.1    bouyer 	if (!doforce)
    801    1.1    bouyer 		flags &= ~FORCECLOSE;
    802    1.1    bouyer 	error = vflush(mp, NULLVP, flags);
    803    1.1    bouyer 	return (error);
    804    1.1    bouyer }
    805    1.1    bouyer 
    806    1.1    bouyer /*
    807    1.1    bouyer  * Get file system statistics.
    808    1.1    bouyer  */
    809    1.1    bouyer int
    810  1.123     pooka ext2fs_statvfs(struct mount *mp, struct statvfs *sbp)
    811    1.1    bouyer {
    812   1.35  augustss 	struct ufsmount *ump;
    813   1.35  augustss 	struct m_ext2fs *fs;
    814  1.122   tsutsui 	uint32_t overhead, overhead_per_group, ngdb;
    815   1.32    bouyer 	int i, ngroups;
    816    1.1    bouyer 
    817    1.1    bouyer 	ump = VFSTOUFS(mp);
    818    1.1    bouyer 	fs = ump->um_e2fs;
    819    1.1    bouyer 	if (fs->e2fs.e2fs_magic != E2FS_MAGIC)
    820   1.67  christos 		panic("ext2fs_statvfs");
    821    1.1    bouyer 
    822    1.1    bouyer 	/*
    823    1.1    bouyer 	 * Compute the overhead (FS structures)
    824    1.1    bouyer 	 */
    825  1.122   tsutsui 	overhead_per_group =
    826  1.122   tsutsui 	    1 /* block bitmap */ +
    827  1.122   tsutsui 	    1 /* inode bitmap */ +
    828  1.122   tsutsui 	    fs->e2fs_itpg;
    829    1.1    bouyer 	overhead = fs->e2fs.e2fs_first_dblock +
    830  1.122   tsutsui 	    fs->e2fs_ncg * overhead_per_group;
    831   1.32    bouyer 	if (fs->e2fs.e2fs_rev > E2FS_REV0 &&
    832   1.32    bouyer 	    fs->e2fs.e2fs_features_rocompat & EXT2F_ROCOMPAT_SPARSESUPER) {
    833   1.32    bouyer 		for (i = 0, ngroups = 0; i < fs->e2fs_ncg; i++) {
    834   1.32    bouyer 			if (cg_has_sb(i))
    835   1.32    bouyer 				ngroups++;
    836   1.32    bouyer 		}
    837   1.32    bouyer 	} else {
    838   1.32    bouyer 		ngroups = fs->e2fs_ncg;
    839   1.32    bouyer 	}
    840  1.121   tsutsui 	ngdb = fs->e2fs_ngdb;
    841  1.121   tsutsui 	if (fs->e2fs.e2fs_rev > E2FS_REV0 &&
    842  1.121   tsutsui 	    fs->e2fs.e2fs_features_compat & EXT2F_COMPAT_RESIZE)
    843  1.121   tsutsui 		ngdb += fs->e2fs.e2fs_reserved_ngdb;
    844  1.122   tsutsui 	overhead += ngroups * (1 /* superblock */ + ngdb);
    845    1.1    bouyer 
    846    1.1    bouyer 	sbp->f_bsize = fs->e2fs_bsize;
    847  1.122   tsutsui 	sbp->f_frsize = MINBSIZE << fs->e2fs.e2fs_fsize;
    848    1.1    bouyer 	sbp->f_iosize = fs->e2fs_bsize;
    849    1.1    bouyer 	sbp->f_blocks = fs->e2fs.e2fs_bcount - overhead;
    850    1.1    bouyer 	sbp->f_bfree = fs->e2fs.e2fs_fbcount;
    851   1.67  christos 	sbp->f_bresvd = fs->e2fs.e2fs_rbcount;
    852   1.67  christos 	if (sbp->f_bfree > sbp->f_bresvd)
    853   1.67  christos 		sbp->f_bavail = sbp->f_bfree - sbp->f_bresvd;
    854   1.67  christos 	else
    855   1.67  christos 		sbp->f_bavail = 0;
    856    1.1    bouyer 	sbp->f_files =  fs->e2fs.e2fs_icount;
    857    1.1    bouyer 	sbp->f_ffree = fs->e2fs.e2fs_ficount;
    858   1.67  christos 	sbp->f_favail = fs->e2fs.e2fs_ficount;
    859   1.67  christos 	sbp->f_fresvd = 0;
    860   1.67  christos 	copy_statvfs_info(sbp, mp);
    861    1.1    bouyer 	return (0);
    862    1.1    bouyer }
    863    1.1    bouyer 
    864    1.1    bouyer /*
    865    1.1    bouyer  * Go through the disk queues to initiate sandbagged IO;
    866    1.1    bouyer  * go through the inodes to write those that have been modified;
    867    1.1    bouyer  * initiate the writing of the super block if it has been modified.
    868    1.1    bouyer  *
    869    1.1    bouyer  * Note: we are always called with the filesystem marked `MPBUSY'.
    870    1.1    bouyer  */
    871    1.1    bouyer int
    872  1.123     pooka ext2fs_sync(struct mount *mp, int waitfor, kauth_cred_t cred)
    873    1.1    bouyer {
    874  1.178   hannken 	struct vnode *vp;
    875    1.9      fvdl 	struct inode *ip;
    876    1.9      fvdl 	struct ufsmount *ump = VFSTOUFS(mp);
    877    1.9      fvdl 	struct m_ext2fs *fs;
    878  1.178   hannken 	struct vnode_iterator *marker;
    879    1.1    bouyer 	int error, allerror = 0;
    880    1.1    bouyer 
    881    1.1    bouyer 	fs = ump->um_e2fs;
    882   1.36   mycroft 	if (fs->e2fs_fmod != 0 && fs->e2fs_ronly != 0) {	/* XXX */
    883    1.9      fvdl 		printf("fs = %s\n", fs->e2fs_fsmnt);
    884    1.9      fvdl 		panic("update: rofs mod");
    885    1.1    bouyer 	}
    886  1.126        ad 
    887    1.1    bouyer 	/*
    888    1.1    bouyer 	 * Write back each (modified) inode.
    889    1.1    bouyer 	 */
    890  1.178   hannken 	vfs_vnode_iterator_init(mp, &marker);
    891  1.178   hannken 	while (vfs_vnode_iterator_next(marker, &vp)) {
    892  1.178   hannken 		error = vn_lock(vp, LK_EXCLUSIVE);
    893  1.178   hannken 		if (error) {
    894  1.178   hannken 			vrele(vp);
    895  1.126        ad 			continue;
    896  1.178   hannken 		}
    897    1.1    bouyer 		ip = VTOI(vp);
    898  1.178   hannken 		/*
    899  1.178   hannken 		 * Skip the vnode/inode if inaccessible.
    900  1.178   hannken 		 */
    901  1.178   hannken 		if (ip == NULL || vp->v_type == VNON) {
    902  1.178   hannken 			vput(vp);
    903  1.178   hannken 			continue;
    904  1.178   hannken 		}
    905  1.178   hannken 
    906  1.178   hannken 		if (((ip->i_flag &
    907   1.74   mycroft 		      (IN_CHANGE | IN_UPDATE | IN_MODIFIED)) == 0 &&
    908   1.41       chs 		     LIST_EMPTY(&vp->v_dirtyblkhd) &&
    909  1.178   hannken 		     UVM_OBJ_IS_CLEAN(&vp->v_uobj))) {
    910  1.178   hannken 			vput(vp);
    911   1.21    bouyer 			continue;
    912    1.9      fvdl 		}
    913   1.74   mycroft 		if (vp->v_type == VREG && waitfor == MNT_LAZY)
    914   1.93      yamt 			error = ext2fs_update(vp, NULL, NULL, 0);
    915   1.74   mycroft 		else
    916   1.74   mycroft 			error = VOP_FSYNC(vp, cred,
    917  1.123     pooka 			    waitfor == MNT_WAIT ? FSYNC_WAIT : 0, 0, 0);
    918   1.74   mycroft 		if (error)
    919    1.1    bouyer 			allerror = error;
    920   1.22    bouyer 		vput(vp);
    921    1.1    bouyer 	}
    922  1.178   hannken 	vfs_vnode_iterator_destroy(marker);
    923    1.1    bouyer 	/*
    924    1.1    bouyer 	 * Force stale file system control information to be flushed.
    925    1.1    bouyer 	 */
    926   1.36   mycroft 	if (waitfor != MNT_LAZY) {
    927   1.36   mycroft 		vn_lock(ump->um_devvp, LK_EXCLUSIVE | LK_RETRY);
    928   1.36   mycroft 		if ((error = VOP_FSYNC(ump->um_devvp, cred,
    929  1.123     pooka 		    waitfor == MNT_WAIT ? FSYNC_WAIT : 0, 0, 0)) != 0)
    930   1.36   mycroft 			allerror = error;
    931  1.157   hannken 		VOP_UNLOCK(ump->um_devvp);
    932   1.36   mycroft 	}
    933    1.9      fvdl 	/*
    934    1.9      fvdl 	 * Write back modified superblock.
    935    1.9      fvdl 	 */
    936    1.9      fvdl 	if (fs->e2fs_fmod != 0) {
    937    1.9      fvdl 		fs->e2fs_fmod = 0;
    938   1.98    kardel 		fs->e2fs.e2fs_wtime = time_second;
    939    1.9      fvdl 		if ((error = ext2fs_cgupdate(ump, waitfor)))
    940    1.9      fvdl 			allerror = error;
    941    1.9      fvdl 	}
    942    1.1    bouyer 	return (allerror);
    943    1.1    bouyer }
    944    1.1    bouyer 
    945    1.1    bouyer /*
    946    1.1    bouyer  * Look up a EXT2FS dinode number to find its incore vnode, otherwise read it
    947    1.1    bouyer  * in from disk.  If it is in core, wait for the lock bit to clear, then
    948    1.1    bouyer  * return the inode locked.  Detection and handling of mount points must be
    949    1.1    bouyer  * done by the calling routine.
    950    1.1    bouyer  */
    951    1.1    bouyer int
    952   1.89   xtraeme ext2fs_vget(struct mount *mp, ino_t ino, struct vnode **vpp)
    953    1.1    bouyer {
    954    1.9      fvdl 	struct m_ext2fs *fs;
    955    1.9      fvdl 	struct inode *ip;
    956    1.1    bouyer 	struct ufsmount *ump;
    957    1.1    bouyer 	struct buf *bp;
    958    1.1    bouyer 	struct vnode *vp;
    959    1.1    bouyer 	dev_t dev;
    960    1.1    bouyer 	int error;
    961  1.109  christos 	void *cp;
    962    1.1    bouyer 
    963    1.1    bouyer 	ump = VFSTOUFS(mp);
    964    1.1    bouyer 	dev = ump->um_dev;
    965  1.120        ad retry:
    966   1.59   thorpej 	if ((*vpp = ufs_ihashget(dev, ino, LK_EXCLUSIVE)) != NULL)
    967   1.37      fvdl 		return (0);
    968    1.1    bouyer 
    969    1.1    bouyer 	/* Allocate a new vnode/inode. */
    970  1.160     rmind 	error = getnewvnode(VT_EXT2FS, mp, ext2fs_vnodeop_p, NULL, &vp);
    971  1.160     rmind 	if (error) {
    972    1.1    bouyer 		*vpp = NULL;
    973    1.1    bouyer 		return (error);
    974    1.1    bouyer 	}
    975  1.108        ad 	ip = pool_get(&ext2fs_inode_pool, PR_WAITOK);
    976   1.37      fvdl 
    977  1.108        ad 	mutex_enter(&ufs_hashlock);
    978  1.120        ad 	if ((*vpp = ufs_ihashget(dev, ino, 0)) != NULL) {
    979  1.108        ad 		mutex_exit(&ufs_hashlock);
    980  1.108        ad 		ungetnewvnode(vp);
    981  1.108        ad 		pool_put(&ext2fs_inode_pool, ip);
    982  1.120        ad 		goto retry;
    983  1.108        ad 	}
    984   1.37      fvdl 
    985  1.119        ad 	vp->v_vflag |= VV_LOCKSWORK;
    986   1.76   thorpej 
    987   1.45       chs 	memset(ip, 0, sizeof(struct inode));
    988    1.1    bouyer 	vp->v_data = ip;
    989    1.1    bouyer 	ip->i_vnode = vp;
    990   1.55      fvdl 	ip->i_ump = ump;
    991    1.1    bouyer 	ip->i_e2fs = fs = ump->um_e2fs;
    992    1.1    bouyer 	ip->i_dev = dev;
    993    1.1    bouyer 	ip->i_number = ino;
    994    1.1    bouyer 	ip->i_e2fs_last_lblk = 0;
    995    1.1    bouyer 	ip->i_e2fs_last_blk = 0;
    996  1.131        ad 	genfs_node_init(vp, &ext2fs_genfsops);
    997    1.1    bouyer 
    998    1.1    bouyer 	/*
    999    1.1    bouyer 	 * Put it onto its hash chain and lock it so that other requests for
   1000    1.1    bouyer 	 * this inode will block if they arrive while we are sleeping waiting
   1001    1.1    bouyer 	 * for old data structures to be purged or for the contents of the
   1002    1.1    bouyer 	 * disk portion of this inode to be read.
   1003    1.1    bouyer 	 */
   1004   1.45       chs 
   1005    1.1    bouyer 	ufs_ihashins(ip);
   1006  1.108        ad 	mutex_exit(&ufs_hashlock);
   1007    1.1    bouyer 
   1008    1.1    bouyer 	/* Read in the disk contents for the inode, copy into the inode. */
   1009  1.171  dholland 	error = bread(ump->um_devvp, EXT2_FSBTODB(fs, ino_to_fsba(fs, ino)),
   1010  1.136   hannken 	    (int)fs->e2fs_bsize, NOCRED, 0, &bp);
   1011    1.1    bouyer 	if (error) {
   1012   1.45       chs 
   1013    1.1    bouyer 		/*
   1014    1.1    bouyer 		 * The inode does not contain anything useful, so it would
   1015    1.1    bouyer 		 * be misleading to leave it on its hash chain. With mode
   1016    1.1    bouyer 		 * still zero, it will be unlinked and returned to the free
   1017    1.1    bouyer 		 * list by vput().
   1018    1.1    bouyer 		 */
   1019   1.45       chs 
   1020    1.1    bouyer 		vput(vp);
   1021    1.1    bouyer 		*vpp = NULL;
   1022    1.1    bouyer 		return (error);
   1023    1.1    bouyer 	}
   1024  1.142  christos 	cp = (char *)bp->b_data + (ino_to_fsbo(fs, ino) * EXT2_DINODE_SIZE(fs));
   1025   1.56      fvdl 	ip->i_din.e2fs_din = pool_get(&ext2fs_dinode_pool, PR_WAITOK);
   1026   1.55      fvdl 	e2fs_iload((struct ext2fs_dinode *)cp, ip->i_din.e2fs_din);
   1027  1.140       mrg 	ext2fs_set_inode_guid(ip);
   1028  1.118        ad 	brelse(bp, 0);
   1029    1.1    bouyer 
   1030    1.5    bouyer 	/* If the inode was deleted, reset all fields */
   1031    1.5    bouyer 	if (ip->i_e2fs_dtime != 0) {
   1032  1.167  jakllsch 		ip->i_e2fs_mode = 0;
   1033   1.82        ws 		(void)ext2fs_setsize(ip, 0);
   1034  1.167  jakllsch 		(void)ext2fs_setnblock(ip, 0);
   1035   1.16     perry 		memset(ip->i_e2fs_blocks, 0, sizeof(ip->i_e2fs_blocks));
   1036    1.5    bouyer 	}
   1037    1.5    bouyer 
   1038    1.1    bouyer 	/*
   1039    1.1    bouyer 	 * Initialize the vnode from the inode, check for aliases.
   1040    1.1    bouyer 	 */
   1041   1.45       chs 
   1042   1.14  sommerfe 	error = ext2fs_vinit(mp, ext2fs_specop_p, ext2fs_fifoop_p, &vp);
   1043    1.1    bouyer 	if (error) {
   1044    1.1    bouyer 		vput(vp);
   1045    1.1    bouyer 		*vpp = NULL;
   1046    1.1    bouyer 		return (error);
   1047    1.1    bouyer 	}
   1048    1.1    bouyer 	/*
   1049    1.1    bouyer 	 * Finish inode initialization now that aliasing has been resolved.
   1050    1.1    bouyer 	 */
   1051   1.45       chs 
   1052    1.1    bouyer 	ip->i_devvp = ump->um_devvp;
   1053  1.153     pooka 	vref(ip->i_devvp);
   1054   1.45       chs 
   1055    1.1    bouyer 	/*
   1056    1.1    bouyer 	 * Set up a generation number for this inode if it does not
   1057    1.1    bouyer 	 * already have one. This should only happen on old filesystems.
   1058    1.1    bouyer 	 */
   1059   1.45       chs 
   1060    1.1    bouyer 	if (ip->i_e2fs_gen == 0) {
   1061   1.98    kardel 		if (++ext2gennumber < (u_long)time_second)
   1062   1.98    kardel 			ext2gennumber = time_second;
   1063    1.1    bouyer 		ip->i_e2fs_gen = ext2gennumber;
   1064    1.1    bouyer 		if ((vp->v_mount->mnt_flag & MNT_RDONLY) == 0)
   1065    1.1    bouyer 			ip->i_flag |= IN_MODIFIED;
   1066    1.1    bouyer 	}
   1067  1.111      yamt 	uvm_vnp_setsize(vp, ext2fs_size(ip));
   1068    1.1    bouyer 	*vpp = vp;
   1069    1.1    bouyer 	return (0);
   1070    1.1    bouyer }
   1071    1.1    bouyer 
   1072    1.1    bouyer /*
   1073    1.1    bouyer  * File handle to vnode
   1074    1.1    bouyer  *
   1075    1.1    bouyer  * Have to be really careful about stale file handles:
   1076    1.1    bouyer  * - check that the inode number is valid
   1077    1.1    bouyer  * - call ext2fs_vget() to get the locked inode
   1078    1.1    bouyer  * - check for an unallocated inode (i_mode == 0)
   1079    1.1    bouyer  */
   1080    1.1    bouyer int
   1081   1.89   xtraeme ext2fs_fhtovp(struct mount *mp, struct fid *fhp, struct vnode **vpp)
   1082    1.1    bouyer {
   1083   1.35  augustss 	struct inode *ip;
   1084   1.24  wrstuden 	struct vnode *nvp;
   1085   1.24  wrstuden 	int error;
   1086   1.99    martin 	struct ufid ufh;
   1087    1.1    bouyer 	struct m_ext2fs *fs;
   1088    1.1    bouyer 
   1089   1.99    martin 	if (fhp->fid_len != sizeof(struct ufid))
   1090   1.99    martin 		return EINVAL;
   1091   1.99    martin 
   1092   1.99    martin 	memcpy(&ufh, fhp, sizeof(struct ufid));
   1093    1.1    bouyer 	fs = VFSTOUFS(mp)->um_e2fs;
   1094   1.99    martin 	if ((ufh.ufid_ino < EXT2_FIRSTINO && ufh.ufid_ino != EXT2_ROOTINO) ||
   1095   1.99    martin 		ufh.ufid_ino >= fs->e2fs_ncg * fs->e2fs.e2fs_ipg)
   1096    1.1    bouyer 		return (ESTALE);
   1097   1.24  wrstuden 
   1098   1.99    martin 	if ((error = VFS_VGET(mp, ufh.ufid_ino, &nvp)) != 0) {
   1099   1.24  wrstuden 		*vpp = NULLVP;
   1100   1.24  wrstuden 		return (error);
   1101   1.24  wrstuden 	}
   1102   1.24  wrstuden 	ip = VTOI(nvp);
   1103   1.83     perry 	if (ip->i_e2fs_mode == 0 || ip->i_e2fs_dtime != 0 ||
   1104   1.99    martin 		ip->i_e2fs_gen != ufh.ufid_gen) {
   1105   1.24  wrstuden 		vput(nvp);
   1106   1.24  wrstuden 		*vpp = NULLVP;
   1107   1.24  wrstuden 		return (ESTALE);
   1108   1.24  wrstuden 	}
   1109   1.24  wrstuden 	*vpp = nvp;
   1110   1.24  wrstuden 	return (0);
   1111    1.1    bouyer }
   1112    1.1    bouyer 
   1113    1.1    bouyer /*
   1114    1.1    bouyer  * Vnode pointer to File handle
   1115    1.1    bouyer  */
   1116    1.1    bouyer /* ARGSUSED */
   1117    1.1    bouyer int
   1118   1.99    martin ext2fs_vptofh(struct vnode *vp, struct fid *fhp, size_t *fh_size)
   1119    1.1    bouyer {
   1120   1.35  augustss 	struct inode *ip;
   1121   1.99    martin 	struct ufid ufh;
   1122   1.99    martin 
   1123   1.99    martin 	if (*fh_size < sizeof(struct ufid)) {
   1124   1.99    martin 		*fh_size = sizeof(struct ufid);
   1125   1.99    martin 		return E2BIG;
   1126   1.99    martin 	}
   1127   1.99    martin 	*fh_size = sizeof(struct ufid);
   1128    1.1    bouyer 
   1129    1.1    bouyer 	ip = VTOI(vp);
   1130   1.99    martin 	memset(&ufh, 0, sizeof(ufh));
   1131   1.99    martin 	ufh.ufid_len = sizeof(struct ufid);
   1132   1.99    martin 	ufh.ufid_ino = ip->i_number;
   1133   1.99    martin 	ufh.ufid_gen = ip->i_e2fs_gen;
   1134   1.99    martin 	memcpy(fhp, &ufh, sizeof(ufh));
   1135    1.1    bouyer 	return (0);
   1136    1.9      fvdl }
   1137    1.9      fvdl 
   1138    1.1    bouyer /*
   1139    1.1    bouyer  * Write a superblock and associated information back to disk.
   1140    1.1    bouyer  */
   1141    1.1    bouyer int
   1142   1.89   xtraeme ext2fs_sbupdate(struct ufsmount *mp, int waitfor)
   1143    1.1    bouyer {
   1144   1.35  augustss 	struct m_ext2fs *fs = mp->um_e2fs;
   1145   1.35  augustss 	struct buf *bp;
   1146    1.1    bouyer 	int error = 0;
   1147    1.1    bouyer 
   1148    1.1    bouyer 	bp = getblk(mp->um_devvp, SBLOCK, SBSIZE, 0, 0);
   1149    1.4    bouyer 	e2fs_sbsave(&fs->e2fs, (struct ext2fs*)bp->b_data);
   1150    1.1    bouyer 	if (waitfor == MNT_WAIT)
   1151    1.1    bouyer 		error = bwrite(bp);
   1152    1.1    bouyer 	else
   1153    1.1    bouyer 		bawrite(bp);
   1154    1.1    bouyer 	return (error);
   1155    1.1    bouyer }
   1156    1.1    bouyer 
   1157    1.1    bouyer int
   1158   1.89   xtraeme ext2fs_cgupdate(struct ufsmount *mp, int waitfor)
   1159    1.1    bouyer {
   1160   1.35  augustss 	struct m_ext2fs *fs = mp->um_e2fs;
   1161   1.35  augustss 	struct buf *bp;
   1162    1.1    bouyer 	int i, error = 0, allerror = 0;
   1163    1.1    bouyer 
   1164    1.1    bouyer 	allerror = ext2fs_sbupdate(mp, waitfor);
   1165    1.1    bouyer 	for (i = 0; i < fs->e2fs_ngdb; i++) {
   1166  1.171  dholland 		bp = getblk(mp->um_devvp, EXT2_FSBTODB(fs,
   1167  1.124   tsutsui 		    fs->e2fs.e2fs_first_dblock +
   1168  1.124   tsutsui 		    1 /* superblock */ + i), fs->e2fs_bsize, 0, 0);
   1169  1.122   tsutsui 		e2fs_cgsave(&fs->e2fs_gd[
   1170  1.122   tsutsui 		    i * fs->e2fs_bsize / sizeof(struct ext2_gd)],
   1171  1.122   tsutsui 		    (struct ext2_gd *)bp->b_data, fs->e2fs_bsize);
   1172    1.1    bouyer 		if (waitfor == MNT_WAIT)
   1173    1.1    bouyer 			error = bwrite(bp);
   1174    1.1    bouyer 		else
   1175    1.1    bouyer 			bawrite(bp);
   1176    1.1    bouyer 	}
   1177    1.1    bouyer 
   1178    1.1    bouyer 	if (!allerror && error)
   1179    1.1    bouyer 		allerror = error;
   1180    1.1    bouyer 	return (allerror);
   1181   1.31    bouyer }
   1182   1.31    bouyer 
   1183   1.31    bouyer static int
   1184   1.89   xtraeme ext2fs_checksb(struct ext2fs *fs, int ronly)
   1185   1.31    bouyer {
   1186  1.165       chs 	uint32_t u32;
   1187  1.122   tsutsui 
   1188   1.31    bouyer 	if (fs2h16(fs->e2fs_magic) != E2FS_MAGIC) {
   1189   1.80   mycroft 		return (EINVAL);		/* XXX needs translation */
   1190   1.31    bouyer 	}
   1191   1.31    bouyer 	if (fs2h32(fs->e2fs_rev) > E2FS_REV1) {
   1192   1.31    bouyer #ifdef DIAGNOSTIC
   1193  1.165       chs 		printf("ext2fs: unsupported revision number: %x\n",
   1194  1.122   tsutsui 		    fs2h32(fs->e2fs_rev));
   1195   1.31    bouyer #endif
   1196   1.80   mycroft 		return (EINVAL);		/* XXX needs translation */
   1197   1.31    bouyer 	}
   1198   1.31    bouyer 	if (fs2h32(fs->e2fs_log_bsize) > 2) { /* block size = 1024|2048|4096 */
   1199   1.31    bouyer #ifdef DIAGNOSTIC
   1200  1.165       chs 		printf("ext2fs: bad block size: %d "
   1201  1.122   tsutsui 		    "(expected <= 2 for ext2 fs)\n",
   1202  1.122   tsutsui 		    fs2h32(fs->e2fs_log_bsize));
   1203   1.31    bouyer #endif
   1204   1.80   mycroft 		return (EINVAL);	   /* XXX needs translation */
   1205   1.31    bouyer 	}
   1206   1.31    bouyer 	if (fs2h32(fs->e2fs_rev) > E2FS_REV0) {
   1207  1.166  christos 		char buf[256];
   1208  1.142  christos 		if (fs2h32(fs->e2fs_first_ino) != EXT2_FIRSTINO) {
   1209  1.165       chs 			printf("ext2fs: unsupported first inode position\n");
   1210   1.33    bouyer 			return (EINVAL);      /* XXX needs translation */
   1211   1.33    bouyer 		}
   1212  1.165       chs 		u32 = fs2h32(fs->e2fs_features_incompat) & ~EXT2F_INCOMPAT_SUPP;
   1213  1.165       chs 		if (u32) {
   1214  1.166  christos 			snprintb(buf, sizeof(buf), EXT2F_INCOMPAT_BITS, u32);
   1215  1.166  christos 			printf("ext2fs: unsupported incompat features: %s\n",
   1216  1.166  christos 			    buf);
   1217  1.166  christos 			return EINVAL;	/* XXX needs translation */
   1218   1.31    bouyer 		}
   1219  1.165       chs 		u32 = fs2h32(fs->e2fs_features_rocompat) & ~EXT2F_ROCOMPAT_SUPP;
   1220  1.165       chs 		if (!ronly && u32) {
   1221  1.166  christos 			snprintb(buf, sizeof(buf), EXT2F_ROCOMPAT_BITS, u32);
   1222  1.166  christos 			printf("ext2fs: unsupported ro-incompat features: %s\n",
   1223  1.166  christos 			    buf);
   1224  1.166  christos 			return EROFS;	/* XXX needs translation */
   1225   1.31    bouyer 		}
   1226   1.31    bouyer 	}
   1227   1.31    bouyer 	return (0);
   1228    1.1    bouyer }
   1229