160727d8bSWarner Losh /*- 2df8bae1dSRodney W. Grimes * Copyright (c) 1989, 1991, 1993, 1994 3df8bae1dSRodney W. Grimes * The Regents of the University of California. All rights reserved. 4df8bae1dSRodney W. Grimes * 5df8bae1dSRodney W. Grimes * Redistribution and use in source and binary forms, with or without 6df8bae1dSRodney W. Grimes * modification, are permitted provided that the following conditions 7df8bae1dSRodney W. Grimes * are met: 8df8bae1dSRodney W. Grimes * 1. Redistributions of source code must retain the above copyright 9df8bae1dSRodney W. Grimes * notice, this list of conditions and the following disclaimer. 10df8bae1dSRodney W. Grimes * 2. Redistributions in binary form must reproduce the above copyright 11df8bae1dSRodney W. Grimes * notice, this list of conditions and the following disclaimer in the 12df8bae1dSRodney W. Grimes * documentation and/or other materials provided with the distribution. 13df8bae1dSRodney W. Grimes * 4. Neither the name of the University nor the names of its contributors 14df8bae1dSRodney W. Grimes * may be used to endorse or promote products derived from this software 15df8bae1dSRodney W. Grimes * without specific prior written permission. 16df8bae1dSRodney W. Grimes * 17df8bae1dSRodney W. Grimes * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 18df8bae1dSRodney W. Grimes * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 19df8bae1dSRodney W. Grimes * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 20df8bae1dSRodney W. Grimes * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 21df8bae1dSRodney W. Grimes * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22df8bae1dSRodney W. Grimes * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 23df8bae1dSRodney W. Grimes * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 24df8bae1dSRodney W. Grimes * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 25df8bae1dSRodney W. Grimes * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 26df8bae1dSRodney W. Grimes * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 27df8bae1dSRodney W. Grimes * SUCH DAMAGE. 28df8bae1dSRodney W. Grimes * 29996c772fSJohn Dyson * @(#)ffs_vfsops.c 8.31 (Berkeley) 5/20/95 30df8bae1dSRodney W. Grimes */ 31df8bae1dSRodney W. Grimes 32f4636c59SDavid E. O'Brien #include <sys/cdefs.h> 33f4636c59SDavid E. O'Brien __FBSDID("$FreeBSD$"); 34f4636c59SDavid E. O'Brien 3580830407SRobert Watson #include "opt_mac.h" 3601733a9bSGarrett Wollman #include "opt_quota.h" 37516081f2SRobert Watson #include "opt_ufs.h" 386e77a041SPoul-Henning Kamp #include "opt_ffs.h" 3901733a9bSGarrett Wollman 40df8bae1dSRodney W. Grimes #include <sys/param.h> 41df8bae1dSRodney W. Grimes #include <sys/systm.h> 42df8bae1dSRodney W. Grimes #include <sys/namei.h> 43df8bae1dSRodney W. Grimes #include <sys/proc.h> 44df8bae1dSRodney W. Grimes #include <sys/kernel.h> 45763bbd2fSRobert Watson #include <sys/mac.h> 46df8bae1dSRodney W. Grimes #include <sys/vnode.h> 47df8bae1dSRodney W. Grimes #include <sys/mount.h> 489626b608SPoul-Henning Kamp #include <sys/bio.h> 49df8bae1dSRodney W. Grimes #include <sys/buf.h> 5081bca6ddSKATO Takenori #include <sys/conf.h> 513ac4d1efSBruce Evans #include <sys/fcntl.h> 52df8bae1dSRodney W. Grimes #include <sys/malloc.h> 531b367556SJason Evans #include <sys/mutex.h> 54a18b1f1dSJason Evans 55a64ed089SRobert Watson #include <ufs/ufs/extattr.h> 56df8bae1dSRodney W. Grimes #include <ufs/ufs/quota.h> 57df8bae1dSRodney W. Grimes #include <ufs/ufs/ufsmount.h> 58df8bae1dSRodney W. Grimes #include <ufs/ufs/inode.h> 59df8bae1dSRodney W. Grimes #include <ufs/ufs/ufs_extern.h> 60df8bae1dSRodney W. Grimes 61df8bae1dSRodney W. Grimes #include <ufs/ffs/fs.h> 62df8bae1dSRodney W. Grimes #include <ufs/ffs/ffs_extern.h> 63df8bae1dSRodney W. Grimes 64f6b04d2bSDavid Greenman #include <vm/vm.h> 65aa4d7a8aSPoul-Henning Kamp #include <vm/uma.h> 66f6b04d2bSDavid Greenman #include <vm/vm_page.h> 67f6b04d2bSDavid Greenman 6843920011SPoul-Henning Kamp #include <geom/geom.h> 6943920011SPoul-Henning Kamp #include <geom/geom_vfs.h> 7043920011SPoul-Henning Kamp 71adf41577SPoul-Henning Kamp static uma_zone_t uma_inode, uma_ufs1, uma_ufs2; 7255166637SPoul-Henning Kamp 736f1e8551SAlfred Perlstein static int ffs_sbupdate(struct ufsmount *, int); 745e8c582aSPoul-Henning Kamp static int ffs_reload(struct mount *, struct thread *); 75975512a9SPoul-Henning Kamp static int ffs_mountfs(struct vnode *, struct mount *, struct thread *); 761c85e6a3SKirk McKusick static void ffs_oldfscompat_read(struct fs *, struct ufsmount *, 771c85e6a3SKirk McKusick ufs2_daddr_t); 781c85e6a3SKirk McKusick static void ffs_oldfscompat_write(struct fs *, struct ufsmount *); 79975512a9SPoul-Henning Kamp static void ffs_ifree(struct ufsmount *ump, struct inode *ip); 809bf1a756SPoul-Henning Kamp static vfs_init_t ffs_init; 819bf1a756SPoul-Henning Kamp static vfs_uninit_t ffs_uninit; 82d6fe88e4SPoul-Henning Kamp static vfs_extattrctl_t ffs_extattrctl; 8320a92a18SPoul-Henning Kamp static vfs_cmount_t ffs_cmount; 84adf41577SPoul-Henning Kamp static vfs_unmount_t ffs_unmount; 8520a92a18SPoul-Henning Kamp static vfs_mount_t ffs_mount; 86adf41577SPoul-Henning Kamp static vfs_statfs_t ffs_statfs; 87adf41577SPoul-Henning Kamp static vfs_fhtovp_t ffs_fhtovp; 88adf41577SPoul-Henning Kamp static vfs_vptofh_t ffs_vptofh; 89adf41577SPoul-Henning Kamp static vfs_sync_t ffs_sync; 90df8bae1dSRodney W. Grimes 91303b270bSEivind Eklund static struct vfsops ufs_vfsops = { 927652131bSPoul-Henning Kamp .vfs_extattrctl = ffs_extattrctl, 937652131bSPoul-Henning Kamp .vfs_fhtovp = ffs_fhtovp, 947652131bSPoul-Henning Kamp .vfs_init = ffs_init, 9520a92a18SPoul-Henning Kamp .vfs_mount = ffs_mount, 9620a92a18SPoul-Henning Kamp .vfs_cmount = ffs_cmount, 977652131bSPoul-Henning Kamp .vfs_quotactl = ufs_quotactl, 987652131bSPoul-Henning Kamp .vfs_root = ufs_root, 997652131bSPoul-Henning Kamp .vfs_statfs = ffs_statfs, 1007652131bSPoul-Henning Kamp .vfs_sync = ffs_sync, 1017652131bSPoul-Henning Kamp .vfs_uninit = ffs_uninit, 1027652131bSPoul-Henning Kamp .vfs_unmount = ffs_unmount, 1037652131bSPoul-Henning Kamp .vfs_vget = ffs_vget, 1047652131bSPoul-Henning Kamp .vfs_vptofh = ffs_vptofh, 105df8bae1dSRodney W. Grimes }; 106df8bae1dSRodney W. Grimes 1078994ca3cSBruce Evans VFS_SET(ufs_vfsops, ufs, 0); 108c901836cSGarrett Wollman 1096e77a041SPoul-Henning Kamp static b_strategy_t ffs_geom_strategy; 110dd19a799SPoul-Henning Kamp static b_write_t ffs_bufwrite; 1116e77a041SPoul-Henning Kamp 1126e77a041SPoul-Henning Kamp static struct buf_ops ffs_ops = { 1136e77a041SPoul-Henning Kamp .bop_name = "FFS", 114dd19a799SPoul-Henning Kamp .bop_write = ffs_bufwrite, 1156e77a041SPoul-Henning Kamp .bop_strategy = ffs_geom_strategy, 1166ef8480aSPoul-Henning Kamp .bop_sync = bufsync, 1176e77a041SPoul-Henning Kamp }; 1186e77a041SPoul-Henning Kamp 11926f59b64SCraig Rodrigues static const char *ffs_opts[] = { "acls", "async", "errmsg", "export", 120359d4388SCraig Rodrigues "force", "from", "multilabel", "noasync", "noatime", "noclusterr", 121359d4388SCraig Rodrigues "noclusterw", "noexec", "nosuid", "nosymfollow", "snapshot", "sync", 122359d4388SCraig Rodrigues "suiddir", "update", "union", NULL }; 12320a92a18SPoul-Henning Kamp 1245e8c582aSPoul-Henning Kamp static int 12520a92a18SPoul-Henning Kamp ffs_mount(struct mount *mp, struct thread *td) 126df8bae1dSRodney W. Grimes { 12720a92a18SPoul-Henning Kamp struct vnode *devvp; 12826f9a767SRodney W. Grimes struct ufsmount *ump = 0; 12905f4ff5dSPoul-Henning Kamp struct fs *fs; 130f2a2857bSKirk McKusick int error, flags; 131c9b99213SBruce Evans mode_t accessmode; 1325e8c582aSPoul-Henning Kamp struct nameidata ndp; 133f21cc2caSPoul-Henning Kamp struct export_args export; 13420a92a18SPoul-Henning Kamp char *fspec; 135df8bae1dSRodney W. Grimes 13620a92a18SPoul-Henning Kamp if (vfs_filteropt(mp->mnt_optnew, ffs_opts)) 13720a92a18SPoul-Henning Kamp return (EINVAL); 138aa4d7a8aSPoul-Henning Kamp if (uma_inode == NULL) { 139aa4d7a8aSPoul-Henning Kamp uma_inode = uma_zcreate("FFS inode", 140aa4d7a8aSPoul-Henning Kamp sizeof(struct inode), NULL, NULL, NULL, NULL, 141aa4d7a8aSPoul-Henning Kamp UMA_ALIGN_PTR, 0); 142aa4d7a8aSPoul-Henning Kamp uma_ufs1 = uma_zcreate("FFS1 dinode", 143aa4d7a8aSPoul-Henning Kamp sizeof(struct ufs1_dinode), NULL, NULL, NULL, NULL, 144aa4d7a8aSPoul-Henning Kamp UMA_ALIGN_PTR, 0); 145aa4d7a8aSPoul-Henning Kamp uma_ufs2 = uma_zcreate("FFS2 dinode", 146aa4d7a8aSPoul-Henning Kamp sizeof(struct ufs2_dinode), NULL, NULL, NULL, NULL, 147aa4d7a8aSPoul-Henning Kamp UMA_ALIGN_PTR, 0); 148aa4d7a8aSPoul-Henning Kamp } 1498d02a378SPawel Jakub Dawidek 15020a92a18SPoul-Henning Kamp fspec = vfs_getopts(mp->mnt_optnew, "from", &error); 15151ac12abSPoul-Henning Kamp if (error) 152f2a2857bSKirk McKusick return (error); 1532b14f991SJulian Elischer 15426f59b64SCraig Rodrigues if (vfs_getopt(mp->mnt_optnew, "acls", NULL, NULL) == 0) 15526f59b64SCraig Rodrigues mp->mnt_flag |= MNT_ACLS; 15626f59b64SCraig Rodrigues 15726f59b64SCraig Rodrigues if (vfs_getopt(mp->mnt_optnew, "async", NULL, NULL) == 0) 15826f59b64SCraig Rodrigues mp->mnt_flag |= MNT_ASYNC; 15926f59b64SCraig Rodrigues 16026f59b64SCraig Rodrigues if (vfs_getopt(mp->mnt_optnew, "force", NULL, NULL) == 0) 16126f59b64SCraig Rodrigues mp->mnt_flag |= MNT_FORCE; 16226f59b64SCraig Rodrigues 16326f59b64SCraig Rodrigues if (vfs_getopt(mp->mnt_optnew, "multilabel", NULL, NULL) == 0) 16426f59b64SCraig Rodrigues mp->mnt_flag |= MNT_MULTILABEL; 16526f59b64SCraig Rodrigues 16626f59b64SCraig Rodrigues if (vfs_getopt(mp->mnt_optnew, "noasync", NULL, NULL) == 0) 16726f59b64SCraig Rodrigues mp->mnt_flag &= ~MNT_ASYNC; 16826f59b64SCraig Rodrigues 16926f59b64SCraig Rodrigues if (vfs_getopt(mp->mnt_optnew, "noatime", NULL, NULL) == 0) 17026f59b64SCraig Rodrigues mp->mnt_flag |= MNT_NOATIME; 17126f59b64SCraig Rodrigues 17226f59b64SCraig Rodrigues if (vfs_getopt(mp->mnt_optnew, "noclusterr", NULL, NULL) == 0) 17326f59b64SCraig Rodrigues mp->mnt_flag |= MNT_NOCLUSTERR; 17426f59b64SCraig Rodrigues 17526f59b64SCraig Rodrigues if (vfs_getopt(mp->mnt_optnew, "noclusterw", NULL, NULL) == 0) 17626f59b64SCraig Rodrigues mp->mnt_flag |= MNT_NOCLUSTERW; 17726f59b64SCraig Rodrigues 17826f59b64SCraig Rodrigues if (vfs_getopt(mp->mnt_optnew, "snapshot", NULL, NULL) == 0) 17926f59b64SCraig Rodrigues mp->mnt_flag |= MNT_SNAPSHOT; 18026f59b64SCraig Rodrigues 18126f59b64SCraig Rodrigues if (vfs_getopt(mp->mnt_optnew, "update", NULL, NULL) == 0) 18226f59b64SCraig Rodrigues mp->mnt_flag |= MNT_UPDATE; 18326f59b64SCraig Rodrigues 184cea90362SCraig Rodrigues export.ex_root = -2; /* DEFAULT_ROOTID */ 185cea90362SCraig Rodrigues 186cea90362SCraig Rodrigues if (mp->mnt_flag & MNT_RDONLY) 187cea90362SCraig Rodrigues export.ex_flags = MNT_EXRDONLY; 188cea90362SCraig Rodrigues else 189cea90362SCraig Rodrigues export.ex_flags = 0; 190cea90362SCraig Rodrigues 191df8bae1dSRodney W. Grimes /* 192df8bae1dSRodney W. Grimes * If updating, check whether changing from read-only to 193df8bae1dSRodney W. Grimes * read/write; if there is no device name, that's all we do. 194df8bae1dSRodney W. Grimes */ 195df8bae1dSRodney W. Grimes if (mp->mnt_flag & MNT_UPDATE) { 196df8bae1dSRodney W. Grimes ump = VFSTOUFS(mp); 197df8bae1dSRodney W. Grimes fs = ump->um_fs; 19826cf9c3bSPeter Wemm devvp = ump->um_devvp; 19920a92a18SPoul-Henning Kamp if (fs->fs_ronly == 0 && 20020a92a18SPoul-Henning Kamp vfs_flagopt(mp->mnt_optnew, "ro", NULL, 0)) { 201f2a2857bSKirk McKusick if ((error = vn_start_write(NULL, &mp, V_WAIT)) != 0) 202f2a2857bSKirk McKusick return (error); 203cd600596SKirk McKusick /* 204cd600596SKirk McKusick * Flush any dirty data. 205cd600596SKirk McKusick */ 206efd6d980SPoul-Henning Kamp if ((error = ffs_sync(mp, MNT_WAIT, td)) != 0) { 2079ab73fd1SKirk McKusick vn_finished_write(mp); 2089ab73fd1SKirk McKusick return (error); 2099ab73fd1SKirk McKusick } 210cd600596SKirk McKusick /* 211cd600596SKirk McKusick * Check for and optionally get rid of files open 212cd600596SKirk McKusick * for writing. 213cd600596SKirk McKusick */ 214df8bae1dSRodney W. Grimes flags = WRITECLOSE; 215df8bae1dSRodney W. Grimes if (mp->mnt_flag & MNT_FORCE) 216df8bae1dSRodney W. Grimes flags |= FORCECLOSE; 217b1897c19SJulian Elischer if (mp->mnt_flag & MNT_SOFTDEP) { 218b40ce416SJulian Elischer error = softdep_flushfiles(mp, flags, td); 219b1897c19SJulian Elischer } else { 220b40ce416SJulian Elischer error = ffs_flushfiles(mp, flags, td); 221df8bae1dSRodney W. Grimes } 222f2a2857bSKirk McKusick if (error) { 223f2a2857bSKirk McKusick vn_finished_write(mp); 224f2a2857bSKirk McKusick return (error); 225b1897c19SJulian Elischer } 2269ccb939eSKirk McKusick if (fs->fs_pendingblocks != 0 || 2279ccb939eSKirk McKusick fs->fs_pendinginodes != 0) { 228cfbf0a46SMaxime Henrion printf("%s: %s: blocks %jd files %d\n", 2291c85e6a3SKirk McKusick fs->fs_fsmnt, "update error", 2301c85e6a3SKirk McKusick (intmax_t)fs->fs_pendingblocks, 2319ccb939eSKirk McKusick fs->fs_pendinginodes); 2329ccb939eSKirk McKusick fs->fs_pendingblocks = 0; 2339ccb939eSKirk McKusick fs->fs_pendinginodes = 0; 2349ccb939eSKirk McKusick } 2351a6a6610SKirk McKusick if ((fs->fs_flags & (FS_UNCLEAN | FS_NEEDSFSCK)) == 0) 236f2a2857bSKirk McKusick fs->fs_clean = 1; 237f2a2857bSKirk McKusick if ((error = ffs_sbupdate(ump, MNT_WAIT)) != 0) { 238f2a2857bSKirk McKusick fs->fs_ronly = 0; 239f2a2857bSKirk McKusick fs->fs_clean = 0; 240f2a2857bSKirk McKusick vn_finished_write(mp); 241f2a2857bSKirk McKusick return (error); 2422b14f991SJulian Elischer } 243f2a2857bSKirk McKusick vn_finished_write(mp); 24443920011SPoul-Henning Kamp DROP_GIANT(); 24543920011SPoul-Henning Kamp g_topology_lock(); 24643920011SPoul-Henning Kamp g_access(ump->um_cp, 0, -1, 0); 24743920011SPoul-Henning Kamp g_topology_unlock(); 24843920011SPoul-Henning Kamp PICKUP_GIANT(); 24920a92a18SPoul-Henning Kamp fs->fs_ronly = 1; 25020a92a18SPoul-Henning Kamp mp->mnt_flag |= MNT_RDONLY; 251f2a2857bSKirk McKusick } 252f2a2857bSKirk McKusick if ((mp->mnt_flag & MNT_RELOAD) && 2535e8c582aSPoul-Henning Kamp (error = ffs_reload(mp, td)) != 0) 254f2a2857bSKirk McKusick return (error); 25520a92a18SPoul-Henning Kamp if (fs->fs_ronly && 25620a92a18SPoul-Henning Kamp !vfs_flagopt(mp->mnt_optnew, "ro", NULL, 0)) { 257c9b99213SBruce Evans /* 258c9b99213SBruce Evans * If upgrade to read-write by non-root, then verify 259c9b99213SBruce Evans * that user has necessary permissions on the device. 260c9b99213SBruce Evans */ 26144731cabSJohn Baldwin if (suser(td)) { 262b40ce416SJulian Elischer vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, td); 2638aef1712SMatthew Dillon if ((error = VOP_ACCESS(devvp, VREAD | VWRITE, 264a854ed98SJohn Baldwin td->td_ucred, td)) != 0) { 265b40ce416SJulian Elischer VOP_UNLOCK(devvp, 0, td); 266c9b99213SBruce Evans return (error); 267c9b99213SBruce Evans } 268b40ce416SJulian Elischer VOP_UNLOCK(devvp, 0, td); 269c9b99213SBruce Evans } 2707e58bfacSBruce Evans fs->fs_flags &= ~FS_UNCLEAN; 2710922cce6SBruce Evans if (fs->fs_clean == 0) { 2727e58bfacSBruce Evans fs->fs_flags |= FS_UNCLEAN; 273812b1d41SKirk McKusick if ((mp->mnt_flag & MNT_FORCE) || 2741a6a6610SKirk McKusick ((fs->fs_flags & FS_NEEDSFSCK) == 0 && 2751a6a6610SKirk McKusick (fs->fs_flags & FS_DOSOFTDEP))) { 276f2a2857bSKirk McKusick printf("WARNING: %s was not %s\n", 277f2a2857bSKirk McKusick fs->fs_fsmnt, "properly dismounted"); 2780922cce6SBruce Evans } else { 2790922cce6SBruce Evans printf( 2800922cce6SBruce Evans "WARNING: R/W mount of %s denied. Filesystem is not clean - run fsck\n", 2810922cce6SBruce Evans fs->fs_fsmnt); 282f2a2857bSKirk McKusick return (EPERM); 2830922cce6SBruce Evans } 2840922cce6SBruce Evans } 28540c340aaSPoul-Henning Kamp DROP_GIANT(); 28640c340aaSPoul-Henning Kamp g_topology_lock(); 28740c340aaSPoul-Henning Kamp /* 28840c340aaSPoul-Henning Kamp * If we're the root device, we may not have an E count 28940c340aaSPoul-Henning Kamp * yet, get it now. 29040c340aaSPoul-Henning Kamp */ 29140c340aaSPoul-Henning Kamp if (ump->um_cp->ace == 0) 29240c340aaSPoul-Henning Kamp error = g_access(ump->um_cp, 0, 1, 1); 29340c340aaSPoul-Henning Kamp else 29440c340aaSPoul-Henning Kamp error = g_access(ump->um_cp, 0, 1, 0); 29540c340aaSPoul-Henning Kamp g_topology_unlock(); 29640c340aaSPoul-Henning Kamp PICKUP_GIANT(); 29740c340aaSPoul-Henning Kamp if (error) 29840c340aaSPoul-Henning Kamp return (error); 299f2a2857bSKirk McKusick if ((error = vn_start_write(NULL, &mp, V_WAIT)) != 0) 300f2a2857bSKirk McKusick return (error); 301f2a2857bSKirk McKusick fs->fs_ronly = 0; 30220a92a18SPoul-Henning Kamp mp->mnt_flag &= ~MNT_RDONLY; 303f2a2857bSKirk McKusick fs->fs_clean = 0; 304f2a2857bSKirk McKusick if ((error = ffs_sbupdate(ump, MNT_WAIT)) != 0) { 305f2a2857bSKirk McKusick vn_finished_write(mp); 306f2a2857bSKirk McKusick return (error); 307f2a2857bSKirk McKusick } 30826cf9c3bSPeter Wemm /* check to see if we need to start softdep */ 309f2a2857bSKirk McKusick if ((fs->fs_flags & FS_DOSOFTDEP) && 310a854ed98SJohn Baldwin (error = softdep_mount(devvp, mp, fs, td->td_ucred))){ 311f2a2857bSKirk McKusick vn_finished_write(mp); 312f2a2857bSKirk McKusick return (error); 31326cf9c3bSPeter Wemm } 314f2a2857bSKirk McKusick if (fs->fs_snapinum[0] != 0) 315f2a2857bSKirk McKusick ffs_snapshot_mount(mp); 316f2a2857bSKirk McKusick vn_finished_write(mp); 3171469eec8SDavid Greenman } 318c11d2981SJulian Elischer /* 319c11d2981SJulian Elischer * Soft updates is incompatible with "async", 320c11d2981SJulian Elischer * so if we are doing softupdates stop the user 321c11d2981SJulian Elischer * from setting the async flag in an update. 322c11d2981SJulian Elischer * Softdep_mount() clears it in an initial mount 323c11d2981SJulian Elischer * or ro->rw remount. 324c11d2981SJulian Elischer */ 325f2a2857bSKirk McKusick if (mp->mnt_flag & MNT_SOFTDEP) 326c11d2981SJulian Elischer mp->mnt_flag &= ~MNT_ASYNC; 327df8bae1dSRodney W. Grimes /* 32839cfb239SPawel Jakub Dawidek * Keep MNT_ACLS flag if it is stored in superblock. 32939cfb239SPawel Jakub Dawidek */ 33039cfb239SPawel Jakub Dawidek if ((fs->fs_flags & FS_ACLS) != 0) 33139cfb239SPawel Jakub Dawidek mp->mnt_flag |= MNT_ACLS; 33239cfb239SPawel Jakub Dawidek /* 333f2a2857bSKirk McKusick * If not updating name, process export requests. 334df8bae1dSRodney W. Grimes */ 335cea90362SCraig Rodrigues error = 0; 336cea90362SCraig Rodrigues if (vfs_getopt(mp->mnt_optnew, "export", NULL, NULL) == 0) { 337cea90362SCraig Rodrigues error = vfs_copyopt(mp->mnt_optnew, "export", 338cea90362SCraig Rodrigues &export, sizeof export); 339cea90362SCraig Rodrigues } 340cea90362SCraig Rodrigues 341f21cc2caSPoul-Henning Kamp if (error == 0 && export.ex_flags != 0) 342f21cc2caSPoul-Henning Kamp return (vfs_export(mp, &export)); 343f2a2857bSKirk McKusick /* 344f2a2857bSKirk McKusick * If this is a snapshot request, take the snapshot. 345f2a2857bSKirk McKusick */ 346f2a2857bSKirk McKusick if (mp->mnt_flag & MNT_SNAPSHOT) 34720a92a18SPoul-Henning Kamp return (ffs_snapshot(mp, fspec)); 348df8bae1dSRodney W. Grimes } 3492b14f991SJulian Elischer 350df8bae1dSRodney W. Grimes /* 351df8bae1dSRodney W. Grimes * Not an update, or updating the name: look up the name 352e9827c6dSBruce Evans * and verify that it refers to a sensible disk device. 353df8bae1dSRodney W. Grimes */ 354fdedad76SSuleiman Souhlal NDINIT(&ndp, LOOKUP, FOLLOW | LOCKLEAF, UIO_SYSSPACE, fspec, td); 3555e8c582aSPoul-Henning Kamp if ((error = namei(&ndp)) != 0) 356f2a2857bSKirk McKusick return (error); 3575e8c582aSPoul-Henning Kamp NDFREE(&ndp, NDF_ONLY_PNBUF); 3585e8c582aSPoul-Henning Kamp devvp = ndp.ni_vp; 359f2a2857bSKirk McKusick if (!vn_isdisk(devvp, &error)) { 360fdedad76SSuleiman Souhlal vput(devvp); 361f2a2857bSKirk McKusick return (error); 362f2a2857bSKirk McKusick } 363c9b99213SBruce Evans 364c9b99213SBruce Evans /* 365c9b99213SBruce Evans * If mount by non-root, then verify that user has necessary 366c9b99213SBruce Evans * permissions on the device. 367c9b99213SBruce Evans */ 36844731cabSJohn Baldwin if (suser(td)) { 369c9b99213SBruce Evans accessmode = VREAD; 370c9b99213SBruce Evans if ((mp->mnt_flag & MNT_RDONLY) == 0) 371c9b99213SBruce Evans accessmode |= VWRITE; 372a854ed98SJohn Baldwin if ((error = VOP_ACCESS(devvp, accessmode, td->td_ucred, td))!= 0){ 373c9b99213SBruce Evans vput(devvp); 374c9b99213SBruce Evans return (error); 375c9b99213SBruce Evans } 376c9b99213SBruce Evans } 377c9b99213SBruce Evans 3782b14f991SJulian Elischer if (mp->mnt_flag & MNT_UPDATE) { 3792b14f991SJulian Elischer /* 380f2a2857bSKirk McKusick * Update only 381f2a2857bSKirk McKusick * 3823e425b96SJulian Elischer * If it's not the same vnode, or at least the same device 3833e425b96SJulian Elischer * then it's not correct. 3842b14f991SJulian Elischer */ 3852b14f991SJulian Elischer 38643920011SPoul-Henning Kamp if (devvp->v_rdev != ump->um_devvp->v_rdev) 387f2a2857bSKirk McKusick error = EINVAL; /* needs translation */ 388fdedad76SSuleiman Souhlal vput(devvp); 389f2a2857bSKirk McKusick if (error) 390f2a2857bSKirk McKusick return (error); 3912b14f991SJulian Elischer } else { 3922b14f991SJulian Elischer /* 393f2a2857bSKirk McKusick * New mount 3942b14f991SJulian Elischer * 395f2a2857bSKirk McKusick * We need the name for the mount point (also used for 396f2a2857bSKirk McKusick * "last mounted on") copied in. If an error occurs, 397f2a2857bSKirk McKusick * the mount point is discarded by the upper level code. 398f3a90da9SAdrian Chadd * Note that vfs_mount() populates f_mntonname for us. 399f2a2857bSKirk McKusick */ 400975512a9SPoul-Henning Kamp if ((error = ffs_mountfs(devvp, mp, td)) != 0) { 401f2a2857bSKirk McKusick vrele(devvp); 402f2a2857bSKirk McKusick return (error); 403f2a2857bSKirk McKusick } 404f2a2857bSKirk McKusick } 40520a92a18SPoul-Henning Kamp vfs_mountedfrom(mp, fspec); 406f2a2857bSKirk McKusick return (0); 4072b14f991SJulian Elischer } 4082b14f991SJulian Elischer 409df8bae1dSRodney W. Grimes /* 41020a92a18SPoul-Henning Kamp * Compatibility with old mount system call. 41120a92a18SPoul-Henning Kamp */ 41220a92a18SPoul-Henning Kamp 41320a92a18SPoul-Henning Kamp static int 41420a92a18SPoul-Henning Kamp ffs_cmount(struct mntarg *ma, void *data, int flags, struct thread *td) 41520a92a18SPoul-Henning Kamp { 41620a92a18SPoul-Henning Kamp struct ufs_args args; 41720a92a18SPoul-Henning Kamp int error; 41820a92a18SPoul-Henning Kamp 41920a92a18SPoul-Henning Kamp if (data == NULL) 42020a92a18SPoul-Henning Kamp return (EINVAL); 42120a92a18SPoul-Henning Kamp error = copyin(data, &args, sizeof args); 42220a92a18SPoul-Henning Kamp if (error) 42320a92a18SPoul-Henning Kamp return (error); 42420a92a18SPoul-Henning Kamp 42520a92a18SPoul-Henning Kamp ma = mount_argsu(ma, "from", args.fspec, MAXPATHLEN); 42620a92a18SPoul-Henning Kamp ma = mount_arg(ma, "export", &args.export, sizeof args.export); 42720a92a18SPoul-Henning Kamp error = kernel_mount(ma, flags); 42820a92a18SPoul-Henning Kamp 42920a92a18SPoul-Henning Kamp return (error); 43020a92a18SPoul-Henning Kamp } 43120a92a18SPoul-Henning Kamp 43220a92a18SPoul-Henning Kamp /* 433df8bae1dSRodney W. Grimes * Reload all incore data for a filesystem (used after running fsck on 434df8bae1dSRodney W. Grimes * the root filesystem and finding things to fix). The filesystem must 435df8bae1dSRodney W. Grimes * be mounted read-only. 436df8bae1dSRodney W. Grimes * 437df8bae1dSRodney W. Grimes * Things to do to update the mount: 438df8bae1dSRodney W. Grimes * 1) invalidate all cached meta-data. 439df8bae1dSRodney W. Grimes * 2) re-read superblock from disk. 440df8bae1dSRodney W. Grimes * 3) re-read summary information from disk. 441df8bae1dSRodney W. Grimes * 4) invalidate all inactive vnodes. 442df8bae1dSRodney W. Grimes * 5) invalidate all cached file data. 443df8bae1dSRodney W. Grimes * 6) re-read inode data for all active vnodes. 444df8bae1dSRodney W. Grimes */ 4455e8c582aSPoul-Henning Kamp static int 4465e8c582aSPoul-Henning Kamp ffs_reload(struct mount *mp, struct thread *td) 447df8bae1dSRodney W. Grimes { 44805f4ff5dSPoul-Henning Kamp struct vnode *vp, *nvp, *devvp; 449df8bae1dSRodney W. Grimes struct inode *ip; 450f55ff3f3SIan Dowse void *space; 451df8bae1dSRodney W. Grimes struct buf *bp; 452996c772fSJohn Dyson struct fs *fs, *newfs; 4533ba649d7SJeff Roberson struct ufsmount *ump; 4541c85e6a3SKirk McKusick ufs2_daddr_t sblockloc; 455df8bae1dSRodney W. Grimes int i, blks, size, error; 456996c772fSJohn Dyson int32_t *lp; 457df8bae1dSRodney W. Grimes 4582b14f991SJulian Elischer if ((mp->mnt_flag & MNT_RDONLY) == 0) 459df8bae1dSRodney W. Grimes return (EINVAL); 4603ba649d7SJeff Roberson ump = VFSTOUFS(mp); 461df8bae1dSRodney W. Grimes /* 462df8bae1dSRodney W. Grimes * Step 1: invalidate all cached meta-data. 463df8bae1dSRodney W. Grimes */ 4642b14f991SJulian Elischer devvp = VFSTOUFS(mp)->um_devvp; 465b40ce416SJulian Elischer vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, td); 4667c0745eeSPoul-Henning Kamp if (vinvalbuf(devvp, 0, td, 0, 0) != 0) 467df8bae1dSRodney W. Grimes panic("ffs_reload: dirty1"); 46804a17687SJeff Roberson VOP_UNLOCK(devvp, 0, td); 46995e5e988SJohn Dyson 470df8bae1dSRodney W. Grimes /* 471df8bae1dSRodney W. Grimes * Step 2: re-read superblock from disk. 472df8bae1dSRodney W. Grimes */ 4731c85e6a3SKirk McKusick fs = VFSTOUFS(mp)->um_fs; 474ada981b2SKirk McKusick if ((error = bread(devvp, btodb(fs->fs_sblockloc), fs->fs_sbsize, 4751c85e6a3SKirk McKusick NOCRED, &bp)) != 0) 476df8bae1dSRodney W. Grimes return (error); 477996c772fSJohn Dyson newfs = (struct fs *)bp->b_data; 4781c85e6a3SKirk McKusick if ((newfs->fs_magic != FS_UFS1_MAGIC && 4791c85e6a3SKirk McKusick newfs->fs_magic != FS_UFS2_MAGIC) || 4801c85e6a3SKirk McKusick newfs->fs_bsize > MAXBSIZE || 481996c772fSJohn Dyson newfs->fs_bsize < sizeof(struct fs)) { 482df8bae1dSRodney W. Grimes brelse(bp); 483df8bae1dSRodney W. Grimes return (EIO); /* XXX needs translation */ 484df8bae1dSRodney W. Grimes } 485996c772fSJohn Dyson /* 486996c772fSJohn Dyson * Copy pointer fields back into superblock before copying in XXX 487996c772fSJohn Dyson * new superblock. These should really be in the ufsmount. XXX 488996c772fSJohn Dyson * Note that important parameters (eg fs_ncg) are unchanged. 489996c772fSJohn Dyson */ 490f55ff3f3SIan Dowse newfs->fs_csp = fs->fs_csp; 491996c772fSJohn Dyson newfs->fs_maxcluster = fs->fs_maxcluster; 4925d69bac4SIan Dowse newfs->fs_contigdirs = fs->fs_contigdirs; 493143a5346SIan Dowse newfs->fs_active = fs->fs_active; 49431c81e4bSDon Lewis /* The file system is still read-only. */ 49531c81e4bSDon Lewis newfs->fs_ronly = 1; 4961c85e6a3SKirk McKusick sblockloc = fs->fs_sblockloc; 497996c772fSJohn Dyson bcopy(newfs, fs, (u_int)fs->fs_sbsize); 498df8bae1dSRodney W. Grimes brelse(bp); 499996c772fSJohn Dyson mp->mnt_maxsymlinklen = fs->fs_maxsymlinklen; 5001c85e6a3SKirk McKusick ffs_oldfscompat_read(fs, VFSTOUFS(mp), sblockloc); 5013ba649d7SJeff Roberson UFS_LOCK(ump); 5029ccb939eSKirk McKusick if (fs->fs_pendingblocks != 0 || fs->fs_pendinginodes != 0) { 503cfbf0a46SMaxime Henrion printf("%s: reload pending error: blocks %jd files %d\n", 5041c85e6a3SKirk McKusick fs->fs_fsmnt, (intmax_t)fs->fs_pendingblocks, 5051c85e6a3SKirk McKusick fs->fs_pendinginodes); 5069ccb939eSKirk McKusick fs->fs_pendingblocks = 0; 5079ccb939eSKirk McKusick fs->fs_pendinginodes = 0; 5089ccb939eSKirk McKusick } 5093ba649d7SJeff Roberson UFS_UNLOCK(ump); 510996c772fSJohn Dyson 511df8bae1dSRodney W. Grimes /* 512df8bae1dSRodney W. Grimes * Step 3: re-read summary information from disk. 513df8bae1dSRodney W. Grimes */ 514df8bae1dSRodney W. Grimes blks = howmany(fs->fs_cssize, fs->fs_fsize); 515f55ff3f3SIan Dowse space = fs->fs_csp; 516df8bae1dSRodney W. Grimes for (i = 0; i < blks; i += fs->fs_frag) { 517df8bae1dSRodney W. Grimes size = fs->fs_bsize; 518df8bae1dSRodney W. Grimes if (i + fs->fs_frag > blks) 519df8bae1dSRodney W. Grimes size = (blks - i) * fs->fs_fsize; 520c9671602SPoul-Henning Kamp error = bread(devvp, fsbtodb(fs, fs->fs_csaddr + i), size, 521c9671602SPoul-Henning Kamp NOCRED, &bp); 522c9671602SPoul-Henning Kamp if (error) 523df8bae1dSRodney W. Grimes return (error); 524f55ff3f3SIan Dowse bcopy(bp->b_data, space, (u_int)size); 525f55ff3f3SIan Dowse space = (char *)space + size; 526df8bae1dSRodney W. Grimes brelse(bp); 527df8bae1dSRodney W. Grimes } 528996c772fSJohn Dyson /* 529996c772fSJohn Dyson * We no longer know anything about clusters per cylinder group. 530996c772fSJohn Dyson */ 531996c772fSJohn Dyson if (fs->fs_contigsumsize > 0) { 532996c772fSJohn Dyson lp = fs->fs_maxcluster; 533996c772fSJohn Dyson for (i = 0; i < fs->fs_ncg; i++) 534996c772fSJohn Dyson *lp++ = fs->fs_contigsumsize; 535996c772fSJohn Dyson } 536996c772fSJohn Dyson 537df8bae1dSRodney W. Grimes loop: 538ca430f2eSAlexander Kabaev MNT_ILOCK(mp); 539e3c5a7a4SPoul-Henning Kamp MNT_VNODE_FOREACH(vp, mp, nvp) { 54004a17687SJeff Roberson VI_LOCK(vp); 541fe68abe2SJeff Roberson if (vp->v_iflag & VI_DOOMED) { 5422f05568aSJeff Roberson VI_UNLOCK(vp); 5432f05568aSJeff Roberson continue; 5442f05568aSJeff Roberson } 545ca430f2eSAlexander Kabaev MNT_IUNLOCK(mp); 546df8bae1dSRodney W. Grimes /* 547fe68abe2SJeff Roberson * Step 4: invalidate all cached file data. 548df8bae1dSRodney W. Grimes */ 549b40ce416SJulian Elischer if (vget(vp, LK_EXCLUSIVE | LK_INTERLOCK, td)) { 550df8bae1dSRodney W. Grimes goto loop; 551996c772fSJohn Dyson } 5527c0745eeSPoul-Henning Kamp if (vinvalbuf(vp, 0, td, 0, 0)) 553df8bae1dSRodney W. Grimes panic("ffs_reload: dirty2"); 554df8bae1dSRodney W. Grimes /* 555fe68abe2SJeff Roberson * Step 5: re-read inode data for all active vnodes. 556df8bae1dSRodney W. Grimes */ 557df8bae1dSRodney W. Grimes ip = VTOI(vp); 558c9671602SPoul-Henning Kamp error = 559df8bae1dSRodney W. Grimes bread(devvp, fsbtodb(fs, ino_to_fsba(fs, ip->i_number)), 560c9671602SPoul-Henning Kamp (int)fs->fs_bsize, NOCRED, &bp); 561c9671602SPoul-Henning Kamp if (error) { 56245d45c6cSAlexander Kabaev VOP_UNLOCK(vp, 0, td); 56345d45c6cSAlexander Kabaev vrele(vp); 564df8bae1dSRodney W. Grimes return (error); 565df8bae1dSRodney W. Grimes } 566de6ba7c0SPoul-Henning Kamp ffs_load_inode(bp, ip, fs, ip->i_number); 567b1897c19SJulian Elischer ip->i_effnlink = ip->i_nlink; 568df8bae1dSRodney W. Grimes brelse(bp); 569cb9ddc80SAlexander Kabaev VOP_UNLOCK(vp, 0, td); 570cb9ddc80SAlexander Kabaev vrele(vp); 571ca430f2eSAlexander Kabaev MNT_ILOCK(mp); 572df8bae1dSRodney W. Grimes } 573ca430f2eSAlexander Kabaev MNT_IUNLOCK(mp); 574df8bae1dSRodney W. Grimes return (0); 575df8bae1dSRodney W. Grimes } 576df8bae1dSRodney W. Grimes 5771c85e6a3SKirk McKusick /* 5781c85e6a3SKirk McKusick * Possible superblock locations ordered from most to least likely. 5791c85e6a3SKirk McKusick */ 5801c85e6a3SKirk McKusick static int sblock_try[] = SBLOCKSEARCH; 5815819ab3fSKirk McKusick 582df8bae1dSRodney W. Grimes /* 583df8bae1dSRodney W. Grimes * Common code for mount and mountroot 584df8bae1dSRodney W. Grimes */ 585975512a9SPoul-Henning Kamp static int 586975512a9SPoul-Henning Kamp ffs_mountfs(devvp, mp, td) 58705f4ff5dSPoul-Henning Kamp struct vnode *devvp; 588df8bae1dSRodney W. Grimes struct mount *mp; 589b40ce416SJulian Elischer struct thread *td; 590df8bae1dSRodney W. Grimes { 59105f4ff5dSPoul-Henning Kamp struct ufsmount *ump; 592df8bae1dSRodney W. Grimes struct buf *bp; 59305f4ff5dSPoul-Henning Kamp struct fs *fs; 59489c9c53dSPoul-Henning Kamp struct cdev *dev; 595f55ff3f3SIan Dowse void *space; 5961c85e6a3SKirk McKusick ufs2_daddr_t sblockloc; 597f5ef029eSPoul-Henning Kamp int error, i, blks, size, ronly; 598996c772fSJohn Dyson int32_t *lp; 599996c772fSJohn Dyson struct ucred *cred; 60043920011SPoul-Henning Kamp struct g_consumer *cp; 601df8bae1dSRodney W. Grimes 602996c772fSJohn Dyson dev = devvp->v_rdev; 603a854ed98SJohn Baldwin cred = td ? td->td_ucred : NOCRED; 60443920011SPoul-Henning Kamp 60543920011SPoul-Henning Kamp ronly = (mp->mnt_flag & MNT_RDONLY) != 0; 60643920011SPoul-Henning Kamp DROP_GIANT(); 60743920011SPoul-Henning Kamp g_topology_lock(); 60843920011SPoul-Henning Kamp error = g_vfs_open(devvp, &cp, "ffs", ronly ? 0 : 1); 60943920011SPoul-Henning Kamp 61043920011SPoul-Henning Kamp /* 61143920011SPoul-Henning Kamp * If we are a root mount, drop the E flag so fsck can do its magic. 61293e0b506SPoul-Henning Kamp * We will pick it up again when we remount R/W. 61343920011SPoul-Henning Kamp */ 61443920011SPoul-Henning Kamp if (error == 0 && ronly && (mp->mnt_flag & MNT_ROOTFS)) 61543920011SPoul-Henning Kamp error = g_access(cp, 0, 0, -1); 61643920011SPoul-Henning Kamp g_topology_unlock(); 61743920011SPoul-Henning Kamp PICKUP_GIANT(); 618b40ce416SJulian Elischer VOP_UNLOCK(devvp, 0, td); 619c9671602SPoul-Henning Kamp if (error) 620df8bae1dSRodney W. Grimes return (error); 6210508986cSBruce Evans if (devvp->v_rdev->si_iosize_max != 0) 6221b5464efSPoul-Henning Kamp mp->mnt_iosize_max = devvp->v_rdev->si_iosize_max; 6231b5464efSPoul-Henning Kamp if (mp->mnt_iosize_max > MAXPHYS) 6241b5464efSPoul-Henning Kamp mp->mnt_iosize_max = MAXPHYS; 62595e5e988SJohn Dyson 62643920011SPoul-Henning Kamp devvp->v_bufobj.bo_private = cp; 6276e77a041SPoul-Henning Kamp devvp->v_bufobj.bo_ops = &ffs_ops; 6286e77a041SPoul-Henning Kamp 629df8bae1dSRodney W. Grimes bp = NULL; 630df8bae1dSRodney W. Grimes ump = NULL; 6311c85e6a3SKirk McKusick fs = NULL; 6321c85e6a3SKirk McKusick sblockloc = 0; 6331c85e6a3SKirk McKusick /* 6341c85e6a3SKirk McKusick * Try reading the superblock in each of its possible locations. 6351c85e6a3SKirk McKusick */ 6361c85e6a3SKirk McKusick for (i = 0; sblock_try[i] != -1; i++) { 637b6cef564SKirk McKusick if ((error = bread(devvp, sblock_try[i] / DEV_BSIZE, SBLOCKSIZE, 6381c85e6a3SKirk McKusick cred, &bp)) != 0) 639df8bae1dSRodney W. Grimes goto out; 640df8bae1dSRodney W. Grimes fs = (struct fs *)bp->b_data; 641ada981b2SKirk McKusick sblockloc = sblock_try[i]; 6421c85e6a3SKirk McKusick if ((fs->fs_magic == FS_UFS1_MAGIC || 6431c85e6a3SKirk McKusick (fs->fs_magic == FS_UFS2_MAGIC && 644ada981b2SKirk McKusick (fs->fs_sblockloc == sblockloc || 645ada981b2SKirk McKusick (fs->fs_old_flags & FS_FLAGS_UPDATED) == 0))) && 6461c85e6a3SKirk McKusick fs->fs_bsize <= MAXBSIZE && 6471c85e6a3SKirk McKusick fs->fs_bsize >= sizeof(struct fs)) 6481c85e6a3SKirk McKusick break; 6491c85e6a3SKirk McKusick brelse(bp); 6501c85e6a3SKirk McKusick bp = NULL; 6511c85e6a3SKirk McKusick } 6521c85e6a3SKirk McKusick if (sblock_try[i] == -1) { 653df8bae1dSRodney W. Grimes error = EINVAL; /* XXX needs translation */ 654df8bae1dSRodney W. Grimes goto out; 655df8bae1dSRodney W. Grimes } 6563f6f17eeSJulian Elischer fs->fs_fmod = 0; 6571c85e6a3SKirk McKusick fs->fs_flags &= ~FS_INDEXDIRS; /* no support for directory indicies */ 6580922cce6SBruce Evans fs->fs_flags &= ~FS_UNCLEAN; 6590922cce6SBruce Evans if (fs->fs_clean == 0) { 6600922cce6SBruce Evans fs->fs_flags |= FS_UNCLEAN; 661812b1d41SKirk McKusick if (ronly || (mp->mnt_flag & MNT_FORCE) || 6621a6a6610SKirk McKusick ((fs->fs_flags & FS_NEEDSFSCK) == 0 && 6631a6a6610SKirk McKusick (fs->fs_flags & FS_DOSOFTDEP))) { 6640922cce6SBruce Evans printf( 6650922cce6SBruce Evans "WARNING: %s was not properly dismounted\n", 6660922cce6SBruce Evans fs->fs_fsmnt); 6671469eec8SDavid Greenman } else { 6680922cce6SBruce Evans printf( 6690922cce6SBruce Evans "WARNING: R/W mount of %s denied. Filesystem is not clean - run fsck\n", 6700922cce6SBruce Evans fs->fs_fsmnt); 6711469eec8SDavid Greenman error = EPERM; 6721469eec8SDavid Greenman goto out; 6731469eec8SDavid Greenman } 6741c85e6a3SKirk McKusick if ((fs->fs_pendingblocks != 0 || fs->fs_pendinginodes != 0) && 6751c85e6a3SKirk McKusick (mp->mnt_flag & MNT_FORCE)) { 676cfbf0a46SMaxime Henrion printf("%s: lost blocks %jd files %d\n", fs->fs_fsmnt, 6771c85e6a3SKirk McKusick (intmax_t)fs->fs_pendingblocks, 6781c85e6a3SKirk McKusick fs->fs_pendinginodes); 6799ccb939eSKirk McKusick fs->fs_pendingblocks = 0; 6809ccb939eSKirk McKusick fs->fs_pendinginodes = 0; 6819ccb939eSKirk McKusick } 6829ccb939eSKirk McKusick } 6839ccb939eSKirk McKusick if (fs->fs_pendingblocks != 0 || fs->fs_pendinginodes != 0) { 684cfbf0a46SMaxime Henrion printf("%s: mount pending error: blocks %jd files %d\n", 6851c85e6a3SKirk McKusick fs->fs_fsmnt, (intmax_t)fs->fs_pendingblocks, 6861c85e6a3SKirk McKusick fs->fs_pendinginodes); 6879ccb939eSKirk McKusick fs->fs_pendingblocks = 0; 6889ccb939eSKirk McKusick fs->fs_pendinginodes = 0; 6891469eec8SDavid Greenman } 690a163d034SWarner Losh ump = malloc(sizeof *ump, M_UFSMNT, M_WAITOK | M_ZERO); 69143920011SPoul-Henning Kamp ump->um_cp = cp; 69243920011SPoul-Henning Kamp ump->um_bo = &devvp->v_bufobj; 6938dd56505SPoul-Henning Kamp ump->um_fs = malloc((u_long)fs->fs_sbsize, M_UFSMNT, M_WAITOK); 6941c85e6a3SKirk McKusick if (fs->fs_magic == FS_UFS1_MAGIC) { 6951c85e6a3SKirk McKusick ump->um_fstype = UFS1; 6961c85e6a3SKirk McKusick ump->um_balloc = ffs_balloc_ufs1; 6971c85e6a3SKirk McKusick } else { 6981c85e6a3SKirk McKusick ump->um_fstype = UFS2; 6991c85e6a3SKirk McKusick ump->um_balloc = ffs_balloc_ufs2; 7001c85e6a3SKirk McKusick } 701cec0f20cSPoul-Henning Kamp ump->um_blkatoff = ffs_blkatoff; 702cec0f20cSPoul-Henning Kamp ump->um_truncate = ffs_truncate; 703987f5696SPoul-Henning Kamp ump->um_update = ffs_update; 704cec0f20cSPoul-Henning Kamp ump->um_valloc = ffs_valloc; 705cec0f20cSPoul-Henning Kamp ump->um_vfree = ffs_vfree; 706975512a9SPoul-Henning Kamp ump->um_ifree = ffs_ifree; 7073ba649d7SJeff Roberson mtx_init(UFS_MTX(ump), "FFS", "FFS Lock", MTX_DEF); 708df8bae1dSRodney W. Grimes bcopy(bp->b_data, ump->um_fs, (u_int)fs->fs_sbsize); 7091c85e6a3SKirk McKusick if (fs->fs_sbsize < SBLOCKSIZE) 710f2a2857bSKirk McKusick bp->b_flags |= B_INVAL | B_NOCACHE; 711df8bae1dSRodney W. Grimes brelse(bp); 712df8bae1dSRodney W. Grimes bp = NULL; 713df8bae1dSRodney W. Grimes fs = ump->um_fs; 7141c85e6a3SKirk McKusick ffs_oldfscompat_read(fs, ump, sblockloc); 715df8bae1dSRodney W. Grimes fs->fs_ronly = ronly; 716996c772fSJohn Dyson size = fs->fs_cssize; 717996c772fSJohn Dyson blks = howmany(size, fs->fs_fsize); 718996c772fSJohn Dyson if (fs->fs_contigsumsize > 0) 719996c772fSJohn Dyson size += fs->fs_ncg * sizeof(int32_t); 720a61ab64aSKirk McKusick size += fs->fs_ncg * sizeof(u_int8_t); 721a163d034SWarner Losh space = malloc((u_long)size, M_UFSMNT, M_WAITOK); 722f55ff3f3SIan Dowse fs->fs_csp = space; 723df8bae1dSRodney W. Grimes for (i = 0; i < blks; i += fs->fs_frag) { 724df8bae1dSRodney W. Grimes size = fs->fs_bsize; 725df8bae1dSRodney W. Grimes if (i + fs->fs_frag > blks) 726df8bae1dSRodney W. Grimes size = (blks - i) * fs->fs_fsize; 7278aef1712SMatthew Dillon if ((error = bread(devvp, fsbtodb(fs, fs->fs_csaddr + i), size, 7288aef1712SMatthew Dillon cred, &bp)) != 0) { 729f55ff3f3SIan Dowse free(fs->fs_csp, M_UFSMNT); 730df8bae1dSRodney W. Grimes goto out; 731df8bae1dSRodney W. Grimes } 732df8bae1dSRodney W. Grimes bcopy(bp->b_data, space, (u_int)size); 733f55ff3f3SIan Dowse space = (char *)space + size; 734df8bae1dSRodney W. Grimes brelse(bp); 735df8bae1dSRodney W. Grimes bp = NULL; 736df8bae1dSRodney W. Grimes } 737996c772fSJohn Dyson if (fs->fs_contigsumsize > 0) { 738f55ff3f3SIan Dowse fs->fs_maxcluster = lp = space; 739996c772fSJohn Dyson for (i = 0; i < fs->fs_ncg; i++) 740996c772fSJohn Dyson *lp++ = fs->fs_contigsumsize; 7414691e9eaSIan Dowse space = lp; 742996c772fSJohn Dyson } 743a61ab64aSKirk McKusick size = fs->fs_ncg * sizeof(u_int8_t); 744a61ab64aSKirk McKusick fs->fs_contigdirs = (u_int8_t *)space; 745a61ab64aSKirk McKusick bzero(fs->fs_contigdirs, size); 746143a5346SIan Dowse fs->fs_active = NULL; 747df8bae1dSRodney W. Grimes mp->mnt_data = (qaddr_t)ump; 74868de329eSPoul-Henning Kamp mp->mnt_stat.f_fsid.val[0] = fs->fs_id[0]; 7498f89943eSGuido van Rooij mp->mnt_stat.f_fsid.val[1] = fs->fs_id[1]; 75068de329eSPoul-Henning Kamp if (fs->fs_id[0] == 0 || fs->fs_id[1] == 0 || 75168de329eSPoul-Henning Kamp vfs_getvfs(&mp->mnt_stat.f_fsid)) 75268de329eSPoul-Henning Kamp vfs_getnewfsid(mp); 753df8bae1dSRodney W. Grimes mp->mnt_maxsymlinklen = fs->fs_maxsymlinklen; 754cc9d8990SPeter Wemm mp->mnt_flag |= MNT_LOCAL; 75580830407SRobert Watson if ((fs->fs_flags & FS_MULTILABEL) != 0) 75680830407SRobert Watson #ifdef MAC 75780830407SRobert Watson mp->mnt_flag |= MNT_MULTILABEL; 75880830407SRobert Watson #else 75980830407SRobert Watson printf( 76080830407SRobert Watson "WARNING: %s: multilabel flag on fs but no MAC support\n", 76180830407SRobert Watson fs->fs_fsmnt); 76280830407SRobert Watson #endif 76380830407SRobert Watson if ((fs->fs_flags & FS_ACLS) != 0) 76480830407SRobert Watson #ifdef UFS_ACL 76580830407SRobert Watson mp->mnt_flag |= MNT_ACLS; 76680830407SRobert Watson #else 76780830407SRobert Watson printf( 76880830407SRobert Watson "WARNING: %s: ACLs flag on fs but no ACLs support\n", 76980830407SRobert Watson fs->fs_fsmnt); 77080830407SRobert Watson #endif 771df8bae1dSRodney W. Grimes ump->um_mountp = mp; 772df8bae1dSRodney W. Grimes ump->um_dev = dev; 773df8bae1dSRodney W. Grimes ump->um_devvp = devvp; 774df8bae1dSRodney W. Grimes ump->um_nindir = fs->fs_nindir; 775df8bae1dSRodney W. Grimes ump->um_bptrtodb = fs->fs_fsbtodb; 776df8bae1dSRodney W. Grimes ump->um_seqinc = fs->fs_frag; 777df8bae1dSRodney W. Grimes for (i = 0; i < MAXQUOTAS; i++) 778df8bae1dSRodney W. Grimes ump->um_quotas[i] = NULLVP; 779516081f2SRobert Watson #ifdef UFS_EXTATTR 780a64ed089SRobert Watson ufs_extattr_uepm_init(&ump->um_extattr); 781a64ed089SRobert Watson #endif 7822b14f991SJulian Elischer /* 7832b14f991SJulian Elischer * Set FS local "last mounted on" information (NULL pad) 7842b14f991SJulian Elischer */ 78593373c42SSuleiman Souhlal bzero(fs->fs_fsmnt, MAXMNTLEN); 78693373c42SSuleiman Souhlal strlcpy(fs->fs_fsmnt, mp->mnt_stat.f_mntonname, MAXMNTLEN); 7872b14f991SJulian Elischer 7882b14f991SJulian Elischer if( mp->mnt_flag & MNT_ROOTFS) { 7892b14f991SJulian Elischer /* 7902b14f991SJulian Elischer * Root mount; update timestamp in mount structure. 7912b14f991SJulian Elischer * this will be used by the common root mount code 7922b14f991SJulian Elischer * to update the system clock. 7932b14f991SJulian Elischer */ 7942b14f991SJulian Elischer mp->mnt_time = fs->fs_time; 7952b14f991SJulian Elischer } 796996c772fSJohn Dyson 797996c772fSJohn Dyson if (ronly == 0) { 798b1897c19SJulian Elischer if ((fs->fs_flags & FS_DOSOFTDEP) && 799b1897c19SJulian Elischer (error = softdep_mount(devvp, mp, fs, cred)) != 0) { 800f55ff3f3SIan Dowse free(fs->fs_csp, M_UFSMNT); 801b1897c19SJulian Elischer goto out; 802b1897c19SJulian Elischer } 803f2a2857bSKirk McKusick if (fs->fs_snapinum[0] != 0) 804f2a2857bSKirk McKusick ffs_snapshot_mount(mp); 805cf60e8e4SKirk McKusick fs->fs_fmod = 1; 806996c772fSJohn Dyson fs->fs_clean = 0; 807996c772fSJohn Dyson (void) ffs_sbupdate(ump, MNT_WAIT); 808996c772fSJohn Dyson } 809d8d3d415SPoul-Henning Kamp /* 810d8d3d415SPoul-Henning Kamp * Initialize filesystem stat information in mount struct. 811d8d3d415SPoul-Henning Kamp */ 812516081f2SRobert Watson #ifdef UFS_EXTATTR 813516081f2SRobert Watson #ifdef UFS_EXTATTR_AUTOSTART 8149de54ba5SRobert Watson /* 8159de54ba5SRobert Watson * 816f5161237SRobert Watson * Auto-starting does the following: 8179de54ba5SRobert Watson * - check for /.attribute in the fs, and extattr_start if so 8189de54ba5SRobert Watson * - for each file in .attribute, enable that file with 8199de54ba5SRobert Watson * an attribute of the same name. 8209de54ba5SRobert Watson * Not clear how to report errors -- probably eat them. 8219de54ba5SRobert Watson * This would all happen while the filesystem was busy/not 8229de54ba5SRobert Watson * available, so would effectively be "atomic". 8239de54ba5SRobert Watson */ 824b40ce416SJulian Elischer (void) ufs_extattr_autostart(mp, td); 825516081f2SRobert Watson #endif /* !UFS_EXTATTR_AUTOSTART */ 826516081f2SRobert Watson #endif /* !UFS_EXTATTR */ 8273ba649d7SJeff Roberson #ifndef QUOTA 8283ba649d7SJeff Roberson mp->mnt_kern_flag |= MNTK_MPSAFE; 8293ba649d7SJeff Roberson #endif 830df8bae1dSRodney W. Grimes return (0); 831df8bae1dSRodney W. Grimes out: 832df8bae1dSRodney W. Grimes if (bp) 833df8bae1dSRodney W. Grimes brelse(bp); 83443920011SPoul-Henning Kamp if (cp != NULL) { 83543920011SPoul-Henning Kamp DROP_GIANT(); 83643920011SPoul-Henning Kamp g_topology_lock(); 83784a69752SPoul-Henning Kamp g_vfs_close(cp, td); 83843920011SPoul-Henning Kamp g_topology_unlock(); 83943920011SPoul-Henning Kamp PICKUP_GIANT(); 84043920011SPoul-Henning Kamp } 841df8bae1dSRodney W. Grimes if (ump) { 8423ba649d7SJeff Roberson mtx_destroy(UFS_MTX(ump)); 843df8bae1dSRodney W. Grimes free(ump->um_fs, M_UFSMNT); 844df8bae1dSRodney W. Grimes free(ump, M_UFSMNT); 845df8bae1dSRodney W. Grimes mp->mnt_data = (qaddr_t)0; 846df8bae1dSRodney W. Grimes } 847df8bae1dSRodney W. Grimes return (error); 848df8bae1dSRodney W. Grimes } 849df8bae1dSRodney W. Grimes 8501c85e6a3SKirk McKusick #include <sys/sysctl.h> 851adf41577SPoul-Henning Kamp static int bigcgs = 0; 8521c85e6a3SKirk McKusick SYSCTL_INT(_debug, OID_AUTO, bigcgs, CTLFLAG_RW, &bigcgs, 0, ""); 8531c85e6a3SKirk McKusick 854df8bae1dSRodney W. Grimes /* 8551c85e6a3SKirk McKusick * Sanity checks for loading old filesystem superblocks. 8561c85e6a3SKirk McKusick * See ffs_oldfscompat_write below for unwound actions. 857df8bae1dSRodney W. Grimes * 8581c85e6a3SKirk McKusick * XXX - Parts get retired eventually. 8591c85e6a3SKirk McKusick * Unfortunately new bits get added. 860df8bae1dSRodney W. Grimes */ 8611c85e6a3SKirk McKusick static void 8621c85e6a3SKirk McKusick ffs_oldfscompat_read(fs, ump, sblockloc) 863df8bae1dSRodney W. Grimes struct fs *fs; 8641c85e6a3SKirk McKusick struct ufsmount *ump; 8651c85e6a3SKirk McKusick ufs2_daddr_t sblockloc; 8661c85e6a3SKirk McKusick { 8671c85e6a3SKirk McKusick off_t maxfilesize; 8681c85e6a3SKirk McKusick 8691c85e6a3SKirk McKusick /* 870ada981b2SKirk McKusick * If not yet done, update fs_flags location and value of fs_sblockloc. 871ada981b2SKirk McKusick */ 872ada981b2SKirk McKusick if ((fs->fs_old_flags & FS_FLAGS_UPDATED) == 0) { 873ada981b2SKirk McKusick fs->fs_flags = fs->fs_old_flags; 874ada981b2SKirk McKusick fs->fs_old_flags |= FS_FLAGS_UPDATED; 875ada981b2SKirk McKusick fs->fs_sblockloc = sblockloc; 876ada981b2SKirk McKusick } 877ada981b2SKirk McKusick /* 8781c85e6a3SKirk McKusick * If not yet done, update UFS1 superblock with new wider fields. 8791c85e6a3SKirk McKusick */ 88074f3809aSKirk McKusick if (fs->fs_magic == FS_UFS1_MAGIC && fs->fs_maxbsize != fs->fs_bsize) { 8811c85e6a3SKirk McKusick fs->fs_maxbsize = fs->fs_bsize; 8821c85e6a3SKirk McKusick fs->fs_time = fs->fs_old_time; 8831c85e6a3SKirk McKusick fs->fs_size = fs->fs_old_size; 8841c85e6a3SKirk McKusick fs->fs_dsize = fs->fs_old_dsize; 8851c85e6a3SKirk McKusick fs->fs_csaddr = fs->fs_old_csaddr; 8861c85e6a3SKirk McKusick fs->fs_cstotal.cs_ndir = fs->fs_old_cstotal.cs_ndir; 8871c85e6a3SKirk McKusick fs->fs_cstotal.cs_nbfree = fs->fs_old_cstotal.cs_nbfree; 8881c85e6a3SKirk McKusick fs->fs_cstotal.cs_nifree = fs->fs_old_cstotal.cs_nifree; 8891c85e6a3SKirk McKusick fs->fs_cstotal.cs_nffree = fs->fs_old_cstotal.cs_nffree; 8901c85e6a3SKirk McKusick } 8911c85e6a3SKirk McKusick if (fs->fs_magic == FS_UFS1_MAGIC && 8921c85e6a3SKirk McKusick fs->fs_old_inodefmt < FS_44INODEFMT) { 8938680d698SNate Lawson fs->fs_maxfilesize = ((uint64_t)1 << 31) - 1; 8941c85e6a3SKirk McKusick fs->fs_qbmask = ~fs->fs_bmask; 8951c85e6a3SKirk McKusick fs->fs_qfmask = ~fs->fs_fmask; 8961c85e6a3SKirk McKusick } 8978f42fb8fSIan Dowse if (fs->fs_magic == FS_UFS1_MAGIC) { 8981c85e6a3SKirk McKusick ump->um_savedmaxfilesize = fs->fs_maxfilesize; 8998680d698SNate Lawson maxfilesize = (uint64_t)0x80000000 * fs->fs_bsize - 1; 9001c85e6a3SKirk McKusick if (fs->fs_maxfilesize > maxfilesize) 9011c85e6a3SKirk McKusick fs->fs_maxfilesize = maxfilesize; 9028f42fb8fSIan Dowse } 9031c85e6a3SKirk McKusick /* Compatibility for old filesystems */ 9041c85e6a3SKirk McKusick if (fs->fs_avgfilesize <= 0) 9051c85e6a3SKirk McKusick fs->fs_avgfilesize = AVFILESIZ; 9061c85e6a3SKirk McKusick if (fs->fs_avgfpdir <= 0) 9071c85e6a3SKirk McKusick fs->fs_avgfpdir = AFPDIR; 9081c85e6a3SKirk McKusick if (bigcgs) { 9091c85e6a3SKirk McKusick fs->fs_save_cgsize = fs->fs_cgsize; 9101c85e6a3SKirk McKusick fs->fs_cgsize = fs->fs_bsize; 9111c85e6a3SKirk McKusick } 9121c85e6a3SKirk McKusick } 9131c85e6a3SKirk McKusick 9141c85e6a3SKirk McKusick /* 9151c85e6a3SKirk McKusick * Unwinding superblock updates for old filesystems. 9161c85e6a3SKirk McKusick * See ffs_oldfscompat_read above for details. 9171c85e6a3SKirk McKusick * 9181c85e6a3SKirk McKusick * XXX - Parts get retired eventually. 9191c85e6a3SKirk McKusick * Unfortunately new bits get added. 9201c85e6a3SKirk McKusick */ 9211c85e6a3SKirk McKusick static void 9221c85e6a3SKirk McKusick ffs_oldfscompat_write(fs, ump) 9231c85e6a3SKirk McKusick struct fs *fs; 9241c85e6a3SKirk McKusick struct ufsmount *ump; 925df8bae1dSRodney W. Grimes { 926df8bae1dSRodney W. Grimes 9271c85e6a3SKirk McKusick /* 9281c85e6a3SKirk McKusick * Copy back UFS2 updated fields that UFS1 inspects. 9291c85e6a3SKirk McKusick */ 9301c85e6a3SKirk McKusick if (fs->fs_magic == FS_UFS1_MAGIC) { 9311c85e6a3SKirk McKusick fs->fs_old_time = fs->fs_time; 9321c85e6a3SKirk McKusick fs->fs_old_cstotal.cs_ndir = fs->fs_cstotal.cs_ndir; 9331c85e6a3SKirk McKusick fs->fs_old_cstotal.cs_nbfree = fs->fs_cstotal.cs_nbfree; 9341c85e6a3SKirk McKusick fs->fs_old_cstotal.cs_nifree = fs->fs_cstotal.cs_nifree; 9351c85e6a3SKirk McKusick fs->fs_old_cstotal.cs_nffree = fs->fs_cstotal.cs_nffree; 9361c85e6a3SKirk McKusick fs->fs_maxfilesize = ump->um_savedmaxfilesize; 9378f42fb8fSIan Dowse } 9381c85e6a3SKirk McKusick if (bigcgs) { 9391c85e6a3SKirk McKusick fs->fs_cgsize = fs->fs_save_cgsize; 9401c85e6a3SKirk McKusick fs->fs_save_cgsize = 0; 9411c85e6a3SKirk McKusick } 942df8bae1dSRodney W. Grimes } 943df8bae1dSRodney W. Grimes 944df8bae1dSRodney W. Grimes /* 945df8bae1dSRodney W. Grimes * unmount system call 946df8bae1dSRodney W. Grimes */ 947adf41577SPoul-Henning Kamp static int 948b40ce416SJulian Elischer ffs_unmount(mp, mntflags, td) 949df8bae1dSRodney W. Grimes struct mount *mp; 950df8bae1dSRodney W. Grimes int mntflags; 951b40ce416SJulian Elischer struct thread *td; 952df8bae1dSRodney W. Grimes { 95305f4ff5dSPoul-Henning Kamp struct ufsmount *ump = VFSTOUFS(mp); 95405f4ff5dSPoul-Henning Kamp struct fs *fs; 955996c772fSJohn Dyson int error, flags; 956df8bae1dSRodney W. Grimes 957df8bae1dSRodney W. Grimes flags = 0; 958df8bae1dSRodney W. Grimes if (mntflags & MNT_FORCE) { 959df8bae1dSRodney W. Grimes flags |= FORCECLOSE; 960df8bae1dSRodney W. Grimes } 961516081f2SRobert Watson #ifdef UFS_EXTATTR 962b40ce416SJulian Elischer if ((error = ufs_extattr_stop(mp, td))) { 963b2b0497aSRobert Watson if (error != EOPNOTSUPP) 964b2b0497aSRobert Watson printf("ffs_unmount: ufs_extattr_stop returned %d\n", 965b2b0497aSRobert Watson error); 9667df97b61SRobert Watson } else { 9679de54ba5SRobert Watson ufs_extattr_uepm_destroy(&ump->um_extattr); 9687df97b61SRobert Watson } 969a64ed089SRobert Watson #endif 970b1897c19SJulian Elischer if (mp->mnt_flag & MNT_SOFTDEP) { 971b40ce416SJulian Elischer if ((error = softdep_flushfiles(mp, flags, td)) != 0) 972df8bae1dSRodney W. Grimes return (error); 973b1897c19SJulian Elischer } else { 974b40ce416SJulian Elischer if ((error = ffs_flushfiles(mp, flags, td)) != 0) 975b1897c19SJulian Elischer return (error); 976b1897c19SJulian Elischer } 977df8bae1dSRodney W. Grimes fs = ump->um_fs; 9783ba649d7SJeff Roberson UFS_LOCK(ump); 9799ccb939eSKirk McKusick if (fs->fs_pendingblocks != 0 || fs->fs_pendinginodes != 0) { 980cfbf0a46SMaxime Henrion printf("%s: unmount pending error: blocks %jd files %d\n", 9811c85e6a3SKirk McKusick fs->fs_fsmnt, (intmax_t)fs->fs_pendingblocks, 9821c85e6a3SKirk McKusick fs->fs_pendinginodes); 9839ccb939eSKirk McKusick fs->fs_pendingblocks = 0; 9849ccb939eSKirk McKusick fs->fs_pendinginodes = 0; 9859ccb939eSKirk McKusick } 9863ba649d7SJeff Roberson UFS_UNLOCK(ump); 987996c772fSJohn Dyson if (fs->fs_ronly == 0) { 9881a6a6610SKirk McKusick fs->fs_clean = fs->fs_flags & (FS_UNCLEAN|FS_NEEDSFSCK) ? 0 : 1; 989996c772fSJohn Dyson error = ffs_sbupdate(ump, MNT_WAIT); 990996c772fSJohn Dyson if (error) { 991996c772fSJohn Dyson fs->fs_clean = 0; 992996c772fSJohn Dyson return (error); 993996c772fSJohn Dyson } 994e0e9c421SDavid Greenman } 99543920011SPoul-Henning Kamp DROP_GIANT(); 99643920011SPoul-Henning Kamp g_topology_lock(); 99784a69752SPoul-Henning Kamp g_vfs_close(ump->um_cp, td); 99843920011SPoul-Henning Kamp g_topology_unlock(); 99943920011SPoul-Henning Kamp PICKUP_GIANT(); 10006476c0d2SJohn Dyson vrele(ump->um_devvp); 10013ba649d7SJeff Roberson mtx_destroy(UFS_MTX(ump)); 1002f55ff3f3SIan Dowse free(fs->fs_csp, M_UFSMNT); 1003df8bae1dSRodney W. Grimes free(fs, M_UFSMNT); 1004df8bae1dSRodney W. Grimes free(ump, M_UFSMNT); 1005df8bae1dSRodney W. Grimes mp->mnt_data = (qaddr_t)0; 1006cc9d8990SPeter Wemm mp->mnt_flag &= ~MNT_LOCAL; 1007df8bae1dSRodney W. Grimes return (error); 1008df8bae1dSRodney W. Grimes } 1009df8bae1dSRodney W. Grimes 1010df8bae1dSRodney W. Grimes /* 1011df8bae1dSRodney W. Grimes * Flush out all the files in a filesystem. 1012df8bae1dSRodney W. Grimes */ 101326f9a767SRodney W. Grimes int 1014b40ce416SJulian Elischer ffs_flushfiles(mp, flags, td) 101505f4ff5dSPoul-Henning Kamp struct mount *mp; 1016df8bae1dSRodney W. Grimes int flags; 1017b40ce416SJulian Elischer struct thread *td; 1018df8bae1dSRodney W. Grimes { 101905f4ff5dSPoul-Henning Kamp struct ufsmount *ump; 1020c9671602SPoul-Henning Kamp int error; 1021df8bae1dSRodney W. Grimes 1022df8bae1dSRodney W. Grimes ump = VFSTOUFS(mp); 1023df8bae1dSRodney W. Grimes #ifdef QUOTA 1024df8bae1dSRodney W. Grimes if (mp->mnt_flag & MNT_QUOTA) { 1025c1d9efcbSPoul-Henning Kamp int i; 1026f257b7a5SAlfred Perlstein error = vflush(mp, 0, SKIPSYSTEM|flags, td); 1027c1d9efcbSPoul-Henning Kamp if (error) 1028df8bae1dSRodney W. Grimes return (error); 1029df8bae1dSRodney W. Grimes for (i = 0; i < MAXQUOTAS; i++) { 1030df8bae1dSRodney W. Grimes if (ump->um_quotas[i] == NULLVP) 1031df8bae1dSRodney W. Grimes continue; 1032b40ce416SJulian Elischer quotaoff(td, mp, i); 1033df8bae1dSRodney W. Grimes } 1034df8bae1dSRodney W. Grimes /* 1035df8bae1dSRodney W. Grimes * Here we fall through to vflush again to ensure 1036df8bae1dSRodney W. Grimes * that we have gotten rid of all the system vnodes. 1037df8bae1dSRodney W. Grimes */ 1038df8bae1dSRodney W. Grimes } 1039df8bae1dSRodney W. Grimes #endif 1040e6e370a7SJeff Roberson ASSERT_VOP_LOCKED(ump->um_devvp, "ffs_flushfiles"); 1041e6e370a7SJeff Roberson if (ump->um_devvp->v_vflag & VV_COPYONWRITE) { 1042f257b7a5SAlfred Perlstein if ((error = vflush(mp, 0, SKIPSYSTEM | flags, td)) != 0) 1043f2a2857bSKirk McKusick return (error); 1044f2a2857bSKirk McKusick ffs_snapshot_unmount(mp); 1045f2a2857bSKirk McKusick /* 1046f2a2857bSKirk McKusick * Here we fall through to vflush again to ensure 1047f2a2857bSKirk McKusick * that we have gotten rid of all the system vnodes. 1048f2a2857bSKirk McKusick */ 1049f2a2857bSKirk McKusick } 1050b1897c19SJulian Elischer /* 1051b1897c19SJulian Elischer * Flush all the files. 1052b1897c19SJulian Elischer */ 1053f257b7a5SAlfred Perlstein if ((error = vflush(mp, 0, flags, td)) != 0) 1054b1897c19SJulian Elischer return (error); 1055b1897c19SJulian Elischer /* 1056b1897c19SJulian Elischer * Flush filesystem metadata. 1057b1897c19SJulian Elischer */ 1058b40ce416SJulian Elischer vn_lock(ump->um_devvp, LK_EXCLUSIVE | LK_RETRY, td); 10598df6bac4SPoul-Henning Kamp error = VOP_FSYNC(ump->um_devvp, MNT_WAIT, td); 1060b40ce416SJulian Elischer VOP_UNLOCK(ump->um_devvp, 0, td); 1061df8bae1dSRodney W. Grimes return (error); 1062df8bae1dSRodney W. Grimes } 1063df8bae1dSRodney W. Grimes 1064df8bae1dSRodney W. Grimes /* 1065df8bae1dSRodney W. Grimes * Get filesystem statistics. 1066df8bae1dSRodney W. Grimes */ 1067adf41577SPoul-Henning Kamp static int 1068b40ce416SJulian Elischer ffs_statfs(mp, sbp, td) 1069df8bae1dSRodney W. Grimes struct mount *mp; 107005f4ff5dSPoul-Henning Kamp struct statfs *sbp; 1071b40ce416SJulian Elischer struct thread *td; 1072df8bae1dSRodney W. Grimes { 107305f4ff5dSPoul-Henning Kamp struct ufsmount *ump; 107405f4ff5dSPoul-Henning Kamp struct fs *fs; 1075df8bae1dSRodney W. Grimes 1076df8bae1dSRodney W. Grimes ump = VFSTOUFS(mp); 1077df8bae1dSRodney W. Grimes fs = ump->um_fs; 10781c85e6a3SKirk McKusick if (fs->fs_magic != FS_UFS1_MAGIC && fs->fs_magic != FS_UFS2_MAGIC) 1079df8bae1dSRodney W. Grimes panic("ffs_statfs"); 1080fde81c7dSKirk McKusick sbp->f_version = STATFS_VERSION; 1081df8bae1dSRodney W. Grimes sbp->f_bsize = fs->fs_fsize; 1082df8bae1dSRodney W. Grimes sbp->f_iosize = fs->fs_bsize; 1083df8bae1dSRodney W. Grimes sbp->f_blocks = fs->fs_dsize; 10843ba649d7SJeff Roberson UFS_LOCK(ump); 1085df8bae1dSRodney W. Grimes sbp->f_bfree = fs->fs_cstotal.cs_nbfree * fs->fs_frag + 10869ccb939eSKirk McKusick fs->fs_cstotal.cs_nffree + dbtofsb(fs, fs->fs_pendingblocks); 10879ccb939eSKirk McKusick sbp->f_bavail = freespace(fs, fs->fs_minfree) + 10889ccb939eSKirk McKusick dbtofsb(fs, fs->fs_pendingblocks); 1089df8bae1dSRodney W. Grimes sbp->f_files = fs->fs_ncg * fs->fs_ipg - ROOTINO; 10909ccb939eSKirk McKusick sbp->f_ffree = fs->fs_cstotal.cs_nifree + fs->fs_pendinginodes; 10913ba649d7SJeff Roberson UFS_UNLOCK(ump); 1092fde81c7dSKirk McKusick sbp->f_namemax = NAME_MAX; 1093df8bae1dSRodney W. Grimes return (0); 1094df8bae1dSRodney W. Grimes } 1095df8bae1dSRodney W. Grimes 1096df8bae1dSRodney W. Grimes /* 1097df8bae1dSRodney W. Grimes * Go through the disk queues to initiate sandbagged IO; 1098df8bae1dSRodney W. Grimes * go through the inodes to write those that have been modified; 1099df8bae1dSRodney W. Grimes * initiate the writing of the super block if it has been modified. 1100df8bae1dSRodney W. Grimes * 1101df8bae1dSRodney W. Grimes * Note: we are always called with the filesystem marked `MPBUSY'. 1102df8bae1dSRodney W. Grimes */ 1103adf41577SPoul-Henning Kamp static int 11048df6bac4SPoul-Henning Kamp ffs_sync(mp, waitfor, td) 1105df8bae1dSRodney W. Grimes struct mount *mp; 1106df8bae1dSRodney W. Grimes int waitfor; 1107b40ce416SJulian Elischer struct thread *td; 1108df8bae1dSRodney W. Grimes { 1109112f7372SKirk McKusick struct vnode *nvp, *vp, *devvp; 1110996c772fSJohn Dyson struct inode *ip; 1111996c772fSJohn Dyson struct ufsmount *ump = VFSTOUFS(mp); 1112996c772fSJohn Dyson struct fs *fs; 11139b971133SKirk McKusick int error, count, wait, lockreq, allerror = 0; 1114156cb265SPoul-Henning Kamp struct bufobj *bo; 1115df8bae1dSRodney W. Grimes 1116df8bae1dSRodney W. Grimes fs = ump->um_fs; 1117996c772fSJohn Dyson if (fs->fs_fmod != 0 && fs->fs_ronly != 0) { /* XXX */ 1118df8bae1dSRodney W. Grimes printf("fs = %s\n", fs->fs_fsmnt); 11195ace3b26SMike Pritchard panic("ffs_sync: rofs mod"); 1120df8bae1dSRodney W. Grimes } 1121df8bae1dSRodney W. Grimes /* 1122df8bae1dSRodney W. Grimes * Write back each (modified) inode. 1123df8bae1dSRodney W. Grimes */ 11249b971133SKirk McKusick wait = 0; 1125245df27cSMatthew Dillon lockreq = LK_EXCLUSIVE | LK_NOWAIT; 11269b971133SKirk McKusick if (waitfor == MNT_WAIT) { 11279b971133SKirk McKusick wait = 1; 1128245df27cSMatthew Dillon lockreq = LK_EXCLUSIVE; 11299b971133SKirk McKusick } 113041d4783dSJeff Roberson lockreq |= LK_INTERLOCK | LK_SLEEPFAIL; 1131ca430f2eSAlexander Kabaev MNT_ILOCK(mp); 1132df8bae1dSRodney W. Grimes loop: 1133e3c5a7a4SPoul-Henning Kamp MNT_VNODE_FOREACH(vp, mp, nvp) { 1134245df27cSMatthew Dillon /* 1135245df27cSMatthew Dillon * Depend on the mntvnode_slock to keep things stable enough 1136245df27cSMatthew Dillon * for a quick test. Since there might be hundreds of 1137245df27cSMatthew Dillon * thousands of vnodes, we cannot afford even a subroutine 1138245df27cSMatthew Dillon * call unless there's a good chance that we have work to do. 1139245df27cSMatthew Dillon */ 11402f05568aSJeff Roberson VI_LOCK(vp); 1141fe68abe2SJeff Roberson if (vp->v_iflag & VI_DOOMED) { 11422f05568aSJeff Roberson VI_UNLOCK(vp); 11432f05568aSJeff Roberson continue; 11442f05568aSJeff Roberson } 1145df8bae1dSRodney W. Grimes ip = VTOI(vp); 1146cf60e8e4SKirk McKusick if (vp->v_type == VNON || ((ip->i_flag & 1147cf60e8e4SKirk McKusick (IN_ACCESS | IN_CHANGE | IN_MODIFIED | IN_UPDATE)) == 0 && 1148156cb265SPoul-Henning Kamp vp->v_bufobj.bo_dirty.bv_cnt == 0)) { 11492f05568aSJeff Roberson VI_UNLOCK(vp); 1150df8bae1dSRodney W. Grimes continue; 1151996c772fSJohn Dyson } 1152ca430f2eSAlexander Kabaev MNT_IUNLOCK(mp); 1153b40ce416SJulian Elischer if ((error = vget(vp, lockreq, td)) != 0) { 1154ca430f2eSAlexander Kabaev MNT_ILOCK(mp); 115541d4783dSJeff Roberson if (error == ENOENT || error == ENOLCK) 1156df8bae1dSRodney W. Grimes goto loop; 11572f05568aSJeff Roberson continue; 11582f05568aSJeff Roberson } 115940854ff5SPoul-Henning Kamp if ((error = ffs_syncvnode(vp, waitfor)) != 0) 1160df8bae1dSRodney W. Grimes allerror = error; 116141d4783dSJeff Roberson vput(vp); 1162ca430f2eSAlexander Kabaev MNT_ILOCK(mp); 1163245df27cSMatthew Dillon } 1164ca430f2eSAlexander Kabaev MNT_IUNLOCK(mp); 1165df8bae1dSRodney W. Grimes /* 1166df8bae1dSRodney W. Grimes * Force stale filesystem control information to be flushed. 1167df8bae1dSRodney W. Grimes */ 11689b971133SKirk McKusick if (waitfor == MNT_WAIT) { 1169b40ce416SJulian Elischer if ((error = softdep_flushworklist(ump->um_mountp, &count, td))) 11709b971133SKirk McKusick allerror = error; 11719b971133SKirk McKusick /* Flushed work items may create new vnodes to clean */ 11729ab73fd1SKirk McKusick if (allerror == 0 && count) { 1173ca430f2eSAlexander Kabaev MNT_ILOCK(mp); 11749b971133SKirk McKusick goto loop; 11759b971133SKirk McKusick } 11769b971133SKirk McKusick } 1177589c7af9SKirk McKusick #ifdef QUOTA 1178589c7af9SKirk McKusick qsync(mp); 1179589c7af9SKirk McKusick #endif 1180112f7372SKirk McKusick devvp = ump->um_devvp; 11812ee5711eSJeff Roberson VI_LOCK(devvp); 1182156cb265SPoul-Henning Kamp bo = &devvp->v_bufobj; 1183112f7372SKirk McKusick if (waitfor != MNT_LAZY && 1184156cb265SPoul-Henning Kamp (bo->bo_numoutput > 0 || bo->bo_dirty.bv_cnt > 0)) { 11852ee5711eSJeff Roberson vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY | LK_INTERLOCK, td); 11868df6bac4SPoul-Henning Kamp if ((error = VOP_FSYNC(devvp, waitfor, td)) != 0) 1187df8bae1dSRodney W. Grimes allerror = error; 1188b40ce416SJulian Elischer VOP_UNLOCK(devvp, 0, td); 11899ab73fd1SKirk McKusick if (allerror == 0 && waitfor == MNT_WAIT) { 1190ca430f2eSAlexander Kabaev MNT_ILOCK(mp); 1191112f7372SKirk McKusick goto loop; 1192b1897c19SJulian Elischer } 1193112f7372SKirk McKusick } else 11942ee5711eSJeff Roberson VI_UNLOCK(devvp); 1195996c772fSJohn Dyson /* 1196996c772fSJohn Dyson * Write back modified superblock. 1197996c772fSJohn Dyson */ 1198b1897c19SJulian Elischer if (fs->fs_fmod != 0 && (error = ffs_sbupdate(ump, waitfor)) != 0) 1199996c772fSJohn Dyson allerror = error; 1200df8bae1dSRodney W. Grimes return (allerror); 1201df8bae1dSRodney W. Grimes } 1202df8bae1dSRodney W. Grimes 1203df8bae1dSRodney W. Grimes int 1204a0595d02SKirk McKusick ffs_vget(mp, ino, flags, vpp) 1205df8bae1dSRodney W. Grimes struct mount *mp; 1206df8bae1dSRodney W. Grimes ino_t ino; 1207a0595d02SKirk McKusick int flags; 1208df8bae1dSRodney W. Grimes struct vnode **vpp; 1209df8bae1dSRodney W. Grimes { 1210996c772fSJohn Dyson struct fs *fs; 1211996c772fSJohn Dyson struct inode *ip; 1212df8bae1dSRodney W. Grimes struct ufsmount *ump; 1213df8bae1dSRodney W. Grimes struct buf *bp; 1214df8bae1dSRodney W. Grimes struct vnode *vp; 121589c9c53dSPoul-Henning Kamp struct cdev *dev; 1216f576a00dSSemen Ustimenko int error; 1217df8bae1dSRodney W. Grimes 121851f5ce0cSPoul-Henning Kamp error = vfs_hash_get(mp, ino, flags, curthread, vpp, NULL, NULL); 1219e82ef95cSPoul-Henning Kamp if (error || *vpp != NULL) 122014bc0685SPoul-Henning Kamp return (error); 1221f576a00dSSemen Ustimenko 1222f576a00dSSemen Ustimenko /* 1223d6919865SJeff Roberson * We must promote to an exclusive lock for vnode creation. This 1224d6919865SJeff Roberson * can happen if lookup is passed LOCKSHARED. 1225d6919865SJeff Roberson */ 1226d6919865SJeff Roberson if ((flags & LK_TYPE_MASK) == LK_SHARED) { 1227d6919865SJeff Roberson flags &= ~LK_TYPE_MASK; 1228d6919865SJeff Roberson flags |= LK_EXCLUSIVE; 1229d6919865SJeff Roberson } 1230d6919865SJeff Roberson 1231d6919865SJeff Roberson /* 123213866b3fSSemen Ustimenko * We do not lock vnode creation as it is believed to be too 1233f576a00dSSemen Ustimenko * expensive for such rare case as simultaneous creation of vnode 1234f576a00dSSemen Ustimenko * for same ino by different processes. We just allow them to race 1235f576a00dSSemen Ustimenko * and check later to decide who wins. Let the race begin! 1236f576a00dSSemen Ustimenko */ 123714bc0685SPoul-Henning Kamp 123814bc0685SPoul-Henning Kamp ump = VFSTOUFS(mp); 123914bc0685SPoul-Henning Kamp dev = ump->um_dev; 124014bc0685SPoul-Henning Kamp fs = ump->um_fs; 1241df8bae1dSRodney W. Grimes 12422094ddb6SDavid Greenman /* 12432f9bae59SDavid Greenman * If this MALLOC() is performed after the getnewvnode() 12442f9bae59SDavid Greenman * it might block, leaving a vnode with a NULL v_data to be 12452f9bae59SDavid Greenman * found by ffs_sync() if a sync happens to fire right then, 12462f9bae59SDavid Greenman * which will cause a panic because ffs_sync() blindly 12472f9bae59SDavid Greenman * dereferences vp->v_data (as well it should). 12482f9bae59SDavid Greenman */ 124914bc0685SPoul-Henning Kamp ip = uma_zalloc(uma_inode, M_WAITOK | M_ZERO); 12502f9bae59SDavid Greenman 1251df8bae1dSRodney W. Grimes /* Allocate a new vnode/inode. */ 125202f2c6a9SPoul-Henning Kamp if (fs->fs_magic == FS_UFS1_MAGIC) 125302f2c6a9SPoul-Henning Kamp error = getnewvnode("ufs", mp, &ffs_vnodeops1, &vp); 125402f2c6a9SPoul-Henning Kamp else 125502f2c6a9SPoul-Henning Kamp error = getnewvnode("ufs", mp, &ffs_vnodeops2, &vp); 1256c9671602SPoul-Henning Kamp if (error) { 1257df8bae1dSRodney W. Grimes *vpp = NULL; 1258aa4d7a8aSPoul-Henning Kamp uma_zfree(uma_inode, ip); 1259df8bae1dSRodney W. Grimes return (error); 1260df8bae1dSRodney W. Grimes } 126167e87166SBoris Popov /* 1262aa7ba427SJeff Roberson * FFS supports recursive and shared locking. 126367e87166SBoris Popov */ 1264a5b65058SKirk McKusick vp->v_vnlock->lk_flags |= LK_CANRECURSE; 1265aa7ba427SJeff Roberson vp->v_vnlock->lk_flags &= ~LK_NOSHARE; 1266df8bae1dSRodney W. Grimes vp->v_data = ip; 12675d9d81e7SPoul-Henning Kamp vp->v_bufobj.bo_bsize = fs->fs_bsize; 1268df8bae1dSRodney W. Grimes ip->i_vnode = vp; 12691c85e6a3SKirk McKusick ip->i_ump = ump; 1270c94cd5fcSPoul-Henning Kamp ip->i_fs = fs; 1271df8bae1dSRodney W. Grimes ip->i_dev = dev; 1272df8bae1dSRodney W. Grimes ip->i_number = ino; 1273df8bae1dSRodney W. Grimes #ifdef QUOTA 1274c1d9efcbSPoul-Henning Kamp { 1275c1d9efcbSPoul-Henning Kamp int i; 1276df8bae1dSRodney W. Grimes for (i = 0; i < MAXQUOTAS; i++) 1277df8bae1dSRodney W. Grimes ip->i_dquot[i] = NODQUOT; 1278c1d9efcbSPoul-Henning Kamp } 1279df8bae1dSRodney W. Grimes #endif 1280df8bae1dSRodney W. Grimes 128151f5ce0cSPoul-Henning Kamp error = vfs_hash_insert(vp, ino, flags, curthread, vpp, NULL, NULL); 128245c26fa2SPoul-Henning Kamp if (error || *vpp != NULL) 1283f576a00dSSemen Ustimenko return (error); 1284f576a00dSSemen Ustimenko 1285df8bae1dSRodney W. Grimes /* Read in the disk contents for the inode, copy into the inode. */ 1286c9671602SPoul-Henning Kamp error = bread(ump->um_devvp, fsbtodb(fs, ino_to_fsba(fs, ino)), 1287c9671602SPoul-Henning Kamp (int)fs->fs_bsize, NOCRED, &bp); 1288c9671602SPoul-Henning Kamp if (error) { 1289df8bae1dSRodney W. Grimes /* 1290df8bae1dSRodney W. Grimes * The inode does not contain anything useful, so it would 1291df8bae1dSRodney W. Grimes * be misleading to leave it on its hash chain. With mode 1292df8bae1dSRodney W. Grimes * still zero, it will be unlinked and returned to the free 1293df8bae1dSRodney W. Grimes * list by vput(). 1294df8bae1dSRodney W. Grimes */ 1295df8bae1dSRodney W. Grimes brelse(bp); 1296bd7e5f99SJohn Dyson vput(vp); 1297df8bae1dSRodney W. Grimes *vpp = NULL; 1298df8bae1dSRodney W. Grimes return (error); 1299df8bae1dSRodney W. Grimes } 1300de6ba7c0SPoul-Henning Kamp if (ip->i_ump->um_fstype == UFS1) 1301a163d034SWarner Losh ip->i_din1 = uma_zalloc(uma_ufs1, M_WAITOK); 1302de6ba7c0SPoul-Henning Kamp else 1303a163d034SWarner Losh ip->i_din2 = uma_zalloc(uma_ufs2, M_WAITOK); 1304de6ba7c0SPoul-Henning Kamp ffs_load_inode(bp, ip, fs, ino); 1305b1897c19SJulian Elischer if (DOINGSOFTDEP(vp)) 1306b1897c19SJulian Elischer softdep_load_inodeblock(ip); 1307b1897c19SJulian Elischer else 1308b1897c19SJulian Elischer ip->i_effnlink = ip->i_nlink; 1309bd7e5f99SJohn Dyson bqrelse(bp); 1310df8bae1dSRodney W. Grimes 1311df8bae1dSRodney W. Grimes /* 1312df8bae1dSRodney W. Grimes * Initialize the vnode from the inode, check for aliases. 1313df8bae1dSRodney W. Grimes * Note that the underlying vnode may have changed. 1314df8bae1dSRodney W. Grimes */ 131502f2c6a9SPoul-Henning Kamp if (ip->i_ump->um_fstype == UFS1) 131602f2c6a9SPoul-Henning Kamp error = ufs_vinit(mp, &ffs_fifoops1, &vp); 131702f2c6a9SPoul-Henning Kamp else 131802f2c6a9SPoul-Henning Kamp error = ufs_vinit(mp, &ffs_fifoops2, &vp); 1319c9671602SPoul-Henning Kamp if (error) { 1320df8bae1dSRodney W. Grimes vput(vp); 1321df8bae1dSRodney W. Grimes *vpp = NULL; 1322df8bae1dSRodney W. Grimes return (error); 1323df8bae1dSRodney W. Grimes } 1324de68347bSPoul-Henning Kamp 1325df8bae1dSRodney W. Grimes /* 13265c24d6eeSPoul-Henning Kamp * Finish inode initialization. 1327df8bae1dSRodney W. Grimes */ 1328de68347bSPoul-Henning Kamp 1329df8bae1dSRodney W. Grimes /* 1330df8bae1dSRodney W. Grimes * Set up a generation number for this inode if it does not 1331df8bae1dSRodney W. Grimes * already have one. This should only happen on old filesystems. 1332df8bae1dSRodney W. Grimes */ 1333df8bae1dSRodney W. Grimes if (ip->i_gen == 0) { 1334aca3e497SKirk McKusick ip->i_gen = arc4random() / 2 + 1; 13351c85e6a3SKirk McKusick if ((vp->v_mount->mnt_flag & MNT_RDONLY) == 0) { 1336df8bae1dSRodney W. Grimes ip->i_flag |= IN_MODIFIED; 1337b403319bSAlexander Kabaev DIP_SET(ip, i_gen, ip->i_gen); 13381c85e6a3SKirk McKusick } 1339df8bae1dSRodney W. Grimes } 1340df8bae1dSRodney W. Grimes /* 1341df8bae1dSRodney W. Grimes * Ensure that uid and gid are correct. This is a temporary 1342df8bae1dSRodney W. Grimes * fix until fsck has been changed to do the update. 1343df8bae1dSRodney W. Grimes */ 13441c85e6a3SKirk McKusick if (fs->fs_magic == FS_UFS1_MAGIC && /* XXX */ 13451c85e6a3SKirk McKusick fs->fs_old_inodefmt < FS_44INODEFMT) { /* XXX */ 13461c85e6a3SKirk McKusick ip->i_uid = ip->i_din1->di_ouid; /* XXX */ 13471c85e6a3SKirk McKusick ip->i_gid = ip->i_din1->di_ogid; /* XXX */ 1348df8bae1dSRodney W. Grimes } /* XXX */ 1349df8bae1dSRodney W. Grimes 1350763bbd2fSRobert Watson #ifdef MAC 1351763bbd2fSRobert Watson if ((mp->mnt_flag & MNT_MULTILABEL) && ip->i_mode) { 1352763bbd2fSRobert Watson /* 1353763bbd2fSRobert Watson * If this vnode is already allocated, and we're running 1354763bbd2fSRobert Watson * multi-label, attempt to perform a label association 1355763bbd2fSRobert Watson * from the extended attributes on the inode. 1356763bbd2fSRobert Watson */ 1357763bbd2fSRobert Watson error = mac_associate_vnode_extattr(mp, vp); 1358763bbd2fSRobert Watson if (error) { 1359763bbd2fSRobert Watson /* ufs_inactive will release ip->i_devvp ref. */ 1360763bbd2fSRobert Watson vput(vp); 1361763bbd2fSRobert Watson *vpp = NULL; 1362763bbd2fSRobert Watson return (error); 1363763bbd2fSRobert Watson } 1364763bbd2fSRobert Watson } 1365763bbd2fSRobert Watson #endif 1366763bbd2fSRobert Watson 1367df8bae1dSRodney W. Grimes *vpp = vp; 1368df8bae1dSRodney W. Grimes return (0); 1369df8bae1dSRodney W. Grimes } 1370df8bae1dSRodney W. Grimes 1371df8bae1dSRodney W. Grimes /* 1372df8bae1dSRodney W. Grimes * File handle to vnode 1373df8bae1dSRodney W. Grimes * 1374df8bae1dSRodney W. Grimes * Have to be really careful about stale file handles: 1375df8bae1dSRodney W. Grimes * - check that the inode number is valid 1376df8bae1dSRodney W. Grimes * - call ffs_vget() to get the locked inode 1377df8bae1dSRodney W. Grimes * - check for an unallocated inode (i_mode == 0) 1378df8bae1dSRodney W. Grimes * - check that the given client host has export rights and return 1379df8bae1dSRodney W. Grimes * those rights via. exflagsp and credanonp 1380df8bae1dSRodney W. Grimes */ 1381adf41577SPoul-Henning Kamp static int 1382c24fda81SAlfred Perlstein ffs_fhtovp(mp, fhp, vpp) 138305f4ff5dSPoul-Henning Kamp struct mount *mp; 1384df8bae1dSRodney W. Grimes struct fid *fhp; 1385df8bae1dSRodney W. Grimes struct vnode **vpp; 1386df8bae1dSRodney W. Grimes { 138705f4ff5dSPoul-Henning Kamp struct ufid *ufhp; 1388df8bae1dSRodney W. Grimes struct fs *fs; 1389df8bae1dSRodney W. Grimes 1390df8bae1dSRodney W. Grimes ufhp = (struct ufid *)fhp; 1391df8bae1dSRodney W. Grimes fs = VFSTOUFS(mp)->um_fs; 1392df8bae1dSRodney W. Grimes if (ufhp->ufid_ino < ROOTINO || 1393df8bae1dSRodney W. Grimes ufhp->ufid_ino >= fs->fs_ncg * fs->fs_ipg) 1394df8bae1dSRodney W. Grimes return (ESTALE); 1395c24fda81SAlfred Perlstein return (ufs_fhtovp(mp, ufhp, vpp)); 1396df8bae1dSRodney W. Grimes } 1397df8bae1dSRodney W. Grimes 1398df8bae1dSRodney W. Grimes /* 1399df8bae1dSRodney W. Grimes * Vnode pointer to File handle 1400df8bae1dSRodney W. Grimes */ 1401df8bae1dSRodney W. Grimes /* ARGSUSED */ 1402adf41577SPoul-Henning Kamp static int 1403df8bae1dSRodney W. Grimes ffs_vptofh(vp, fhp) 1404df8bae1dSRodney W. Grimes struct vnode *vp; 1405df8bae1dSRodney W. Grimes struct fid *fhp; 1406df8bae1dSRodney W. Grimes { 140705f4ff5dSPoul-Henning Kamp struct inode *ip; 140805f4ff5dSPoul-Henning Kamp struct ufid *ufhp; 1409df8bae1dSRodney W. Grimes 1410df8bae1dSRodney W. Grimes ip = VTOI(vp); 1411df8bae1dSRodney W. Grimes ufhp = (struct ufid *)fhp; 1412df8bae1dSRodney W. Grimes ufhp->ufid_len = sizeof(struct ufid); 1413df8bae1dSRodney W. Grimes ufhp->ufid_ino = ip->i_number; 1414df8bae1dSRodney W. Grimes ufhp->ufid_gen = ip->i_gen; 1415df8bae1dSRodney W. Grimes return (0); 1416df8bae1dSRodney W. Grimes } 1417df8bae1dSRodney W. Grimes 1418df8bae1dSRodney W. Grimes /* 14195346934fSIan Dowse * Initialize the filesystem. 1420996c772fSJohn Dyson */ 1421996c772fSJohn Dyson static int 1422996c772fSJohn Dyson ffs_init(vfsp) 1423996c772fSJohn Dyson struct vfsconf *vfsp; 1424996c772fSJohn Dyson { 1425996c772fSJohn Dyson 1426b1897c19SJulian Elischer softdep_initialize(); 1427996c772fSJohn Dyson return (ufs_init(vfsp)); 1428996c772fSJohn Dyson } 1429996c772fSJohn Dyson 1430996c772fSJohn Dyson /* 14315346934fSIan Dowse * Undo the work of ffs_init(). 14325346934fSIan Dowse */ 14335346934fSIan Dowse static int 14345346934fSIan Dowse ffs_uninit(vfsp) 14355346934fSIan Dowse struct vfsconf *vfsp; 14365346934fSIan Dowse { 14375346934fSIan Dowse int ret; 14385346934fSIan Dowse 14395346934fSIan Dowse ret = ufs_uninit(vfsp); 14405346934fSIan Dowse softdep_uninitialize(); 14415346934fSIan Dowse return (ret); 14425346934fSIan Dowse } 14435346934fSIan Dowse 14445346934fSIan Dowse /* 1445df8bae1dSRodney W. Grimes * Write a superblock and associated information back to disk. 1446df8bae1dSRodney W. Grimes */ 1447b8dce649SPoul-Henning Kamp static int 1448df8bae1dSRodney W. Grimes ffs_sbupdate(mp, waitfor) 1449df8bae1dSRodney W. Grimes struct ufsmount *mp; 1450df8bae1dSRodney W. Grimes int waitfor; 1451df8bae1dSRodney W. Grimes { 14521c85e6a3SKirk McKusick struct fs *fs = mp->um_fs; 14533ba649d7SJeff Roberson struct buf *sbbp; 145405f4ff5dSPoul-Henning Kamp struct buf *bp; 1455df8bae1dSRodney W. Grimes int blks; 1456f55ff3f3SIan Dowse void *space; 1457996c772fSJohn Dyson int i, size, error, allerror = 0; 1458df8bae1dSRodney W. Grimes 145974f3809aSKirk McKusick if (fs->fs_ronly == 1 && 146074f3809aSKirk McKusick (mp->um_mountp->mnt_flag & (MNT_RDONLY | MNT_UPDATE)) != 146174f3809aSKirk McKusick (MNT_RDONLY | MNT_UPDATE)) 146274f3809aSKirk McKusick panic("ffs_sbupdate: write read-only filesystem"); 1463996c772fSJohn Dyson /* 14643ba649d7SJeff Roberson * We use the superblock's buf to serialize calls to ffs_sbupdate(). 14653ba649d7SJeff Roberson */ 14663ba649d7SJeff Roberson sbbp = getblk(mp->um_devvp, btodb(fs->fs_sblockloc), (int)fs->fs_sbsize, 14673ba649d7SJeff Roberson 0, 0, 0); 14683ba649d7SJeff Roberson /* 1469996c772fSJohn Dyson * First write back the summary information. 1470996c772fSJohn Dyson */ 1471df8bae1dSRodney W. Grimes blks = howmany(fs->fs_cssize, fs->fs_fsize); 1472f55ff3f3SIan Dowse space = fs->fs_csp; 1473df8bae1dSRodney W. Grimes for (i = 0; i < blks; i += fs->fs_frag) { 1474df8bae1dSRodney W. Grimes size = fs->fs_bsize; 1475df8bae1dSRodney W. Grimes if (i + fs->fs_frag > blks) 1476df8bae1dSRodney W. Grimes size = (blks - i) * fs->fs_fsize; 1477df8bae1dSRodney W. Grimes bp = getblk(mp->um_devvp, fsbtodb(fs, fs->fs_csaddr + i), 14787261f5f6SJeff Roberson size, 0, 0, 0); 1479df8bae1dSRodney W. Grimes bcopy(space, bp->b_data, (u_int)size); 1480f55ff3f3SIan Dowse space = (char *)space + size; 1481996c772fSJohn Dyson if (waitfor != MNT_WAIT) 1482df8bae1dSRodney W. Grimes bawrite(bp); 14838aef1712SMatthew Dillon else if ((error = bwrite(bp)) != 0) 1484996c772fSJohn Dyson allerror = error; 1485df8bae1dSRodney W. Grimes } 1486996c772fSJohn Dyson /* 1487996c772fSJohn Dyson * Now write back the superblock itself. If any errors occurred 1488996c772fSJohn Dyson * up to this point, then fail so that the superblock avoids 1489996c772fSJohn Dyson * being written out as clean. 1490996c772fSJohn Dyson */ 14913ba649d7SJeff Roberson if (allerror) { 14923ba649d7SJeff Roberson brelse(sbbp); 1493996c772fSJohn Dyson return (allerror); 14943ba649d7SJeff Roberson } 14953ba649d7SJeff Roberson bp = sbbp; 149631574422SKirk McKusick if (fs->fs_magic == FS_UFS1_MAGIC && fs->fs_sblockloc != SBLOCK_UFS1 && 149731574422SKirk McKusick (fs->fs_flags & FS_FLAGS_UPDATED) == 0) { 1498fa5d33e2SKirk McKusick printf("%s: correcting fs_sblockloc from %jd to %d\n", 1499fa5d33e2SKirk McKusick fs->fs_fsmnt, fs->fs_sblockloc, SBLOCK_UFS1); 1500fa5d33e2SKirk McKusick fs->fs_sblockloc = SBLOCK_UFS1; 1501fa5d33e2SKirk McKusick } 150231574422SKirk McKusick if (fs->fs_magic == FS_UFS2_MAGIC && fs->fs_sblockloc != SBLOCK_UFS2 && 150331574422SKirk McKusick (fs->fs_flags & FS_FLAGS_UPDATED) == 0) { 1504fa5d33e2SKirk McKusick printf("%s: correcting fs_sblockloc from %jd to %d\n", 1505fa5d33e2SKirk McKusick fs->fs_fsmnt, fs->fs_sblockloc, SBLOCK_UFS2); 1506fa5d33e2SKirk McKusick fs->fs_sblockloc = SBLOCK_UFS2; 1507fa5d33e2SKirk McKusick } 1508b1897c19SJulian Elischer fs->fs_fmod = 0; 1509227ee8a1SPoul-Henning Kamp fs->fs_time = time_second; 1510996c772fSJohn Dyson bcopy((caddr_t)fs, bp->b_data, (u_int)fs->fs_sbsize); 15111c85e6a3SKirk McKusick ffs_oldfscompat_write((struct fs *)bp->b_data, mp); 1512996c772fSJohn Dyson if (waitfor != MNT_WAIT) 1513996c772fSJohn Dyson bawrite(bp); 15148aef1712SMatthew Dillon else if ((error = bwrite(bp)) != 0) 1515996c772fSJohn Dyson allerror = error; 1516996c772fSJohn Dyson return (allerror); 1517df8bae1dSRodney W. Grimes } 1518d6fe88e4SPoul-Henning Kamp 1519d6fe88e4SPoul-Henning Kamp static int 1520d6fe88e4SPoul-Henning Kamp ffs_extattrctl(struct mount *mp, int cmd, struct vnode *filename_vp, 1521d6fe88e4SPoul-Henning Kamp int attrnamespace, const char *attrname, struct thread *td) 1522d6fe88e4SPoul-Henning Kamp { 1523d6fe88e4SPoul-Henning Kamp 1524d6fe88e4SPoul-Henning Kamp #ifdef UFS_EXTATTR 1525d6fe88e4SPoul-Henning Kamp return (ufs_extattrctl(mp, cmd, filename_vp, attrnamespace, 1526d6fe88e4SPoul-Henning Kamp attrname, td)); 1527d6fe88e4SPoul-Henning Kamp #else 1528d6fe88e4SPoul-Henning Kamp return (vfs_stdextattrctl(mp, cmd, filename_vp, attrnamespace, 1529d6fe88e4SPoul-Henning Kamp attrname, td)); 1530d6fe88e4SPoul-Henning Kamp #endif 1531d6fe88e4SPoul-Henning Kamp } 1532975512a9SPoul-Henning Kamp 1533975512a9SPoul-Henning Kamp static void 1534975512a9SPoul-Henning Kamp ffs_ifree(struct ufsmount *ump, struct inode *ip) 1535975512a9SPoul-Henning Kamp { 1536975512a9SPoul-Henning Kamp 153736329289STim J. Robbins if (ump->um_fstype == UFS1 && ip->i_din1 != NULL) 1538aa4d7a8aSPoul-Henning Kamp uma_zfree(uma_ufs1, ip->i_din1); 153936329289STim J. Robbins else if (ip->i_din2 != NULL) 15408d721e87STim J. Robbins uma_zfree(uma_ufs2, ip->i_din2); 1541aa4d7a8aSPoul-Henning Kamp uma_zfree(uma_inode, ip); 1542975512a9SPoul-Henning Kamp } 15436e77a041SPoul-Henning Kamp 1544dd19a799SPoul-Henning Kamp static int dobkgrdwrite = 1; 1545dd19a799SPoul-Henning Kamp SYSCTL_INT(_debug, OID_AUTO, dobkgrdwrite, CTLFLAG_RW, &dobkgrdwrite, 0, 1546dd19a799SPoul-Henning Kamp "Do background writes (honoring the BV_BKGRDWRITE flag)?"); 1547dd19a799SPoul-Henning Kamp 1548dd19a799SPoul-Henning Kamp /* 1549dd19a799SPoul-Henning Kamp * Complete a background write started from bwrite. 1550dd19a799SPoul-Henning Kamp */ 1551dd19a799SPoul-Henning Kamp static void 1552dd19a799SPoul-Henning Kamp ffs_backgroundwritedone(struct buf *bp) 1553dd19a799SPoul-Henning Kamp { 1554204ec66dSJeff Roberson struct bufobj *bufobj; 1555dd19a799SPoul-Henning Kamp struct buf *origbp; 1556dd19a799SPoul-Henning Kamp 1557dd19a799SPoul-Henning Kamp /* 1558dd19a799SPoul-Henning Kamp * Find the original buffer that we are writing. 1559dd19a799SPoul-Henning Kamp */ 1560204ec66dSJeff Roberson bufobj = bp->b_bufobj; 1561204ec66dSJeff Roberson BO_LOCK(bufobj); 1562dd19a799SPoul-Henning Kamp if ((origbp = gbincore(bp->b_bufobj, bp->b_lblkno)) == NULL) 1563dd19a799SPoul-Henning Kamp panic("backgroundwritedone: lost buffer"); 1564204ec66dSJeff Roberson /* Grab an extra reference to be dropped by the bufdone() below. */ 1565204ec66dSJeff Roberson bufobj_wrefl(bufobj); 1566204ec66dSJeff Roberson BO_UNLOCK(bufobj); 1567dd19a799SPoul-Henning Kamp /* 1568dd19a799SPoul-Henning Kamp * Process dependencies then return any unfinished ones. 1569dd19a799SPoul-Henning Kamp */ 1570dd19a799SPoul-Henning Kamp if (LIST_FIRST(&bp->b_dep) != NULL) 1571dd19a799SPoul-Henning Kamp buf_complete(bp); 1572dd19a799SPoul-Henning Kamp #ifdef SOFTUPDATES 1573dd19a799SPoul-Henning Kamp if (LIST_FIRST(&bp->b_dep) != NULL) 1574dd19a799SPoul-Henning Kamp softdep_move_dependencies(bp, origbp); 1575dd19a799SPoul-Henning Kamp #endif 1576dd19a799SPoul-Henning Kamp /* 1577204ec66dSJeff Roberson * This buffer is marked B_NOCACHE so when it is released 1578204ec66dSJeff Roberson * by biodone it will be tossed. 1579dd19a799SPoul-Henning Kamp */ 1580dd19a799SPoul-Henning Kamp bp->b_flags |= B_NOCACHE; 1581ec9c9e73SAlan Cox bp->b_flags &= ~B_CACHE; 1582dd19a799SPoul-Henning Kamp bufdone(bp); 1583204ec66dSJeff Roberson BO_LOCK(bufobj); 1584dd19a799SPoul-Henning Kamp /* 1585dd19a799SPoul-Henning Kamp * Clear the BV_BKGRDINPROG flag in the original buffer 1586dd19a799SPoul-Henning Kamp * and awaken it if it is waiting for the write to complete. 1587dd19a799SPoul-Henning Kamp * If BV_BKGRDINPROG is not set in the original buffer it must 1588dd19a799SPoul-Henning Kamp * have been released and re-instantiated - which is not legal. 1589dd19a799SPoul-Henning Kamp */ 1590dd19a799SPoul-Henning Kamp KASSERT((origbp->b_vflags & BV_BKGRDINPROG), 1591dd19a799SPoul-Henning Kamp ("backgroundwritedone: lost buffer2")); 1592dd19a799SPoul-Henning Kamp origbp->b_vflags &= ~BV_BKGRDINPROG; 1593dd19a799SPoul-Henning Kamp if (origbp->b_vflags & BV_BKGRDWAIT) { 1594dd19a799SPoul-Henning Kamp origbp->b_vflags &= ~BV_BKGRDWAIT; 1595dd19a799SPoul-Henning Kamp wakeup(&origbp->b_xflags); 1596dd19a799SPoul-Henning Kamp } 1597204ec66dSJeff Roberson BO_UNLOCK(bufobj); 1598dd19a799SPoul-Henning Kamp } 1599dd19a799SPoul-Henning Kamp 1600dd19a799SPoul-Henning Kamp 1601dd19a799SPoul-Henning Kamp /* 1602dd19a799SPoul-Henning Kamp * Write, release buffer on completion. (Done by iodone 1603dd19a799SPoul-Henning Kamp * if async). Do not bother writing anything if the buffer 1604dd19a799SPoul-Henning Kamp * is invalid. 1605dd19a799SPoul-Henning Kamp * 1606dd19a799SPoul-Henning Kamp * Note that we set B_CACHE here, indicating that buffer is 1607dd19a799SPoul-Henning Kamp * fully valid and thus cacheable. This is true even of NFS 1608dd19a799SPoul-Henning Kamp * now so we set it generally. This could be set either here 1609dd19a799SPoul-Henning Kamp * or in biodone() since the I/O is synchronous. We put it 1610dd19a799SPoul-Henning Kamp * here. 1611dd19a799SPoul-Henning Kamp */ 1612dd19a799SPoul-Henning Kamp static int 1613dd19a799SPoul-Henning Kamp ffs_bufwrite(struct buf *bp) 1614dd19a799SPoul-Henning Kamp { 1615dd19a799SPoul-Henning Kamp int oldflags, s; 1616dd19a799SPoul-Henning Kamp struct buf *newbp; 1617dd19a799SPoul-Henning Kamp 1618dd19a799SPoul-Henning Kamp CTR3(KTR_BUF, "bufwrite(%p) vp %p flags %X", bp, bp->b_vp, bp->b_flags); 1619dd19a799SPoul-Henning Kamp if (bp->b_flags & B_INVAL) { 1620dd19a799SPoul-Henning Kamp brelse(bp); 1621dd19a799SPoul-Henning Kamp return (0); 1622dd19a799SPoul-Henning Kamp } 1623dd19a799SPoul-Henning Kamp 1624dd19a799SPoul-Henning Kamp oldflags = bp->b_flags; 1625dd19a799SPoul-Henning Kamp 1626dd19a799SPoul-Henning Kamp if (BUF_REFCNT(bp) == 0) 1627dd19a799SPoul-Henning Kamp panic("bufwrite: buffer is not busy???"); 1628dd19a799SPoul-Henning Kamp s = splbio(); 1629dd19a799SPoul-Henning Kamp /* 1630dd19a799SPoul-Henning Kamp * If a background write is already in progress, delay 1631dd19a799SPoul-Henning Kamp * writing this block if it is asynchronous. Otherwise 1632dd19a799SPoul-Henning Kamp * wait for the background write to complete. 1633dd19a799SPoul-Henning Kamp */ 1634dd19a799SPoul-Henning Kamp BO_LOCK(bp->b_bufobj); 1635dd19a799SPoul-Henning Kamp if (bp->b_vflags & BV_BKGRDINPROG) { 1636dd19a799SPoul-Henning Kamp if (bp->b_flags & B_ASYNC) { 1637dd19a799SPoul-Henning Kamp BO_UNLOCK(bp->b_bufobj); 1638dd19a799SPoul-Henning Kamp splx(s); 1639dd19a799SPoul-Henning Kamp bdwrite(bp); 1640dd19a799SPoul-Henning Kamp return (0); 1641dd19a799SPoul-Henning Kamp } 1642dd19a799SPoul-Henning Kamp bp->b_vflags |= BV_BKGRDWAIT; 1643dd19a799SPoul-Henning Kamp msleep(&bp->b_xflags, BO_MTX(bp->b_bufobj), PRIBIO, "bwrbg", 0); 1644dd19a799SPoul-Henning Kamp if (bp->b_vflags & BV_BKGRDINPROG) 1645dd19a799SPoul-Henning Kamp panic("bufwrite: still writing"); 1646dd19a799SPoul-Henning Kamp } 1647dd19a799SPoul-Henning Kamp BO_UNLOCK(bp->b_bufobj); 1648dd19a799SPoul-Henning Kamp 1649dd19a799SPoul-Henning Kamp /* Mark the buffer clean */ 1650dd19a799SPoul-Henning Kamp bundirty(bp); 1651dd19a799SPoul-Henning Kamp 1652dd19a799SPoul-Henning Kamp /* 1653dd19a799SPoul-Henning Kamp * If this buffer is marked for background writing and we 1654dd19a799SPoul-Henning Kamp * do not have to wait for it, make a copy and write the 1655dd19a799SPoul-Henning Kamp * copy so as to leave this buffer ready for further use. 1656dd19a799SPoul-Henning Kamp * 1657dd19a799SPoul-Henning Kamp * This optimization eats a lot of memory. If we have a page 1658dd19a799SPoul-Henning Kamp * or buffer shortfall we can't do it. 1659dd19a799SPoul-Henning Kamp */ 1660dd19a799SPoul-Henning Kamp if (dobkgrdwrite && (bp->b_xflags & BX_BKGRDWRITE) && 1661dd19a799SPoul-Henning Kamp (bp->b_flags & B_ASYNC) && 1662dd19a799SPoul-Henning Kamp !vm_page_count_severe() && 1663dd19a799SPoul-Henning Kamp !buf_dirty_count_severe()) { 1664dd19a799SPoul-Henning Kamp KASSERT(bp->b_iodone == NULL, 1665dd19a799SPoul-Henning Kamp ("bufwrite: needs chained iodone (%p)", bp->b_iodone)); 1666dd19a799SPoul-Henning Kamp 1667dd19a799SPoul-Henning Kamp /* get a new block */ 1668dd19a799SPoul-Henning Kamp newbp = geteblk(bp->b_bufsize); 1669dd19a799SPoul-Henning Kamp 1670dd19a799SPoul-Henning Kamp /* 1671dd19a799SPoul-Henning Kamp * set it to be identical to the old block. We have to 1672dd19a799SPoul-Henning Kamp * set b_lblkno and BKGRDMARKER before calling bgetvp() 1673dd19a799SPoul-Henning Kamp * to avoid confusing the splay tree and gbincore(). 1674dd19a799SPoul-Henning Kamp */ 1675dd19a799SPoul-Henning Kamp memcpy(newbp->b_data, bp->b_data, bp->b_bufsize); 1676dd19a799SPoul-Henning Kamp newbp->b_lblkno = bp->b_lblkno; 1677dd19a799SPoul-Henning Kamp newbp->b_xflags |= BX_BKGRDMARKER; 1678dd19a799SPoul-Henning Kamp BO_LOCK(bp->b_bufobj); 1679dd19a799SPoul-Henning Kamp bp->b_vflags |= BV_BKGRDINPROG; 1680dd19a799SPoul-Henning Kamp bgetvp(bp->b_vp, newbp); 1681dd19a799SPoul-Henning Kamp BO_UNLOCK(bp->b_bufobj); 1682dd19a799SPoul-Henning Kamp newbp->b_bufobj = &bp->b_vp->v_bufobj; 1683dd19a799SPoul-Henning Kamp newbp->b_blkno = bp->b_blkno; 1684dd19a799SPoul-Henning Kamp newbp->b_offset = bp->b_offset; 1685dd19a799SPoul-Henning Kamp newbp->b_iodone = ffs_backgroundwritedone; 1686dd19a799SPoul-Henning Kamp newbp->b_flags |= B_ASYNC; 1687dd19a799SPoul-Henning Kamp newbp->b_flags &= ~B_INVAL; 1688dd19a799SPoul-Henning Kamp 1689dd19a799SPoul-Henning Kamp #ifdef SOFTUPDATES 1690dd19a799SPoul-Henning Kamp /* move over the dependencies */ 1691dd19a799SPoul-Henning Kamp if (LIST_FIRST(&bp->b_dep) != NULL) 1692dd19a799SPoul-Henning Kamp softdep_move_dependencies(bp, newbp); 1693dd19a799SPoul-Henning Kamp #endif 1694dd19a799SPoul-Henning Kamp 1695dd19a799SPoul-Henning Kamp /* 1696dd19a799SPoul-Henning Kamp * Initiate write on the copy, release the original to 1697dd19a799SPoul-Henning Kamp * the B_LOCKED queue so that it cannot go away until 1698dd19a799SPoul-Henning Kamp * the background write completes. If not locked it could go 1699dd19a799SPoul-Henning Kamp * away and then be reconstituted while it was being written. 1700dd19a799SPoul-Henning Kamp * If the reconstituted buffer were written, we could end up 1701dd19a799SPoul-Henning Kamp * with two background copies being written at the same time. 1702dd19a799SPoul-Henning Kamp */ 1703dd19a799SPoul-Henning Kamp bqrelse(bp); 1704dd19a799SPoul-Henning Kamp bp = newbp; 1705dd19a799SPoul-Henning Kamp } 1706dd19a799SPoul-Henning Kamp 1707dd19a799SPoul-Henning Kamp /* Let the normal bufwrite do the rest for us */ 17089248a827STor Egge return (bufwrite(bp)); 1709dd19a799SPoul-Henning Kamp } 1710dd19a799SPoul-Henning Kamp 1711dd19a799SPoul-Henning Kamp 17128dd56505SPoul-Henning Kamp static void 17136e77a041SPoul-Henning Kamp ffs_geom_strategy(struct bufobj *bo, struct buf *bp) 17146e77a041SPoul-Henning Kamp { 1715153910e0SJeff Roberson struct vnode *vp; 1716153910e0SJeff Roberson int error; 17176e77a041SPoul-Henning Kamp 1718153910e0SJeff Roberson vp = bo->__bo_vnode; 1719153910e0SJeff Roberson if (bp->b_iocmd == BIO_WRITE) { 17206e77a041SPoul-Henning Kamp #ifdef SOFTUPDATES 1721153910e0SJeff Roberson if (LIST_FIRST(&bp->b_dep) != NULL) 1722153910e0SJeff Roberson buf_start(bp); 17236e77a041SPoul-Henning Kamp #endif 1724153910e0SJeff Roberson if ((bp->b_flags & B_VALIDSUSPWRT) == 0 && 1725153910e0SJeff Roberson bp->b_vp != NULL && bp->b_vp->v_mount != NULL && 1726153910e0SJeff Roberson (bp->b_vp->v_mount->mnt_kern_flag & MNTK_SUSPENDED) != 0) 1727153910e0SJeff Roberson panic("ffs_geom_strategy: bad I/O"); 1728153910e0SJeff Roberson bp->b_flags &= ~B_VALIDSUSPWRT; 1729153910e0SJeff Roberson if ((vp->v_vflag & VV_COPYONWRITE) && 1730153910e0SJeff Roberson vp->v_rdev->si_snapdata != NULL && 1731153910e0SJeff Roberson (error = (ffs_copyonwrite)(vp, bp)) != 0 && 1732153910e0SJeff Roberson error != EOPNOTSUPP) { 1733153910e0SJeff Roberson bp->b_error = error; 1734153910e0SJeff Roberson bp->b_ioflags |= BIO_ERROR; 1735153910e0SJeff Roberson bufdone(bp); 1736153910e0SJeff Roberson return; 1737153910e0SJeff Roberson } 1738153910e0SJeff Roberson } 173943920011SPoul-Henning Kamp g_vfs_strategy(bo, bp); 17406e77a041SPoul-Henning Kamp } 1741