/*
* Concurrency: @dt is write locked.
*/
static int osd_object_create(const struct lu_env *env, struct dt_object *dt,
struct lu_attr *attr,
struct dt_allocation_hint *hint,
struct dt_object_format *dof,
struct thandle *th)
{
struct osd_thread_info *info = osd_oti_get(env);
struct lustre_mdt_attrs *lma = &info->oti_mdt_attrs;
struct zpl_direntry *zde = &info->oti_zde.lzd_reg;
const struct lu_fid *fid = lu_object_fid(&dt->do_lu);
struct osd_object *obj = osd_dt_obj(dt);
struct osd_device *osd = osd_obj2dev(obj);
char *buf = info->oti_str;
struct osd_thandle *oh;
dmu_buf_t *db = NULL;
uint64_t zapid, parent = 0;
int rc;
ENTRY;
/* concurrent create declarations should not see
* the object inconsistent (db, attr, etc).
* in regular cases acquisition should be cheap */
down_write(&obj->oo_guard);
if (unlikely(dt_object_exists(dt)))
GOTO(out, rc = -EEXIST);
LASSERT(osd_invariant(obj));
LASSERT(dof != NULL);
LASSERT(th != NULL);
oh = container_of0(th, struct osd_thandle, ot_super);
/*
* XXX missing: Quote handling.
*/
LASSERT(obj->oo_db == NULL);
/* to follow ZFS on-disk format we need
* to initialize parent dnode properly */
if (hint != NULL && hint->dah_parent != NULL &&
!dt_object_remote(hint->dah_parent))
parent = osd_dt_obj(hint->dah_parent)->oo_db->db_object;
/* we may fix some attributes, better do not change the source */
obj->oo_attr = *attr;
obj->oo_attr.la_valid |= LA_SIZE | LA_NLINK | LA_TYPE;
db = osd_create_type_f(dof->dof_type)(env, obj, &obj->oo_attr, oh);
if (IS_ERR(db)) {
rc = PTR_ERR(db);
db = NULL;
GOTO(out, rc);
}
zde->zde_pad = 0;
zde->zde_dnode = db->db_object;
zde->zde_type = IFTODT(attr->la_mode & S_IFMT);
zapid = osd_get_name_n_idx(env, osd, fid, buf, sizeof(info->oti_str));
rc = -zap_add(osd->od_os, zapid, buf, 8, 1, zde, oh->ot_tx);
if (rc)
GOTO(out, rc);
/* Now add in all of the "SA" attributes */
rc = -sa_handle_get(osd->od_os, db->db_object, NULL,
SA_HDL_PRIVATE, &obj->oo_sa_hdl);
if (rc)
GOTO(out, rc);
/* configure new osd object */
obj->oo_db = db;
parent = parent != 0 ? parent : zapid;
rc = __osd_attr_init(env, osd, obj->oo_sa_hdl, oh->ot_tx,
&obj->oo_attr, parent);
if (rc)
GOTO(out, rc);
/* XXX: oo_lma_flags */
obj->oo_dt.do_lu.lo_header->loh_attr |= obj->oo_attr.la_mode & S_IFMT;
smp_mb();
obj->oo_dt.do_lu.lo_header->loh_attr |= LOHA_EXISTS;
if (likely(!fid_is_acct(lu_object_fid(&obj->oo_dt.do_lu))))
/* no body operations for accounting objects */
obj->oo_dt.do_body_ops = &osd_body_ops;
rc = -nvlist_alloc(&obj->oo_sa_xattr, NV_UNIQUE_NAME, KM_SLEEP);
if (rc)
GOTO(out, rc);
/* initialize LMA */
lustre_lma_init(lma, lu_object_fid(&obj->oo_dt.do_lu), 0, 0);
lustre_lma_swab(lma);
rc = -nvlist_add_byte_array(obj->oo_sa_xattr, XATTR_NAME_LMA,
(uchar_t *)lma, sizeof(*lma));
if (rc)
GOTO(out, rc);
rc = __osd_sa_xattr_update(env, obj, oh);
if (rc)
GOTO(out, rc);
/* Add new object to inode accounting.
* Errors are not considered as fatal */
rc = -zap_increment_int(osd->od_os, osd->od_iusr_oid,
(attr->la_valid & LA_UID) ? attr->la_uid : 0, 1,
oh->ot_tx);
if (rc)
CERROR("%s: failed to add "DFID" to accounting ZAP for usr %d "
"(%d)\n", osd->od_svname, PFID(fid), attr->la_uid, rc);
rc = -zap_increment_int(osd->od_os, osd->od_igrp_oid,
(attr->la_valid & LA_GID) ? attr->la_gid : 0, 1,
oh->ot_tx);
if (rc)
CERROR("%s: failed to add "DFID" to accounting ZAP for grp %d "
"(%d)\n", osd->od_svname, PFID(fid), attr->la_gid, rc);
out:
if (unlikely(rc && db)) {
dmu_object_free(osd->od_os, db->db_object, oh->ot_tx);
sa_buf_rele(db, osd_obj_tag);
obj->oo_db = NULL;
}
up_write(&obj->oo_guard);
RETURN(rc);
}
/*
* sync out AVL trees to persistent storage.
*/
void
zfs_fuid_sync(zfsvfs_t *zfsvfs, dmu_tx_t *tx)
{
nvlist_t *nvp;
nvlist_t **fuids;
size_t nvsize = 0;
char *packed;
dmu_buf_t *db;
fuid_domain_t *domnode;
int numnodes;
int i;
if (!zfsvfs->z_fuid_dirty) {
return;
}
rw_enter(&zfsvfs->z_fuid_lock, RW_WRITER);
/*
* First see if table needs to be created?
*/
if (zfsvfs->z_fuid_obj == 0) {
zfsvfs->z_fuid_obj = dmu_object_alloc(zfsvfs->z_os,
DMU_OT_FUID, 1 << 14, DMU_OT_FUID_SIZE,
sizeof (uint64_t), tx);
VERIFY(zap_add(zfsvfs->z_os, MASTER_NODE_OBJ,
ZFS_FUID_TABLES, sizeof (uint64_t), 1,
&zfsvfs->z_fuid_obj, tx) == 0);
}
VERIFY(nvlist_alloc(&nvp, NV_UNIQUE_NAME, KM_SLEEP) == 0);
numnodes = avl_numnodes(&zfsvfs->z_fuid_idx);
fuids = kmem_alloc(numnodes * sizeof (void *), KM_SLEEP);
for (i = 0, domnode = avl_first(&zfsvfs->z_fuid_domain); domnode; i++,
domnode = AVL_NEXT(&zfsvfs->z_fuid_domain, domnode)) {
VERIFY(nvlist_alloc(&fuids[i], NV_UNIQUE_NAME, KM_SLEEP) == 0);
VERIFY(nvlist_add_uint64(fuids[i], FUID_IDX,
domnode->f_idx) == 0);
VERIFY(nvlist_add_uint64(fuids[i], FUID_OFFSET, 0) == 0);
VERIFY(nvlist_add_string(fuids[i], FUID_DOMAIN,
domnode->f_ksid->kd_name) == 0);
}
VERIFY(nvlist_add_nvlist_array(nvp, FUID_NVP_ARRAY,
fuids, numnodes) == 0);
for (i = 0; i != numnodes; i++)
nvlist_free(fuids[i]);
kmem_free(fuids, numnodes * sizeof (void *));
VERIFY(nvlist_size(nvp, &nvsize, NV_ENCODE_XDR) == 0);
packed = kmem_alloc(nvsize, KM_SLEEP);
VERIFY(nvlist_pack(nvp, &packed, &nvsize,
NV_ENCODE_XDR, KM_SLEEP) == 0);
nvlist_free(nvp);
zfsvfs->z_fuid_size = nvsize;
dmu_write(zfsvfs->z_os, zfsvfs->z_fuid_obj, 0,
zfsvfs->z_fuid_size, packed, tx);
kmem_free(packed, zfsvfs->z_fuid_size);
VERIFY(0 == dmu_bonus_hold(zfsvfs->z_os, zfsvfs->z_fuid_obj,
FTAG, &db));
dmu_buf_will_dirty(db, tx);
*(uint64_t *)db->db_data = zfsvfs->z_fuid_size;
dmu_buf_rele(db, FTAG);
zfsvfs->z_fuid_dirty = B_FALSE;
rw_exit(&zfsvfs->z_fuid_lock);
}
dsl_pool_t *
dsl_pool_create(spa_t *spa, nvlist_t *zplprops, uint64_t txg)
{
int err;
dsl_pool_t *dp = dsl_pool_open_impl(spa, txg);
dmu_tx_t *tx = dmu_tx_create_assigned(dp, txg);
objset_t *os;
dsl_dataset_t *ds;
uint64_t obj;
rrw_enter(&dp->dp_config_rwlock, RW_WRITER, FTAG);
/* create and open the MOS (meta-objset) */
dp->dp_meta_objset = dmu_objset_create_impl(spa,
NULL, &dp->dp_meta_rootbp, DMU_OST_META, tx);
/* create the pool directory */
err = zap_create_claim(dp->dp_meta_objset, DMU_POOL_DIRECTORY_OBJECT,
DMU_OT_OBJECT_DIRECTORY, DMU_OT_NONE, 0, tx);
ASSERT0(err);
/* Initialize scan structures */
VERIFY0(dsl_scan_init(dp, txg));
/* create and open the root dir */
dp->dp_root_dir_obj = dsl_dir_create_sync(dp, NULL, NULL, tx);
VERIFY0(dsl_dir_hold_obj(dp, dp->dp_root_dir_obj,
NULL, dp, &dp->dp_root_dir));
/* create and open the meta-objset dir */
(void) dsl_dir_create_sync(dp, dp->dp_root_dir, MOS_DIR_NAME, tx);
VERIFY0(dsl_pool_open_special_dir(dp,
MOS_DIR_NAME, &dp->dp_mos_dir));
if (spa_version(spa) >= SPA_VERSION_DEADLISTS) {
/* create and open the free dir */
(void) dsl_dir_create_sync(dp, dp->dp_root_dir,
FREE_DIR_NAME, tx);
VERIFY0(dsl_pool_open_special_dir(dp,
FREE_DIR_NAME, &dp->dp_free_dir));
/* create and open the free_bplist */
obj = bpobj_alloc(dp->dp_meta_objset, SPA_OLD_MAXBLOCKSIZE, tx);
VERIFY(zap_add(dp->dp_meta_objset, DMU_POOL_DIRECTORY_OBJECT,
DMU_POOL_FREE_BPOBJ, sizeof (uint64_t), 1, &obj, tx) == 0);
VERIFY0(bpobj_open(&dp->dp_free_bpobj,
dp->dp_meta_objset, obj));
}
if (spa_version(spa) >= SPA_VERSION_DSL_SCRUB)
dsl_pool_create_origin(dp, tx);
/* create the root dataset */
obj = dsl_dataset_create_sync_dd(dp->dp_root_dir, NULL, 0, tx);
/* create the root objset */
VERIFY0(dsl_dataset_hold_obj(dp, obj, FTAG, &ds));
VERIFY(NULL != (os = dmu_objset_create_impl(dp->dp_spa, ds,
dsl_dataset_get_blkptr(ds), DMU_OST_ZFS, tx)));
#ifdef _KERNEL
zfs_create_fs(os, kcred, zplprops, tx);
#endif
dsl_dataset_rele(ds, FTAG);
dmu_tx_commit(tx);
rrw_exit(&dp->dp_config_rwlock, FTAG);
return (dp);
}
ddt_object_create(ddt_t *ddt, enum ddt_type type, enum ddt_class class,
dmu_tx_t *tx)
{
spa_t *spa = ddt->ddt_spa;
objset_t *os = ddt->ddt_os;
uint64_t *objectp = &ddt->ddt_object[type][class];
boolean_t prehash = zio_checksum_table[ddt->ddt_checksum].ci_dedup;
char name[DDT_NAMELEN];
ddt_object_name(ddt, type, class, name);
ASSERT(*objectp == 0);
VERIFY(ddt_ops[type]->ddt_op_create(os, objectp, tx, prehash) == 0);
ASSERT(*objectp != 0);
VERIFY(zap_add(os, DMU_POOL_DIRECTORY_OBJECT, name,
sizeof (uint64_t), 1, objectp, tx) == 0);
VERIFY(zap_add(os, spa->spa_ddt_stat_object, name,
sizeof (uint64_t), sizeof (ddt_histogram_t) / sizeof (uint64_t),
&ddt->ddt_histogram[type][class], tx) == 0);
}
static void
ddt_object_destroy(ddt_t *ddt, enum ddt_type type, enum ddt_class class,
dmu_tx_t *tx)
{
spa_t *spa = ddt->ddt_spa;
objset_t *os = ddt->ddt_os;
uint64_t *objectp = &ddt->ddt_object[type][class];
char name[DDT_NAMELEN];
/*
* Link zp into dl. Can only fail if zp has been unlinked.
*/
int
zfs_link_create(zfs_dirlock_t *dl, znode_t *zp, dmu_tx_t *tx, int flag)
{
znode_t *dzp = dl->dl_dzp;
zfs_sb_t *zsb = ZTOZSB(zp);
uint64_t value;
int zp_is_dir = S_ISDIR(ZTOI(zp)->i_mode);
sa_bulk_attr_t bulk[5];
uint64_t mtime[2], ctime[2];
int count = 0;
int error;
mutex_enter(&zp->z_lock);
if (!(flag & ZRENAMING)) {
if (zp->z_unlinked) { /* no new links to unlinked zp */
ASSERT(!(flag & (ZNEW | ZEXISTS)));
mutex_exit(&zp->z_lock);
return (SET_ERROR(ENOENT));
}
zp->z_links++;
SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_LINKS(zsb), NULL,
&zp->z_links, sizeof (zp->z_links));
}
SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_PARENT(zsb), NULL,
&dzp->z_id, sizeof (dzp->z_id));
SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_FLAGS(zsb), NULL,
&zp->z_pflags, sizeof (zp->z_pflags));
if (!(flag & ZNEW)) {
SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_CTIME(zsb), NULL,
ctime, sizeof (ctime));
zfs_tstamp_update_setup(zp, STATE_CHANGED, mtime,
ctime, B_TRUE);
}
error = sa_bulk_update(zp->z_sa_hdl, bulk, count, tx);
ASSERT(error == 0);
mutex_exit(&zp->z_lock);
mutex_enter(&dzp->z_lock);
dzp->z_size++;
dzp->z_links += zp_is_dir;
count = 0;
SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_SIZE(zsb), NULL,
&dzp->z_size, sizeof (dzp->z_size));
SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_LINKS(zsb), NULL,
&dzp->z_links, sizeof (dzp->z_links));
SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_MTIME(zsb), NULL,
mtime, sizeof (mtime));
SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_CTIME(zsb), NULL,
ctime, sizeof (ctime));
SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_FLAGS(zsb), NULL,
&dzp->z_pflags, sizeof (dzp->z_pflags));
zfs_tstamp_update_setup(dzp, CONTENT_MODIFIED, mtime, ctime, B_TRUE);
error = sa_bulk_update(dzp->z_sa_hdl, bulk, count, tx);
ASSERT(error == 0);
mutex_exit(&dzp->z_lock);
value = zfs_dirent(zp, zp->z_mode);
error = zap_add(ZTOZSB(zp)->z_os, dzp->z_id, dl->dl_name,
8, 1, &value, tx);
ASSERT(error == 0);
return (0);
}
/*
* Concurrency: @dt is write locked.
*/
static int osd_object_create(const struct lu_env *env, struct dt_object *dt,
struct lu_attr *attr,
struct dt_allocation_hint *hint,
struct dt_object_format *dof,
struct thandle *th)
{
struct zpl_direntry *zde = &osd_oti_get(env)->oti_zde.lzd_reg;
const struct lu_fid *fid = lu_object_fid(&dt->do_lu);
struct osd_object *obj = osd_dt_obj(dt);
struct osd_device *osd = osd_obj2dev(obj);
char *buf = osd_oti_get(env)->oti_str;
struct osd_thandle *oh;
dmu_buf_t *db;
uint64_t zapid;
int rc;
ENTRY;
/* concurrent create declarations should not see
* the object inconsistent (db, attr, etc).
* in regular cases acquisition should be cheap */
down_write(&obj->oo_guard);
if (unlikely(dt_object_exists(dt)))
GOTO(out, rc = -EEXIST);
LASSERT(osd_invariant(obj));
LASSERT(dof != NULL);
LASSERT(th != NULL);
oh = container_of0(th, struct osd_thandle, ot_super);
/*
* XXX missing: Quote handling.
*/
LASSERT(obj->oo_db == NULL);
/* to follow ZFS on-disk format we need
* to initialize parent dnode properly */
zapid = 0;
if (hint != NULL && hint->dah_parent != NULL &&
!dt_object_remote(hint->dah_parent))
zapid = osd_dt_obj(hint->dah_parent)->oo_db->db_object;
db = osd_create_type_f(dof->dof_type)(env, obj, attr, zapid, oh);
if (IS_ERR(db))
GOTO(out, rc = PTR_ERR(db));
zde->zde_pad = 0;
zde->zde_dnode = db->db_object;
zde->zde_type = IFTODT(attr->la_mode & S_IFMT);
zapid = osd_get_name_n_idx(env, osd, fid, buf);
rc = -zap_add(osd->od_os, zapid, buf, 8, 1, zde, oh->ot_tx);
if (rc)
GOTO(out, rc);
/* Add new object to inode accounting.
* Errors are not considered as fatal */
rc = -zap_increment_int(osd->od_os, osd->od_iusr_oid,
(attr->la_valid & LA_UID) ? attr->la_uid : 0, 1,
oh->ot_tx);
if (rc)
CERROR("%s: failed to add "DFID" to accounting ZAP for usr %d "
"(%d)\n", osd->od_svname, PFID(fid), attr->la_uid, rc);
rc = -zap_increment_int(osd->od_os, osd->od_igrp_oid,
(attr->la_valid & LA_GID) ? attr->la_gid : 0, 1,
oh->ot_tx);
if (rc)
CERROR("%s: failed to add "DFID" to accounting ZAP for grp %d "
"(%d)\n", osd->od_svname, PFID(fid), attr->la_gid, rc);
/* configure new osd object */
obj->oo_db = db;
rc = osd_object_init0(env, obj);
LASSERT(ergo(rc == 0, dt_object_exists(dt)));
LASSERT(osd_invariant(obj));
rc = osd_init_lma(env, obj, fid, oh);
if (rc != 0)
CERROR("%s: can not set LMA on "DFID": rc = %d\n",
osd->od_svname, PFID(fid), rc);
out:
up_write(&obj->oo_guard);
RETURN(rc);
}
/**
* Inserts (key, value) pair in \a directory object.
*
* \param dt osd index object
* \param key key for index
* \param rec record reference
* \param th transaction handler
* \param capa capability descriptor
* \param ignore_quota update should not affect quota
*
* \retval 0 success
* \retval -ve failure
*/
static int osd_dir_insert(const struct lu_env *env, struct dt_object *dt,
const struct dt_rec *rec, const struct dt_key *key,
struct thandle *th, struct lustre_capa *capa,
int ignore_quota)
{
struct osd_thread_info *oti = osd_oti_get(env);
struct osd_object *parent = osd_dt_obj(dt);
struct osd_device *osd = osd_obj2dev(parent);
struct lu_fid *fid = (struct lu_fid *)rec;
struct osd_thandle *oh;
struct osd_object *child = NULL;
__u32 attr;
char *name = (char *)key;
int rc;
ENTRY;
LASSERT(parent->oo_db);
LASSERT(udmu_object_is_zap(parent->oo_db));
LASSERT(dt_object_exists(dt));
LASSERT(osd_invariant(parent));
LASSERT(th != NULL);
oh = container_of0(th, struct osd_thandle, ot_super);
rc = osd_remote_fid(env, osd, fid);
if (rc < 0) {
CERROR("%s: Can not find object "DFID": rc = %d\n",
osd->od_svname, PFID(fid), rc);
RETURN(rc);
}
if (unlikely(rc == 1)) {
/* Insert remote entry */
memset(&oti->oti_zde.lzd_reg, 0, sizeof(oti->oti_zde.lzd_reg));
oti->oti_zde.lzd_reg.zde_type = IFTODT(S_IFDIR & S_IFMT);
} else {
/*
* To simulate old Orion setups with ./.. stored in the
* directories
*/
/* Insert local entry */
child = osd_object_find(env, dt, fid);
if (IS_ERR(child))
RETURN(PTR_ERR(child));
LASSERT(child->oo_db);
if (name[0] == '.') {
if (name[1] == 0) {
/* do not store ".", instead generate it
* during iteration */
GOTO(out, rc = 0);
} else if (name[1] == '.' && name[2] == 0) {
/* update parent dnode in the child.
* later it will be used to generate ".." */
udmu_objset_t *uos = &osd->od_objset;
rc = osd_object_sa_update(parent,
SA_ZPL_PARENT(uos),
&child->oo_db->db_object,
8, oh);
GOTO(out, rc);
}
}
CLASSERT(sizeof(oti->oti_zde.lzd_reg) == 8);
CLASSERT(sizeof(oti->oti_zde) % 8 == 0);
attr = child->oo_dt.do_lu.lo_header ->loh_attr;
oti->oti_zde.lzd_reg.zde_type = IFTODT(attr & S_IFMT);
oti->oti_zde.lzd_reg.zde_dnode = child->oo_db->db_object;
}
oti->oti_zde.lzd_fid = *fid;
/* Insert (key,oid) into ZAP */
rc = -zap_add(osd->od_objset.os, parent->oo_db->db_object,
(char *)key, 8, sizeof(oti->oti_zde) / 8,
(void *)&oti->oti_zde, oh->ot_tx);
out:
if (child != NULL)
osd_object_put(env, child);
RETURN(rc);
}
int
__osd_xattr_set(const struct lu_env *env, struct osd_object *obj,
const struct lu_buf *buf, const char *name, int fl,
struct osd_thandle *oh)
{
struct osd_device *osd = osd_obj2dev(obj);
udmu_objset_t *uos = &osd->od_objset;
dmu_buf_t *xa_zap_db = NULL;
dmu_buf_t *xa_data_db = NULL;
uint64_t xa_data_obj;
sa_handle_t *sa_hdl = NULL;
dmu_tx_t *tx = oh->ot_tx;
uint64_t size;
int rc;
LASSERT(obj->oo_sa_hdl);
if (obj->oo_xattr == ZFS_NO_OBJECT) {
struct lu_attr *la = &osd_oti_get(env)->oti_la;
la->la_valid = LA_MODE;
la->la_mode = S_IFDIR | S_IRUGO | S_IWUSR | S_IXUGO;
rc = __osd_zap_create(env, uos, &xa_zap_db, tx, la,
obj->oo_db->db_object, FTAG, 0);
if (rc)
return rc;
obj->oo_xattr = xa_zap_db->db_object;
rc = osd_object_sa_update(obj, SA_ZPL_XATTR(uos),
&obj->oo_xattr, 8, oh);
if (rc)
goto out;
}
rc = -zap_lookup(uos->os, obj->oo_xattr, name, sizeof(uint64_t), 1,
&xa_data_obj);
if (rc == 0) {
if (fl & LU_XATTR_CREATE) {
rc = -EEXIST;
goto out;
}
/*
* Entry already exists.
* We'll truncate the existing object.
*/
rc = __osd_obj2dbuf(env, uos->os, xa_data_obj,
&xa_data_db, FTAG);
if (rc)
goto out;
rc = -sa_handle_get(uos->os, xa_data_obj, NULL,
SA_HDL_PRIVATE, &sa_hdl);
if (rc)
goto out;
rc = -sa_lookup(sa_hdl, SA_ZPL_SIZE(uos), &size, 8);
if (rc)
goto out_sa;
rc = -dmu_free_range(uos->os, xa_data_db->db_object,
0, DMU_OBJECT_END, tx);
if (rc)
goto out_sa;
} else if (rc == -ENOENT) {
struct lu_attr *la = &osd_oti_get(env)->oti_la;
/*
* Entry doesn't exist, we need to create a new one and a new
* object to store the value.
*/
if (fl & LU_XATTR_REPLACE) {
/* should be ENOATTR according to the
* man, but that is undefined here */
rc = -ENODATA;
goto out;
}
la->la_valid = LA_MODE;
la->la_mode = S_IFREG | S_IRUGO | S_IWUSR;
rc = __osd_object_create(env, uos, &xa_data_db, tx, la,
obj->oo_xattr, FTAG);
if (rc)
goto out;
xa_data_obj = xa_data_db->db_object;
rc = -sa_handle_get(uos->os, xa_data_obj, NULL,
SA_HDL_PRIVATE, &sa_hdl);
if (rc)
goto out;
rc = -zap_add(uos->os, obj->oo_xattr, name, sizeof(uint64_t),
1, &xa_data_obj, tx);
if (rc)
goto out_sa;
} else {
/* There was an error looking up the xattr name */
goto out;
}
/* Finally write the xattr value */
dmu_write(uos->os, xa_data_obj, 0, buf->lb_len, buf->lb_buf, tx);
size = buf->lb_len;
rc = -sa_update(sa_hdl, SA_ZPL_SIZE(uos), &size, 8, tx);
out_sa:
sa_handle_destroy(sa_hdl);
out:
if (xa_data_db != NULL)
dmu_buf_rele(xa_data_db, FTAG);
if (xa_zap_db != NULL)
dmu_buf_rele(xa_zap_db, FTAG);
return rc;
}
static void
dsl_bookmark_create_sync(void *arg, dmu_tx_t *tx)
{
dsl_bookmark_create_arg_t *dbca = arg;
dsl_pool_t *dp = dmu_tx_pool(tx);
objset_t *mos = dp->dp_meta_objset;
nvpair_t *pair;
ASSERT(spa_feature_is_enabled(dp->dp_spa, SPA_FEATURE_BOOKMARKS));
for (pair = nvlist_next_nvpair(dbca->dbca_bmarks, NULL);
pair != NULL; pair = nvlist_next_nvpair(dbca->dbca_bmarks, pair)) {
dsl_dataset_t *snapds, *bmark_fs;
zfs_bookmark_phys_t bmark_phys = { 0 };
char *shortname;
uint32_t bmark_len = BOOKMARK_PHYS_SIZE_V1;
VERIFY0(dsl_dataset_hold(dp, fnvpair_value_string(pair),
FTAG, &snapds));
VERIFY0(dsl_bookmark_hold_ds(dp, nvpair_name(pair),
&bmark_fs, FTAG, &shortname));
if (bmark_fs->ds_bookmarks == 0) {
bmark_fs->ds_bookmarks =
zap_create_norm(mos, U8_TEXTPREP_TOUPPER,
DMU_OTN_ZAP_METADATA, DMU_OT_NONE, 0, tx);
spa_feature_incr(dp->dp_spa, SPA_FEATURE_BOOKMARKS, tx);
dsl_dataset_zapify(bmark_fs, tx);
VERIFY0(zap_add(mos, bmark_fs->ds_object,
DS_FIELD_BOOKMARK_NAMES,
sizeof (bmark_fs->ds_bookmarks), 1,
&bmark_fs->ds_bookmarks, tx));
}
bmark_phys.zbm_guid = dsl_dataset_phys(snapds)->ds_guid;
bmark_phys.zbm_creation_txg =
dsl_dataset_phys(snapds)->ds_creation_txg;
bmark_phys.zbm_creation_time =
dsl_dataset_phys(snapds)->ds_creation_time;
/*
* If the dataset is encrypted create a larger bookmark to
* accommodate the IVset guid. The IVset guid was added
* after the encryption feature to prevent a problem with
* raw sends. If we encounter an encrypted dataset without
* an IVset guid we fall back to a normal bookmark.
*/
if (snapds->ds_dir->dd_crypto_obj != 0 &&
spa_feature_is_enabled(dp->dp_spa,
SPA_FEATURE_BOOKMARK_V2)) {
int err = zap_lookup(mos, snapds->ds_object,
DS_FIELD_IVSET_GUID, sizeof (uint64_t), 1,
&bmark_phys.zbm_ivset_guid);
if (err == 0) {
bmark_len = BOOKMARK_PHYS_SIZE_V2;
spa_feature_incr(dp->dp_spa,
SPA_FEATURE_BOOKMARK_V2, tx);
}
}
VERIFY0(zap_add(mos, bmark_fs->ds_bookmarks,
shortname, sizeof (uint64_t),
bmark_len / sizeof (uint64_t), &bmark_phys, tx));
spa_history_log_internal_ds(bmark_fs, "bookmark", tx,
"name=%s creation_txg=%llu target_snap=%llu",
shortname,
(longlong_t)bmark_phys.zbm_creation_txg,
(longlong_t)snapds->ds_object);
dsl_dataset_rele(bmark_fs, FTAG);
dsl_dataset_rele(snapds, FTAG);
}
}
int
zfs_set_userquota(zfs_sb_t *zsb, zfs_userquota_prop_t type,
const char *domain, uint64_t rid, uint64_t quota)
{
char buf[32];
int err;
dmu_tx_t *tx;
uint64_t *objp;
boolean_t fuid_dirtied;
if (zsb->z_version < ZPL_VERSION_USERSPACE)
return (SET_ERROR(ENOTSUP));
switch (type) {
case ZFS_PROP_USERQUOTA:
objp = &zsb->z_userquota_obj;
break;
case ZFS_PROP_GROUPQUOTA:
objp = &zsb->z_groupquota_obj;
break;
case ZFS_PROP_USEROBJQUOTA:
objp = &zsb->z_userobjquota_obj;
break;
case ZFS_PROP_GROUPOBJQUOTA:
objp = &zsb->z_groupobjquota_obj;
break;
default:
return (SET_ERROR(EINVAL));
}
err = id_to_fuidstr(zsb, domain, rid, buf, B_TRUE);
if (err)
return (err);
fuid_dirtied = zsb->z_fuid_dirty;
tx = dmu_tx_create(zsb->z_os);
dmu_tx_hold_zap(tx, *objp ? *objp : DMU_NEW_OBJECT, B_TRUE, NULL);
if (*objp == 0) {
dmu_tx_hold_zap(tx, MASTER_NODE_OBJ, B_TRUE,
zfs_userquota_prop_prefixes[type]);
}
if (fuid_dirtied)
zfs_fuid_txhold(zsb, tx);
err = dmu_tx_assign(tx, TXG_WAIT);
if (err) {
dmu_tx_abort(tx);
return (err);
}
mutex_enter(&zsb->z_lock);
if (*objp == 0) {
*objp = zap_create(zsb->z_os, DMU_OT_USERGROUP_QUOTA,
DMU_OT_NONE, 0, tx);
VERIFY(0 == zap_add(zsb->z_os, MASTER_NODE_OBJ,
zfs_userquota_prop_prefixes[type], 8, 1, objp, tx));
}
mutex_exit(&zsb->z_lock);
if (quota == 0) {
err = zap_remove(zsb->z_os, *objp, buf, tx);
if (err == ENOENT)
err = 0;
} else {
err = zap_update(zsb->z_os, *objp, buf, 8, 1, "a, tx);
}
ASSERT(err == 0);
if (fuid_dirtied)
zfs_fuid_sync(zsb, tx);
dmu_tx_commit(tx);
return (err);
}
