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. 13fbbd9655SWarner Losh * 3. 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 3501733a9bSGarrett Wollman #include "opt_quota.h" 36516081f2SRobert Watson #include "opt_ufs.h" 376e77a041SPoul-Henning Kamp #include "opt_ffs.h" 3852dfc8d7SKonstantin Belousov #include "opt_ddb.h" 3901733a9bSGarrett Wollman 40df8bae1dSRodney W. Grimes #include <sys/param.h> 41df8bae1dSRodney W. Grimes #include <sys/systm.h> 42df8bae1dSRodney W. Grimes #include <sys/namei.h> 43acd3428bSRobert Watson #include <sys/priv.h> 44df8bae1dSRodney W. Grimes #include <sys/proc.h> 45c79dff0fSKonstantin Belousov #include <sys/taskqueue.h> 46df8bae1dSRodney W. Grimes #include <sys/kernel.h> 47df8bae1dSRodney W. Grimes #include <sys/vnode.h> 48df8bae1dSRodney W. Grimes #include <sys/mount.h> 499626b608SPoul-Henning Kamp #include <sys/bio.h> 50df8bae1dSRodney W. Grimes #include <sys/buf.h> 5181bca6ddSKATO Takenori #include <sys/conf.h> 523ac4d1efSBruce Evans #include <sys/fcntl.h> 531848286aSEdward Tomasz Napierala #include <sys/ioccom.h> 54df8bae1dSRodney W. Grimes #include <sys/malloc.h> 551b367556SJason Evans #include <sys/mutex.h> 5622a72260SJeff Roberson #include <sys/rwlock.h> 57*9ed01c32SGleb Smirnoff #include <sys/vmmeter.h> 58a18b1f1dSJason Evans 59aed55708SRobert Watson #include <security/mac/mac_framework.h> 60aed55708SRobert Watson 61a96da1c3SConrad Meyer #include <ufs/ufs/dir.h> 62a64ed089SRobert Watson #include <ufs/ufs/extattr.h> 631a60c7fcSPawel Jakub Dawidek #include <ufs/ufs/gjournal.h> 64df8bae1dSRodney W. Grimes #include <ufs/ufs/quota.h> 65df8bae1dSRodney W. Grimes #include <ufs/ufs/ufsmount.h> 66df8bae1dSRodney W. Grimes #include <ufs/ufs/inode.h> 67df8bae1dSRodney W. Grimes #include <ufs/ufs/ufs_extern.h> 68df8bae1dSRodney W. Grimes 69df8bae1dSRodney W. Grimes #include <ufs/ffs/fs.h> 70df8bae1dSRodney W. Grimes #include <ufs/ffs/ffs_extern.h> 71df8bae1dSRodney W. Grimes 72f6b04d2bSDavid Greenman #include <vm/vm.h> 73aa4d7a8aSPoul-Henning Kamp #include <vm/uma.h> 74f6b04d2bSDavid Greenman #include <vm/vm_page.h> 75f6b04d2bSDavid Greenman 7643920011SPoul-Henning Kamp #include <geom/geom.h> 7743920011SPoul-Henning Kamp #include <geom/geom_vfs.h> 7843920011SPoul-Henning Kamp 7952dfc8d7SKonstantin Belousov #include <ddb/ddb.h> 8052dfc8d7SKonstantin Belousov 81adf41577SPoul-Henning Kamp static uma_zone_t uma_inode, uma_ufs1, uma_ufs2; 8255166637SPoul-Henning Kamp 83975512a9SPoul-Henning Kamp static int ffs_mountfs(struct vnode *, struct mount *, struct thread *); 841c85e6a3SKirk McKusick static void ffs_oldfscompat_read(struct fs *, struct ufsmount *, 851c85e6a3SKirk McKusick ufs2_daddr_t); 86975512a9SPoul-Henning Kamp static void ffs_ifree(struct ufsmount *ump, struct inode *ip); 87a988a5c6SKonstantin Belousov static int ffs_sync_lazy(struct mount *mp); 88a988a5c6SKonstantin Belousov 899bf1a756SPoul-Henning Kamp static vfs_init_t ffs_init; 909bf1a756SPoul-Henning Kamp static vfs_uninit_t ffs_uninit; 91d6fe88e4SPoul-Henning Kamp static vfs_extattrctl_t ffs_extattrctl; 9220a92a18SPoul-Henning Kamp static vfs_cmount_t ffs_cmount; 93adf41577SPoul-Henning Kamp static vfs_unmount_t ffs_unmount; 9420a92a18SPoul-Henning Kamp static vfs_mount_t ffs_mount; 95adf41577SPoul-Henning Kamp static vfs_statfs_t ffs_statfs; 96adf41577SPoul-Henning Kamp static vfs_fhtovp_t ffs_fhtovp; 97adf41577SPoul-Henning Kamp static vfs_sync_t ffs_sync; 98df8bae1dSRodney W. Grimes 99303b270bSEivind Eklund static struct vfsops ufs_vfsops = { 1007652131bSPoul-Henning Kamp .vfs_extattrctl = ffs_extattrctl, 1017652131bSPoul-Henning Kamp .vfs_fhtovp = ffs_fhtovp, 1027652131bSPoul-Henning Kamp .vfs_init = ffs_init, 10320a92a18SPoul-Henning Kamp .vfs_mount = ffs_mount, 10420a92a18SPoul-Henning Kamp .vfs_cmount = ffs_cmount, 1057652131bSPoul-Henning Kamp .vfs_quotactl = ufs_quotactl, 1067652131bSPoul-Henning Kamp .vfs_root = ufs_root, 1077652131bSPoul-Henning Kamp .vfs_statfs = ffs_statfs, 1087652131bSPoul-Henning Kamp .vfs_sync = ffs_sync, 1097652131bSPoul-Henning Kamp .vfs_uninit = ffs_uninit, 1107652131bSPoul-Henning Kamp .vfs_unmount = ffs_unmount, 1117652131bSPoul-Henning Kamp .vfs_vget = ffs_vget, 1122814d5baSKonstantin Belousov .vfs_susp_clean = process_deferred_inactive, 113df8bae1dSRodney W. Grimes }; 114df8bae1dSRodney W. Grimes 1158994ca3cSBruce Evans VFS_SET(ufs_vfsops, ufs, 0); 1165fe6d2beSPawel Jakub Dawidek MODULE_VERSION(ufs, 1); 117c901836cSGarrett Wollman 1186e77a041SPoul-Henning Kamp static b_strategy_t ffs_geom_strategy; 119dd19a799SPoul-Henning Kamp static b_write_t ffs_bufwrite; 1206e77a041SPoul-Henning Kamp 1216e77a041SPoul-Henning Kamp static struct buf_ops ffs_ops = { 1226e77a041SPoul-Henning Kamp .bop_name = "FFS", 123dd19a799SPoul-Henning Kamp .bop_write = ffs_bufwrite, 1246e77a041SPoul-Henning Kamp .bop_strategy = ffs_geom_strategy, 1256ef8480aSPoul-Henning Kamp .bop_sync = bufsync, 1262cc7d26fSKonstantin Belousov #ifdef NO_FFS_SNAPSHOT 1272cc7d26fSKonstantin Belousov .bop_bdflush = bufbdflush, 1282cc7d26fSKonstantin Belousov #else 1292cc7d26fSKonstantin Belousov .bop_bdflush = ffs_bdflush, 1302cc7d26fSKonstantin Belousov #endif 1316e77a041SPoul-Henning Kamp }; 1326e77a041SPoul-Henning Kamp 1330b962648SAndriy Gapon /* 1340b962648SAndriy Gapon * Note that userquota and groupquota options are not currently used 1350b962648SAndriy Gapon * by UFS/FFS code and generally mount(8) does not pass those options 1360b962648SAndriy Gapon * from userland, but they can be passed by loader(8) via 1370b962648SAndriy Gapon * vfs.root.mountfrom.options. 1380b962648SAndriy Gapon */ 139d952ba1bSJohn Baldwin static const char *ffs_opts[] = { "acls", "async", "noatime", "noclusterr", 1400b962648SAndriy Gapon "noclusterw", "noexec", "export", "force", "from", "groupquota", 141927a12aeSKirk McKusick "multilabel", "nfsv4acls", "fsckpid", "snapshot", "nosuid", "suiddir", 142927a12aeSKirk McKusick "nosymfollow", "sync", "union", "userquota", NULL }; 14320a92a18SPoul-Henning Kamp 1445e8c582aSPoul-Henning Kamp static int 145dfd233edSAttilio Rao ffs_mount(struct mount *mp) 146df8bae1dSRodney W. Grimes { 14720a92a18SPoul-Henning Kamp struct vnode *devvp; 148dfd233edSAttilio Rao struct thread *td; 149f7a3729cSKevin Lo struct ufsmount *ump = NULL; 15005f4ff5dSPoul-Henning Kamp struct fs *fs; 151927a12aeSKirk McKusick pid_t fsckpid = 0; 152714b7df5SKonstantin Belousov int error, error1, flags; 153cc672d35SKirk McKusick uint64_t mntorflags; 15415bc6b2bSEdward Tomasz Napierala accmode_t accmode; 1555e8c582aSPoul-Henning Kamp struct nameidata ndp; 15620a92a18SPoul-Henning Kamp char *fspec; 157df8bae1dSRodney W. Grimes 158dfd233edSAttilio Rao td = curthread; 15920a92a18SPoul-Henning Kamp if (vfs_filteropt(mp->mnt_optnew, ffs_opts)) 16020a92a18SPoul-Henning Kamp return (EINVAL); 161aa4d7a8aSPoul-Henning Kamp if (uma_inode == NULL) { 162aa4d7a8aSPoul-Henning Kamp uma_inode = uma_zcreate("FFS inode", 163aa4d7a8aSPoul-Henning Kamp sizeof(struct inode), NULL, NULL, NULL, NULL, 164aa4d7a8aSPoul-Henning Kamp UMA_ALIGN_PTR, 0); 165aa4d7a8aSPoul-Henning Kamp uma_ufs1 = uma_zcreate("FFS1 dinode", 166aa4d7a8aSPoul-Henning Kamp sizeof(struct ufs1_dinode), NULL, NULL, NULL, NULL, 167aa4d7a8aSPoul-Henning Kamp UMA_ALIGN_PTR, 0); 168aa4d7a8aSPoul-Henning Kamp uma_ufs2 = uma_zcreate("FFS2 dinode", 169aa4d7a8aSPoul-Henning Kamp sizeof(struct ufs2_dinode), NULL, NULL, NULL, NULL, 170aa4d7a8aSPoul-Henning Kamp UMA_ALIGN_PTR, 0); 171aa4d7a8aSPoul-Henning Kamp } 1728d02a378SPawel Jakub Dawidek 1730b962648SAndriy Gapon vfs_deleteopt(mp->mnt_optnew, "groupquota"); 1740b962648SAndriy Gapon vfs_deleteopt(mp->mnt_optnew, "userquota"); 1750b962648SAndriy Gapon 17620a92a18SPoul-Henning Kamp fspec = vfs_getopts(mp->mnt_optnew, "from", &error); 17751ac12abSPoul-Henning Kamp if (error) 178f2a2857bSKirk McKusick return (error); 1792b14f991SJulian Elischer 1805da56ddbSTor Egge mntorflags = 0; 18126f59b64SCraig Rodrigues if (vfs_getopt(mp->mnt_optnew, "acls", NULL, NULL) == 0) 1825da56ddbSTor Egge mntorflags |= MNT_ACLS; 18326f59b64SCraig Rodrigues 184fb77e0afSCraig Rodrigues if (vfs_getopt(mp->mnt_optnew, "snapshot", NULL, NULL) == 0) { 1855da56ddbSTor Egge mntorflags |= MNT_SNAPSHOT; 186fb77e0afSCraig Rodrigues /* 187fb77e0afSCraig Rodrigues * Once we have set the MNT_SNAPSHOT flag, do not 188fb77e0afSCraig Rodrigues * persist "snapshot" in the options list. 189fb77e0afSCraig Rodrigues */ 190fb77e0afSCraig Rodrigues vfs_deleteopt(mp->mnt_optnew, "snapshot"); 191fb77e0afSCraig Rodrigues vfs_deleteopt(mp->mnt_opt, "snapshot"); 192fb77e0afSCraig Rodrigues } 19326f59b64SCraig Rodrigues 194927a12aeSKirk McKusick if (vfs_getopt(mp->mnt_optnew, "fsckpid", NULL, NULL) == 0 && 195927a12aeSKirk McKusick vfs_scanopt(mp->mnt_optnew, "fsckpid", "%d", &fsckpid) == 1) { 196927a12aeSKirk McKusick /* 197927a12aeSKirk McKusick * Once we have set the restricted PID, do not 198927a12aeSKirk McKusick * persist "fsckpid" in the options list. 199927a12aeSKirk McKusick */ 200927a12aeSKirk McKusick vfs_deleteopt(mp->mnt_optnew, "fsckpid"); 201927a12aeSKirk McKusick vfs_deleteopt(mp->mnt_opt, "fsckpid"); 202927a12aeSKirk McKusick if (mp->mnt_flag & MNT_UPDATE) { 203927a12aeSKirk McKusick if (VFSTOUFS(mp)->um_fs->fs_ronly == 0 && 204927a12aeSKirk McKusick vfs_flagopt(mp->mnt_optnew, "ro", NULL, 0) == 0) { 205b60ee81eSKirk McKusick vfs_mount_error(mp, 206b60ee81eSKirk McKusick "Checker enable: Must be read-only"); 207927a12aeSKirk McKusick return (EINVAL); 208927a12aeSKirk McKusick } 209927a12aeSKirk McKusick } else if (vfs_flagopt(mp->mnt_optnew, "ro", NULL, 0) == 0) { 210b60ee81eSKirk McKusick vfs_mount_error(mp, 211b60ee81eSKirk McKusick "Checker enable: Must be read-only"); 212927a12aeSKirk McKusick return (EINVAL); 213927a12aeSKirk McKusick } 214927a12aeSKirk McKusick /* Set to -1 if we are done */ 215927a12aeSKirk McKusick if (fsckpid == 0) 216927a12aeSKirk McKusick fsckpid = -1; 217927a12aeSKirk McKusick } 218927a12aeSKirk McKusick 2199340fc72SEdward Tomasz Napierala if (vfs_getopt(mp->mnt_optnew, "nfsv4acls", NULL, NULL) == 0) { 2209340fc72SEdward Tomasz Napierala if (mntorflags & MNT_ACLS) { 221b60ee81eSKirk McKusick vfs_mount_error(mp, 222b60ee81eSKirk McKusick "\"acls\" and \"nfsv4acls\" options " 223b60ee81eSKirk McKusick "are mutually exclusive"); 2249340fc72SEdward Tomasz Napierala return (EINVAL); 2259340fc72SEdward Tomasz Napierala } 2269340fc72SEdward Tomasz Napierala mntorflags |= MNT_NFS4ACLS; 2279340fc72SEdward Tomasz Napierala } 2289340fc72SEdward Tomasz Napierala 2295da56ddbSTor Egge MNT_ILOCK(mp); 23061996181SEdward Tomasz Napierala mp->mnt_flag |= mntorflags; 2315da56ddbSTor Egge MNT_IUNLOCK(mp); 232df8bae1dSRodney W. Grimes /* 233df8bae1dSRodney W. Grimes * If updating, check whether changing from read-only to 234df8bae1dSRodney W. Grimes * read/write; if there is no device name, that's all we do. 235df8bae1dSRodney W. Grimes */ 236df8bae1dSRodney W. Grimes if (mp->mnt_flag & MNT_UPDATE) { 237df8bae1dSRodney W. Grimes ump = VFSTOUFS(mp); 238df8bae1dSRodney W. Grimes fs = ump->um_fs; 23926cf9c3bSPeter Wemm devvp = ump->um_devvp; 240927a12aeSKirk McKusick if (fsckpid == -1 && ump->um_fsckpid > 0) { 241927a12aeSKirk McKusick if ((error = ffs_flushfiles(mp, WRITECLOSE, td)) != 0 || 242927a12aeSKirk McKusick (error = ffs_sbupdate(ump, MNT_WAIT, 0)) != 0) 243927a12aeSKirk McKusick return (error); 244927a12aeSKirk McKusick g_topology_lock(); 245927a12aeSKirk McKusick /* 246927a12aeSKirk McKusick * Return to normal read-only mode. 247927a12aeSKirk McKusick */ 248927a12aeSKirk McKusick error = g_access(ump->um_cp, 0, -1, 0); 249927a12aeSKirk McKusick g_topology_unlock(); 250927a12aeSKirk McKusick ump->um_fsckpid = 0; 251927a12aeSKirk McKusick } 25220a92a18SPoul-Henning Kamp if (fs->fs_ronly == 0 && 25320a92a18SPoul-Henning Kamp vfs_flagopt(mp->mnt_optnew, "ro", NULL, 0)) { 2546fecb4e4SKonstantin Belousov /* 2556fecb4e4SKonstantin Belousov * Flush any dirty data and suspend filesystem. 2566fecb4e4SKonstantin Belousov */ 257f2a2857bSKirk McKusick if ((error = vn_start_write(NULL, &mp, V_WAIT)) != 0) 258f2a2857bSKirk McKusick return (error); 259895b3782SKonstantin Belousov error = vfs_write_suspend_umnt(mp); 260895b3782SKonstantin Belousov if (error != 0) 2619ab73fd1SKirk McKusick return (error); 262cd600596SKirk McKusick /* 263cd600596SKirk McKusick * Check for and optionally get rid of files open 264cd600596SKirk McKusick * for writing. 265cd600596SKirk McKusick */ 266df8bae1dSRodney W. Grimes flags = WRITECLOSE; 267df8bae1dSRodney W. Grimes if (mp->mnt_flag & MNT_FORCE) 268df8bae1dSRodney W. Grimes flags |= FORCECLOSE; 269fddf7baeSKirk McKusick if (MOUNTEDSOFTDEP(mp)) { 270b40ce416SJulian Elischer error = softdep_flushfiles(mp, flags, td); 271b1897c19SJulian Elischer } else { 272b40ce416SJulian Elischer error = ffs_flushfiles(mp, flags, td); 273df8bae1dSRodney W. Grimes } 274f2a2857bSKirk McKusick if (error) { 275ddd6b3fcSKonstantin Belousov vfs_write_resume(mp, 0); 276f2a2857bSKirk McKusick return (error); 277b1897c19SJulian Elischer } 2789ccb939eSKirk McKusick if (fs->fs_pendingblocks != 0 || 2799ccb939eSKirk McKusick fs->fs_pendinginodes != 0) { 280b60ee81eSKirk McKusick printf("WARNING: %s Update error: blocks %jd " 281b60ee81eSKirk McKusick "files %d\n", fs->fs_fsmnt, 2821c85e6a3SKirk McKusick (intmax_t)fs->fs_pendingblocks, 2839ccb939eSKirk McKusick fs->fs_pendinginodes); 2849ccb939eSKirk McKusick fs->fs_pendingblocks = 0; 2859ccb939eSKirk McKusick fs->fs_pendinginodes = 0; 2869ccb939eSKirk McKusick } 2871a6a6610SKirk McKusick if ((fs->fs_flags & (FS_UNCLEAN | FS_NEEDSFSCK)) == 0) 288f2a2857bSKirk McKusick fs->fs_clean = 1; 289791dd2faSTor Egge if ((error = ffs_sbupdate(ump, MNT_WAIT, 0)) != 0) { 290f2a2857bSKirk McKusick fs->fs_ronly = 0; 291f2a2857bSKirk McKusick fs->fs_clean = 0; 292ddd6b3fcSKonstantin Belousov vfs_write_resume(mp, 0); 293f2a2857bSKirk McKusick return (error); 2942b14f991SJulian Elischer } 295fddf7baeSKirk McKusick if (MOUNTEDSOFTDEP(mp)) 2969420dc62SKirk McKusick softdep_unmount(mp); 29743920011SPoul-Henning Kamp g_topology_lock(); 2988795189cSKirk McKusick /* 2998795189cSKirk McKusick * Drop our write and exclusive access. 3008795189cSKirk McKusick */ 3018795189cSKirk McKusick g_access(ump->um_cp, 0, -1, -1); 30243920011SPoul-Henning Kamp g_topology_unlock(); 30320a92a18SPoul-Henning Kamp fs->fs_ronly = 1; 3045da56ddbSTor Egge MNT_ILOCK(mp); 30520a92a18SPoul-Henning Kamp mp->mnt_flag |= MNT_RDONLY; 3065da56ddbSTor Egge MNT_IUNLOCK(mp); 3076fecb4e4SKonstantin Belousov /* 3086fecb4e4SKonstantin Belousov * Allow the writers to note that filesystem 3096fecb4e4SKonstantin Belousov * is ro now. 3106fecb4e4SKonstantin Belousov */ 311ddd6b3fcSKonstantin Belousov vfs_write_resume(mp, 0); 312f2a2857bSKirk McKusick } 313f2a2857bSKirk McKusick if ((mp->mnt_flag & MNT_RELOAD) && 3141848286aSEdward Tomasz Napierala (error = ffs_reload(mp, td, 0)) != 0) 315f2a2857bSKirk McKusick return (error); 31620a92a18SPoul-Henning Kamp if (fs->fs_ronly && 31720a92a18SPoul-Henning Kamp !vfs_flagopt(mp->mnt_optnew, "ro", NULL, 0)) { 318c9b99213SBruce Evans /* 319927a12aeSKirk McKusick * If we are running a checker, do not allow upgrade. 320927a12aeSKirk McKusick */ 321927a12aeSKirk McKusick if (ump->um_fsckpid > 0) { 322b60ee81eSKirk McKusick vfs_mount_error(mp, 323b60ee81eSKirk McKusick "Active checker, cannot upgrade to write"); 324927a12aeSKirk McKusick return (EINVAL); 325927a12aeSKirk McKusick } 326927a12aeSKirk McKusick /* 327c9b99213SBruce Evans * If upgrade to read-write by non-root, then verify 328c9b99213SBruce Evans * that user has necessary permissions on the device. 329c9b99213SBruce Evans */ 330cb05b60aSAttilio Rao vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY); 331acd3428bSRobert Watson error = VOP_ACCESS(devvp, VREAD | VWRITE, 332acd3428bSRobert Watson td->td_ucred, td); 333acd3428bSRobert Watson if (error) 334acd3428bSRobert Watson error = priv_check(td, PRIV_VFS_MOUNT_PERM); 335acd3428bSRobert Watson if (error) { 33622db15c0SAttilio Rao VOP_UNLOCK(devvp, 0); 337c9b99213SBruce Evans return (error); 338c9b99213SBruce Evans } 33922db15c0SAttilio Rao VOP_UNLOCK(devvp, 0); 3407e58bfacSBruce Evans fs->fs_flags &= ~FS_UNCLEAN; 3410922cce6SBruce Evans if (fs->fs_clean == 0) { 3427e58bfacSBruce Evans fs->fs_flags |= FS_UNCLEAN; 343812b1d41SKirk McKusick if ((mp->mnt_flag & MNT_FORCE) || 344113db2ddSJeff Roberson ((fs->fs_flags & 345113db2ddSJeff Roberson (FS_SUJ | FS_NEEDSFSCK)) == 0 && 3461a6a6610SKirk McKusick (fs->fs_flags & FS_DOSOFTDEP))) { 347b60ee81eSKirk McKusick printf("WARNING: %s was not properly " 348b60ee81eSKirk McKusick "dismounted\n", fs->fs_fsmnt); 3490922cce6SBruce Evans } else { 350b60ee81eSKirk McKusick vfs_mount_error(mp, 351b60ee81eSKirk McKusick "R/W mount of %s denied. %s.%s", 352b60ee81eSKirk McKusick fs->fs_fsmnt, 353b60ee81eSKirk McKusick "Filesystem is not clean - run fsck", 354b60ee81eSKirk McKusick (fs->fs_flags & FS_SUJ) == 0 ? "" : 355b60ee81eSKirk McKusick " Forced mount will invalidate" 356b60ee81eSKirk McKusick " journal contents"); 357f2a2857bSKirk McKusick return (EPERM); 3580922cce6SBruce Evans } 3590922cce6SBruce Evans } 36040c340aaSPoul-Henning Kamp g_topology_lock(); 36140c340aaSPoul-Henning Kamp /* 3628795189cSKirk McKusick * Request exclusive write access. 36340c340aaSPoul-Henning Kamp */ 36440c340aaSPoul-Henning Kamp error = g_access(ump->um_cp, 0, 1, 1); 36540c340aaSPoul-Henning Kamp g_topology_unlock(); 36640c340aaSPoul-Henning Kamp if (error) 36740c340aaSPoul-Henning Kamp return (error); 368f2a2857bSKirk McKusick if ((error = vn_start_write(NULL, &mp, V_WAIT)) != 0) 369f2a2857bSKirk McKusick return (error); 370f2a2857bSKirk McKusick fs->fs_ronly = 0; 3715da56ddbSTor Egge MNT_ILOCK(mp); 37220a92a18SPoul-Henning Kamp mp->mnt_flag &= ~MNT_RDONLY; 3735da56ddbSTor Egge MNT_IUNLOCK(mp); 374113db2ddSJeff Roberson fs->fs_mtime = time_second; 37526cf9c3bSPeter Wemm /* check to see if we need to start softdep */ 376f2a2857bSKirk McKusick if ((fs->fs_flags & FS_DOSOFTDEP) && 377a854ed98SJohn Baldwin (error = softdep_mount(devvp, mp, fs, td->td_ucred))){ 378f2a2857bSKirk McKusick vn_finished_write(mp); 379f2a2857bSKirk McKusick return (error); 38026cf9c3bSPeter Wemm } 381113db2ddSJeff Roberson fs->fs_clean = 0; 382113db2ddSJeff Roberson if ((error = ffs_sbupdate(ump, MNT_WAIT, 0)) != 0) { 383113db2ddSJeff Roberson vn_finished_write(mp); 384113db2ddSJeff Roberson return (error); 385113db2ddSJeff Roberson } 386f2a2857bSKirk McKusick if (fs->fs_snapinum[0] != 0) 387f2a2857bSKirk McKusick ffs_snapshot_mount(mp); 388f2a2857bSKirk McKusick vn_finished_write(mp); 3891469eec8SDavid Greenman } 390c11d2981SJulian Elischer /* 391c11d2981SJulian Elischer * Soft updates is incompatible with "async", 392c11d2981SJulian Elischer * so if we are doing softupdates stop the user 393c11d2981SJulian Elischer * from setting the async flag in an update. 394c11d2981SJulian Elischer * Softdep_mount() clears it in an initial mount 395c11d2981SJulian Elischer * or ro->rw remount. 396c11d2981SJulian Elischer */ 397fddf7baeSKirk McKusick if (MOUNTEDSOFTDEP(mp)) { 3985da56ddbSTor Egge /* XXX: Reset too late ? */ 3995da56ddbSTor Egge MNT_ILOCK(mp); 400c11d2981SJulian Elischer mp->mnt_flag &= ~MNT_ASYNC; 4015da56ddbSTor Egge MNT_IUNLOCK(mp); 4025da56ddbSTor Egge } 403df8bae1dSRodney W. Grimes /* 40439cfb239SPawel Jakub Dawidek * Keep MNT_ACLS flag if it is stored in superblock. 40539cfb239SPawel Jakub Dawidek */ 4065da56ddbSTor Egge if ((fs->fs_flags & FS_ACLS) != 0) { 4075da56ddbSTor Egge /* XXX: Set too late ? */ 4085da56ddbSTor Egge MNT_ILOCK(mp); 40939cfb239SPawel Jakub Dawidek mp->mnt_flag |= MNT_ACLS; 4105da56ddbSTor Egge MNT_IUNLOCK(mp); 4115da56ddbSTor Egge } 412cea90362SCraig Rodrigues 4139340fc72SEdward Tomasz Napierala if ((fs->fs_flags & FS_NFS4ACLS) != 0) { 4149340fc72SEdward Tomasz Napierala /* XXX: Set too late ? */ 4159340fc72SEdward Tomasz Napierala MNT_ILOCK(mp); 4169340fc72SEdward Tomasz Napierala mp->mnt_flag |= MNT_NFS4ACLS; 4179340fc72SEdward Tomasz Napierala MNT_IUNLOCK(mp); 4189340fc72SEdward Tomasz Napierala } 419927a12aeSKirk McKusick /* 420927a12aeSKirk McKusick * If this is a request from fsck to clean up the filesystem, 421927a12aeSKirk McKusick * then allow the specified pid to proceed. 422927a12aeSKirk McKusick */ 423927a12aeSKirk McKusick if (fsckpid > 0) { 424927a12aeSKirk McKusick if (ump->um_fsckpid != 0) { 425b60ee81eSKirk McKusick vfs_mount_error(mp, 426b60ee81eSKirk McKusick "Active checker already running on %s", 427927a12aeSKirk McKusick fs->fs_fsmnt); 428927a12aeSKirk McKusick return (EINVAL); 429927a12aeSKirk McKusick } 430fddf7baeSKirk McKusick KASSERT(MOUNTEDSOFTDEP(mp) == 0, 431927a12aeSKirk McKusick ("soft updates enabled on read-only file system")); 432927a12aeSKirk McKusick g_topology_lock(); 433927a12aeSKirk McKusick /* 434927a12aeSKirk McKusick * Request write access. 435927a12aeSKirk McKusick */ 436927a12aeSKirk McKusick error = g_access(ump->um_cp, 0, 1, 0); 437927a12aeSKirk McKusick g_topology_unlock(); 438927a12aeSKirk McKusick if (error) { 439b60ee81eSKirk McKusick vfs_mount_error(mp, 440b60ee81eSKirk McKusick "Checker activation failed on %s", 441927a12aeSKirk McKusick fs->fs_fsmnt); 442927a12aeSKirk McKusick return (error); 443927a12aeSKirk McKusick } 444927a12aeSKirk McKusick ump->um_fsckpid = fsckpid; 445927a12aeSKirk McKusick if (fs->fs_snapinum[0] != 0) 446927a12aeSKirk McKusick ffs_snapshot_mount(mp); 447927a12aeSKirk McKusick fs->fs_mtime = time_second; 448927a12aeSKirk McKusick fs->fs_fmod = 1; 449927a12aeSKirk McKusick fs->fs_clean = 0; 450927a12aeSKirk McKusick (void) ffs_sbupdate(ump, MNT_WAIT, 0); 451927a12aeSKirk McKusick } 4529340fc72SEdward Tomasz Napierala 453f2a2857bSKirk McKusick /* 454f2a2857bSKirk McKusick * If this is a snapshot request, take the snapshot. 455f2a2857bSKirk McKusick */ 456f2a2857bSKirk McKusick if (mp->mnt_flag & MNT_SNAPSHOT) 45720a92a18SPoul-Henning Kamp return (ffs_snapshot(mp, fspec)); 458714b7df5SKonstantin Belousov 459714b7df5SKonstantin Belousov /* 460714b7df5SKonstantin Belousov * Must not call namei() while owning busy ref. 461714b7df5SKonstantin Belousov */ 462714b7df5SKonstantin Belousov vfs_unbusy(mp); 463df8bae1dSRodney W. Grimes } 4642b14f991SJulian Elischer 465df8bae1dSRodney W. Grimes /* 466df8bae1dSRodney W. Grimes * Not an update, or updating the name: look up the name 467e9827c6dSBruce Evans * and verify that it refers to a sensible disk device. 468df8bae1dSRodney W. Grimes */ 469fdedad76SSuleiman Souhlal NDINIT(&ndp, LOOKUP, FOLLOW | LOCKLEAF, UIO_SYSSPACE, fspec, td); 470714b7df5SKonstantin Belousov error = namei(&ndp); 471714b7df5SKonstantin Belousov if ((mp->mnt_flag & MNT_UPDATE) != 0) { 472714b7df5SKonstantin Belousov /* 473714b7df5SKonstantin Belousov * Unmount does not start if MNT_UPDATE is set. Mount 474714b7df5SKonstantin Belousov * update busies mp before setting MNT_UPDATE. We 475714b7df5SKonstantin Belousov * must be able to retain our busy ref succesfully, 476714b7df5SKonstantin Belousov * without sleep. 477714b7df5SKonstantin Belousov */ 478714b7df5SKonstantin Belousov error1 = vfs_busy(mp, MBF_NOWAIT); 479714b7df5SKonstantin Belousov MPASS(error1 == 0); 480714b7df5SKonstantin Belousov } 481714b7df5SKonstantin Belousov if (error != 0) 482f2a2857bSKirk McKusick return (error); 4835e8c582aSPoul-Henning Kamp NDFREE(&ndp, NDF_ONLY_PNBUF); 4845e8c582aSPoul-Henning Kamp devvp = ndp.ni_vp; 485f2a2857bSKirk McKusick if (!vn_isdisk(devvp, &error)) { 486fdedad76SSuleiman Souhlal vput(devvp); 487f2a2857bSKirk McKusick return (error); 488f2a2857bSKirk McKusick } 489c9b99213SBruce Evans 490c9b99213SBruce Evans /* 491c9b99213SBruce Evans * If mount by non-root, then verify that user has necessary 492c9b99213SBruce Evans * permissions on the device. 493c9b99213SBruce Evans */ 49415bc6b2bSEdward Tomasz Napierala accmode = VREAD; 495c9b99213SBruce Evans if ((mp->mnt_flag & MNT_RDONLY) == 0) 49615bc6b2bSEdward Tomasz Napierala accmode |= VWRITE; 49715bc6b2bSEdward Tomasz Napierala error = VOP_ACCESS(devvp, accmode, td->td_ucred, td); 498acd3428bSRobert Watson if (error) 499acd3428bSRobert Watson error = priv_check(td, PRIV_VFS_MOUNT_PERM); 500acd3428bSRobert Watson if (error) { 501c9b99213SBruce Evans vput(devvp); 502c9b99213SBruce Evans return (error); 503c9b99213SBruce Evans } 504c9b99213SBruce Evans 5052b14f991SJulian Elischer if (mp->mnt_flag & MNT_UPDATE) { 5062b14f991SJulian Elischer /* 507f2a2857bSKirk McKusick * Update only 508f2a2857bSKirk McKusick * 5093e425b96SJulian Elischer * If it's not the same vnode, or at least the same device 5103e425b96SJulian Elischer * then it's not correct. 5112b14f991SJulian Elischer */ 5122b14f991SJulian Elischer 51343920011SPoul-Henning Kamp if (devvp->v_rdev != ump->um_devvp->v_rdev) 514f2a2857bSKirk McKusick error = EINVAL; /* needs translation */ 515fdedad76SSuleiman Souhlal vput(devvp); 516f2a2857bSKirk McKusick if (error) 517f2a2857bSKirk McKusick return (error); 5182b14f991SJulian Elischer } else { 5192b14f991SJulian Elischer /* 520f2a2857bSKirk McKusick * New mount 5212b14f991SJulian Elischer * 522f2a2857bSKirk McKusick * We need the name for the mount point (also used for 523f2a2857bSKirk McKusick * "last mounted on") copied in. If an error occurs, 524f2a2857bSKirk McKusick * the mount point is discarded by the upper level code. 52598cbffd7SKonstantin Belousov * Note that vfs_mount_alloc() populates f_mntonname for us. 526f2a2857bSKirk McKusick */ 527975512a9SPoul-Henning Kamp if ((error = ffs_mountfs(devvp, mp, td)) != 0) { 528f2a2857bSKirk McKusick vrele(devvp); 529f2a2857bSKirk McKusick return (error); 530f2a2857bSKirk McKusick } 531927a12aeSKirk McKusick if (fsckpid > 0) { 532fddf7baeSKirk McKusick KASSERT(MOUNTEDSOFTDEP(mp) == 0, 533927a12aeSKirk McKusick ("soft updates enabled on read-only file system")); 534927a12aeSKirk McKusick ump = VFSTOUFS(mp); 535927a12aeSKirk McKusick fs = ump->um_fs; 536927a12aeSKirk McKusick g_topology_lock(); 537927a12aeSKirk McKusick /* 538927a12aeSKirk McKusick * Request write access. 539927a12aeSKirk McKusick */ 540927a12aeSKirk McKusick error = g_access(ump->um_cp, 0, 1, 0); 541927a12aeSKirk McKusick g_topology_unlock(); 542927a12aeSKirk McKusick if (error) { 543b60ee81eSKirk McKusick printf("WARNING: %s: Checker activation " 544b60ee81eSKirk McKusick "failed\n", fs->fs_fsmnt); 545927a12aeSKirk McKusick } else { 546927a12aeSKirk McKusick ump->um_fsckpid = fsckpid; 547927a12aeSKirk McKusick if (fs->fs_snapinum[0] != 0) 548927a12aeSKirk McKusick ffs_snapshot_mount(mp); 549927a12aeSKirk McKusick fs->fs_mtime = time_second; 550927a12aeSKirk McKusick fs->fs_clean = 0; 551927a12aeSKirk McKusick (void) ffs_sbupdate(ump, MNT_WAIT, 0); 552927a12aeSKirk McKusick } 553927a12aeSKirk McKusick } 554f2a2857bSKirk McKusick } 55520a92a18SPoul-Henning Kamp vfs_mountedfrom(mp, fspec); 556f2a2857bSKirk McKusick return (0); 5572b14f991SJulian Elischer } 5582b14f991SJulian Elischer 559df8bae1dSRodney W. Grimes /* 56020a92a18SPoul-Henning Kamp * Compatibility with old mount system call. 56120a92a18SPoul-Henning Kamp */ 56220a92a18SPoul-Henning Kamp 56320a92a18SPoul-Henning Kamp static int 564cc672d35SKirk McKusick ffs_cmount(struct mntarg *ma, void *data, uint64_t flags) 56520a92a18SPoul-Henning Kamp { 56620a92a18SPoul-Henning Kamp struct ufs_args args; 567d0cc54f3SKonstantin Belousov struct export_args exp; 56820a92a18SPoul-Henning Kamp int error; 56920a92a18SPoul-Henning Kamp 57020a92a18SPoul-Henning Kamp if (data == NULL) 57120a92a18SPoul-Henning Kamp return (EINVAL); 57220a92a18SPoul-Henning Kamp error = copyin(data, &args, sizeof args); 57320a92a18SPoul-Henning Kamp if (error) 57420a92a18SPoul-Henning Kamp return (error); 575d0cc54f3SKonstantin Belousov vfs_oexport_conv(&args.export, &exp); 57620a92a18SPoul-Henning Kamp 57720a92a18SPoul-Henning Kamp ma = mount_argsu(ma, "from", args.fspec, MAXPATHLEN); 578d0cc54f3SKonstantin Belousov ma = mount_arg(ma, "export", &exp, sizeof(exp)); 57920a92a18SPoul-Henning Kamp error = kernel_mount(ma, flags); 58020a92a18SPoul-Henning Kamp 58120a92a18SPoul-Henning Kamp return (error); 58220a92a18SPoul-Henning Kamp } 58320a92a18SPoul-Henning Kamp 58420a92a18SPoul-Henning Kamp /* 585df8bae1dSRodney W. Grimes * Reload all incore data for a filesystem (used after running fsck on 5861848286aSEdward Tomasz Napierala * the root filesystem and finding things to fix). If the 'force' flag 5871848286aSEdward Tomasz Napierala * is 0, the filesystem must be mounted read-only. 588df8bae1dSRodney W. Grimes * 589df8bae1dSRodney W. Grimes * Things to do to update the mount: 590df8bae1dSRodney W. Grimes * 1) invalidate all cached meta-data. 591df8bae1dSRodney W. Grimes * 2) re-read superblock from disk. 592df8bae1dSRodney W. Grimes * 3) re-read summary information from disk. 593df8bae1dSRodney W. Grimes * 4) invalidate all inactive vnodes. 594df426577SKonstantin Belousov * 5) clear MNTK_SUSPEND2 and MNTK_SUSPENDED flags, allowing secondary 595df426577SKonstantin Belousov * writers, if requested. 596df426577SKonstantin Belousov * 6) invalidate all cached file data. 597df426577SKonstantin Belousov * 7) re-read inode data for all active vnodes. 598df8bae1dSRodney W. Grimes */ 5991848286aSEdward Tomasz Napierala int 600df426577SKonstantin Belousov ffs_reload(struct mount *mp, struct thread *td, int flags) 601df8bae1dSRodney W. Grimes { 60282be0a5aSTor Egge struct vnode *vp, *mvp, *devvp; 603df8bae1dSRodney W. Grimes struct inode *ip; 604f55ff3f3SIan Dowse void *space; 605df8bae1dSRodney W. Grimes struct buf *bp; 606996c772fSJohn Dyson struct fs *fs, *newfs; 6073ba649d7SJeff Roberson struct ufsmount *ump; 6081c85e6a3SKirk McKusick ufs2_daddr_t sblockloc; 609ad544726SKirk McKusick int i, blks, error; 610ad544726SKirk McKusick u_long size; 611996c772fSJohn Dyson int32_t *lp; 612df8bae1dSRodney W. Grimes 6133ba649d7SJeff Roberson ump = VFSTOUFS(mp); 6141848286aSEdward Tomasz Napierala 6151848286aSEdward Tomasz Napierala MNT_ILOCK(mp); 616df426577SKonstantin Belousov if ((mp->mnt_flag & MNT_RDONLY) == 0 && (flags & FFSR_FORCE) == 0) { 6171848286aSEdward Tomasz Napierala MNT_IUNLOCK(mp); 6181848286aSEdward Tomasz Napierala return (EINVAL); 6191848286aSEdward Tomasz Napierala } 6201848286aSEdward Tomasz Napierala MNT_IUNLOCK(mp); 6211848286aSEdward Tomasz Napierala 622df8bae1dSRodney W. Grimes /* 623df8bae1dSRodney W. Grimes * Step 1: invalidate all cached meta-data. 624df8bae1dSRodney W. Grimes */ 6252b14f991SJulian Elischer devvp = VFSTOUFS(mp)->um_devvp; 626cb05b60aSAttilio Rao vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY); 6270d7935fdSAttilio Rao if (vinvalbuf(devvp, 0, 0, 0) != 0) 628df8bae1dSRodney W. Grimes panic("ffs_reload: dirty1"); 62922db15c0SAttilio Rao VOP_UNLOCK(devvp, 0); 63095e5e988SJohn Dyson 631df8bae1dSRodney W. Grimes /* 632df8bae1dSRodney W. Grimes * Step 2: re-read superblock from disk. 633df8bae1dSRodney W. Grimes */ 6341c85e6a3SKirk McKusick fs = VFSTOUFS(mp)->um_fs; 635ada981b2SKirk McKusick if ((error = bread(devvp, btodb(fs->fs_sblockloc), fs->fs_sbsize, 6361c85e6a3SKirk McKusick NOCRED, &bp)) != 0) 637df8bae1dSRodney W. Grimes return (error); 638996c772fSJohn Dyson newfs = (struct fs *)bp->b_data; 6391c85e6a3SKirk McKusick if ((newfs->fs_magic != FS_UFS1_MAGIC && 6401c85e6a3SKirk McKusick newfs->fs_magic != FS_UFS2_MAGIC) || 6411c85e6a3SKirk McKusick newfs->fs_bsize > MAXBSIZE || 642996c772fSJohn Dyson newfs->fs_bsize < sizeof(struct fs)) { 643df8bae1dSRodney W. Grimes brelse(bp); 644df8bae1dSRodney W. Grimes return (EIO); /* XXX needs translation */ 645df8bae1dSRodney W. Grimes } 646996c772fSJohn Dyson /* 647996c772fSJohn Dyson * Copy pointer fields back into superblock before copying in XXX 648996c772fSJohn Dyson * new superblock. These should really be in the ufsmount. XXX 649996c772fSJohn Dyson * Note that important parameters (eg fs_ncg) are unchanged. 650996c772fSJohn Dyson */ 651f55ff3f3SIan Dowse newfs->fs_csp = fs->fs_csp; 652996c772fSJohn Dyson newfs->fs_maxcluster = fs->fs_maxcluster; 6535d69bac4SIan Dowse newfs->fs_contigdirs = fs->fs_contigdirs; 654143a5346SIan Dowse newfs->fs_active = fs->fs_active; 6551848286aSEdward Tomasz Napierala newfs->fs_ronly = fs->fs_ronly; 6561c85e6a3SKirk McKusick sblockloc = fs->fs_sblockloc; 657996c772fSJohn Dyson bcopy(newfs, fs, (u_int)fs->fs_sbsize); 658df8bae1dSRodney W. Grimes brelse(bp); 659996c772fSJohn Dyson mp->mnt_maxsymlinklen = fs->fs_maxsymlinklen; 6601c85e6a3SKirk McKusick ffs_oldfscompat_read(fs, VFSTOUFS(mp), sblockloc); 6613ba649d7SJeff Roberson UFS_LOCK(ump); 6629ccb939eSKirk McKusick if (fs->fs_pendingblocks != 0 || fs->fs_pendinginodes != 0) { 663b60ee81eSKirk McKusick printf("WARNING: %s: reload pending error: blocks %jd " 664b60ee81eSKirk McKusick "files %d\n", fs->fs_fsmnt, (intmax_t)fs->fs_pendingblocks, 6651c85e6a3SKirk McKusick fs->fs_pendinginodes); 6669ccb939eSKirk McKusick fs->fs_pendingblocks = 0; 6679ccb939eSKirk McKusick fs->fs_pendinginodes = 0; 6689ccb939eSKirk McKusick } 6693ba649d7SJeff Roberson UFS_UNLOCK(ump); 670996c772fSJohn Dyson 671df8bae1dSRodney W. Grimes /* 672df8bae1dSRodney W. Grimes * Step 3: re-read summary information from disk. 673df8bae1dSRodney W. Grimes */ 6742b028c25SEdward Tomasz Napierala size = fs->fs_cssize; 6752b028c25SEdward Tomasz Napierala blks = howmany(size, fs->fs_fsize); 6762b028c25SEdward Tomasz Napierala if (fs->fs_contigsumsize > 0) 6772b028c25SEdward Tomasz Napierala size += fs->fs_ncg * sizeof(int32_t); 6782b028c25SEdward Tomasz Napierala size += fs->fs_ncg * sizeof(u_int8_t); 6792b028c25SEdward Tomasz Napierala free(fs->fs_csp, M_UFSMNT); 680ad544726SKirk McKusick space = malloc(size, M_UFSMNT, M_WAITOK); 6812b028c25SEdward Tomasz Napierala fs->fs_csp = space; 682df8bae1dSRodney W. Grimes for (i = 0; i < blks; i += fs->fs_frag) { 683df8bae1dSRodney W. Grimes size = fs->fs_bsize; 684df8bae1dSRodney W. Grimes if (i + fs->fs_frag > blks) 685df8bae1dSRodney W. Grimes size = (blks - i) * fs->fs_fsize; 686c9671602SPoul-Henning Kamp error = bread(devvp, fsbtodb(fs, fs->fs_csaddr + i), size, 687c9671602SPoul-Henning Kamp NOCRED, &bp); 688c9671602SPoul-Henning Kamp if (error) 689df8bae1dSRodney W. Grimes return (error); 690f55ff3f3SIan Dowse bcopy(bp->b_data, space, (u_int)size); 691f55ff3f3SIan Dowse space = (char *)space + size; 692df8bae1dSRodney W. Grimes brelse(bp); 693df8bae1dSRodney W. Grimes } 694996c772fSJohn Dyson /* 695996c772fSJohn Dyson * We no longer know anything about clusters per cylinder group. 696996c772fSJohn Dyson */ 697996c772fSJohn Dyson if (fs->fs_contigsumsize > 0) { 69872b8ff1cSEdward Tomasz Napierala fs->fs_maxcluster = lp = space; 699996c772fSJohn Dyson for (i = 0; i < fs->fs_ncg; i++) 700996c772fSJohn Dyson *lp++ = fs->fs_contigsumsize; 70172b8ff1cSEdward Tomasz Napierala space = lp; 702996c772fSJohn Dyson } 70372b8ff1cSEdward Tomasz Napierala size = fs->fs_ncg * sizeof(u_int8_t); 70472b8ff1cSEdward Tomasz Napierala fs->fs_contigdirs = (u_int8_t *)space; 70572b8ff1cSEdward Tomasz Napierala bzero(fs->fs_contigdirs, size); 706df426577SKonstantin Belousov if ((flags & FFSR_UNSUSPEND) != 0) { 707df426577SKonstantin Belousov MNT_ILOCK(mp); 708df426577SKonstantin Belousov mp->mnt_kern_flag &= ~(MNTK_SUSPENDED | MNTK_SUSPEND2); 709df426577SKonstantin Belousov wakeup(&mp->mnt_flag); 710df426577SKonstantin Belousov MNT_IUNLOCK(mp); 711df426577SKonstantin Belousov } 712996c772fSJohn Dyson 713df8bae1dSRodney W. Grimes loop: 71471469bb3SKirk McKusick MNT_VNODE_FOREACH_ALL(vp, mp, mvp) { 715df8bae1dSRodney W. Grimes /* 7161848286aSEdward Tomasz Napierala * Skip syncer vnode. 7171848286aSEdward Tomasz Napierala */ 7181848286aSEdward Tomasz Napierala if (vp->v_type == VNON) { 7191848286aSEdward Tomasz Napierala VI_UNLOCK(vp); 7201848286aSEdward Tomasz Napierala continue; 7211848286aSEdward Tomasz Napierala } 7221848286aSEdward Tomasz Napierala /* 723fe68abe2SJeff Roberson * Step 4: invalidate all cached file data. 724df8bae1dSRodney W. Grimes */ 725b40ce416SJulian Elischer if (vget(vp, LK_EXCLUSIVE | LK_INTERLOCK, td)) { 72671469bb3SKirk McKusick MNT_VNODE_FOREACH_ALL_ABORT(mp, mvp); 727df8bae1dSRodney W. Grimes goto loop; 728996c772fSJohn Dyson } 7290d7935fdSAttilio Rao if (vinvalbuf(vp, 0, 0, 0)) 730df8bae1dSRodney W. Grimes panic("ffs_reload: dirty2"); 731df8bae1dSRodney W. Grimes /* 732fe68abe2SJeff Roberson * Step 5: re-read inode data for all active vnodes. 733df8bae1dSRodney W. Grimes */ 734df8bae1dSRodney W. Grimes ip = VTOI(vp); 735c9671602SPoul-Henning Kamp error = 736df8bae1dSRodney W. Grimes bread(devvp, fsbtodb(fs, ino_to_fsba(fs, ip->i_number)), 737c9671602SPoul-Henning Kamp (int)fs->fs_bsize, NOCRED, &bp); 738c9671602SPoul-Henning Kamp if (error) { 73922db15c0SAttilio Rao VOP_UNLOCK(vp, 0); 74045d45c6cSAlexander Kabaev vrele(vp); 74171469bb3SKirk McKusick MNT_VNODE_FOREACH_ALL_ABORT(mp, mvp); 742df8bae1dSRodney W. Grimes return (error); 743df8bae1dSRodney W. Grimes } 744de6ba7c0SPoul-Henning Kamp ffs_load_inode(bp, ip, fs, ip->i_number); 745b1897c19SJulian Elischer ip->i_effnlink = ip->i_nlink; 746df8bae1dSRodney W. Grimes brelse(bp); 74722db15c0SAttilio Rao VOP_UNLOCK(vp, 0); 748cb9ddc80SAlexander Kabaev vrele(vp); 749df8bae1dSRodney W. Grimes } 750df8bae1dSRodney W. Grimes return (0); 751df8bae1dSRodney W. Grimes } 752df8bae1dSRodney W. Grimes 7531c85e6a3SKirk McKusick /* 7541c85e6a3SKirk McKusick * Possible superblock locations ordered from most to least likely. 7551c85e6a3SKirk McKusick */ 7561c85e6a3SKirk McKusick static int sblock_try[] = SBLOCKSEARCH; 7575819ab3fSKirk McKusick 758df8bae1dSRodney W. Grimes /* 759df8bae1dSRodney W. Grimes * Common code for mount and mountroot 760df8bae1dSRodney W. Grimes */ 761975512a9SPoul-Henning Kamp static int 762975512a9SPoul-Henning Kamp ffs_mountfs(devvp, mp, td) 76305f4ff5dSPoul-Henning Kamp struct vnode *devvp; 764df8bae1dSRodney W. Grimes struct mount *mp; 765b40ce416SJulian Elischer struct thread *td; 766df8bae1dSRodney W. Grimes { 76705f4ff5dSPoul-Henning Kamp struct ufsmount *ump; 768df8bae1dSRodney W. Grimes struct buf *bp; 76905f4ff5dSPoul-Henning Kamp struct fs *fs; 77089c9c53dSPoul-Henning Kamp struct cdev *dev; 771f55ff3f3SIan Dowse void *space; 7721c85e6a3SKirk McKusick ufs2_daddr_t sblockloc; 773ad544726SKirk McKusick int error, i, blks, len, ronly; 774ad544726SKirk McKusick u_long size; 775996c772fSJohn Dyson int32_t *lp; 776996c772fSJohn Dyson struct ucred *cred; 77743920011SPoul-Henning Kamp struct g_consumer *cp; 7783bbd6d8aSJeff Roberson struct mount *nmp; 779df8bae1dSRodney W. Grimes 780ee445a69SJohn Baldwin bp = NULL; 781ee445a69SJohn Baldwin ump = NULL; 782a854ed98SJohn Baldwin cred = td ? td->td_ucred : NOCRED; 78343920011SPoul-Henning Kamp ronly = (mp->mnt_flag & MNT_RDONLY) != 0; 784ee445a69SJohn Baldwin 785c70b3cd2SKonstantin Belousov KASSERT(devvp->v_type == VCHR, ("reclaimed devvp")); 786ee445a69SJohn Baldwin dev = devvp->v_rdev; 787c70b3cd2SKonstantin Belousov if (atomic_cmpset_acq_ptr((uintptr_t *)&dev->si_mountpt, 0, 788c70b3cd2SKonstantin Belousov (uintptr_t)mp) == 0) { 789c70b3cd2SKonstantin Belousov VOP_UNLOCK(devvp, 0); 790c70b3cd2SKonstantin Belousov return (EBUSY); 791c70b3cd2SKonstantin Belousov } 79243920011SPoul-Henning Kamp g_topology_lock(); 79343920011SPoul-Henning Kamp error = g_vfs_open(devvp, &cp, "ffs", ronly ? 0 : 1); 79443920011SPoul-Henning Kamp g_topology_unlock(); 795c70b3cd2SKonstantin Belousov if (error != 0) { 796c70b3cd2SKonstantin Belousov atomic_store_rel_ptr((uintptr_t *)&dev->si_mountpt, 0); 79722db15c0SAttilio Rao VOP_UNLOCK(devvp, 0); 798c70b3cd2SKonstantin Belousov return (error); 799c70b3cd2SKonstantin Belousov } 800c70b3cd2SKonstantin Belousov dev_ref(dev); 801c70b3cd2SKonstantin Belousov devvp->v_bufobj.bo_ops = &ffs_ops; 802c70b3cd2SKonstantin Belousov VOP_UNLOCK(devvp, 0); 803c70b3cd2SKonstantin Belousov if (dev->si_iosize_max != 0) 804c70b3cd2SKonstantin Belousov mp->mnt_iosize_max = dev->si_iosize_max; 8051b5464efSPoul-Henning Kamp if (mp->mnt_iosize_max > MAXPHYS) 8061b5464efSPoul-Henning Kamp mp->mnt_iosize_max = MAXPHYS; 80795e5e988SJohn Dyson 8081c85e6a3SKirk McKusick fs = NULL; 8091c85e6a3SKirk McKusick sblockloc = 0; 8101c85e6a3SKirk McKusick /* 8111c85e6a3SKirk McKusick * Try reading the superblock in each of its possible locations. 8121c85e6a3SKirk McKusick */ 8131c85e6a3SKirk McKusick for (i = 0; sblock_try[i] != -1; i++) { 81471ac2d7cSCraig Rodrigues if ((SBLOCKSIZE % cp->provider->sectorsize) != 0) { 81571ac2d7cSCraig Rodrigues error = EINVAL; 81671ac2d7cSCraig Rodrigues vfs_mount_error(mp, 81771ac2d7cSCraig Rodrigues "Invalid sectorsize %d for superblock size %d", 81871ac2d7cSCraig Rodrigues cp->provider->sectorsize, SBLOCKSIZE); 81971ac2d7cSCraig Rodrigues goto out; 82071ac2d7cSCraig Rodrigues } 82171ac2d7cSCraig Rodrigues if ((error = bread(devvp, btodb(sblock_try[i]), SBLOCKSIZE, 8221c85e6a3SKirk McKusick cred, &bp)) != 0) 823df8bae1dSRodney W. Grimes goto out; 824df8bae1dSRodney W. Grimes fs = (struct fs *)bp->b_data; 825ada981b2SKirk McKusick sblockloc = sblock_try[i]; 8261c85e6a3SKirk McKusick if ((fs->fs_magic == FS_UFS1_MAGIC || 8271c85e6a3SKirk McKusick (fs->fs_magic == FS_UFS2_MAGIC && 828ada981b2SKirk McKusick (fs->fs_sblockloc == sblockloc || 829ada981b2SKirk McKusick (fs->fs_old_flags & FS_FLAGS_UPDATED) == 0))) && 8301c85e6a3SKirk McKusick fs->fs_bsize <= MAXBSIZE && 8311c85e6a3SKirk McKusick fs->fs_bsize >= sizeof(struct fs)) 8321c85e6a3SKirk McKusick break; 8331c85e6a3SKirk McKusick brelse(bp); 8341c85e6a3SKirk McKusick bp = NULL; 8351c85e6a3SKirk McKusick } 8361c85e6a3SKirk McKusick if (sblock_try[i] == -1) { 837df8bae1dSRodney W. Grimes error = EINVAL; /* XXX needs translation */ 838df8bae1dSRodney W. Grimes goto out; 839df8bae1dSRodney W. Grimes } 8403f6f17eeSJulian Elischer fs->fs_fmod = 0; 84108e94183SPedro F. Giffuni fs->fs_flags &= ~FS_INDEXDIRS; /* no support for directory indices */ 8420922cce6SBruce Evans fs->fs_flags &= ~FS_UNCLEAN; 8430922cce6SBruce Evans if (fs->fs_clean == 0) { 8440922cce6SBruce Evans fs->fs_flags |= FS_UNCLEAN; 845812b1d41SKirk McKusick if (ronly || (mp->mnt_flag & MNT_FORCE) || 846113db2ddSJeff Roberson ((fs->fs_flags & (FS_SUJ | FS_NEEDSFSCK)) == 0 && 8471a6a6610SKirk McKusick (fs->fs_flags & FS_DOSOFTDEP))) { 84859b3a4ebSDavid E. O'Brien printf("WARNING: %s was not properly dismounted\n", 8490922cce6SBruce Evans fs->fs_fsmnt); 8501469eec8SDavid Greenman } else { 851b60ee81eSKirk McKusick vfs_mount_error(mp, "R/W mount of %s denied. %s%s", 852b60ee81eSKirk McKusick fs->fs_fsmnt, "Filesystem is not clean - run fsck.", 853b60ee81eSKirk McKusick (fs->fs_flags & FS_SUJ) == 0 ? "" : 854b60ee81eSKirk McKusick " Forced mount will invalidate journal contents"); 8551469eec8SDavid Greenman error = EPERM; 8561469eec8SDavid Greenman goto out; 8571469eec8SDavid Greenman } 8581c85e6a3SKirk McKusick if ((fs->fs_pendingblocks != 0 || fs->fs_pendinginodes != 0) && 8591c85e6a3SKirk McKusick (mp->mnt_flag & MNT_FORCE)) { 860b60ee81eSKirk McKusick printf("WARNING: %s: lost blocks %jd files %d\n", 861b60ee81eSKirk McKusick fs->fs_fsmnt, (intmax_t)fs->fs_pendingblocks, 8621c85e6a3SKirk McKusick fs->fs_pendinginodes); 8639ccb939eSKirk McKusick fs->fs_pendingblocks = 0; 8649ccb939eSKirk McKusick fs->fs_pendinginodes = 0; 8659ccb939eSKirk McKusick } 8669ccb939eSKirk McKusick } 8679ccb939eSKirk McKusick if (fs->fs_pendingblocks != 0 || fs->fs_pendinginodes != 0) { 868b60ee81eSKirk McKusick printf("WARNING: %s: mount pending error: blocks %jd " 869b60ee81eSKirk McKusick "files %d\n", fs->fs_fsmnt, (intmax_t)fs->fs_pendingblocks, 8701c85e6a3SKirk McKusick fs->fs_pendinginodes); 8719ccb939eSKirk McKusick fs->fs_pendingblocks = 0; 8729ccb939eSKirk McKusick fs->fs_pendinginodes = 0; 8731469eec8SDavid Greenman } 8741a60c7fcSPawel Jakub Dawidek if ((fs->fs_flags & FS_GJOURNAL) != 0) { 8751a60c7fcSPawel Jakub Dawidek #ifdef UFS_GJOURNAL 8761a60c7fcSPawel Jakub Dawidek /* 8771a60c7fcSPawel Jakub Dawidek * Get journal provider name. 8781a60c7fcSPawel Jakub Dawidek */ 879ad544726SKirk McKusick len = 1024; 880ad544726SKirk McKusick mp->mnt_gjprovider = malloc((u_long)len, M_UFSMNT, M_WAITOK); 881ad544726SKirk McKusick if (g_io_getattr("GJOURNAL::provider", cp, &len, 8821a60c7fcSPawel Jakub Dawidek mp->mnt_gjprovider) == 0) { 883ad544726SKirk McKusick mp->mnt_gjprovider = realloc(mp->mnt_gjprovider, len, 8841a60c7fcSPawel Jakub Dawidek M_UFSMNT, M_WAITOK); 8851a60c7fcSPawel Jakub Dawidek MNT_ILOCK(mp); 8861a60c7fcSPawel Jakub Dawidek mp->mnt_flag |= MNT_GJOURNAL; 8871a60c7fcSPawel Jakub Dawidek MNT_IUNLOCK(mp); 8881a60c7fcSPawel Jakub Dawidek } else { 889b60ee81eSKirk McKusick printf("WARNING: %s: GJOURNAL flag on fs " 890b60ee81eSKirk McKusick "but no gjournal provider below\n", 8911a60c7fcSPawel Jakub Dawidek mp->mnt_stat.f_mntonname); 8921a60c7fcSPawel Jakub Dawidek free(mp->mnt_gjprovider, M_UFSMNT); 8931a60c7fcSPawel Jakub Dawidek mp->mnt_gjprovider = NULL; 8941a60c7fcSPawel Jakub Dawidek } 8951a60c7fcSPawel Jakub Dawidek #else 896b60ee81eSKirk McKusick printf("WARNING: %s: GJOURNAL flag on fs but no " 897b60ee81eSKirk McKusick "UFS_GJOURNAL support\n", mp->mnt_stat.f_mntonname); 8981a60c7fcSPawel Jakub Dawidek #endif 8991a60c7fcSPawel Jakub Dawidek } else { 9001a60c7fcSPawel Jakub Dawidek mp->mnt_gjprovider = NULL; 9011a60c7fcSPawel Jakub Dawidek } 902a163d034SWarner Losh ump = malloc(sizeof *ump, M_UFSMNT, M_WAITOK | M_ZERO); 90343920011SPoul-Henning Kamp ump->um_cp = cp; 90443920011SPoul-Henning Kamp ump->um_bo = &devvp->v_bufobj; 9058dd56505SPoul-Henning Kamp ump->um_fs = malloc((u_long)fs->fs_sbsize, M_UFSMNT, M_WAITOK); 9061c85e6a3SKirk McKusick if (fs->fs_magic == FS_UFS1_MAGIC) { 9071c85e6a3SKirk McKusick ump->um_fstype = UFS1; 9081c85e6a3SKirk McKusick ump->um_balloc = ffs_balloc_ufs1; 9091c85e6a3SKirk McKusick } else { 9101c85e6a3SKirk McKusick ump->um_fstype = UFS2; 9111c85e6a3SKirk McKusick ump->um_balloc = ffs_balloc_ufs2; 9121c85e6a3SKirk McKusick } 913cec0f20cSPoul-Henning Kamp ump->um_blkatoff = ffs_blkatoff; 914cec0f20cSPoul-Henning Kamp ump->um_truncate = ffs_truncate; 915987f5696SPoul-Henning Kamp ump->um_update = ffs_update; 916cec0f20cSPoul-Henning Kamp ump->um_valloc = ffs_valloc; 917cec0f20cSPoul-Henning Kamp ump->um_vfree = ffs_vfree; 918975512a9SPoul-Henning Kamp ump->um_ifree = ffs_ifree; 91990446e36SKonstantin Belousov ump->um_rdonly = ffs_rdonly; 92016b1f68dSKonstantin Belousov ump->um_snapgone = ffs_snapgone; 9213ba649d7SJeff Roberson mtx_init(UFS_MTX(ump), "FFS", "FFS Lock", MTX_DEF); 922df8bae1dSRodney W. Grimes bcopy(bp->b_data, ump->um_fs, (u_int)fs->fs_sbsize); 9231c85e6a3SKirk McKusick if (fs->fs_sbsize < SBLOCKSIZE) 924f2a2857bSKirk McKusick bp->b_flags |= B_INVAL | B_NOCACHE; 925df8bae1dSRodney W. Grimes brelse(bp); 926df8bae1dSRodney W. Grimes bp = NULL; 927df8bae1dSRodney W. Grimes fs = ump->um_fs; 9281c85e6a3SKirk McKusick ffs_oldfscompat_read(fs, ump, sblockloc); 929df8bae1dSRodney W. Grimes fs->fs_ronly = ronly; 930996c772fSJohn Dyson size = fs->fs_cssize; 931996c772fSJohn Dyson blks = howmany(size, fs->fs_fsize); 932996c772fSJohn Dyson if (fs->fs_contigsumsize > 0) 933996c772fSJohn Dyson size += fs->fs_ncg * sizeof(int32_t); 934a61ab64aSKirk McKusick size += fs->fs_ncg * sizeof(u_int8_t); 935ad544726SKirk McKusick space = malloc(size, M_UFSMNT, M_WAITOK); 936f55ff3f3SIan Dowse fs->fs_csp = space; 937df8bae1dSRodney W. Grimes for (i = 0; i < blks; i += fs->fs_frag) { 938df8bae1dSRodney W. Grimes size = fs->fs_bsize; 939df8bae1dSRodney W. Grimes if (i + fs->fs_frag > blks) 940df8bae1dSRodney W. Grimes size = (blks - i) * fs->fs_fsize; 9418aef1712SMatthew Dillon if ((error = bread(devvp, fsbtodb(fs, fs->fs_csaddr + i), size, 9428aef1712SMatthew Dillon cred, &bp)) != 0) { 943f55ff3f3SIan Dowse free(fs->fs_csp, M_UFSMNT); 944df8bae1dSRodney W. Grimes goto out; 945df8bae1dSRodney W. Grimes } 946df8bae1dSRodney W. Grimes bcopy(bp->b_data, space, (u_int)size); 947f55ff3f3SIan Dowse space = (char *)space + size; 948df8bae1dSRodney W. Grimes brelse(bp); 949df8bae1dSRodney W. Grimes bp = NULL; 950df8bae1dSRodney W. Grimes } 951996c772fSJohn Dyson if (fs->fs_contigsumsize > 0) { 952f55ff3f3SIan Dowse fs->fs_maxcluster = lp = space; 953996c772fSJohn Dyson for (i = 0; i < fs->fs_ncg; i++) 954996c772fSJohn Dyson *lp++ = fs->fs_contigsumsize; 9554691e9eaSIan Dowse space = lp; 956996c772fSJohn Dyson } 957a61ab64aSKirk McKusick size = fs->fs_ncg * sizeof(u_int8_t); 958a61ab64aSKirk McKusick fs->fs_contigdirs = (u_int8_t *)space; 959a61ab64aSKirk McKusick bzero(fs->fs_contigdirs, size); 960143a5346SIan Dowse fs->fs_active = NULL; 96177465d93SAlfred Perlstein mp->mnt_data = ump; 96268de329eSPoul-Henning Kamp mp->mnt_stat.f_fsid.val[0] = fs->fs_id[0]; 9638f89943eSGuido van Rooij mp->mnt_stat.f_fsid.val[1] = fs->fs_id[1]; 9643bbd6d8aSJeff Roberson nmp = NULL; 96568de329eSPoul-Henning Kamp if (fs->fs_id[0] == 0 || fs->fs_id[1] == 0 || 9663bbd6d8aSJeff Roberson (nmp = vfs_getvfs(&mp->mnt_stat.f_fsid))) { 9673bbd6d8aSJeff Roberson if (nmp) 9683bbd6d8aSJeff Roberson vfs_rel(nmp); 96968de329eSPoul-Henning Kamp vfs_getnewfsid(mp); 9703bbd6d8aSJeff Roberson } 971df8bae1dSRodney W. Grimes mp->mnt_maxsymlinklen = fs->fs_maxsymlinklen; 9725da56ddbSTor Egge MNT_ILOCK(mp); 973cc9d8990SPeter Wemm mp->mnt_flag |= MNT_LOCAL; 9745da56ddbSTor Egge MNT_IUNLOCK(mp); 9755da56ddbSTor Egge if ((fs->fs_flags & FS_MULTILABEL) != 0) { 9767b3f1bbdSTom Rhodes #ifdef MAC 9775da56ddbSTor Egge MNT_ILOCK(mp); 97880830407SRobert Watson mp->mnt_flag |= MNT_MULTILABEL; 9795da56ddbSTor Egge MNT_IUNLOCK(mp); 9807b3f1bbdSTom Rhodes #else 981b60ee81eSKirk McKusick printf("WARNING: %s: multilabel flag on fs but " 982b60ee81eSKirk McKusick "no MAC support\n", mp->mnt_stat.f_mntonname); 9837b3f1bbdSTom Rhodes #endif 9845da56ddbSTor Egge } 9855da56ddbSTor Egge if ((fs->fs_flags & FS_ACLS) != 0) { 9867b3f1bbdSTom Rhodes #ifdef UFS_ACL 9875da56ddbSTor Egge MNT_ILOCK(mp); 9889340fc72SEdward Tomasz Napierala 9899340fc72SEdward Tomasz Napierala if (mp->mnt_flag & MNT_NFS4ACLS) 990b60ee81eSKirk McKusick printf("WARNING: %s: ACLs flag on fs conflicts with " 991b60ee81eSKirk McKusick "\"nfsv4acls\" mount option; option ignored\n", 992b60ee81eSKirk McKusick mp->mnt_stat.f_mntonname); 9939340fc72SEdward Tomasz Napierala mp->mnt_flag &= ~MNT_NFS4ACLS; 99480830407SRobert Watson mp->mnt_flag |= MNT_ACLS; 9959340fc72SEdward Tomasz Napierala 9965da56ddbSTor Egge MNT_IUNLOCK(mp); 9977b3f1bbdSTom Rhodes #else 99859b3a4ebSDavid E. O'Brien printf("WARNING: %s: ACLs flag on fs but no ACLs support\n", 999946478fcSPawel Jakub Dawidek mp->mnt_stat.f_mntonname); 10007b3f1bbdSTom Rhodes #endif 10015da56ddbSTor Egge } 10029340fc72SEdward Tomasz Napierala if ((fs->fs_flags & FS_NFS4ACLS) != 0) { 10039340fc72SEdward Tomasz Napierala #ifdef UFS_ACL 10049340fc72SEdward Tomasz Napierala MNT_ILOCK(mp); 10059340fc72SEdward Tomasz Napierala 10069340fc72SEdward Tomasz Napierala if (mp->mnt_flag & MNT_ACLS) 1007b60ee81eSKirk McKusick printf("WARNING: %s: NFSv4 ACLs flag on fs conflicts " 1008b60ee81eSKirk McKusick "with \"acls\" mount option; option ignored\n", 1009b60ee81eSKirk McKusick mp->mnt_stat.f_mntonname); 10109340fc72SEdward Tomasz Napierala mp->mnt_flag &= ~MNT_ACLS; 10119340fc72SEdward Tomasz Napierala mp->mnt_flag |= MNT_NFS4ACLS; 10129340fc72SEdward Tomasz Napierala 10139340fc72SEdward Tomasz Napierala MNT_IUNLOCK(mp); 10149340fc72SEdward Tomasz Napierala #else 1015b60ee81eSKirk McKusick printf("WARNING: %s: NFSv4 ACLs flag on fs but no " 1016b60ee81eSKirk McKusick "ACLs support\n", mp->mnt_stat.f_mntonname); 10179340fc72SEdward Tomasz Napierala #endif 10189340fc72SEdward Tomasz Napierala } 10198c2a54deSKonstantin Belousov if ((fs->fs_flags & FS_TRIM) != 0) { 1020ad544726SKirk McKusick len = sizeof(int); 1021ad544726SKirk McKusick if (g_io_getattr("GEOM::candelete", cp, &len, 10228c2a54deSKonstantin Belousov &ump->um_candelete) == 0) { 10238c2a54deSKonstantin Belousov if (!ump->um_candelete) 1024b60ee81eSKirk McKusick printf("WARNING: %s: TRIM flag on fs but disk " 1025b60ee81eSKirk McKusick "does not support TRIM\n", 10268c2a54deSKonstantin Belousov mp->mnt_stat.f_mntonname); 10278c2a54deSKonstantin Belousov } else { 1028b60ee81eSKirk McKusick printf("WARNING: %s: TRIM flag on fs but disk does " 1029b60ee81eSKirk McKusick "not confirm that it supports TRIM\n", 10308c2a54deSKonstantin Belousov mp->mnt_stat.f_mntonname); 10318c2a54deSKonstantin Belousov ump->um_candelete = 0; 10328c2a54deSKonstantin Belousov } 1033c79dff0fSKonstantin Belousov if (ump->um_candelete) { 1034c79dff0fSKonstantin Belousov ump->um_trim_tq = taskqueue_create("trim", M_WAITOK, 1035c79dff0fSKonstantin Belousov taskqueue_thread_enqueue, &ump->um_trim_tq); 1036c79dff0fSKonstantin Belousov taskqueue_start_threads(&ump->um_trim_tq, 1, PVFS, 1037c79dff0fSKonstantin Belousov "%s trim", mp->mnt_stat.f_mntonname); 1038c79dff0fSKonstantin Belousov } 10398c2a54deSKonstantin Belousov } 10409340fc72SEdward Tomasz Napierala 1041df8bae1dSRodney W. Grimes ump->um_mountp = mp; 1042df8bae1dSRodney W. Grimes ump->um_dev = dev; 1043df8bae1dSRodney W. Grimes ump->um_devvp = devvp; 1044df8bae1dSRodney W. Grimes ump->um_nindir = fs->fs_nindir; 1045df8bae1dSRodney W. Grimes ump->um_bptrtodb = fs->fs_fsbtodb; 1046df8bae1dSRodney W. Grimes ump->um_seqinc = fs->fs_frag; 1047df8bae1dSRodney W. Grimes for (i = 0; i < MAXQUOTAS; i++) 1048df8bae1dSRodney W. Grimes ump->um_quotas[i] = NULLVP; 1049516081f2SRobert Watson #ifdef UFS_EXTATTR 1050a64ed089SRobert Watson ufs_extattr_uepm_init(&ump->um_extattr); 1051a64ed089SRobert Watson #endif 10522b14f991SJulian Elischer /* 10532b14f991SJulian Elischer * Set FS local "last mounted on" information (NULL pad) 10542b14f991SJulian Elischer */ 105593373c42SSuleiman Souhlal bzero(fs->fs_fsmnt, MAXMNTLEN); 105693373c42SSuleiman Souhlal strlcpy(fs->fs_fsmnt, mp->mnt_stat.f_mntonname, MAXMNTLEN); 1057113db2ddSJeff Roberson mp->mnt_stat.f_iosize = fs->fs_bsize; 10582b14f991SJulian Elischer 10592b14f991SJulian Elischer if (mp->mnt_flag & MNT_ROOTFS) { 10602b14f991SJulian Elischer /* 10612b14f991SJulian Elischer * Root mount; update timestamp in mount structure. 10622b14f991SJulian Elischer * this will be used by the common root mount code 10632b14f991SJulian Elischer * to update the system clock. 10642b14f991SJulian Elischer */ 10652b14f991SJulian Elischer mp->mnt_time = fs->fs_time; 10662b14f991SJulian Elischer } 1067996c772fSJohn Dyson 1068996c772fSJohn Dyson if (ronly == 0) { 1069113db2ddSJeff Roberson fs->fs_mtime = time_second; 1070b1897c19SJulian Elischer if ((fs->fs_flags & FS_DOSOFTDEP) && 1071b1897c19SJulian Elischer (error = softdep_mount(devvp, mp, fs, cred)) != 0) { 1072f55ff3f3SIan Dowse free(fs->fs_csp, M_UFSMNT); 1073fddd463dSKonstantin Belousov ffs_flushfiles(mp, FORCECLOSE, td); 1074b1897c19SJulian Elischer goto out; 1075b1897c19SJulian Elischer } 1076f2a2857bSKirk McKusick if (fs->fs_snapinum[0] != 0) 1077f2a2857bSKirk McKusick ffs_snapshot_mount(mp); 1078cf60e8e4SKirk McKusick fs->fs_fmod = 1; 1079996c772fSJohn Dyson fs->fs_clean = 0; 1080791dd2faSTor Egge (void) ffs_sbupdate(ump, MNT_WAIT, 0); 1081996c772fSJohn Dyson } 1082d8d3d415SPoul-Henning Kamp /* 108398cbffd7SKonstantin Belousov * Initialize filesystem state information in mount struct. 1084d8d3d415SPoul-Henning Kamp */ 10856cf7bc60SRobert Watson MNT_ILOCK(mp); 1086bc2258daSAttilio Rao mp->mnt_kern_flag |= MNTK_LOOKUP_SHARED | MNTK_EXTENDED_SHARED | 10875f34e93cSMark Johnston MNTK_NO_IOPF | MNTK_UNMAPPED_BUFS | MNTK_USES_BCACHE; 10886cf7bc60SRobert Watson MNT_IUNLOCK(mp); 1089516081f2SRobert Watson #ifdef UFS_EXTATTR 1090516081f2SRobert Watson #ifdef UFS_EXTATTR_AUTOSTART 10919de54ba5SRobert Watson /* 10929de54ba5SRobert Watson * 1093f5161237SRobert Watson * Auto-starting does the following: 10949de54ba5SRobert Watson * - check for /.attribute in the fs, and extattr_start if so 10959de54ba5SRobert Watson * - for each file in .attribute, enable that file with 10969de54ba5SRobert Watson * an attribute of the same name. 10979de54ba5SRobert Watson * Not clear how to report errors -- probably eat them. 10989de54ba5SRobert Watson * This would all happen while the filesystem was busy/not 10999de54ba5SRobert Watson * available, so would effectively be "atomic". 11009de54ba5SRobert Watson */ 1101b40ce416SJulian Elischer (void) ufs_extattr_autostart(mp, td); 1102516081f2SRobert Watson #endif /* !UFS_EXTATTR_AUTOSTART */ 1103516081f2SRobert Watson #endif /* !UFS_EXTATTR */ 1104df8bae1dSRodney W. Grimes return (0); 1105df8bae1dSRodney W. Grimes out: 1106df8bae1dSRodney W. Grimes if (bp) 1107df8bae1dSRodney W. Grimes brelse(bp); 110843920011SPoul-Henning Kamp if (cp != NULL) { 110943920011SPoul-Henning Kamp g_topology_lock(); 11100d7935fdSAttilio Rao g_vfs_close(cp); 111143920011SPoul-Henning Kamp g_topology_unlock(); 111243920011SPoul-Henning Kamp } 1113df8bae1dSRodney W. Grimes if (ump) { 11143ba649d7SJeff Roberson mtx_destroy(UFS_MTX(ump)); 11151a60c7fcSPawel Jakub Dawidek if (mp->mnt_gjprovider != NULL) { 11161a60c7fcSPawel Jakub Dawidek free(mp->mnt_gjprovider, M_UFSMNT); 11171a60c7fcSPawel Jakub Dawidek mp->mnt_gjprovider = NULL; 11181a60c7fcSPawel Jakub Dawidek } 1119df8bae1dSRodney W. Grimes free(ump->um_fs, M_UFSMNT); 1120df8bae1dSRodney W. Grimes free(ump, M_UFSMNT); 112177465d93SAlfred Perlstein mp->mnt_data = NULL; 1122df8bae1dSRodney W. Grimes } 1123c70b3cd2SKonstantin Belousov atomic_store_rel_ptr((uintptr_t *)&dev->si_mountpt, 0); 112449c4791cSEdward Tomasz Napierala dev_rel(dev); 1125df8bae1dSRodney W. Grimes return (error); 1126df8bae1dSRodney W. Grimes } 1127df8bae1dSRodney W. Grimes 11281c85e6a3SKirk McKusick #include <sys/sysctl.h> 1129adf41577SPoul-Henning Kamp static int bigcgs = 0; 11301c85e6a3SKirk McKusick SYSCTL_INT(_debug, OID_AUTO, bigcgs, CTLFLAG_RW, &bigcgs, 0, ""); 11311c85e6a3SKirk McKusick 1132df8bae1dSRodney W. Grimes /* 11331c85e6a3SKirk McKusick * Sanity checks for loading old filesystem superblocks. 11341c85e6a3SKirk McKusick * See ffs_oldfscompat_write below for unwound actions. 1135df8bae1dSRodney W. Grimes * 11361c85e6a3SKirk McKusick * XXX - Parts get retired eventually. 11371c85e6a3SKirk McKusick * Unfortunately new bits get added. 1138df8bae1dSRodney W. Grimes */ 11391c85e6a3SKirk McKusick static void 11401c85e6a3SKirk McKusick ffs_oldfscompat_read(fs, ump, sblockloc) 1141df8bae1dSRodney W. Grimes struct fs *fs; 11421c85e6a3SKirk McKusick struct ufsmount *ump; 11431c85e6a3SKirk McKusick ufs2_daddr_t sblockloc; 11441c85e6a3SKirk McKusick { 11451c85e6a3SKirk McKusick off_t maxfilesize; 11461c85e6a3SKirk McKusick 11471c85e6a3SKirk McKusick /* 1148ada981b2SKirk McKusick * If not yet done, update fs_flags location and value of fs_sblockloc. 1149ada981b2SKirk McKusick */ 1150ada981b2SKirk McKusick if ((fs->fs_old_flags & FS_FLAGS_UPDATED) == 0) { 1151ada981b2SKirk McKusick fs->fs_flags = fs->fs_old_flags; 1152ada981b2SKirk McKusick fs->fs_old_flags |= FS_FLAGS_UPDATED; 1153ada981b2SKirk McKusick fs->fs_sblockloc = sblockloc; 1154ada981b2SKirk McKusick } 1155ada981b2SKirk McKusick /* 11561c85e6a3SKirk McKusick * If not yet done, update UFS1 superblock with new wider fields. 11571c85e6a3SKirk McKusick */ 115874f3809aSKirk McKusick if (fs->fs_magic == FS_UFS1_MAGIC && fs->fs_maxbsize != fs->fs_bsize) { 11591c85e6a3SKirk McKusick fs->fs_maxbsize = fs->fs_bsize; 11601c85e6a3SKirk McKusick fs->fs_time = fs->fs_old_time; 11611c85e6a3SKirk McKusick fs->fs_size = fs->fs_old_size; 11621c85e6a3SKirk McKusick fs->fs_dsize = fs->fs_old_dsize; 11631c85e6a3SKirk McKusick fs->fs_csaddr = fs->fs_old_csaddr; 11641c85e6a3SKirk McKusick fs->fs_cstotal.cs_ndir = fs->fs_old_cstotal.cs_ndir; 11651c85e6a3SKirk McKusick fs->fs_cstotal.cs_nbfree = fs->fs_old_cstotal.cs_nbfree; 11661c85e6a3SKirk McKusick fs->fs_cstotal.cs_nifree = fs->fs_old_cstotal.cs_nifree; 11671c85e6a3SKirk McKusick fs->fs_cstotal.cs_nffree = fs->fs_old_cstotal.cs_nffree; 11681c85e6a3SKirk McKusick } 11691c85e6a3SKirk McKusick if (fs->fs_magic == FS_UFS1_MAGIC && 11701c85e6a3SKirk McKusick fs->fs_old_inodefmt < FS_44INODEFMT) { 11718680d698SNate Lawson fs->fs_maxfilesize = ((uint64_t)1 << 31) - 1; 11721c85e6a3SKirk McKusick fs->fs_qbmask = ~fs->fs_bmask; 11731c85e6a3SKirk McKusick fs->fs_qfmask = ~fs->fs_fmask; 11741c85e6a3SKirk McKusick } 11758f42fb8fSIan Dowse if (fs->fs_magic == FS_UFS1_MAGIC) { 11761c85e6a3SKirk McKusick ump->um_savedmaxfilesize = fs->fs_maxfilesize; 11778680d698SNate Lawson maxfilesize = (uint64_t)0x80000000 * fs->fs_bsize - 1; 11781c85e6a3SKirk McKusick if (fs->fs_maxfilesize > maxfilesize) 11791c85e6a3SKirk McKusick fs->fs_maxfilesize = maxfilesize; 11808f42fb8fSIan Dowse } 11811c85e6a3SKirk McKusick /* Compatibility for old filesystems */ 11821c85e6a3SKirk McKusick if (fs->fs_avgfilesize <= 0) 11831c85e6a3SKirk McKusick fs->fs_avgfilesize = AVFILESIZ; 11841c85e6a3SKirk McKusick if (fs->fs_avgfpdir <= 0) 11851c85e6a3SKirk McKusick fs->fs_avgfpdir = AFPDIR; 11861c85e6a3SKirk McKusick if (bigcgs) { 11871c85e6a3SKirk McKusick fs->fs_save_cgsize = fs->fs_cgsize; 11881c85e6a3SKirk McKusick fs->fs_cgsize = fs->fs_bsize; 11891c85e6a3SKirk McKusick } 11901c85e6a3SKirk McKusick } 11911c85e6a3SKirk McKusick 11921c85e6a3SKirk McKusick /* 11931c85e6a3SKirk McKusick * Unwinding superblock updates for old filesystems. 11941c85e6a3SKirk McKusick * See ffs_oldfscompat_read above for details. 11951c85e6a3SKirk McKusick * 11961c85e6a3SKirk McKusick * XXX - Parts get retired eventually. 11971c85e6a3SKirk McKusick * Unfortunately new bits get added. 11981c85e6a3SKirk McKusick */ 1199113db2ddSJeff Roberson void 12001c85e6a3SKirk McKusick ffs_oldfscompat_write(fs, ump) 12011c85e6a3SKirk McKusick struct fs *fs; 12021c85e6a3SKirk McKusick struct ufsmount *ump; 1203df8bae1dSRodney W. Grimes { 1204df8bae1dSRodney W. Grimes 12051c85e6a3SKirk McKusick /* 12061c85e6a3SKirk McKusick * Copy back UFS2 updated fields that UFS1 inspects. 12071c85e6a3SKirk McKusick */ 12081c85e6a3SKirk McKusick if (fs->fs_magic == FS_UFS1_MAGIC) { 12091c85e6a3SKirk McKusick fs->fs_old_time = fs->fs_time; 12101c85e6a3SKirk McKusick fs->fs_old_cstotal.cs_ndir = fs->fs_cstotal.cs_ndir; 12111c85e6a3SKirk McKusick fs->fs_old_cstotal.cs_nbfree = fs->fs_cstotal.cs_nbfree; 12121c85e6a3SKirk McKusick fs->fs_old_cstotal.cs_nifree = fs->fs_cstotal.cs_nifree; 12131c85e6a3SKirk McKusick fs->fs_old_cstotal.cs_nffree = fs->fs_cstotal.cs_nffree; 12141c85e6a3SKirk McKusick fs->fs_maxfilesize = ump->um_savedmaxfilesize; 12158f42fb8fSIan Dowse } 12161c85e6a3SKirk McKusick if (bigcgs) { 12171c85e6a3SKirk McKusick fs->fs_cgsize = fs->fs_save_cgsize; 12181c85e6a3SKirk McKusick fs->fs_save_cgsize = 0; 12191c85e6a3SKirk McKusick } 1220df8bae1dSRodney W. Grimes } 1221df8bae1dSRodney W. Grimes 1222df8bae1dSRodney W. Grimes /* 1223df8bae1dSRodney W. Grimes * unmount system call 1224df8bae1dSRodney W. Grimes */ 1225adf41577SPoul-Henning Kamp static int 1226dfd233edSAttilio Rao ffs_unmount(mp, mntflags) 1227df8bae1dSRodney W. Grimes struct mount *mp; 1228df8bae1dSRodney W. Grimes int mntflags; 1229df8bae1dSRodney W. Grimes { 1230dfd233edSAttilio Rao struct thread *td; 123105f4ff5dSPoul-Henning Kamp struct ufsmount *ump = VFSTOUFS(mp); 123205f4ff5dSPoul-Henning Kamp struct fs *fs; 12336fecb4e4SKonstantin Belousov int error, flags, susp; 1234df86ccf6SKonstantin Belousov #ifdef UFS_EXTATTR 1235df86ccf6SKonstantin Belousov int e_restart; 1236df86ccf6SKonstantin Belousov #endif 1237df8bae1dSRodney W. Grimes 1238df8bae1dSRodney W. Grimes flags = 0; 1239dfd233edSAttilio Rao td = curthread; 12406fecb4e4SKonstantin Belousov fs = ump->um_fs; 1241b60ee81eSKirk McKusick susp = 0; 1242df8bae1dSRodney W. Grimes if (mntflags & MNT_FORCE) { 1243df8bae1dSRodney W. Grimes flags |= FORCECLOSE; 12444ce90426SKonstantin Belousov susp = fs->fs_ronly == 0; 1245b60ee81eSKirk McKusick } 1246516081f2SRobert Watson #ifdef UFS_EXTATTR 1247b40ce416SJulian Elischer if ((error = ufs_extattr_stop(mp, td))) { 1248b2b0497aSRobert Watson if (error != EOPNOTSUPP) 1249b60ee81eSKirk McKusick printf("WARNING: unmount %s: ufs_extattr_stop " 1250b60ee81eSKirk McKusick "returned errno %d\n", mp->mnt_stat.f_mntonname, 1251b2b0497aSRobert Watson error); 1252df86ccf6SKonstantin Belousov e_restart = 0; 12537df97b61SRobert Watson } else { 12549de54ba5SRobert Watson ufs_extattr_uepm_destroy(&ump->um_extattr); 1255df86ccf6SKonstantin Belousov e_restart = 1; 12567df97b61SRobert Watson } 1257a64ed089SRobert Watson #endif 12586fecb4e4SKonstantin Belousov if (susp) { 1259895b3782SKonstantin Belousov error = vfs_write_suspend_umnt(mp); 1260895b3782SKonstantin Belousov if (error != 0) 1261895b3782SKonstantin Belousov goto fail1; 12626fecb4e4SKonstantin Belousov } 1263fddf7baeSKirk McKusick if (MOUNTEDSOFTDEP(mp)) 12643c140b2dSEdward Tomasz Napierala error = softdep_flushfiles(mp, flags, td); 12653c140b2dSEdward Tomasz Napierala else 12663c140b2dSEdward Tomasz Napierala error = ffs_flushfiles(mp, flags, td); 12674f560d75SEdward Tomasz Napierala if (error != 0 && error != ENXIO) 12686fecb4e4SKonstantin Belousov goto fail; 12693c140b2dSEdward Tomasz Napierala 12703ba649d7SJeff Roberson UFS_LOCK(ump); 12719ccb939eSKirk McKusick if (fs->fs_pendingblocks != 0 || fs->fs_pendinginodes != 0) { 1272b60ee81eSKirk McKusick printf("WARNING: unmount %s: pending error: blocks %jd " 1273b60ee81eSKirk McKusick "files %d\n", fs->fs_fsmnt, (intmax_t)fs->fs_pendingblocks, 12741c85e6a3SKirk McKusick fs->fs_pendinginodes); 12759ccb939eSKirk McKusick fs->fs_pendingblocks = 0; 12769ccb939eSKirk McKusick fs->fs_pendinginodes = 0; 12779ccb939eSKirk McKusick } 12783ba649d7SJeff Roberson UFS_UNLOCK(ump); 1279519e3c3bSKirk McKusick if (MOUNTEDSOFTDEP(mp)) 1280113db2ddSJeff Roberson softdep_unmount(mp); 1281927a12aeSKirk McKusick if (fs->fs_ronly == 0 || ump->um_fsckpid > 0) { 12821a6a6610SKirk McKusick fs->fs_clean = fs->fs_flags & (FS_UNCLEAN|FS_NEEDSFSCK) ? 0 : 1; 1283791dd2faSTor Egge error = ffs_sbupdate(ump, MNT_WAIT, 0); 12844f560d75SEdward Tomasz Napierala if (error && error != ENXIO) { 1285996c772fSJohn Dyson fs->fs_clean = 0; 12866fecb4e4SKonstantin Belousov goto fail; 1287996c772fSJohn Dyson } 1288e0e9c421SDavid Greenman } 1289ddd6b3fcSKonstantin Belousov if (susp) 1290ddd6b3fcSKonstantin Belousov vfs_write_resume(mp, VR_START_WRITE); 1291c79dff0fSKonstantin Belousov if (ump->um_trim_tq != NULL) { 1292c79dff0fSKonstantin Belousov while (ump->um_trim_inflight != 0) 1293c79dff0fSKonstantin Belousov pause("ufsutr", hz); 1294c79dff0fSKonstantin Belousov taskqueue_drain_all(ump->um_trim_tq); 1295c79dff0fSKonstantin Belousov taskqueue_free(ump->um_trim_tq); 1296c79dff0fSKonstantin Belousov } 129743920011SPoul-Henning Kamp g_topology_lock(); 1298927a12aeSKirk McKusick if (ump->um_fsckpid > 0) { 1299927a12aeSKirk McKusick /* 1300927a12aeSKirk McKusick * Return to normal read-only mode. 1301927a12aeSKirk McKusick */ 1302927a12aeSKirk McKusick error = g_access(ump->um_cp, 0, -1, 0); 1303927a12aeSKirk McKusick ump->um_fsckpid = 0; 1304927a12aeSKirk McKusick } 13050d7935fdSAttilio Rao g_vfs_close(ump->um_cp); 130643920011SPoul-Henning Kamp g_topology_unlock(); 1307c70b3cd2SKonstantin Belousov atomic_store_rel_ptr((uintptr_t *)&ump->um_dev->si_mountpt, 0); 13086476c0d2SJohn Dyson vrele(ump->um_devvp); 130949c4791cSEdward Tomasz Napierala dev_rel(ump->um_dev); 13103ba649d7SJeff Roberson mtx_destroy(UFS_MTX(ump)); 13111a60c7fcSPawel Jakub Dawidek if (mp->mnt_gjprovider != NULL) { 13121a60c7fcSPawel Jakub Dawidek free(mp->mnt_gjprovider, M_UFSMNT); 13131a60c7fcSPawel Jakub Dawidek mp->mnt_gjprovider = NULL; 13141a60c7fcSPawel Jakub Dawidek } 1315f55ff3f3SIan Dowse free(fs->fs_csp, M_UFSMNT); 1316df8bae1dSRodney W. Grimes free(fs, M_UFSMNT); 1317df8bae1dSRodney W. Grimes free(ump, M_UFSMNT); 131877465d93SAlfred Perlstein mp->mnt_data = NULL; 13195da56ddbSTor Egge MNT_ILOCK(mp); 1320cc9d8990SPeter Wemm mp->mnt_flag &= ~MNT_LOCAL; 13215da56ddbSTor Egge MNT_IUNLOCK(mp); 1322df8bae1dSRodney W. Grimes return (error); 13236fecb4e4SKonstantin Belousov 13246fecb4e4SKonstantin Belousov fail: 1325ddd6b3fcSKonstantin Belousov if (susp) 1326ddd6b3fcSKonstantin Belousov vfs_write_resume(mp, VR_START_WRITE); 1327895b3782SKonstantin Belousov fail1: 1328df86ccf6SKonstantin Belousov #ifdef UFS_EXTATTR 1329df86ccf6SKonstantin Belousov if (e_restart) { 1330df86ccf6SKonstantin Belousov ufs_extattr_uepm_init(&ump->um_extattr); 1331df86ccf6SKonstantin Belousov #ifdef UFS_EXTATTR_AUTOSTART 1332df86ccf6SKonstantin Belousov (void) ufs_extattr_autostart(mp, td); 1333df86ccf6SKonstantin Belousov #endif 1334df86ccf6SKonstantin Belousov } 1335df86ccf6SKonstantin Belousov #endif 1336df86ccf6SKonstantin Belousov 13376fecb4e4SKonstantin Belousov return (error); 1338df8bae1dSRodney W. Grimes } 1339df8bae1dSRodney W. Grimes 1340df8bae1dSRodney W. Grimes /* 1341df8bae1dSRodney W. Grimes * Flush out all the files in a filesystem. 1342df8bae1dSRodney W. Grimes */ 134326f9a767SRodney W. Grimes int 1344b40ce416SJulian Elischer ffs_flushfiles(mp, flags, td) 134505f4ff5dSPoul-Henning Kamp struct mount *mp; 1346df8bae1dSRodney W. Grimes int flags; 1347b40ce416SJulian Elischer struct thread *td; 1348df8bae1dSRodney W. Grimes { 134905f4ff5dSPoul-Henning Kamp struct ufsmount *ump; 1350ba05dec5SKonstantin Belousov int qerror, error; 1351df8bae1dSRodney W. Grimes 1352df8bae1dSRodney W. Grimes ump = VFSTOUFS(mp); 1353ba05dec5SKonstantin Belousov qerror = 0; 1354df8bae1dSRodney W. Grimes #ifdef QUOTA 1355df8bae1dSRodney W. Grimes if (mp->mnt_flag & MNT_QUOTA) { 1356c1d9efcbSPoul-Henning Kamp int i; 1357f257b7a5SAlfred Perlstein error = vflush(mp, 0, SKIPSYSTEM|flags, td); 1358c1d9efcbSPoul-Henning Kamp if (error) 1359df8bae1dSRodney W. Grimes return (error); 1360df8bae1dSRodney W. Grimes for (i = 0; i < MAXQUOTAS; i++) { 1361ba05dec5SKonstantin Belousov error = quotaoff(td, mp, i); 1362ba05dec5SKonstantin Belousov if (error != 0) { 1363ba05dec5SKonstantin Belousov if ((flags & EARLYFLUSH) == 0) 1364ba05dec5SKonstantin Belousov return (error); 1365ba05dec5SKonstantin Belousov else 1366ba05dec5SKonstantin Belousov qerror = error; 1367df8bae1dSRodney W. Grimes } 1368ba05dec5SKonstantin Belousov } 1369ba05dec5SKonstantin Belousov 1370df8bae1dSRodney W. Grimes /* 1371ba05dec5SKonstantin Belousov * Here we fall through to vflush again to ensure that 1372ba05dec5SKonstantin Belousov * we have gotten rid of all the system vnodes, unless 1373ba05dec5SKonstantin Belousov * quotas must not be closed. 1374df8bae1dSRodney W. Grimes */ 1375df8bae1dSRodney W. Grimes } 1376df8bae1dSRodney W. Grimes #endif 1377e6e370a7SJeff Roberson ASSERT_VOP_LOCKED(ump->um_devvp, "ffs_flushfiles"); 1378e6e370a7SJeff Roberson if (ump->um_devvp->v_vflag & VV_COPYONWRITE) { 1379f257b7a5SAlfred Perlstein if ((error = vflush(mp, 0, SKIPSYSTEM | flags, td)) != 0) 1380f2a2857bSKirk McKusick return (error); 1381f2a2857bSKirk McKusick ffs_snapshot_unmount(mp); 138295e7a3c3STor Egge flags |= FORCECLOSE; 1383f2a2857bSKirk McKusick /* 1384f2a2857bSKirk McKusick * Here we fall through to vflush again to ensure 1385f2a2857bSKirk McKusick * that we have gotten rid of all the system vnodes. 1386f2a2857bSKirk McKusick */ 1387f2a2857bSKirk McKusick } 1388ba05dec5SKonstantin Belousov 1389b1897c19SJulian Elischer /* 1390ba05dec5SKonstantin Belousov * Do not close system files if quotas were not closed, to be 1391ba05dec5SKonstantin Belousov * able to sync the remaining dquots. The freeblks softupdate 1392ba05dec5SKonstantin Belousov * workitems might hold a reference on a dquot, preventing 1393ba05dec5SKonstantin Belousov * quotaoff() from completing. Next round of 1394ba05dec5SKonstantin Belousov * softdep_flushworklist() iteration should process the 1395ba05dec5SKonstantin Belousov * blockers, allowing the next run of quotaoff() to finally 1396ba05dec5SKonstantin Belousov * flush held dquots. 1397ba05dec5SKonstantin Belousov * 1398ba05dec5SKonstantin Belousov * Otherwise, flush all the files. 1399b1897c19SJulian Elischer */ 1400ba05dec5SKonstantin Belousov if (qerror == 0 && (error = vflush(mp, 0, flags, td)) != 0) 1401b1897c19SJulian Elischer return (error); 1402ba05dec5SKonstantin Belousov 1403b1897c19SJulian Elischer /* 1404b1897c19SJulian Elischer * Flush filesystem metadata. 1405b1897c19SJulian Elischer */ 1406cb05b60aSAttilio Rao vn_lock(ump->um_devvp, LK_EXCLUSIVE | LK_RETRY); 14078df6bac4SPoul-Henning Kamp error = VOP_FSYNC(ump->um_devvp, MNT_WAIT, td); 140822db15c0SAttilio Rao VOP_UNLOCK(ump->um_devvp, 0); 1409df8bae1dSRodney W. Grimes return (error); 1410df8bae1dSRodney W. Grimes } 1411df8bae1dSRodney W. Grimes 1412df8bae1dSRodney W. Grimes /* 1413df8bae1dSRodney W. Grimes * Get filesystem statistics. 1414df8bae1dSRodney W. Grimes */ 1415adf41577SPoul-Henning Kamp static int 1416dfd233edSAttilio Rao ffs_statfs(mp, sbp) 1417df8bae1dSRodney W. Grimes struct mount *mp; 141805f4ff5dSPoul-Henning Kamp struct statfs *sbp; 1419df8bae1dSRodney W. Grimes { 142005f4ff5dSPoul-Henning Kamp struct ufsmount *ump; 142105f4ff5dSPoul-Henning Kamp struct fs *fs; 1422df8bae1dSRodney W. Grimes 1423df8bae1dSRodney W. Grimes ump = VFSTOUFS(mp); 1424df8bae1dSRodney W. Grimes fs = ump->um_fs; 14251c85e6a3SKirk McKusick if (fs->fs_magic != FS_UFS1_MAGIC && fs->fs_magic != FS_UFS2_MAGIC) 1426df8bae1dSRodney W. Grimes panic("ffs_statfs"); 1427fde81c7dSKirk McKusick sbp->f_version = STATFS_VERSION; 1428df8bae1dSRodney W. Grimes sbp->f_bsize = fs->fs_fsize; 1429df8bae1dSRodney W. Grimes sbp->f_iosize = fs->fs_bsize; 1430df8bae1dSRodney W. Grimes sbp->f_blocks = fs->fs_dsize; 14313ba649d7SJeff Roberson UFS_LOCK(ump); 1432df8bae1dSRodney W. Grimes sbp->f_bfree = fs->fs_cstotal.cs_nbfree * fs->fs_frag + 14339ccb939eSKirk McKusick fs->fs_cstotal.cs_nffree + dbtofsb(fs, fs->fs_pendingblocks); 14349ccb939eSKirk McKusick sbp->f_bavail = freespace(fs, fs->fs_minfree) + 14359ccb939eSKirk McKusick dbtofsb(fs, fs->fs_pendingblocks); 14361dc349abSEd Maste sbp->f_files = fs->fs_ncg * fs->fs_ipg - UFS_ROOTINO; 14379ccb939eSKirk McKusick sbp->f_ffree = fs->fs_cstotal.cs_nifree + fs->fs_pendinginodes; 14383ba649d7SJeff Roberson UFS_UNLOCK(ump); 1439a96da1c3SConrad Meyer sbp->f_namemax = UFS_MAXNAMLEN; 1440df8bae1dSRodney W. Grimes return (0); 1441df8bae1dSRodney W. Grimes } 1442df8bae1dSRodney W. Grimes 14431eabd967SKonstantin Belousov static bool 14441eabd967SKonstantin Belousov sync_doupdate(struct inode *ip) 14451eabd967SKonstantin Belousov { 14461eabd967SKonstantin Belousov 14471eabd967SKonstantin Belousov return ((ip->i_flag & (IN_ACCESS | IN_CHANGE | IN_MODIFIED | 14481eabd967SKonstantin Belousov IN_UPDATE)) != 0); 14491eabd967SKonstantin Belousov } 14501eabd967SKonstantin Belousov 1451df8bae1dSRodney W. Grimes /* 1452a988a5c6SKonstantin Belousov * For a lazy sync, we only care about access times, quotas and the 1453a988a5c6SKonstantin Belousov * superblock. Other filesystem changes are already converted to 1454a988a5c6SKonstantin Belousov * cylinder group blocks or inode blocks updates and are written to 1455a988a5c6SKonstantin Belousov * disk by syncer. 1456a988a5c6SKonstantin Belousov */ 1457a988a5c6SKonstantin Belousov static int 1458a988a5c6SKonstantin Belousov ffs_sync_lazy(mp) 1459a988a5c6SKonstantin Belousov struct mount *mp; 1460a988a5c6SKonstantin Belousov { 1461a988a5c6SKonstantin Belousov struct vnode *mvp, *vp; 1462a988a5c6SKonstantin Belousov struct inode *ip; 1463a988a5c6SKonstantin Belousov struct thread *td; 1464a988a5c6SKonstantin Belousov int allerror, error; 1465a988a5c6SKonstantin Belousov 1466a988a5c6SKonstantin Belousov allerror = 0; 1467a988a5c6SKonstantin Belousov td = curthread; 1468a988a5c6SKonstantin Belousov if ((mp->mnt_flag & MNT_NOATIME) != 0) 1469a988a5c6SKonstantin Belousov goto qupdate; 1470dca5e0ecSKirk McKusick MNT_VNODE_FOREACH_ACTIVE(vp, mp, mvp) { 147171469bb3SKirk McKusick if (vp->v_type == VNON) { 1472a988a5c6SKonstantin Belousov VI_UNLOCK(vp); 1473a988a5c6SKonstantin Belousov continue; 1474a988a5c6SKonstantin Belousov } 1475a988a5c6SKonstantin Belousov ip = VTOI(vp); 1476a988a5c6SKonstantin Belousov 1477a988a5c6SKonstantin Belousov /* 1478a988a5c6SKonstantin Belousov * The IN_ACCESS flag is converted to IN_MODIFIED by 1479a988a5c6SKonstantin Belousov * ufs_close() and ufs_getattr() by the calls to 1480ea573a50SKonstantin Belousov * ufs_itimes_locked(), without subsequent UFS_UPDATE(). 1481ea573a50SKonstantin Belousov * Test also all the other timestamp flags too, to pick up 1482ea573a50SKonstantin Belousov * any other cases that could be missed. 1483a988a5c6SKonstantin Belousov */ 14841eabd967SKonstantin Belousov if (!sync_doupdate(ip) && (vp->v_iflag & VI_OWEINACT) == 0) { 1485a988a5c6SKonstantin Belousov VI_UNLOCK(vp); 1486a988a5c6SKonstantin Belousov continue; 1487a988a5c6SKonstantin Belousov } 1488a988a5c6SKonstantin Belousov if ((error = vget(vp, LK_EXCLUSIVE | LK_NOWAIT | LK_INTERLOCK, 148971469bb3SKirk McKusick td)) != 0) 1490a988a5c6SKonstantin Belousov continue; 14911eabd967SKonstantin Belousov if (sync_doupdate(ip)) 1492a988a5c6SKonstantin Belousov error = ffs_update(vp, 0); 1493a988a5c6SKonstantin Belousov if (error != 0) 1494a988a5c6SKonstantin Belousov allerror = error; 1495a988a5c6SKonstantin Belousov vput(vp); 1496a988a5c6SKonstantin Belousov } 1497a988a5c6SKonstantin Belousov 1498a988a5c6SKonstantin Belousov qupdate: 1499a988a5c6SKonstantin Belousov #ifdef QUOTA 1500a988a5c6SKonstantin Belousov qsync(mp); 1501a988a5c6SKonstantin Belousov #endif 1502a988a5c6SKonstantin Belousov 1503a988a5c6SKonstantin Belousov if (VFSTOUFS(mp)->um_fs->fs_fmod != 0 && 1504a988a5c6SKonstantin Belousov (error = ffs_sbupdate(VFSTOUFS(mp), MNT_LAZY, 0)) != 0) 1505a988a5c6SKonstantin Belousov allerror = error; 1506a988a5c6SKonstantin Belousov return (allerror); 1507a988a5c6SKonstantin Belousov } 1508a988a5c6SKonstantin Belousov 1509a988a5c6SKonstantin Belousov /* 1510df8bae1dSRodney W. Grimes * Go through the disk queues to initiate sandbagged IO; 1511df8bae1dSRodney W. Grimes * go through the inodes to write those that have been modified; 1512df8bae1dSRodney W. Grimes * initiate the writing of the super block if it has been modified. 1513df8bae1dSRodney W. Grimes * 1514a988a5c6SKonstantin Belousov * Note: we are always called with the filesystem marked busy using 1515a988a5c6SKonstantin Belousov * vfs_busy(). 1516df8bae1dSRodney W. Grimes */ 1517adf41577SPoul-Henning Kamp static int 1518dfd233edSAttilio Rao ffs_sync(mp, waitfor) 1519df8bae1dSRodney W. Grimes struct mount *mp; 1520df8bae1dSRodney W. Grimes int waitfor; 1521df8bae1dSRodney W. Grimes { 152282be0a5aSTor Egge struct vnode *mvp, *vp, *devvp; 1523dfd233edSAttilio Rao struct thread *td; 1524996c772fSJohn Dyson struct inode *ip; 1525996c772fSJohn Dyson struct ufsmount *ump = VFSTOUFS(mp); 1526996c772fSJohn Dyson struct fs *fs; 152769baeadcSKonstantin Belousov int error, count, lockreq, allerror = 0; 1528791dd2faSTor Egge int suspend; 1529791dd2faSTor Egge int suspended; 1530791dd2faSTor Egge int secondary_writes; 1531791dd2faSTor Egge int secondary_accwrites; 1532791dd2faSTor Egge int softdep_deps; 1533791dd2faSTor Egge int softdep_accdeps; 1534156cb265SPoul-Henning Kamp struct bufobj *bo; 1535df8bae1dSRodney W. Grimes 153619c87af0SKirk McKusick suspend = 0; 153719c87af0SKirk McKusick suspended = 0; 1538dfd233edSAttilio Rao td = curthread; 1539df8bae1dSRodney W. Grimes fs = ump->um_fs; 1540b60ee81eSKirk McKusick if (fs->fs_fmod != 0 && fs->fs_ronly != 0 && ump->um_fsckpid == 0) 1541b60ee81eSKirk McKusick panic("%s: ffs_sync: modification on read-only filesystem", 1542b60ee81eSKirk McKusick fs->fs_fsmnt); 15434af9f77eSKonstantin Belousov if (waitfor == MNT_LAZY) { 15444af9f77eSKonstantin Belousov if (!rebooting) 1545a988a5c6SKonstantin Belousov return (ffs_sync_lazy(mp)); 15464af9f77eSKonstantin Belousov waitfor = MNT_NOWAIT; 15474af9f77eSKonstantin Belousov } 1548a988a5c6SKonstantin Belousov 154919c87af0SKirk McKusick /* 1550df8bae1dSRodney W. Grimes * Write back each (modified) inode. 1551df8bae1dSRodney W. Grimes */ 1552245df27cSMatthew Dillon lockreq = LK_EXCLUSIVE | LK_NOWAIT; 1553791dd2faSTor Egge if (waitfor == MNT_SUSPEND) { 1554791dd2faSTor Egge suspend = 1; 1555791dd2faSTor Egge waitfor = MNT_WAIT; 1556791dd2faSTor Egge } 155769baeadcSKonstantin Belousov if (waitfor == MNT_WAIT) 1558245df27cSMatthew Dillon lockreq = LK_EXCLUSIVE; 155941d4783dSJeff Roberson lockreq |= LK_INTERLOCK | LK_SLEEPFAIL; 1560df8bae1dSRodney W. Grimes loop: 1561791dd2faSTor Egge /* Grab snapshot of secondary write counts */ 156271469bb3SKirk McKusick MNT_ILOCK(mp); 1563791dd2faSTor Egge secondary_writes = mp->mnt_secondary_writes; 1564791dd2faSTor Egge secondary_accwrites = mp->mnt_secondary_accwrites; 156571469bb3SKirk McKusick MNT_IUNLOCK(mp); 1566791dd2faSTor Egge 1567791dd2faSTor Egge /* Grab snapshot of softdep dependency counts */ 1568791dd2faSTor Egge softdep_get_depcounts(mp, &softdep_deps, &softdep_accdeps); 1569791dd2faSTor Egge 157071469bb3SKirk McKusick MNT_VNODE_FOREACH_ALL(vp, mp, mvp) { 1571245df27cSMatthew Dillon /* 1572e0c17408SKonstantin Belousov * Depend on the vnode interlock to keep things stable enough 1573245df27cSMatthew Dillon * for a quick test. Since there might be hundreds of 1574245df27cSMatthew Dillon * thousands of vnodes, we cannot afford even a subroutine 1575245df27cSMatthew Dillon * call unless there's a good chance that we have work to do. 1576245df27cSMatthew Dillon */ 157771469bb3SKirk McKusick if (vp->v_type == VNON) { 15782f05568aSJeff Roberson VI_UNLOCK(vp); 15792f05568aSJeff Roberson continue; 15802f05568aSJeff Roberson } 1581df8bae1dSRodney W. Grimes ip = VTOI(vp); 158271469bb3SKirk McKusick if ((ip->i_flag & 1583cf60e8e4SKirk McKusick (IN_ACCESS | IN_CHANGE | IN_MODIFIED | IN_UPDATE)) == 0 && 158471469bb3SKirk McKusick vp->v_bufobj.bo_dirty.bv_cnt == 0) { 15852f05568aSJeff Roberson VI_UNLOCK(vp); 1586df8bae1dSRodney W. Grimes continue; 1587996c772fSJohn Dyson } 1588b40ce416SJulian Elischer if ((error = vget(vp, lockreq, td)) != 0) { 158982be0a5aSTor Egge if (error == ENOENT || error == ENOLCK) { 159071469bb3SKirk McKusick MNT_VNODE_FOREACH_ALL_ABORT(mp, mvp); 1591df8bae1dSRodney W. Grimes goto loop; 159282be0a5aSTor Egge } 15932f05568aSJeff Roberson continue; 15942f05568aSJeff Roberson } 159575a58389SKirk McKusick if ((error = ffs_syncvnode(vp, waitfor, 0)) != 0) 1596df8bae1dSRodney W. Grimes allerror = error; 159741d4783dSJeff Roberson vput(vp); 1598245df27cSMatthew Dillon } 1599df8bae1dSRodney W. Grimes /* 1600df8bae1dSRodney W. Grimes * Force stale filesystem control information to be flushed. 1601df8bae1dSRodney W. Grimes */ 16024af9f77eSKonstantin Belousov if (waitfor == MNT_WAIT || rebooting) { 1603b40ce416SJulian Elischer if ((error = softdep_flushworklist(ump->um_mountp, &count, td))) 16049b971133SKirk McKusick allerror = error; 16059b971133SKirk McKusick /* Flushed work items may create new vnodes to clean */ 160671469bb3SKirk McKusick if (allerror == 0 && count) 16079b971133SKirk McKusick goto loop; 16089b971133SKirk McKusick } 1609589c7af9SKirk McKusick #ifdef QUOTA 1610589c7af9SKirk McKusick qsync(mp); 1611589c7af9SKirk McKusick #endif 161219c87af0SKirk McKusick 1613112f7372SKirk McKusick devvp = ump->um_devvp; 1614156cb265SPoul-Henning Kamp bo = &devvp->v_bufobj; 1615698b1a66SJeff Roberson BO_LOCK(bo); 161619c87af0SKirk McKusick if (bo->bo_numoutput > 0 || bo->bo_dirty.bv_cnt > 0) { 1617698b1a66SJeff Roberson BO_UNLOCK(bo); 1618698b1a66SJeff Roberson vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY); 16194af9f77eSKonstantin Belousov error = VOP_FSYNC(devvp, waitfor, td); 162022db15c0SAttilio Rao VOP_UNLOCK(devvp, 0); 16214af9f77eSKonstantin Belousov if (MOUNTEDSOFTDEP(mp) && (error == 0 || error == EAGAIN)) 16224af9f77eSKonstantin Belousov error = ffs_sbupdate(ump, waitfor, 0); 16234af9f77eSKonstantin Belousov if (error != 0) 16244af9f77eSKonstantin Belousov allerror = error; 162571469bb3SKirk McKusick if (allerror == 0 && waitfor == MNT_WAIT) 1626112f7372SKirk McKusick goto loop; 1627791dd2faSTor Egge } else if (suspend != 0) { 1628791dd2faSTor Egge if (softdep_check_suspend(mp, 1629791dd2faSTor Egge devvp, 1630791dd2faSTor Egge softdep_deps, 1631791dd2faSTor Egge softdep_accdeps, 1632791dd2faSTor Egge secondary_writes, 163371469bb3SKirk McKusick secondary_accwrites) != 0) { 163471469bb3SKirk McKusick MNT_IUNLOCK(mp); 1635791dd2faSTor Egge goto loop; /* More work needed */ 163671469bb3SKirk McKusick } 1637791dd2faSTor Egge mtx_assert(MNT_MTX(mp), MA_OWNED); 1638ca2fa807STor Egge mp->mnt_kern_flag |= MNTK_SUSPEND2 | MNTK_SUSPENDED; 1639791dd2faSTor Egge MNT_IUNLOCK(mp); 1640791dd2faSTor Egge suspended = 1; 1641112f7372SKirk McKusick } else 1642698b1a66SJeff Roberson BO_UNLOCK(bo); 1643996c772fSJohn Dyson /* 1644996c772fSJohn Dyson * Write back modified superblock. 1645996c772fSJohn Dyson */ 1646791dd2faSTor Egge if (fs->fs_fmod != 0 && 1647791dd2faSTor Egge (error = ffs_sbupdate(ump, waitfor, suspended)) != 0) 1648996c772fSJohn Dyson allerror = error; 1649df8bae1dSRodney W. Grimes return (allerror); 1650df8bae1dSRodney W. Grimes } 1651df8bae1dSRodney W. Grimes 1652df8bae1dSRodney W. Grimes int 1653a0595d02SKirk McKusick ffs_vget(mp, ino, flags, vpp) 1654df8bae1dSRodney W. Grimes struct mount *mp; 1655df8bae1dSRodney W. Grimes ino_t ino; 1656a0595d02SKirk McKusick int flags; 1657df8bae1dSRodney W. Grimes struct vnode **vpp; 1658df8bae1dSRodney W. Grimes { 16597b7ed832SKonstantin Belousov return (ffs_vgetf(mp, ino, flags, vpp, 0)); 16607b7ed832SKonstantin Belousov } 16617b7ed832SKonstantin Belousov 16627b7ed832SKonstantin Belousov int 16637b7ed832SKonstantin Belousov ffs_vgetf(mp, ino, flags, vpp, ffs_flags) 16647b7ed832SKonstantin Belousov struct mount *mp; 16657b7ed832SKonstantin Belousov ino_t ino; 16667b7ed832SKonstantin Belousov int flags; 16677b7ed832SKonstantin Belousov struct vnode **vpp; 16687b7ed832SKonstantin Belousov int ffs_flags; 16697b7ed832SKonstantin Belousov { 1670996c772fSJohn Dyson struct fs *fs; 1671996c772fSJohn Dyson struct inode *ip; 1672df8bae1dSRodney W. Grimes struct ufsmount *ump; 1673df8bae1dSRodney W. Grimes struct buf *bp; 1674df8bae1dSRodney W. Grimes struct vnode *vp; 1675f576a00dSSemen Ustimenko int error; 1676df8bae1dSRodney W. Grimes 167751f5ce0cSPoul-Henning Kamp error = vfs_hash_get(mp, ino, flags, curthread, vpp, NULL, NULL); 1678e82ef95cSPoul-Henning Kamp if (error || *vpp != NULL) 167914bc0685SPoul-Henning Kamp return (error); 1680f576a00dSSemen Ustimenko 1681f576a00dSSemen Ustimenko /* 1682d6919865SJeff Roberson * We must promote to an exclusive lock for vnode creation. This 1683d6919865SJeff Roberson * can happen if lookup is passed LOCKSHARED. 1684d6919865SJeff Roberson */ 1685d6919865SJeff Roberson if ((flags & LK_TYPE_MASK) == LK_SHARED) { 1686d6919865SJeff Roberson flags &= ~LK_TYPE_MASK; 1687d6919865SJeff Roberson flags |= LK_EXCLUSIVE; 1688d6919865SJeff Roberson } 1689d6919865SJeff Roberson 1690d6919865SJeff Roberson /* 169113866b3fSSemen Ustimenko * We do not lock vnode creation as it is believed to be too 1692f576a00dSSemen Ustimenko * expensive for such rare case as simultaneous creation of vnode 1693f576a00dSSemen Ustimenko * for same ino by different processes. We just allow them to race 1694f576a00dSSemen Ustimenko * and check later to decide who wins. Let the race begin! 1695f576a00dSSemen Ustimenko */ 169614bc0685SPoul-Henning Kamp 169714bc0685SPoul-Henning Kamp ump = VFSTOUFS(mp); 169814bc0685SPoul-Henning Kamp fs = ump->um_fs; 169914bc0685SPoul-Henning Kamp ip = uma_zalloc(uma_inode, M_WAITOK | M_ZERO); 17002f9bae59SDavid Greenman 1701df8bae1dSRodney W. Grimes /* Allocate a new vnode/inode. */ 170243a993bbSKirk McKusick error = getnewvnode("ufs", mp, fs->fs_magic == FS_UFS1_MAGIC ? 170343a993bbSKirk McKusick &ffs_vnodeops1 : &ffs_vnodeops2, &vp); 1704c9671602SPoul-Henning Kamp if (error) { 1705df8bae1dSRodney W. Grimes *vpp = NULL; 1706aa4d7a8aSPoul-Henning Kamp uma_zfree(uma_inode, ip); 1707df8bae1dSRodney W. Grimes return (error); 1708df8bae1dSRodney W. Grimes } 170967e87166SBoris Popov /* 171033fc3625SJohn Baldwin * FFS supports recursive locking. 171167e87166SBoris Popov */ 17123634d5b2SJohn Baldwin lockmgr(vp->v_vnlock, LK_EXCLUSIVE, NULL); 1713628f51d2SAttilio Rao VN_LOCK_AREC(vp); 1714df8bae1dSRodney W. Grimes vp->v_data = ip; 17155d9d81e7SPoul-Henning Kamp vp->v_bufobj.bo_bsize = fs->fs_bsize; 1716df8bae1dSRodney W. Grimes ip->i_vnode = vp; 17171c85e6a3SKirk McKusick ip->i_ump = ump; 1718df8bae1dSRodney W. Grimes ip->i_number = ino; 1719e65f5a4eSKonstantin Belousov ip->i_ea_refs = 0; 172074a87c38SKirk McKusick ip->i_nextclustercg = -1; 1721e1db6897SKonstantin Belousov ip->i_flag = fs->fs_magic == FS_UFS1_MAGIC ? 0 : IN_UFS2; 1722df8bae1dSRodney W. Grimes #ifdef QUOTA 1723c1d9efcbSPoul-Henning Kamp { 1724c1d9efcbSPoul-Henning Kamp int i; 1725df8bae1dSRodney W. Grimes for (i = 0; i < MAXQUOTAS; i++) 1726df8bae1dSRodney W. Grimes ip->i_dquot[i] = NODQUOT; 1727c1d9efcbSPoul-Henning Kamp } 1728df8bae1dSRodney W. Grimes #endif 1729df8bae1dSRodney W. Grimes 17307b7ed832SKonstantin Belousov if (ffs_flags & FFSV_FORCEINSMQ) 17317b7ed832SKonstantin Belousov vp->v_vflag |= VV_FORCEINSMQ; 173261b9d89fSTor Egge error = insmntque(vp, mp); 173361b9d89fSTor Egge if (error != 0) { 17346cc745d2SKonstantin Belousov uma_zfree(uma_inode, ip); 173561b9d89fSTor Egge *vpp = NULL; 173661b9d89fSTor Egge return (error); 173761b9d89fSTor Egge } 17387b7ed832SKonstantin Belousov vp->v_vflag &= ~VV_FORCEINSMQ; 1739a80d8caaSPawel Jakub Dawidek error = vfs_hash_insert(vp, ino, flags, curthread, vpp, NULL, NULL); 174045c26fa2SPoul-Henning Kamp if (error || *vpp != NULL) 1741f576a00dSSemen Ustimenko return (error); 1742f576a00dSSemen Ustimenko 1743df8bae1dSRodney W. Grimes /* Read in the disk contents for the inode, copy into the inode. */ 1744c9671602SPoul-Henning Kamp error = bread(ump->um_devvp, fsbtodb(fs, ino_to_fsba(fs, ino)), 1745c9671602SPoul-Henning Kamp (int)fs->fs_bsize, NOCRED, &bp); 1746c9671602SPoul-Henning Kamp if (error) { 1747df8bae1dSRodney W. Grimes /* 1748df8bae1dSRodney W. Grimes * The inode does not contain anything useful, so it would 1749df8bae1dSRodney W. Grimes * be misleading to leave it on its hash chain. With mode 1750df8bae1dSRodney W. Grimes * still zero, it will be unlinked and returned to the free 1751df8bae1dSRodney W. Grimes * list by vput(). 1752df8bae1dSRodney W. Grimes */ 1753df8bae1dSRodney W. Grimes brelse(bp); 1754bd7e5f99SJohn Dyson vput(vp); 1755df8bae1dSRodney W. Grimes *vpp = NULL; 1756df8bae1dSRodney W. Grimes return (error); 1757df8bae1dSRodney W. Grimes } 1758e1db6897SKonstantin Belousov if (I_IS_UFS1(ip)) 1759a163d034SWarner Losh ip->i_din1 = uma_zalloc(uma_ufs1, M_WAITOK); 1760de6ba7c0SPoul-Henning Kamp else 1761a163d034SWarner Losh ip->i_din2 = uma_zalloc(uma_ufs2, M_WAITOK); 1762de6ba7c0SPoul-Henning Kamp ffs_load_inode(bp, ip, fs, ino); 1763b1897c19SJulian Elischer if (DOINGSOFTDEP(vp)) 1764b1897c19SJulian Elischer softdep_load_inodeblock(ip); 1765b1897c19SJulian Elischer else 1766b1897c19SJulian Elischer ip->i_effnlink = ip->i_nlink; 1767bd7e5f99SJohn Dyson bqrelse(bp); 1768df8bae1dSRodney W. Grimes 1769df8bae1dSRodney W. Grimes /* 1770df8bae1dSRodney W. Grimes * Initialize the vnode from the inode, check for aliases. 1771df8bae1dSRodney W. Grimes * Note that the underlying vnode may have changed. 1772df8bae1dSRodney W. Grimes */ 1773e1db6897SKonstantin Belousov error = ufs_vinit(mp, I_IS_UFS1(ip) ? &ffs_fifoops1 : &ffs_fifoops2, 1774e1db6897SKonstantin Belousov &vp); 1775c9671602SPoul-Henning Kamp if (error) { 1776df8bae1dSRodney W. Grimes vput(vp); 1777df8bae1dSRodney W. Grimes *vpp = NULL; 1778df8bae1dSRodney W. Grimes return (error); 1779df8bae1dSRodney W. Grimes } 1780de68347bSPoul-Henning Kamp 1781df8bae1dSRodney W. Grimes /* 17825c24d6eeSPoul-Henning Kamp * Finish inode initialization. 1783df8bae1dSRodney W. Grimes */ 178433fc3625SJohn Baldwin if (vp->v_type != VFIFO) { 178533fc3625SJohn Baldwin /* FFS supports shared locking for all files except fifos. */ 178633fc3625SJohn Baldwin VN_LOCK_ASHARE(vp); 178733fc3625SJohn Baldwin } 1788de68347bSPoul-Henning Kamp 1789df8bae1dSRodney W. Grimes /* 1790df8bae1dSRodney W. Grimes * Set up a generation number for this inode if it does not 1791df8bae1dSRodney W. Grimes * already have one. This should only happen on old filesystems. 1792df8bae1dSRodney W. Grimes */ 1793df8bae1dSRodney W. Grimes if (ip->i_gen == 0) { 179457d2ac2fSKevin Lo while (ip->i_gen == 0) 179557d2ac2fSKevin Lo ip->i_gen = arc4random(); 17961c85e6a3SKirk McKusick if ((vp->v_mount->mnt_flag & MNT_RDONLY) == 0) { 1797df8bae1dSRodney W. Grimes ip->i_flag |= IN_MODIFIED; 1798b403319bSAlexander Kabaev DIP_SET(ip, i_gen, ip->i_gen); 17991c85e6a3SKirk McKusick } 1800df8bae1dSRodney W. Grimes } 1801763bbd2fSRobert Watson #ifdef MAC 1802763bbd2fSRobert Watson if ((mp->mnt_flag & MNT_MULTILABEL) && ip->i_mode) { 1803763bbd2fSRobert Watson /* 1804763bbd2fSRobert Watson * If this vnode is already allocated, and we're running 1805763bbd2fSRobert Watson * multi-label, attempt to perform a label association 1806763bbd2fSRobert Watson * from the extended attributes on the inode. 1807763bbd2fSRobert Watson */ 180830d239bcSRobert Watson error = mac_vnode_associate_extattr(mp, vp); 1809763bbd2fSRobert Watson if (error) { 1810763bbd2fSRobert Watson /* ufs_inactive will release ip->i_devvp ref. */ 1811763bbd2fSRobert Watson vput(vp); 1812763bbd2fSRobert Watson *vpp = NULL; 1813763bbd2fSRobert Watson return (error); 1814763bbd2fSRobert Watson } 1815763bbd2fSRobert Watson } 1816763bbd2fSRobert Watson #endif 1817763bbd2fSRobert Watson 1818df8bae1dSRodney W. Grimes *vpp = vp; 1819df8bae1dSRodney W. Grimes return (0); 1820df8bae1dSRodney W. Grimes } 1821df8bae1dSRodney W. Grimes 1822df8bae1dSRodney W. Grimes /* 1823df8bae1dSRodney W. Grimes * File handle to vnode 1824df8bae1dSRodney W. Grimes * 1825df8bae1dSRodney W. Grimes * Have to be really careful about stale file handles: 1826df8bae1dSRodney W. Grimes * - check that the inode number is valid 1827abe53f7eSKirk McKusick * - for UFS2 check that the inode number is initialized 1828df8bae1dSRodney W. Grimes * - call ffs_vget() to get the locked inode 1829df8bae1dSRodney W. Grimes * - check for an unallocated inode (i_mode == 0) 1830df8bae1dSRodney W. Grimes * - check that the given client host has export rights and return 1831df8bae1dSRodney W. Grimes * those rights via. exflagsp and credanonp 1832df8bae1dSRodney W. Grimes */ 1833adf41577SPoul-Henning Kamp static int 1834694a586aSRick Macklem ffs_fhtovp(mp, fhp, flags, vpp) 183505f4ff5dSPoul-Henning Kamp struct mount *mp; 1836df8bae1dSRodney W. Grimes struct fid *fhp; 1837694a586aSRick Macklem int flags; 1838df8bae1dSRodney W. Grimes struct vnode **vpp; 1839df8bae1dSRodney W. Grimes { 184005f4ff5dSPoul-Henning Kamp struct ufid *ufhp; 1841abe53f7eSKirk McKusick struct ufsmount *ump; 1842df8bae1dSRodney W. Grimes struct fs *fs; 1843abe53f7eSKirk McKusick struct cg *cgp; 1844abe53f7eSKirk McKusick struct buf *bp; 1845abe53f7eSKirk McKusick ino_t ino; 1846abe53f7eSKirk McKusick u_int cg; 1847abe53f7eSKirk McKusick int error; 1848df8bae1dSRodney W. Grimes 1849df8bae1dSRodney W. Grimes ufhp = (struct ufid *)fhp; 1850abe53f7eSKirk McKusick ino = ufhp->ufid_ino; 1851abe53f7eSKirk McKusick ump = VFSTOUFS(mp); 1852abe53f7eSKirk McKusick fs = ump->um_fs; 18531dc349abSEd Maste if (ino < UFS_ROOTINO || ino >= fs->fs_ncg * fs->fs_ipg) 1854df8bae1dSRodney W. Grimes return (ESTALE); 1855abe53f7eSKirk McKusick /* 1856abe53f7eSKirk McKusick * Need to check if inode is initialized because UFS2 does lazy 1857abe53f7eSKirk McKusick * initialization and nfs_fhtovp can offer arbitrary inode numbers. 1858abe53f7eSKirk McKusick */ 1859abe53f7eSKirk McKusick if (fs->fs_magic != FS_UFS2_MAGIC) 1860abe53f7eSKirk McKusick return (ufs_fhtovp(mp, ufhp, flags, vpp)); 1861abe53f7eSKirk McKusick cg = ino_to_cg(fs, ino); 1862abe53f7eSKirk McKusick error = bread(ump->um_devvp, fsbtodb(fs, cgtod(fs, cg)), 1863abe53f7eSKirk McKusick (int)fs->fs_cgsize, NOCRED, &bp); 1864abe53f7eSKirk McKusick if (error) 1865abe53f7eSKirk McKusick return (error); 1866abe53f7eSKirk McKusick cgp = (struct cg *)bp->b_data; 1867abe53f7eSKirk McKusick if (!cg_chkmagic(cgp) || ino >= cg * fs->fs_ipg + cgp->cg_initediblk) { 1868abe53f7eSKirk McKusick brelse(bp); 1869abe53f7eSKirk McKusick return (ESTALE); 1870abe53f7eSKirk McKusick } 1871abe53f7eSKirk McKusick brelse(bp); 1872694a586aSRick Macklem return (ufs_fhtovp(mp, ufhp, flags, vpp)); 1873df8bae1dSRodney W. Grimes } 1874df8bae1dSRodney W. Grimes 1875df8bae1dSRodney W. Grimes /* 18765346934fSIan Dowse * Initialize the filesystem. 1877996c772fSJohn Dyson */ 1878996c772fSJohn Dyson static int 1879996c772fSJohn Dyson ffs_init(vfsp) 1880996c772fSJohn Dyson struct vfsconf *vfsp; 1881996c772fSJohn Dyson { 1882996c772fSJohn Dyson 18831848286aSEdward Tomasz Napierala ffs_susp_initialize(); 1884b1897c19SJulian Elischer softdep_initialize(); 1885996c772fSJohn Dyson return (ufs_init(vfsp)); 1886996c772fSJohn Dyson } 1887996c772fSJohn Dyson 1888996c772fSJohn Dyson /* 18895346934fSIan Dowse * Undo the work of ffs_init(). 18905346934fSIan Dowse */ 18915346934fSIan Dowse static int 18925346934fSIan Dowse ffs_uninit(vfsp) 18935346934fSIan Dowse struct vfsconf *vfsp; 18945346934fSIan Dowse { 18955346934fSIan Dowse int ret; 18965346934fSIan Dowse 18975346934fSIan Dowse ret = ufs_uninit(vfsp); 18985346934fSIan Dowse softdep_uninitialize(); 18991848286aSEdward Tomasz Napierala ffs_susp_uninitialize(); 19005346934fSIan Dowse return (ret); 19015346934fSIan Dowse } 19025346934fSIan Dowse 19035346934fSIan Dowse /* 1904df8bae1dSRodney W. Grimes * Write a superblock and associated information back to disk. 1905df8bae1dSRodney W. Grimes */ 19061a60c7fcSPawel Jakub Dawidek int 1907927a12aeSKirk McKusick ffs_sbupdate(ump, waitfor, suspended) 1908927a12aeSKirk McKusick struct ufsmount *ump; 1909df8bae1dSRodney W. Grimes int waitfor; 1910791dd2faSTor Egge int suspended; 1911df8bae1dSRodney W. Grimes { 1912927a12aeSKirk McKusick struct fs *fs = ump->um_fs; 19133ba649d7SJeff Roberson struct buf *sbbp; 191405f4ff5dSPoul-Henning Kamp struct buf *bp; 1915df8bae1dSRodney W. Grimes int blks; 1916f55ff3f3SIan Dowse void *space; 1917996c772fSJohn Dyson int i, size, error, allerror = 0; 1918df8bae1dSRodney W. Grimes 191974f3809aSKirk McKusick if (fs->fs_ronly == 1 && 1920927a12aeSKirk McKusick (ump->um_mountp->mnt_flag & (MNT_RDONLY | MNT_UPDATE)) != 1921927a12aeSKirk McKusick (MNT_RDONLY | MNT_UPDATE) && ump->um_fsckpid == 0) 192274f3809aSKirk McKusick panic("ffs_sbupdate: write read-only filesystem"); 1923996c772fSJohn Dyson /* 19243ba649d7SJeff Roberson * We use the superblock's buf to serialize calls to ffs_sbupdate(). 19253ba649d7SJeff Roberson */ 1926927a12aeSKirk McKusick sbbp = getblk(ump->um_devvp, btodb(fs->fs_sblockloc), 1927927a12aeSKirk McKusick (int)fs->fs_sbsize, 0, 0, 0); 19283ba649d7SJeff Roberson /* 1929996c772fSJohn Dyson * First write back the summary information. 1930996c772fSJohn Dyson */ 1931df8bae1dSRodney W. Grimes blks = howmany(fs->fs_cssize, fs->fs_fsize); 1932f55ff3f3SIan Dowse space = fs->fs_csp; 1933df8bae1dSRodney W. Grimes for (i = 0; i < blks; i += fs->fs_frag) { 1934df8bae1dSRodney W. Grimes size = fs->fs_bsize; 1935df8bae1dSRodney W. Grimes if (i + fs->fs_frag > blks) 1936df8bae1dSRodney W. Grimes size = (blks - i) * fs->fs_fsize; 1937927a12aeSKirk McKusick bp = getblk(ump->um_devvp, fsbtodb(fs, fs->fs_csaddr + i), 19387261f5f6SJeff Roberson size, 0, 0, 0); 1939df8bae1dSRodney W. Grimes bcopy(space, bp->b_data, (u_int)size); 1940f55ff3f3SIan Dowse space = (char *)space + size; 1941791dd2faSTor Egge if (suspended) 1942791dd2faSTor Egge bp->b_flags |= B_VALIDSUSPWRT; 1943996c772fSJohn Dyson if (waitfor != MNT_WAIT) 1944df8bae1dSRodney W. Grimes bawrite(bp); 19458aef1712SMatthew Dillon else if ((error = bwrite(bp)) != 0) 1946996c772fSJohn Dyson allerror = error; 1947df8bae1dSRodney W. Grimes } 1948996c772fSJohn Dyson /* 1949996c772fSJohn Dyson * Now write back the superblock itself. If any errors occurred 1950996c772fSJohn Dyson * up to this point, then fail so that the superblock avoids 1951996c772fSJohn Dyson * being written out as clean. 1952996c772fSJohn Dyson */ 19533ba649d7SJeff Roberson if (allerror) { 19543ba649d7SJeff Roberson brelse(sbbp); 1955996c772fSJohn Dyson return (allerror); 19563ba649d7SJeff Roberson } 19573ba649d7SJeff Roberson bp = sbbp; 195831574422SKirk McKusick if (fs->fs_magic == FS_UFS1_MAGIC && fs->fs_sblockloc != SBLOCK_UFS1 && 1959e9838c11SJohn-Mark Gurney (fs->fs_old_flags & FS_FLAGS_UPDATED) == 0) { 1960b60ee81eSKirk McKusick printf("WARNING: %s: correcting fs_sblockloc from %jd to %d\n", 1961fa5d33e2SKirk McKusick fs->fs_fsmnt, fs->fs_sblockloc, SBLOCK_UFS1); 1962fa5d33e2SKirk McKusick fs->fs_sblockloc = SBLOCK_UFS1; 1963fa5d33e2SKirk McKusick } 196431574422SKirk McKusick if (fs->fs_magic == FS_UFS2_MAGIC && fs->fs_sblockloc != SBLOCK_UFS2 && 1965e9838c11SJohn-Mark Gurney (fs->fs_old_flags & FS_FLAGS_UPDATED) == 0) { 1966b60ee81eSKirk McKusick printf("WARNING: %s: correcting fs_sblockloc from %jd to %d\n", 1967fa5d33e2SKirk McKusick fs->fs_fsmnt, fs->fs_sblockloc, SBLOCK_UFS2); 1968fa5d33e2SKirk McKusick fs->fs_sblockloc = SBLOCK_UFS2; 1969fa5d33e2SKirk McKusick } 1970b1897c19SJulian Elischer fs->fs_fmod = 0; 1971227ee8a1SPoul-Henning Kamp fs->fs_time = time_second; 1972519e3c3bSKirk McKusick if (MOUNTEDSOFTDEP(ump->um_mountp)) 1973927a12aeSKirk McKusick softdep_setup_sbupdate(ump, (struct fs *)bp->b_data, bp); 1974996c772fSJohn Dyson bcopy((caddr_t)fs, bp->b_data, (u_int)fs->fs_sbsize); 1975927a12aeSKirk McKusick ffs_oldfscompat_write((struct fs *)bp->b_data, ump); 1976791dd2faSTor Egge if (suspended) 1977791dd2faSTor Egge bp->b_flags |= B_VALIDSUSPWRT; 1978996c772fSJohn Dyson if (waitfor != MNT_WAIT) 1979996c772fSJohn Dyson bawrite(bp); 19808aef1712SMatthew Dillon else if ((error = bwrite(bp)) != 0) 1981996c772fSJohn Dyson allerror = error; 1982996c772fSJohn Dyson return (allerror); 1983df8bae1dSRodney W. Grimes } 1984d6fe88e4SPoul-Henning Kamp 1985d6fe88e4SPoul-Henning Kamp static int 1986d6fe88e4SPoul-Henning Kamp ffs_extattrctl(struct mount *mp, int cmd, struct vnode *filename_vp, 1987dfd233edSAttilio Rao int attrnamespace, const char *attrname) 1988d6fe88e4SPoul-Henning Kamp { 1989d6fe88e4SPoul-Henning Kamp 1990d6fe88e4SPoul-Henning Kamp #ifdef UFS_EXTATTR 1991d6fe88e4SPoul-Henning Kamp return (ufs_extattrctl(mp, cmd, filename_vp, attrnamespace, 1992dfd233edSAttilio Rao attrname)); 1993d6fe88e4SPoul-Henning Kamp #else 1994d6fe88e4SPoul-Henning Kamp return (vfs_stdextattrctl(mp, cmd, filename_vp, attrnamespace, 1995dfd233edSAttilio Rao attrname)); 1996d6fe88e4SPoul-Henning Kamp #endif 1997d6fe88e4SPoul-Henning Kamp } 1998975512a9SPoul-Henning Kamp 1999975512a9SPoul-Henning Kamp static void 2000975512a9SPoul-Henning Kamp ffs_ifree(struct ufsmount *ump, struct inode *ip) 2001975512a9SPoul-Henning Kamp { 2002975512a9SPoul-Henning Kamp 200336329289STim J. Robbins if (ump->um_fstype == UFS1 && ip->i_din1 != NULL) 2004aa4d7a8aSPoul-Henning Kamp uma_zfree(uma_ufs1, ip->i_din1); 200536329289STim J. Robbins else if (ip->i_din2 != NULL) 20068d721e87STim J. Robbins uma_zfree(uma_ufs2, ip->i_din2); 2007aa4d7a8aSPoul-Henning Kamp uma_zfree(uma_inode, ip); 2008975512a9SPoul-Henning Kamp } 20096e77a041SPoul-Henning Kamp 2010dd19a799SPoul-Henning Kamp static int dobkgrdwrite = 1; 2011dd19a799SPoul-Henning Kamp SYSCTL_INT(_debug, OID_AUTO, dobkgrdwrite, CTLFLAG_RW, &dobkgrdwrite, 0, 2012dd19a799SPoul-Henning Kamp "Do background writes (honoring the BV_BKGRDWRITE flag)?"); 2013dd19a799SPoul-Henning Kamp 2014dd19a799SPoul-Henning Kamp /* 2015dd19a799SPoul-Henning Kamp * Complete a background write started from bwrite. 2016dd19a799SPoul-Henning Kamp */ 2017dd19a799SPoul-Henning Kamp static void 2018dd19a799SPoul-Henning Kamp ffs_backgroundwritedone(struct buf *bp) 2019dd19a799SPoul-Henning Kamp { 2020204ec66dSJeff Roberson struct bufobj *bufobj; 2021dd19a799SPoul-Henning Kamp struct buf *origbp; 2022dd19a799SPoul-Henning Kamp 2023dd19a799SPoul-Henning Kamp /* 2024dd19a799SPoul-Henning Kamp * Find the original buffer that we are writing. 2025dd19a799SPoul-Henning Kamp */ 2026204ec66dSJeff Roberson bufobj = bp->b_bufobj; 2027204ec66dSJeff Roberson BO_LOCK(bufobj); 2028dd19a799SPoul-Henning Kamp if ((origbp = gbincore(bp->b_bufobj, bp->b_lblkno)) == NULL) 2029dd19a799SPoul-Henning Kamp panic("backgroundwritedone: lost buffer"); 2030b2c3df84SKonstantin Belousov 2031b2c3df84SKonstantin Belousov /* 2032b2c3df84SKonstantin Belousov * We should mark the cylinder group buffer origbp as 2033b2c3df84SKonstantin Belousov * dirty, to not loose the failed write. 2034b2c3df84SKonstantin Belousov */ 2035b2c3df84SKonstantin Belousov if ((bp->b_ioflags & BIO_ERROR) != 0) 2036b2c3df84SKonstantin Belousov origbp->b_vflags |= BV_BKGRDERR; 2037204ec66dSJeff Roberson BO_UNLOCK(bufobj); 2038dd19a799SPoul-Henning Kamp /* 2039dd19a799SPoul-Henning Kamp * Process dependencies then return any unfinished ones. 2040dd19a799SPoul-Henning Kamp */ 204126089666SJeff Roberson pbrelvp(bp); 2042b2c3df84SKonstantin Belousov if (!LIST_EMPTY(&bp->b_dep) && (bp->b_ioflags & BIO_ERROR) == 0) 2043dd19a799SPoul-Henning Kamp buf_complete(bp); 2044dd19a799SPoul-Henning Kamp #ifdef SOFTUPDATES 204504533fc6SXin LI if (!LIST_EMPTY(&bp->b_dep)) 2046dd19a799SPoul-Henning Kamp softdep_move_dependencies(bp, origbp); 2047dd19a799SPoul-Henning Kamp #endif 2048dd19a799SPoul-Henning Kamp /* 2049204ec66dSJeff Roberson * This buffer is marked B_NOCACHE so when it is released 2050204ec66dSJeff Roberson * by biodone it will be tossed. 2051dd19a799SPoul-Henning Kamp */ 2052dd19a799SPoul-Henning Kamp bp->b_flags |= B_NOCACHE; 2053ec9c9e73SAlan Cox bp->b_flags &= ~B_CACHE; 2054b2c3df84SKonstantin Belousov 2055b2c3df84SKonstantin Belousov /* 2056b2c3df84SKonstantin Belousov * Prevent brelse() from trying to keep and re-dirtying bp on 2057b2c3df84SKonstantin Belousov * errors. It causes b_bufobj dereference in 2058b2c3df84SKonstantin Belousov * bdirty()/reassignbuf(), and b_bufobj was cleared in 2059b2c3df84SKonstantin Belousov * pbrelvp() above. 2060b2c3df84SKonstantin Belousov */ 2061b2c3df84SKonstantin Belousov if ((bp->b_ioflags & BIO_ERROR) != 0) 2062b2c3df84SKonstantin Belousov bp->b_flags |= B_INVAL; 2063dd19a799SPoul-Henning Kamp bufdone(bp); 2064204ec66dSJeff Roberson BO_LOCK(bufobj); 2065dd19a799SPoul-Henning Kamp /* 2066dd19a799SPoul-Henning Kamp * Clear the BV_BKGRDINPROG flag in the original buffer 2067dd19a799SPoul-Henning Kamp * and awaken it if it is waiting for the write to complete. 2068dd19a799SPoul-Henning Kamp * If BV_BKGRDINPROG is not set in the original buffer it must 2069dd19a799SPoul-Henning Kamp * have been released and re-instantiated - which is not legal. 2070dd19a799SPoul-Henning Kamp */ 2071dd19a799SPoul-Henning Kamp KASSERT((origbp->b_vflags & BV_BKGRDINPROG), 2072dd19a799SPoul-Henning Kamp ("backgroundwritedone: lost buffer2")); 2073dd19a799SPoul-Henning Kamp origbp->b_vflags &= ~BV_BKGRDINPROG; 2074dd19a799SPoul-Henning Kamp if (origbp->b_vflags & BV_BKGRDWAIT) { 2075dd19a799SPoul-Henning Kamp origbp->b_vflags &= ~BV_BKGRDWAIT; 2076dd19a799SPoul-Henning Kamp wakeup(&origbp->b_xflags); 2077dd19a799SPoul-Henning Kamp } 2078204ec66dSJeff Roberson BO_UNLOCK(bufobj); 2079dd19a799SPoul-Henning Kamp } 2080dd19a799SPoul-Henning Kamp 2081dd19a799SPoul-Henning Kamp 2082dd19a799SPoul-Henning Kamp /* 2083dd19a799SPoul-Henning Kamp * Write, release buffer on completion. (Done by iodone 2084dd19a799SPoul-Henning Kamp * if async). Do not bother writing anything if the buffer 2085dd19a799SPoul-Henning Kamp * is invalid. 2086dd19a799SPoul-Henning Kamp * 2087dd19a799SPoul-Henning Kamp * Note that we set B_CACHE here, indicating that buffer is 2088dd19a799SPoul-Henning Kamp * fully valid and thus cacheable. This is true even of NFS 2089dd19a799SPoul-Henning Kamp * now so we set it generally. This could be set either here 2090dd19a799SPoul-Henning Kamp * or in biodone() since the I/O is synchronous. We put it 2091dd19a799SPoul-Henning Kamp * here. 2092dd19a799SPoul-Henning Kamp */ 2093dd19a799SPoul-Henning Kamp static int 2094dd19a799SPoul-Henning Kamp ffs_bufwrite(struct buf *bp) 2095dd19a799SPoul-Henning Kamp { 2096dd19a799SPoul-Henning Kamp struct buf *newbp; 2097dd19a799SPoul-Henning Kamp 2098dd19a799SPoul-Henning Kamp CTR3(KTR_BUF, "bufwrite(%p) vp %p flags %X", bp, bp->b_vp, bp->b_flags); 2099dd19a799SPoul-Henning Kamp if (bp->b_flags & B_INVAL) { 2100dd19a799SPoul-Henning Kamp brelse(bp); 2101dd19a799SPoul-Henning Kamp return (0); 2102dd19a799SPoul-Henning Kamp } 2103dd19a799SPoul-Henning Kamp 2104d638e093SAttilio Rao if (!BUF_ISLOCKED(bp)) 2105dd19a799SPoul-Henning Kamp panic("bufwrite: buffer is not busy???"); 2106dd19a799SPoul-Henning Kamp /* 2107dd19a799SPoul-Henning Kamp * If a background write is already in progress, delay 2108dd19a799SPoul-Henning Kamp * writing this block if it is asynchronous. Otherwise 2109dd19a799SPoul-Henning Kamp * wait for the background write to complete. 2110dd19a799SPoul-Henning Kamp */ 2111dd19a799SPoul-Henning Kamp BO_LOCK(bp->b_bufobj); 2112dd19a799SPoul-Henning Kamp if (bp->b_vflags & BV_BKGRDINPROG) { 2113dd19a799SPoul-Henning Kamp if (bp->b_flags & B_ASYNC) { 2114dd19a799SPoul-Henning Kamp BO_UNLOCK(bp->b_bufobj); 2115dd19a799SPoul-Henning Kamp bdwrite(bp); 2116dd19a799SPoul-Henning Kamp return (0); 2117dd19a799SPoul-Henning Kamp } 2118dd19a799SPoul-Henning Kamp bp->b_vflags |= BV_BKGRDWAIT; 211922a72260SJeff Roberson msleep(&bp->b_xflags, BO_LOCKPTR(bp->b_bufobj), PRIBIO, 212022a72260SJeff Roberson "bwrbg", 0); 2121dd19a799SPoul-Henning Kamp if (bp->b_vflags & BV_BKGRDINPROG) 2122dd19a799SPoul-Henning Kamp panic("bufwrite: still writing"); 2123dd19a799SPoul-Henning Kamp } 2124b2c3df84SKonstantin Belousov bp->b_vflags &= ~BV_BKGRDERR; 2125dd19a799SPoul-Henning Kamp BO_UNLOCK(bp->b_bufobj); 2126dd19a799SPoul-Henning Kamp 2127dd19a799SPoul-Henning Kamp /* 2128dd19a799SPoul-Henning Kamp * If this buffer is marked for background writing and we 2129dd19a799SPoul-Henning Kamp * do not have to wait for it, make a copy and write the 2130dd19a799SPoul-Henning Kamp * copy so as to leave this buffer ready for further use. 2131dd19a799SPoul-Henning Kamp * 2132dd19a799SPoul-Henning Kamp * This optimization eats a lot of memory. If we have a page 2133dd19a799SPoul-Henning Kamp * or buffer shortfall we can't do it. 2134dd19a799SPoul-Henning Kamp */ 2135dd19a799SPoul-Henning Kamp if (dobkgrdwrite && (bp->b_xflags & BX_BKGRDWRITE) && 2136dd19a799SPoul-Henning Kamp (bp->b_flags & B_ASYNC) && 2137dd19a799SPoul-Henning Kamp !vm_page_count_severe() && 2138dd19a799SPoul-Henning Kamp !buf_dirty_count_severe()) { 2139dd19a799SPoul-Henning Kamp KASSERT(bp->b_iodone == NULL, 2140dd19a799SPoul-Henning Kamp ("bufwrite: needs chained iodone (%p)", bp->b_iodone)); 2141dd19a799SPoul-Henning Kamp 2142dd19a799SPoul-Henning Kamp /* get a new block */ 2143c1d8b5e8SKonstantin Belousov newbp = geteblk(bp->b_bufsize, GB_NOWAIT_BD); 2144c1d8b5e8SKonstantin Belousov if (newbp == NULL) 2145c1d8b5e8SKonstantin Belousov goto normal_write; 2146dd19a799SPoul-Henning Kamp 2147fade8dd7SJeff Roberson KASSERT(buf_mapped(bp), ("Unmapped cg")); 2148dd19a799SPoul-Henning Kamp memcpy(newbp->b_data, bp->b_data, bp->b_bufsize); 2149dd19a799SPoul-Henning Kamp BO_LOCK(bp->b_bufobj); 2150dd19a799SPoul-Henning Kamp bp->b_vflags |= BV_BKGRDINPROG; 2151dd19a799SPoul-Henning Kamp BO_UNLOCK(bp->b_bufobj); 215226089666SJeff Roberson newbp->b_xflags |= BX_BKGRDMARKER; 215326089666SJeff Roberson newbp->b_lblkno = bp->b_lblkno; 2154dd19a799SPoul-Henning Kamp newbp->b_blkno = bp->b_blkno; 2155dd19a799SPoul-Henning Kamp newbp->b_offset = bp->b_offset; 2156dd19a799SPoul-Henning Kamp newbp->b_iodone = ffs_backgroundwritedone; 2157dd19a799SPoul-Henning Kamp newbp->b_flags |= B_ASYNC; 2158dd19a799SPoul-Henning Kamp newbp->b_flags &= ~B_INVAL; 215926089666SJeff Roberson pbgetvp(bp->b_vp, newbp); 2160dd19a799SPoul-Henning Kamp 2161dd19a799SPoul-Henning Kamp #ifdef SOFTUPDATES 2162113db2ddSJeff Roberson /* 2163113db2ddSJeff Roberson * Move over the dependencies. If there are rollbacks, 2164113db2ddSJeff Roberson * leave the parent buffer dirtied as it will need to 2165113db2ddSJeff Roberson * be written again. 2166113db2ddSJeff Roberson */ 2167113db2ddSJeff Roberson if (LIST_EMPTY(&bp->b_dep) || 2168113db2ddSJeff Roberson softdep_move_dependencies(bp, newbp) == 0) 2169113db2ddSJeff Roberson bundirty(bp); 2170113db2ddSJeff Roberson #else 2171113db2ddSJeff Roberson bundirty(bp); 2172dd19a799SPoul-Henning Kamp #endif 2173dd19a799SPoul-Henning Kamp 2174dd19a799SPoul-Henning Kamp /* 217526089666SJeff Roberson * Initiate write on the copy, release the original. The 217626089666SJeff Roberson * BKGRDINPROG flag prevents it from going away until 217726089666SJeff Roberson * the background write completes. 2178dd19a799SPoul-Henning Kamp */ 2179dd19a799SPoul-Henning Kamp bqrelse(bp); 2180dd19a799SPoul-Henning Kamp bp = newbp; 2181113db2ddSJeff Roberson } else 2182113db2ddSJeff Roberson /* Mark the buffer clean */ 2183113db2ddSJeff Roberson bundirty(bp); 2184113db2ddSJeff Roberson 2185dd19a799SPoul-Henning Kamp 2186dd19a799SPoul-Henning Kamp /* Let the normal bufwrite do the rest for us */ 2187c1d8b5e8SKonstantin Belousov normal_write: 21889248a827STor Egge return (bufwrite(bp)); 2189dd19a799SPoul-Henning Kamp } 2190dd19a799SPoul-Henning Kamp 2191dd19a799SPoul-Henning Kamp 21928dd56505SPoul-Henning Kamp static void 21936e77a041SPoul-Henning Kamp ffs_geom_strategy(struct bufobj *bo, struct buf *bp) 21946e77a041SPoul-Henning Kamp { 2195153910e0SJeff Roberson struct vnode *vp; 2196153910e0SJeff Roberson int error; 21977de3839dSTor Egge struct buf *tbp; 2198113db2ddSJeff Roberson int nocopy; 21996e77a041SPoul-Henning Kamp 22008660b707SMateusz Guzik vp = bo2vnode(bo); 2201153910e0SJeff Roberson if (bp->b_iocmd == BIO_WRITE) { 2202153910e0SJeff Roberson if ((bp->b_flags & B_VALIDSUSPWRT) == 0 && 2203153910e0SJeff Roberson bp->b_vp != NULL && bp->b_vp->v_mount != NULL && 2204153910e0SJeff Roberson (bp->b_vp->v_mount->mnt_kern_flag & MNTK_SUSPENDED) != 0) 2205153910e0SJeff Roberson panic("ffs_geom_strategy: bad I/O"); 2206113db2ddSJeff Roberson nocopy = bp->b_flags & B_NOCOPY; 2207113db2ddSJeff Roberson bp->b_flags &= ~(B_VALIDSUSPWRT | B_NOCOPY); 2208113db2ddSJeff Roberson if ((vp->v_vflag & VV_COPYONWRITE) && nocopy == 0 && 22097de3839dSTor Egge vp->v_rdev->si_snapdata != NULL) { 22107de3839dSTor Egge if ((bp->b_flags & B_CLUSTER) != 0) { 2211868bb88fSTor Egge runningbufwakeup(bp); 22127de3839dSTor Egge TAILQ_FOREACH(tbp, &bp->b_cluster.cluster_head, 22137de3839dSTor Egge b_cluster.cluster_entry) { 22147de3839dSTor Egge error = ffs_copyonwrite(vp, tbp); 22157de3839dSTor Egge if (error != 0 && 2216153910e0SJeff Roberson error != EOPNOTSUPP) { 2217153910e0SJeff Roberson bp->b_error = error; 2218153910e0SJeff Roberson bp->b_ioflags |= BIO_ERROR; 2219153910e0SJeff Roberson bufdone(bp); 2220153910e0SJeff Roberson return; 2221153910e0SJeff Roberson } 2222153910e0SJeff Roberson } 2223868bb88fSTor Egge bp->b_runningbufspace = bp->b_bufsize; 22245bd65606SJohn Baldwin atomic_add_long(&runningbufspace, 2225868bb88fSTor Egge bp->b_runningbufspace); 22267de3839dSTor Egge } else { 22277de3839dSTor Egge error = ffs_copyonwrite(vp, bp); 22287de3839dSTor Egge if (error != 0 && error != EOPNOTSUPP) { 22297de3839dSTor Egge bp->b_error = error; 22307de3839dSTor Egge bp->b_ioflags |= BIO_ERROR; 22317de3839dSTor Egge bufdone(bp); 22327de3839dSTor Egge return; 22337de3839dSTor Egge } 22347de3839dSTor Egge } 22357de3839dSTor Egge } 22367de3839dSTor Egge #ifdef SOFTUPDATES 22377de3839dSTor Egge if ((bp->b_flags & B_CLUSTER) != 0) { 22387de3839dSTor Egge TAILQ_FOREACH(tbp, &bp->b_cluster.cluster_head, 22397de3839dSTor Egge b_cluster.cluster_entry) { 224004533fc6SXin LI if (!LIST_EMPTY(&tbp->b_dep)) 22417de3839dSTor Egge buf_start(tbp); 22427de3839dSTor Egge } 22437de3839dSTor Egge } else { 224404533fc6SXin LI if (!LIST_EMPTY(&bp->b_dep)) 22457de3839dSTor Egge buf_start(bp); 22467de3839dSTor Egge } 22477de3839dSTor Egge 22487de3839dSTor Egge #endif 22497de3839dSTor Egge } 225043920011SPoul-Henning Kamp g_vfs_strategy(bo, bp); 22516e77a041SPoul-Henning Kamp } 225252dfc8d7SKonstantin Belousov 22531848286aSEdward Tomasz Napierala int 22541848286aSEdward Tomasz Napierala ffs_own_mount(const struct mount *mp) 22551848286aSEdward Tomasz Napierala { 22561848286aSEdward Tomasz Napierala 22571848286aSEdward Tomasz Napierala if (mp->mnt_op == &ufs_vfsops) 22581848286aSEdward Tomasz Napierala return (1); 22591848286aSEdward Tomasz Napierala return (0); 22601848286aSEdward Tomasz Napierala } 22611848286aSEdward Tomasz Napierala 226252dfc8d7SKonstantin Belousov #ifdef DDB 2263cf058082SBrooks Davis #ifdef SOFTUPDATES 226452dfc8d7SKonstantin Belousov 2265519e3c3bSKirk McKusick /* defined in ffs_softdep.c */ 2266519e3c3bSKirk McKusick extern void db_print_ffs(struct ufsmount *ump); 226752dfc8d7SKonstantin Belousov 226852dfc8d7SKonstantin Belousov DB_SHOW_COMMAND(ffs, db_show_ffs) 226952dfc8d7SKonstantin Belousov { 227052dfc8d7SKonstantin Belousov struct mount *mp; 227152dfc8d7SKonstantin Belousov struct ufsmount *ump; 227252dfc8d7SKonstantin Belousov 227352dfc8d7SKonstantin Belousov if (have_addr) { 227452dfc8d7SKonstantin Belousov ump = VFSTOUFS((struct mount *)addr); 227552dfc8d7SKonstantin Belousov db_print_ffs(ump); 227652dfc8d7SKonstantin Belousov return; 227752dfc8d7SKonstantin Belousov } 227852dfc8d7SKonstantin Belousov 227952dfc8d7SKonstantin Belousov TAILQ_FOREACH(mp, &mountlist, mnt_list) { 228052dfc8d7SKonstantin Belousov if (!strcmp(mp->mnt_stat.f_fstypename, ufs_vfsconf.vfc_name)) 228152dfc8d7SKonstantin Belousov db_print_ffs(VFSTOUFS(mp)); 228252dfc8d7SKonstantin Belousov } 228352dfc8d7SKonstantin Belousov } 228452dfc8d7SKonstantin Belousov 2285cf058082SBrooks Davis #endif /* SOFTUPDATES */ 228652dfc8d7SKonstantin Belousov #endif /* DDB */ 2287