Lines Matching refs:zfsvfs
105 static void zfs_objset_close(zfsvfs_t *zfsvfs);
130 zfs_getquota(zfsvfs_t *zfsvfs, uid_t id, int isgroup, struct dqblk64 *dqp)
140 quotaobj = isgroup ? zfsvfs->z_groupquota_obj : zfsvfs->z_userquota_obj;
142 if (quotaobj == 0 || zfsvfs->z_replay) {
147 if ((error = zap_lookup(zfsvfs->z_os, quotaobj,
157 error = zap_lookup(zfsvfs->z_os, usedobj, buf, sizeof(used), 1, &used);
178 zfsvfs_t *zfsvfs = vfsp->vfs_data;
190 ZFS_ENTER(zfsvfs);
238 * Create fuid using zfs_fuid_create(zfsvfs, id,
269 error = zfs_set_userquota(zfsvfs, quota_type,
273 error = zfs_getquota(zfsvfs, id, type == GRPQUOTA, &dqblk);
282 ZFS_EXIT(zfsvfs);
309 zfsvfs_t *zfsvfs = vfsp->vfs_data;
317 ZFS_ENTER(zfsvfs);
318 dp = dmu_objset_pool(zfsvfs->z_os);
325 ZFS_EXIT(zfsvfs);
329 if (zfsvfs->z_log != NULL)
330 zil_commit(zfsvfs->z_log, 0);
332 ZFS_EXIT(zfsvfs);
402 zfsvfs_t *zfsvfs = arg;
405 zfsvfs->z_atime = TRUE;
406 zfsvfs->z_vfs->vfs_flag &= ~MNT_NOATIME;
407 vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_NOATIME);
408 vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_ATIME, NULL, 0);
410 zfsvfs->z_atime = FALSE;
411 zfsvfs->z_vfs->vfs_flag |= MNT_NOATIME;
412 vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_ATIME);
413 vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_NOATIME, NULL, 0);
420 zfsvfs_t *zfsvfs = arg;
425 zfsvfs->z_vfs->vfs_flag |= VFS_XATTR;
427 vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_NOXATTR);
428 vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_XATTR, NULL, 0);
432 zfsvfs->z_vfs->vfs_flag &= ~VFS_XATTR;
434 vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_XATTR);
435 vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_NOXATTR, NULL, 0);
442 zfsvfs_t *zfsvfs = arg;
443 ASSERT3U(newval, <=, spa_maxblocksize(dmu_objset_spa(zfsvfs->z_os)));
447 zfsvfs->z_max_blksz = newval;
448 zfsvfs->z_vfs->mnt_stat.f_iosize = newval;
454 zfsvfs_t *zfsvfs = arg;
458 zfsvfs->z_vfs->vfs_flag |= VFS_RDONLY;
459 vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_RW);
460 vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_RO, NULL, 0);
463 zfsvfs->z_vfs->vfs_flag &= ~VFS_RDONLY;
464 vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_RO);
465 vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_RW, NULL, 0);
472 zfsvfs_t *zfsvfs = arg;
475 zfsvfs->z_vfs->vfs_flag |= VFS_NOSETUID;
476 vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_SETUID);
477 vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_NOSETUID, NULL, 0);
479 zfsvfs->z_vfs->vfs_flag &= ~VFS_NOSETUID;
480 vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_NOSETUID);
481 vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_SETUID, NULL, 0);
488 zfsvfs_t *zfsvfs = arg;
491 zfsvfs->z_vfs->vfs_flag |= VFS_NOEXEC;
492 vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_EXEC);
493 vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_NOEXEC, NULL, 0);
495 zfsvfs->z_vfs->vfs_flag &= ~VFS_NOEXEC;
496 vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_NOEXEC);
497 vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_EXEC, NULL, 0);
512 zfsvfs_t *zfsvfs = arg;
514 vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_NBMAND);
515 vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_NONBMAND, NULL, 0);
517 vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_NONBMAND);
518 vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_NBMAND, NULL, 0);
525 zfsvfs_t *zfsvfs = arg;
527 zfsvfs->z_show_ctldir = newval;
533 zfsvfs_t *zfsvfs = arg;
535 zfsvfs->z_vscan = newval;
541 zfsvfs_t *zfsvfs = arg;
543 zfsvfs->z_acl_mode = newval;
549 zfsvfs_t *zfsvfs = arg;
551 zfsvfs->z_acl_inherit = newval;
559 zfsvfs_t *zfsvfs = NULL;
578 zfsvfs = vfsp->vfs_data;
579 ASSERT(zfsvfs);
580 os = zfsvfs->z_os;
674 zfs_prop_to_name(ZFS_PROP_ATIME), atime_changed_cb, zfsvfs);
676 zfs_prop_to_name(ZFS_PROP_XATTR), xattr_changed_cb, zfsvfs);
678 zfs_prop_to_name(ZFS_PROP_RECORDSIZE), blksz_changed_cb, zfsvfs);
680 zfs_prop_to_name(ZFS_PROP_READONLY), readonly_changed_cb, zfsvfs);
683 zfs_prop_to_name(ZFS_PROP_DEVICES), devices_changed_cb, zfsvfs);
686 zfs_prop_to_name(ZFS_PROP_SETUID), setuid_changed_cb, zfsvfs);
688 zfs_prop_to_name(ZFS_PROP_EXEC), exec_changed_cb, zfsvfs);
690 zfs_prop_to_name(ZFS_PROP_SNAPDIR), snapdir_changed_cb, zfsvfs);
692 zfs_prop_to_name(ZFS_PROP_ACLMODE), acl_mode_changed_cb, zfsvfs);
695 zfsvfs);
697 zfs_prop_to_name(ZFS_PROP_VSCAN), vscan_changed_cb, zfsvfs);
706 readonly_changed_cb(zfsvfs, readonly);
708 setuid_changed_cb(zfsvfs, setuid);
710 exec_changed_cb(zfsvfs, exec);
712 xattr_changed_cb(zfsvfs, xattr);
714 atime_changed_cb(zfsvfs, atime);
716 nbmand_changed_cb(zfsvfs, nbmand);
721 dsl_prop_unregister_all(ds, zfsvfs);
789 fuidstr_to_sid(zfsvfs_t *zfsvfs, const char *fuidstr,
797 domain = zfs_fuid_find_by_idx(zfsvfs, FUID_INDEX(fuid));
806 zfs_userquota_prop_to_obj(zfsvfs_t *zfsvfs, zfs_userquota_prop_t type)
814 return (zfsvfs->z_userquota_obj);
816 return (zfsvfs->z_groupquota_obj);
822 zfs_userspace_many(zfsvfs_t *zfsvfs, zfs_userquota_prop_t type,
831 if (!dmu_objset_userspace_present(zfsvfs->z_os))
834 obj = zfs_userquota_prop_to_obj(zfsvfs, type);
840 for (zap_cursor_init_serialized(&zc, zfsvfs->z_os, obj, *cookiep);
847 fuidstr_to_sid(zfsvfs, za.za_name,
867 id_to_fuidstr(zfsvfs_t *zfsvfs, const char *domain, uid_t rid,
874 domainid = zfs_fuid_find_by_domain(zfsvfs, domain, NULL, addok);
884 zfs_userspace_one(zfsvfs_t *zfsvfs, zfs_userquota_prop_t type,
893 if (!dmu_objset_userspace_present(zfsvfs->z_os))
896 obj = zfs_userquota_prop_to_obj(zfsvfs, type);
900 err = id_to_fuidstr(zfsvfs, domain, rid, buf, B_FALSE);
904 err = zap_lookup(zfsvfs->z_os, obj, buf, 8, 1, valp);
911 zfs_set_userquota(zfsvfs_t *zfsvfs, zfs_userquota_prop_t type,
923 if (zfsvfs->z_version < ZPL_VERSION_USERSPACE)
926 objp = (type == ZFS_PROP_USERQUOTA) ? &zfsvfs->z_userquota_obj :
927 &zfsvfs->z_groupquota_obj;
929 err = id_to_fuidstr(zfsvfs, domain, rid, buf, B_TRUE);
932 fuid_dirtied = zfsvfs->z_fuid_dirty;
934 tx = dmu_tx_create(zfsvfs->z_os);
941 zfs_fuid_txhold(zfsvfs, tx);
948 mutex_enter(&zfsvfs->z_lock);
950 *objp = zap_create(zfsvfs->z_os, DMU_OT_USERGROUP_QUOTA,
952 VERIFY(0 == zap_add(zfsvfs->z_os, MASTER_NODE_OBJ,
955 mutex_exit(&zfsvfs->z_lock);
958 err = zap_remove(zfsvfs->z_os, *objp, buf, tx);
962 err = zap_update(zfsvfs->z_os, *objp, buf, 8, 1, "a, tx);
966 zfs_fuid_sync(zfsvfs, tx);
972 zfs_fuid_overquota(zfsvfs_t *zfsvfs, boolean_t isgroup, uint64_t fuid)
979 quotaobj = isgroup ? zfsvfs->z_groupquota_obj : zfsvfs->z_userquota_obj;
981 if (quotaobj == 0 || zfsvfs->z_replay)
985 err = zap_lookup(zfsvfs->z_os, quotaobj, buf, 8, 1, "a);
989 err = zap_lookup(zfsvfs->z_os, usedobj, buf, 8, 1, &used);
996 zfs_owner_overquota(zfsvfs_t *zfsvfs, znode_t *zp, boolean_t isgroup)
1001 quotaobj = isgroup ? zfsvfs->z_groupquota_obj : zfsvfs->z_userquota_obj;
1005 if (quotaobj == 0 || zfsvfs->z_replay)
1008 return (zfs_fuid_overquota(zfsvfs, isgroup, fuid));
1012 * Associate this zfsvfs with the given objset, which must be owned.
1014 * zfsvfs.
1017 zfsvfs_init(zfsvfs_t *zfsvfs, objset_t *os)
1022 zfsvfs->z_max_blksz = SPA_OLD_MAXBLOCKSIZE;
1023 zfsvfs->z_show_ctldir = ZFS_SNAPDIR_VISIBLE;
1024 zfsvfs->z_os = os;
1026 error = zfs_get_zplprop(os, ZFS_PROP_VERSION, &zfsvfs->z_version);
1029 if (zfsvfs->z_version >
1033 "this file system.", (u_longlong_t)zfsvfs->z_version,
1040 zfsvfs->z_norm = (int)val;
1045 zfsvfs->z_utf8 = (val != 0);
1050 zfsvfs->z_case = (uint_t)val;
1056 if (zfsvfs->z_case == ZFS_CASE_INSENSITIVE ||
1057 zfsvfs->z_case == ZFS_CASE_MIXED)
1058 zfsvfs->z_norm |= U8_TEXTPREP_TOUPPER;
1060 zfsvfs->z_use_fuids = USE_FUIDS(zfsvfs->z_version, zfsvfs->z_os);
1061 zfsvfs->z_use_sa = USE_SA(zfsvfs->z_version, zfsvfs->z_os);
1064 if (zfsvfs->z_use_sa) {
1073 &zfsvfs->z_attr_table);
1077 if (zfsvfs->z_version >= ZPL_VERSION_SA)
1081 &zfsvfs->z_root);
1084 ASSERT(zfsvfs->z_root != 0);
1087 &zfsvfs->z_unlinkedobj);
1093 8, 1, &zfsvfs->z_userquota_obj);
1095 zfsvfs->z_userquota_obj = 0;
1101 8, 1, &zfsvfs->z_groupquota_obj);
1103 zfsvfs->z_groupquota_obj = 0;
1108 &zfsvfs->z_fuid_obj);
1110 zfsvfs->z_fuid_obj = 0;
1115 &zfsvfs->z_shares_dir);
1117 zfsvfs->z_shares_dir = 0;
1129 zfsvfs->z_use_namecache = !zfsvfs->z_norm ||
1130 ((zfsvfs->z_case == ZFS_CASE_MIXED) &&
1131 !(zfsvfs->z_norm & ~U8_TEXTPREP_TOUPPER));
1151 zfsvfs_t *zfsvfs;
1165 zfsvfs = kmem_zalloc(sizeof (zfsvfs_t), KM_SLEEP);
1172 error = dmu_objset_own(osname, DMU_OST_ZFS, B_TRUE, zfsvfs, &os);
1174 kmem_free(zfsvfs, sizeof (zfsvfs_t));
1178 error = zfsvfs_create_impl(zfvp, zfsvfs, os);
1180 dmu_objset_disown(os, zfsvfs);
1187 zfsvfs_create_impl(zfsvfs_t **zfvp, zfsvfs_t *zfsvfs, objset_t *os)
1191 zfsvfs->z_vfs = NULL;
1192 zfsvfs->z_parent = zfsvfs;
1194 mutex_init(&zfsvfs->z_znodes_lock, NULL, MUTEX_DEFAULT, NULL);
1195 mutex_init(&zfsvfs->z_lock, NULL, MUTEX_DEFAULT, NULL);
1196 list_create(&zfsvfs->z_all_znodes, sizeof (znode_t),
1199 TASK_INIT(&zfsvfs->z_unlinked_drain_task, 0,
1200 zfsvfs_task_unlinked_drain, zfsvfs);
1203 rrm_init(&zfsvfs->z_teardown_lock, B_TRUE);
1205 rrm_init(&zfsvfs->z_teardown_lock, B_FALSE);
1207 rw_init(&zfsvfs->z_teardown_inactive_lock, NULL, RW_DEFAULT, NULL);
1208 rw_init(&zfsvfs->z_fuid_lock, NULL, RW_DEFAULT, NULL);
1210 mutex_init(&zfsvfs->z_hold_mtx[i], NULL, MUTEX_DEFAULT, NULL);
1212 error = zfsvfs_init(zfsvfs, os);
1215 kmem_free(zfsvfs, sizeof (zfsvfs_t));
1219 *zfvp = zfsvfs;
1224 zfsvfs_setup(zfsvfs_t *zfsvfs, boolean_t mounting)
1228 error = zfs_register_callbacks(zfsvfs->z_vfs);
1232 zfsvfs->z_log = zil_open(zfsvfs->z_os, zfs_get_data);
1246 readonly = zfsvfs->z_vfs->vfs_flag & VFS_RDONLY;
1248 zfsvfs->z_vfs->vfs_flag &= ~VFS_RDONLY;
1250 zfs_unlinked_drain(zfsvfs);
1279 if (spa_writeable(dmu_objset_spa(zfsvfs->z_os))) {
1281 zil_destroy(zfsvfs->z_log, B_FALSE);
1283 zfsvfs->z_replay = B_TRUE;
1284 zil_replay(zfsvfs->z_os, zfsvfs,
1286 zfsvfs->z_replay = B_FALSE;
1289 zfsvfs->z_vfs->vfs_flag |= readonly; /* restore readonly bit */
1293 * Set the objset user_ptr to track its zfsvfs.
1295 mutex_enter(&zfsvfs->z_os->os_user_ptr_lock);
1296 dmu_objset_set_user(zfsvfs->z_os, zfsvfs);
1297 mutex_exit(&zfsvfs->z_os->os_user_ptr_lock);
1305 zfsvfs_free(zfsvfs_t *zfsvfs)
1318 zfs_fuid_destroy(zfsvfs);
1320 mutex_destroy(&zfsvfs->z_znodes_lock);
1321 mutex_destroy(&zfsvfs->z_lock);
1322 list_destroy(&zfsvfs->z_all_znodes);
1323 rrm_destroy(&zfsvfs->z_teardown_lock);
1324 rw_destroy(&zfsvfs->z_teardown_inactive_lock);
1325 rw_destroy(&zfsvfs->z_fuid_lock);
1327 mutex_destroy(&zfsvfs->z_hold_mtx[i]);
1328 kmem_free(zfsvfs, sizeof (zfsvfs_t));
1332 zfs_set_fuid_feature(zfsvfs_t *zfsvfs)
1334 zfsvfs->z_use_fuids = USE_FUIDS(zfsvfs->z_version, zfsvfs->z_os);
1335 if (zfsvfs->z_vfs) {
1336 if (zfsvfs->z_use_fuids) {
1337 vfs_set_feature(zfsvfs->z_vfs, VFSFT_XVATTR);
1338 vfs_set_feature(zfsvfs->z_vfs, VFSFT_SYSATTR_VIEWS);
1339 vfs_set_feature(zfsvfs->z_vfs, VFSFT_ACEMASKONACCESS);
1340 vfs_set_feature(zfsvfs->z_vfs, VFSFT_ACLONCREATE);
1341 vfs_set_feature(zfsvfs->z_vfs, VFSFT_ACCESS_FILTER);
1342 vfs_set_feature(zfsvfs->z_vfs, VFSFT_REPARSE);
1344 vfs_clear_feature(zfsvfs->z_vfs, VFSFT_XVATTR);
1345 vfs_clear_feature(zfsvfs->z_vfs, VFSFT_SYSATTR_VIEWS);
1346 vfs_clear_feature(zfsvfs->z_vfs, VFSFT_ACEMASKONACCESS);
1347 vfs_clear_feature(zfsvfs->z_vfs, VFSFT_ACLONCREATE);
1348 vfs_clear_feature(zfsvfs->z_vfs, VFSFT_ACCESS_FILTER);
1349 vfs_clear_feature(zfsvfs->z_vfs, VFSFT_REPARSE);
1352 zfsvfs->z_use_sa = USE_SA(zfsvfs->z_version, zfsvfs->z_os);
1360 zfsvfs_t *zfsvfs;
1366 error = zfsvfs_create(osname, &zfsvfs);
1369 zfsvfs->z_vfs = vfsp;
1386 zfsvfs->z_vfs->vfs_bsize = SPA_MINBLOCKSIZE;
1387 zfsvfs->z_vfs->mnt_stat.f_iosize = recordsize;
1389 vfsp->vfs_data = zfsvfs;
1404 fsid_guid = dmu_objset_fsid_guid(zfsvfs->z_os);
1413 zfs_set_fuid_feature(zfsvfs);
1414 if (zfsvfs->z_case == ZFS_CASE_INSENSITIVE) {
1418 } else if (zfsvfs->z_case == ZFS_CASE_MIXED) {
1424 if (dmu_objset_is_snapshot(zfsvfs->z_os)) {
1427 atime_changed_cb(zfsvfs, B_FALSE);
1428 readonly_changed_cb(zfsvfs, B_TRUE);
1431 xattr_changed_cb(zfsvfs, pval);
1432 zfsvfs->z_issnap = B_TRUE;
1433 zfsvfs->z_os->os_sync = ZFS_SYNC_DISABLED;
1435 mutex_enter(&zfsvfs->z_os->os_user_ptr_lock);
1436 dmu_objset_set_user(zfsvfs->z_os, zfsvfs);
1437 mutex_exit(&zfsvfs->z_os->os_user_ptr_lock);
1439 error = zfsvfs_setup(zfsvfs, B_TRUE);
1444 if (!zfsvfs->z_issnap)
1445 zfsctl_create(zfsvfs);
1448 dmu_objset_disown(zfsvfs->z_os, zfsvfs);
1449 zfsvfs_free(zfsvfs);
1458 zfs_unregister_callbacks(zfsvfs_t *zfsvfs)
1460 objset_t *os = zfsvfs->z_os;
1463 dsl_prop_unregister_all(dmu_objset_ds(os), zfsvfs);
1659 zfsvfs_t *zfsvfs = NULL;
1715 zfsvfs = (zfsvfs_t *)vfsp->vfs_data;
1716 ASSERT(zfsvfs);
1717 if (error = zfs_zget(zfsvfs, zfsvfs->z_root, &zp)) {
1896 zfsvfs_t *zfsvfs = vfsp->vfs_data;
1905 rrm_enter(&zfsvfs->z_teardown_lock, RW_WRITER, FTAG);
1906 zfs_unregister_callbacks(zfsvfs);
1908 rrm_exit(&zfsvfs->z_teardown_lock, FTAG);
1943 zfsvfs_t *zfsvfs = vfsp->vfs_data;
1948 ZFS_ENTER(zfsvfs);
1950 dmu_objset_space(zfsvfs->z_os,
1959 statp->f_iosize = zfsvfs->z_vfs->mnt_stat.f_iosize;
1994 ZFS_EXIT(zfsvfs);
2001 zfsvfs_t *zfsvfs = vfsp->vfs_data;
2005 ZFS_ENTER(zfsvfs);
2007 error = zfs_zget(zfsvfs, zfsvfs->z_root, &rootzp);
2011 ZFS_EXIT(zfsvfs);
2024 * Teardown the zfsvfs::z_os.
2030 zfsvfs_teardown(zfsvfs_t *zfsvfs, boolean_t unmounting)
2034 rrm_enter(&zfsvfs->z_teardown_lock, RW_WRITER, FTAG);
2043 (void) dnlc_purge_vfsp(zfsvfs->z_parent->z_vfs, 0);
2045 cache_purgevfs(zfsvfs->z_parent->z_vfs, true);
2053 if (zfsvfs->z_log) {
2054 zil_close(zfsvfs->z_log);
2055 zfsvfs->z_log = NULL;
2058 rw_enter(&zfsvfs->z_teardown_inactive_lock, RW_WRITER);
2065 if (!unmounting && (zfsvfs->z_unmounted || zfsvfs->z_os == NULL)) {
2066 rw_exit(&zfsvfs->z_teardown_inactive_lock);
2067 rrm_exit(&zfsvfs->z_teardown_lock, FTAG);
2078 mutex_enter(&zfsvfs->z_znodes_lock);
2079 for (zp = list_head(&zfsvfs->z_all_znodes); zp != NULL;
2080 zp = list_next(&zfsvfs->z_all_znodes, zp))
2085 mutex_exit(&zfsvfs->z_znodes_lock);
2093 zfsvfs->z_unmounted = B_TRUE;
2094 rw_exit(&zfsvfs->z_teardown_inactive_lock);
2095 rrm_exit(&zfsvfs->z_teardown_lock, FTAG);
2100 * zfsvfs, so just return as the properties had already been
2103 if (zfsvfs->z_os == NULL)
2109 zfs_unregister_callbacks(zfsvfs);
2114 if (dsl_dataset_is_dirty(dmu_objset_ds(zfsvfs->z_os)) &&
2115 !(zfsvfs->z_vfs->vfs_flag & VFS_RDONLY))
2116 txg_wait_synced(dmu_objset_pool(zfsvfs->z_os), 0);
2117 dmu_objset_evict_dbufs(zfsvfs->z_os);
2127 zfsvfs_t *zfsvfs = vfsp->vfs_data;
2145 (void) dnlc_purge_vfsp(zfsvfs->z_parent->z_vfs, 0);
2151 if (zfsvfs->z_ctldir != NULL) {
2162 rrm_enter(&zfsvfs->z_teardown_lock, RW_WRITER, FTAG);
2163 zfsvfs->z_unmounted = B_TRUE;
2164 rrm_exit(&zfsvfs->z_teardown_lock, FTAG);
2186 if (zfsvfs->z_ctldir == NULL) {
2191 zfsvfs->z_ctldir->v_count > 1)
2198 &zfsvfs->z_unlinked_drain_task, NULL) != 0)
2200 &zfsvfs->z_unlinked_drain_task);
2202 VERIFY(zfsvfs_teardown(zfsvfs, B_TRUE) == 0);
2203 os = zfsvfs->z_os;
2207 * attempting to reopen zfsvfs.
2220 dmu_objset_disown(os, zfsvfs);
2226 if (zfsvfs->z_ctldir != NULL)
2227 zfsctl_destroy(zfsvfs);
2236 zfsvfs_t *zfsvfs = vfsp->vfs_data;
2246 (zfsvfs->z_shares_dir != 0 && ino == zfsvfs->z_shares_dir))
2249 ZFS_ENTER(zfsvfs);
2250 err = zfs_zget(zfsvfs, ino, &zp);
2257 ZFS_EXIT(zfsvfs);
2272 zfsvfs_t *zfsvfs = vfsp->vfs_data;
2276 * zfsvfs->z_parent->z_vfs, but if it is snapshot,
2277 * zfsvfs->z_parent->z_vfs represents parent file system
2281 return (vfs_stdcheckexp(zfsvfs->z_parent->z_vfs, nam, extflagsp,
2292 zfsvfs_t *zfsvfs = vfsp->vfs_data;
2303 ZFS_ENTER(zfsvfs);
2309 if (zfsvfs->z_parent == zfsvfs && fidp->fid_len == LONG_FID_LEN) {
2320 ZFS_EXIT(zfsvfs);
2322 err = zfsctl_lookup_objset(vfsp, objsetid, &zfsvfs);
2325 ZFS_ENTER(zfsvfs);
2337 ZFS_EXIT(zfsvfs);
2343 * directory tree. If the object == zfsvfs->z_shares_dir, then
2348 (zfsvfs->z_shares_dir != 0 && object == zfsvfs->z_shares_dir)) {
2349 ZFS_EXIT(zfsvfs);
2350 VERIFY0(zfsctl_root(zfsvfs, LK_SHARED, &dvp));
2359 } else if (object == zfsvfs->z_shares_dir) {
2381 if (err = zfs_zget(zfsvfs, object, &zp)) {
2382 ZFS_EXIT(zfsvfs);
2385 (void) sa_lookup(zp->z_sa_hdl, SA_ZPL_GEN(zfsvfs), &zp_gen,
2393 ZFS_EXIT(zfsvfs);
2398 ZFS_EXIT(zfsvfs);
2416 zfs_suspend_fs(zfsvfs_t *zfsvfs)
2420 if ((error = zfsvfs_teardown(zfsvfs, B_FALSE)) != 0)
2431 * zfsvfs, held, and long held on entry.
2434 zfs_resume_fs(zfsvfs_t *zfsvfs, dsl_dataset_t *ds)
2439 ASSERT(RRM_WRITE_HELD(&zfsvfs->z_teardown_lock));
2440 ASSERT(RW_WRITE_HELD(&zfsvfs->z_teardown_inactive_lock));
2447 VERIFY3P(ds->ds_owner, ==, zfsvfs);
2451 err = zfsvfs_init(zfsvfs, os);
2455 VERIFY(zfsvfs_setup(zfsvfs, B_FALSE) == 0);
2457 zfs_set_fuid_feature(zfsvfs);
2465 mutex_enter(&zfsvfs->z_znodes_lock);
2466 for (zp = list_head(&zfsvfs->z_all_znodes); zp;
2467 zp = list_next(&zfsvfs->z_all_znodes, zp)) {
2470 mutex_exit(&zfsvfs->z_znodes_lock);
2474 rw_exit(&zfsvfs->z_teardown_inactive_lock);
2475 rrm_exit(&zfsvfs->z_teardown_lock, FTAG);
2482 if (vn_vfswlock(zfsvfs->z_vfs->vfs_vnodecovered) == 0) {
2483 vfs_ref(zfsvfs->z_vfs);
2484 (void) dounmount(zfsvfs->z_vfs, MS_FORCE, curthread);
2493 zfsvfs_t *zfsvfs = vfsp->vfs_data;
2502 if (zfsvfs->z_issnap && (vfsp != rootvfs))
2503 VFS_RELE(zfsvfs->z_parent->z_vfs);
2506 zfsvfs_free(zfsvfs);
2570 zfsvfs_taskq = taskq_create("zfsvfs", 1, minclsyspri, 0, 0, 0);
2592 zfs_set_version(zfsvfs_t *zfsvfs, uint64_t newvers)
2595 objset_t *os = zfsvfs->z_os;
2601 if (newvers < zfsvfs->z_version)
2605 spa_version(dmu_objset_spa(zfsvfs->z_os)))
2610 if (newvers >= ZPL_VERSION_SA && !zfsvfs->z_use_sa) {
2629 if (newvers >= ZPL_VERSION_SA && !zfsvfs->z_use_sa) {
2632 ASSERT3U(spa_version(dmu_objset_spa(zfsvfs->z_os)), >=,
2646 "from %llu to %llu", zfsvfs->z_version, newvers);
2650 zfsvfs->z_version = newvers;
2653 zfs_set_fuid_feature(zfsvfs);