Home | History | Annotate | Line # | Download | only in ffs
ffs_vfsops.c revision 1.196.6.5
      1  1.196.6.5        ad /*	$NetBSD: ffs_vfsops.c,v 1.196.6.5 2007/04/14 11:38:33 ad Exp $	*/
      2        1.4       cgd 
      3        1.1   mycroft /*
      4        1.1   mycroft  * Copyright (c) 1989, 1991, 1993, 1994
      5        1.1   mycroft  *	The Regents of the University of California.  All rights reserved.
      6        1.1   mycroft  *
      7        1.1   mycroft  * Redistribution and use in source and binary forms, with or without
      8        1.1   mycroft  * modification, are permitted provided that the following conditions
      9        1.1   mycroft  * are met:
     10        1.1   mycroft  * 1. Redistributions of source code must retain the above copyright
     11        1.1   mycroft  *    notice, this list of conditions and the following disclaimer.
     12        1.1   mycroft  * 2. Redistributions in binary form must reproduce the above copyright
     13        1.1   mycroft  *    notice, this list of conditions and the following disclaimer in the
     14        1.1   mycroft  *    documentation and/or other materials provided with the distribution.
     15      1.119       agc  * 3. Neither the name of the University nor the names of its contributors
     16        1.1   mycroft  *    may be used to endorse or promote products derived from this software
     17        1.1   mycroft  *    without specific prior written permission.
     18        1.1   mycroft  *
     19        1.1   mycroft  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     20        1.1   mycroft  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     21        1.1   mycroft  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     22        1.1   mycroft  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     23        1.1   mycroft  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     24        1.1   mycroft  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     25        1.1   mycroft  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     26        1.1   mycroft  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     27        1.1   mycroft  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     28        1.1   mycroft  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     29        1.1   mycroft  * SUCH DAMAGE.
     30        1.1   mycroft  *
     31       1.33      fvdl  *	@(#)ffs_vfsops.c	8.31 (Berkeley) 5/20/95
     32        1.1   mycroft  */
     33       1.88     lukem 
     34       1.88     lukem #include <sys/cdefs.h>
     35  1.196.6.5        ad __KERNEL_RCSID(0, "$NetBSD: ffs_vfsops.c,v 1.196.6.5 2007/04/14 11:38:33 ad Exp $");
     36       1.36    scottr 
     37       1.81       mrg #if defined(_KERNEL_OPT)
     38       1.45   thorpej #include "opt_ffs.h"
     39       1.36    scottr #include "opt_quota.h"
     40       1.66      matt #include "opt_softdep.h"
     41       1.37    scottr #endif
     42        1.1   mycroft 
     43        1.1   mycroft #include <sys/param.h>
     44        1.1   mycroft #include <sys/systm.h>
     45        1.1   mycroft #include <sys/namei.h>
     46        1.1   mycroft #include <sys/proc.h>
     47        1.1   mycroft #include <sys/kernel.h>
     48        1.1   mycroft #include <sys/vnode.h>
     49        1.1   mycroft #include <sys/socket.h>
     50        1.1   mycroft #include <sys/mount.h>
     51        1.1   mycroft #include <sys/buf.h>
     52       1.23   thorpej #include <sys/device.h>
     53        1.1   mycroft #include <sys/mbuf.h>
     54        1.1   mycroft #include <sys/file.h>
     55        1.1   mycroft #include <sys/disklabel.h>
     56        1.1   mycroft #include <sys/ioctl.h>
     57        1.1   mycroft #include <sys/errno.h>
     58        1.1   mycroft #include <sys/malloc.h>
     59       1.43   thorpej #include <sys/pool.h>
     60       1.29      fvdl #include <sys/lock.h>
     61       1.33      fvdl #include <sys/sysctl.h>
     62      1.101   gehenna #include <sys/conf.h>
     63      1.181      elad #include <sys/kauth.h>
     64      1.193   hannken #include <sys/fstrans.h>
     65        1.1   mycroft 
     66        1.1   mycroft #include <miscfs/specfs/specdev.h>
     67        1.1   mycroft 
     68        1.1   mycroft #include <ufs/ufs/quota.h>
     69        1.1   mycroft #include <ufs/ufs/ufsmount.h>
     70        1.1   mycroft #include <ufs/ufs/inode.h>
     71       1.25    bouyer #include <ufs/ufs/dir.h>
     72        1.1   mycroft #include <ufs/ufs/ufs_extern.h>
     73       1.34    bouyer #include <ufs/ufs/ufs_bswap.h>
     74        1.1   mycroft 
     75        1.1   mycroft #include <ufs/ffs/fs.h>
     76        1.1   mycroft #include <ufs/ffs/ffs_extern.h>
     77        1.1   mycroft 
     78       1.59  jdolecek /* how many times ffs_init() was called */
     79       1.59  jdolecek int ffs_initcount = 0;
     80       1.59  jdolecek 
     81      1.195        ad extern kmutex_t ufs_hashlock;
     82       1.29      fvdl 
     83      1.105      matt extern const struct vnodeopv_desc ffs_vnodeop_opv_desc;
     84      1.105      matt extern const struct vnodeopv_desc ffs_specop_opv_desc;
     85      1.105      matt extern const struct vnodeopv_desc ffs_fifoop_opv_desc;
     86       1.32   thorpej 
     87       1.79  jdolecek const struct vnodeopv_desc * const ffs_vnodeopv_descs[] = {
     88       1.32   thorpej 	&ffs_vnodeop_opv_desc,
     89       1.32   thorpej 	&ffs_specop_opv_desc,
     90       1.32   thorpej 	&ffs_fifoop_opv_desc,
     91       1.32   thorpej 	NULL,
     92       1.32   thorpej };
     93       1.32   thorpej 
     94       1.17   mycroft struct vfsops ffs_vfsops = {
     95       1.17   mycroft 	MOUNT_FFS,
     96        1.1   mycroft 	ffs_mount,
     97        1.1   mycroft 	ufs_start,
     98        1.1   mycroft 	ffs_unmount,
     99        1.1   mycroft 	ufs_root,
    100        1.1   mycroft 	ufs_quotactl,
    101      1.143  christos 	ffs_statvfs,
    102        1.1   mycroft 	ffs_sync,
    103        1.1   mycroft 	ffs_vget,
    104        1.1   mycroft 	ffs_fhtovp,
    105        1.1   mycroft 	ffs_vptofh,
    106        1.1   mycroft 	ffs_init,
    107       1.86       chs 	ffs_reinit,
    108       1.59  jdolecek 	ffs_done,
    109       1.23   thorpej 	ffs_mountroot,
    110      1.149   hannken 	ffs_snapshot,
    111      1.170   thorpej 	ffs_extattrctl,
    112      1.193   hannken 	ffs_suspendctl,
    113       1.32   thorpej 	ffs_vnodeopv_descs,
    114      1.185  christos 	0,
    115      1.185  christos 	{ NULL, NULL },
    116        1.1   mycroft };
    117      1.163   thorpej VFS_ATTACH(ffs_vfsops);
    118        1.1   mycroft 
    119      1.165      yamt static const struct genfs_ops ffs_genfsops = {
    120      1.165      yamt 	.gop_size = ffs_gop_size,
    121      1.165      yamt 	.gop_alloc = ufs_gop_alloc,
    122      1.165      yamt 	.gop_write = genfs_gop_write,
    123      1.167      yamt 	.gop_markupdate = ufs_gop_markupdate,
    124       1.87       chs };
    125       1.87       chs 
    126      1.175      yamt static const struct ufs_ops ffs_ufsops = {
    127      1.175      yamt 	.uo_itimes = ffs_itimes,
    128      1.176      yamt 	.uo_update = ffs_update,
    129      1.176      yamt 	.uo_truncate = ffs_truncate,
    130      1.176      yamt 	.uo_valloc = ffs_valloc,
    131      1.176      yamt 	.uo_vfree = ffs_vfree,
    132      1.176      yamt 	.uo_balloc = ffs_balloc,
    133      1.175      yamt };
    134      1.175      yamt 
    135      1.144    simonb POOL_INIT(ffs_inode_pool, sizeof(struct inode), 0, 0, 0, "ffsinopl",
    136  1.196.6.1        ad     &pool_allocator_nointr, IPL_NONE);
    137      1.144    simonb POOL_INIT(ffs_dinode1_pool, sizeof(struct ufs1_dinode), 0, 0, 0, "dino1pl",
    138  1.196.6.1        ad     &pool_allocator_nointr, IPL_NONE);
    139      1.144    simonb POOL_INIT(ffs_dinode2_pool, sizeof(struct ufs2_dinode), 0, 0, 0, "dino2pl",
    140  1.196.6.1        ad     &pool_allocator_nointr, IPL_NONE);
    141      1.110      fvdl 
    142      1.146    simonb static void ffs_oldfscompat_read(struct fs *, struct ufsmount *, daddr_t);
    143      1.110      fvdl static void ffs_oldfscompat_write(struct fs *, struct ufsmount *);
    144       1.43   thorpej 
    145        1.1   mycroft /*
    146       1.33      fvdl  * Called by main() when ffs is going to be mounted as root.
    147        1.1   mycroft  */
    148        1.1   mycroft 
    149       1.19  christos int
    150      1.166   thorpej ffs_mountroot(void)
    151        1.1   mycroft {
    152       1.33      fvdl 	struct fs *fs;
    153       1.33      fvdl 	struct mount *mp;
    154      1.177  christos 	struct lwp *l = curlwp;			/* XXX */
    155        1.1   mycroft 	struct ufsmount *ump;
    156        1.1   mycroft 	int error;
    157       1.23   thorpej 
    158      1.180   thorpej 	if (device_class(root_device) != DV_DISK)
    159       1.23   thorpej 		return (ENODEV);
    160       1.23   thorpej 
    161       1.51  wrstuden 	if ((error = vfs_rootmountalloc(MOUNT_FFS, "root_device", &mp))) {
    162       1.51  wrstuden 		vrele(rootvp);
    163       1.33      fvdl 		return (error);
    164       1.51  wrstuden 	}
    165      1.177  christos 	if ((error = ffs_mountfs(rootvp, mp, l)) != 0) {
    166       1.33      fvdl 		mp->mnt_op->vfs_refcount--;
    167       1.33      fvdl 		vfs_unbusy(mp);
    168        1.1   mycroft 		free(mp, M_MOUNT);
    169        1.1   mycroft 		return (error);
    170        1.1   mycroft 	}
    171  1.196.6.2        ad 	mutex_enter(&mountlist_lock);
    172       1.11   mycroft 	CIRCLEQ_INSERT_TAIL(&mountlist, mp, mnt_list);
    173  1.196.6.2        ad 	mutex_exit(&mountlist_lock);
    174        1.1   mycroft 	ump = VFSTOUFS(mp);
    175        1.1   mycroft 	fs = ump->um_fs;
    176       1.42     perry 	memset(fs->fs_fsmnt, 0, sizeof(fs->fs_fsmnt));
    177       1.33      fvdl 	(void)copystr(mp->mnt_stat.f_mntonname, fs->fs_fsmnt, MNAMELEN - 1, 0);
    178      1.177  christos 	(void)ffs_statvfs(mp, &mp->mnt_stat, l);
    179       1.33      fvdl 	vfs_unbusy(mp);
    180      1.151        pk 	setrootfstime((time_t)fs->fs_time);
    181        1.1   mycroft 	return (0);
    182        1.1   mycroft }
    183        1.1   mycroft 
    184        1.1   mycroft /*
    185        1.1   mycroft  * VFS Operations.
    186        1.1   mycroft  *
    187        1.1   mycroft  * mount system call
    188        1.1   mycroft  */
    189        1.1   mycroft int
    190      1.166   thorpej ffs_mount(struct mount *mp, const char *path, void *data,
    191      1.177  christos     struct nameidata *ndp, struct lwp *l)
    192        1.1   mycroft {
    193      1.104       scw 	struct vnode *devvp = NULL;
    194        1.1   mycroft 	struct ufs_args args;
    195       1.19  christos 	struct ufsmount *ump = NULL;
    196       1.61  augustss 	struct fs *fs;
    197       1.95  christos 	int error, flags, update;
    198        1.9   mycroft 	mode_t accessmode;
    199        1.1   mycroft 
    200      1.102  christos 	if (mp->mnt_flag & MNT_GETARGS) {
    201      1.102  christos 		ump = VFSTOUFS(mp);
    202      1.102  christos 		if (ump == NULL)
    203      1.102  christos 			return EIO;
    204      1.102  christos 		args.fspec = NULL;
    205      1.102  christos 		return copyout(&args, data, sizeof(args));
    206      1.102  christos 	}
    207      1.108       dsl 	error = copyin(data, &args, sizeof (struct ufs_args));
    208       1.19  christos 	if (error)
    209        1.1   mycroft 		return (error);
    210       1.66      matt 
    211       1.66      matt #if !defined(SOFTDEP)
    212       1.67  perseant 	mp->mnt_flag &= ~MNT_SOFTDEP;
    213       1.66      matt #endif
    214       1.66      matt 
    215       1.95  christos 	update = mp->mnt_flag & MNT_UPDATE;
    216       1.95  christos 
    217       1.95  christos 	/* Check arguments */
    218       1.97     enami 	if (args.fspec != NULL) {
    219       1.95  christos 		/*
    220       1.95  christos 		 * Look up the name and verify that it's sane.
    221       1.95  christos 		 */
    222      1.177  christos 		NDINIT(ndp, LOOKUP, FOLLOW, UIO_USERSPACE, args.fspec, l);
    223       1.95  christos 		if ((error = namei(ndp)) != 0)
    224       1.95  christos 			return (error);
    225       1.95  christos 		devvp = ndp->ni_vp;
    226       1.95  christos 
    227       1.95  christos 		if (!update) {
    228       1.95  christos 			/*
    229       1.95  christos 			 * Be sure this is a valid block device
    230       1.95  christos 			 */
    231       1.95  christos 			if (devvp->v_type != VBLK)
    232       1.95  christos 				error = ENOTBLK;
    233      1.101   gehenna 			else if (bdevsw_lookup(devvp->v_rdev) == NULL)
    234       1.95  christos 				error = ENXIO;
    235       1.95  christos 		} else {
    236       1.95  christos 			/*
    237       1.95  christos 			 * Be sure we're still naming the same device
    238       1.95  christos 			 * used for our initial mount
    239       1.95  christos 			 */
    240      1.160   mycroft 			ump = VFSTOUFS(mp);
    241      1.186       jld 			if (devvp != ump->um_devvp) {
    242      1.186       jld 				if (devvp->v_rdev != ump->um_devvp->v_rdev)
    243      1.186       jld 					error = EINVAL;
    244      1.186       jld 				else {
    245      1.186       jld 					vrele(devvp);
    246      1.186       jld 					devvp = ump->um_devvp;
    247      1.186       jld 					vref(devvp);
    248      1.186       jld 				}
    249      1.186       jld 			}
    250       1.95  christos 		}
    251      1.160   mycroft 	} else {
    252      1.160   mycroft 		if (!update) {
    253      1.160   mycroft 			/* New mounts must have a filename for the device */
    254      1.160   mycroft 			return (EINVAL);
    255      1.160   mycroft 		} else {
    256      1.160   mycroft 			/* Use the extant mount */
    257      1.160   mycroft 			ump = VFSTOUFS(mp);
    258      1.160   mycroft 			devvp = ump->um_devvp;
    259      1.160   mycroft 			vref(devvp);
    260      1.160   mycroft 		}
    261       1.95  christos 	}
    262       1.95  christos 
    263        1.1   mycroft 	/*
    264       1.95  christos 	 * If mount by non-root, then verify that user has necessary
    265       1.95  christos 	 * permissions on the device.
    266        1.1   mycroft 	 */
    267      1.191      elad 	if (error == 0 && kauth_authorize_generic(l->l_cred,
    268      1.191      elad 	    KAUTH_GENERIC_ISSUSER, NULL) != 0) {
    269       1.95  christos 		accessmode = VREAD;
    270       1.96  christos 		if (update ?
    271      1.124       dbj 		    (mp->mnt_iflag & IMNT_WANTRDWR) != 0 :
    272       1.96  christos 		    (mp->mnt_flag & MNT_RDONLY) == 0)
    273       1.95  christos 			accessmode |= VWRITE;
    274       1.95  christos 		vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
    275      1.184        ad 		error = VOP_ACCESS(devvp, accessmode, l->l_cred, l);
    276       1.95  christos 		VOP_UNLOCK(devvp, 0);
    277       1.95  christos 	}
    278       1.95  christos 
    279       1.95  christos 	if (error) {
    280       1.95  christos 		vrele(devvp);
    281       1.95  christos 		return (error);
    282       1.95  christos 	}
    283       1.95  christos 
    284       1.95  christos 	if (!update) {
    285      1.164  christos 		int xflags;
    286      1.159   mycroft 
    287      1.159   mycroft 		/*
    288      1.159   mycroft 		 * Disallow multiple mounts of the same device.
    289      1.159   mycroft 		 * Disallow mounting of a device that is currently in use
    290      1.159   mycroft 		 * (except for root, which might share swap device for
    291      1.159   mycroft 		 * miniroot).
    292      1.159   mycroft 		 */
    293      1.159   mycroft 		error = vfs_mountedon(devvp);
    294      1.159   mycroft 		if (error)
    295      1.159   mycroft 			goto fail;
    296      1.159   mycroft 		if (vcount(devvp) > 1 && devvp != rootvp) {
    297      1.159   mycroft 			error = EBUSY;
    298      1.159   mycroft 			goto fail;
    299      1.159   mycroft 		}
    300      1.159   mycroft 		if (mp->mnt_flag & MNT_RDONLY)
    301      1.164  christos 			xflags = FREAD;
    302      1.159   mycroft 		else
    303      1.164  christos 			xflags = FREAD|FWRITE;
    304      1.177  christos 		error = VOP_OPEN(devvp, xflags, FSCRED, l);
    305      1.159   mycroft 		if (error)
    306      1.159   mycroft 			goto fail;
    307      1.177  christos 		error = ffs_mountfs(devvp, mp, l);
    308       1.95  christos 		if (error) {
    309      1.159   mycroft 			vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
    310      1.177  christos 			(void)VOP_CLOSE(devvp, xflags, NOCRED, l);
    311      1.159   mycroft 			VOP_UNLOCK(devvp, 0);
    312      1.159   mycroft 			goto fail;
    313       1.95  christos 		}
    314       1.95  christos 
    315        1.1   mycroft 		ump = VFSTOUFS(mp);
    316        1.1   mycroft 		fs = ump->um_fs;
    317       1.95  christos 		if ((mp->mnt_flag & (MNT_SOFTDEP | MNT_ASYNC)) ==
    318       1.95  christos 		    (MNT_SOFTDEP | MNT_ASYNC)) {
    319       1.95  christos 			printf("%s fs uses soft updates, "
    320       1.96  christos 			    "ignoring async mode\n",
    321       1.96  christos 			    fs->fs_fsmnt);
    322       1.95  christos 			mp->mnt_flag &= ~MNT_ASYNC;
    323       1.95  christos 		}
    324       1.95  christos 	} else {
    325       1.95  christos 		/*
    326       1.96  christos 		 * Update the mount.
    327       1.96  christos 		 */
    328       1.96  christos 
    329       1.96  christos 		/*
    330       1.96  christos 		 * The initial mount got a reference on this
    331       1.96  christos 		 * device, so drop the one obtained via
    332       1.96  christos 		 * namei(), above.
    333       1.95  christos 		 */
    334       1.96  christos 		vrele(devvp);
    335       1.96  christos 
    336      1.160   mycroft 		ump = VFSTOUFS(mp);
    337       1.95  christos 		fs = ump->um_fs;
    338        1.1   mycroft 		if (fs->fs_ronly == 0 && (mp->mnt_flag & MNT_RDONLY)) {
    339       1.95  christos 			/*
    340       1.95  christos 			 * Changing from r/w to r/o
    341       1.95  christos 			 */
    342        1.1   mycroft 			flags = WRITECLOSE;
    343        1.1   mycroft 			if (mp->mnt_flag & MNT_FORCE)
    344        1.1   mycroft 				flags |= FORCECLOSE;
    345       1.55      fvdl 			if (mp->mnt_flag & MNT_SOFTDEP)
    346      1.177  christos 				error = softdep_flushfiles(mp, flags, l);
    347       1.55      fvdl 			else
    348      1.177  christos 				error = ffs_flushfiles(mp, flags, l);
    349       1.89      fvdl 			if (fs->fs_pendingblocks != 0 ||
    350       1.89      fvdl 			    fs->fs_pendinginodes != 0) {
    351      1.110      fvdl 				printf("%s: update error: blocks %" PRId64
    352      1.110      fvdl 				       " files %d\n",
    353       1.89      fvdl 				    fs->fs_fsmnt, fs->fs_pendingblocks,
    354       1.89      fvdl 				    fs->fs_pendinginodes);
    355       1.89      fvdl 				fs->fs_pendingblocks = 0;
    356       1.89      fvdl 				fs->fs_pendinginodes = 0;
    357       1.89      fvdl 			}
    358       1.15   mycroft 			if (error == 0 &&
    359       1.15   mycroft 			    ffs_cgupdate(ump, MNT_WAIT) == 0 &&
    360       1.15   mycroft 			    fs->fs_clean & FS_WASCLEAN) {
    361       1.65      fvdl 				if (mp->mnt_flag & MNT_SOFTDEP)
    362       1.65      fvdl 					fs->fs_flags &= ~FS_DOSOFTDEP;
    363       1.15   mycroft 				fs->fs_clean = FS_ISCLEAN;
    364       1.15   mycroft 				(void) ffs_sbupdate(ump, MNT_WAIT);
    365       1.15   mycroft 			}
    366       1.15   mycroft 			if (error)
    367       1.15   mycroft 				return (error);
    368       1.15   mycroft 			fs->fs_ronly = 1;
    369       1.78   mycroft 			fs->fs_fmod = 0;
    370        1.1   mycroft 		}
    371       1.65      fvdl 
    372       1.65      fvdl 		/*
    373       1.65      fvdl 		 * Flush soft dependencies if disabling it via an update
    374       1.65      fvdl 		 * mount. This may leave some items to be processed,
    375       1.65      fvdl 		 * so don't do this yet XXX.
    376       1.65      fvdl 		 */
    377       1.65      fvdl 		if ((fs->fs_flags & FS_DOSOFTDEP) &&
    378       1.65      fvdl 		    !(mp->mnt_flag & MNT_SOFTDEP) && fs->fs_ronly == 0) {
    379       1.65      fvdl #ifdef notyet
    380       1.65      fvdl 			flags = WRITECLOSE;
    381       1.65      fvdl 			if (mp->mnt_flag & MNT_FORCE)
    382       1.65      fvdl 				flags |= FORCECLOSE;
    383      1.177  christos 			error = softdep_flushfiles(mp, flags, l);
    384       1.65      fvdl 			if (error == 0 && ffs_cgupdate(ump, MNT_WAIT) == 0)
    385       1.65      fvdl 				fs->fs_flags &= ~FS_DOSOFTDEP;
    386       1.65      fvdl 				(void) ffs_sbupdate(ump, MNT_WAIT);
    387       1.66      matt #elif defined(SOFTDEP)
    388       1.65      fvdl 			mp->mnt_flag |= MNT_SOFTDEP;
    389       1.65      fvdl #endif
    390       1.65      fvdl 		}
    391       1.65      fvdl 
    392       1.65      fvdl 		/*
    393       1.65      fvdl 		 * When upgrading to a softdep mount, we must first flush
    394       1.65      fvdl 		 * all vnodes. (not done yet -- see above)
    395       1.65      fvdl 		 */
    396       1.65      fvdl 		if (!(fs->fs_flags & FS_DOSOFTDEP) &&
    397       1.65      fvdl 		    (mp->mnt_flag & MNT_SOFTDEP) && fs->fs_ronly == 0) {
    398       1.65      fvdl #ifdef notyet
    399       1.65      fvdl 			flags = WRITECLOSE;
    400       1.65      fvdl 			if (mp->mnt_flag & MNT_FORCE)
    401       1.65      fvdl 				flags |= FORCECLOSE;
    402      1.177  christos 			error = ffs_flushfiles(mp, flags, l);
    403       1.65      fvdl #else
    404       1.65      fvdl 			mp->mnt_flag &= ~MNT_SOFTDEP;
    405       1.65      fvdl #endif
    406       1.65      fvdl 		}
    407       1.65      fvdl 
    408       1.15   mycroft 		if (mp->mnt_flag & MNT_RELOAD) {
    409      1.184        ad 			error = ffs_reload(mp, l->l_cred, l);
    410       1.15   mycroft 			if (error)
    411       1.15   mycroft 				return (error);
    412       1.15   mycroft 		}
    413       1.95  christos 
    414      1.124       dbj 		if (fs->fs_ronly && (mp->mnt_iflag & IMNT_WANTRDWR)) {
    415        1.9   mycroft 			/*
    416       1.95  christos 			 * Changing from read-only to read/write
    417        1.9   mycroft 			 */
    418        1.1   mycroft 			fs->fs_ronly = 0;
    419       1.15   mycroft 			fs->fs_clean <<= 1;
    420       1.15   mycroft 			fs->fs_fmod = 1;
    421       1.55      fvdl 			if ((fs->fs_flags & FS_DOSOFTDEP)) {
    422       1.55      fvdl 				error = softdep_mount(devvp, mp, fs,
    423      1.184        ad 				    l->l_cred);
    424       1.55      fvdl 				if (error)
    425       1.55      fvdl 					return (error);
    426       1.65      fvdl 			}
    427      1.149   hannken 			if (fs->fs_snapinum[0] != 0)
    428      1.149   hannken 				ffs_snapshot_mount(mp);
    429        1.9   mycroft 		}
    430      1.174      jmmv 		if (args.fspec == NULL)
    431      1.174      jmmv 			return EINVAL;
    432       1.55      fvdl 		if ((mp->mnt_flag & (MNT_SOFTDEP | MNT_ASYNC)) ==
    433       1.55      fvdl 		    (MNT_SOFTDEP | MNT_ASYNC)) {
    434       1.55      fvdl 			printf("%s fs uses soft updates, ignoring async mode\n",
    435       1.55      fvdl 			    fs->fs_fsmnt);
    436       1.55      fvdl 			mp->mnt_flag &= ~MNT_ASYNC;
    437       1.55      fvdl 		}
    438        1.1   mycroft 	}
    439        1.1   mycroft 
    440      1.143  christos 	error = set_statvfs_info(path, UIO_USERSPACE, args.fspec,
    441      1.177  christos 	    UIO_USERSPACE, mp, l);
    442      1.114  christos 	if (error == 0)
    443      1.114  christos 		(void)strncpy(fs->fs_fsmnt, mp->mnt_stat.f_mntonname,
    444      1.114  christos 		    sizeof(fs->fs_fsmnt));
    445       1.65      fvdl 	if (mp->mnt_flag & MNT_SOFTDEP)
    446       1.65      fvdl 		fs->fs_flags |= FS_DOSOFTDEP;
    447       1.74      fvdl 	else
    448       1.74      fvdl 		fs->fs_flags &= ~FS_DOSOFTDEP;
    449       1.15   mycroft 	if (fs->fs_fmod != 0) {	/* XXX */
    450       1.15   mycroft 		fs->fs_fmod = 0;
    451       1.15   mycroft 		if (fs->fs_clean & FS_WASCLEAN)
    452      1.182    kardel 			fs->fs_time = time_second;
    453       1.89      fvdl 		else {
    454       1.82     lukem 			printf("%s: file system not clean (fs_clean=%x); please fsck(8)\n",
    455       1.34    bouyer 			    mp->mnt_stat.f_mntfromname, fs->fs_clean);
    456      1.110      fvdl 			printf("%s: lost blocks %" PRId64 " files %d\n",
    457       1.89      fvdl 			    mp->mnt_stat.f_mntfromname, fs->fs_pendingblocks,
    458       1.89      fvdl 			    fs->fs_pendinginodes);
    459       1.89      fvdl 		}
    460       1.15   mycroft 		(void) ffs_cgupdate(ump, MNT_WAIT);
    461       1.15   mycroft 	}
    462      1.159   mycroft 	return (error);
    463      1.159   mycroft 
    464      1.159   mycroft fail:
    465      1.159   mycroft 	vrele(devvp);
    466      1.159   mycroft 	return (error);
    467        1.1   mycroft }
    468        1.1   mycroft 
    469        1.1   mycroft /*
    470        1.1   mycroft  * Reload all incore data for a filesystem (used after running fsck on
    471        1.1   mycroft  * the root filesystem and finding things to fix). The filesystem must
    472        1.1   mycroft  * be mounted read-only.
    473        1.1   mycroft  *
    474        1.1   mycroft  * Things to do to update the mount:
    475        1.1   mycroft  *	1) invalidate all cached meta-data.
    476        1.1   mycroft  *	2) re-read superblock from disk.
    477        1.1   mycroft  *	3) re-read summary information from disk.
    478        1.1   mycroft  *	4) invalidate all inactive vnodes.
    479        1.1   mycroft  *	5) invalidate all cached file data.
    480        1.1   mycroft  *	6) re-read inode data for all active vnodes.
    481        1.1   mycroft  */
    482       1.19  christos int
    483      1.181      elad ffs_reload(struct mount *mp, kauth_cred_t cred, struct lwp *l)
    484        1.1   mycroft {
    485      1.189   reinoud 	struct vnode *vp, *nvp, *devvp;
    486        1.1   mycroft 	struct inode *ip;
    487       1.84     lukem 	void *space;
    488        1.1   mycroft 	struct buf *bp;
    489       1.18       cgd 	struct fs *fs, *newfs;
    490        1.1   mycroft 	struct partinfo dpart;
    491        1.1   mycroft 	int i, blks, size, error;
    492       1.18       cgd 	int32_t *lp;
    493      1.111      fvdl 	struct ufsmount *ump;
    494      1.141       dbj 	daddr_t sblockloc;
    495        1.1   mycroft 
    496      1.153   mycroft 	if ((mp->mnt_flag & MNT_RDONLY) == 0)
    497        1.1   mycroft 		return (EINVAL);
    498      1.111      fvdl 
    499      1.153   mycroft 	ump = VFSTOUFS(mp);
    500        1.1   mycroft 	/*
    501        1.1   mycroft 	 * Step 1: invalidate all cached meta-data.
    502        1.1   mycroft 	 */
    503      1.111      fvdl 	devvp = ump->um_devvp;
    504       1.55      fvdl 	vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
    505      1.177  christos 	error = vinvalbuf(devvp, 0, cred, l, 0, 0);
    506       1.55      fvdl 	VOP_UNLOCK(devvp, 0);
    507       1.55      fvdl 	if (error)
    508        1.1   mycroft 		panic("ffs_reload: dirty1");
    509        1.1   mycroft 	/*
    510        1.1   mycroft 	 * Step 2: re-read superblock from disk.
    511        1.1   mycroft 	 */
    512      1.111      fvdl 	fs = ump->um_fs;
    513      1.177  christos 	if (VOP_IOCTL(devvp, DIOCGPART, &dpart, FREAD, NOCRED, l) != 0)
    514        1.1   mycroft 		size = DEV_BSIZE;
    515        1.1   mycroft 	else
    516        1.1   mycroft 		size = dpart.disklab->d_secsize;
    517      1.141       dbj 	/* XXX we don't handle possibility that superblock moved. */
    518      1.110      fvdl 	error = bread(devvp, fs->fs_sblockloc / size, fs->fs_sbsize,
    519      1.110      fvdl 		      NOCRED, &bp);
    520       1.47    bouyer 	if (error) {
    521       1.47    bouyer 		brelse(bp);
    522        1.1   mycroft 		return (error);
    523       1.47    bouyer 	}
    524       1.34    bouyer 	newfs = malloc(fs->fs_sbsize, M_UFSMNT, M_WAITOK);
    525       1.42     perry 	memcpy(newfs, bp->b_data, fs->fs_sbsize);
    526       1.34    bouyer #ifdef FFS_EI
    527      1.111      fvdl 	if (ump->um_flags & UFS_NEEDSWAP) {
    528       1.83     lukem 		ffs_sb_swap((struct fs*)bp->b_data, newfs);
    529       1.55      fvdl 		fs->fs_flags |= FS_SWAPPED;
    530      1.121    bouyer 	} else
    531       1.34    bouyer #endif
    532      1.121    bouyer 		fs->fs_flags &= ~FS_SWAPPED;
    533      1.161     perry 	if ((newfs->fs_magic != FS_UFS1_MAGIC &&
    534      1.110      fvdl 	     newfs->fs_magic != FS_UFS2_MAGIC)||
    535      1.110      fvdl 	     newfs->fs_bsize > MAXBSIZE ||
    536      1.110      fvdl 	     newfs->fs_bsize < sizeof(struct fs)) {
    537        1.1   mycroft 		brelse(bp);
    538       1.34    bouyer 		free(newfs, M_UFSMNT);
    539        1.1   mycroft 		return (EIO);		/* XXX needs translation */
    540        1.1   mycroft 	}
    541      1.141       dbj 	/* Store off old fs_sblockloc for fs_oldfscompat_read. */
    542      1.141       dbj 	sblockloc = fs->fs_sblockloc;
    543      1.161     perry 	/*
    544       1.18       cgd 	 * Copy pointer fields back into superblock before copying in	XXX
    545       1.18       cgd 	 * new superblock. These should really be in the ufsmount.	XXX
    546       1.18       cgd 	 * Note that important parameters (eg fs_ncg) are unchanged.
    547       1.18       cgd 	 */
    548       1.84     lukem 	newfs->fs_csp = fs->fs_csp;
    549       1.18       cgd 	newfs->fs_maxcluster = fs->fs_maxcluster;
    550       1.85     lukem 	newfs->fs_contigdirs = fs->fs_contigdirs;
    551       1.76   mycroft 	newfs->fs_ronly = fs->fs_ronly;
    552      1.110      fvdl 	newfs->fs_active = fs->fs_active;
    553       1.42     perry 	memcpy(fs, newfs, (u_int)fs->fs_sbsize);
    554        1.1   mycroft 	brelse(bp);
    555       1.34    bouyer 	free(newfs, M_UFSMNT);
    556      1.103       dbj 
    557      1.103       dbj 	/* Recheck for apple UFS filesystem */
    558      1.153   mycroft 	ump->um_flags &= ~UFS_ISAPPLEUFS;
    559      1.103       dbj 	/* First check to see if this is tagged as an Apple UFS filesystem
    560      1.103       dbj 	 * in the disklabel
    561      1.103       dbj 	 */
    562      1.177  christos 	if ((VOP_IOCTL(devvp, DIOCGPART, &dpart, FREAD, cred, l) == 0) &&
    563      1.103       dbj 		(dpart.part->p_fstype == FS_APPLEUFS)) {
    564      1.153   mycroft 		ump->um_flags |= UFS_ISAPPLEUFS;
    565      1.103       dbj 	}
    566      1.103       dbj #ifdef APPLE_UFS
    567      1.103       dbj 	else {
    568      1.103       dbj 		/* Manually look for an apple ufs label, and if a valid one
    569      1.103       dbj 		 * is found, then treat it like an Apple UFS filesystem anyway
    570      1.103       dbj 		 */
    571      1.106      fvdl 		error = bread(devvp, (daddr_t)(APPLEUFS_LABEL_OFFSET / size),
    572      1.103       dbj 			APPLEUFS_LABEL_SIZE, cred, &bp);
    573      1.103       dbj 		if (error) {
    574      1.103       dbj 			brelse(bp);
    575      1.103       dbj 			return (error);
    576      1.103       dbj 		}
    577      1.103       dbj 		error = ffs_appleufs_validate(fs->fs_fsmnt,
    578      1.103       dbj 			(struct appleufslabel *)bp->b_data,NULL);
    579      1.153   mycroft 		if (error == 0)
    580      1.153   mycroft 			ump->um_flags |= UFS_ISAPPLEUFS;
    581      1.103       dbj 		brelse(bp);
    582      1.103       dbj 		bp = NULL;
    583      1.103       dbj 	}
    584      1.103       dbj #else
    585      1.153   mycroft 	if (ump->um_flags & UFS_ISAPPLEUFS)
    586      1.103       dbj 		return (EIO);
    587      1.103       dbj #endif
    588      1.103       dbj 
    589      1.153   mycroft 	if (UFS_MPISAPPLEUFS(ump)) {
    590      1.103       dbj 		/* see comment about NeXT below */
    591      1.153   mycroft 		ump->um_maxsymlinklen = APPLEUFS_MAXSYMLINKLEN;
    592      1.153   mycroft 		ump->um_dirblksiz = APPLEUFS_DIRBLKSIZ;
    593      1.153   mycroft 		mp->mnt_iflag |= IMNT_DTYPE;
    594      1.153   mycroft 	} else {
    595      1.153   mycroft 		ump->um_maxsymlinklen = fs->fs_maxsymlinklen;
    596      1.153   mycroft 		ump->um_dirblksiz = DIRBLKSIZ;
    597      1.153   mycroft 		if (ump->um_maxsymlinklen > 0)
    598      1.153   mycroft 			mp->mnt_iflag |= IMNT_DTYPE;
    599      1.153   mycroft 		else
    600      1.153   mycroft 			mp->mnt_iflag &= ~IMNT_DTYPE;
    601      1.103       dbj 	}
    602      1.154      yamt 	ffs_oldfscompat_read(fs, ump, sblockloc);
    603  1.196.6.4        ad 	mutex_enter(&ump->um_lock);
    604      1.153   mycroft 	ump->um_maxfilesize = fs->fs_maxfilesize;
    605       1.89      fvdl 	if (fs->fs_pendingblocks != 0 || fs->fs_pendinginodes != 0) {
    606       1.89      fvdl 		fs->fs_pendingblocks = 0;
    607       1.89      fvdl 		fs->fs_pendinginodes = 0;
    608       1.89      fvdl 	}
    609  1.196.6.4        ad 	mutex_exit(&ump->um_lock);
    610       1.85     lukem 
    611      1.177  christos 	ffs_statvfs(mp, &mp->mnt_stat, l);
    612        1.1   mycroft 	/*
    613        1.1   mycroft 	 * Step 3: re-read summary information from disk.
    614        1.1   mycroft 	 */
    615        1.1   mycroft 	blks = howmany(fs->fs_cssize, fs->fs_fsize);
    616       1.84     lukem 	space = fs->fs_csp;
    617        1.1   mycroft 	for (i = 0; i < blks; i += fs->fs_frag) {
    618        1.1   mycroft 		size = fs->fs_bsize;
    619        1.1   mycroft 		if (i + fs->fs_frag > blks)
    620        1.1   mycroft 			size = (blks - i) * fs->fs_fsize;
    621       1.19  christos 		error = bread(devvp, fsbtodb(fs, fs->fs_csaddr + i), size,
    622       1.19  christos 			      NOCRED, &bp);
    623       1.47    bouyer 		if (error) {
    624       1.47    bouyer 			brelse(bp);
    625        1.1   mycroft 			return (error);
    626       1.47    bouyer 		}
    627       1.34    bouyer #ifdef FFS_EI
    628       1.55      fvdl 		if (UFS_FSNEEDSWAP(fs))
    629       1.84     lukem 			ffs_csum_swap((struct csum *)bp->b_data,
    630       1.84     lukem 			    (struct csum *)space, size);
    631       1.34    bouyer 		else
    632       1.34    bouyer #endif
    633       1.84     lukem 			memcpy(space, bp->b_data, (size_t)size);
    634       1.84     lukem 		space = (char *)space + size;
    635        1.1   mycroft 		brelse(bp);
    636        1.1   mycroft 	}
    637       1.55      fvdl 	if ((fs->fs_flags & FS_DOSOFTDEP))
    638      1.153   mycroft 		softdep_mount(devvp, mp, fs, cred);
    639      1.149   hannken 	if (fs->fs_snapinum[0] != 0)
    640      1.153   mycroft 		ffs_snapshot_mount(mp);
    641       1.18       cgd 	/*
    642       1.18       cgd 	 * We no longer know anything about clusters per cylinder group.
    643       1.18       cgd 	 */
    644       1.18       cgd 	if (fs->fs_contigsumsize > 0) {
    645       1.18       cgd 		lp = fs->fs_maxcluster;
    646       1.18       cgd 		for (i = 0; i < fs->fs_ncg; i++)
    647       1.18       cgd 			*lp++ = fs->fs_contigsumsize;
    648       1.18       cgd 	}
    649       1.18       cgd 
    650        1.1   mycroft loop:
    651      1.189   reinoud 	/*
    652      1.189   reinoud 	 * NOTE: not using the TAILQ_FOREACH here since in this loop vgone()
    653      1.189   reinoud 	 * and vclean() can be called indirectly
    654      1.189   reinoud 	 */
    655  1.196.6.2        ad 	mutex_enter(&mntvnode_lock);
    656      1.189   reinoud 	for (vp = TAILQ_FIRST(&mp->mnt_vnodelist); vp; vp = nvp) {
    657      1.153   mycroft 		if (vp->v_mount != mp) {
    658  1.196.6.2        ad 			mutex_exit(&mntvnode_lock);
    659       1.33      fvdl 			goto loop;
    660       1.33      fvdl 		}
    661        1.1   mycroft 		/*
    662        1.1   mycroft 		 * Step 4: invalidate all inactive vnodes.
    663        1.1   mycroft 		 */
    664  1.196.6.2        ad 		if (vrecycle(vp, &mntvnode_lock, l))
    665       1.33      fvdl 			goto loop;
    666        1.1   mycroft 		/*
    667        1.1   mycroft 		 * Step 5: invalidate all cached file data.
    668        1.1   mycroft 		 */
    669  1.196.6.2        ad 		mutex_enter(&vp->v_interlock);
    670      1.189   reinoud 		nvp = TAILQ_NEXT(vp, v_mntvnodes);
    671  1.196.6.2        ad 		mutex_exit(&mntvnode_lock);
    672      1.117   thorpej 		if (vget(vp, LK_EXCLUSIVE | LK_INTERLOCK))
    673        1.1   mycroft 			goto loop;
    674      1.177  christos 		if (vinvalbuf(vp, 0, cred, l, 0, 0))
    675        1.1   mycroft 			panic("ffs_reload: dirty2");
    676        1.1   mycroft 		/*
    677        1.1   mycroft 		 * Step 6: re-read inode data for all active vnodes.
    678        1.1   mycroft 		 */
    679        1.1   mycroft 		ip = VTOI(vp);
    680       1.19  christos 		error = bread(devvp, fsbtodb(fs, ino_to_fsba(fs, ip->i_number)),
    681       1.19  christos 			      (int)fs->fs_bsize, NOCRED, &bp);
    682       1.19  christos 		if (error) {
    683       1.47    bouyer 			brelse(bp);
    684        1.1   mycroft 			vput(vp);
    685        1.1   mycroft 			return (error);
    686        1.1   mycroft 		}
    687      1.110      fvdl 		ffs_load_inode(bp, ip, fs, ip->i_number);
    688      1.110      fvdl 		ip->i_ffs_effnlink = ip->i_nlink;
    689        1.1   mycroft 		brelse(bp);
    690        1.1   mycroft 		vput(vp);
    691  1.196.6.2        ad 		mutex_enter(&mntvnode_lock);
    692        1.1   mycroft 	}
    693  1.196.6.2        ad 	mutex_exit(&mntvnode_lock);
    694        1.1   mycroft 	return (0);
    695        1.1   mycroft }
    696        1.1   mycroft 
    697        1.1   mycroft /*
    698      1.110      fvdl  * Possible superblock locations ordered from most to least likely.
    699      1.110      fvdl  */
    700      1.135  jdolecek static const int sblock_try[] = SBLOCKSEARCH;
    701      1.110      fvdl 
    702      1.110      fvdl /*
    703        1.1   mycroft  * Common code for mount and mountroot
    704        1.1   mycroft  */
    705        1.1   mycroft int
    706      1.177  christos ffs_mountfs(struct vnode *devvp, struct mount *mp, struct lwp *l)
    707        1.1   mycroft {
    708       1.34    bouyer 	struct ufsmount *ump;
    709        1.1   mycroft 	struct buf *bp;
    710       1.34    bouyer 	struct fs *fs;
    711        1.9   mycroft 	dev_t dev;
    712        1.1   mycroft 	struct partinfo dpart;
    713       1.84     lukem 	void *space;
    714      1.110      fvdl 	daddr_t sblockloc, fsblockloc;
    715      1.110      fvdl 	int blks, fstype;
    716       1.52  drochner 	int error, i, size, ronly;
    717       1.52  drochner #ifdef FFS_EI
    718      1.110      fvdl 	int needswap = 0;		/* keep gcc happy */
    719       1.52  drochner #endif
    720        1.9   mycroft 	int32_t *lp;
    721      1.181      elad 	kauth_cred_t cred;
    722      1.110      fvdl 	u_int32_t sbsize = 8192;	/* keep gcc happy*/
    723        1.1   mycroft 
    724        1.9   mycroft 	dev = devvp->v_rdev;
    725      1.184        ad 	cred = l ? l->l_cred : NOCRED;
    726      1.159   mycroft 
    727      1.159   mycroft 	/* Flush out any old buffers remaining from a previous use. */
    728       1.55      fvdl 	vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
    729      1.177  christos 	error = vinvalbuf(devvp, V_SAVE, cred, l, 0, 0);
    730       1.55      fvdl 	VOP_UNLOCK(devvp, 0);
    731       1.55      fvdl 	if (error)
    732        1.1   mycroft 		return (error);
    733        1.1   mycroft 
    734        1.1   mycroft 	ronly = (mp->mnt_flag & MNT_RDONLY) != 0;
    735      1.177  christos 	if (VOP_IOCTL(devvp, DIOCGPART, &dpart, FREAD, cred, l) != 0)
    736        1.1   mycroft 		size = DEV_BSIZE;
    737        1.1   mycroft 	else
    738        1.1   mycroft 		size = dpart.disklab->d_secsize;
    739        1.1   mycroft 
    740        1.1   mycroft 	bp = NULL;
    741        1.1   mycroft 	ump = NULL;
    742      1.110      fvdl 	fs = NULL;
    743      1.138       dsl 	sblockloc = 0;
    744      1.110      fvdl 	fstype = 0;
    745       1.34    bouyer 
    746      1.110      fvdl 	/*
    747      1.192     isaki 	 * Try reading the superblock in each of its possible locations.
    748      1.192     isaki 	 */
    749      1.138       dsl 	for (i = 0; ; i++) {
    750      1.138       dsl 		if (bp != NULL) {
    751      1.138       dsl 			bp->b_flags |= B_NOCACHE;
    752      1.138       dsl 			brelse(bp);
    753      1.138       dsl 			bp = NULL;
    754      1.138       dsl 		}
    755      1.138       dsl 		if (sblock_try[i] == -1) {
    756      1.138       dsl 			error = EINVAL;
    757      1.138       dsl 			fs = NULL;
    758      1.138       dsl 			goto out;
    759      1.138       dsl 		}
    760      1.110      fvdl 		error = bread(devvp, sblock_try[i] / size, SBLOCKSIZE, cred,
    761      1.110      fvdl 			      &bp);
    762      1.168  drochner 		if (error) {
    763      1.168  drochner 			fs = NULL;
    764      1.110      fvdl 			goto out;
    765      1.168  drochner 		}
    766      1.110      fvdl 		fs = (struct fs*)bp->b_data;
    767      1.110      fvdl 		fsblockloc = sblockloc = sblock_try[i];
    768      1.110      fvdl 		if (fs->fs_magic == FS_UFS1_MAGIC) {
    769      1.110      fvdl 			sbsize = fs->fs_sbsize;
    770      1.110      fvdl 			fstype = UFS1;
    771       1.34    bouyer #ifdef FFS_EI
    772      1.110      fvdl 			needswap = 0;
    773      1.110      fvdl 		} else if (fs->fs_magic == bswap32(FS_UFS1_MAGIC)) {
    774      1.110      fvdl 			sbsize = bswap32(fs->fs_sbsize);
    775      1.110      fvdl 			fstype = UFS1;
    776      1.110      fvdl 			needswap = 1;
    777       1.34    bouyer #endif
    778      1.110      fvdl 		} else if (fs->fs_magic == FS_UFS2_MAGIC) {
    779      1.110      fvdl 			sbsize = fs->fs_sbsize;
    780      1.110      fvdl 			fstype = UFS2;
    781      1.110      fvdl #ifdef FFS_EI
    782      1.110      fvdl 			needswap = 0;
    783      1.110      fvdl 		} else if (fs->fs_magic == bswap32(FS_UFS2_MAGIC)) {
    784      1.110      fvdl 			sbsize = bswap32(fs->fs_sbsize);
    785      1.110      fvdl 			fstype = UFS2;
    786      1.110      fvdl 			needswap = 1;
    787      1.110      fvdl #endif
    788      1.112      fvdl 		} else
    789      1.138       dsl 			continue;
    790      1.138       dsl 
    791      1.138       dsl 
    792      1.138       dsl 		/* fs->fs_sblockloc isn't defined for old filesystems */
    793      1.140       dsl 		if (fstype == UFS1 && !(fs->fs_old_flags & FS_FLAGS_UPDATED)) {
    794      1.140       dsl 			if (sblockloc == SBLOCK_UFS2)
    795      1.138       dsl 				/*
    796      1.138       dsl 				 * This is likely to be the first alternate
    797      1.138       dsl 				 * in a filesystem with 64k blocks.
    798      1.138       dsl 				 * Don't use it.
    799      1.138       dsl 				 */
    800      1.138       dsl 				continue;
    801      1.138       dsl 			fsblockloc = sblockloc;
    802      1.138       dsl 		} else {
    803      1.138       dsl 			fsblockloc = fs->fs_sblockloc;
    804      1.138       dsl #ifdef FFS_EI
    805      1.138       dsl 			if (needswap)
    806      1.138       dsl 				fsblockloc = bswap64(fsblockloc);
    807      1.138       dsl #endif
    808      1.138       dsl 		}
    809      1.110      fvdl 
    810      1.138       dsl 		/* Check we haven't found an alternate superblock */
    811      1.138       dsl 		if (fsblockloc != sblockloc)
    812      1.138       dsl 			continue;
    813      1.112      fvdl 
    814      1.138       dsl 		/* Validate size of superblock */
    815      1.138       dsl 		if (sbsize > MAXBSIZE || sbsize < sizeof(struct fs))
    816      1.138       dsl 			continue;
    817      1.110      fvdl 
    818      1.138       dsl 		/* Ok seems to be a good superblock */
    819      1.138       dsl 		break;
    820       1.34    bouyer 	}
    821       1.34    bouyer 
    822       1.34    bouyer 	fs = malloc((u_long)sbsize, M_UFSMNT, M_WAITOK);
    823       1.42     perry 	memcpy(fs, bp->b_data, sbsize);
    824      1.111      fvdl 
    825      1.111      fvdl 	ump = malloc(sizeof *ump, M_UFSMNT, M_WAITOK);
    826      1.111      fvdl 	memset(ump, 0, sizeof *ump);
    827  1.196.6.4        ad 	mutex_init(&ump->um_lock, MUTEX_DEFAULT, IPL_NONE);
    828      1.149   hannken 	TAILQ_INIT(&ump->um_snapshots);
    829      1.111      fvdl 	ump->um_fs = fs;
    830      1.175      yamt 	ump->um_ops = &ffs_ufsops;
    831      1.111      fvdl 
    832       1.34    bouyer #ifdef FFS_EI
    833       1.55      fvdl 	if (needswap) {
    834       1.83     lukem 		ffs_sb_swap((struct fs*)bp->b_data, fs);
    835       1.55      fvdl 		fs->fs_flags |= FS_SWAPPED;
    836      1.121    bouyer 	} else
    837       1.34    bouyer #endif
    838      1.121    bouyer 		fs->fs_flags &= ~FS_SWAPPED;
    839       1.56  drochner 
    840      1.154      yamt 	ffs_oldfscompat_read(fs, ump, sblockloc);
    841      1.153   mycroft 	ump->um_maxfilesize = fs->fs_maxfilesize;
    842      1.131       dbj 
    843       1.89      fvdl 	if (fs->fs_pendingblocks != 0 || fs->fs_pendinginodes != 0) {
    844       1.89      fvdl 		fs->fs_pendingblocks = 0;
    845       1.89      fvdl 		fs->fs_pendinginodes = 0;
    846       1.89      fvdl 	}
    847       1.56  drochner 
    848      1.110      fvdl 	ump->um_fstype = fstype;
    849      1.110      fvdl 	if (fs->fs_sbsize < SBLOCKSIZE)
    850        1.1   mycroft 		bp->b_flags |= B_INVAL;
    851        1.1   mycroft 	brelse(bp);
    852        1.1   mycroft 	bp = NULL;
    853       1.94       chs 
    854      1.103       dbj 	/* First check to see if this is tagged as an Apple UFS filesystem
    855      1.103       dbj 	 * in the disklabel
    856      1.103       dbj 	 */
    857      1.177  christos 	if ((VOP_IOCTL(devvp, DIOCGPART, &dpart, FREAD, cred, l) == 0) &&
    858      1.103       dbj 		(dpart.part->p_fstype == FS_APPLEUFS)) {
    859      1.103       dbj 		ump->um_flags |= UFS_ISAPPLEUFS;
    860      1.103       dbj 	}
    861      1.103       dbj #ifdef APPLE_UFS
    862      1.103       dbj 	else {
    863      1.103       dbj 		/* Manually look for an apple ufs label, and if a valid one
    864      1.103       dbj 		 * is found, then treat it like an Apple UFS filesystem anyway
    865      1.103       dbj 		 */
    866      1.106      fvdl 		error = bread(devvp, (daddr_t)(APPLEUFS_LABEL_OFFSET / size),
    867      1.103       dbj 			APPLEUFS_LABEL_SIZE, cred, &bp);
    868      1.103       dbj 		if (error)
    869      1.103       dbj 			goto out;
    870      1.103       dbj 		error = ffs_appleufs_validate(fs->fs_fsmnt,
    871      1.103       dbj 			(struct appleufslabel *)bp->b_data,NULL);
    872      1.103       dbj 		if (error == 0) {
    873      1.103       dbj 			ump->um_flags |= UFS_ISAPPLEUFS;
    874      1.103       dbj 		}
    875      1.103       dbj 		brelse(bp);
    876      1.103       dbj 		bp = NULL;
    877      1.103       dbj 	}
    878      1.103       dbj #else
    879      1.103       dbj 	if (ump->um_flags & UFS_ISAPPLEUFS) {
    880      1.103       dbj 		error = EINVAL;
    881      1.103       dbj 		goto out;
    882      1.103       dbj 	}
    883      1.103       dbj #endif
    884      1.103       dbj 
    885       1.94       chs 	/*
    886       1.99       chs 	 * verify that we can access the last block in the fs
    887       1.99       chs 	 * if we're mounting read/write.
    888       1.94       chs 	 */
    889       1.94       chs 
    890       1.99       chs 	if (!ronly) {
    891       1.99       chs 		error = bread(devvp, fsbtodb(fs, fs->fs_size - 1), fs->fs_fsize,
    892       1.99       chs 		    cred, &bp);
    893       1.99       chs 		if (bp->b_bcount != fs->fs_fsize)
    894       1.99       chs 			error = EINVAL;
    895       1.99       chs 		bp->b_flags |= B_INVAL;
    896       1.99       chs 		if (error)
    897       1.99       chs 			goto out;
    898       1.99       chs 		brelse(bp);
    899       1.99       chs 		bp = NULL;
    900       1.99       chs 	}
    901       1.94       chs 
    902        1.1   mycroft 	fs->fs_ronly = ronly;
    903       1.15   mycroft 	if (ronly == 0) {
    904       1.15   mycroft 		fs->fs_clean <<= 1;
    905        1.1   mycroft 		fs->fs_fmod = 1;
    906       1.15   mycroft 	}
    907        1.9   mycroft 	size = fs->fs_cssize;
    908        1.9   mycroft 	blks = howmany(size, fs->fs_fsize);
    909        1.9   mycroft 	if (fs->fs_contigsumsize > 0)
    910        1.9   mycroft 		size += fs->fs_ncg * sizeof(int32_t);
    911       1.85     lukem 	size += fs->fs_ncg * sizeof(*fs->fs_contigdirs);
    912       1.84     lukem 	space = malloc((u_long)size, M_UFSMNT, M_WAITOK);
    913       1.84     lukem 	fs->fs_csp = space;
    914        1.1   mycroft 	for (i = 0; i < blks; i += fs->fs_frag) {
    915        1.1   mycroft 		size = fs->fs_bsize;
    916        1.1   mycroft 		if (i + fs->fs_frag > blks)
    917        1.1   mycroft 			size = (blks - i) * fs->fs_fsize;
    918       1.19  christos 		error = bread(devvp, fsbtodb(fs, fs->fs_csaddr + i), size,
    919       1.19  christos 			      cred, &bp);
    920       1.19  christos 		if (error) {
    921       1.84     lukem 			free(fs->fs_csp, M_UFSMNT);
    922      1.128       dbj 			goto out;
    923        1.1   mycroft 		}
    924       1.34    bouyer #ifdef FFS_EI
    925       1.34    bouyer 		if (needswap)
    926       1.84     lukem 			ffs_csum_swap((struct csum *)bp->b_data,
    927       1.84     lukem 				(struct csum *)space, size);
    928       1.34    bouyer 		else
    929       1.34    bouyer #endif
    930       1.42     perry 			memcpy(space, bp->b_data, (u_int)size);
    931      1.161     perry 
    932       1.84     lukem 		space = (char *)space + size;
    933        1.1   mycroft 		brelse(bp);
    934        1.1   mycroft 		bp = NULL;
    935        1.1   mycroft 	}
    936        1.9   mycroft 	if (fs->fs_contigsumsize > 0) {
    937       1.85     lukem 		fs->fs_maxcluster = lp = space;
    938        1.9   mycroft 		for (i = 0; i < fs->fs_ncg; i++)
    939        1.9   mycroft 			*lp++ = fs->fs_contigsumsize;
    940       1.85     lukem 		space = lp;
    941        1.9   mycroft 	}
    942       1.85     lukem 	size = fs->fs_ncg * sizeof(*fs->fs_contigdirs);
    943       1.85     lukem 	fs->fs_contigdirs = space;
    944       1.85     lukem 	space = (char *)space + size;
    945       1.85     lukem 	memset(fs->fs_contigdirs, 0, size);
    946       1.85     lukem 		/* Compatibility for old filesystems - XXX */
    947       1.85     lukem 	if (fs->fs_avgfilesize <= 0)
    948       1.85     lukem 		fs->fs_avgfilesize = AVFILESIZ;
    949       1.85     lukem 	if (fs->fs_avgfpdir <= 0)
    950       1.85     lukem 		fs->fs_avgfpdir = AFPDIR;
    951      1.150   hannken 	fs->fs_active = NULL;
    952      1.100     soren 	mp->mnt_data = ump;
    953      1.143  christos 	mp->mnt_stat.f_fsidx.__fsid_val[0] = (long)dev;
    954      1.143  christos 	mp->mnt_stat.f_fsidx.__fsid_val[1] = makefstype(MOUNT_FFS);
    955      1.143  christos 	mp->mnt_stat.f_fsid = mp->mnt_stat.f_fsidx.__fsid_val[0];
    956      1.169  christos 	mp->mnt_stat.f_namemax = FFS_MAXNAMLEN;
    957      1.153   mycroft 	if (UFS_MPISAPPLEUFS(ump)) {
    958      1.103       dbj 		/* NeXT used to keep short symlinks in the inode even
    959      1.103       dbj 		 * when using FS_42INODEFMT.  In that case fs->fs_maxsymlinklen
    960      1.103       dbj 		 * is probably -1, but we still need to be able to identify
    961      1.103       dbj 		 * short symlinks.
    962      1.103       dbj 		 */
    963      1.153   mycroft 		ump->um_maxsymlinklen = APPLEUFS_MAXSYMLINKLEN;
    964      1.153   mycroft 		ump->um_dirblksiz = APPLEUFS_DIRBLKSIZ;
    965      1.153   mycroft 		mp->mnt_iflag |= IMNT_DTYPE;
    966      1.153   mycroft 	} else {
    967      1.153   mycroft 		ump->um_maxsymlinklen = fs->fs_maxsymlinklen;
    968      1.153   mycroft 		ump->um_dirblksiz = DIRBLKSIZ;
    969      1.153   mycroft 		if (ump->um_maxsymlinklen > 0)
    970      1.153   mycroft 			mp->mnt_iflag |= IMNT_DTYPE;
    971      1.153   mycroft 		else
    972      1.153   mycroft 			mp->mnt_iflag &= ~IMNT_DTYPE;
    973      1.103       dbj 	}
    974       1.73       chs 	mp->mnt_fs_bshift = fs->fs_bshift;
    975       1.73       chs 	mp->mnt_dev_bshift = DEV_BSHIFT;	/* XXX */
    976        1.1   mycroft 	mp->mnt_flag |= MNT_LOCAL;
    977      1.193   hannken 	mp->mnt_iflag |= IMNT_HAS_TRANS;
    978       1.34    bouyer #ifdef FFS_EI
    979       1.34    bouyer 	if (needswap)
    980       1.34    bouyer 		ump->um_flags |= UFS_NEEDSWAP;
    981       1.34    bouyer #endif
    982        1.1   mycroft 	ump->um_mountp = mp;
    983        1.1   mycroft 	ump->um_dev = dev;
    984        1.1   mycroft 	ump->um_devvp = devvp;
    985        1.1   mycroft 	ump->um_nindir = fs->fs_nindir;
    986       1.73       chs 	ump->um_lognindir = ffs(fs->fs_nindir) - 1;
    987        1.1   mycroft 	ump->um_bptrtodb = fs->fs_fsbtodb;
    988        1.1   mycroft 	ump->um_seqinc = fs->fs_frag;
    989        1.1   mycroft 	for (i = 0; i < MAXQUOTAS; i++)
    990        1.1   mycroft 		ump->um_quotas[i] = NULLVP;
    991       1.55      fvdl 	devvp->v_specmountpoint = mp;
    992       1.55      fvdl 	if (ronly == 0 && (fs->fs_flags & FS_DOSOFTDEP)) {
    993       1.55      fvdl 		error = softdep_mount(devvp, mp, fs, cred);
    994       1.55      fvdl 		if (error) {
    995       1.84     lukem 			free(fs->fs_csp, M_UFSMNT);
    996       1.55      fvdl 			goto out;
    997       1.55      fvdl 		}
    998       1.55      fvdl 	}
    999      1.149   hannken 	if (ronly == 0 && fs->fs_snapinum[0] != 0)
   1000      1.149   hannken 		ffs_snapshot_mount(mp);
   1001      1.170   thorpej #ifdef UFS_EXTATTR
   1002      1.170   thorpej 	/*
   1003      1.170   thorpej 	 * Initialize file-backed extended attributes on UFS1 file
   1004      1.170   thorpej 	 * systems.
   1005      1.170   thorpej 	 */
   1006      1.170   thorpej 	if (ump->um_fstype == UFS1) {
   1007      1.170   thorpej 		ufs_extattr_uepm_init(&ump->um_extattr);
   1008      1.170   thorpej #ifdef UFS_EXTATTR_AUTOSTART
   1009      1.170   thorpej 		/*
   1010      1.170   thorpej 		 * XXX Just ignore errors.  Not clear that we should
   1011      1.170   thorpej 		 * XXX fail the mount in this case.
   1012      1.170   thorpej 		 */
   1013      1.178    rpaulo 		(void) ufs_extattr_autostart(mp, l);
   1014      1.170   thorpej #endif
   1015      1.170   thorpej 	}
   1016      1.170   thorpej #endif /* UFS_EXTATTR */
   1017        1.1   mycroft 	return (0);
   1018        1.1   mycroft out:
   1019      1.128       dbj 	if (fs)
   1020      1.128       dbj 		free(fs, M_UFSMNT);
   1021       1.55      fvdl 	devvp->v_specmountpoint = NULL;
   1022        1.1   mycroft 	if (bp)
   1023        1.1   mycroft 		brelse(bp);
   1024        1.1   mycroft 	if (ump) {
   1025      1.131       dbj 		if (ump->um_oldfscompat)
   1026      1.131       dbj 			free(ump->um_oldfscompat, M_UFSMNT);
   1027  1.196.6.4        ad 		mutex_destroy(&ump->um_lock);
   1028        1.1   mycroft 		free(ump, M_UFSMNT);
   1029      1.100     soren 		mp->mnt_data = NULL;
   1030        1.1   mycroft 	}
   1031        1.1   mycroft 	return (error);
   1032        1.1   mycroft }
   1033        1.1   mycroft 
   1034        1.1   mycroft /*
   1035      1.110      fvdl  * Sanity checks for loading old filesystem superblocks.
   1036      1.110      fvdl  * See ffs_oldfscompat_write below for unwound actions.
   1037        1.1   mycroft  *
   1038      1.110      fvdl  * XXX - Parts get retired eventually.
   1039      1.110      fvdl  * Unfortunately new bits get added.
   1040        1.1   mycroft  */
   1041      1.110      fvdl static void
   1042      1.166   thorpej ffs_oldfscompat_read(struct fs *fs, struct ufsmount *ump, daddr_t sblockloc)
   1043      1.110      fvdl {
   1044      1.110      fvdl 	off_t maxfilesize;
   1045      1.131       dbj 	int32_t *extrasave;
   1046      1.110      fvdl 
   1047      1.131       dbj 	if ((fs->fs_magic != FS_UFS1_MAGIC) ||
   1048      1.131       dbj 	    (fs->fs_old_flags & FS_FLAGS_UPDATED))
   1049      1.111      fvdl 		return;
   1050      1.111      fvdl 
   1051      1.131       dbj 	if (!ump->um_oldfscompat)
   1052      1.131       dbj 		ump->um_oldfscompat = malloc(512 + 3*sizeof(int32_t),
   1053      1.131       dbj 		    M_UFSMNT, M_WAITOK);
   1054      1.131       dbj 
   1055      1.131       dbj 	memcpy(ump->um_oldfscompat, &fs->fs_old_postbl_start, 512);
   1056      1.131       dbj 	extrasave = ump->um_oldfscompat;
   1057      1.131       dbj 	extrasave += 512/sizeof(int32_t);
   1058      1.131       dbj 	extrasave[0] = fs->fs_old_npsect;
   1059      1.131       dbj 	extrasave[1] = fs->fs_old_interleave;
   1060      1.131       dbj 	extrasave[2] = fs->fs_old_trackskew;
   1061      1.131       dbj 
   1062      1.131       dbj 	/* These fields will be overwritten by their
   1063      1.131       dbj 	 * original values in fs_oldfscompat_write, so it is harmless
   1064      1.131       dbj 	 * to modify them here.
   1065      1.131       dbj 	 */
   1066      1.131       dbj 	fs->fs_cstotal.cs_ndir = fs->fs_old_cstotal.cs_ndir;
   1067      1.131       dbj 	fs->fs_cstotal.cs_nbfree = fs->fs_old_cstotal.cs_nbfree;
   1068      1.131       dbj 	fs->fs_cstotal.cs_nifree = fs->fs_old_cstotal.cs_nifree;
   1069      1.131       dbj 	fs->fs_cstotal.cs_nffree = fs->fs_old_cstotal.cs_nffree;
   1070      1.131       dbj 
   1071      1.131       dbj 	fs->fs_maxbsize = fs->fs_bsize;
   1072      1.131       dbj 	fs->fs_time = fs->fs_old_time;
   1073      1.131       dbj 	fs->fs_size = fs->fs_old_size;
   1074      1.131       dbj 	fs->fs_dsize = fs->fs_old_dsize;
   1075      1.131       dbj 	fs->fs_csaddr = fs->fs_old_csaddr;
   1076      1.131       dbj 	fs->fs_sblockloc = sblockloc;
   1077      1.131       dbj 
   1078      1.162  christos         fs->fs_flags = fs->fs_old_flags | (fs->fs_flags & FS_INTERNAL);
   1079      1.122     enami 
   1080      1.131       dbj 	if (fs->fs_old_postblformat == FS_42POSTBLFMT) {
   1081      1.131       dbj 		fs->fs_old_nrpos = 8;
   1082      1.131       dbj 		fs->fs_old_npsect = fs->fs_old_nsect;
   1083      1.131       dbj 		fs->fs_old_interleave = 1;
   1084      1.131       dbj 		fs->fs_old_trackskew = 0;
   1085      1.111      fvdl 	}
   1086      1.111      fvdl 
   1087      1.111      fvdl 	if (fs->fs_old_inodefmt < FS_44INODEFMT) {
   1088      1.153   mycroft 		ump->um_maxfilesize = (u_quad_t) 1LL << 39;
   1089      1.110      fvdl 		fs->fs_qbmask = ~fs->fs_bmask;
   1090      1.110      fvdl 		fs->fs_qfmask = ~fs->fs_fmask;
   1091      1.110      fvdl 	}
   1092      1.111      fvdl 
   1093      1.111      fvdl 	maxfilesize = (u_int64_t)0x80000000 * fs->fs_bsize - 1;
   1094      1.153   mycroft 	if (ump->um_maxfilesize > maxfilesize)
   1095      1.153   mycroft 		ump->um_maxfilesize = maxfilesize;
   1096      1.111      fvdl 
   1097      1.110      fvdl 	/* Compatibility for old filesystems */
   1098      1.110      fvdl 	if (fs->fs_avgfilesize <= 0)
   1099      1.110      fvdl 		fs->fs_avgfilesize = AVFILESIZ;
   1100      1.110      fvdl 	if (fs->fs_avgfpdir <= 0)
   1101      1.110      fvdl 		fs->fs_avgfpdir = AFPDIR;
   1102      1.131       dbj 
   1103      1.110      fvdl #if 0
   1104      1.110      fvdl 	if (bigcgs) {
   1105      1.110      fvdl 		fs->fs_save_cgsize = fs->fs_cgsize;
   1106      1.110      fvdl 		fs->fs_cgsize = fs->fs_bsize;
   1107      1.110      fvdl 	}
   1108      1.110      fvdl #endif
   1109      1.110      fvdl }
   1110      1.110      fvdl 
   1111      1.110      fvdl /*
   1112      1.110      fvdl  * Unwinding superblock updates for old filesystems.
   1113      1.110      fvdl  * See ffs_oldfscompat_read above for details.
   1114      1.110      fvdl  *
   1115      1.110      fvdl  * XXX - Parts get retired eventually.
   1116      1.110      fvdl  * Unfortunately new bits get added.
   1117      1.110      fvdl  */
   1118      1.110      fvdl static void
   1119      1.166   thorpej ffs_oldfscompat_write(struct fs *fs, struct ufsmount *ump)
   1120        1.1   mycroft {
   1121      1.131       dbj 	int32_t *extrasave;
   1122      1.131       dbj 
   1123      1.131       dbj 	if ((fs->fs_magic != FS_UFS1_MAGIC) ||
   1124      1.131       dbj 	    (fs->fs_old_flags & FS_FLAGS_UPDATED))
   1125      1.111      fvdl 		return;
   1126      1.115      fvdl 
   1127      1.111      fvdl 	fs->fs_old_time = fs->fs_time;
   1128      1.111      fvdl 	fs->fs_old_cstotal.cs_ndir = fs->fs_cstotal.cs_ndir;
   1129      1.111      fvdl 	fs->fs_old_cstotal.cs_nbfree = fs->fs_cstotal.cs_nbfree;
   1130      1.111      fvdl 	fs->fs_old_cstotal.cs_nifree = fs->fs_cstotal.cs_nifree;
   1131      1.111      fvdl 	fs->fs_old_cstotal.cs_nffree = fs->fs_cstotal.cs_nffree;
   1132      1.131       dbj 	fs->fs_old_flags = fs->fs_flags;
   1133      1.111      fvdl 
   1134      1.110      fvdl #if 0
   1135      1.110      fvdl 	if (bigcgs) {
   1136      1.110      fvdl 		fs->fs_cgsize = fs->fs_save_cgsize;
   1137      1.110      fvdl 	}
   1138      1.110      fvdl #endif
   1139      1.131       dbj 
   1140      1.131       dbj 	memcpy(&fs->fs_old_postbl_start, ump->um_oldfscompat, 512);
   1141      1.131       dbj 	extrasave = ump->um_oldfscompat;
   1142      1.131       dbj 	extrasave += 512/sizeof(int32_t);
   1143      1.131       dbj 	fs->fs_old_npsect = extrasave[0];
   1144      1.131       dbj 	fs->fs_old_interleave = extrasave[1];
   1145      1.131       dbj 	fs->fs_old_trackskew = extrasave[2];
   1146      1.131       dbj 
   1147        1.1   mycroft }
   1148        1.1   mycroft 
   1149        1.1   mycroft /*
   1150        1.1   mycroft  * unmount system call
   1151        1.1   mycroft  */
   1152        1.1   mycroft int
   1153      1.177  christos ffs_unmount(struct mount *mp, int mntflags, struct lwp *l)
   1154        1.1   mycroft {
   1155      1.170   thorpej 	struct ufsmount *ump = VFSTOUFS(mp);
   1156      1.170   thorpej 	struct fs *fs = ump->um_fs;
   1157       1.91      fvdl 	int error, flags, penderr;
   1158        1.1   mycroft 
   1159       1.91      fvdl 	penderr = 0;
   1160        1.1   mycroft 	flags = 0;
   1161       1.11   mycroft 	if (mntflags & MNT_FORCE)
   1162        1.1   mycroft 		flags |= FORCECLOSE;
   1163      1.170   thorpej #ifdef UFS_EXTATTR
   1164      1.170   thorpej 	if (ump->um_fstype == UFS1) {
   1165      1.178    rpaulo 		error = ufs_extattr_stop(mp, l);
   1166      1.173    rpaulo 		if (error) {
   1167      1.173    rpaulo 			if (error != EOPNOTSUPP)
   1168      1.173    rpaulo 				printf("%s: ufs_extattr_stop returned %d\n",
   1169      1.173    rpaulo 				    fs->fs_fsmnt, error);
   1170      1.173    rpaulo 		} else
   1171      1.170   thorpej 			ufs_extattr_uepm_destroy(&ump->um_extattr);
   1172      1.170   thorpej 	}
   1173      1.170   thorpej #endif /* UFS_EXTATTR */
   1174       1.55      fvdl 	if (mp->mnt_flag & MNT_SOFTDEP) {
   1175      1.177  christos 		if ((error = softdep_flushfiles(mp, flags, l)) != 0)
   1176       1.55      fvdl 			return (error);
   1177       1.55      fvdl 	} else {
   1178      1.177  christos 		if ((error = ffs_flushfiles(mp, flags, l)) != 0)
   1179       1.55      fvdl 			return (error);
   1180       1.55      fvdl 	}
   1181       1.89      fvdl 	if (fs->fs_pendingblocks != 0 || fs->fs_pendinginodes != 0) {
   1182      1.110      fvdl 		printf("%s: unmount pending error: blocks %" PRId64
   1183      1.110      fvdl 		       " files %d\n",
   1184       1.89      fvdl 		    fs->fs_fsmnt, fs->fs_pendingblocks, fs->fs_pendinginodes);
   1185       1.89      fvdl 		fs->fs_pendingblocks = 0;
   1186       1.89      fvdl 		fs->fs_pendinginodes = 0;
   1187       1.91      fvdl 		penderr = 1;
   1188       1.89      fvdl 	}
   1189       1.15   mycroft 	if (fs->fs_ronly == 0 &&
   1190       1.15   mycroft 	    ffs_cgupdate(ump, MNT_WAIT) == 0 &&
   1191       1.15   mycroft 	    fs->fs_clean & FS_WASCLEAN) {
   1192       1.91      fvdl 		/*
   1193       1.91      fvdl 		 * XXXX don't mark fs clean in the case of softdep
   1194       1.91      fvdl 		 * pending block errors, until they are fixed.
   1195       1.91      fvdl 		 */
   1196       1.91      fvdl 		if (penderr == 0) {
   1197       1.91      fvdl 			if (mp->mnt_flag & MNT_SOFTDEP)
   1198       1.91      fvdl 				fs->fs_flags &= ~FS_DOSOFTDEP;
   1199       1.91      fvdl 			fs->fs_clean = FS_ISCLEAN;
   1200       1.91      fvdl 		}
   1201      1.109      fvdl 		fs->fs_fmod = 0;
   1202       1.15   mycroft 		(void) ffs_sbupdate(ump, MNT_WAIT);
   1203       1.15   mycroft 	}
   1204       1.54     enami 	if (ump->um_devvp->v_type != VBAD)
   1205       1.55      fvdl 		ump->um_devvp->v_specmountpoint = NULL;
   1206       1.53  wrstuden 	vn_lock(ump->um_devvp, LK_EXCLUSIVE | LK_RETRY);
   1207      1.129       dbj 	(void)VOP_CLOSE(ump->um_devvp, fs->fs_ronly ? FREAD : FREAD|FWRITE,
   1208      1.177  christos 		NOCRED, l);
   1209       1.53  wrstuden 	vput(ump->um_devvp);
   1210       1.84     lukem 	free(fs->fs_csp, M_UFSMNT);
   1211        1.1   mycroft 	free(fs, M_UFSMNT);
   1212      1.131       dbj 	if (ump->um_oldfscompat != NULL)
   1213      1.131       dbj 		free(ump->um_oldfscompat, M_UFSMNT);
   1214  1.196.6.4        ad 	mutex_destroy(&ump->um_lock);
   1215        1.1   mycroft 	free(ump, M_UFSMNT);
   1216      1.100     soren 	mp->mnt_data = NULL;
   1217        1.1   mycroft 	mp->mnt_flag &= ~MNT_LOCAL;
   1218      1.129       dbj 	return (0);
   1219        1.1   mycroft }
   1220        1.1   mycroft 
   1221        1.1   mycroft /*
   1222        1.1   mycroft  * Flush out all the files in a filesystem.
   1223        1.1   mycroft  */
   1224       1.19  christos int
   1225      1.177  christos ffs_flushfiles(struct mount *mp, int flags, struct lwp *l)
   1226        1.1   mycroft {
   1227        1.1   mycroft 	extern int doforce;
   1228       1.61  augustss 	struct ufsmount *ump;
   1229       1.19  christos 	int error;
   1230        1.1   mycroft 
   1231        1.1   mycroft 	if (!doforce)
   1232        1.1   mycroft 		flags &= ~FORCECLOSE;
   1233        1.1   mycroft 	ump = VFSTOUFS(mp);
   1234        1.1   mycroft #ifdef QUOTA
   1235        1.1   mycroft 	if (mp->mnt_flag & MNT_QUOTA) {
   1236       1.19  christos 		int i;
   1237       1.19  christos 		if ((error = vflush(mp, NULLVP, SKIPSYSTEM|flags)) != 0)
   1238        1.1   mycroft 			return (error);
   1239        1.1   mycroft 		for (i = 0; i < MAXQUOTAS; i++) {
   1240        1.1   mycroft 			if (ump->um_quotas[i] == NULLVP)
   1241        1.1   mycroft 				continue;
   1242      1.177  christos 			quotaoff(l, mp, i);
   1243        1.1   mycroft 		}
   1244        1.1   mycroft 		/*
   1245        1.1   mycroft 		 * Here we fall through to vflush again to ensure
   1246        1.1   mycroft 		 * that we have gotten rid of all the system vnodes.
   1247        1.1   mycroft 		 */
   1248        1.1   mycroft 	}
   1249        1.1   mycroft #endif
   1250      1.149   hannken 	if ((error = vflush(mp, 0, SKIPSYSTEM | flags)) != 0)
   1251      1.149   hannken 		return (error);
   1252      1.149   hannken 	ffs_snapshot_unmount(mp);
   1253       1.55      fvdl 	/*
   1254       1.55      fvdl 	 * Flush all the files.
   1255       1.55      fvdl 	 */
   1256        1.1   mycroft 	error = vflush(mp, NULLVP, flags);
   1257       1.55      fvdl 	if (error)
   1258       1.55      fvdl 		return (error);
   1259       1.55      fvdl 	/*
   1260       1.55      fvdl 	 * Flush filesystem metadata.
   1261       1.55      fvdl 	 */
   1262       1.55      fvdl 	vn_lock(ump->um_devvp, LK_EXCLUSIVE | LK_RETRY);
   1263      1.184        ad 	error = VOP_FSYNC(ump->um_devvp, l->l_cred, FSYNC_WAIT, 0, 0, l);
   1264       1.55      fvdl 	VOP_UNLOCK(ump->um_devvp, 0);
   1265        1.1   mycroft 	return (error);
   1266        1.1   mycroft }
   1267        1.1   mycroft 
   1268        1.1   mycroft /*
   1269        1.1   mycroft  * Get file system statistics.
   1270        1.1   mycroft  */
   1271        1.1   mycroft int
   1272      1.190  christos ffs_statvfs(struct mount *mp, struct statvfs *sbp, struct lwp *l)
   1273        1.1   mycroft {
   1274       1.61  augustss 	struct ufsmount *ump;
   1275       1.61  augustss 	struct fs *fs;
   1276        1.1   mycroft 
   1277        1.1   mycroft 	ump = VFSTOUFS(mp);
   1278        1.1   mycroft 	fs = ump->um_fs;
   1279      1.143  christos 	sbp->f_bsize = fs->fs_bsize;
   1280      1.143  christos 	sbp->f_frsize = fs->fs_fsize;
   1281        1.1   mycroft 	sbp->f_iosize = fs->fs_bsize;
   1282        1.1   mycroft 	sbp->f_blocks = fs->fs_dsize;
   1283       1.98   mycroft 	sbp->f_bfree = blkstofrags(fs, fs->fs_cstotal.cs_nbfree) +
   1284       1.89      fvdl 		fs->fs_cstotal.cs_nffree + dbtofsb(fs, fs->fs_pendingblocks);
   1285      1.143  christos 	sbp->f_bresvd = ((u_int64_t) fs->fs_dsize * (u_int64_t)
   1286      1.143  christos 	    fs->fs_minfree) / (u_int64_t) 100;
   1287      1.143  christos 	if (sbp->f_bfree > sbp->f_bresvd)
   1288      1.143  christos 		sbp->f_bavail = sbp->f_bfree - sbp->f_bresvd;
   1289      1.143  christos 	else
   1290      1.143  christos 		sbp->f_bavail = 0;
   1291        1.1   mycroft 	sbp->f_files =  fs->fs_ncg * fs->fs_ipg - ROOTINO;
   1292       1.89      fvdl 	sbp->f_ffree = fs->fs_cstotal.cs_nifree + fs->fs_pendinginodes;
   1293      1.143  christos 	sbp->f_favail = sbp->f_ffree;
   1294      1.143  christos 	sbp->f_fresvd = 0;
   1295      1.143  christos 	copy_statvfs_info(sbp, mp);
   1296        1.1   mycroft 	return (0);
   1297        1.1   mycroft }
   1298        1.1   mycroft 
   1299        1.1   mycroft /*
   1300        1.1   mycroft  * Go through the disk queues to initiate sandbagged IO;
   1301        1.1   mycroft  * go through the inodes to write those that have been modified;
   1302        1.1   mycroft  * initiate the writing of the super block if it has been modified.
   1303        1.1   mycroft  *
   1304        1.1   mycroft  * Note: we are always called with the filesystem marked `MPBUSY'.
   1305        1.1   mycroft  */
   1306        1.1   mycroft int
   1307      1.181      elad ffs_sync(struct mount *mp, int waitfor, kauth_cred_t cred, struct lwp *l)
   1308        1.1   mycroft {
   1309      1.189   reinoud 	struct vnode *vp, *nvp;
   1310       1.33      fvdl 	struct inode *ip;
   1311       1.33      fvdl 	struct ufsmount *ump = VFSTOUFS(mp);
   1312       1.33      fvdl 	struct fs *fs;
   1313      1.132   hannken 	int error, count, allerror = 0;
   1314        1.1   mycroft 
   1315        1.1   mycroft 	fs = ump->um_fs;
   1316       1.33      fvdl 	if (fs->fs_fmod != 0 && fs->fs_ronly != 0) {		/* XXX */
   1317       1.33      fvdl 		printf("fs = %s\n", fs->fs_fsmnt);
   1318       1.33      fvdl 		panic("update: rofs mod");
   1319        1.1   mycroft 	}
   1320      1.194   hannken 	if ((error = fstrans_start(mp, FSTRANS_SHARED)) != 0)
   1321      1.193   hannken 		return error;
   1322        1.1   mycroft 	/*
   1323        1.1   mycroft 	 * Write back each (modified) inode.
   1324        1.1   mycroft 	 */
   1325  1.196.6.2        ad 	mutex_enter(&mntvnode_lock);
   1326        1.1   mycroft loop:
   1327      1.189   reinoud 	/*
   1328      1.189   reinoud 	 * NOTE: not using the TAILQ_FOREACH here since in this loop vgone()
   1329      1.189   reinoud 	 * and vclean() can be called indirectly
   1330      1.189   reinoud 	 */
   1331      1.189   reinoud 	for (vp = TAILQ_FIRST(&mp->mnt_vnodelist); vp; vp = nvp) {
   1332        1.1   mycroft 		/*
   1333        1.1   mycroft 		 * If the vnode that we are about to sync is no longer
   1334        1.1   mycroft 		 * associated with this mount point, start over.
   1335        1.1   mycroft 		 */
   1336        1.1   mycroft 		if (vp->v_mount != mp)
   1337        1.1   mycroft 			goto loop;
   1338  1.196.6.2        ad 		mutex_enter(&vp->v_interlock);
   1339      1.189   reinoud 		nvp = TAILQ_NEXT(vp, v_mntvnodes);
   1340        1.1   mycroft 		ip = VTOI(vp);
   1341  1.196.6.5        ad 		if ((vp->v_flag & VFREEING) != 0 || vp->v_type == VNON ||
   1342       1.57      fvdl 		    ((ip->i_flag &
   1343      1.152   mycroft 		      (IN_CHANGE | IN_UPDATE | IN_MODIFIED)) == 0 &&
   1344       1.75       chs 		     LIST_EMPTY(&vp->v_dirtyblkhd) &&
   1345       1.87       chs 		     vp->v_uobj.uo_npages == 0))
   1346       1.57      fvdl 		{
   1347  1.196.6.2        ad 			mutex_exit(&vp->v_interlock);
   1348       1.33      fvdl 			continue;
   1349       1.33      fvdl 		}
   1350      1.193   hannken 		if (vp->v_type == VBLK &&
   1351      1.194   hannken 		    fstrans_getstate(mp) == FSTRANS_SUSPENDING) {
   1352  1.196.6.2        ad 			mutex_exit(&vp->v_interlock);
   1353      1.193   hannken 			continue;
   1354      1.193   hannken 		}
   1355  1.196.6.2        ad 		mutex_exit(&mntvnode_lock);
   1356      1.117   thorpej 		error = vget(vp, LK_EXCLUSIVE | LK_NOWAIT | LK_INTERLOCK);
   1357       1.33      fvdl 		if (error) {
   1358  1.196.6.2        ad 			mutex_enter(&mntvnode_lock);
   1359       1.33      fvdl 			if (error == ENOENT)
   1360       1.33      fvdl 				goto loop;
   1361        1.1   mycroft 			continue;
   1362       1.33      fvdl 		}
   1363      1.152   mycroft 		if (vp->v_type == VREG && waitfor == MNT_LAZY)
   1364      1.176      yamt 			error = ffs_update(vp, NULL, NULL, 0);
   1365      1.152   mycroft 		else
   1366      1.152   mycroft 			error = VOP_FSYNC(vp, cred,
   1367      1.177  christos 			    waitfor == MNT_WAIT ? FSYNC_WAIT : 0, 0, 0, l);
   1368      1.152   mycroft 		if (error)
   1369        1.1   mycroft 			allerror = error;
   1370        1.1   mycroft 		vput(vp);
   1371  1.196.6.2        ad 		mutex_enter(&mntvnode_lock);
   1372        1.1   mycroft 	}
   1373  1.196.6.2        ad 	mutex_exit(&mntvnode_lock);
   1374        1.1   mycroft 	/*
   1375        1.1   mycroft 	 * Force stale file system control information to be flushed.
   1376        1.1   mycroft 	 */
   1377      1.132   hannken 	if (waitfor == MNT_WAIT && (ump->um_mountp->mnt_flag & MNT_SOFTDEP)) {
   1378      1.177  christos 		if ((error = softdep_flushworklist(ump->um_mountp, &count, l)))
   1379      1.132   hannken 			allerror = error;
   1380      1.132   hannken 		/* Flushed work items may create new vnodes to clean */
   1381      1.132   hannken 		if (allerror == 0 && count) {
   1382  1.196.6.2        ad 			mutex_enter(&mntvnode_lock);
   1383      1.132   hannken 			goto loop;
   1384      1.132   hannken 		}
   1385      1.132   hannken 	}
   1386      1.132   hannken 	if (waitfor != MNT_LAZY && (ump->um_devvp->v_numoutput > 0 ||
   1387      1.132   hannken 	    !LIST_EMPTY(&ump->um_devvp->v_dirtyblkhd))) {
   1388       1.55      fvdl 		vn_lock(ump->um_devvp, LK_EXCLUSIVE | LK_RETRY);
   1389       1.55      fvdl 		if ((error = VOP_FSYNC(ump->um_devvp, cred,
   1390      1.177  christos 		    waitfor == MNT_WAIT ? FSYNC_WAIT : 0, 0, 0, l)) != 0)
   1391       1.55      fvdl 			allerror = error;
   1392       1.55      fvdl 		VOP_UNLOCK(ump->um_devvp, 0);
   1393      1.132   hannken 		if (allerror == 0 && waitfor == MNT_WAIT) {
   1394  1.196.6.2        ad 			mutex_enter(&mntvnode_lock);
   1395      1.132   hannken 			goto loop;
   1396      1.132   hannken 		}
   1397       1.55      fvdl 	}
   1398        1.1   mycroft #ifdef QUOTA
   1399      1.118      fvdl 	qsync(mp);
   1400        1.1   mycroft #endif
   1401       1.33      fvdl 	/*
   1402       1.33      fvdl 	 * Write back modified superblock.
   1403       1.33      fvdl 	 */
   1404       1.33      fvdl 	if (fs->fs_fmod != 0) {
   1405       1.33      fvdl 		fs->fs_fmod = 0;
   1406      1.182    kardel 		fs->fs_time = time_second;
   1407       1.64   mycroft 		if ((error = ffs_cgupdate(ump, waitfor)))
   1408       1.64   mycroft 			allerror = error;
   1409       1.33      fvdl 	}
   1410      1.193   hannken 	fstrans_done(mp);
   1411        1.1   mycroft 	return (allerror);
   1412        1.1   mycroft }
   1413        1.1   mycroft 
   1414        1.1   mycroft /*
   1415        1.1   mycroft  * Look up a FFS dinode number to find its incore vnode, otherwise read it
   1416        1.1   mycroft  * in from disk.  If it is in core, wait for the lock bit to clear, then
   1417        1.1   mycroft  * return the inode locked.  Detection and handling of mount points must be
   1418        1.1   mycroft  * done by the calling routine.
   1419        1.1   mycroft  */
   1420        1.1   mycroft int
   1421      1.166   thorpej ffs_vget(struct mount *mp, ino_t ino, struct vnode **vpp)
   1422        1.1   mycroft {
   1423       1.33      fvdl 	struct fs *fs;
   1424       1.33      fvdl 	struct inode *ip;
   1425        1.1   mycroft 	struct ufsmount *ump;
   1426        1.1   mycroft 	struct buf *bp;
   1427        1.1   mycroft 	struct vnode *vp;
   1428        1.1   mycroft 	dev_t dev;
   1429       1.43   thorpej 	int error;
   1430        1.1   mycroft 
   1431        1.1   mycroft 	ump = VFSTOUFS(mp);
   1432        1.1   mycroft 	dev = ump->um_dev;
   1433       1.68      fvdl 
   1434      1.117   thorpej 	if ((*vpp = ufs_ihashget(dev, ino, LK_EXCLUSIVE)) != NULL)
   1435       1.68      fvdl 		return (0);
   1436        1.1   mycroft 
   1437        1.1   mycroft 	/* Allocate a new vnode/inode. */
   1438       1.19  christos 	if ((error = getnewvnode(VT_UFS, mp, ffs_vnodeop_p, &vp)) != 0) {
   1439        1.1   mycroft 		*vpp = NULL;
   1440        1.1   mycroft 		return (error);
   1441        1.1   mycroft 	}
   1442      1.195        ad 	ip = pool_get(&ffs_inode_pool, PR_WAITOK);
   1443       1.68      fvdl 
   1444       1.68      fvdl 	/*
   1445       1.68      fvdl 	 * If someone beat us to it while sleeping in getnewvnode(),
   1446       1.68      fvdl 	 * push back the freshly allocated vnode we don't need, and return.
   1447       1.68      fvdl 	 */
   1448      1.195        ad 	mutex_enter(&ufs_hashlock);
   1449      1.195        ad 	if ((*vpp = ufs_ihashget(dev, ino, LK_EXCLUSIVE)) != NULL) {
   1450      1.195        ad 		mutex_exit(&ufs_hashlock);
   1451      1.195        ad 		ungetnewvnode(vp);
   1452      1.195        ad 		pool_put(&ffs_inode_pool, ip);
   1453      1.195        ad 		return (0);
   1454      1.195        ad 	}
   1455       1.68      fvdl 
   1456      1.155   thorpej 	vp->v_flag |= VLOCKSWORK;
   1457      1.155   thorpej 
   1458       1.43   thorpej 	/*
   1459       1.43   thorpej 	 * XXX MFS ends up here, too, to allocate an inode.  Should we
   1460       1.43   thorpej 	 * XXX create another pool for MFS inodes?
   1461       1.43   thorpej 	 */
   1462       1.87       chs 
   1463       1.87       chs 	memset(ip, 0, sizeof(struct inode));
   1464        1.1   mycroft 	vp->v_data = ip;
   1465        1.1   mycroft 	ip->i_vnode = vp;
   1466      1.110      fvdl 	ip->i_ump = ump;
   1467        1.1   mycroft 	ip->i_fs = fs = ump->um_fs;
   1468        1.1   mycroft 	ip->i_dev = dev;
   1469        1.1   mycroft 	ip->i_number = ino;
   1470       1.77       chs 	LIST_INIT(&ip->i_pcbufhd);
   1471        1.1   mycroft #ifdef QUOTA
   1472       1.19  christos 	{
   1473       1.19  christos 		int i;
   1474       1.19  christos 
   1475       1.19  christos 		for (i = 0; i < MAXQUOTAS; i++)
   1476       1.19  christos 			ip->i_dquot[i] = NODQUOT;
   1477       1.19  christos 	}
   1478        1.1   mycroft #endif
   1479       1.86       chs 
   1480        1.1   mycroft 	/*
   1481        1.1   mycroft 	 * Put it onto its hash chain and lock it so that other requests for
   1482        1.1   mycroft 	 * this inode will block if they arrive while we are sleeping waiting
   1483        1.1   mycroft 	 * for old data structures to be purged or for the contents of the
   1484        1.1   mycroft 	 * disk portion of this inode to be read.
   1485        1.1   mycroft 	 */
   1486       1.87       chs 
   1487        1.1   mycroft 	ufs_ihashins(ip);
   1488      1.195        ad 	mutex_exit(&ufs_hashlock);
   1489        1.1   mycroft 
   1490        1.1   mycroft 	/* Read in the disk contents for the inode, copy into the inode. */
   1491       1.19  christos 	error = bread(ump->um_devvp, fsbtodb(fs, ino_to_fsba(fs, ino)),
   1492       1.19  christos 		      (int)fs->fs_bsize, NOCRED, &bp);
   1493       1.19  christos 	if (error) {
   1494       1.87       chs 
   1495        1.1   mycroft 		/*
   1496        1.1   mycroft 		 * The inode does not contain anything useful, so it would
   1497        1.1   mycroft 		 * be misleading to leave it on its hash chain. With mode
   1498        1.1   mycroft 		 * still zero, it will be unlinked and returned to the free
   1499        1.1   mycroft 		 * list by vput().
   1500        1.1   mycroft 		 */
   1501       1.87       chs 
   1502        1.1   mycroft 		vput(vp);
   1503        1.1   mycroft 		brelse(bp);
   1504        1.1   mycroft 		*vpp = NULL;
   1505        1.1   mycroft 		return (error);
   1506        1.1   mycroft 	}
   1507      1.110      fvdl 	if (ip->i_ump->um_fstype == UFS1)
   1508      1.110      fvdl 		ip->i_din.ffs1_din = pool_get(&ffs_dinode1_pool, PR_WAITOK);
   1509      1.110      fvdl 	else
   1510      1.110      fvdl 		ip->i_din.ffs2_din = pool_get(&ffs_dinode2_pool, PR_WAITOK);
   1511      1.110      fvdl 	ffs_load_inode(bp, ip, fs, ino);
   1512       1.55      fvdl 	if (DOINGSOFTDEP(vp))
   1513       1.55      fvdl 		softdep_load_inodeblock(ip);
   1514       1.55      fvdl 	else
   1515      1.110      fvdl 		ip->i_ffs_effnlink = ip->i_nlink;
   1516        1.1   mycroft 	brelse(bp);
   1517        1.1   mycroft 
   1518        1.1   mycroft 	/*
   1519        1.1   mycroft 	 * Initialize the vnode from the inode, check for aliases.
   1520        1.1   mycroft 	 * Note that the underlying vnode may have changed.
   1521        1.1   mycroft 	 */
   1522       1.87       chs 
   1523       1.87       chs 	ufs_vinit(mp, ffs_specop_p, ffs_fifoop_p, &vp);
   1524       1.87       chs 
   1525        1.1   mycroft 	/*
   1526        1.1   mycroft 	 * Finish inode initialization now that aliasing has been resolved.
   1527        1.1   mycroft 	 */
   1528       1.87       chs 
   1529       1.87       chs 	genfs_node_init(vp, &ffs_genfsops);
   1530        1.1   mycroft 	ip->i_devvp = ump->um_devvp;
   1531        1.1   mycroft 	VREF(ip->i_devvp);
   1532       1.87       chs 
   1533        1.1   mycroft 	/*
   1534        1.1   mycroft 	 * Ensure that uid and gid are correct. This is a temporary
   1535        1.1   mycroft 	 * fix until fsck has been changed to do the update.
   1536        1.1   mycroft 	 */
   1537       1.87       chs 
   1538      1.110      fvdl 	if (fs->fs_old_inodefmt < FS_44INODEFMT) {		/* XXX */
   1539      1.110      fvdl 		ip->i_uid = ip->i_ffs1_ouid;			/* XXX */
   1540      1.110      fvdl 		ip->i_gid = ip->i_ffs1_ogid;			/* XXX */
   1541       1.38    kleink 	}							/* XXX */
   1542      1.110      fvdl 	uvm_vnp_setsize(vp, ip->i_size);
   1543        1.1   mycroft 	*vpp = vp;
   1544        1.1   mycroft 	return (0);
   1545        1.1   mycroft }
   1546        1.1   mycroft 
   1547        1.1   mycroft /*
   1548        1.1   mycroft  * File handle to vnode
   1549        1.1   mycroft  *
   1550        1.1   mycroft  * Have to be really careful about stale file handles:
   1551        1.1   mycroft  * - check that the inode number is valid
   1552        1.1   mycroft  * - call ffs_vget() to get the locked inode
   1553        1.1   mycroft  * - check for an unallocated inode (i_mode == 0)
   1554        1.1   mycroft  * - check that the given client host has export rights and return
   1555        1.1   mycroft  *   those rights via. exflagsp and credanonp
   1556        1.1   mycroft  */
   1557        1.1   mycroft int
   1558      1.166   thorpej ffs_fhtovp(struct mount *mp, struct fid *fhp, struct vnode **vpp)
   1559        1.1   mycroft {
   1560      1.183    martin 	struct ufid ufh;
   1561        1.1   mycroft 	struct fs *fs;
   1562        1.1   mycroft 
   1563      1.183    martin 	if (fhp->fid_len != sizeof(struct ufid))
   1564      1.183    martin 		return EINVAL;
   1565      1.183    martin 
   1566      1.183    martin 	memcpy(&ufh, fhp, sizeof(ufh));
   1567        1.1   mycroft 	fs = VFSTOUFS(mp)->um_fs;
   1568      1.183    martin 	if (ufh.ufid_ino < ROOTINO ||
   1569      1.183    martin 	    ufh.ufid_ino >= fs->fs_ncg * fs->fs_ipg)
   1570        1.1   mycroft 		return (ESTALE);
   1571      1.183    martin 	return (ufs_fhtovp(mp, &ufh, vpp));
   1572        1.1   mycroft }
   1573        1.1   mycroft 
   1574        1.1   mycroft /*
   1575        1.1   mycroft  * Vnode pointer to File handle
   1576        1.1   mycroft  */
   1577        1.1   mycroft /* ARGSUSED */
   1578       1.19  christos int
   1579      1.183    martin ffs_vptofh(struct vnode *vp, struct fid *fhp, size_t *fh_size)
   1580        1.1   mycroft {
   1581       1.61  augustss 	struct inode *ip;
   1582      1.183    martin 	struct ufid ufh;
   1583        1.1   mycroft 
   1584      1.183    martin 	if (*fh_size < sizeof(struct ufid)) {
   1585      1.183    martin 		*fh_size = sizeof(struct ufid);
   1586      1.183    martin 		return E2BIG;
   1587      1.183    martin 	}
   1588        1.1   mycroft 	ip = VTOI(vp);
   1589      1.183    martin 	*fh_size = sizeof(struct ufid);
   1590      1.183    martin 	memset(&ufh, 0, sizeof(ufh));
   1591      1.183    martin 	ufh.ufid_len = sizeof(struct ufid);
   1592      1.183    martin 	ufh.ufid_ino = ip->i_number;
   1593      1.183    martin 	ufh.ufid_gen = ip->i_gen;
   1594      1.183    martin 	memcpy(fhp, &ufh, sizeof(ufh));
   1595        1.1   mycroft 	return (0);
   1596       1.33      fvdl }
   1597       1.33      fvdl 
   1598       1.33      fvdl void
   1599      1.166   thorpej ffs_init(void)
   1600       1.33      fvdl {
   1601       1.59  jdolecek 	if (ffs_initcount++ > 0)
   1602       1.59  jdolecek 		return;
   1603       1.59  jdolecek 
   1604      1.147    atatat #ifdef _LKM
   1605      1.147    atatat 	pool_init(&ffs_inode_pool, sizeof(struct inode), 0, 0, 0,
   1606  1.196.6.1        ad 		  "ffsinopl", &pool_allocator_nointr, IPL_NONE);
   1607      1.161     perry 	pool_init(&ffs_dinode1_pool, sizeof(struct ufs1_dinode), 0, 0, 0,
   1608  1.196.6.1        ad 		  "dino1pl", &pool_allocator_nointr, IPL_NONE);
   1609      1.147    atatat 	pool_init(&ffs_dinode2_pool, sizeof(struct ufs2_dinode), 0, 0, 0,
   1610  1.196.6.1        ad 		  "dino2pl", &pool_allocator_nointr, IPL_NONE);
   1611      1.147    atatat #endif
   1612       1.55      fvdl 	softdep_initialize();
   1613       1.33      fvdl 	ufs_init();
   1614       1.86       chs }
   1615       1.86       chs 
   1616       1.86       chs void
   1617      1.166   thorpej ffs_reinit(void)
   1618       1.86       chs {
   1619       1.86       chs 	softdep_reinitialize();
   1620       1.86       chs 	ufs_reinit();
   1621       1.59  jdolecek }
   1622       1.59  jdolecek 
   1623       1.59  jdolecek void
   1624      1.166   thorpej ffs_done(void)
   1625       1.59  jdolecek {
   1626       1.59  jdolecek 	if (--ffs_initcount > 0)
   1627       1.59  jdolecek 		return;
   1628       1.59  jdolecek 
   1629       1.59  jdolecek 	/* XXX softdep cleanup ? */
   1630       1.59  jdolecek 	ufs_done();
   1631      1.147    atatat #ifdef _LKM
   1632      1.147    atatat 	pool_destroy(&ffs_dinode2_pool);
   1633      1.147    atatat 	pool_destroy(&ffs_dinode1_pool);
   1634       1.59  jdolecek 	pool_destroy(&ffs_inode_pool);
   1635      1.147    atatat #endif
   1636       1.33      fvdl }
   1637       1.33      fvdl 
   1638      1.130    atatat SYSCTL_SETUP(sysctl_vfs_ffs_setup, "sysctl vfs.ffs subtree setup")
   1639       1.33      fvdl {
   1640      1.176      yamt #if 0
   1641       1.87       chs 	extern int doasyncfree;
   1642      1.176      yamt #endif
   1643       1.62  jdolecek 	extern int ffs_log_changeopt;
   1644       1.33      fvdl 
   1645      1.139    atatat 	sysctl_createv(clog, 0, NULL, NULL,
   1646      1.139    atatat 		       CTLFLAG_PERMANENT,
   1647      1.130    atatat 		       CTLTYPE_NODE, "vfs", NULL,
   1648      1.130    atatat 		       NULL, 0, NULL, 0,
   1649      1.130    atatat 		       CTL_VFS, CTL_EOL);
   1650      1.139    atatat 	sysctl_createv(clog, 0, NULL, NULL,
   1651      1.139    atatat 		       CTLFLAG_PERMANENT,
   1652      1.148    atatat 		       CTLTYPE_NODE, "ffs",
   1653      1.148    atatat 		       SYSCTL_DESCR("Berkeley Fast File System"),
   1654      1.130    atatat 		       NULL, 0, NULL, 0,
   1655      1.130    atatat 		       CTL_VFS, 1, CTL_EOL);
   1656      1.130    atatat 
   1657      1.130    atatat 	/*
   1658      1.130    atatat 	 * @@@ should we even bother with these first three?
   1659      1.130    atatat 	 */
   1660      1.139    atatat 	sysctl_createv(clog, 0, NULL, NULL,
   1661      1.156  jdolecek 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
   1662      1.130    atatat 		       CTLTYPE_INT, "doclusterread", NULL,
   1663      1.130    atatat 		       sysctl_notavail, 0, NULL, 0,
   1664      1.130    atatat 		       CTL_VFS, 1, FFS_CLUSTERREAD, CTL_EOL);
   1665      1.139    atatat 	sysctl_createv(clog, 0, NULL, NULL,
   1666      1.156  jdolecek 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
   1667      1.130    atatat 		       CTLTYPE_INT, "doclusterwrite", NULL,
   1668      1.130    atatat 		       sysctl_notavail, 0, NULL, 0,
   1669      1.130    atatat 		       CTL_VFS, 1, FFS_CLUSTERWRITE, CTL_EOL);
   1670      1.139    atatat 	sysctl_createv(clog, 0, NULL, NULL,
   1671      1.156  jdolecek 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
   1672      1.130    atatat 		       CTLTYPE_INT, "doreallocblks", NULL,
   1673      1.130    atatat 		       sysctl_notavail, 0, NULL, 0,
   1674      1.130    atatat 		       CTL_VFS, 1, FFS_REALLOCBLKS, CTL_EOL);
   1675      1.176      yamt #if 0
   1676      1.139    atatat 	sysctl_createv(clog, 0, NULL, NULL,
   1677      1.156  jdolecek 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
   1678      1.148    atatat 		       CTLTYPE_INT, "doasyncfree",
   1679      1.148    atatat 		       SYSCTL_DESCR("Release dirty blocks asynchronously"),
   1680      1.130    atatat 		       NULL, 0, &doasyncfree, 0,
   1681      1.130    atatat 		       CTL_VFS, 1, FFS_ASYNCFREE, CTL_EOL);
   1682      1.176      yamt #endif
   1683      1.139    atatat 	sysctl_createv(clog, 0, NULL, NULL,
   1684      1.156  jdolecek 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
   1685      1.148    atatat 		       CTLTYPE_INT, "log_changeopt",
   1686      1.148    atatat 		       SYSCTL_DESCR("Log changes in optimization strategy"),
   1687      1.130    atatat 		       NULL, 0, &ffs_log_changeopt, 0,
   1688      1.130    atatat 		       CTL_VFS, 1, FFS_LOG_CHANGEOPT, CTL_EOL);
   1689        1.1   mycroft }
   1690        1.1   mycroft 
   1691        1.1   mycroft /*
   1692        1.1   mycroft  * Write a superblock and associated information back to disk.
   1693        1.1   mycroft  */
   1694        1.1   mycroft int
   1695      1.166   thorpej ffs_sbupdate(struct ufsmount *mp, int waitfor)
   1696        1.1   mycroft {
   1697       1.61  augustss 	struct fs *fs = mp->um_fs;
   1698       1.61  augustss 	struct buf *bp;
   1699      1.110      fvdl 	int error = 0;
   1700      1.110      fvdl 	u_int32_t saveflag;
   1701       1.34    bouyer 
   1702      1.110      fvdl 	bp = getblk(mp->um_devvp,
   1703      1.110      fvdl 	    fs->fs_sblockloc >> (fs->fs_fshift - fs->fs_fsbtodb),
   1704       1.34    bouyer 	    (int)fs->fs_sbsize, 0, 0);
   1705       1.55      fvdl 	saveflag = fs->fs_flags & FS_INTERNAL;
   1706       1.55      fvdl 	fs->fs_flags &= ~FS_INTERNAL;
   1707      1.161     perry 
   1708       1.42     perry 	memcpy(bp->b_data, fs, fs->fs_sbsize);
   1709      1.110      fvdl 
   1710      1.110      fvdl 	ffs_oldfscompat_write((struct fs *)bp->b_data, mp);
   1711       1.34    bouyer #ifdef FFS_EI
   1712       1.34    bouyer 	if (mp->um_flags & UFS_NEEDSWAP)
   1713      1.123     enami 		ffs_sb_swap((struct fs *)bp->b_data, (struct fs *)bp->b_data);
   1714      1.111      fvdl #endif
   1715       1.55      fvdl 	fs->fs_flags |= saveflag;
   1716       1.34    bouyer 
   1717        1.1   mycroft 	if (waitfor == MNT_WAIT)
   1718        1.1   mycroft 		error = bwrite(bp);
   1719        1.1   mycroft 	else
   1720        1.1   mycroft 		bawrite(bp);
   1721       1.15   mycroft 	return (error);
   1722       1.15   mycroft }
   1723       1.15   mycroft 
   1724       1.15   mycroft int
   1725      1.166   thorpej ffs_cgupdate(struct ufsmount *mp, int waitfor)
   1726       1.15   mycroft {
   1727       1.61  augustss 	struct fs *fs = mp->um_fs;
   1728       1.61  augustss 	struct buf *bp;
   1729       1.15   mycroft 	int blks;
   1730       1.84     lukem 	void *space;
   1731       1.15   mycroft 	int i, size, error = 0, allerror = 0;
   1732       1.15   mycroft 
   1733       1.15   mycroft 	allerror = ffs_sbupdate(mp, waitfor);
   1734        1.1   mycroft 	blks = howmany(fs->fs_cssize, fs->fs_fsize);
   1735       1.84     lukem 	space = fs->fs_csp;
   1736        1.1   mycroft 	for (i = 0; i < blks; i += fs->fs_frag) {
   1737        1.1   mycroft 		size = fs->fs_bsize;
   1738        1.1   mycroft 		if (i + fs->fs_frag > blks)
   1739        1.1   mycroft 			size = (blks - i) * fs->fs_fsize;
   1740        1.1   mycroft 		bp = getblk(mp->um_devvp, fsbtodb(fs, fs->fs_csaddr + i),
   1741        1.1   mycroft 		    size, 0, 0);
   1742       1.34    bouyer #ifdef FFS_EI
   1743       1.34    bouyer 		if (mp->um_flags & UFS_NEEDSWAP)
   1744       1.34    bouyer 			ffs_csum_swap((struct csum*)space,
   1745       1.38    kleink 			    (struct csum*)bp->b_data, size);
   1746       1.34    bouyer 		else
   1747       1.34    bouyer #endif
   1748       1.42     perry 			memcpy(bp->b_data, space, (u_int)size);
   1749       1.84     lukem 		space = (char *)space + size;
   1750        1.1   mycroft 		if (waitfor == MNT_WAIT)
   1751        1.1   mycroft 			error = bwrite(bp);
   1752        1.1   mycroft 		else
   1753        1.1   mycroft 			bawrite(bp);
   1754        1.1   mycroft 	}
   1755       1.15   mycroft 	if (!allerror && error)
   1756       1.15   mycroft 		allerror = error;
   1757       1.15   mycroft 	return (allerror);
   1758        1.1   mycroft }
   1759      1.170   thorpej 
   1760      1.170   thorpej int
   1761      1.170   thorpej ffs_extattrctl(struct mount *mp, int cmd, struct vnode *vp,
   1762      1.177  christos     int attrnamespace, const char *attrname, struct lwp *l)
   1763      1.170   thorpej {
   1764      1.170   thorpej #ifdef UFS_EXTATTR
   1765      1.170   thorpej 	/*
   1766      1.170   thorpej 	 * File-backed extended attributes are only supported on UFS1.
   1767      1.170   thorpej 	 * UFS2 has native extended attributes.
   1768      1.170   thorpej 	 */
   1769      1.170   thorpej 	if (VFSTOUFS(mp)->um_fstype == UFS1)
   1770      1.170   thorpej 		return (ufs_extattrctl(mp, cmd, vp, attrnamespace, attrname,
   1771      1.177  christos 				       l));
   1772      1.170   thorpej #endif
   1773      1.177  christos 	return (vfs_stdextattrctl(mp, cmd, vp, attrnamespace, attrname, l));
   1774      1.170   thorpej }
   1775      1.193   hannken 
   1776      1.193   hannken int
   1777      1.193   hannken ffs_suspendctl(struct mount *mp, int cmd)
   1778      1.193   hannken {
   1779      1.193   hannken 	int error;
   1780      1.193   hannken 	struct lwp *l = curlwp;
   1781      1.193   hannken 
   1782      1.193   hannken 	switch (cmd) {
   1783      1.193   hannken 	case SUSPEND_SUSPEND:
   1784      1.194   hannken 		if ((error = fstrans_setstate(mp, FSTRANS_SUSPENDING)) != 0)
   1785      1.193   hannken 			return error;
   1786      1.193   hannken 		error = ffs_sync(mp, MNT_WAIT, l->l_proc->p_cred, l);
   1787      1.193   hannken 		if (error == 0)
   1788      1.194   hannken 			error = fstrans_setstate(mp, FSTRANS_SUSPENDED);
   1789      1.193   hannken 		if (error != 0) {
   1790      1.194   hannken 			(void) fstrans_setstate(mp, FSTRANS_NORMAL);
   1791      1.193   hannken 			return error;
   1792      1.193   hannken 		}
   1793      1.193   hannken 		return 0;
   1794      1.193   hannken 
   1795      1.193   hannken 	case SUSPEND_RESUME:
   1796      1.194   hannken 		return fstrans_setstate(mp, FSTRANS_NORMAL);
   1797      1.193   hannken 
   1798      1.193   hannken 	default:
   1799      1.193   hannken 		return EINVAL;
   1800      1.193   hannken 	}
   1801      1.193   hannken }
   1802