int __osd_xattr_load(struct osd_device *osd, uint64_t dnode, nvlist_t **sa)
{
sa_handle_t *sa_hdl;
char *buf;
int rc, size;
if (unlikely(dnode == ZFS_NO_OBJECT))
return -ENOENT;
rc = -sa_handle_get(osd->od_os, dnode, NULL, SA_HDL_PRIVATE, &sa_hdl);
if (rc)
return rc;
rc = -sa_size(sa_hdl, SA_ZPL_DXATTR(osd), &size);
if (rc) {
if (rc == -ENOENT)
rc = -nvlist_alloc(sa, NV_UNIQUE_NAME, KM_SLEEP);
goto out_sa;
}
buf = osd_zio_buf_alloc(size);
if (buf == NULL) {
rc = -ENOMEM;
goto out_sa;
}
rc = -sa_lookup(sa_hdl, SA_ZPL_DXATTR(osd), buf, size);
if (rc == 0)
rc = -nvlist_unpack(buf, size, sa, KM_SLEEP);
osd_zio_buf_free(buf, size);
out_sa:
sa_handle_destroy(sa_hdl);
return rc;
}
/*
* Copy an extended attribute into the buffer provided, or compute the
* required buffer size.
*
* If buf is NULL, it computes the required buffer size.
*
* Returns 0 on success or a negative error number on failure.
* On success, the number of bytes used / required is stored in 'size'.
*
* No locking is done here.
*/
int __osd_xattr_load(udmu_objset_t *uos, uint64_t dnode, nvlist_t **sa_xattr)
{
sa_handle_t *sa_hdl;
char *buf;
int rc, size;
if (unlikely(dnode == ZFS_NO_OBJECT))
return -ENOENT;
rc = -sa_handle_get(uos->os, dnode, NULL, SA_HDL_PRIVATE, &sa_hdl);
if (rc)
return rc;
rc = -sa_size(sa_hdl, SA_ZPL_DXATTR(uos), &size);
if (rc) {
if (rc == -ENOENT)
rc = -nvlist_alloc(sa_xattr, NV_UNIQUE_NAME, KM_SLEEP);
goto out_sa;
}
buf = sa_spill_alloc(KM_SLEEP);
if (buf == NULL) {
rc = -ENOMEM;
goto out_sa;
}
rc = -sa_lookup(sa_hdl, SA_ZPL_DXATTR(uos), buf, size);
if (rc == 0)
rc = -nvlist_unpack(buf, size, sa_xattr, KM_SLEEP);
sa_spill_free(buf);
out_sa:
sa_handle_destroy(sa_hdl);
return rc;
}
int __osd_xattr_get_large(const struct lu_env *env, struct osd_device *osd,
uint64_t xattr, struct lu_buf *buf,
const char *name, int *sizep)
{
dmu_buf_t *xa_data_db;
sa_handle_t *sa_hdl = NULL;
uint64_t xa_data_obj, size;
int rc;
/* are there any extended attributes? */
if (xattr == ZFS_NO_OBJECT)
return -ENOENT;
/* Lookup the object number containing the xattr data */
rc = -zap_lookup(osd->od_os, xattr, name, sizeof(uint64_t), 1,
&xa_data_obj);
if (rc)
return rc;
rc = __osd_obj2dbuf(env, osd->od_os, xa_data_obj, &xa_data_db);
if (rc)
return rc;
rc = -sa_handle_get(osd->od_os, xa_data_obj, NULL, SA_HDL_PRIVATE,
&sa_hdl);
if (rc)
goto out_rele;
/* Get the xattr value length / object size */
rc = -sa_lookup(sa_hdl, SA_ZPL_SIZE(osd), &size, 8);
if (rc)
goto out;
if (size > INT_MAX) {
rc = -EOVERFLOW;
goto out;
}
*sizep = (int)size;
if (buf == NULL || buf->lb_buf == NULL) {
/* We only need to return the required size */
goto out;
}
if (*sizep > buf->lb_len) {
rc = -ERANGE; /* match ldiskfs error */
goto out;
}
rc = -dmu_read(osd->od_os, xa_data_db->db_object, 0,
size, buf->lb_buf, DMU_READ_PREFETCH);
out:
sa_handle_destroy(sa_hdl);
out_rele:
dmu_buf_rele(xa_data_db, FTAG);
return rc;
}
static void
osd_object_sa_fini(struct osd_object *obj)
{
if (obj->oo_sa_hdl) {
sa_handle_destroy(obj->oo_sa_hdl);
obj->oo_sa_hdl = NULL;
}
}
void
zfs_znode_dmu_fini(znode_t *zp)
{
ASSERT(MUTEX_HELD(ZFS_OBJ_MUTEX(ZTOZSB(zp), zp->z_id)) ||
zp->z_unlinked ||
RW_WRITE_HELD(&ZTOZSB(zp)->z_teardown_inactive_lock));
sa_handle_destroy(zp->z_sa_hdl);
zp->z_sa_hdl = NULL;
}
int
zfs_create_share_dir(zfs_sb_t *zsb, dmu_tx_t *tx)
{
#ifdef HAVE_SMB_SHARE
zfs_acl_ids_t acl_ids;
vattr_t vattr;
znode_t *sharezp;
vnode_t *vp;
znode_t *zp;
int error;
vattr.va_mask = AT_MODE|AT_UID|AT_GID|AT_TYPE;
vattr.va_mode = S_IFDIR | 0555;
vattr.va_uid = crgetuid(kcred);
vattr.va_gid = crgetgid(kcred);
sharezp = kmem_cache_alloc(znode_cache, KM_SLEEP);
sharezp->z_moved = 0;
sharezp->z_unlinked = 0;
sharezp->z_atime_dirty = 0;
sharezp->z_zfsvfs = zfsvfs;
sharezp->z_is_sa = zfsvfs->z_use_sa;
vp = ZTOV(sharezp);
vn_reinit(vp);
vp->v_type = VDIR;
VERIFY(0 == zfs_acl_ids_create(sharezp, IS_ROOT_NODE, &vattr,
kcred, NULL, &acl_ids));
zfs_mknode(sharezp, &vattr, tx, kcred, IS_ROOT_NODE, &zp, &acl_ids);
ASSERT3P(zp, ==, sharezp);
ASSERT(!vn_in_dnlc(ZTOV(sharezp))); /* not valid to move */
POINTER_INVALIDATE(&sharezp->z_zfsvfs);
error = zap_add(zfsvfs->z_os, MASTER_NODE_OBJ,
ZFS_SHARES_DIR, 8, 1, &sharezp->z_id, tx);
zfsvfs->z_shares_dir = sharezp->z_id;
zfs_acl_ids_free(&acl_ids);
// ZTOV(sharezp)->v_count = 0;
sa_handle_destroy(sharezp->z_sa_hdl);
kmem_cache_free(znode_cache, sharezp);
return (error);
#else
return (0);
#endif /* HAVE_SMB_SHARE */
}
/*
* Copy an extended attribute into the buffer provided, or compute the
* required buffer size.
*
* If buf is NULL, it computes the required buffer size.
*
* Returns 0 on success or a negative error number on failure.
* On success, the number of bytes used / required is stored in 'size'.
*
* No locking is done here.
*/
int __osd_xattr_cache(const struct lu_env *env, struct osd_object *obj)
{
struct osd_device *osd = osd_obj2dev(obj);
udmu_objset_t *uos = &osd->od_objset;
sa_handle_t *sa_hdl;
char *buf;
int size;
int rc;
LASSERT(obj->oo_sa_xattr == NULL);
LASSERT(obj->oo_db != NULL);
rc = -sa_handle_get(uos->os, obj->oo_db->db_object, NULL,
SA_HDL_PRIVATE, &sa_hdl);
if (rc)
return rc;
rc = -sa_size(sa_hdl, SA_ZPL_DXATTR(uos), &size);
if (rc) {
if (rc == -ENOENT)
rc = -nvlist_alloc(&obj->oo_sa_xattr,
NV_UNIQUE_NAME, KM_SLEEP);
goto out_sa;
}
buf = sa_spill_alloc(KM_SLEEP);
if (buf == NULL) {
rc = -ENOMEM;
goto out_sa;
}
rc = -sa_lookup(sa_hdl, SA_ZPL_DXATTR(uos), buf, size);
if (rc == 0)
rc = -nvlist_unpack(buf, size, &obj->oo_sa_xattr, KM_SLEEP);
sa_spill_free(buf);
out_sa:
sa_handle_destroy(sa_hdl);
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);
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, osd, &xa_zap_db, tx, la,
obj->oo_db->db_object, 0);
if (rc)
return rc;
obj->oo_xattr = xa_zap_db->db_object;
rc = osd_object_sa_update(obj, SA_ZPL_XATTR(osd),
&obj->oo_xattr, 8, oh);
if (rc)
goto out;
}
rc = -zap_lookup(osd->od_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, osd->od_os, xa_data_obj,
&xa_data_db);
if (rc)
goto out;
rc = -sa_handle_get(osd->od_os, xa_data_obj, NULL,
SA_HDL_PRIVATE, &sa_hdl);
if (rc)
goto out;
rc = -sa_lookup(sa_hdl, SA_ZPL_SIZE(osd), &size, 8);
if (rc)
goto out_sa;
rc = -dmu_free_range(osd->od_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, obj, &xa_data_db, tx, la,
obj->oo_xattr);
if (rc)
goto out;
xa_data_obj = xa_data_db->db_object;
rc = -sa_handle_get(osd->od_os, xa_data_obj, NULL,
SA_HDL_PRIVATE, &sa_hdl);
if (rc)
goto out;
rc = -zap_add(osd->od_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(osd->od_os, xa_data_obj, 0, buf->lb_len, buf->lb_buf, tx);
size = buf->lb_len;
rc = -sa_update(sa_hdl, SA_ZPL_SIZE(osd), &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;
}
/*
* Retrieve the attributes of a DMU object
*/
int __osd_object_attr_get(const struct lu_env *env, udmu_objset_t *uos,
struct osd_object *obj, struct lu_attr *la)
{
struct osa_attr *osa = &osd_oti_get(env)->oti_osa;
sa_handle_t *sa_hdl;
sa_bulk_attr_t *bulk;
int cnt = 0;
int rc;
ENTRY;
LASSERT(obj->oo_db != NULL);
rc = -sa_handle_get(uos->os, obj->oo_db->db_object, NULL,
SA_HDL_PRIVATE, &sa_hdl);
if (rc)
RETURN(rc);
OBD_ALLOC(bulk, sizeof(sa_bulk_attr_t) * 9);
if (bulk == NULL)
GOTO(out_sa, rc = -ENOMEM);
la->la_valid |= LA_ATIME | LA_MTIME | LA_CTIME | LA_MODE | LA_TYPE |
LA_SIZE | LA_UID | LA_GID | LA_FLAGS | LA_NLINK;
SA_ADD_BULK_ATTR(bulk, cnt, SA_ZPL_ATIME(uos), NULL, osa->atime, 16);
SA_ADD_BULK_ATTR(bulk, cnt, SA_ZPL_MTIME(uos), NULL, osa->mtime, 16);
SA_ADD_BULK_ATTR(bulk, cnt, SA_ZPL_CTIME(uos), NULL, osa->ctime, 16);
SA_ADD_BULK_ATTR(bulk, cnt, SA_ZPL_MODE(uos), NULL, &osa->mode, 8);
SA_ADD_BULK_ATTR(bulk, cnt, SA_ZPL_SIZE(uos), NULL, &osa->size, 8);
SA_ADD_BULK_ATTR(bulk, cnt, SA_ZPL_LINKS(uos), NULL, &osa->nlink, 8);
SA_ADD_BULK_ATTR(bulk, cnt, SA_ZPL_UID(uos), NULL, &osa->uid, 8);
SA_ADD_BULK_ATTR(bulk, cnt, SA_ZPL_GID(uos), NULL, &osa->gid, 8);
SA_ADD_BULK_ATTR(bulk, cnt, SA_ZPL_FLAGS(uos), NULL, &osa->flags, 8);
rc = -sa_bulk_lookup(sa_hdl, bulk, cnt);
if (rc)
GOTO(out_bulk, rc);
la->la_atime = osa->atime[0];
la->la_mtime = osa->mtime[0];
la->la_ctime = osa->ctime[0];
la->la_mode = osa->mode;
la->la_uid = osa->uid;
la->la_gid = osa->gid;
la->la_nlink = osa->nlink;
la->la_flags = osa->flags;
la->la_size = osa->size;
if (S_ISCHR(la->la_mode) || S_ISBLK(la->la_mode)) {
rc = -sa_lookup(sa_hdl, SA_ZPL_RDEV(uos), &osa->rdev, 8);
if (rc)
GOTO(out_bulk, rc);
la->la_rdev = osa->rdev;
la->la_valid |= LA_RDEV;
}
out_bulk:
OBD_FREE(bulk, sizeof(sa_bulk_attr_t) * 9);
out_sa:
sa_handle_destroy(sa_hdl);
RETURN(rc);
}
int __osd_attr_init(const struct lu_env *env, udmu_objset_t *uos,
uint64_t oid, dmu_tx_t *tx, struct lu_attr *la)
{
sa_bulk_attr_t *bulk;
sa_handle_t *sa_hdl;
struct osa_attr *osa = &osd_oti_get(env)->oti_osa;
uint64_t gen;
uint64_t parent;
uint64_t crtime[2];
timestruc_t now;
int cnt;
int rc;
gethrestime(&now);
gen = dmu_tx_get_txg(tx);
ZFS_TIME_ENCODE(&now, crtime);
/* XXX: this should be real id of parent for ZPL access, but we have no
* such info in OSD, probably it can be part of dt_object_format */
parent = 0;
osa->atime[0] = la->la_atime;
osa->ctime[0] = la->la_ctime;
osa->mtime[0] = la->la_mtime;
osa->mode = la->la_mode;
osa->uid = la->la_uid;
osa->gid = la->la_gid;
osa->rdev = la->la_rdev;
osa->nlink = la->la_nlink;
osa->flags = la->la_flags;
osa->size = la->la_size;
/* Now add in all of the "SA" attributes */
rc = -sa_handle_get(uos->os, oid, NULL, SA_HDL_PRIVATE, &sa_hdl);
if (rc)
return rc;
OBD_ALLOC(bulk, sizeof(sa_bulk_attr_t) * 13);
if (bulk == NULL) {
rc = -ENOMEM;
goto out;
}
/*
* we need to create all SA below upon object create.
*
* XXX The attribute order matters since the accounting callback relies
* on static offsets (i.e. SA_*_OFFSET, see zfs_space_delta_cb()) to
* look up the UID/GID attributes. Moreover, the callback does not seem
* to support the spill block.
* We define attributes in the same order as SA_*_OFFSET in order to
* work around the problem. See ORI-610.
*/
cnt = 0;
SA_ADD_BULK_ATTR(bulk, cnt, SA_ZPL_MODE(uos), NULL, &osa->mode, 8);
SA_ADD_BULK_ATTR(bulk, cnt, SA_ZPL_SIZE(uos), NULL, &osa->size, 8);
SA_ADD_BULK_ATTR(bulk, cnt, SA_ZPL_GEN(uos), NULL, &gen, 8);
SA_ADD_BULK_ATTR(bulk, cnt, SA_ZPL_UID(uos), NULL, &osa->uid, 8);
SA_ADD_BULK_ATTR(bulk, cnt, SA_ZPL_GID(uos), NULL, &osa->gid, 8);
SA_ADD_BULK_ATTR(bulk, cnt, SA_ZPL_PARENT(uos), NULL, &parent, 8);
SA_ADD_BULK_ATTR(bulk, cnt, SA_ZPL_FLAGS(uos), NULL, &osa->flags, 8);
SA_ADD_BULK_ATTR(bulk, cnt, SA_ZPL_ATIME(uos), NULL, osa->atime, 16);
SA_ADD_BULK_ATTR(bulk, cnt, SA_ZPL_MTIME(uos), NULL, osa->mtime, 16);
SA_ADD_BULK_ATTR(bulk, cnt, SA_ZPL_CTIME(uos), NULL, osa->ctime, 16);
SA_ADD_BULK_ATTR(bulk, cnt, SA_ZPL_CRTIME(uos), NULL, crtime, 16);
SA_ADD_BULK_ATTR(bulk, cnt, SA_ZPL_LINKS(uos), NULL, &osa->nlink, 8);
SA_ADD_BULK_ATTR(bulk, cnt, SA_ZPL_RDEV(uos), NULL, &osa->rdev, 8);
rc = -sa_replace_all_by_template(sa_hdl, bulk, cnt, tx);
OBD_FREE(bulk, sizeof(sa_bulk_attr_t) * 13);
out:
sa_handle_destroy(sa_hdl);
return rc;
}
/*
* Construct a znode+inode and initialize.
*
* This does not do a call to dmu_set_user() that is
* up to the caller to do, in case you don't want to
* return the znode
*/
static znode_t *
zfs_znode_alloc(zfs_sb_t *zsb, dmu_buf_t *db, int blksz,
dmu_object_type_t obj_type, uint64_t obj, sa_handle_t *hdl,
struct inode *dip)
{
znode_t *zp;
struct inode *ip;
uint64_t mode;
uint64_t parent;
sa_bulk_attr_t bulk[9];
int count = 0;
ASSERT(zsb != NULL);
ip = new_inode(zsb->z_sb);
if (ip == NULL)
return (NULL);
zp = ITOZ(ip);
ASSERT(zp->z_dirlocks == NULL);
ASSERT3P(zp->z_acl_cached, ==, NULL);
ASSERT3P(zp->z_xattr_cached, ==, NULL);
ASSERT3P(zp->z_xattr_parent, ==, NULL);
zp->z_moved = 0;
zp->z_sa_hdl = NULL;
zp->z_unlinked = 0;
zp->z_atime_dirty = 0;
zp->z_mapcnt = 0;
zp->z_id = db->db_object;
zp->z_blksz = blksz;
zp->z_seq = 0x7A4653;
zp->z_sync_cnt = 0;
zp->z_is_zvol = B_FALSE;
zp->z_is_mapped = B_FALSE;
zp->z_is_ctldir = B_FALSE;
zp->z_is_stale = B_FALSE;
zfs_znode_sa_init(zsb, zp, db, obj_type, hdl);
SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_MODE(zsb), NULL, &mode, 8);
SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_GEN(zsb), NULL, &zp->z_gen, 8);
SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_SIZE(zsb), NULL, &zp->z_size, 8);
SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_LINKS(zsb), NULL, &zp->z_links, 8);
SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_FLAGS(zsb), NULL,
&zp->z_pflags, 8);
SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_PARENT(zsb), NULL,
&parent, 8);
SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_ATIME(zsb), NULL,
&zp->z_atime, 16);
SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_UID(zsb), NULL, &zp->z_uid, 8);
SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_GID(zsb), NULL, &zp->z_gid, 8);
if (sa_bulk_lookup(zp->z_sa_hdl, bulk, count) != 0 || zp->z_gen == 0) {
if (hdl == NULL)
sa_handle_destroy(zp->z_sa_hdl);
goto error;
}
zp->z_mode = mode;
/*
* xattr znodes hold a reference on their unique parent
*/
if (dip && zp->z_pflags & ZFS_XATTR) {
igrab(dip);
zp->z_xattr_parent = ITOZ(dip);
}
ip->i_ino = obj;
zfs_inode_update(zp);
zfs_inode_set_ops(zsb, ip);
/*
* The only way insert_inode_locked() can fail is if the ip->i_ino
* number is already hashed for this super block. This can never
* happen because the inode numbers map 1:1 with the object numbers.
*
* The one exception is rolling back a mounted file system, but in
* this case all the active inode are unhashed during the rollback.
*/
VERIFY3S(insert_inode_locked(ip), ==, 0);
mutex_enter(&zsb->z_znodes_lock);
list_insert_tail(&zsb->z_all_znodes, zp);
zsb->z_nr_znodes++;
membar_producer();
mutex_exit(&zsb->z_znodes_lock);
unlock_new_inode(ip);
return (zp);
error:
unlock_new_inode(ip);
iput(ip);
return (NULL);
}
void
zfs_release_sa_handle(sa_handle_t *hdl, dmu_buf_t *db, void *tag)
{
sa_handle_destroy(hdl);
sa_buf_rele(db, tag);
}
void
zfs_create_fs(objset_t *os, cred_t *cr, nvlist_t *zplprops, dmu_tx_t *tx)
{
struct super_block *sb;
zfs_sb_t *zsb;
uint64_t moid, obj, sa_obj, version;
uint64_t sense = ZFS_CASE_SENSITIVE;
uint64_t norm = 0;
nvpair_t *elem;
int error;
int i;
znode_t *rootzp = NULL;
vattr_t vattr;
znode_t *zp;
zfs_acl_ids_t acl_ids;
/*
* First attempt to create master node.
*/
/*
* In an empty objset, there are no blocks to read and thus
* there can be no i/o errors (which we assert below).
*/
moid = MASTER_NODE_OBJ;
error = zap_create_claim(os, moid, DMU_OT_MASTER_NODE,
DMU_OT_NONE, 0, tx);
ASSERT(error == 0);
/*
* Set starting attributes.
*/
version = zfs_zpl_version_map(spa_version(dmu_objset_spa(os)));
elem = NULL;
while ((elem = nvlist_next_nvpair(zplprops, elem)) != NULL) {
/* For the moment we expect all zpl props to be uint64_ts */
uint64_t val;
char *name;
ASSERT(nvpair_type(elem) == DATA_TYPE_UINT64);
VERIFY(nvpair_value_uint64(elem, &val) == 0);
name = nvpair_name(elem);
if (strcmp(name, zfs_prop_to_name(ZFS_PROP_VERSION)) == 0) {
if (val < version)
version = val;
} else {
error = zap_update(os, moid, name, 8, 1, &val, tx);
}
ASSERT(error == 0);
if (strcmp(name, zfs_prop_to_name(ZFS_PROP_NORMALIZE)) == 0)
norm = val;
else if (strcmp(name, zfs_prop_to_name(ZFS_PROP_CASE)) == 0)
sense = val;
}
ASSERT(version != 0);
error = zap_update(os, moid, ZPL_VERSION_STR, 8, 1, &version, tx);
/*
* Create zap object used for SA attribute registration
*/
if (version >= ZPL_VERSION_SA) {
sa_obj = zap_create(os, DMU_OT_SA_MASTER_NODE,
DMU_OT_NONE, 0, tx);
error = zap_add(os, moid, ZFS_SA_ATTRS, 8, 1, &sa_obj, tx);
ASSERT(error == 0);
} else {
sa_obj = 0;
}
/*
* Create a delete queue.
*/
obj = zap_create(os, DMU_OT_UNLINKED_SET, DMU_OT_NONE, 0, tx);
error = zap_add(os, moid, ZFS_UNLINKED_SET, 8, 1, &obj, tx);
ASSERT(error == 0);
/*
* Create root znode. Create minimal znode/inode/zsb/sb
* to allow zfs_mknode to work.
*/
vattr.va_mask = ATTR_MODE|ATTR_UID|ATTR_GID;
vattr.va_mode = S_IFDIR|0755;
vattr.va_uid = crgetuid(cr);
vattr.va_gid = crgetgid(cr);
rootzp = kmem_cache_alloc(znode_cache, KM_PUSHPAGE);
rootzp->z_moved = 0;
rootzp->z_unlinked = 0;
rootzp->z_atime_dirty = 0;
rootzp->z_is_sa = USE_SA(version, os);
zsb = kmem_zalloc(sizeof (zfs_sb_t), KM_PUSHPAGE | KM_NODEBUG);
zsb->z_os = os;
zsb->z_parent = zsb;
zsb->z_version = version;
zsb->z_use_fuids = USE_FUIDS(version, os);
zsb->z_use_sa = USE_SA(version, os);
zsb->z_norm = norm;
sb = kmem_zalloc(sizeof (struct super_block), KM_PUSHPAGE);
sb->s_fs_info = zsb;
ZTOI(rootzp)->i_sb = sb;
error = sa_setup(os, sa_obj, zfs_attr_table, ZPL_END,
&zsb->z_attr_table);
ASSERT(error == 0);
/*
* Fold case on file systems that are always or sometimes case
* insensitive.
*/
if (sense == ZFS_CASE_INSENSITIVE || sense == ZFS_CASE_MIXED)
zsb->z_norm |= U8_TEXTPREP_TOUPPER;
mutex_init(&zsb->z_znodes_lock, NULL, MUTEX_DEFAULT, NULL);
list_create(&zsb->z_all_znodes, sizeof (znode_t),
offsetof(znode_t, z_link_node));
for (i = 0; i != ZFS_OBJ_MTX_SZ; i++)
mutex_init(&zsb->z_hold_mtx[i], NULL, MUTEX_DEFAULT, NULL);
VERIFY(0 == zfs_acl_ids_create(rootzp, IS_ROOT_NODE, &vattr,
cr, NULL, &acl_ids));
zfs_mknode(rootzp, &vattr, tx, cr, IS_ROOT_NODE, &zp, &acl_ids);
ASSERT3P(zp, ==, rootzp);
error = zap_add(os, moid, ZFS_ROOT_OBJ, 8, 1, &rootzp->z_id, tx);
ASSERT(error == 0);
zfs_acl_ids_free(&acl_ids);
atomic_set(&ZTOI(rootzp)->i_count, 0);
sa_handle_destroy(rootzp->z_sa_hdl);
kmem_cache_free(znode_cache, rootzp);
/*
* Create shares directory
*/
error = zfs_create_share_dir(zsb, tx);
ASSERT(error == 0);
for (i = 0; i != ZFS_OBJ_MTX_SZ; i++)
mutex_destroy(&zsb->z_hold_mtx[i]);
kmem_free(sb, sizeof (struct super_block));
kmem_free(zsb, sizeof (zfs_sb_t));
}
/*
* Retrieve the attributes of a DMU object
*/
int __osd_object_attr_get(const struct lu_env *env, struct osd_device *o,
struct osd_object *obj, struct lu_attr *la)
{
struct osa_attr *osa = &osd_oti_get(env)->oti_osa;
sa_bulk_attr_t *bulk = osd_oti_get(env)->oti_attr_bulk;
sa_handle_t *sa_hdl;
int cnt = 0;
int rc;
ENTRY;
LASSERT(obj->oo_db != NULL);
rc = -sa_handle_get(o->od_os, obj->oo_db->db_object, NULL,
SA_HDL_PRIVATE, &sa_hdl);
if (rc)
RETURN(rc);
la->la_valid |= LA_ATIME | LA_MTIME | LA_CTIME | LA_MODE | LA_TYPE |
LA_SIZE | LA_UID | LA_GID | LA_FLAGS | LA_NLINK;
SA_ADD_BULK_ATTR(bulk, cnt, SA_ZPL_ATIME(o), NULL, osa->atime, 16);
SA_ADD_BULK_ATTR(bulk, cnt, SA_ZPL_MTIME(o), NULL, osa->mtime, 16);
SA_ADD_BULK_ATTR(bulk, cnt, SA_ZPL_CTIME(o), NULL, osa->ctime, 16);
SA_ADD_BULK_ATTR(bulk, cnt, SA_ZPL_MODE(o), NULL, &osa->mode, 8);
SA_ADD_BULK_ATTR(bulk, cnt, SA_ZPL_SIZE(o), NULL, &osa->size, 8);
SA_ADD_BULK_ATTR(bulk, cnt, SA_ZPL_LINKS(o), NULL, &osa->nlink, 8);
SA_ADD_BULK_ATTR(bulk, cnt, SA_ZPL_UID(o), NULL, &osa->uid, 8);
SA_ADD_BULK_ATTR(bulk, cnt, SA_ZPL_GID(o), NULL, &osa->gid, 8);
SA_ADD_BULK_ATTR(bulk, cnt, SA_ZPL_FLAGS(o), NULL, &osa->flags, 8);
LASSERT(cnt <= ARRAY_SIZE(osd_oti_get(env)->oti_attr_bulk));
rc = -sa_bulk_lookup(sa_hdl, bulk, cnt);
if (rc)
GOTO(out_sa, rc);
la->la_atime = osa->atime[0];
la->la_mtime = osa->mtime[0];
la->la_ctime = osa->ctime[0];
la->la_mode = osa->mode;
la->la_uid = osa->uid;
la->la_gid = osa->gid;
la->la_nlink = osa->nlink;
la->la_flags = attrs_zfs2fs(osa->flags);
la->la_size = osa->size;
/* Try to get extra flag from LMA. Right now, only LMAI_ORPHAN
* flags is stored in LMA, and it is only for orphan directory */
if (S_ISDIR(la->la_mode) && dt_object_exists(&obj->oo_dt)) {
struct osd_thread_info *info = osd_oti_get(env);
struct lustre_mdt_attrs *lma;
struct lu_buf buf;
lma = (struct lustre_mdt_attrs *)info->oti_buf;
buf.lb_buf = lma;
buf.lb_len = sizeof(info->oti_buf);
rc = osd_xattr_get(env, &obj->oo_dt, &buf, XATTR_NAME_LMA);
if (rc > 0) {
rc = 0;
lma->lma_incompat = le32_to_cpu(lma->lma_incompat);
obj->oo_lma_flags =
lma_to_lustre_flags(lma->lma_incompat);
} else if (rc == -ENODATA) {
rc = 0;
}
}
if (S_ISCHR(la->la_mode) || S_ISBLK(la->la_mode)) {
rc = -sa_lookup(sa_hdl, SA_ZPL_RDEV(o), &osa->rdev, 8);
if (rc)
GOTO(out_sa, rc);
la->la_rdev = osa->rdev;
la->la_valid |= LA_RDEV;
}
out_sa:
sa_handle_destroy(sa_hdl);
RETURN(rc);
}
/*
* as we don't know FID, we can't use LU object, so this function
* partially duplicate __osd_xattr_get() which is built around
* LU-object and uses it to cache data like regular EA dnode, etc
*/
static int osd_find_parent_by_dnode(const struct lu_env *env,
struct dt_object *o,
struct lu_fid *fid)
{
struct lustre_mdt_attrs *lma;
udmu_objset_t *uos = &osd_obj2dev(osd_dt_obj(o))->od_objset;
struct lu_buf buf;
sa_handle_t *sa_hdl;
nvlist_t *nvbuf = NULL;
uchar_t *value;
uint64_t dnode;
int rc, size;
ENTRY;
/* first of all, get parent dnode from own attributes */
LASSERT(osd_dt_obj(o)->oo_db);
rc = -sa_handle_get(uos->os, osd_dt_obj(o)->oo_db->db_object,
NULL, SA_HDL_PRIVATE, &sa_hdl);
if (rc)
RETURN(rc);
dnode = ZFS_NO_OBJECT;
rc = -sa_lookup(sa_hdl, SA_ZPL_PARENT(uos), &dnode, 8);
sa_handle_destroy(sa_hdl);
if (rc)
RETURN(rc);
/* now get EA buffer */
rc = __osd_xattr_load(uos, dnode, &nvbuf);
if (rc)
GOTO(regular, rc);
/* XXX: if we get that far.. should we cache the result? */
/* try to find LMA attribute */
LASSERT(nvbuf != NULL);
rc = -nvlist_lookup_byte_array(nvbuf, XATTR_NAME_LMA, &value, &size);
if (rc == 0 && size >= sizeof(*lma)) {
lma = (struct lustre_mdt_attrs *)value;
lustre_lma_swab(lma);
*fid = lma->lma_self_fid;
GOTO(out, rc = 0);
}
regular:
/* no LMA attribute in SA, let's try regular EA */
/* first of all, get parent dnode storing regular EA */
rc = -sa_handle_get(uos->os, dnode, NULL, SA_HDL_PRIVATE, &sa_hdl);
if (rc)
GOTO(out, rc);
dnode = ZFS_NO_OBJECT;
rc = -sa_lookup(sa_hdl, SA_ZPL_XATTR(uos), &dnode, 8);
sa_handle_destroy(sa_hdl);
if (rc)
GOTO(out, rc);
CLASSERT(sizeof(*lma) <= sizeof(osd_oti_get(env)->oti_buf));
buf.lb_buf = osd_oti_get(env)->oti_buf;
buf.lb_len = sizeof(osd_oti_get(env)->oti_buf);
/* now try to find LMA */
rc = __osd_xattr_get_large(env, uos, dnode, &buf,
XATTR_NAME_LMA, &size);
if (rc == 0 && size >= sizeof(*lma)) {
lma = buf.lb_buf;
lustre_lma_swab(lma);
*fid = lma->lma_self_fid;
GOTO(out, rc = 0);
} else if (rc < 0) {
GOTO(out, rc);
} else {
GOTO(out, rc = -EIO);
}
out:
if (nvbuf != NULL)
nvlist_free(nvbuf);
RETURN(rc);
}
/*
* Construct a znode+inode and initialize.
*
* This does not do a call to dmu_set_user() that is
* up to the caller to do, in case you don't want to
* return the znode
*/
static znode_t *
zfs_znode_alloc(zfs_sb_t *zsb, dmu_buf_t *db, int blksz,
dmu_object_type_t obj_type, uint64_t obj, sa_handle_t *hdl,
struct dentry *dentry, struct inode *dip)
{
znode_t *zp;
struct inode *ip;
uint64_t parent;
sa_bulk_attr_t bulk[9];
int count = 0;
ASSERT(zsb != NULL);
ip = new_inode(zsb->z_sb);
if (ip == NULL)
return (NULL);
zp = ITOZ(ip);
ASSERT(zp->z_dirlocks == NULL);
ASSERT3P(zp->z_acl_cached, ==, NULL);
ASSERT3P(zp->z_xattr_cached, ==, NULL);
zp->z_moved = 0;
zp->z_sa_hdl = NULL;
zp->z_unlinked = 0;
zp->z_atime_dirty = 0;
zp->z_mapcnt = 0;
zp->z_id = db->db_object;
zp->z_blksz = blksz;
zp->z_seq = 0x7A4653;
zp->z_sync_cnt = 0;
zp->z_is_zvol = B_FALSE;
zp->z_is_mapped = B_FALSE;
zp->z_is_ctldir = B_FALSE;
zfs_znode_sa_init(zsb, zp, db, obj_type, hdl);
SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_MODE(zsb), NULL, &zp->z_mode, 8);
SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_GEN(zsb), NULL, &zp->z_gen, 8);
SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_SIZE(zsb), NULL, &zp->z_size, 8);
SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_LINKS(zsb), NULL, &zp->z_links, 8);
SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_FLAGS(zsb), NULL,
&zp->z_pflags, 8);
SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_PARENT(zsb), NULL,
&parent, 8);
SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_ATIME(zsb), NULL,
&zp->z_atime, 16);
SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_UID(zsb), NULL, &zp->z_uid, 8);
SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_GID(zsb), NULL, &zp->z_gid, 8);
if (sa_bulk_lookup(zp->z_sa_hdl, bulk, count) != 0 || zp->z_gen == 0) {
if (hdl == NULL)
sa_handle_destroy(zp->z_sa_hdl);
goto error;
}
ip->i_ino = obj;
zfs_inode_update(zp);
zfs_inode_set_ops(zsb, ip);
if (insert_inode_locked(ip))
goto error;
if (dentry) {
if (zpl_xattr_security_init(ip, dip, &dentry->d_name))
goto error;
d_instantiate(dentry, ip);
}
mutex_enter(&zsb->z_znodes_lock);
list_insert_tail(&zsb->z_all_znodes, zp);
zsb->z_nr_znodes++;
membar_producer();
mutex_exit(&zsb->z_znodes_lock);
unlock_new_inode(ip);
return (zp);
error:
unlock_new_inode(ip);
iput(ip);
return NULL;
}
