Home | History | Annotate | Line # | Download | only in ffs
ffs_vfsops.c revision 1.80.2.6
      1  1.80.2.6   nathanw /*	$NetBSD: ffs_vfsops.c,v 1.80.2.6 2002/01/08 00:34:48 nathanw 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.1   mycroft  * 3. All advertising materials mentioning features or use of this software
     16       1.1   mycroft  *    must display the following acknowledgement:
     17       1.1   mycroft  *	This product includes software developed by the University of
     18       1.1   mycroft  *	California, Berkeley and its contributors.
     19       1.1   mycroft  * 4. Neither the name of the University nor the names of its contributors
     20       1.1   mycroft  *    may be used to endorse or promote products derived from this software
     21       1.1   mycroft  *    without specific prior written permission.
     22       1.1   mycroft  *
     23       1.1   mycroft  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     24       1.1   mycroft  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     25       1.1   mycroft  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     26       1.1   mycroft  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     27       1.1   mycroft  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     28       1.1   mycroft  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     29       1.1   mycroft  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     30       1.1   mycroft  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     31       1.1   mycroft  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     32       1.1   mycroft  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     33       1.1   mycroft  * SUCH DAMAGE.
     34       1.1   mycroft  *
     35      1.33      fvdl  *	@(#)ffs_vfsops.c	8.31 (Berkeley) 5/20/95
     36       1.1   mycroft  */
     37  1.80.2.5   nathanw 
     38  1.80.2.5   nathanw #include <sys/cdefs.h>
     39  1.80.2.6   nathanw __KERNEL_RCSID(0, "$NetBSD: ffs_vfsops.c,v 1.80.2.6 2002/01/08 00:34:48 nathanw Exp $");
     40      1.36    scottr 
     41  1.80.2.2   nathanw #if defined(_KERNEL_OPT)
     42      1.45   thorpej #include "opt_ffs.h"
     43      1.36    scottr #include "opt_quota.h"
     44      1.41  jonathan #include "opt_compat_netbsd.h"
     45      1.66      matt #include "opt_softdep.h"
     46      1.37    scottr #endif
     47       1.1   mycroft 
     48       1.1   mycroft #include <sys/param.h>
     49       1.1   mycroft #include <sys/systm.h>
     50       1.1   mycroft #include <sys/namei.h>
     51  1.80.2.1   nathanw #include <sys/lwp.h>
     52       1.1   mycroft #include <sys/proc.h>
     53       1.1   mycroft #include <sys/kernel.h>
     54       1.1   mycroft #include <sys/vnode.h>
     55       1.1   mycroft #include <sys/socket.h>
     56       1.1   mycroft #include <sys/mount.h>
     57       1.1   mycroft #include <sys/buf.h>
     58      1.23   thorpej #include <sys/device.h>
     59       1.1   mycroft #include <sys/mbuf.h>
     60       1.1   mycroft #include <sys/file.h>
     61       1.1   mycroft #include <sys/disklabel.h>
     62       1.1   mycroft #include <sys/ioctl.h>
     63       1.1   mycroft #include <sys/errno.h>
     64       1.1   mycroft #include <sys/malloc.h>
     65      1.43   thorpej #include <sys/pool.h>
     66      1.29      fvdl #include <sys/lock.h>
     67      1.33      fvdl #include <sys/sysctl.h>
     68       1.1   mycroft 
     69       1.1   mycroft #include <miscfs/specfs/specdev.h>
     70       1.1   mycroft 
     71       1.1   mycroft #include <ufs/ufs/quota.h>
     72       1.1   mycroft #include <ufs/ufs/ufsmount.h>
     73       1.1   mycroft #include <ufs/ufs/inode.h>
     74      1.25    bouyer #include <ufs/ufs/dir.h>
     75       1.1   mycroft #include <ufs/ufs/ufs_extern.h>
     76      1.34    bouyer #include <ufs/ufs/ufs_bswap.h>
     77       1.1   mycroft 
     78       1.1   mycroft #include <ufs/ffs/fs.h>
     79       1.1   mycroft #include <ufs/ffs/ffs_extern.h>
     80       1.1   mycroft 
     81      1.59  jdolecek /* how many times ffs_init() was called */
     82      1.59  jdolecek int ffs_initcount = 0;
     83      1.59  jdolecek 
     84      1.29      fvdl extern struct lock ufs_hashlock;
     85      1.29      fvdl 
     86      1.32   thorpej extern struct vnodeopv_desc ffs_vnodeop_opv_desc;
     87      1.32   thorpej extern struct vnodeopv_desc ffs_specop_opv_desc;
     88      1.32   thorpej extern struct vnodeopv_desc ffs_fifoop_opv_desc;
     89      1.32   thorpej 
     90      1.79  jdolecek const struct vnodeopv_desc * const ffs_vnodeopv_descs[] = {
     91      1.32   thorpej 	&ffs_vnodeop_opv_desc,
     92      1.32   thorpej 	&ffs_specop_opv_desc,
     93      1.32   thorpej 	&ffs_fifoop_opv_desc,
     94      1.32   thorpej 	NULL,
     95      1.32   thorpej };
     96      1.32   thorpej 
     97      1.17   mycroft struct vfsops ffs_vfsops = {
     98      1.17   mycroft 	MOUNT_FFS,
     99       1.1   mycroft 	ffs_mount,
    100       1.1   mycroft 	ufs_start,
    101       1.1   mycroft 	ffs_unmount,
    102       1.1   mycroft 	ufs_root,
    103       1.1   mycroft 	ufs_quotactl,
    104       1.1   mycroft 	ffs_statfs,
    105       1.1   mycroft 	ffs_sync,
    106       1.1   mycroft 	ffs_vget,
    107       1.1   mycroft 	ffs_fhtovp,
    108       1.1   mycroft 	ffs_vptofh,
    109       1.1   mycroft 	ffs_init,
    110  1.80.2.4   nathanw 	ffs_reinit,
    111      1.59  jdolecek 	ffs_done,
    112      1.33      fvdl 	ffs_sysctl,
    113      1.23   thorpej 	ffs_mountroot,
    114      1.48  wrstuden 	ufs_check_export,
    115      1.32   thorpej 	ffs_vnodeopv_descs,
    116       1.1   mycroft };
    117       1.1   mycroft 
    118  1.80.2.4   nathanw struct genfs_ops ffs_genfsops = {
    119  1.80.2.4   nathanw 	ffs_gop_size,
    120  1.80.2.4   nathanw 	ffs_gop_alloc,
    121  1.80.2.4   nathanw 	genfs_gop_write,
    122  1.80.2.4   nathanw };
    123  1.80.2.4   nathanw 
    124      1.43   thorpej struct pool ffs_inode_pool;
    125      1.43   thorpej 
    126       1.1   mycroft /*
    127      1.33      fvdl  * Called by main() when ffs is going to be mounted as root.
    128       1.1   mycroft  */
    129       1.1   mycroft 
    130      1.19  christos int
    131       1.1   mycroft ffs_mountroot()
    132       1.1   mycroft {
    133      1.33      fvdl 	struct fs *fs;
    134      1.33      fvdl 	struct mount *mp;
    135  1.80.2.1   nathanw 	struct proc *p = curproc->l_proc;	/* XXX */
    136       1.1   mycroft 	struct ufsmount *ump;
    137       1.1   mycroft 	int error;
    138      1.23   thorpej 
    139      1.23   thorpej 	if (root_device->dv_class != DV_DISK)
    140      1.23   thorpej 		return (ENODEV);
    141      1.23   thorpej 
    142       1.1   mycroft 	/*
    143      1.26       mrg 	 * Get vnodes for rootdev.
    144       1.1   mycroft 	 */
    145      1.26       mrg 	if (bdevvp(rootdev, &rootvp))
    146       1.1   mycroft 		panic("ffs_mountroot: can't setup bdevvp's");
    147       1.1   mycroft 
    148      1.51  wrstuden 	if ((error = vfs_rootmountalloc(MOUNT_FFS, "root_device", &mp))) {
    149      1.51  wrstuden 		vrele(rootvp);
    150      1.33      fvdl 		return (error);
    151      1.51  wrstuden 	}
    152      1.19  christos 	if ((error = ffs_mountfs(rootvp, mp, p)) != 0) {
    153      1.33      fvdl 		mp->mnt_op->vfs_refcount--;
    154      1.33      fvdl 		vfs_unbusy(mp);
    155       1.1   mycroft 		free(mp, M_MOUNT);
    156      1.51  wrstuden 		vrele(rootvp);
    157       1.1   mycroft 		return (error);
    158       1.1   mycroft 	}
    159      1.33      fvdl 	simple_lock(&mountlist_slock);
    160      1.11   mycroft 	CIRCLEQ_INSERT_TAIL(&mountlist, mp, mnt_list);
    161      1.33      fvdl 	simple_unlock(&mountlist_slock);
    162       1.1   mycroft 	ump = VFSTOUFS(mp);
    163       1.1   mycroft 	fs = ump->um_fs;
    164      1.42     perry 	memset(fs->fs_fsmnt, 0, sizeof(fs->fs_fsmnt));
    165      1.33      fvdl 	(void)copystr(mp->mnt_stat.f_mntonname, fs->fs_fsmnt, MNAMELEN - 1, 0);
    166       1.1   mycroft 	(void)ffs_statfs(mp, &mp->mnt_stat, p);
    167      1.33      fvdl 	vfs_unbusy(mp);
    168       1.1   mycroft 	inittodr(fs->fs_time);
    169       1.1   mycroft 	return (0);
    170       1.1   mycroft }
    171       1.1   mycroft 
    172       1.1   mycroft /*
    173       1.1   mycroft  * VFS Operations.
    174       1.1   mycroft  *
    175       1.1   mycroft  * mount system call
    176       1.1   mycroft  */
    177       1.1   mycroft int
    178       1.1   mycroft ffs_mount(mp, path, data, ndp, p)
    179      1.61  augustss 	struct mount *mp;
    180      1.22       cgd 	const char *path;
    181      1.22       cgd 	void *data;
    182       1.1   mycroft 	struct nameidata *ndp;
    183       1.1   mycroft 	struct proc *p;
    184       1.1   mycroft {
    185       1.1   mycroft 	struct vnode *devvp;
    186       1.1   mycroft 	struct ufs_args args;
    187      1.19  christos 	struct ufsmount *ump = NULL;
    188      1.61  augustss 	struct fs *fs;
    189      1.14   mycroft 	size_t size;
    190       1.1   mycroft 	int error, flags;
    191       1.9   mycroft 	mode_t accessmode;
    192       1.1   mycroft 
    193      1.19  christos 	error = copyin(data, (caddr_t)&args, sizeof (struct ufs_args));
    194      1.19  christos 	if (error)
    195       1.1   mycroft 		return (error);
    196      1.66      matt 
    197      1.66      matt #if !defined(SOFTDEP)
    198      1.67  perseant 	mp->mnt_flag &= ~MNT_SOFTDEP;
    199      1.66      matt #endif
    200      1.66      matt 
    201       1.1   mycroft 	/*
    202       1.1   mycroft 	 * If updating, check whether changing from read-only to
    203       1.1   mycroft 	 * read/write; if there is no device name, that's all we do.
    204       1.1   mycroft 	 */
    205       1.1   mycroft 	if (mp->mnt_flag & MNT_UPDATE) {
    206       1.1   mycroft 		ump = VFSTOUFS(mp);
    207       1.1   mycroft 		fs = ump->um_fs;
    208       1.1   mycroft 		if (fs->fs_ronly == 0 && (mp->mnt_flag & MNT_RDONLY)) {
    209       1.1   mycroft 			flags = WRITECLOSE;
    210       1.1   mycroft 			if (mp->mnt_flag & MNT_FORCE)
    211       1.1   mycroft 				flags |= FORCECLOSE;
    212      1.55      fvdl 			if (mp->mnt_flag & MNT_SOFTDEP)
    213      1.55      fvdl 				error = softdep_flushfiles(mp, flags, p);
    214      1.55      fvdl 			else
    215      1.55      fvdl 				error = ffs_flushfiles(mp, flags, p);
    216  1.80.2.6   nathanw 			if (fs->fs_pendingblocks != 0 ||
    217  1.80.2.6   nathanw 			    fs->fs_pendinginodes != 0) {
    218  1.80.2.6   nathanw 				printf("%s: update error: blocks %d files %d\n",
    219  1.80.2.6   nathanw 				    fs->fs_fsmnt, fs->fs_pendingblocks,
    220  1.80.2.6   nathanw 				    fs->fs_pendinginodes);
    221  1.80.2.6   nathanw 				fs->fs_pendingblocks = 0;
    222  1.80.2.6   nathanw 				fs->fs_pendinginodes = 0;
    223  1.80.2.6   nathanw 			}
    224      1.15   mycroft 			if (error == 0 &&
    225      1.15   mycroft 			    ffs_cgupdate(ump, MNT_WAIT) == 0 &&
    226      1.15   mycroft 			    fs->fs_clean & FS_WASCLEAN) {
    227      1.65      fvdl 				if (mp->mnt_flag & MNT_SOFTDEP)
    228      1.65      fvdl 					fs->fs_flags &= ~FS_DOSOFTDEP;
    229      1.15   mycroft 				fs->fs_clean = FS_ISCLEAN;
    230      1.15   mycroft 				(void) ffs_sbupdate(ump, MNT_WAIT);
    231      1.15   mycroft 			}
    232      1.15   mycroft 			if (error)
    233      1.15   mycroft 				return (error);
    234      1.15   mycroft 			fs->fs_ronly = 1;
    235      1.78   mycroft 			fs->fs_fmod = 0;
    236       1.1   mycroft 		}
    237      1.65      fvdl 
    238      1.65      fvdl 		/*
    239      1.65      fvdl 		 * Flush soft dependencies if disabling it via an update
    240      1.65      fvdl 		 * mount. This may leave some items to be processed,
    241      1.65      fvdl 		 * so don't do this yet XXX.
    242      1.65      fvdl 		 */
    243      1.65      fvdl 		if ((fs->fs_flags & FS_DOSOFTDEP) &&
    244      1.65      fvdl 		    !(mp->mnt_flag & MNT_SOFTDEP) && fs->fs_ronly == 0) {
    245      1.65      fvdl #ifdef notyet
    246      1.65      fvdl 			flags = WRITECLOSE;
    247      1.65      fvdl 			if (mp->mnt_flag & MNT_FORCE)
    248      1.65      fvdl 				flags |= FORCECLOSE;
    249      1.65      fvdl 			error = softdep_flushfiles(mp, flags, p);
    250      1.65      fvdl 			if (error == 0 && ffs_cgupdate(ump, MNT_WAIT) == 0)
    251      1.65      fvdl 				fs->fs_flags &= ~FS_DOSOFTDEP;
    252      1.65      fvdl 				(void) ffs_sbupdate(ump, MNT_WAIT);
    253      1.66      matt #elif defined(SOFTDEP)
    254      1.65      fvdl 			mp->mnt_flag |= MNT_SOFTDEP;
    255      1.65      fvdl #endif
    256      1.65      fvdl 		}
    257      1.65      fvdl 
    258      1.65      fvdl 		/*
    259      1.65      fvdl 		 * When upgrading to a softdep mount, we must first flush
    260      1.65      fvdl 		 * all vnodes. (not done yet -- see above)
    261      1.65      fvdl 		 */
    262      1.65      fvdl 		if (!(fs->fs_flags & FS_DOSOFTDEP) &&
    263      1.65      fvdl 		    (mp->mnt_flag & MNT_SOFTDEP) && fs->fs_ronly == 0) {
    264      1.65      fvdl #ifdef notyet
    265      1.65      fvdl 			flags = WRITECLOSE;
    266      1.65      fvdl 			if (mp->mnt_flag & MNT_FORCE)
    267      1.65      fvdl 				flags |= FORCECLOSE;
    268      1.65      fvdl 			error = ffs_flushfiles(mp, flags, p);
    269      1.65      fvdl #else
    270      1.65      fvdl 			mp->mnt_flag &= ~MNT_SOFTDEP;
    271      1.65      fvdl #endif
    272      1.65      fvdl 		}
    273      1.65      fvdl 
    274      1.15   mycroft 		if (mp->mnt_flag & MNT_RELOAD) {
    275       1.1   mycroft 			error = ffs_reload(mp, ndp->ni_cnd.cn_cred, p);
    276      1.15   mycroft 			if (error)
    277      1.15   mycroft 				return (error);
    278      1.15   mycroft 		}
    279       1.9   mycroft 		if (fs->fs_ronly && (mp->mnt_flag & MNT_WANTRDWR)) {
    280       1.9   mycroft 			/*
    281       1.9   mycroft 			 * If upgrade to read-write by non-root, then verify
    282       1.9   mycroft 			 * that user has necessary permissions on the device.
    283       1.9   mycroft 			 */
    284      1.55      fvdl 			devvp = ump->um_devvp;
    285       1.9   mycroft 			if (p->p_ucred->cr_uid != 0) {
    286      1.33      fvdl 				vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
    287      1.19  christos 				error = VOP_ACCESS(devvp, VREAD | VWRITE,
    288      1.19  christos 						   p->p_ucred, p);
    289      1.33      fvdl 				VOP_UNLOCK(devvp, 0);
    290      1.33      fvdl 				if (error)
    291       1.9   mycroft 					return (error);
    292       1.9   mycroft 			}
    293       1.1   mycroft 			fs->fs_ronly = 0;
    294      1.15   mycroft 			fs->fs_clean <<= 1;
    295      1.15   mycroft 			fs->fs_fmod = 1;
    296      1.55      fvdl 			if ((fs->fs_flags & FS_DOSOFTDEP)) {
    297      1.55      fvdl 				error = softdep_mount(devvp, mp, fs,
    298      1.55      fvdl 				    p->p_ucred);
    299      1.55      fvdl 				if (error)
    300      1.55      fvdl 					return (error);
    301      1.65      fvdl 			}
    302       1.9   mycroft 		}
    303       1.1   mycroft 		if (args.fspec == 0) {
    304       1.1   mycroft 			/*
    305       1.1   mycroft 			 * Process export requests.
    306       1.1   mycroft 			 */
    307       1.1   mycroft 			return (vfs_export(mp, &ump->um_export, &args.export));
    308       1.1   mycroft 		}
    309      1.55      fvdl 		if ((mp->mnt_flag & (MNT_SOFTDEP | MNT_ASYNC)) ==
    310      1.55      fvdl 		    (MNT_SOFTDEP | MNT_ASYNC)) {
    311      1.55      fvdl 			printf("%s fs uses soft updates, ignoring async mode\n",
    312      1.55      fvdl 			    fs->fs_fsmnt);
    313      1.55      fvdl 			mp->mnt_flag &= ~MNT_ASYNC;
    314      1.55      fvdl 		}
    315       1.1   mycroft 	}
    316       1.1   mycroft 	/*
    317       1.1   mycroft 	 * Not an update, or updating the name: look up the name
    318       1.1   mycroft 	 * and verify that it refers to a sensible block device.
    319       1.1   mycroft 	 */
    320       1.1   mycroft 	NDINIT(ndp, LOOKUP, FOLLOW, UIO_USERSPACE, args.fspec, p);
    321      1.19  christos 	if ((error = namei(ndp)) != 0)
    322       1.1   mycroft 		return (error);
    323       1.1   mycroft 	devvp = ndp->ni_vp;
    324       1.1   mycroft 
    325       1.1   mycroft 	if (devvp->v_type != VBLK) {
    326       1.1   mycroft 		vrele(devvp);
    327       1.1   mycroft 		return (ENOTBLK);
    328       1.1   mycroft 	}
    329       1.1   mycroft 	if (major(devvp->v_rdev) >= nblkdev) {
    330       1.1   mycroft 		vrele(devvp);
    331       1.1   mycroft 		return (ENXIO);
    332       1.1   mycroft 	}
    333       1.9   mycroft 	/*
    334       1.9   mycroft 	 * If mount by non-root, then verify that user has necessary
    335       1.9   mycroft 	 * permissions on the device.
    336       1.9   mycroft 	 */
    337       1.9   mycroft 	if (p->p_ucred->cr_uid != 0) {
    338       1.9   mycroft 		accessmode = VREAD;
    339       1.9   mycroft 		if ((mp->mnt_flag & MNT_RDONLY) == 0)
    340       1.9   mycroft 			accessmode |= VWRITE;
    341      1.33      fvdl 		vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
    342      1.19  christos 		error = VOP_ACCESS(devvp, accessmode, p->p_ucred, p);
    343      1.33      fvdl 		VOP_UNLOCK(devvp, 0);
    344      1.19  christos 		if (error) {
    345      1.33      fvdl 			vrele(devvp);
    346       1.9   mycroft 			return (error);
    347       1.9   mycroft 		}
    348       1.9   mycroft 	}
    349      1.55      fvdl 	if ((mp->mnt_flag & MNT_UPDATE) == 0) {
    350       1.1   mycroft 		error = ffs_mountfs(devvp, mp, p);
    351      1.58      fvdl 		if (!error) {
    352      1.58      fvdl 			ump = VFSTOUFS(mp);
    353      1.58      fvdl 			fs = ump->um_fs;
    354      1.58      fvdl 			if ((mp->mnt_flag & (MNT_SOFTDEP | MNT_ASYNC)) ==
    355      1.58      fvdl 			    (MNT_SOFTDEP | MNT_ASYNC)) {
    356      1.58      fvdl 				printf("%s fs uses soft updates, "
    357      1.58      fvdl 				       "ignoring async mode\n",
    358      1.58      fvdl 				    fs->fs_fsmnt);
    359      1.58      fvdl 				mp->mnt_flag &= ~MNT_ASYNC;
    360      1.58      fvdl 			}
    361      1.55      fvdl 		}
    362      1.55      fvdl 	}
    363       1.1   mycroft 	else {
    364       1.1   mycroft 		if (devvp != ump->um_devvp)
    365       1.1   mycroft 			error = EINVAL;	/* needs translation */
    366       1.1   mycroft 		else
    367       1.1   mycroft 			vrele(devvp);
    368       1.1   mycroft 	}
    369       1.1   mycroft 	if (error) {
    370       1.1   mycroft 		vrele(devvp);
    371       1.1   mycroft 		return (error);
    372       1.1   mycroft 	}
    373       1.1   mycroft 	(void) copyinstr(path, fs->fs_fsmnt, sizeof(fs->fs_fsmnt) - 1, &size);
    374      1.42     perry 	memset(fs->fs_fsmnt + size, 0, sizeof(fs->fs_fsmnt) - size);
    375      1.42     perry 	memcpy(mp->mnt_stat.f_mntonname, fs->fs_fsmnt, MNAMELEN);
    376       1.1   mycroft 	(void) copyinstr(args.fspec, mp->mnt_stat.f_mntfromname, MNAMELEN - 1,
    377       1.1   mycroft 	    &size);
    378      1.42     perry 	memset(mp->mnt_stat.f_mntfromname + size, 0, MNAMELEN - size);
    379      1.65      fvdl 	if (mp->mnt_flag & MNT_SOFTDEP)
    380      1.65      fvdl 		fs->fs_flags |= FS_DOSOFTDEP;
    381      1.74      fvdl 	else
    382      1.74      fvdl 		fs->fs_flags &= ~FS_DOSOFTDEP;
    383      1.15   mycroft 	if (fs->fs_fmod != 0) {	/* XXX */
    384      1.15   mycroft 		fs->fs_fmod = 0;
    385      1.15   mycroft 		if (fs->fs_clean & FS_WASCLEAN)
    386      1.15   mycroft 			fs->fs_time = time.tv_sec;
    387  1.80.2.6   nathanw 		else {
    388  1.80.2.3   nathanw 			printf("%s: file system not clean (fs_clean=%x); please fsck(8)\n",
    389      1.34    bouyer 			    mp->mnt_stat.f_mntfromname, fs->fs_clean);
    390  1.80.2.6   nathanw 			printf("%s: lost blocks %d files %d\n",
    391  1.80.2.6   nathanw 			    mp->mnt_stat.f_mntfromname, fs->fs_pendingblocks,
    392  1.80.2.6   nathanw 			    fs->fs_pendinginodes);
    393  1.80.2.6   nathanw 		}
    394      1.15   mycroft 		(void) ffs_cgupdate(ump, MNT_WAIT);
    395      1.15   mycroft 	}
    396       1.1   mycroft 	return (0);
    397       1.1   mycroft }
    398       1.1   mycroft 
    399       1.1   mycroft /*
    400       1.1   mycroft  * Reload all incore data for a filesystem (used after running fsck on
    401       1.1   mycroft  * the root filesystem and finding things to fix). The filesystem must
    402       1.1   mycroft  * be mounted read-only.
    403       1.1   mycroft  *
    404       1.1   mycroft  * Things to do to update the mount:
    405       1.1   mycroft  *	1) invalidate all cached meta-data.
    406       1.1   mycroft  *	2) re-read superblock from disk.
    407       1.1   mycroft  *	3) re-read summary information from disk.
    408       1.1   mycroft  *	4) invalidate all inactive vnodes.
    409       1.1   mycroft  *	5) invalidate all cached file data.
    410       1.1   mycroft  *	6) re-read inode data for all active vnodes.
    411       1.1   mycroft  */
    412      1.19  christos int
    413       1.1   mycroft ffs_reload(mountp, cred, p)
    414      1.61  augustss 	struct mount *mountp;
    415       1.1   mycroft 	struct ucred *cred;
    416       1.1   mycroft 	struct proc *p;
    417       1.1   mycroft {
    418      1.61  augustss 	struct vnode *vp, *nvp, *devvp;
    419       1.1   mycroft 	struct inode *ip;
    420  1.80.2.4   nathanw 	void *space;
    421       1.1   mycroft 	struct buf *bp;
    422      1.18       cgd 	struct fs *fs, *newfs;
    423       1.1   mycroft 	struct partinfo dpart;
    424       1.1   mycroft 	int i, blks, size, error;
    425      1.18       cgd 	int32_t *lp;
    426      1.44   thorpej 	caddr_t cp;
    427       1.1   mycroft 
    428       1.1   mycroft 	if ((mountp->mnt_flag & MNT_RDONLY) == 0)
    429       1.1   mycroft 		return (EINVAL);
    430       1.1   mycroft 	/*
    431       1.1   mycroft 	 * Step 1: invalidate all cached meta-data.
    432       1.1   mycroft 	 */
    433       1.1   mycroft 	devvp = VFSTOUFS(mountp)->um_devvp;
    434      1.55      fvdl 	vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
    435      1.55      fvdl 	error = vinvalbuf(devvp, 0, cred, p, 0, 0);
    436      1.55      fvdl 	VOP_UNLOCK(devvp, 0);
    437      1.55      fvdl 	if (error)
    438       1.1   mycroft 		panic("ffs_reload: dirty1");
    439       1.1   mycroft 	/*
    440       1.1   mycroft 	 * Step 2: re-read superblock from disk.
    441       1.1   mycroft 	 */
    442       1.1   mycroft 	if (VOP_IOCTL(devvp, DIOCGPART, (caddr_t)&dpart, FREAD, NOCRED, p) != 0)
    443       1.1   mycroft 		size = DEV_BSIZE;
    444       1.1   mycroft 	else
    445       1.1   mycroft 		size = dpart.disklab->d_secsize;
    446      1.33      fvdl 	error = bread(devvp, (ufs_daddr_t)(SBOFF / size), SBSIZE, NOCRED, &bp);
    447      1.47    bouyer 	if (error) {
    448      1.47    bouyer 		brelse(bp);
    449       1.1   mycroft 		return (error);
    450      1.47    bouyer 	}
    451      1.34    bouyer 	fs = VFSTOUFS(mountp)->um_fs;
    452      1.34    bouyer 	newfs = malloc(fs->fs_sbsize, M_UFSMNT, M_WAITOK);
    453      1.42     perry 	memcpy(newfs, bp->b_data, fs->fs_sbsize);
    454      1.34    bouyer #ifdef FFS_EI
    455      1.55      fvdl 	if (VFSTOUFS(mountp)->um_flags & UFS_NEEDSWAP) {
    456  1.80.2.3   nathanw 		ffs_sb_swap((struct fs*)bp->b_data, newfs);
    457      1.55      fvdl 		fs->fs_flags |= FS_SWAPPED;
    458      1.55      fvdl 	}
    459      1.34    bouyer #endif
    460      1.18       cgd 	if (newfs->fs_magic != FS_MAGIC || newfs->fs_bsize > MAXBSIZE ||
    461      1.18       cgd 	    newfs->fs_bsize < sizeof(struct fs)) {
    462       1.1   mycroft 		brelse(bp);
    463      1.34    bouyer 		free(newfs, M_UFSMNT);
    464       1.1   mycroft 		return (EIO);		/* XXX needs translation */
    465       1.1   mycroft 	}
    466      1.18       cgd 	/*
    467      1.18       cgd 	 * Copy pointer fields back into superblock before copying in	XXX
    468      1.18       cgd 	 * new superblock. These should really be in the ufsmount.	XXX
    469      1.18       cgd 	 * Note that important parameters (eg fs_ncg) are unchanged.
    470      1.18       cgd 	 */
    471  1.80.2.4   nathanw 	newfs->fs_csp = fs->fs_csp;
    472      1.18       cgd 	newfs->fs_maxcluster = fs->fs_maxcluster;
    473  1.80.2.4   nathanw 	newfs->fs_contigdirs = fs->fs_contigdirs;
    474      1.76   mycroft 	newfs->fs_ronly = fs->fs_ronly;
    475      1.42     perry 	memcpy(fs, newfs, (u_int)fs->fs_sbsize);
    476       1.1   mycroft 	if (fs->fs_sbsize < SBSIZE)
    477       1.1   mycroft 		bp->b_flags |= B_INVAL;
    478       1.1   mycroft 	brelse(bp);
    479      1.34    bouyer 	free(newfs, M_UFSMNT);
    480       1.3   mycroft 	mountp->mnt_maxsymlinklen = fs->fs_maxsymlinklen;
    481       1.1   mycroft 	ffs_oldfscompat(fs);
    482  1.80.2.4   nathanw 		/* An old fsck may have zeroed these fields, so recheck them. */
    483  1.80.2.4   nathanw 	if (fs->fs_avgfilesize <= 0)
    484  1.80.2.4   nathanw 		fs->fs_avgfilesize = AVFILESIZ;
    485  1.80.2.4   nathanw 	if (fs->fs_avgfpdir <= 0)
    486  1.80.2.4   nathanw 		fs->fs_avgfpdir = AFPDIR;
    487  1.80.2.6   nathanw 	if (fs->fs_pendingblocks != 0 || fs->fs_pendinginodes != 0) {
    488  1.80.2.6   nathanw 		fs->fs_pendingblocks = 0;
    489  1.80.2.6   nathanw 		fs->fs_pendinginodes = 0;
    490  1.80.2.6   nathanw 	}
    491  1.80.2.4   nathanw 
    492      1.55      fvdl 	ffs_statfs(mountp, &mountp->mnt_stat, p);
    493       1.1   mycroft 	/*
    494       1.1   mycroft 	 * Step 3: re-read summary information from disk.
    495       1.1   mycroft 	 */
    496       1.1   mycroft 	blks = howmany(fs->fs_cssize, fs->fs_fsize);
    497  1.80.2.4   nathanw 	space = fs->fs_csp;
    498       1.1   mycroft 	for (i = 0; i < blks; i += fs->fs_frag) {
    499       1.1   mycroft 		size = fs->fs_bsize;
    500       1.1   mycroft 		if (i + fs->fs_frag > blks)
    501       1.1   mycroft 			size = (blks - i) * fs->fs_fsize;
    502      1.19  christos 		error = bread(devvp, fsbtodb(fs, fs->fs_csaddr + i), size,
    503      1.19  christos 			      NOCRED, &bp);
    504      1.47    bouyer 		if (error) {
    505      1.47    bouyer 			brelse(bp);
    506       1.1   mycroft 			return (error);
    507      1.47    bouyer 		}
    508      1.34    bouyer #ifdef FFS_EI
    509      1.55      fvdl 		if (UFS_FSNEEDSWAP(fs))
    510  1.80.2.4   nathanw 			ffs_csum_swap((struct csum *)bp->b_data,
    511  1.80.2.4   nathanw 			    (struct csum *)space, size);
    512      1.34    bouyer 		else
    513      1.34    bouyer #endif
    514  1.80.2.4   nathanw 			memcpy(space, bp->b_data, (size_t)size);
    515  1.80.2.4   nathanw 		space = (char *)space + size;
    516       1.1   mycroft 		brelse(bp);
    517       1.1   mycroft 	}
    518      1.55      fvdl 	if ((fs->fs_flags & FS_DOSOFTDEP))
    519      1.55      fvdl 		softdep_mount(devvp, mountp, fs, cred);
    520      1.18       cgd 	/*
    521      1.18       cgd 	 * We no longer know anything about clusters per cylinder group.
    522      1.18       cgd 	 */
    523      1.18       cgd 	if (fs->fs_contigsumsize > 0) {
    524      1.18       cgd 		lp = fs->fs_maxcluster;
    525      1.18       cgd 		for (i = 0; i < fs->fs_ncg; i++)
    526      1.18       cgd 			*lp++ = fs->fs_contigsumsize;
    527      1.18       cgd 	}
    528      1.18       cgd 
    529       1.1   mycroft loop:
    530      1.33      fvdl 	simple_lock(&mntvnode_slock);
    531       1.1   mycroft 	for (vp = mountp->mnt_vnodelist.lh_first; vp != NULL; vp = nvp) {
    532      1.33      fvdl 		if (vp->v_mount != mountp) {
    533      1.33      fvdl 			simple_unlock(&mntvnode_slock);
    534      1.33      fvdl 			goto loop;
    535      1.33      fvdl 		}
    536       1.1   mycroft 		nvp = vp->v_mntvnodes.le_next;
    537       1.1   mycroft 		/*
    538       1.1   mycroft 		 * Step 4: invalidate all inactive vnodes.
    539       1.1   mycroft 		 */
    540      1.33      fvdl 		if (vrecycle(vp, &mntvnode_slock, p))
    541      1.33      fvdl 			goto loop;
    542       1.1   mycroft 		/*
    543       1.1   mycroft 		 * Step 5: invalidate all cached file data.
    544       1.1   mycroft 		 */
    545      1.33      fvdl 		simple_lock(&vp->v_interlock);
    546      1.33      fvdl 		simple_unlock(&mntvnode_slock);
    547      1.33      fvdl 		if (vget(vp, LK_EXCLUSIVE | LK_INTERLOCK))
    548       1.1   mycroft 			goto loop;
    549       1.1   mycroft 		if (vinvalbuf(vp, 0, cred, p, 0, 0))
    550       1.1   mycroft 			panic("ffs_reload: dirty2");
    551       1.1   mycroft 		/*
    552       1.1   mycroft 		 * Step 6: re-read inode data for all active vnodes.
    553       1.1   mycroft 		 */
    554       1.1   mycroft 		ip = VTOI(vp);
    555      1.19  christos 		error = bread(devvp, fsbtodb(fs, ino_to_fsba(fs, ip->i_number)),
    556      1.19  christos 			      (int)fs->fs_bsize, NOCRED, &bp);
    557      1.19  christos 		if (error) {
    558      1.47    bouyer 			brelse(bp);
    559       1.1   mycroft 			vput(vp);
    560       1.1   mycroft 			return (error);
    561       1.1   mycroft 		}
    562      1.44   thorpej 		cp = (caddr_t)bp->b_data +
    563      1.44   thorpej 		    (ino_to_fsbo(fs, ip->i_number) * DINODE_SIZE);
    564      1.34    bouyer #ifdef FFS_EI
    565      1.55      fvdl 		if (UFS_FSNEEDSWAP(fs))
    566      1.44   thorpej 			ffs_dinode_swap((struct dinode *)cp,
    567      1.44   thorpej 			    &ip->i_din.ffs_din);
    568      1.34    bouyer 		else
    569      1.34    bouyer #endif
    570      1.44   thorpej 			memcpy(&ip->i_din.ffs_din, cp, DINODE_SIZE);
    571      1.55      fvdl 		ip->i_ffs_effnlink = ip->i_ffs_nlink;
    572       1.1   mycroft 		brelse(bp);
    573       1.1   mycroft 		vput(vp);
    574      1.33      fvdl 		simple_lock(&mntvnode_slock);
    575       1.1   mycroft 	}
    576      1.33      fvdl 	simple_unlock(&mntvnode_slock);
    577       1.1   mycroft 	return (0);
    578       1.1   mycroft }
    579       1.1   mycroft 
    580       1.1   mycroft /*
    581       1.1   mycroft  * Common code for mount and mountroot
    582       1.1   mycroft  */
    583       1.1   mycroft int
    584       1.1   mycroft ffs_mountfs(devvp, mp, p)
    585      1.61  augustss 	struct vnode *devvp;
    586       1.1   mycroft 	struct mount *mp;
    587       1.1   mycroft 	struct proc *p;
    588       1.1   mycroft {
    589      1.34    bouyer 	struct ufsmount *ump;
    590       1.1   mycroft 	struct buf *bp;
    591      1.34    bouyer 	struct fs *fs;
    592       1.9   mycroft 	dev_t dev;
    593       1.1   mycroft 	struct partinfo dpart;
    594  1.80.2.4   nathanw 	void *space;
    595       1.1   mycroft 	int blks;
    596      1.52  drochner 	int error, i, size, ronly;
    597      1.52  drochner #ifdef FFS_EI
    598      1.52  drochner 	int needswap;
    599      1.52  drochner #endif
    600       1.9   mycroft 	int32_t *lp;
    601       1.9   mycroft 	struct ucred *cred;
    602       1.9   mycroft 	u_int64_t maxfilesize;					/* XXX */
    603      1.34    bouyer 	u_int32_t sbsize;
    604       1.1   mycroft 
    605       1.9   mycroft 	dev = devvp->v_rdev;
    606       1.9   mycroft 	cred = p ? p->p_ucred : NOCRED;
    607       1.1   mycroft 	/*
    608       1.1   mycroft 	 * Disallow multiple mounts of the same device.
    609       1.1   mycroft 	 * Disallow mounting of a device that is currently in use
    610       1.1   mycroft 	 * (except for root, which might share swap device for miniroot).
    611       1.1   mycroft 	 * Flush out any old buffers remaining from a previous use.
    612       1.1   mycroft 	 */
    613      1.19  christos 	if ((error = vfs_mountedon(devvp)) != 0)
    614       1.1   mycroft 		return (error);
    615       1.1   mycroft 	if (vcount(devvp) > 1 && devvp != rootvp)
    616       1.1   mycroft 		return (EBUSY);
    617      1.55      fvdl 	vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
    618      1.55      fvdl 	error = vinvalbuf(devvp, V_SAVE, cred, p, 0, 0);
    619      1.55      fvdl 	VOP_UNLOCK(devvp, 0);
    620      1.55      fvdl 	if (error)
    621       1.1   mycroft 		return (error);
    622       1.1   mycroft 
    623       1.1   mycroft 	ronly = (mp->mnt_flag & MNT_RDONLY) != 0;
    624      1.19  christos 	error = VOP_OPEN(devvp, ronly ? FREAD : FREAD|FWRITE, FSCRED, p);
    625      1.19  christos 	if (error)
    626       1.1   mycroft 		return (error);
    627       1.9   mycroft 	if (VOP_IOCTL(devvp, DIOCGPART, (caddr_t)&dpart, FREAD, cred, p) != 0)
    628       1.1   mycroft 		size = DEV_BSIZE;
    629       1.1   mycroft 	else
    630       1.1   mycroft 		size = dpart.disklab->d_secsize;
    631       1.1   mycroft 
    632       1.1   mycroft 	bp = NULL;
    633       1.1   mycroft 	ump = NULL;
    634      1.33      fvdl 	error = bread(devvp, (ufs_daddr_t)(SBOFF / size), SBSIZE, cred, &bp);
    635      1.19  christos 	if (error)
    636       1.1   mycroft 		goto out;
    637      1.34    bouyer 
    638      1.34    bouyer 	fs = (struct fs*)bp->b_data;
    639      1.34    bouyer 	if (fs->fs_magic == FS_MAGIC) {
    640      1.34    bouyer 		sbsize = fs->fs_sbsize;
    641      1.34    bouyer #ifdef FFS_EI
    642      1.52  drochner 		needswap = 0;
    643      1.34    bouyer 	} else if (fs->fs_magic == bswap32(FS_MAGIC)) {
    644      1.52  drochner 		sbsize = bswap32(fs->fs_sbsize);
    645      1.34    bouyer 		needswap = 1;
    646      1.34    bouyer #endif
    647      1.34    bouyer 	} else {
    648      1.34    bouyer 		error = EINVAL;
    649      1.34    bouyer 		goto out;
    650      1.46    bouyer 	}
    651      1.49    bouyer 	if (sbsize > MAXBSIZE || sbsize < sizeof(struct fs)) {
    652      1.46    bouyer 		error = EINVAL;
    653      1.46    bouyer 		goto out;
    654      1.34    bouyer 	}
    655      1.34    bouyer 
    656      1.34    bouyer 	fs = malloc((u_long)sbsize, M_UFSMNT, M_WAITOK);
    657      1.42     perry 	memcpy(fs, bp->b_data, sbsize);
    658      1.34    bouyer #ifdef FFS_EI
    659      1.55      fvdl 	if (needswap) {
    660  1.80.2.3   nathanw 		ffs_sb_swap((struct fs*)bp->b_data, fs);
    661      1.55      fvdl 		fs->fs_flags |= FS_SWAPPED;
    662      1.55      fvdl 	}
    663      1.34    bouyer #endif
    664      1.56  drochner 	ffs_oldfscompat(fs);
    665      1.56  drochner 
    666      1.49    bouyer 	if (fs->fs_bsize > MAXBSIZE || fs->fs_bsize < sizeof(struct fs)) {
    667      1.49    bouyer 		error = EINVAL;
    668      1.49    bouyer 		goto out;
    669      1.49    bouyer 	}
    670      1.46    bouyer 	 /* make sure cylinder group summary area is a reasonable size. */
    671      1.46    bouyer 	if (fs->fs_cgsize == 0 || fs->fs_cpg == 0 ||
    672      1.46    bouyer 	    fs->fs_ncg > fs->fs_ncyl / fs->fs_cpg + 1 ||
    673      1.46    bouyer 	    fs->fs_cssize >
    674      1.46    bouyer 	    fragroundup(fs, fs->fs_ncg * sizeof(struct csum))) {
    675       1.1   mycroft 		error = EINVAL;		/* XXX needs translation */
    676      1.34    bouyer 		goto out2;
    677       1.1   mycroft 	}
    678  1.80.2.6   nathanw 	if (fs->fs_pendingblocks != 0 || fs->fs_pendinginodes != 0) {
    679  1.80.2.6   nathanw 		fs->fs_pendingblocks = 0;
    680  1.80.2.6   nathanw 		fs->fs_pendinginodes = 0;
    681  1.80.2.6   nathanw 	}
    682       1.1   mycroft 	/* XXX updating 4.2 FFS superblocks trashes rotational layout tables */
    683       1.1   mycroft 	if (fs->fs_postblformat == FS_42POSTBLFMT && !ronly) {
    684       1.1   mycroft 		error = EROFS;		/* XXX what should be returned? */
    685      1.34    bouyer 		goto out2;
    686       1.1   mycroft 	}
    687      1.56  drochner 
    688       1.1   mycroft 	ump = malloc(sizeof *ump, M_UFSMNT, M_WAITOK);
    689      1.42     perry 	memset((caddr_t)ump, 0, sizeof *ump);
    690      1.34    bouyer 	ump->um_fs = fs;
    691       1.1   mycroft 	if (fs->fs_sbsize < SBSIZE)
    692       1.1   mycroft 		bp->b_flags |= B_INVAL;
    693       1.1   mycroft 	brelse(bp);
    694       1.1   mycroft 	bp = NULL;
    695       1.1   mycroft 	fs->fs_ronly = ronly;
    696      1.15   mycroft 	if (ronly == 0) {
    697      1.15   mycroft 		fs->fs_clean <<= 1;
    698       1.1   mycroft 		fs->fs_fmod = 1;
    699      1.15   mycroft 	}
    700       1.9   mycroft 	size = fs->fs_cssize;
    701       1.9   mycroft 	blks = howmany(size, fs->fs_fsize);
    702       1.9   mycroft 	if (fs->fs_contigsumsize > 0)
    703       1.9   mycroft 		size += fs->fs_ncg * sizeof(int32_t);
    704  1.80.2.4   nathanw 	size += fs->fs_ncg * sizeof(*fs->fs_contigdirs);
    705  1.80.2.4   nathanw 	space = malloc((u_long)size, M_UFSMNT, M_WAITOK);
    706  1.80.2.4   nathanw 	fs->fs_csp = space;
    707       1.1   mycroft 	for (i = 0; i < blks; i += fs->fs_frag) {
    708       1.1   mycroft 		size = fs->fs_bsize;
    709       1.1   mycroft 		if (i + fs->fs_frag > blks)
    710       1.1   mycroft 			size = (blks - i) * fs->fs_fsize;
    711      1.19  christos 		error = bread(devvp, fsbtodb(fs, fs->fs_csaddr + i), size,
    712      1.19  christos 			      cred, &bp);
    713      1.19  christos 		if (error) {
    714  1.80.2.4   nathanw 			free(fs->fs_csp, M_UFSMNT);
    715      1.34    bouyer 			goto out2;
    716       1.1   mycroft 		}
    717      1.34    bouyer #ifdef FFS_EI
    718      1.34    bouyer 		if (needswap)
    719  1.80.2.4   nathanw 			ffs_csum_swap((struct csum *)bp->b_data,
    720  1.80.2.4   nathanw 				(struct csum *)space, size);
    721      1.34    bouyer 		else
    722      1.34    bouyer #endif
    723      1.42     perry 			memcpy(space, bp->b_data, (u_int)size);
    724      1.34    bouyer 
    725  1.80.2.4   nathanw 		space = (char *)space + size;
    726       1.1   mycroft 		brelse(bp);
    727       1.1   mycroft 		bp = NULL;
    728       1.1   mycroft 	}
    729       1.9   mycroft 	if (fs->fs_contigsumsize > 0) {
    730  1.80.2.4   nathanw 		fs->fs_maxcluster = lp = space;
    731       1.9   mycroft 		for (i = 0; i < fs->fs_ncg; i++)
    732       1.9   mycroft 			*lp++ = fs->fs_contigsumsize;
    733  1.80.2.4   nathanw 		space = lp;
    734       1.9   mycroft 	}
    735  1.80.2.4   nathanw 	size = fs->fs_ncg * sizeof(*fs->fs_contigdirs);
    736  1.80.2.4   nathanw 	fs->fs_contigdirs = space;
    737  1.80.2.4   nathanw 	space = (char *)space + size;
    738  1.80.2.4   nathanw 	memset(fs->fs_contigdirs, 0, size);
    739  1.80.2.4   nathanw 		/* Compatibility for old filesystems - XXX */
    740  1.80.2.4   nathanw 	if (fs->fs_avgfilesize <= 0)
    741  1.80.2.4   nathanw 		fs->fs_avgfilesize = AVFILESIZ;
    742  1.80.2.4   nathanw 	if (fs->fs_avgfpdir <= 0)
    743  1.80.2.4   nathanw 		fs->fs_avgfpdir = AFPDIR;
    744       1.1   mycroft 	mp->mnt_data = (qaddr_t)ump;
    745       1.1   mycroft 	mp->mnt_stat.f_fsid.val[0] = (long)dev;
    746      1.17   mycroft 	mp->mnt_stat.f_fsid.val[1] = makefstype(MOUNT_FFS);
    747       1.1   mycroft 	mp->mnt_maxsymlinklen = fs->fs_maxsymlinklen;
    748      1.73       chs 	mp->mnt_fs_bshift = fs->fs_bshift;
    749      1.73       chs 	mp->mnt_dev_bshift = DEV_BSHIFT;	/* XXX */
    750       1.1   mycroft 	mp->mnt_flag |= MNT_LOCAL;
    751      1.34    bouyer #ifdef FFS_EI
    752      1.34    bouyer 	if (needswap)
    753      1.34    bouyer 		ump->um_flags |= UFS_NEEDSWAP;
    754      1.34    bouyer #endif
    755       1.1   mycroft 	ump->um_mountp = mp;
    756       1.1   mycroft 	ump->um_dev = dev;
    757       1.1   mycroft 	ump->um_devvp = devvp;
    758       1.1   mycroft 	ump->um_nindir = fs->fs_nindir;
    759      1.73       chs 	ump->um_lognindir = ffs(fs->fs_nindir) - 1;
    760       1.1   mycroft 	ump->um_bptrtodb = fs->fs_fsbtodb;
    761       1.1   mycroft 	ump->um_seqinc = fs->fs_frag;
    762       1.1   mycroft 	for (i = 0; i < MAXQUOTAS; i++)
    763       1.1   mycroft 		ump->um_quotas[i] = NULLVP;
    764      1.55      fvdl 	devvp->v_specmountpoint = mp;
    765       1.9   mycroft 	ump->um_savedmaxfilesize = fs->fs_maxfilesize;		/* XXX */
    766       1.9   mycroft 	maxfilesize = (u_int64_t)0x80000000 * fs->fs_bsize - 1;	/* XXX */
    767       1.9   mycroft 	if (fs->fs_maxfilesize > maxfilesize)			/* XXX */
    768       1.9   mycroft 		fs->fs_maxfilesize = maxfilesize;		/* XXX */
    769      1.55      fvdl 	if (ronly == 0 && (fs->fs_flags & FS_DOSOFTDEP)) {
    770      1.55      fvdl 		error = softdep_mount(devvp, mp, fs, cred);
    771      1.55      fvdl 		if (error) {
    772  1.80.2.4   nathanw 			free(fs->fs_csp, M_UFSMNT);
    773      1.55      fvdl 			goto out;
    774      1.55      fvdl 		}
    775      1.55      fvdl 	}
    776       1.1   mycroft 	return (0);
    777      1.34    bouyer out2:
    778      1.34    bouyer 	free(fs, M_UFSMNT);
    779       1.1   mycroft out:
    780      1.55      fvdl 	devvp->v_specmountpoint = NULL;
    781       1.1   mycroft 	if (bp)
    782       1.1   mycroft 		brelse(bp);
    783      1.53  wrstuden 	vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
    784       1.9   mycroft 	(void)VOP_CLOSE(devvp, ronly ? FREAD : FREAD|FWRITE, cred, p);
    785      1.53  wrstuden 	VOP_UNLOCK(devvp, 0);
    786       1.1   mycroft 	if (ump) {
    787       1.1   mycroft 		free(ump, M_UFSMNT);
    788       1.1   mycroft 		mp->mnt_data = (qaddr_t)0;
    789       1.1   mycroft 	}
    790       1.1   mycroft 	return (error);
    791       1.1   mycroft }
    792       1.1   mycroft 
    793       1.1   mycroft /*
    794       1.1   mycroft  * Sanity checks for old file systems.
    795       1.1   mycroft  *
    796       1.1   mycroft  * XXX - goes away some day.
    797       1.1   mycroft  */
    798      1.19  christos int
    799       1.1   mycroft ffs_oldfscompat(fs)
    800       1.1   mycroft 	struct fs *fs;
    801       1.1   mycroft {
    802       1.1   mycroft 	int i;
    803       1.1   mycroft 
    804       1.1   mycroft 	fs->fs_npsect = max(fs->fs_npsect, fs->fs_nsect);	/* XXX */
    805       1.1   mycroft 	fs->fs_interleave = max(fs->fs_interleave, 1);		/* XXX */
    806       1.1   mycroft 	if (fs->fs_postblformat == FS_42POSTBLFMT)		/* XXX */
    807       1.1   mycroft 		fs->fs_nrpos = 8;				/* XXX */
    808       1.1   mycroft 	if (fs->fs_inodefmt < FS_44INODEFMT) {			/* XXX */
    809       1.5   mycroft 		u_int64_t sizepb = fs->fs_bsize;		/* XXX */
    810       1.1   mycroft 								/* XXX */
    811       1.1   mycroft 		fs->fs_maxfilesize = fs->fs_bsize * NDADDR - 1;	/* XXX */
    812       1.1   mycroft 		for (i = 0; i < NIADDR; i++) {			/* XXX */
    813       1.1   mycroft 			sizepb *= NINDIR(fs);			/* XXX */
    814       1.1   mycroft 			fs->fs_maxfilesize += sizepb;		/* XXX */
    815       1.1   mycroft 		}						/* XXX */
    816       1.1   mycroft 		fs->fs_qbmask = ~fs->fs_bmask;			/* XXX */
    817       1.1   mycroft 		fs->fs_qfmask = ~fs->fs_fmask;			/* XXX */
    818       1.1   mycroft 	}							/* XXX */
    819       1.1   mycroft 	return (0);
    820       1.1   mycroft }
    821       1.1   mycroft 
    822       1.1   mycroft /*
    823       1.1   mycroft  * unmount system call
    824       1.1   mycroft  */
    825       1.1   mycroft int
    826       1.1   mycroft ffs_unmount(mp, mntflags, p)
    827       1.1   mycroft 	struct mount *mp;
    828       1.1   mycroft 	int mntflags;
    829       1.1   mycroft 	struct proc *p;
    830       1.1   mycroft {
    831      1.61  augustss 	struct ufsmount *ump;
    832      1.61  augustss 	struct fs *fs;
    833  1.80.2.6   nathanw 	int error, flags, penderr;
    834       1.1   mycroft 
    835  1.80.2.6   nathanw 	penderr = 0;
    836       1.1   mycroft 	flags = 0;
    837      1.11   mycroft 	if (mntflags & MNT_FORCE)
    838       1.1   mycroft 		flags |= FORCECLOSE;
    839      1.55      fvdl 	if (mp->mnt_flag & MNT_SOFTDEP) {
    840      1.55      fvdl 		if ((error = softdep_flushfiles(mp, flags, p)) != 0)
    841      1.55      fvdl 			return (error);
    842      1.55      fvdl 	} else {
    843      1.55      fvdl 		if ((error = ffs_flushfiles(mp, flags, p)) != 0)
    844      1.55      fvdl 			return (error);
    845      1.55      fvdl 	}
    846       1.1   mycroft 	ump = VFSTOUFS(mp);
    847       1.1   mycroft 	fs = ump->um_fs;
    848  1.80.2.6   nathanw 	if (fs->fs_pendingblocks != 0 || fs->fs_pendinginodes != 0) {
    849  1.80.2.6   nathanw 		printf("%s: unmount pending error: blocks %d files %d\n",
    850  1.80.2.6   nathanw 		    fs->fs_fsmnt, fs->fs_pendingblocks, fs->fs_pendinginodes);
    851  1.80.2.6   nathanw 		fs->fs_pendingblocks = 0;
    852  1.80.2.6   nathanw 		fs->fs_pendinginodes = 0;
    853  1.80.2.6   nathanw 		penderr = 1;
    854  1.80.2.6   nathanw 	}
    855      1.15   mycroft 	if (fs->fs_ronly == 0 &&
    856      1.15   mycroft 	    ffs_cgupdate(ump, MNT_WAIT) == 0 &&
    857      1.15   mycroft 	    fs->fs_clean & FS_WASCLEAN) {
    858  1.80.2.6   nathanw 		/*
    859  1.80.2.6   nathanw 		 * XXXX don't mark fs clean in the case of softdep
    860  1.80.2.6   nathanw 		 * pending block errors, until they are fixed.
    861  1.80.2.6   nathanw 		 */
    862  1.80.2.6   nathanw 		if (penderr == 0) {
    863  1.80.2.6   nathanw 			if (mp->mnt_flag & MNT_SOFTDEP)
    864  1.80.2.6   nathanw 				fs->fs_flags &= ~FS_DOSOFTDEP;
    865  1.80.2.6   nathanw 			fs->fs_clean = FS_ISCLEAN;
    866  1.80.2.6   nathanw 		}
    867      1.15   mycroft 		(void) ffs_sbupdate(ump, MNT_WAIT);
    868      1.15   mycroft 	}
    869      1.54     enami 	if (ump->um_devvp->v_type != VBAD)
    870      1.55      fvdl 		ump->um_devvp->v_specmountpoint = NULL;
    871      1.53  wrstuden 	vn_lock(ump->um_devvp, LK_EXCLUSIVE | LK_RETRY);
    872       1.9   mycroft 	error = VOP_CLOSE(ump->um_devvp, fs->fs_ronly ? FREAD : FREAD|FWRITE,
    873       1.1   mycroft 		NOCRED, p);
    874      1.53  wrstuden 	vput(ump->um_devvp);
    875  1.80.2.4   nathanw 	free(fs->fs_csp, M_UFSMNT);
    876       1.1   mycroft 	free(fs, M_UFSMNT);
    877       1.1   mycroft 	free(ump, M_UFSMNT);
    878       1.1   mycroft 	mp->mnt_data = (qaddr_t)0;
    879       1.1   mycroft 	mp->mnt_flag &= ~MNT_LOCAL;
    880       1.1   mycroft 	return (error);
    881       1.1   mycroft }
    882       1.1   mycroft 
    883       1.1   mycroft /*
    884       1.1   mycroft  * Flush out all the files in a filesystem.
    885       1.1   mycroft  */
    886      1.19  christos int
    887       1.1   mycroft ffs_flushfiles(mp, flags, p)
    888      1.61  augustss 	struct mount *mp;
    889       1.1   mycroft 	int flags;
    890       1.1   mycroft 	struct proc *p;
    891       1.1   mycroft {
    892       1.1   mycroft 	extern int doforce;
    893      1.61  augustss 	struct ufsmount *ump;
    894      1.19  christos 	int error;
    895       1.1   mycroft 
    896       1.1   mycroft 	if (!doforce)
    897       1.1   mycroft 		flags &= ~FORCECLOSE;
    898       1.1   mycroft 	ump = VFSTOUFS(mp);
    899       1.1   mycroft #ifdef QUOTA
    900       1.1   mycroft 	if (mp->mnt_flag & MNT_QUOTA) {
    901      1.19  christos 		int i;
    902      1.19  christos 		if ((error = vflush(mp, NULLVP, SKIPSYSTEM|flags)) != 0)
    903       1.1   mycroft 			return (error);
    904       1.1   mycroft 		for (i = 0; i < MAXQUOTAS; i++) {
    905       1.1   mycroft 			if (ump->um_quotas[i] == NULLVP)
    906       1.1   mycroft 				continue;
    907       1.1   mycroft 			quotaoff(p, mp, i);
    908       1.1   mycroft 		}
    909       1.1   mycroft 		/*
    910       1.1   mycroft 		 * Here we fall through to vflush again to ensure
    911       1.1   mycroft 		 * that we have gotten rid of all the system vnodes.
    912       1.1   mycroft 		 */
    913       1.1   mycroft 	}
    914       1.1   mycroft #endif
    915      1.55      fvdl 	/*
    916      1.55      fvdl 	 * Flush all the files.
    917      1.55      fvdl 	 */
    918       1.1   mycroft 	error = vflush(mp, NULLVP, flags);
    919      1.55      fvdl 	if (error)
    920      1.55      fvdl 		return (error);
    921      1.55      fvdl 	/*
    922      1.55      fvdl 	 * Flush filesystem metadata.
    923      1.55      fvdl 	 */
    924      1.55      fvdl 	vn_lock(ump->um_devvp, LK_EXCLUSIVE | LK_RETRY);
    925      1.71      fvdl 	error = VOP_FSYNC(ump->um_devvp, p->p_ucred, FSYNC_WAIT, 0, 0, p);
    926      1.55      fvdl 	VOP_UNLOCK(ump->um_devvp, 0);
    927       1.1   mycroft 	return (error);
    928       1.1   mycroft }
    929       1.1   mycroft 
    930       1.1   mycroft /*
    931       1.1   mycroft  * Get file system statistics.
    932       1.1   mycroft  */
    933       1.1   mycroft int
    934       1.1   mycroft ffs_statfs(mp, sbp, p)
    935       1.1   mycroft 	struct mount *mp;
    936      1.61  augustss 	struct statfs *sbp;
    937       1.1   mycroft 	struct proc *p;
    938       1.1   mycroft {
    939      1.61  augustss 	struct ufsmount *ump;
    940      1.61  augustss 	struct fs *fs;
    941       1.1   mycroft 
    942       1.1   mycroft 	ump = VFSTOUFS(mp);
    943       1.1   mycroft 	fs = ump->um_fs;
    944       1.1   mycroft 	if (fs->fs_magic != FS_MAGIC)
    945       1.1   mycroft 		panic("ffs_statfs");
    946       1.1   mycroft #ifdef COMPAT_09
    947       1.1   mycroft 	sbp->f_type = 1;
    948       1.1   mycroft #else
    949       1.1   mycroft 	sbp->f_type = 0;
    950       1.1   mycroft #endif
    951       1.1   mycroft 	sbp->f_bsize = fs->fs_fsize;
    952       1.1   mycroft 	sbp->f_iosize = fs->fs_bsize;
    953       1.1   mycroft 	sbp->f_blocks = fs->fs_dsize;
    954       1.1   mycroft 	sbp->f_bfree = fs->fs_cstotal.cs_nbfree * fs->fs_frag +
    955  1.80.2.6   nathanw 		fs->fs_cstotal.cs_nffree + dbtofsb(fs, fs->fs_pendingblocks);
    956      1.31    mjacob 	sbp->f_bavail = (long) (((u_int64_t) fs->fs_dsize * (u_int64_t)
    957      1.38    kleink 	    (100 - fs->fs_minfree) / (u_int64_t) 100) -
    958  1.80.2.6   nathanw 	    (u_int64_t) (fs->fs_dsize - sbp->f_bfree) +
    959  1.80.2.6   nathanw 	    (u_int64_t) dbtofsb(fs, fs->fs_pendingblocks));
    960       1.1   mycroft 	sbp->f_files =  fs->fs_ncg * fs->fs_ipg - ROOTINO;
    961  1.80.2.6   nathanw 	sbp->f_ffree = fs->fs_cstotal.cs_nifree + fs->fs_pendinginodes;
    962       1.1   mycroft 	if (sbp != &mp->mnt_stat) {
    963      1.42     perry 		memcpy(sbp->f_mntonname, mp->mnt_stat.f_mntonname, MNAMELEN);
    964      1.42     perry 		memcpy(sbp->f_mntfromname, mp->mnt_stat.f_mntfromname, MNAMELEN);
    965       1.1   mycroft 	}
    966      1.12   mycroft 	strncpy(sbp->f_fstypename, mp->mnt_op->vfs_name, MFSNAMELEN);
    967       1.1   mycroft 	return (0);
    968       1.1   mycroft }
    969       1.1   mycroft 
    970       1.1   mycroft /*
    971       1.1   mycroft  * Go through the disk queues to initiate sandbagged IO;
    972       1.1   mycroft  * go through the inodes to write those that have been modified;
    973       1.1   mycroft  * initiate the writing of the super block if it has been modified.
    974       1.1   mycroft  *
    975       1.1   mycroft  * Note: we are always called with the filesystem marked `MPBUSY'.
    976       1.1   mycroft  */
    977       1.1   mycroft int
    978       1.1   mycroft ffs_sync(mp, waitfor, cred, p)
    979       1.1   mycroft 	struct mount *mp;
    980       1.1   mycroft 	int waitfor;
    981       1.1   mycroft 	struct ucred *cred;
    982       1.1   mycroft 	struct proc *p;
    983       1.1   mycroft {
    984      1.33      fvdl 	struct vnode *vp, *nvp;
    985      1.33      fvdl 	struct inode *ip;
    986      1.33      fvdl 	struct ufsmount *ump = VFSTOUFS(mp);
    987      1.33      fvdl 	struct fs *fs;
    988       1.1   mycroft 	int error, allerror = 0;
    989       1.1   mycroft 
    990       1.1   mycroft 	fs = ump->um_fs;
    991      1.33      fvdl 	if (fs->fs_fmod != 0 && fs->fs_ronly != 0) {		/* XXX */
    992      1.33      fvdl 		printf("fs = %s\n", fs->fs_fsmnt);
    993      1.33      fvdl 		panic("update: rofs mod");
    994       1.1   mycroft 	}
    995       1.1   mycroft 	/*
    996       1.1   mycroft 	 * Write back each (modified) inode.
    997       1.1   mycroft 	 */
    998      1.33      fvdl 	simple_lock(&mntvnode_slock);
    999       1.1   mycroft loop:
   1000      1.64   mycroft 	for (vp = LIST_FIRST(&mp->mnt_vnodelist); vp != NULL; vp = nvp) {
   1001       1.1   mycroft 		/*
   1002       1.1   mycroft 		 * If the vnode that we are about to sync is no longer
   1003       1.1   mycroft 		 * associated with this mount point, start over.
   1004       1.1   mycroft 		 */
   1005       1.1   mycroft 		if (vp->v_mount != mp)
   1006       1.1   mycroft 			goto loop;
   1007      1.33      fvdl 		simple_lock(&vp->v_interlock);
   1008      1.64   mycroft 		nvp = LIST_NEXT(vp, v_mntvnodes);
   1009       1.1   mycroft 		ip = VTOI(vp);
   1010      1.57      fvdl 		if (vp->v_type == VNON ||
   1011      1.57      fvdl 		    ((ip->i_flag &
   1012      1.63   mycroft 		      (IN_ACCESS | IN_CHANGE | IN_UPDATE | IN_MODIFIED | IN_ACCESSED)) == 0 &&
   1013      1.75       chs 		     LIST_EMPTY(&vp->v_dirtyblkhd) &&
   1014  1.80.2.4   nathanw 		     vp->v_uobj.uo_npages == 0))
   1015      1.57      fvdl 		{
   1016      1.33      fvdl 			simple_unlock(&vp->v_interlock);
   1017      1.33      fvdl 			continue;
   1018      1.33      fvdl 		}
   1019      1.33      fvdl 		simple_unlock(&mntvnode_slock);
   1020      1.33      fvdl 		error = vget(vp, LK_EXCLUSIVE | LK_NOWAIT | LK_INTERLOCK);
   1021      1.33      fvdl 		if (error) {
   1022      1.33      fvdl 			simple_lock(&mntvnode_slock);
   1023      1.33      fvdl 			if (error == ENOENT)
   1024      1.33      fvdl 				goto loop;
   1025       1.1   mycroft 			continue;
   1026      1.33      fvdl 		}
   1027      1.35    kleink 		if ((error = VOP_FSYNC(vp, cred,
   1028      1.71      fvdl 		    waitfor == MNT_WAIT ? FSYNC_WAIT : 0, 0, 0, p)) != 0)
   1029       1.1   mycroft 			allerror = error;
   1030       1.1   mycroft 		vput(vp);
   1031      1.33      fvdl 		simple_lock(&mntvnode_slock);
   1032       1.1   mycroft 	}
   1033      1.33      fvdl 	simple_unlock(&mntvnode_slock);
   1034       1.1   mycroft 	/*
   1035       1.1   mycroft 	 * Force stale file system control information to be flushed.
   1036       1.1   mycroft 	 */
   1037      1.55      fvdl 	if (waitfor != MNT_LAZY) {
   1038      1.55      fvdl 		if (ump->um_mountp->mnt_flag & MNT_SOFTDEP)
   1039      1.55      fvdl 			waitfor = MNT_NOWAIT;
   1040      1.55      fvdl 		vn_lock(ump->um_devvp, LK_EXCLUSIVE | LK_RETRY);
   1041      1.55      fvdl 		if ((error = VOP_FSYNC(ump->um_devvp, cred,
   1042      1.71      fvdl 		    waitfor == MNT_WAIT ? FSYNC_WAIT : 0, 0, 0, p)) != 0)
   1043      1.55      fvdl 			allerror = error;
   1044      1.55      fvdl 		VOP_UNLOCK(ump->um_devvp, 0);
   1045      1.55      fvdl 	}
   1046       1.1   mycroft #ifdef QUOTA
   1047       1.1   mycroft 	qsync(mp);
   1048       1.1   mycroft #endif
   1049      1.33      fvdl 	/*
   1050      1.33      fvdl 	 * Write back modified superblock.
   1051      1.33      fvdl 	 */
   1052      1.33      fvdl 	if (fs->fs_fmod != 0) {
   1053      1.33      fvdl 		fs->fs_fmod = 0;
   1054      1.33      fvdl 		fs->fs_time = time.tv_sec;
   1055      1.64   mycroft 		if ((error = ffs_cgupdate(ump, waitfor)))
   1056      1.64   mycroft 			allerror = error;
   1057      1.33      fvdl 	}
   1058       1.1   mycroft 	return (allerror);
   1059       1.1   mycroft }
   1060       1.1   mycroft 
   1061       1.1   mycroft /*
   1062       1.1   mycroft  * Look up a FFS dinode number to find its incore vnode, otherwise read it
   1063       1.1   mycroft  * in from disk.  If it is in core, wait for the lock bit to clear, then
   1064       1.1   mycroft  * return the inode locked.  Detection and handling of mount points must be
   1065       1.1   mycroft  * done by the calling routine.
   1066       1.1   mycroft  */
   1067       1.1   mycroft int
   1068       1.1   mycroft ffs_vget(mp, ino, vpp)
   1069       1.1   mycroft 	struct mount *mp;
   1070       1.1   mycroft 	ino_t ino;
   1071       1.1   mycroft 	struct vnode **vpp;
   1072       1.1   mycroft {
   1073      1.33      fvdl 	struct fs *fs;
   1074      1.33      fvdl 	struct inode *ip;
   1075       1.1   mycroft 	struct ufsmount *ump;
   1076       1.1   mycroft 	struct buf *bp;
   1077       1.1   mycroft 	struct vnode *vp;
   1078       1.1   mycroft 	dev_t dev;
   1079      1.43   thorpej 	int error;
   1080      1.44   thorpej 	caddr_t cp;
   1081       1.1   mycroft 
   1082       1.1   mycroft 	ump = VFSTOUFS(mp);
   1083       1.1   mycroft 	dev = ump->um_dev;
   1084      1.68      fvdl 
   1085      1.68      fvdl 	if ((*vpp = ufs_ihashget(dev, ino, LK_EXCLUSIVE)) != NULL)
   1086      1.68      fvdl 		return (0);
   1087       1.1   mycroft 
   1088       1.1   mycroft 	/* Allocate a new vnode/inode. */
   1089      1.19  christos 	if ((error = getnewvnode(VT_UFS, mp, ffs_vnodeop_p, &vp)) != 0) {
   1090       1.1   mycroft 		*vpp = NULL;
   1091       1.1   mycroft 		return (error);
   1092       1.1   mycroft 	}
   1093      1.68      fvdl 
   1094      1.68      fvdl 	/*
   1095      1.68      fvdl 	 * If someone beat us to it while sleeping in getnewvnode(),
   1096      1.68      fvdl 	 * push back the freshly allocated vnode we don't need, and return.
   1097      1.68      fvdl 	 */
   1098  1.80.2.4   nathanw 
   1099      1.68      fvdl 	do {
   1100      1.68      fvdl 		if ((*vpp = ufs_ihashget(dev, ino, LK_EXCLUSIVE)) != NULL) {
   1101      1.69      fvdl 			ungetnewvnode(vp);
   1102      1.68      fvdl 			return (0);
   1103      1.68      fvdl 		}
   1104      1.68      fvdl 	} while (lockmgr(&ufs_hashlock, LK_EXCLUSIVE|LK_SLEEPFAIL, 0));
   1105      1.68      fvdl 
   1106      1.43   thorpej 	/*
   1107      1.43   thorpej 	 * XXX MFS ends up here, too, to allocate an inode.  Should we
   1108      1.43   thorpej 	 * XXX create another pool for MFS inodes?
   1109      1.43   thorpej 	 */
   1110  1.80.2.4   nathanw 
   1111      1.43   thorpej 	ip = pool_get(&ffs_inode_pool, PR_WAITOK);
   1112  1.80.2.4   nathanw 	memset(ip, 0, sizeof(struct inode));
   1113       1.1   mycroft 	vp->v_data = ip;
   1114       1.1   mycroft 	ip->i_vnode = vp;
   1115       1.1   mycroft 	ip->i_fs = fs = ump->um_fs;
   1116       1.1   mycroft 	ip->i_dev = dev;
   1117       1.1   mycroft 	ip->i_number = ino;
   1118      1.77       chs 	LIST_INIT(&ip->i_pcbufhd);
   1119       1.1   mycroft #ifdef QUOTA
   1120      1.19  christos 	{
   1121      1.19  christos 		int i;
   1122      1.19  christos 
   1123      1.19  christos 		for (i = 0; i < MAXQUOTAS; i++)
   1124      1.19  christos 			ip->i_dquot[i] = NODQUOT;
   1125      1.19  christos 	}
   1126       1.1   mycroft #endif
   1127  1.80.2.4   nathanw 
   1128       1.1   mycroft 	/*
   1129       1.1   mycroft 	 * Put it onto its hash chain and lock it so that other requests for
   1130       1.1   mycroft 	 * this inode will block if they arrive while we are sleeping waiting
   1131       1.1   mycroft 	 * for old data structures to be purged or for the contents of the
   1132       1.1   mycroft 	 * disk portion of this inode to be read.
   1133       1.1   mycroft 	 */
   1134  1.80.2.4   nathanw 
   1135       1.1   mycroft 	ufs_ihashins(ip);
   1136      1.33      fvdl 	lockmgr(&ufs_hashlock, LK_RELEASE, 0);
   1137       1.1   mycroft 
   1138       1.1   mycroft 	/* Read in the disk contents for the inode, copy into the inode. */
   1139      1.19  christos 	error = bread(ump->um_devvp, fsbtodb(fs, ino_to_fsba(fs, ino)),
   1140      1.19  christos 		      (int)fs->fs_bsize, NOCRED, &bp);
   1141      1.19  christos 	if (error) {
   1142  1.80.2.4   nathanw 
   1143       1.1   mycroft 		/*
   1144       1.1   mycroft 		 * The inode does not contain anything useful, so it would
   1145       1.1   mycroft 		 * be misleading to leave it on its hash chain. With mode
   1146       1.1   mycroft 		 * still zero, it will be unlinked and returned to the free
   1147       1.1   mycroft 		 * list by vput().
   1148       1.1   mycroft 		 */
   1149  1.80.2.4   nathanw 
   1150       1.1   mycroft 		vput(vp);
   1151       1.1   mycroft 		brelse(bp);
   1152       1.1   mycroft 		*vpp = NULL;
   1153       1.1   mycroft 		return (error);
   1154       1.1   mycroft 	}
   1155      1.44   thorpej 	cp = (caddr_t)bp->b_data + (ino_to_fsbo(fs, ino) * DINODE_SIZE);
   1156      1.34    bouyer #ifdef FFS_EI
   1157      1.55      fvdl 	if (UFS_FSNEEDSWAP(fs))
   1158      1.44   thorpej 		ffs_dinode_swap((struct dinode *)cp, &ip->i_din.ffs_din);
   1159      1.34    bouyer 	else
   1160      1.34    bouyer #endif
   1161      1.44   thorpej 		memcpy(&ip->i_din.ffs_din, cp, DINODE_SIZE);
   1162      1.55      fvdl 	if (DOINGSOFTDEP(vp))
   1163      1.55      fvdl 		softdep_load_inodeblock(ip);
   1164      1.55      fvdl 	else
   1165      1.55      fvdl 		ip->i_ffs_effnlink = ip->i_ffs_nlink;
   1166       1.1   mycroft 	brelse(bp);
   1167       1.1   mycroft 
   1168       1.1   mycroft 	/*
   1169       1.1   mycroft 	 * Initialize the vnode from the inode, check for aliases.
   1170       1.1   mycroft 	 * Note that the underlying vnode may have changed.
   1171       1.1   mycroft 	 */
   1172  1.80.2.4   nathanw 
   1173  1.80.2.4   nathanw 	ufs_vinit(mp, ffs_specop_p, ffs_fifoop_p, &vp);
   1174  1.80.2.4   nathanw 
   1175       1.1   mycroft 	/*
   1176       1.1   mycroft 	 * Finish inode initialization now that aliasing has been resolved.
   1177       1.1   mycroft 	 */
   1178  1.80.2.4   nathanw 
   1179  1.80.2.4   nathanw 	genfs_node_init(vp, &ffs_genfsops);
   1180       1.1   mycroft 	ip->i_devvp = ump->um_devvp;
   1181       1.1   mycroft 	VREF(ip->i_devvp);
   1182  1.80.2.4   nathanw 
   1183       1.1   mycroft 	/*
   1184       1.1   mycroft 	 * Ensure that uid and gid are correct. This is a temporary
   1185       1.1   mycroft 	 * fix until fsck has been changed to do the update.
   1186       1.1   mycroft 	 */
   1187  1.80.2.4   nathanw 
   1188      1.38    kleink 	if (fs->fs_inodefmt < FS_44INODEFMT) {			/* XXX */
   1189      1.38    kleink 		ip->i_ffs_uid = ip->i_din.ffs_din.di_ouid;	/* XXX */
   1190      1.38    kleink 		ip->i_ffs_gid = ip->i_din.ffs_din.di_ogid;	/* XXX */
   1191      1.38    kleink 	}							/* XXX */
   1192      1.73       chs 	uvm_vnp_setsize(vp, ip->i_ffs_size);
   1193       1.1   mycroft 	*vpp = vp;
   1194       1.1   mycroft 	return (0);
   1195       1.1   mycroft }
   1196       1.1   mycroft 
   1197       1.1   mycroft /*
   1198       1.1   mycroft  * File handle to vnode
   1199       1.1   mycroft  *
   1200       1.1   mycroft  * Have to be really careful about stale file handles:
   1201       1.1   mycroft  * - check that the inode number is valid
   1202       1.1   mycroft  * - call ffs_vget() to get the locked inode
   1203       1.1   mycroft  * - check for an unallocated inode (i_mode == 0)
   1204       1.1   mycroft  * - check that the given client host has export rights and return
   1205       1.1   mycroft  *   those rights via. exflagsp and credanonp
   1206       1.1   mycroft  */
   1207       1.1   mycroft int
   1208      1.48  wrstuden ffs_fhtovp(mp, fhp, vpp)
   1209      1.61  augustss 	struct mount *mp;
   1210       1.1   mycroft 	struct fid *fhp;
   1211       1.1   mycroft 	struct vnode **vpp;
   1212       1.1   mycroft {
   1213      1.61  augustss 	struct ufid *ufhp;
   1214       1.1   mycroft 	struct fs *fs;
   1215       1.1   mycroft 
   1216       1.1   mycroft 	ufhp = (struct ufid *)fhp;
   1217       1.1   mycroft 	fs = VFSTOUFS(mp)->um_fs;
   1218       1.1   mycroft 	if (ufhp->ufid_ino < ROOTINO ||
   1219       1.1   mycroft 	    ufhp->ufid_ino >= fs->fs_ncg * fs->fs_ipg)
   1220       1.1   mycroft 		return (ESTALE);
   1221      1.48  wrstuden 	return (ufs_fhtovp(mp, ufhp, vpp));
   1222       1.1   mycroft }
   1223       1.1   mycroft 
   1224       1.1   mycroft /*
   1225       1.1   mycroft  * Vnode pointer to File handle
   1226       1.1   mycroft  */
   1227       1.1   mycroft /* ARGSUSED */
   1228      1.19  christos int
   1229       1.1   mycroft ffs_vptofh(vp, fhp)
   1230       1.1   mycroft 	struct vnode *vp;
   1231       1.1   mycroft 	struct fid *fhp;
   1232       1.1   mycroft {
   1233      1.61  augustss 	struct inode *ip;
   1234      1.61  augustss 	struct ufid *ufhp;
   1235       1.1   mycroft 
   1236       1.1   mycroft 	ip = VTOI(vp);
   1237       1.1   mycroft 	ufhp = (struct ufid *)fhp;
   1238       1.1   mycroft 	ufhp->ufid_len = sizeof(struct ufid);
   1239       1.1   mycroft 	ufhp->ufid_ino = ip->i_number;
   1240      1.25    bouyer 	ufhp->ufid_gen = ip->i_ffs_gen;
   1241       1.1   mycroft 	return (0);
   1242      1.33      fvdl }
   1243      1.33      fvdl 
   1244      1.33      fvdl void
   1245      1.33      fvdl ffs_init()
   1246      1.33      fvdl {
   1247      1.59  jdolecek 	if (ffs_initcount++ > 0)
   1248      1.59  jdolecek 		return;
   1249      1.59  jdolecek 
   1250      1.55      fvdl 	softdep_initialize();
   1251      1.33      fvdl 	ufs_init();
   1252      1.43   thorpej 
   1253      1.43   thorpej 	pool_init(&ffs_inode_pool, sizeof(struct inode), 0, 0, 0, "ffsinopl",
   1254      1.43   thorpej 	    0, pool_page_alloc_nointr, pool_page_free_nointr, M_FFSNODE);
   1255      1.59  jdolecek }
   1256      1.59  jdolecek 
   1257      1.59  jdolecek void
   1258  1.80.2.4   nathanw ffs_reinit()
   1259  1.80.2.4   nathanw {
   1260  1.80.2.4   nathanw 	softdep_reinitialize();
   1261  1.80.2.4   nathanw 	ufs_reinit();
   1262  1.80.2.4   nathanw }
   1263  1.80.2.4   nathanw 
   1264  1.80.2.4   nathanw void
   1265      1.59  jdolecek ffs_done()
   1266      1.59  jdolecek {
   1267      1.59  jdolecek 	if (--ffs_initcount > 0)
   1268      1.59  jdolecek 		return;
   1269      1.59  jdolecek 
   1270      1.59  jdolecek 	/* XXX softdep cleanup ? */
   1271      1.59  jdolecek 	ufs_done();
   1272      1.59  jdolecek 	pool_destroy(&ffs_inode_pool);
   1273      1.33      fvdl }
   1274      1.33      fvdl 
   1275      1.33      fvdl int
   1276      1.33      fvdl ffs_sysctl(name, namelen, oldp, oldlenp, newp, newlen, p)
   1277      1.33      fvdl 	int *name;
   1278      1.33      fvdl 	u_int namelen;
   1279      1.33      fvdl 	void *oldp;
   1280      1.33      fvdl 	size_t *oldlenp;
   1281      1.33      fvdl 	void *newp;
   1282      1.33      fvdl 	size_t newlen;
   1283      1.33      fvdl 	struct proc *p;
   1284      1.33      fvdl {
   1285  1.80.2.4   nathanw 	extern int doasyncfree;
   1286      1.62  jdolecek 	extern int ffs_log_changeopt;
   1287      1.33      fvdl 
   1288      1.33      fvdl 	/* all sysctl names at this level are terminal */
   1289      1.33      fvdl 	if (namelen != 1)
   1290      1.33      fvdl 		return (ENOTDIR);		/* overloaded */
   1291      1.33      fvdl 
   1292      1.33      fvdl 	switch (name[0]) {
   1293      1.33      fvdl 	case FFS_ASYNCFREE:
   1294      1.33      fvdl 		return (sysctl_int(oldp, oldlenp, newp, newlen, &doasyncfree));
   1295      1.62  jdolecek 	case FFS_LOG_CHANGEOPT:
   1296      1.62  jdolecek 		return (sysctl_int(oldp, oldlenp, newp, newlen,
   1297      1.62  jdolecek 			&ffs_log_changeopt));
   1298      1.33      fvdl 	default:
   1299      1.33      fvdl 		return (EOPNOTSUPP);
   1300      1.33      fvdl 	}
   1301      1.33      fvdl 	/* NOTREACHED */
   1302       1.1   mycroft }
   1303       1.1   mycroft 
   1304       1.1   mycroft /*
   1305       1.1   mycroft  * Write a superblock and associated information back to disk.
   1306       1.1   mycroft  */
   1307       1.1   mycroft int
   1308       1.1   mycroft ffs_sbupdate(mp, waitfor)
   1309       1.1   mycroft 	struct ufsmount *mp;
   1310       1.1   mycroft 	int waitfor;
   1311       1.1   mycroft {
   1312      1.61  augustss 	struct fs *fs = mp->um_fs;
   1313      1.61  augustss 	struct buf *bp;
   1314      1.15   mycroft 	int i, error = 0;
   1315      1.34    bouyer 	int32_t saved_nrpos = fs->fs_nrpos;
   1316      1.34    bouyer 	int64_t saved_qbmask = fs->fs_qbmask;
   1317      1.34    bouyer 	int64_t saved_qfmask = fs->fs_qfmask;
   1318      1.34    bouyer 	u_int64_t saved_maxfilesize = fs->fs_maxfilesize;
   1319      1.55      fvdl 	u_int8_t saveflag;
   1320       1.1   mycroft 
   1321       1.1   mycroft 	/* Restore compatibility to old file systems.		   XXX */
   1322       1.1   mycroft 	if (fs->fs_postblformat == FS_42POSTBLFMT)		/* XXX */
   1323      1.34    bouyer 		fs->fs_nrpos = -1;		/* XXX */
   1324       1.1   mycroft 	if (fs->fs_inodefmt < FS_44INODEFMT) {			/* XXX */
   1325       1.5   mycroft 		int32_t *lp, tmp;				/* XXX */
   1326       1.1   mycroft 								/* XXX */
   1327      1.38    kleink 		lp = (int32_t *)&fs->fs_qbmask;	/* XXX nuke qfmask too */
   1328       1.1   mycroft 		tmp = lp[4];					/* XXX */
   1329       1.1   mycroft 		for (i = 4; i > 0; i--)				/* XXX */
   1330       1.1   mycroft 			lp[i] = lp[i-1];			/* XXX */
   1331       1.1   mycroft 		lp[0] = tmp;					/* XXX */
   1332       1.1   mycroft 	}							/* XXX */
   1333      1.34    bouyer 	fs->fs_maxfilesize = mp->um_savedmaxfilesize;	/* XXX */
   1334      1.34    bouyer 
   1335      1.34    bouyer 	bp = getblk(mp->um_devvp, SBOFF >> (fs->fs_fshift - fs->fs_fsbtodb),
   1336      1.34    bouyer 	    (int)fs->fs_sbsize, 0, 0);
   1337      1.55      fvdl 	saveflag = fs->fs_flags & FS_INTERNAL;
   1338      1.55      fvdl 	fs->fs_flags &= ~FS_INTERNAL;
   1339      1.42     perry 	memcpy(bp->b_data, fs, fs->fs_sbsize);
   1340      1.34    bouyer #ifdef FFS_EI
   1341      1.34    bouyer 	if (mp->um_flags & UFS_NEEDSWAP)
   1342  1.80.2.3   nathanw 		ffs_sb_swap(fs, (struct fs*)bp->b_data);
   1343      1.34    bouyer #endif
   1344      1.34    bouyer 
   1345      1.55      fvdl 	fs->fs_flags |= saveflag;
   1346      1.34    bouyer 	fs->fs_nrpos = saved_nrpos; /* XXX */
   1347      1.34    bouyer 	fs->fs_qbmask = saved_qbmask; /* XXX */
   1348      1.34    bouyer 	fs->fs_qfmask = saved_qfmask; /* XXX */
   1349      1.34    bouyer 	fs->fs_maxfilesize = saved_maxfilesize; /* XXX */
   1350      1.34    bouyer 
   1351       1.1   mycroft 	if (waitfor == MNT_WAIT)
   1352       1.1   mycroft 		error = bwrite(bp);
   1353       1.1   mycroft 	else
   1354       1.1   mycroft 		bawrite(bp);
   1355      1.15   mycroft 	return (error);
   1356      1.15   mycroft }
   1357      1.15   mycroft 
   1358      1.15   mycroft int
   1359      1.15   mycroft ffs_cgupdate(mp, waitfor)
   1360      1.15   mycroft 	struct ufsmount *mp;
   1361      1.15   mycroft 	int waitfor;
   1362      1.15   mycroft {
   1363      1.61  augustss 	struct fs *fs = mp->um_fs;
   1364      1.61  augustss 	struct buf *bp;
   1365      1.15   mycroft 	int blks;
   1366  1.80.2.4   nathanw 	void *space;
   1367      1.15   mycroft 	int i, size, error = 0, allerror = 0;
   1368      1.15   mycroft 
   1369      1.15   mycroft 	allerror = ffs_sbupdate(mp, waitfor);
   1370       1.1   mycroft 	blks = howmany(fs->fs_cssize, fs->fs_fsize);
   1371  1.80.2.4   nathanw 	space = fs->fs_csp;
   1372       1.1   mycroft 	for (i = 0; i < blks; i += fs->fs_frag) {
   1373       1.1   mycroft 		size = fs->fs_bsize;
   1374       1.1   mycroft 		if (i + fs->fs_frag > blks)
   1375       1.1   mycroft 			size = (blks - i) * fs->fs_fsize;
   1376       1.1   mycroft 		bp = getblk(mp->um_devvp, fsbtodb(fs, fs->fs_csaddr + i),
   1377       1.1   mycroft 		    size, 0, 0);
   1378      1.34    bouyer #ifdef FFS_EI
   1379      1.34    bouyer 		if (mp->um_flags & UFS_NEEDSWAP)
   1380      1.34    bouyer 			ffs_csum_swap((struct csum*)space,
   1381      1.38    kleink 			    (struct csum*)bp->b_data, size);
   1382      1.34    bouyer 		else
   1383      1.34    bouyer #endif
   1384      1.42     perry 			memcpy(bp->b_data, space, (u_int)size);
   1385  1.80.2.4   nathanw 		space = (char *)space + size;
   1386       1.1   mycroft 		if (waitfor == MNT_WAIT)
   1387       1.1   mycroft 			error = bwrite(bp);
   1388       1.1   mycroft 		else
   1389       1.1   mycroft 			bawrite(bp);
   1390       1.1   mycroft 	}
   1391      1.15   mycroft 	if (!allerror && error)
   1392      1.15   mycroft 		allerror = error;
   1393      1.15   mycroft 	return (allerror);
   1394       1.1   mycroft }
   1395