*/
/*
* Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2013 by Delphix. All rights reserved.
*/
/* Portions Copyright 2010 Robert Milkowski */
((zfs_sb_t *)arg)->z_atime = newval;
}
+static void
+relatime_changed_cb(void *arg, uint64_t newval)
+{
+ ((zfs_sb_t *)arg)->z_relatime = newval;
+}
+
static void
xattr_changed_cb(void *arg, uint64_t newval)
{
}
}
+static void
+acltype_changed_cb(void *arg, uint64_t newval)
+{
+ zfs_sb_t *zsb = arg;
+
+ switch (newval) {
+ case ZFS_ACLTYPE_OFF:
+ zsb->z_acl_type = ZFS_ACLTYPE_OFF;
+ zsb->z_sb->s_flags &= ~MS_POSIXACL;
+ break;
+ case ZFS_ACLTYPE_POSIXACL:
+#ifdef CONFIG_FS_POSIX_ACL
+ zsb->z_acl_type = ZFS_ACLTYPE_POSIXACL;
+ zsb->z_sb->s_flags |= MS_POSIXACL;
+#else
+ zsb->z_acl_type = ZFS_ACLTYPE_OFF;
+ zsb->z_sb->s_flags &= ~MS_POSIXACL;
+#endif /* CONFIG_FS_POSIX_ACL */
+ break;
+ default:
+ break;
+ }
+}
+
static void
blksz_changed_cb(void *arg, uint64_t newval)
{
* overboard...
*/
ds = dmu_objset_ds(os);
+ dsl_pool_config_enter(dmu_objset_pool(os), FTAG);
+ error = dsl_prop_register(ds,
+ zfs_prop_to_name(ZFS_PROP_ATIME), atime_changed_cb, zsb);
error = dsl_prop_register(ds,
- "atime", atime_changed_cb, zsb);
+ zfs_prop_to_name(ZFS_PROP_RELATIME), relatime_changed_cb, zsb);
error = error ? error : dsl_prop_register(ds,
- "xattr", xattr_changed_cb, zsb);
+ zfs_prop_to_name(ZFS_PROP_XATTR), xattr_changed_cb, zsb);
error = error ? error : dsl_prop_register(ds,
- "recordsize", blksz_changed_cb, zsb);
+ zfs_prop_to_name(ZFS_PROP_RECORDSIZE), blksz_changed_cb, zsb);
error = error ? error : dsl_prop_register(ds,
- "readonly", readonly_changed_cb, zsb);
+ zfs_prop_to_name(ZFS_PROP_READONLY), readonly_changed_cb, zsb);
error = error ? error : dsl_prop_register(ds,
- "devices", devices_changed_cb, zsb);
+ zfs_prop_to_name(ZFS_PROP_DEVICES), devices_changed_cb, zsb);
error = error ? error : dsl_prop_register(ds,
- "setuid", setuid_changed_cb, zsb);
+ zfs_prop_to_name(ZFS_PROP_SETUID), setuid_changed_cb, zsb);
error = error ? error : dsl_prop_register(ds,
- "exec", exec_changed_cb, zsb);
+ zfs_prop_to_name(ZFS_PROP_EXEC), exec_changed_cb, zsb);
error = error ? error : dsl_prop_register(ds,
- "snapdir", snapdir_changed_cb, zsb);
+ zfs_prop_to_name(ZFS_PROP_SNAPDIR), snapdir_changed_cb, zsb);
error = error ? error : dsl_prop_register(ds,
- "aclinherit", acl_inherit_changed_cb, zsb);
+ zfs_prop_to_name(ZFS_PROP_ACLTYPE), acltype_changed_cb, zsb);
error = error ? error : dsl_prop_register(ds,
- "vscan", vscan_changed_cb, zsb);
+ zfs_prop_to_name(ZFS_PROP_ACLINHERIT), acl_inherit_changed_cb, zsb);
error = error ? error : dsl_prop_register(ds,
- "nbmand", nbmand_changed_cb, zsb);
+ zfs_prop_to_name(ZFS_PROP_VSCAN), vscan_changed_cb, zsb);
+ error = error ? error : dsl_prop_register(ds,
+ zfs_prop_to_name(ZFS_PROP_NBMAND), nbmand_changed_cb, zsb);
+ dsl_pool_config_exit(dmu_objset_pool(os), FTAG);
if (error)
goto unregister;
* registered, but this is OK; it will simply return ENOMSG,
* which we will ignore.
*/
- (void) dsl_prop_unregister(ds, "atime", atime_changed_cb, zsb);
- (void) dsl_prop_unregister(ds, "xattr", xattr_changed_cb, zsb);
- (void) dsl_prop_unregister(ds, "recordsize", blksz_changed_cb, zsb);
- (void) dsl_prop_unregister(ds, "readonly", readonly_changed_cb, zsb);
- (void) dsl_prop_unregister(ds, "devices", devices_changed_cb, zsb);
- (void) dsl_prop_unregister(ds, "setuid", setuid_changed_cb, zsb);
- (void) dsl_prop_unregister(ds, "exec", exec_changed_cb, zsb);
- (void) dsl_prop_unregister(ds, "snapdir", snapdir_changed_cb, zsb);
- (void) dsl_prop_unregister(ds, "aclinherit", acl_inherit_changed_cb,
- zsb);
- (void) dsl_prop_unregister(ds, "vscan", vscan_changed_cb, zsb);
- (void) dsl_prop_unregister(ds, "nbmand", nbmand_changed_cb, zsb);
+ (void) dsl_prop_unregister(ds, zfs_prop_to_name(ZFS_PROP_ATIME),
+ atime_changed_cb, zsb);
+ (void) dsl_prop_unregister(ds, zfs_prop_to_name(ZFS_PROP_RELATIME),
+ relatime_changed_cb, zsb);
+ (void) dsl_prop_unregister(ds, zfs_prop_to_name(ZFS_PROP_XATTR),
+ xattr_changed_cb, zsb);
+ (void) dsl_prop_unregister(ds, zfs_prop_to_name(ZFS_PROP_RECORDSIZE),
+ blksz_changed_cb, zsb);
+ (void) dsl_prop_unregister(ds, zfs_prop_to_name(ZFS_PROP_READONLY),
+ readonly_changed_cb, zsb);
+ (void) dsl_prop_unregister(ds, zfs_prop_to_name(ZFS_PROP_DEVICES),
+ devices_changed_cb, zsb);
+ (void) dsl_prop_unregister(ds, zfs_prop_to_name(ZFS_PROP_SETUID),
+ setuid_changed_cb, zsb);
+ (void) dsl_prop_unregister(ds, zfs_prop_to_name(ZFS_PROP_EXEC),
+ exec_changed_cb, zsb);
+ (void) dsl_prop_unregister(ds, zfs_prop_to_name(ZFS_PROP_SNAPDIR),
+ snapdir_changed_cb, zsb);
+ (void) dsl_prop_unregister(ds, zfs_prop_to_name(ZFS_PROP_ACLTYPE),
+ acltype_changed_cb, zsb);
+ (void) dsl_prop_unregister(ds, zfs_prop_to_name(ZFS_PROP_ACLINHERIT),
+ acl_inherit_changed_cb, zsb);
+ (void) dsl_prop_unregister(ds, zfs_prop_to_name(ZFS_PROP_VSCAN),
+ vscan_changed_cb, zsb);
+ (void) dsl_prop_unregister(ds, zfs_prop_to_name(ZFS_PROP_NBMAND),
+ nbmand_changed_cb, zsb);
return (error);
}
zfs_space_delta_cb(dmu_object_type_t bonustype, void *data,
uint64_t *userp, uint64_t *groupp)
{
- int error = 0;
-
/*
* Is it a valid type of object to track?
*/
if (bonustype != DMU_OT_ZNODE && bonustype != DMU_OT_SA)
- return (ENOENT);
+ return (SET_ERROR(ENOENT));
/*
* If we have a NULL data pointer
* use the same ids
*/
if (data == NULL)
- return (EEXIST);
+ return (SET_ERROR(EEXIST));
if (bonustype == DMU_OT_ZNODE) {
znode_phys_t *znp = data;
*groupp = BSWAP_64(*groupp);
}
}
- return (error);
+ return (0);
}
static void
case ZFS_PROP_GROUPQUOTA:
return (zsb->z_groupquota_obj);
default:
- return (ENOTSUP);
+ return (SET_ERROR(ENOTSUP));
}
return (0);
}
uint64_t obj;
if (!dmu_objset_userspace_present(zsb->z_os))
- return (ENOTSUP);
+ return (SET_ERROR(ENOTSUP));
obj = zfs_userquota_prop_to_obj(zsb, type);
if (obj == 0) {
if (domain && domain[0]) {
domainid = zfs_fuid_find_by_domain(zsb, domain, NULL, addok);
if (domainid == -1)
- return (ENOENT);
+ return (SET_ERROR(ENOENT));
}
fuid = FUID_ENCODE(domainid, rid);
(void) sprintf(buf, "%llx", (longlong_t)fuid);
*valp = 0;
if (!dmu_objset_userspace_present(zsb->z_os))
- return (ENOTSUP);
+ return (SET_ERROR(ENOTSUP));
obj = zfs_userquota_prop_to_obj(zsb, type);
if (obj == 0)
boolean_t fuid_dirtied;
if (type != ZFS_PROP_USERQUOTA && type != ZFS_PROP_GROUPQUOTA)
- return (EINVAL);
+ return (SET_ERROR(EINVAL));
if (zsb->z_version < ZPL_VERSION_USERSPACE)
- return (ENOTSUP);
+ return (SET_ERROR(ENOTSUP));
objp = (type == ZFS_PROP_USERQUOTA) ? &zsb->z_userquota_obj :
&zsb->z_groupquota_obj;
"on a version %lld pool\n. Pool must be upgraded to mount "
"this file system.", (u_longlong_t)zsb->z_version,
(u_longlong_t)spa_version(dmu_objset_spa(os)));
- error = ENOTSUP;
+ error = SET_ERROR(ENOTSUP);
goto out;
}
if ((error = zfs_get_zplprop(os, ZFS_PROP_NORMALIZE, &zval)) != 0)
goto out;
zsb->z_case = (uint_t)zval;
+ if ((error = zfs_get_zplprop(os, ZFS_PROP_ACLTYPE, &zval)) != 0)
+ goto out;
+ zsb->z_acl_type = (uint_t)zval;
+
/*
* Fold case on file systems that are always or sometimes case
* insensitive.
mutex_init(&zsb->z_lock, NULL, MUTEX_DEFAULT, NULL);
list_create(&zsb->z_all_znodes, sizeof (znode_t),
offsetof(znode_t, z_link_node));
- rrw_init(&zsb->z_teardown_lock);
+ rrw_init(&zsb->z_teardown_lock, B_FALSE);
rw_init(&zsb->z_teardown_inactive_lock, NULL, RW_DEFAULT, NULL);
rw_init(&zsb->z_fuid_lock, NULL, RW_DEFAULT, NULL);
for (i = 0; i != ZFS_OBJ_MTX_SZ; i++)
VERIFY(dsl_prop_unregister(ds, "atime", atime_changed_cb,
zsb) == 0);
+ VERIFY(dsl_prop_unregister(ds, "relatime", relatime_changed_cb,
+ zsb) == 0);
+
VERIFY(dsl_prop_unregister(ds, "xattr", xattr_changed_cb,
zsb) == 0);
VERIFY(dsl_prop_unregister(ds, "snapdir", snapdir_changed_cb,
zsb) == 0);
+ VERIFY(dsl_prop_unregister(ds, "acltype", acltype_changed_cb,
+ zsb) == 0);
+
VERIFY(dsl_prop_unregister(ds, "aclinherit",
acl_inherit_changed_cb, zsb) == 0);
#ifdef HAVE_MLSLABEL
/*
- * zfs_check_global_label:
- * Check that the hex label string is appropriate for the dataset
- * being mounted into the global_zone proper.
+ * Check that the hex label string is appropriate for the dataset being
+ * mounted into the global_zone proper.
*
- * Return an error if the hex label string is not default or
- * admin_low/admin_high. For admin_low labels, the corresponding
- * dataset must be readonly.
+ * Return an error if the hex label string is not default or
+ * admin_low/admin_high. For admin_low labels, the corresponding
+ * dataset must be readonly.
*/
int
zfs_check_global_label(const char *dsname, const char *hexsl)
if (dsl_prop_get_integer(dsname,
zfs_prop_to_name(ZFS_PROP_READONLY), &rdonly, NULL))
- return (EACCES);
+ return (SET_ERROR(EACCES));
return (rdonly ? 0 : EACCES);
}
- return (EACCES);
+ return (SET_ERROR(EACCES));
}
EXPORT_SYMBOL(zfs_check_global_label);
#endif /* HAVE_MLSLABEL */
{
znode_t *zp;
+ /*
+ * If someone has not already unmounted this file system,
+ * drain the iput_taskq to ensure all active references to the
+ * zfs_sb_t have been handled only then can it be safely destroyed.
+ */
+ if (zsb->z_os)
+ taskq_wait(dsl_pool_iput_taskq(dmu_objset_pool(zsb->z_os)));
+
rrw_enter(&zsb->z_teardown_lock, RW_WRITER, FTAG);
if (!unmounting) {
shrink_dcache_sb(zsb->z_parent->z_sb);
}
- /*
- * If someone has not already unmounted this file system,
- * drain the iput_taskq to ensure all active references to the
- * zfs_sb_t have been handled only then can it be safely destroyed.
- */
- if (zsb->z_os)
- taskq_wait(dsl_pool_iput_taskq(dmu_objset_pool(zsb->z_os)));
-
/*
* Close the zil. NB: Can't close the zil while zfs_inactive
* threads are blocked as zil_close can call zfs_inactive.
if (!unmounting && (zsb->z_unmounted || zsb->z_os == NULL)) {
rw_exit(&zsb->z_teardown_inactive_lock);
rrw_exit(&zsb->z_teardown_lock, FTAG);
- return (EIO);
+ return (SET_ERROR(EIO));
}
/*
mutex_enter(&zsb->z_znodes_lock);
for (zp = list_head(&zsb->z_all_znodes); zp != NULL;
zp = list_next(&zsb->z_all_znodes, zp)) {
- if (zp->z_sa_hdl) {
- ASSERT(atomic_read(&ZTOI(zp)->i_count) > 0);
+ if (zp->z_sa_hdl)
zfs_znode_dmu_fini(zp);
- }
}
mutex_exit(&zsb->z_znodes_lock);
if (dsl_dataset_is_dirty(dmu_objset_ds(zsb->z_os)) &&
!zfs_is_readonly(zsb))
txg_wait_synced(dmu_objset_pool(zsb->z_os), 0);
- (void) dmu_objset_evict_dbufs(zsb->z_os);
+ dmu_objset_evict_dbufs(zsb->z_os);
return (0);
}
atime_changed_cb(zsb, B_FALSE);
readonly_changed_cb(zsb, B_TRUE);
- if ((error = dsl_prop_get_integer(osname,"xattr",&pval,NULL)))
+ if ((error = dsl_prop_get_integer(osname,
+ "xattr", &pval, NULL)))
goto out;
xattr_changed_cb(zsb, pval);
+ if ((error = dsl_prop_get_integer(osname,
+ "acltype", &pval, NULL)))
+ goto out;
+ acltype_changed_cb(zsb, pval);
zsb->z_issnap = B_TRUE;
zsb->z_os->os_sync = ZFS_SYNC_DISABLED;
sb->s_root = d_make_root(root_inode);
if (sb->s_root == NULL) {
(void) zfs_umount(sb);
- error = ENOMEM;
+ error = SET_ERROR(ENOMEM);
goto out;
}
err = zfsctl_lookup_objset(sb, objsetid, &zsb);
if (err)
- return (EINVAL);
+ return (SET_ERROR(EINVAL));
ZFS_ENTER(zsb);
}
fid_gen |= ((uint64_t)zfid->zf_gen[i]) << (8 * i);
} else {
ZFS_EXIT(zsb);
- return (EINVAL);
+ return (SET_ERROR(EINVAL));
}
/* A zero fid_gen means we are in the .zfs control directories */
dprintf("znode gen (%u) != fid gen (%u)\n", zp_gen, fid_gen);
iput(ZTOI(zp));
ZFS_EXIT(zsb);
- return (EINVAL);
+ return (SET_ERROR(EINVAL));
}
*ipp = ZTOI(zp);
* Block out VFS ops and close zfs_sb_t
*
* Note, if successful, then we return with the 'z_teardown_lock' and
- * 'z_teardown_inactive_lock' write held.
+ * 'z_teardown_inactive_lock' write held. We leave ownership of the underlying
+ * dataset and objset intact so that they can be atomically handed off during
+ * a subsequent rollback or recv operation and the resume thereafter.
*/
int
zfs_suspend_fs(zfs_sb_t *zsb)
if ((error = zfs_sb_teardown(zsb, B_FALSE)) != 0)
return (error);
- dmu_objset_disown(zsb->z_os, zsb);
-
return (0);
}
EXPORT_SYMBOL(zfs_suspend_fs);
zfs_resume_fs(zfs_sb_t *zsb, const char *osname)
{
int err, err2;
+ znode_t *zp;
+ uint64_t sa_obj = 0;
ASSERT(RRW_WRITE_HELD(&zsb->z_teardown_lock));
ASSERT(RW_WRITE_HELD(&zsb->z_teardown_inactive_lock));
- err = dmu_objset_own(osname, DMU_OST_ZFS, B_FALSE, zsb, &zsb->z_os);
- if (err) {
- zsb->z_os = NULL;
- } else {
- znode_t *zp;
- uint64_t sa_obj = 0;
+ /*
+ * We already own this, so just hold and rele it to update the
+ * objset_t, as the one we had before may have been evicted.
+ */
+ VERIFY0(dmu_objset_hold(osname, zsb, &zsb->z_os));
+ VERIFY3P(zsb->z_os->os_dsl_dataset->ds_owner, ==, zsb);
+ VERIFY(dsl_dataset_long_held(zsb->z_os->os_dsl_dataset));
+ dmu_objset_rele(zsb->z_os, zsb);
- err2 = zap_lookup(zsb->z_os, MASTER_NODE_OBJ,
- ZFS_SA_ATTRS, 8, 1, &sa_obj);
+ /*
+ * Make sure version hasn't changed
+ */
- if ((err || err2) && zsb->z_version >= ZPL_VERSION_SA)
- goto bail;
+ err = zfs_get_zplprop(zsb->z_os, ZFS_PROP_VERSION,
+ &zsb->z_version);
+ if (err)
+ goto bail;
- if ((err = sa_setup(zsb->z_os, sa_obj,
- zfs_attr_table, ZPL_END, &zsb->z_attr_table)) != 0)
- goto bail;
+ err = zap_lookup(zsb->z_os, MASTER_NODE_OBJ,
+ ZFS_SA_ATTRS, 8, 1, &sa_obj);
- VERIFY(zfs_sb_setup(zsb, B_FALSE) == 0);
- zsb->z_rollback_time = jiffies;
+ if (err && zsb->z_version >= ZPL_VERSION_SA)
+ goto bail;
- /*
- * Attempt to re-establish all the active inodes with their
- * dbufs. If a zfs_rezget() fails, then we unhash the inode
- * and mark it stale. This prevents a collision if a new
- * inode/object is created which must use the same inode
- * number. The stale inode will be be released when the
- * VFS prunes the dentry holding the remaining references
- * on the stale inode.
- */
- mutex_enter(&zsb->z_znodes_lock);
- for (zp = list_head(&zsb->z_all_znodes); zp;
- zp = list_next(&zsb->z_all_znodes, zp)) {
- err2 = zfs_rezget(zp);
- if (err2) {
- remove_inode_hash(ZTOI(zp));
- zp->z_is_stale = B_TRUE;
- }
+ if ((err = sa_setup(zsb->z_os, sa_obj,
+ zfs_attr_table, ZPL_END, &zsb->z_attr_table)) != 0)
+ goto bail;
+
+ if (zsb->z_version >= ZPL_VERSION_SA)
+ sa_register_update_callback(zsb->z_os,
+ zfs_sa_upgrade);
+
+ VERIFY(zfs_sb_setup(zsb, B_FALSE) == 0);
+
+ zfs_set_fuid_feature(zsb);
+ zsb->z_rollback_time = jiffies;
+
+ /*
+ * Attempt to re-establish all the active inodes with their
+ * dbufs. If a zfs_rezget() fails, then we unhash the inode
+ * and mark it stale. This prevents a collision if a new
+ * inode/object is created which must use the same inode
+ * number. The stale inode will be be released when the
+ * VFS prunes the dentry holding the remaining references
+ * on the stale inode.
+ */
+ mutex_enter(&zsb->z_znodes_lock);
+ for (zp = list_head(&zsb->z_all_znodes); zp;
+ zp = list_next(&zsb->z_all_znodes, zp)) {
+ err2 = zfs_rezget(zp);
+ if (err2) {
+ remove_inode_hash(ZTOI(zp));
+ zp->z_is_stale = B_TRUE;
}
- mutex_exit(&zsb->z_znodes_lock);
}
+ mutex_exit(&zsb->z_znodes_lock);
bail:
/* release the VFS ops */
if (err) {
/*
- * Since we couldn't reopen zfs_sb_t or, setup the
- * sa framework, force unmount this file system.
+ * Since we couldn't setup the sa framework, try to force
+ * unmount this file system.
*/
if (zsb->z_os)
(void) zfs_umount(zsb->z_sb);
dmu_tx_t *tx;
if (newvers < ZPL_VERSION_INITIAL || newvers > ZPL_VERSION)
- return (EINVAL);
+ return (SET_ERROR(EINVAL));
if (newvers < zsb->z_version)
- return (EINVAL);
+ return (SET_ERROR(EINVAL));
if (zfs_spa_version_map(newvers) >
spa_version(dmu_objset_spa(zsb->z_os)))
- return (ENOTSUP);
+ return (SET_ERROR(ENOTSUP));
tx = dmu_tx_create(os);
dmu_tx_hold_zap(tx, MASTER_NODE_OBJ, B_FALSE, ZPL_VERSION_STR);
sa_register_update_callback(os, zfs_sa_upgrade);
}
- spa_history_log_internal(LOG_DS_UPGRADE,
- dmu_objset_spa(os), tx, "oldver=%llu newver=%llu dataset = %llu",
- zsb->z_version, newvers, dmu_objset_id(os));
+ spa_history_log_internal_ds(dmu_objset_ds(os), "upgrade", tx,
+ "from %llu to %llu", zsb->z_version, newvers);
dmu_tx_commit(tx);
zsb->z_version = newvers;
- if (zsb->z_version >= ZPL_VERSION_FUID)
- zfs_set_fuid_feature(zsb);
+ zfs_set_fuid_feature(zsb);
return (0);
}
zfs_get_zplprop(objset_t *os, zfs_prop_t prop, uint64_t *value)
{
const char *pname;
- int error = ENOENT;
+ int error = SET_ERROR(ENOENT);
/*
* Look up the file system's value for the property. For the
case ZFS_PROP_CASE:
*value = ZFS_CASE_SENSITIVE;
break;
+ case ZFS_PROP_ACLTYPE:
+ *value = ZFS_ACLTYPE_OFF;
+ break;
default:
return (error);
}
void
zfs_fini(void)
{
+ taskq_wait(system_taskq);
unregister_filesystem(&zpl_fs_type);
zfs_znode_fini();
zfsctl_fini();
projects / mirror_zfs-debian.git / blobdiff