1789Sahrens /* 2789Sahrens * CDDL HEADER START 3789Sahrens * 4789Sahrens * The contents of this file are subject to the terms of the 51484Sek110237 * Common Development and Distribution License (the "License"). 61484Sek110237 * You may not use this file except in compliance with the License. 7789Sahrens * 8789Sahrens * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9789Sahrens * or http://www.opensolaris.org/os/licensing. 10789Sahrens * See the License for the specific language governing permissions 11789Sahrens * and limitations under the License. 12789Sahrens * 13789Sahrens * When distributing Covered Code, include this CDDL HEADER in each 14789Sahrens * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15789Sahrens * If applicable, add the following below this CDDL HEADER, with the 16789Sahrens * fields enclosed by brackets "[]" replaced with your own identifying 17789Sahrens * information: Portions Copyright [yyyy] [name of copyright owner] 18789Sahrens * 19789Sahrens * CDDL HEADER END 20789Sahrens */ 21789Sahrens /* 221298Sperrin * Copyright 2006 Sun Microsystems, Inc. All rights reserved. 23789Sahrens * Use is subject to license terms. 24789Sahrens */ 25789Sahrens 26789Sahrens #pragma ident "%Z%%M% %I% %E% SMI" 27789Sahrens 28789Sahrens #include <sys/types.h> 29789Sahrens #include <sys/param.h> 30789Sahrens #include <sys/systm.h> 31789Sahrens #include <sys/sysmacros.h> 32789Sahrens #include <sys/kmem.h> 33789Sahrens #include <sys/pathname.h> 34789Sahrens #include <sys/acl.h> 35789Sahrens #include <sys/vnode.h> 36789Sahrens #include <sys/vfs.h> 37789Sahrens #include <sys/mntent.h> 38789Sahrens #include <sys/mount.h> 39789Sahrens #include <sys/cmn_err.h> 40789Sahrens #include "fs/fs_subr.h" 41789Sahrens #include <sys/zfs_znode.h> 42789Sahrens #include <sys/zil.h> 43789Sahrens #include <sys/fs/zfs.h> 44789Sahrens #include <sys/dmu.h> 45789Sahrens #include <sys/dsl_prop.h> 46789Sahrens #include <sys/spa.h> 47789Sahrens #include <sys/zap.h> 48789Sahrens #include <sys/varargs.h> 49789Sahrens #include <sys/policy.h> 50789Sahrens #include <sys/atomic.h> 51789Sahrens #include <sys/mkdev.h> 52789Sahrens #include <sys/modctl.h> 53789Sahrens #include <sys/zfs_ioctl.h> 54789Sahrens #include <sys/zfs_ctldir.h> 551544Seschrock #include <sys/bootconf.h> 56849Sbonwick #include <sys/sunddi.h> 571484Sek110237 #include <sys/dnlc.h> 58789Sahrens 59789Sahrens int zfsfstype; 60789Sahrens vfsops_t *zfs_vfsops = NULL; 61849Sbonwick static major_t zfs_major; 62789Sahrens static minor_t zfs_minor; 63789Sahrens static kmutex_t zfs_dev_mtx; 64789Sahrens 651544Seschrock extern char zfs_bootpath[BO_MAXOBJNAME]; 661544Seschrock 67789Sahrens static int zfs_mount(vfs_t *vfsp, vnode_t *mvp, struct mounta *uap, cred_t *cr); 68789Sahrens static int zfs_umount(vfs_t *vfsp, int fflag, cred_t *cr); 691544Seschrock static int zfs_mountroot(vfs_t *vfsp, enum whymountroot); 70789Sahrens static int zfs_root(vfs_t *vfsp, vnode_t **vpp); 71789Sahrens static int zfs_statvfs(vfs_t *vfsp, struct statvfs64 *statp); 72789Sahrens static int zfs_vget(vfs_t *vfsp, vnode_t **vpp, fid_t *fidp); 73789Sahrens static void zfs_freevfs(vfs_t *vfsp); 74789Sahrens static void zfs_objset_close(zfsvfs_t *zfsvfs); 75789Sahrens 76789Sahrens static const fs_operation_def_t zfs_vfsops_template[] = { 77789Sahrens VFSNAME_MOUNT, zfs_mount, 781544Seschrock VFSNAME_MOUNTROOT, zfs_mountroot, 79789Sahrens VFSNAME_UNMOUNT, zfs_umount, 80789Sahrens VFSNAME_ROOT, zfs_root, 81789Sahrens VFSNAME_STATVFS, zfs_statvfs, 82789Sahrens VFSNAME_SYNC, (fs_generic_func_p) zfs_sync, 83789Sahrens VFSNAME_VGET, zfs_vget, 84789Sahrens VFSNAME_FREEVFS, (fs_generic_func_p) zfs_freevfs, 85789Sahrens NULL, NULL 86789Sahrens }; 87789Sahrens 88789Sahrens static const fs_operation_def_t zfs_vfsops_eio_template[] = { 89789Sahrens VFSNAME_FREEVFS, (fs_generic_func_p) zfs_freevfs, 90789Sahrens NULL, NULL 91789Sahrens }; 92789Sahrens 93789Sahrens /* 94789Sahrens * We need to keep a count of active fs's. 95789Sahrens * This is necessary to prevent our module 96789Sahrens * from being unloaded after a umount -f 97789Sahrens */ 98789Sahrens static uint32_t zfs_active_fs_count = 0; 99789Sahrens 100789Sahrens static char *noatime_cancel[] = { MNTOPT_ATIME, NULL }; 101789Sahrens static char *atime_cancel[] = { MNTOPT_NOATIME, NULL }; 102789Sahrens 103789Sahrens static mntopt_t mntopts[] = { 104789Sahrens { MNTOPT_XATTR, NULL, NULL, MO_NODISPLAY|MO_DEFAULT, NULL }, 105789Sahrens { MNTOPT_NOATIME, noatime_cancel, NULL, MO_DEFAULT, NULL }, 106789Sahrens { MNTOPT_ATIME, atime_cancel, NULL, 0, NULL } 107789Sahrens }; 108789Sahrens 109789Sahrens static mntopts_t zfs_mntopts = { 110789Sahrens sizeof (mntopts) / sizeof (mntopt_t), 111789Sahrens mntopts 112789Sahrens }; 113789Sahrens 114789Sahrens /*ARGSUSED*/ 115789Sahrens int 116789Sahrens zfs_sync(vfs_t *vfsp, short flag, cred_t *cr) 117789Sahrens { 118789Sahrens /* 119789Sahrens * Data integrity is job one. We don't want a compromised kernel 120789Sahrens * writing to the storage pool, so we never sync during panic. 121789Sahrens */ 122789Sahrens if (panicstr) 123789Sahrens return (0); 124789Sahrens 125789Sahrens /* 126789Sahrens * SYNC_ATTR is used by fsflush() to force old filesystems like UFS 127789Sahrens * to sync metadata, which they would otherwise cache indefinitely. 128789Sahrens * Semantically, the only requirement is that the sync be initiated. 129789Sahrens * The DMU syncs out txgs frequently, so there's nothing to do. 130789Sahrens */ 131789Sahrens if (flag & SYNC_ATTR) 132789Sahrens return (0); 133789Sahrens 134789Sahrens if (vfsp != NULL) { 135789Sahrens /* 136789Sahrens * Sync a specific filesystem. 137789Sahrens */ 138789Sahrens zfsvfs_t *zfsvfs = vfsp->vfs_data; 139789Sahrens 140789Sahrens ZFS_ENTER(zfsvfs); 141789Sahrens if (zfsvfs->z_log != NULL) 142789Sahrens zil_commit(zfsvfs->z_log, UINT64_MAX, FSYNC); 143789Sahrens else 144789Sahrens txg_wait_synced(dmu_objset_pool(zfsvfs->z_os), 0); 145789Sahrens ZFS_EXIT(zfsvfs); 146789Sahrens } else { 147789Sahrens /* 148789Sahrens * Sync all ZFS filesystems. This is what happens when you 149789Sahrens * run sync(1M). Unlike other filesystems, ZFS honors the 150789Sahrens * request by waiting for all pools to commit all dirty data. 151789Sahrens */ 152789Sahrens spa_sync_allpools(); 153789Sahrens } 154789Sahrens 155789Sahrens return (0); 156789Sahrens } 157789Sahrens 1581544Seschrock static int 1591544Seschrock zfs_create_unique_device(dev_t *dev) 1601544Seschrock { 1611544Seschrock major_t new_major; 1621544Seschrock 1631544Seschrock do { 1641544Seschrock ASSERT3U(zfs_minor, <=, MAXMIN32); 1651544Seschrock minor_t start = zfs_minor; 1661544Seschrock do { 1671544Seschrock mutex_enter(&zfs_dev_mtx); 1681544Seschrock if (zfs_minor >= MAXMIN32) { 1691544Seschrock /* 1701544Seschrock * If we're still using the real major 1711544Seschrock * keep out of /dev/zfs and /dev/zvol minor 1721544Seschrock * number space. If we're using a getudev()'ed 1731544Seschrock * major number, we can use all of its minors. 1741544Seschrock */ 1751544Seschrock if (zfs_major == ddi_name_to_major(ZFS_DRIVER)) 1761544Seschrock zfs_minor = ZFS_MIN_MINOR; 1771544Seschrock else 1781544Seschrock zfs_minor = 0; 1791544Seschrock } else { 1801544Seschrock zfs_minor++; 1811544Seschrock } 1821544Seschrock *dev = makedevice(zfs_major, zfs_minor); 1831544Seschrock mutex_exit(&zfs_dev_mtx); 1841544Seschrock } while (vfs_devismounted(*dev) && zfs_minor != start); 1851544Seschrock if (zfs_minor == start) { 1861544Seschrock /* 1871544Seschrock * We are using all ~262,000 minor numbers for the 1881544Seschrock * current major number. Create a new major number. 1891544Seschrock */ 1901544Seschrock if ((new_major = getudev()) == (major_t)-1) { 1911544Seschrock cmn_err(CE_WARN, 1921544Seschrock "zfs_mount: Can't get unique major " 1931544Seschrock "device number."); 1941544Seschrock return (-1); 1951544Seschrock } 1961544Seschrock mutex_enter(&zfs_dev_mtx); 1971544Seschrock zfs_major = new_major; 1981544Seschrock zfs_minor = 0; 1991544Seschrock 2001544Seschrock mutex_exit(&zfs_dev_mtx); 2011544Seschrock } else { 2021544Seschrock break; 2031544Seschrock } 2041544Seschrock /* CONSTANTCONDITION */ 2051544Seschrock } while (1); 2061544Seschrock 2071544Seschrock return (0); 2081544Seschrock } 2091544Seschrock 210789Sahrens static void 211789Sahrens atime_changed_cb(void *arg, uint64_t newval) 212789Sahrens { 213789Sahrens zfsvfs_t *zfsvfs = arg; 214789Sahrens 215789Sahrens if (newval == TRUE) { 216789Sahrens zfsvfs->z_atime = TRUE; 217789Sahrens vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_NOATIME); 218789Sahrens vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_ATIME, NULL, 0); 219789Sahrens } else { 220789Sahrens zfsvfs->z_atime = FALSE; 221789Sahrens vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_ATIME); 222789Sahrens vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_NOATIME, NULL, 0); 223789Sahrens } 224789Sahrens } 225789Sahrens 226789Sahrens static void 227789Sahrens blksz_changed_cb(void *arg, uint64_t newval) 228789Sahrens { 229789Sahrens zfsvfs_t *zfsvfs = arg; 230789Sahrens 231789Sahrens if (newval < SPA_MINBLOCKSIZE || 232789Sahrens newval > SPA_MAXBLOCKSIZE || !ISP2(newval)) 233789Sahrens newval = SPA_MAXBLOCKSIZE; 234789Sahrens 235789Sahrens zfsvfs->z_max_blksz = newval; 236789Sahrens zfsvfs->z_vfs->vfs_bsize = newval; 237789Sahrens } 238789Sahrens 239789Sahrens static void 240789Sahrens readonly_changed_cb(void *arg, uint64_t newval) 241789Sahrens { 242789Sahrens zfsvfs_t *zfsvfs = arg; 243789Sahrens 244789Sahrens if (newval) { 245789Sahrens /* XXX locking on vfs_flag? */ 246789Sahrens zfsvfs->z_vfs->vfs_flag |= VFS_RDONLY; 247789Sahrens vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_RW); 248789Sahrens vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_RO, NULL, 0); 249789Sahrens (void) zfs_delete_thread_target(zfsvfs, 0); 250789Sahrens } else { 251789Sahrens /* XXX locking on vfs_flag? */ 252789Sahrens zfsvfs->z_vfs->vfs_flag &= ~VFS_RDONLY; 253789Sahrens vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_RO); 254789Sahrens vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_RW, NULL, 0); 255789Sahrens (void) zfs_delete_thread_target(zfsvfs, 1); 256789Sahrens } 257789Sahrens } 258789Sahrens 259789Sahrens static void 260789Sahrens devices_changed_cb(void *arg, uint64_t newval) 261789Sahrens { 262789Sahrens zfsvfs_t *zfsvfs = arg; 263789Sahrens 264789Sahrens if (newval == FALSE) { 265789Sahrens zfsvfs->z_vfs->vfs_flag |= VFS_NODEVICES; 266789Sahrens vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_DEVICES); 267789Sahrens vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_NODEVICES, NULL, 0); 268789Sahrens } else { 269789Sahrens zfsvfs->z_vfs->vfs_flag &= ~VFS_NODEVICES; 270789Sahrens vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_NODEVICES); 271789Sahrens vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_DEVICES, NULL, 0); 272789Sahrens } 273789Sahrens } 274789Sahrens 275789Sahrens static void 276789Sahrens setuid_changed_cb(void *arg, uint64_t newval) 277789Sahrens { 278789Sahrens zfsvfs_t *zfsvfs = arg; 279789Sahrens 280789Sahrens if (newval == FALSE) { 281789Sahrens zfsvfs->z_vfs->vfs_flag |= VFS_NOSETUID; 282789Sahrens vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_SETUID); 283789Sahrens vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_NOSETUID, NULL, 0); 284789Sahrens } else { 285789Sahrens zfsvfs->z_vfs->vfs_flag &= ~VFS_NOSETUID; 286789Sahrens vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_NOSETUID); 287789Sahrens vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_SETUID, NULL, 0); 288789Sahrens } 289789Sahrens } 290789Sahrens 291789Sahrens static void 292789Sahrens exec_changed_cb(void *arg, uint64_t newval) 293789Sahrens { 294789Sahrens zfsvfs_t *zfsvfs = arg; 295789Sahrens 296789Sahrens if (newval == FALSE) { 297789Sahrens zfsvfs->z_vfs->vfs_flag |= VFS_NOEXEC; 298789Sahrens vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_EXEC); 299789Sahrens vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_NOEXEC, NULL, 0); 300789Sahrens } else { 301789Sahrens zfsvfs->z_vfs->vfs_flag &= ~VFS_NOEXEC; 302789Sahrens vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_NOEXEC); 303789Sahrens vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_EXEC, NULL, 0); 304789Sahrens } 305789Sahrens } 306789Sahrens 307789Sahrens static void 308789Sahrens snapdir_changed_cb(void *arg, uint64_t newval) 309789Sahrens { 310789Sahrens zfsvfs_t *zfsvfs = arg; 311789Sahrens 312789Sahrens zfsvfs->z_show_ctldir = newval; 313789Sahrens } 314789Sahrens 315789Sahrens static void 316789Sahrens acl_mode_changed_cb(void *arg, uint64_t newval) 317789Sahrens { 318789Sahrens zfsvfs_t *zfsvfs = arg; 319789Sahrens 320789Sahrens zfsvfs->z_acl_mode = newval; 321789Sahrens } 322789Sahrens 323789Sahrens static void 324789Sahrens acl_inherit_changed_cb(void *arg, uint64_t newval) 325789Sahrens { 326789Sahrens zfsvfs_t *zfsvfs = arg; 327789Sahrens 328789Sahrens zfsvfs->z_acl_inherit = newval; 329789Sahrens } 330789Sahrens 3311544Seschrock static int 3321544Seschrock zfs_refresh_properties(vfs_t *vfsp) 3331544Seschrock { 3341544Seschrock zfsvfs_t *zfsvfs = vfsp->vfs_data; 3351544Seschrock 3361544Seschrock if (vfs_optionisset(vfsp, MNTOPT_RO, NULL)) { 3371544Seschrock readonly_changed_cb(zfsvfs, B_TRUE); 3381544Seschrock } else if (vfs_optionisset(vfsp, MNTOPT_RW, NULL)) { 3391544Seschrock if (dmu_objset_is_snapshot(zfsvfs->z_os)) 3401544Seschrock return (EROFS); 3411544Seschrock readonly_changed_cb(zfsvfs, B_FALSE); 3421544Seschrock } 3431544Seschrock 3441544Seschrock if (vfs_optionisset(vfsp, MNTOPT_NOSUID, NULL)) { 3451544Seschrock devices_changed_cb(zfsvfs, B_FALSE); 3461544Seschrock setuid_changed_cb(zfsvfs, B_FALSE); 3471544Seschrock } else { 3481544Seschrock if (vfs_optionisset(vfsp, MNTOPT_NODEVICES, NULL)) 3491544Seschrock devices_changed_cb(zfsvfs, B_FALSE); 3501544Seschrock else if (vfs_optionisset(vfsp, MNTOPT_DEVICES, NULL)) 3511544Seschrock devices_changed_cb(zfsvfs, B_TRUE); 3521544Seschrock 3531544Seschrock if (vfs_optionisset(vfsp, MNTOPT_NOSETUID, NULL)) 3541544Seschrock setuid_changed_cb(zfsvfs, B_FALSE); 3551544Seschrock else if (vfs_optionisset(vfsp, MNTOPT_SETUID, NULL)) 3561544Seschrock setuid_changed_cb(zfsvfs, B_TRUE); 3571544Seschrock } 3581544Seschrock 3591544Seschrock if (vfs_optionisset(vfsp, MNTOPT_NOEXEC, NULL)) 3601544Seschrock exec_changed_cb(zfsvfs, B_FALSE); 3611544Seschrock else if (vfs_optionisset(vfsp, MNTOPT_EXEC, NULL)) 3621544Seschrock exec_changed_cb(zfsvfs, B_TRUE); 3631544Seschrock 3641544Seschrock return (0); 3651544Seschrock } 3661544Seschrock 3671544Seschrock static int 3681544Seschrock zfs_register_callbacks(vfs_t *vfsp) 3691544Seschrock { 3701544Seschrock struct dsl_dataset *ds = NULL; 3711544Seschrock objset_t *os = NULL; 3721544Seschrock zfsvfs_t *zfsvfs = NULL; 3731544Seschrock int do_readonly = FALSE, readonly; 3741544Seschrock int do_setuid = FALSE, setuid; 3751544Seschrock int do_exec = FALSE, exec; 3761544Seschrock int do_devices = FALSE, devices; 3771544Seschrock int error = 0; 3781544Seschrock 3791544Seschrock ASSERT(vfsp); 3801544Seschrock zfsvfs = vfsp->vfs_data; 3811544Seschrock ASSERT(zfsvfs); 3821544Seschrock os = zfsvfs->z_os; 3831544Seschrock 3841544Seschrock /* 3851544Seschrock * The act of registering our callbacks will destroy any mount 3861544Seschrock * options we may have. In order to enable temporary overrides 3871544Seschrock * of mount options, we stash away the current values and restore 3881544Seschrock * restore them after we register the callbacks. 3891544Seschrock */ 3901544Seschrock if (vfs_optionisset(vfsp, MNTOPT_RO, NULL)) { 3911544Seschrock readonly = B_TRUE; 3921544Seschrock do_readonly = B_TRUE; 3931544Seschrock } else if (vfs_optionisset(vfsp, MNTOPT_RW, NULL)) { 3941544Seschrock readonly = B_FALSE; 3951544Seschrock do_readonly = B_TRUE; 3961544Seschrock } 3971544Seschrock if (vfs_optionisset(vfsp, MNTOPT_NOSUID, NULL)) { 3981544Seschrock devices = B_FALSE; 3991544Seschrock setuid = B_FALSE; 4001544Seschrock do_devices = B_TRUE; 4011544Seschrock do_setuid = B_TRUE; 4021544Seschrock } else { 4031544Seschrock if (vfs_optionisset(vfsp, MNTOPT_NODEVICES, NULL)) { 4041544Seschrock devices = B_FALSE; 4051544Seschrock do_devices = B_TRUE; 4061544Seschrock } else if (vfs_optionisset(vfsp, 4071544Seschrock MNTOPT_DEVICES, NULL)) { 4081544Seschrock devices = B_TRUE; 4091544Seschrock do_devices = B_TRUE; 4101544Seschrock } 4111544Seschrock 4121544Seschrock if (vfs_optionisset(vfsp, MNTOPT_NOSETUID, NULL)) { 4131544Seschrock setuid = B_FALSE; 4141544Seschrock do_setuid = B_TRUE; 4151544Seschrock } else if (vfs_optionisset(vfsp, MNTOPT_SETUID, NULL)) { 4161544Seschrock setuid = B_TRUE; 4171544Seschrock do_setuid = B_TRUE; 4181544Seschrock } 4191544Seschrock } 4201544Seschrock if (vfs_optionisset(vfsp, MNTOPT_NOEXEC, NULL)) { 4211544Seschrock exec = B_FALSE; 4221544Seschrock do_exec = B_TRUE; 4231544Seschrock } else if (vfs_optionisset(vfsp, MNTOPT_EXEC, NULL)) { 4241544Seschrock exec = B_TRUE; 4251544Seschrock do_exec = B_TRUE; 4261544Seschrock } 4271544Seschrock 4281544Seschrock /* 4291544Seschrock * Register property callbacks. 4301544Seschrock * 4311544Seschrock * It would probably be fine to just check for i/o error from 4321544Seschrock * the first prop_register(), but I guess I like to go 4331544Seschrock * overboard... 4341544Seschrock */ 4351544Seschrock ds = dmu_objset_ds(os); 4361544Seschrock error = dsl_prop_register(ds, "atime", atime_changed_cb, zfsvfs); 4371544Seschrock error = error ? error : dsl_prop_register(ds, 4381544Seschrock "recordsize", blksz_changed_cb, zfsvfs); 4391544Seschrock error = error ? error : dsl_prop_register(ds, 4401544Seschrock "readonly", readonly_changed_cb, zfsvfs); 4411544Seschrock error = error ? error : dsl_prop_register(ds, 4421544Seschrock "devices", devices_changed_cb, zfsvfs); 4431544Seschrock error = error ? error : dsl_prop_register(ds, 4441544Seschrock "setuid", setuid_changed_cb, zfsvfs); 4451544Seschrock error = error ? error : dsl_prop_register(ds, 4461544Seschrock "exec", exec_changed_cb, zfsvfs); 4471544Seschrock error = error ? error : dsl_prop_register(ds, 4481544Seschrock "snapdir", snapdir_changed_cb, zfsvfs); 4491544Seschrock error = error ? error : dsl_prop_register(ds, 4501544Seschrock "aclmode", acl_mode_changed_cb, zfsvfs); 4511544Seschrock error = error ? error : dsl_prop_register(ds, 4521544Seschrock "aclinherit", acl_inherit_changed_cb, zfsvfs); 4531544Seschrock if (error) 4541544Seschrock goto unregister; 4551544Seschrock 4561544Seschrock /* 4571544Seschrock * Invoke our callbacks to restore temporary mount options. 4581544Seschrock */ 4591544Seschrock if (do_readonly) 4601544Seschrock readonly_changed_cb(zfsvfs, readonly); 4611544Seschrock if (do_setuid) 4621544Seschrock setuid_changed_cb(zfsvfs, setuid); 4631544Seschrock if (do_exec) 4641544Seschrock exec_changed_cb(zfsvfs, exec); 4651544Seschrock if (do_devices) 4661544Seschrock devices_changed_cb(zfsvfs, devices); 4671544Seschrock 4681544Seschrock return (0); 4691544Seschrock 4701544Seschrock unregister: 4711544Seschrock /* 4721544Seschrock * We may attempt to unregister some callbacks that are not 4731544Seschrock * registered, but this is OK; it will simply return ENOMSG, 4741544Seschrock * which we will ignore. 4751544Seschrock */ 4761544Seschrock (void) dsl_prop_unregister(ds, "atime", atime_changed_cb, zfsvfs); 4771544Seschrock (void) dsl_prop_unregister(ds, "recordsize", blksz_changed_cb, zfsvfs); 4781544Seschrock (void) dsl_prop_unregister(ds, "readonly", readonly_changed_cb, zfsvfs); 4791544Seschrock (void) dsl_prop_unregister(ds, "devices", devices_changed_cb, zfsvfs); 4801544Seschrock (void) dsl_prop_unregister(ds, "setuid", setuid_changed_cb, zfsvfs); 4811544Seschrock (void) dsl_prop_unregister(ds, "exec", exec_changed_cb, zfsvfs); 4821544Seschrock (void) dsl_prop_unregister(ds, "snapdir", snapdir_changed_cb, zfsvfs); 4831544Seschrock (void) dsl_prop_unregister(ds, "aclmode", acl_mode_changed_cb, zfsvfs); 4841544Seschrock (void) dsl_prop_unregister(ds, "aclinherit", acl_inherit_changed_cb, 4851544Seschrock zfsvfs); 4861544Seschrock return (error); 4871544Seschrock 4881544Seschrock } 4891544Seschrock 4901544Seschrock static int 4911544Seschrock zfs_domount(vfs_t *vfsp, char *osname, cred_t *cr) 4921544Seschrock { 4931544Seschrock dev_t mount_dev; 4941544Seschrock uint64_t recordsize, readonly; 4951544Seschrock int error = 0; 4961544Seschrock int mode; 4971544Seschrock zfsvfs_t *zfsvfs; 4981544Seschrock znode_t *zp = NULL; 4991544Seschrock 5001544Seschrock ASSERT(vfsp); 5011544Seschrock ASSERT(osname); 5021544Seschrock 5031544Seschrock /* 5041544Seschrock * Initialize the zfs-specific filesystem structure. 5051544Seschrock * Should probably make this a kmem cache, shuffle fields, 5061544Seschrock * and just bzero up to z_hold_mtx[]. 5071544Seschrock */ 5081544Seschrock zfsvfs = kmem_zalloc(sizeof (zfsvfs_t), KM_SLEEP); 5091544Seschrock zfsvfs->z_vfs = vfsp; 5101544Seschrock zfsvfs->z_parent = zfsvfs; 5111544Seschrock zfsvfs->z_assign = TXG_NOWAIT; 5121544Seschrock zfsvfs->z_max_blksz = SPA_MAXBLOCKSIZE; 5131544Seschrock zfsvfs->z_show_ctldir = ZFS_SNAPDIR_VISIBLE; 5141544Seschrock 5151544Seschrock mutex_init(&zfsvfs->z_znodes_lock, NULL, MUTEX_DEFAULT, NULL); 5161544Seschrock list_create(&zfsvfs->z_all_znodes, sizeof (znode_t), 5171544Seschrock offsetof(znode_t, z_link_node)); 5181544Seschrock rw_init(&zfsvfs->z_um_lock, NULL, RW_DEFAULT, NULL); 5191544Seschrock 5201544Seschrock /* Initialize the generic filesystem structure. */ 5211544Seschrock vfsp->vfs_bcount = 0; 5221544Seschrock vfsp->vfs_data = NULL; 5231544Seschrock 5241544Seschrock if (zfs_create_unique_device(&mount_dev) == -1) { 5251544Seschrock error = ENODEV; 5261544Seschrock goto out; 5271544Seschrock } 5281544Seschrock ASSERT(vfs_devismounted(mount_dev) == 0); 5291544Seschrock 5301544Seschrock if (error = dsl_prop_get_integer(osname, "recordsize", &recordsize, 5311544Seschrock NULL)) 5321544Seschrock goto out; 5331544Seschrock 5341544Seschrock vfsp->vfs_dev = mount_dev; 5351544Seschrock vfsp->vfs_fstype = zfsfstype; 5361544Seschrock vfsp->vfs_bsize = recordsize; 5371544Seschrock vfsp->vfs_flag |= VFS_NOTRUNC; 5381544Seschrock vfsp->vfs_data = zfsvfs; 5391544Seschrock 5401544Seschrock if (error = dsl_prop_get_integer(osname, "readonly", &readonly, NULL)) 5411544Seschrock goto out; 5421544Seschrock 5431544Seschrock if (readonly) 5441544Seschrock mode = DS_MODE_PRIMARY | DS_MODE_READONLY; 5451544Seschrock else 5461544Seschrock mode = DS_MODE_PRIMARY; 5471544Seschrock 5481544Seschrock error = dmu_objset_open(osname, DMU_OST_ZFS, mode, &zfsvfs->z_os); 5491544Seschrock if (error == EROFS) { 5501544Seschrock mode = DS_MODE_PRIMARY | DS_MODE_READONLY; 5511544Seschrock error = dmu_objset_open(osname, DMU_OST_ZFS, mode, 5521544Seschrock &zfsvfs->z_os); 5531544Seschrock } 5541544Seschrock 5551544Seschrock if (error) 5561544Seschrock goto out; 5571544Seschrock 5581544Seschrock if (error = zfs_init_fs(zfsvfs, &zp, cr)) 5591544Seschrock goto out; 5601544Seschrock 5611544Seschrock /* The call to zfs_init_fs leaves the vnode held, release it here. */ 5621544Seschrock VN_RELE(ZTOV(zp)); 5631544Seschrock 5641544Seschrock if (dmu_objset_is_snapshot(zfsvfs->z_os)) { 5651544Seschrock ASSERT(mode & DS_MODE_READONLY); 5661544Seschrock atime_changed_cb(zfsvfs, B_FALSE); 5671544Seschrock readonly_changed_cb(zfsvfs, B_TRUE); 5681544Seschrock zfsvfs->z_issnap = B_TRUE; 5691544Seschrock } else { 5701544Seschrock error = zfs_register_callbacks(vfsp); 5711544Seschrock if (error) 5721544Seschrock goto out; 5731544Seschrock 5741544Seschrock /* 5751544Seschrock * Start a delete thread running. 5761544Seschrock */ 5771544Seschrock (void) zfs_delete_thread_target(zfsvfs, 1); 5781544Seschrock 5791544Seschrock /* 5801544Seschrock * Parse and replay the intent log. 5811544Seschrock */ 5821544Seschrock zil_replay(zfsvfs->z_os, zfsvfs, &zfsvfs->z_assign, 5831544Seschrock zfs_replay_vector, (void (*)(void *))zfs_delete_wait_empty); 5841544Seschrock 5851544Seschrock if (!zil_disable) 5861544Seschrock zfsvfs->z_log = zil_open(zfsvfs->z_os, zfs_get_data); 5871544Seschrock } 5881544Seschrock 5891544Seschrock if (!zfsvfs->z_issnap) 5901544Seschrock zfsctl_create(zfsvfs); 5911544Seschrock out: 5921544Seschrock if (error) { 5931544Seschrock if (zfsvfs->z_os) 5941544Seschrock dmu_objset_close(zfsvfs->z_os); 5951544Seschrock kmem_free(zfsvfs, sizeof (zfsvfs_t)); 5961544Seschrock } else { 5971544Seschrock atomic_add_32(&zfs_active_fs_count, 1); 5981544Seschrock } 5991544Seschrock 6001544Seschrock return (error); 6011544Seschrock 6021544Seschrock } 6031544Seschrock 6041544Seschrock void 6051544Seschrock zfs_unregister_callbacks(zfsvfs_t *zfsvfs) 6061544Seschrock { 6071544Seschrock objset_t *os = zfsvfs->z_os; 6081544Seschrock struct dsl_dataset *ds; 6091544Seschrock 6101544Seschrock /* 6111544Seschrock * Unregister properties. 6121544Seschrock */ 6131544Seschrock if (!dmu_objset_is_snapshot(os)) { 6141544Seschrock ds = dmu_objset_ds(os); 6151544Seschrock VERIFY(dsl_prop_unregister(ds, "atime", atime_changed_cb, 6161544Seschrock zfsvfs) == 0); 6171544Seschrock 6181544Seschrock VERIFY(dsl_prop_unregister(ds, "recordsize", blksz_changed_cb, 6191544Seschrock zfsvfs) == 0); 6201544Seschrock 6211544Seschrock VERIFY(dsl_prop_unregister(ds, "readonly", readonly_changed_cb, 6221544Seschrock zfsvfs) == 0); 6231544Seschrock 6241544Seschrock VERIFY(dsl_prop_unregister(ds, "devices", devices_changed_cb, 6251544Seschrock zfsvfs) == 0); 6261544Seschrock 6271544Seschrock VERIFY(dsl_prop_unregister(ds, "setuid", setuid_changed_cb, 6281544Seschrock zfsvfs) == 0); 6291544Seschrock 6301544Seschrock VERIFY(dsl_prop_unregister(ds, "exec", exec_changed_cb, 6311544Seschrock zfsvfs) == 0); 6321544Seschrock 6331544Seschrock VERIFY(dsl_prop_unregister(ds, "snapdir", snapdir_changed_cb, 6341544Seschrock zfsvfs) == 0); 6351544Seschrock 6361544Seschrock VERIFY(dsl_prop_unregister(ds, "aclmode", acl_mode_changed_cb, 6371544Seschrock zfsvfs) == 0); 6381544Seschrock 6391544Seschrock VERIFY(dsl_prop_unregister(ds, "aclinherit", 6401544Seschrock acl_inherit_changed_cb, zfsvfs) == 0); 6411544Seschrock } 6421544Seschrock } 6431544Seschrock 6441544Seschrock static int 6451544Seschrock zfs_mountroot(vfs_t *vfsp, enum whymountroot why) 6461544Seschrock { 6471544Seschrock int error = 0; 6481544Seschrock int ret = 0; 6491544Seschrock static int zfsrootdone = 0; 6501544Seschrock zfsvfs_t *zfsvfs = NULL; 6511544Seschrock znode_t *zp = NULL; 6521544Seschrock vnode_t *vp = NULL; 6531544Seschrock 6541544Seschrock ASSERT(vfsp); 6551544Seschrock 6561544Seschrock /* 6571544Seschrock * The filesystem that we mount as root is defined in 6581544Seschrock * /etc/system using the zfsroot variable. The value defined 6591544Seschrock * there is copied early in startup code to zfs_bootpath 6601544Seschrock * (defined in modsysfile.c). 6611544Seschrock */ 6621544Seschrock if (why == ROOT_INIT) { 6631544Seschrock if (zfsrootdone++) 6641544Seschrock return (EBUSY); 6651544Seschrock 6661544Seschrock /* 6671544Seschrock * This needs to be done here, so that when we return from 6681544Seschrock * mountroot, the vfs resource name will be set correctly. 6691544Seschrock */ 6701544Seschrock if (snprintf(rootfs.bo_name, BO_MAXOBJNAME, "%s", zfs_bootpath) 6711544Seschrock >= BO_MAXOBJNAME) 6721544Seschrock return (ENAMETOOLONG); 6731544Seschrock 6741544Seschrock if (error = vfs_lock(vfsp)) 6751544Seschrock return (error); 6761544Seschrock 6771544Seschrock if (error = zfs_domount(vfsp, zfs_bootpath, CRED())) 6781544Seschrock goto out; 6791544Seschrock 6801544Seschrock zfsvfs = (zfsvfs_t *)vfsp->vfs_data; 6811544Seschrock ASSERT(zfsvfs); 6821544Seschrock if (error = zfs_zget(zfsvfs, zfsvfs->z_root, &zp)) 6831544Seschrock goto out; 6841544Seschrock 6851544Seschrock vp = ZTOV(zp); 6861544Seschrock mutex_enter(&vp->v_lock); 6871544Seschrock vp->v_flag |= VROOT; 6881544Seschrock mutex_exit(&vp->v_lock); 6891544Seschrock rootvp = vp; 6901544Seschrock 6911544Seschrock /* 6921544Seschrock * The zfs_zget call above returns with a hold on vp, we release 6931544Seschrock * it here. 6941544Seschrock */ 6951544Seschrock VN_RELE(vp); 6961544Seschrock 6971544Seschrock /* 6981544Seschrock * Mount root as readonly initially, it will be remouted 6991544Seschrock * read/write by /lib/svc/method/fs-usr. 7001544Seschrock */ 7011544Seschrock readonly_changed_cb(vfsp->vfs_data, B_TRUE); 7021544Seschrock vfs_add((struct vnode *)0, vfsp, 7031544Seschrock (vfsp->vfs_flag & VFS_RDONLY) ? MS_RDONLY : 0); 7041544Seschrock out: 7051544Seschrock vfs_unlock(vfsp); 7061544Seschrock ret = (error) ? error : 0; 7071544Seschrock return (ret); 7081544Seschrock 7091544Seschrock } else if (why == ROOT_REMOUNT) { 7101544Seschrock 7111544Seschrock readonly_changed_cb(vfsp->vfs_data, B_FALSE); 7121544Seschrock vfsp->vfs_flag |= VFS_REMOUNT; 7131544Seschrock return (zfs_refresh_properties(vfsp)); 7141544Seschrock 7151544Seschrock } else if (why == ROOT_UNMOUNT) { 7161544Seschrock zfs_unregister_callbacks((zfsvfs_t *)vfsp->vfs_data); 7171544Seschrock (void) zfs_sync(vfsp, 0, 0); 7181544Seschrock return (0); 7191544Seschrock } 7201544Seschrock 7211544Seschrock /* 7221544Seschrock * if "why" is equal to anything else other than ROOT_INIT, 7231544Seschrock * ROOT_REMOUNT, or ROOT_UNMOUNT, we do not support it. 7241544Seschrock */ 7251544Seschrock return (ENOTSUP); 7261544Seschrock } 7271544Seschrock 728789Sahrens /*ARGSUSED*/ 729789Sahrens static int 730789Sahrens zfs_mount(vfs_t *vfsp, vnode_t *mvp, struct mounta *uap, cred_t *cr) 731789Sahrens { 732789Sahrens char *osname; 733789Sahrens pathname_t spn; 734789Sahrens int error = 0; 735789Sahrens uio_seg_t fromspace = (uap->flags & MS_SYSSPACE) ? 736789Sahrens UIO_SYSSPACE : UIO_USERSPACE; 737789Sahrens int canwrite; 738789Sahrens 739789Sahrens if (mvp->v_type != VDIR) 740789Sahrens return (ENOTDIR); 741789Sahrens 742789Sahrens mutex_enter(&mvp->v_lock); 743789Sahrens if ((uap->flags & MS_REMOUNT) == 0 && 744789Sahrens (uap->flags & MS_OVERLAY) == 0 && 745789Sahrens (mvp->v_count != 1 || (mvp->v_flag & VROOT))) { 746789Sahrens mutex_exit(&mvp->v_lock); 747789Sahrens return (EBUSY); 748789Sahrens } 749789Sahrens mutex_exit(&mvp->v_lock); 750789Sahrens 751789Sahrens /* 752789Sahrens * ZFS does not support passing unparsed data in via MS_DATA. 753789Sahrens * Users should use the MS_OPTIONSTR interface; this means 754789Sahrens * that all option parsing is already done and the options struct 755789Sahrens * can be interrogated. 756789Sahrens */ 757789Sahrens if ((uap->flags & MS_DATA) && uap->datalen > 0) 758789Sahrens return (EINVAL); 759789Sahrens 760789Sahrens /* 761789Sahrens * When doing a remount, we simply refresh our temporary properties 762789Sahrens * according to those options set in the current VFS options. 763789Sahrens */ 764789Sahrens if (uap->flags & MS_REMOUNT) { 7651544Seschrock return (zfs_refresh_properties(vfsp)); 766789Sahrens } 767789Sahrens 768789Sahrens /* 769789Sahrens * Get the objset name (the "special" mount argument). 770789Sahrens */ 771789Sahrens if (error = pn_get(uap->spec, fromspace, &spn)) 772789Sahrens return (error); 773789Sahrens 774789Sahrens osname = spn.pn_path; 775789Sahrens 776789Sahrens if ((error = secpolicy_fs_mount(cr, mvp, vfsp)) != 0) 777789Sahrens goto out; 778789Sahrens 779789Sahrens /* 780789Sahrens * Refuse to mount a filesystem if we are in a local zone and the 781789Sahrens * dataset is not visible. 782789Sahrens */ 783789Sahrens if (!INGLOBALZONE(curproc) && 784789Sahrens (!zone_dataset_visible(osname, &canwrite) || !canwrite)) { 785789Sahrens error = EPERM; 786789Sahrens goto out; 787789Sahrens } 788789Sahrens 7891544Seschrock error = zfs_domount(vfsp, osname, cr); 790789Sahrens 791789Sahrens out: 792789Sahrens pn_free(&spn); 793789Sahrens return (error); 794789Sahrens } 795789Sahrens 796789Sahrens static int 797789Sahrens zfs_statvfs(vfs_t *vfsp, struct statvfs64 *statp) 798789Sahrens { 799789Sahrens zfsvfs_t *zfsvfs = vfsp->vfs_data; 800789Sahrens dmu_objset_stats_t dstats; 801789Sahrens dev32_t d32; 802789Sahrens 803789Sahrens ZFS_ENTER(zfsvfs); 804789Sahrens 805789Sahrens dmu_objset_stats(zfsvfs->z_os, &dstats); 806789Sahrens 807789Sahrens /* 808789Sahrens * The underlying storage pool actually uses multiple block sizes. 809789Sahrens * We report the fragsize as the smallest block size we support, 810789Sahrens * and we report our blocksize as the filesystem's maximum blocksize. 811789Sahrens */ 812789Sahrens statp->f_frsize = 1UL << SPA_MINBLOCKSHIFT; 813789Sahrens statp->f_bsize = zfsvfs->z_max_blksz; 814789Sahrens 815789Sahrens /* 816789Sahrens * The following report "total" blocks of various kinds in the 817789Sahrens * file system, but reported in terms of f_frsize - the 818789Sahrens * "fragment" size. 819789Sahrens */ 820789Sahrens 821789Sahrens statp->f_blocks = 822789Sahrens (dstats.dds_space_refd + dstats.dds_available) >> SPA_MINBLOCKSHIFT; 823789Sahrens statp->f_bfree = dstats.dds_available >> SPA_MINBLOCKSHIFT; 824789Sahrens statp->f_bavail = statp->f_bfree; /* no root reservation */ 825789Sahrens 826789Sahrens /* 827789Sahrens * statvfs() should really be called statufs(), because it assumes 828789Sahrens * static metadata. ZFS doesn't preallocate files, so the best 829789Sahrens * we can do is report the max that could possibly fit in f_files, 830789Sahrens * and that minus the number actually used in f_ffree. 831789Sahrens * For f_ffree, report the smaller of the number of object available 832789Sahrens * and the number of blocks (each object will take at least a block). 833789Sahrens */ 834789Sahrens statp->f_ffree = MIN(dstats.dds_objects_avail, statp->f_bfree); 835789Sahrens statp->f_favail = statp->f_ffree; /* no "root reservation" */ 836789Sahrens statp->f_files = statp->f_ffree + dstats.dds_objects_used; 837789Sahrens 838789Sahrens (void) cmpldev(&d32, vfsp->vfs_dev); 839789Sahrens statp->f_fsid = d32; 840789Sahrens 841789Sahrens /* 842789Sahrens * We're a zfs filesystem. 843789Sahrens */ 844789Sahrens (void) strcpy(statp->f_basetype, vfssw[vfsp->vfs_fstype].vsw_name); 845789Sahrens 8461123Smarks statp->f_flag = vf_to_stf(vfsp->vfs_flag); 847789Sahrens 848789Sahrens statp->f_namemax = ZFS_MAXNAMELEN; 849789Sahrens 850789Sahrens /* 851789Sahrens * We have all of 32 characters to stuff a string here. 852789Sahrens * Is there anything useful we could/should provide? 853789Sahrens */ 854789Sahrens bzero(statp->f_fstr, sizeof (statp->f_fstr)); 855789Sahrens 856789Sahrens ZFS_EXIT(zfsvfs); 857789Sahrens return (0); 858789Sahrens } 859789Sahrens 860789Sahrens static int 861789Sahrens zfs_root(vfs_t *vfsp, vnode_t **vpp) 862789Sahrens { 863789Sahrens zfsvfs_t *zfsvfs = vfsp->vfs_data; 864789Sahrens znode_t *rootzp; 865789Sahrens int error; 866789Sahrens 867789Sahrens ZFS_ENTER(zfsvfs); 868789Sahrens 869789Sahrens error = zfs_zget(zfsvfs, zfsvfs->z_root, &rootzp); 870789Sahrens if (error == 0) 871789Sahrens *vpp = ZTOV(rootzp); 872789Sahrens 873789Sahrens ZFS_EXIT(zfsvfs); 874789Sahrens return (error); 875789Sahrens } 876789Sahrens 877789Sahrens /*ARGSUSED*/ 878789Sahrens static int 879789Sahrens zfs_umount(vfs_t *vfsp, int fflag, cred_t *cr) 880789Sahrens { 881789Sahrens zfsvfs_t *zfsvfs = vfsp->vfs_data; 882789Sahrens int ret; 883789Sahrens 884789Sahrens if ((ret = secpolicy_fs_unmount(cr, vfsp)) != 0) 885789Sahrens return (ret); 886789Sahrens 8871484Sek110237 8881484Sek110237 (void) dnlc_purge_vfsp(vfsp, 0); 8891484Sek110237 890789Sahrens /* 891789Sahrens * Unmount any snapshots mounted under .zfs before unmounting the 892789Sahrens * dataset itself. 893789Sahrens */ 894789Sahrens if (zfsvfs->z_ctldir != NULL && 895789Sahrens (ret = zfsctl_umount_snapshots(vfsp, fflag, cr)) != 0) 896789Sahrens return (ret); 897789Sahrens 898789Sahrens if (fflag & MS_FORCE) { 899789Sahrens vfsp->vfs_flag |= VFS_UNMOUNTED; 900789Sahrens zfsvfs->z_unmounted1 = B_TRUE; 901789Sahrens 902789Sahrens /* 903789Sahrens * Wait for all zfs threads to leave zfs. 904789Sahrens * Grabbing a rwlock as reader in all vops and 905789Sahrens * as writer here doesn't work because it too easy to get 906789Sahrens * multiple reader enters as zfs can re-enter itself. 907789Sahrens * This can lead to deadlock if there is an intervening 908789Sahrens * rw_enter as writer. 909789Sahrens * So a file system threads ref count (z_op_cnt) is used. 910789Sahrens * A polling loop on z_op_cnt may seem inefficient, but 911789Sahrens * - this saves all threads on exit from having to grab a 912789Sahrens * mutex in order to cv_signal 913789Sahrens * - only occurs on forced unmount in the rare case when 914789Sahrens * there are outstanding threads within the file system. 915789Sahrens */ 916789Sahrens while (zfsvfs->z_op_cnt) { 917789Sahrens delay(1); 918789Sahrens } 919789Sahrens 920789Sahrens zfs_objset_close(zfsvfs); 921789Sahrens 922789Sahrens return (0); 923789Sahrens } 924789Sahrens /* 925789Sahrens * Stop all delete threads. 926789Sahrens */ 927789Sahrens (void) zfs_delete_thread_target(zfsvfs, 0); 928789Sahrens 929789Sahrens /* 930789Sahrens * Check the number of active vnodes in the file system. 931789Sahrens * Our count is maintained in the vfs structure, but the number 932789Sahrens * is off by 1 to indicate a hold on the vfs structure itself. 933789Sahrens * 934789Sahrens * The '.zfs' directory maintains a reference of its own, and any active 935789Sahrens * references underneath are reflected in the vnode count. 936789Sahrens */ 937789Sahrens if (zfsvfs->z_ctldir == NULL) { 938789Sahrens if (vfsp->vfs_count > 1) { 939789Sahrens if ((zfsvfs->z_vfs->vfs_flag & VFS_RDONLY) == 0) 940789Sahrens (void) zfs_delete_thread_target(zfsvfs, 1); 941789Sahrens return (EBUSY); 942789Sahrens } 943789Sahrens } else { 944789Sahrens if (vfsp->vfs_count > 2 || 945789Sahrens (zfsvfs->z_ctldir->v_count > 1 && !(fflag & MS_FORCE))) { 946789Sahrens if ((zfsvfs->z_vfs->vfs_flag & VFS_RDONLY) == 0) 947789Sahrens (void) zfs_delete_thread_target(zfsvfs, 1); 948789Sahrens return (EBUSY); 949789Sahrens } 950789Sahrens } 951789Sahrens 952789Sahrens vfsp->vfs_flag |= VFS_UNMOUNTED; 953789Sahrens zfs_objset_close(zfsvfs); 954789Sahrens 955789Sahrens return (0); 956789Sahrens } 957789Sahrens 958789Sahrens static int 959789Sahrens zfs_vget(vfs_t *vfsp, vnode_t **vpp, fid_t *fidp) 960789Sahrens { 961789Sahrens zfsvfs_t *zfsvfs = vfsp->vfs_data; 962789Sahrens znode_t *zp; 963789Sahrens uint64_t object = 0; 964789Sahrens uint64_t fid_gen = 0; 965789Sahrens uint64_t gen_mask; 966789Sahrens uint64_t zp_gen; 967789Sahrens int i, err; 968789Sahrens 969789Sahrens *vpp = NULL; 970789Sahrens 971789Sahrens ZFS_ENTER(zfsvfs); 972789Sahrens 973789Sahrens if (fidp->fid_len == LONG_FID_LEN) { 974789Sahrens zfid_long_t *zlfid = (zfid_long_t *)fidp; 975789Sahrens uint64_t objsetid = 0; 976789Sahrens uint64_t setgen = 0; 977789Sahrens 978789Sahrens for (i = 0; i < sizeof (zlfid->zf_setid); i++) 979789Sahrens objsetid |= ((uint64_t)zlfid->zf_setid[i]) << (8 * i); 980789Sahrens 981789Sahrens for (i = 0; i < sizeof (zlfid->zf_setgen); i++) 982789Sahrens setgen |= ((uint64_t)zlfid->zf_setgen[i]) << (8 * i); 983789Sahrens 984789Sahrens ZFS_EXIT(zfsvfs); 985789Sahrens 986789Sahrens err = zfsctl_lookup_objset(vfsp, objsetid, &zfsvfs); 987789Sahrens if (err) 988789Sahrens return (EINVAL); 989789Sahrens ZFS_ENTER(zfsvfs); 990789Sahrens } 991789Sahrens 992789Sahrens if (fidp->fid_len == SHORT_FID_LEN || fidp->fid_len == LONG_FID_LEN) { 993789Sahrens zfid_short_t *zfid = (zfid_short_t *)fidp; 994789Sahrens 995789Sahrens for (i = 0; i < sizeof (zfid->zf_object); i++) 996789Sahrens object |= ((uint64_t)zfid->zf_object[i]) << (8 * i); 997789Sahrens 998789Sahrens for (i = 0; i < sizeof (zfid->zf_gen); i++) 999789Sahrens fid_gen |= ((uint64_t)zfid->zf_gen[i]) << (8 * i); 1000789Sahrens } else { 1001789Sahrens ZFS_EXIT(zfsvfs); 1002789Sahrens return (EINVAL); 1003789Sahrens } 1004789Sahrens 1005789Sahrens /* A zero fid_gen means we are in the .zfs control directories */ 1006789Sahrens if (fid_gen == 0 && 1007789Sahrens (object == ZFSCTL_INO_ROOT || object == ZFSCTL_INO_SNAPDIR)) { 1008789Sahrens *vpp = zfsvfs->z_ctldir; 1009789Sahrens ASSERT(*vpp != NULL); 1010789Sahrens if (object == ZFSCTL_INO_SNAPDIR) { 1011789Sahrens VERIFY(zfsctl_root_lookup(*vpp, "snapshot", vpp, NULL, 1012789Sahrens 0, NULL, NULL) == 0); 1013789Sahrens } else { 1014789Sahrens VN_HOLD(*vpp); 1015789Sahrens } 1016789Sahrens ZFS_EXIT(zfsvfs); 1017789Sahrens return (0); 1018789Sahrens } 1019789Sahrens 1020789Sahrens gen_mask = -1ULL >> (64 - 8 * i); 1021789Sahrens 1022789Sahrens dprintf("getting %llu [%u mask %llx]\n", object, fid_gen, gen_mask); 1023789Sahrens if (err = zfs_zget(zfsvfs, object, &zp)) { 1024789Sahrens ZFS_EXIT(zfsvfs); 1025789Sahrens return (err); 1026789Sahrens } 1027789Sahrens zp_gen = zp->z_phys->zp_gen & gen_mask; 1028789Sahrens if (zp_gen == 0) 1029789Sahrens zp_gen = 1; 1030789Sahrens if (zp->z_reap || zp_gen != fid_gen) { 1031789Sahrens dprintf("znode gen (%u) != fid gen (%u)\n", zp_gen, fid_gen); 1032789Sahrens VN_RELE(ZTOV(zp)); 1033789Sahrens ZFS_EXIT(zfsvfs); 1034789Sahrens return (EINVAL); 1035789Sahrens } 1036789Sahrens 1037789Sahrens *vpp = ZTOV(zp); 1038789Sahrens ZFS_EXIT(zfsvfs); 1039789Sahrens return (0); 1040789Sahrens } 1041789Sahrens 1042789Sahrens static void 1043789Sahrens zfs_objset_close(zfsvfs_t *zfsvfs) 1044789Sahrens { 1045789Sahrens zfs_delete_t *zd = &zfsvfs->z_delete_head; 1046789Sahrens znode_t *zp, *nextzp; 1047789Sahrens objset_t *os = zfsvfs->z_os; 1048789Sahrens 1049789Sahrens /* 1050789Sahrens * Stop all delete threads. 1051789Sahrens */ 1052789Sahrens (void) zfs_delete_thread_target(zfsvfs, 0); 1053789Sahrens 1054789Sahrens /* 1055789Sahrens * For forced unmount, at this point all vops except zfs_inactive 1056789Sahrens * are erroring EIO. We need to now suspend zfs_inactive threads 1057789Sahrens * while we are freeing dbufs before switching zfs_inactive 1058789Sahrens * to use behaviour without a objset. 1059789Sahrens */ 1060789Sahrens rw_enter(&zfsvfs->z_um_lock, RW_WRITER); 1061789Sahrens 1062789Sahrens /* 1063789Sahrens * Release all delete in progress znodes 1064789Sahrens * They will be processed when the file system remounts. 1065789Sahrens */ 1066789Sahrens mutex_enter(&zd->z_mutex); 1067789Sahrens while (zp = list_head(&zd->z_znodes)) { 1068789Sahrens list_remove(&zd->z_znodes, zp); 1069789Sahrens zp->z_dbuf_held = 0; 10701544Seschrock dmu_buf_rele(zp->z_dbuf, NULL); 1071789Sahrens } 1072789Sahrens mutex_exit(&zd->z_mutex); 1073789Sahrens 1074789Sahrens /* 1075789Sahrens * Release all holds on dbufs 1076789Sahrens * Note, although we have stopped all other vop threads and 1077789Sahrens * zfs_inactive(), the dmu can callback via znode_pageout_func() 1078789Sahrens * which can zfs_znode_free() the znode. 1079789Sahrens * So we lock z_all_znodes; search the list for a held 1080789Sahrens * dbuf; drop the lock (we know zp can't disappear if we hold 1081789Sahrens * a dbuf lock; then regrab the lock and restart. 1082789Sahrens */ 1083789Sahrens mutex_enter(&zfsvfs->z_znodes_lock); 1084789Sahrens for (zp = list_head(&zfsvfs->z_all_znodes); zp; zp = nextzp) { 1085789Sahrens nextzp = list_next(&zfsvfs->z_all_znodes, zp); 1086789Sahrens if (zp->z_dbuf_held) { 1087789Sahrens /* dbufs should only be held when force unmounting */ 1088789Sahrens zp->z_dbuf_held = 0; 1089789Sahrens mutex_exit(&zfsvfs->z_znodes_lock); 10901544Seschrock dmu_buf_rele(zp->z_dbuf, NULL); 1091789Sahrens /* Start again */ 1092789Sahrens mutex_enter(&zfsvfs->z_znodes_lock); 1093789Sahrens nextzp = list_head(&zfsvfs->z_all_znodes); 1094789Sahrens } 1095789Sahrens } 1096789Sahrens mutex_exit(&zfsvfs->z_znodes_lock); 1097789Sahrens 1098789Sahrens /* 1099789Sahrens * Unregister properties. 1100789Sahrens */ 11011544Seschrock if (!dmu_objset_is_snapshot(os)) 11021544Seschrock zfs_unregister_callbacks(zfsvfs); 1103789Sahrens 1104789Sahrens /* 1105789Sahrens * Switch zfs_inactive to behaviour without an objset. 1106789Sahrens * It just tosses cached pages and frees the znode & vnode. 1107789Sahrens * Then re-enable zfs_inactive threads in that new behaviour. 1108789Sahrens */ 1109789Sahrens zfsvfs->z_unmounted2 = B_TRUE; 1110789Sahrens rw_exit(&zfsvfs->z_um_lock); /* re-enable any zfs_inactive threads */ 1111789Sahrens 1112789Sahrens /* 1113789Sahrens * Close the zil. Can't close the zil while zfs_inactive 1114789Sahrens * threads are blocked as zil_close can call zfs_inactive. 1115789Sahrens */ 1116789Sahrens if (zfsvfs->z_log) { 1117789Sahrens zil_close(zfsvfs->z_log); 1118789Sahrens zfsvfs->z_log = NULL; 1119789Sahrens } 1120789Sahrens 1121789Sahrens /* 11221544Seschrock * Evict all dbufs so that cached znodes will be freed 11231544Seschrock */ 1124*1646Sperrin if (dmu_objset_evict_dbufs(os, 1)) { 1125*1646Sperrin txg_wait_synced(dmu_objset_pool(zfsvfs->z_os), 0); 1126*1646Sperrin (void) dmu_objset_evict_dbufs(os, 0); 1127*1646Sperrin } 11281544Seschrock 11291544Seschrock /* 1130789Sahrens * Finally close the objset 1131789Sahrens */ 1132789Sahrens dmu_objset_close(os); 1133789Sahrens 11341298Sperrin /* 11351298Sperrin * We can now safely destroy the '.zfs' directory node. 11361298Sperrin */ 11371298Sperrin if (zfsvfs->z_ctldir != NULL) 11381298Sperrin zfsctl_destroy(zfsvfs); 11391298Sperrin 1140789Sahrens } 1141789Sahrens 1142789Sahrens static void 1143789Sahrens zfs_freevfs(vfs_t *vfsp) 1144789Sahrens { 1145789Sahrens zfsvfs_t *zfsvfs = vfsp->vfs_data; 1146789Sahrens 1147789Sahrens kmem_free(zfsvfs, sizeof (zfsvfs_t)); 1148789Sahrens 1149789Sahrens atomic_add_32(&zfs_active_fs_count, -1); 1150789Sahrens } 1151789Sahrens 1152789Sahrens /* 1153789Sahrens * VFS_INIT() initialization. Note that there is no VFS_FINI(), 1154789Sahrens * so we can't safely do any non-idempotent initialization here. 1155789Sahrens * Leave that to zfs_init() and zfs_fini(), which are called 1156789Sahrens * from the module's _init() and _fini() entry points. 1157789Sahrens */ 1158789Sahrens /*ARGSUSED*/ 1159789Sahrens static int 1160789Sahrens zfs_vfsinit(int fstype, char *name) 1161789Sahrens { 1162789Sahrens int error; 1163789Sahrens 1164789Sahrens zfsfstype = fstype; 1165789Sahrens 1166789Sahrens /* 1167789Sahrens * Setup vfsops and vnodeops tables. 1168789Sahrens */ 1169789Sahrens error = vfs_setfsops(fstype, zfs_vfsops_template, &zfs_vfsops); 1170789Sahrens if (error != 0) { 1171789Sahrens cmn_err(CE_WARN, "zfs: bad vfs ops template"); 1172789Sahrens } 1173789Sahrens 1174789Sahrens error = zfs_create_op_tables(); 1175789Sahrens if (error) { 1176789Sahrens zfs_remove_op_tables(); 1177789Sahrens cmn_err(CE_WARN, "zfs: bad vnode ops template"); 1178789Sahrens (void) vfs_freevfsops_by_type(zfsfstype); 1179789Sahrens return (error); 1180789Sahrens } 1181789Sahrens 1182789Sahrens mutex_init(&zfs_dev_mtx, NULL, MUTEX_DEFAULT, NULL); 1183789Sahrens 1184789Sahrens /* 1185849Sbonwick * Unique major number for all zfs mounts. 1186849Sbonwick * If we run out of 32-bit minors, we'll getudev() another major. 1187789Sahrens */ 1188849Sbonwick zfs_major = ddi_name_to_major(ZFS_DRIVER); 1189849Sbonwick zfs_minor = ZFS_MIN_MINOR; 1190789Sahrens 1191789Sahrens return (0); 1192789Sahrens } 1193789Sahrens 1194789Sahrens void 1195789Sahrens zfs_init(void) 1196789Sahrens { 1197789Sahrens /* 1198789Sahrens * Initialize .zfs directory structures 1199789Sahrens */ 1200789Sahrens zfsctl_init(); 1201789Sahrens 1202789Sahrens /* 1203789Sahrens * Initialize znode cache, vnode ops, etc... 1204789Sahrens */ 1205789Sahrens zfs_znode_init(); 1206789Sahrens } 1207789Sahrens 1208789Sahrens void 1209789Sahrens zfs_fini(void) 1210789Sahrens { 1211789Sahrens zfsctl_fini(); 1212789Sahrens zfs_znode_fini(); 1213789Sahrens } 1214789Sahrens 1215789Sahrens int 1216789Sahrens zfs_busy(void) 1217789Sahrens { 1218789Sahrens return (zfs_active_fs_count != 0); 1219789Sahrens } 1220789Sahrens 1221789Sahrens static vfsdef_t vfw = { 1222789Sahrens VFSDEF_VERSION, 1223789Sahrens MNTTYPE_ZFS, 1224789Sahrens zfs_vfsinit, 12251488Srsb VSW_HASPROTO|VSW_CANRWRO|VSW_CANREMOUNT|VSW_VOLATILEDEV|VSW_STATS, 1226789Sahrens &zfs_mntopts 1227789Sahrens }; 1228789Sahrens 1229789Sahrens struct modlfs zfs_modlfs = { 1230789Sahrens &mod_fsops, "ZFS filesystem version 1", &vfw 1231789Sahrens }; 1232