static int mdt_rmtlsetfacl(struct mdt_thread_info *info,
struct md_object *next,
const char *xattr_name,
ext_acl_xattr_header *header,
posix_acl_xattr_header **out)
{
struct ptlrpc_request *req = mdt_info_req(info);
struct mdt_export_data *med = mdt_req2med(req);
struct md_ucred *uc = mdt_ucred(info);
struct lu_buf *buf = &info->mti_buf;
int rc;
ENTRY;
rc = lustre_ext_acl_xattr_id2server(uc, med->med_idmap, header);
if (rc)
RETURN(rc);
rc = mo_xattr_get(info->mti_env, next, &LU_BUF_NULL, xattr_name);
if (rc == -ENODATA)
rc = 0;
else if (rc < 0)
RETURN(rc);
buf->lb_len = rc;
if (buf->lb_len > 0) {
OBD_ALLOC_LARGE(buf->lb_buf, buf->lb_len);
if (unlikely(buf->lb_buf == NULL))
RETURN(-ENOMEM);
rc = mo_xattr_get(info->mti_env, next, buf, xattr_name);
if (rc < 0) {
CERROR("getxattr failed: %d\n", rc);
GOTO(_out, rc);
}
} else
buf->lb_buf = NULL;
rc = lustre_acl_xattr_merge2posix((posix_acl_xattr_header *)(buf->lb_buf),
buf->lb_len, header, out);
EXIT;
_out:
if (rc <= 0 && buf->lb_buf != NULL)
OBD_FREE_LARGE(buf->lb_buf, buf->lb_len);
return rc;
}
/* return EADATA length to the caller. negative value means error */
static int mdt_getxattr_pack_reply(struct mdt_thread_info * info)
{
struct req_capsule *pill = info->mti_pill ;
struct ptlrpc_request *req = mdt_info_req(info);
char *xattr_name;
__u64 valid = info->mti_body->valid;
static const char user_string[] = "user.";
int size, rc;
ENTRY;
if (OBD_FAIL_CHECK(OBD_FAIL_MDS_GETXATTR_PACK))
RETURN(-ENOMEM);
/* Determine how many bytes we need */
if (valid & OBD_MD_FLXATTR) {
xattr_name = req_capsule_client_get(pill, &RMF_NAME);
if (!xattr_name)
RETURN(-EFAULT);
if (!(req->rq_export->exp_connect_flags & OBD_CONNECT_XATTR) &&
!strncmp(xattr_name, user_string, sizeof(user_string) - 1))
RETURN(-EOPNOTSUPP);
size = mo_xattr_get(info->mti_env,
mdt_object_child(info->mti_object),
&LU_BUF_NULL, xattr_name);
} else if (valid & OBD_MD_FLXATTRLS) {
size = mo_xattr_list(info->mti_env,
mdt_object_child(info->mti_object),
&LU_BUF_NULL);
} else {
CDEBUG(D_INFO, "Valid bits: "LPX64"\n", info->mti_body->valid);
RETURN(-EINVAL);
}
if (size == -ENODATA) {
size = 0;
} else if (size < 0) {
CERROR("Error geting EA size: %d\n", size);
RETURN(size);
}
if (info->mti_body->eadatasize != 0 &&
info->mti_body->eadatasize < size)
RETURN(-ERANGE);
req_capsule_set_size(pill, &RMF_EADATA, RCL_SERVER,
info->mti_body->eadatasize == 0 ? 0 : size);
rc = req_capsule_server_pack(pill);
if (rc) {
LASSERT(rc < 0);
RETURN(rc);
}
RETURN(size);
}
static int
mdt_getxattr_one(struct mdt_thread_info *info,
char *xattr_name, struct md_object *next,
struct lu_buf *buf, struct mdt_export_data *med,
struct lu_ucred *uc)
{
__u32 remote = exp_connect_rmtclient(info->mti_exp);
int flags = CFS_IC_NOTHING, rc;
ENTRY;
CDEBUG(D_INODE, "getxattr %s\n", xattr_name);
rc = mo_xattr_get(info->mti_env, next, buf, xattr_name);
if (rc < 0) {
CERROR("getxattr failed: %d\n", rc);
GOTO(out, rc);
}
if (info->mti_body->valid &
(OBD_MD_FLRMTLSETFACL | OBD_MD_FLRMTLGETFACL))
flags = CFS_IC_ALL;
else if (info->mti_body->valid & OBD_MD_FLRMTRGETFACL)
flags = CFS_IC_MAPPED;
if (rc > 0 && flags != CFS_IC_NOTHING) {
int rc1;
if (unlikely(!remote))
GOTO(out, rc = -EINVAL);
rc1 = lustre_posix_acl_xattr_id2client(uc,
med->med_idmap,
(posix_acl_xattr_header *)(buf->lb_buf),
rc, flags);
if (unlikely(rc1 < 0))
rc = rc1;
}
out:
return rc;
}
int mdt_getxattr(struct mdt_thread_info *info)
{
struct ptlrpc_request *req = mdt_info_req(info);
struct mdt_export_data *med = mdt_req2med(req);
struct md_ucred *uc = mdt_ucred(info);
struct mdt_body *reqbody;
struct mdt_body *repbody = NULL;
struct md_object *next;
struct lu_buf *buf;
__u32 remote = exp_connect_rmtclient(info->mti_exp);
__u32 perm;
int easize, rc;
ENTRY;
LASSERT(info->mti_object != NULL);
LASSERT(lu_object_assert_exists(&info->mti_object->mot_obj.mo_lu));
CDEBUG(D_INODE, "getxattr "DFID"\n", PFID(&info->mti_body->fid1));
reqbody = req_capsule_client_get(info->mti_pill, &RMF_MDT_BODY);
if (reqbody == NULL)
RETURN(err_serious(-EFAULT));
rc = mdt_init_ucred(info, reqbody);
if (rc)
RETURN(err_serious(rc));
next = mdt_object_child(info->mti_object);
if (info->mti_body->valid & OBD_MD_FLRMTRGETFACL) {
if (unlikely(!remote))
GOTO(out, rc = err_serious(-EINVAL));
perm = mdt_identity_get_perm(uc->mu_identity, remote,
req->rq_peer.nid);
if (!(perm & CFS_RMTACL_PERM))
GOTO(out, rc = err_serious(-EPERM));
rc = mo_permission(info->mti_env, NULL, next, NULL,
MAY_RGETFACL);
if (rc)
GOTO(out, rc = err_serious(rc));
}
easize = mdt_getxattr_pack_reply(info);
if (easize < 0)
GOTO(out, rc = err_serious(easize));
repbody = req_capsule_server_get(info->mti_pill, &RMF_MDT_BODY);
LASSERT(repbody != NULL);
/* No need further getxattr. */
if (easize == 0 || reqbody->eadatasize == 0)
GOTO(out, rc = easize);
buf = &info->mti_buf;
buf->lb_buf = req_capsule_server_get(info->mti_pill, &RMF_EADATA);
buf->lb_len = easize;
if (info->mti_body->valid & OBD_MD_FLXATTR) {
int flags = CFS_IC_NOTHING;
char *xattr_name = req_capsule_client_get(info->mti_pill,
&RMF_NAME);
CDEBUG(D_INODE, "getxattr %s\n", xattr_name);
rc = mo_xattr_get(info->mti_env, next, buf, xattr_name);
if (rc < 0) {
CERROR("getxattr failed: %d\n", rc);
GOTO(out, rc);
}
if (info->mti_body->valid &
(OBD_MD_FLRMTLSETFACL | OBD_MD_FLRMTLGETFACL))
flags = CFS_IC_ALL;
else if (info->mti_body->valid & OBD_MD_FLRMTRGETFACL)
flags = CFS_IC_MAPPED;
if (rc > 0 && flags != CFS_IC_NOTHING) {
int rc1;
if (unlikely(!remote))
GOTO(out, rc = -EINVAL);
rc1 = lustre_posix_acl_xattr_id2client(uc,
med->med_idmap,
(posix_acl_xattr_header *)(buf->lb_buf),
rc, flags);
if (unlikely(rc1 < 0))
rc = rc1;
}
} else if (info->mti_body->valid & OBD_MD_FLXATTRLS) {
CDEBUG(D_INODE, "listxattr\n");
rc = mo_xattr_list(info->mti_env, next, buf);
if (rc < 0)
CDEBUG(D_INFO, "listxattr failed: %d\n", rc);
} else
LBUG();
EXIT;
out:
if (rc >= 0) {
mdt_counter_incr(req->rq_export, LPROC_MDT_GETXATTR);
repbody->eadatasize = rc;
rc = 0;
}
mdt_exit_ucred(info);
return rc;
}
/* return EADATA length to the caller. negative value means error */
static int mdt_getxattr_pack_reply(struct mdt_thread_info * info)
{
struct req_capsule *pill = info->mti_pill ;
struct ptlrpc_request *req = mdt_info_req(info);
char *xattr_name;
__u64 valid;
static const char user_string[] = "user.";
int size, rc;
ENTRY;
if (OBD_FAIL_CHECK(OBD_FAIL_MDS_GETXATTR_PACK))
RETURN(-ENOMEM);
valid = info->mti_body->valid & (OBD_MD_FLXATTR | OBD_MD_FLXATTRLS);
/* Determine how many bytes we need */
if (valid == OBD_MD_FLXATTR) {
xattr_name = req_capsule_client_get(pill, &RMF_NAME);
if (!xattr_name)
RETURN(-EFAULT);
if (!(exp_connect_flags(req->rq_export) & OBD_CONNECT_XATTR) &&
!strncmp(xattr_name, user_string, sizeof(user_string) - 1))
RETURN(-EOPNOTSUPP);
size = mo_xattr_get(info->mti_env,
mdt_object_child(info->mti_object),
&LU_BUF_NULL, xattr_name);
} else if (valid == OBD_MD_FLXATTRLS) {
size = mo_xattr_list(info->mti_env,
mdt_object_child(info->mti_object),
&LU_BUF_NULL);
} else if (valid == OBD_MD_FLXATTRALL) {
/* N.B. eadatasize = 0 is not valid for FLXATTRALL */
/* We could calculate accurate sizes, but this would
* introduce a lot of overhead, let's do it later... */
size = info->mti_body->eadatasize;
req_capsule_set_size(pill, &RMF_EAVALS, RCL_SERVER, size);
req_capsule_set_size(pill, &RMF_EAVALS_LENS, RCL_SERVER, size);
} else {
CDEBUG(D_INFO, "Valid bits: "LPX64"\n", info->mti_body->valid);
RETURN(-EINVAL);
}
if (size == -ENODATA) {
size = 0;
} else if (size < 0) {
CERROR("Error geting EA size: %d\n", size);
RETURN(size);
}
req_capsule_set_size(pill, &RMF_EADATA, RCL_SERVER,
info->mti_body->eadatasize == 0 ? 0 : size);
rc = req_capsule_server_pack(pill);
if (rc) {
LASSERT(rc < 0);
RETURN(rc);
}
RETURN(size);
}
static int mdt_lvbo_fill(struct ldlm_lock *lock, void *lvb, int lvblen)
{
struct lu_env env;
struct mdt_thread_info *info;
struct mdt_device *mdt;
struct lu_fid *fid;
struct mdt_object *obj = NULL;
struct md_object *child = NULL;
int rc;
ENTRY;
mdt = ldlm_lock_to_ns(lock)->ns_lvbp;
if (IS_LQUOTA_RES(lock->l_resource)) {
if (mdt->mdt_qmt_dev == NULL)
RETURN(0);
/* call lvbo fill function of quota master */
rc = qmt_hdls.qmth_lvbo_fill(mdt->mdt_qmt_dev, lock, lvb,
lvblen);
RETURN(rc);
}
if (!ldlm_has_layout(lock))
RETURN(0);
/* layout lock will be granted to client, fill in lvb with layout */
/* XXX create an env to talk to mdt stack. We should get this env from
* ptlrpc_thread->t_env. */
rc = lu_env_init(&env, LCT_MD_THREAD);
/* Likely ENOMEM */
if (rc)
RETURN(rc);
info = lu_context_key_get(&env.le_ctx, &mdt_thread_key);
/* Likely ENOMEM */
if (info == NULL)
GOTO(out, rc = -ENOMEM);
memset(info, 0, sizeof *info);
info->mti_env = &env;
info->mti_exp = lock->l_export;
info->mti_mdt = mdt;
/* XXX get fid by resource id. why don't include fid in ldlm_resource */
fid = &info->mti_tmp_fid2;
fid_extract_from_res_name(fid, &lock->l_resource->lr_name);
obj = mdt_object_find(&env, info->mti_mdt, fid);
if (IS_ERR(obj))
GOTO(out, rc = PTR_ERR(obj));
if (!mdt_object_exists(obj) || mdt_object_remote(obj))
GOTO(out, rc = -ENOENT);
child = mdt_object_child(obj);
/* get the length of lsm */
rc = mo_xattr_get(&env, child, &LU_BUF_NULL, XATTR_NAME_LOV);
if (rc < 0)
GOTO(out, rc);
if (rc > 0) {
struct lu_buf *lmm = NULL;
if (lvblen < rc) {
CERROR("%s: expected %d actual %d.\n",
mdt_obd_name(mdt), rc, lvblen);
GOTO(out, rc = -ERANGE);
}
lmm = &info->mti_buf;
lmm->lb_buf = lvb;
lmm->lb_len = rc;
rc = mo_xattr_get(&env, child, lmm, XATTR_NAME_LOV);
if (rc < 0)
GOTO(out, rc);
}
out:
if (obj != NULL && !IS_ERR(obj))
mdt_object_put(&env, obj);
lu_env_fini(&env);
RETURN(rc < 0 ? 0 : rc);
}
/* return EADATA length to the caller. negative value means error */
static int mdt_getxattr_pack_reply(struct mdt_thread_info * info)
{
struct req_capsule *pill = info->mti_pill;
struct ptlrpc_request *req = mdt_info_req(info);
const char *xattr_name;
u64 valid;
static const char user_string[] = "user.";
int size;
int rc = 0;
int rc2;
ENTRY;
valid = info->mti_body->mbo_valid & (OBD_MD_FLXATTR | OBD_MD_FLXATTRLS);
/* Determine how many bytes we need */
if (valid == OBD_MD_FLXATTR) {
xattr_name = req_capsule_client_get(pill, &RMF_NAME);
if (!xattr_name)
RETURN(-EFAULT);
if (!(exp_connect_flags(req->rq_export) & OBD_CONNECT_XATTR) &&
!strncmp(xattr_name, user_string, sizeof(user_string) - 1))
RETURN(-EOPNOTSUPP);
size = mo_xattr_get(info->mti_env,
mdt_object_child(info->mti_object),
&LU_BUF_NULL, xattr_name);
if (size == -ENODATA) {
/* XXX: Some client code will not handle -ENODATA
* for XATTR_NAME_LOV (trusted.lov) properly. */
if (strcmp(xattr_name, XATTR_NAME_LOV) == 0)
rc = 0;
else
rc = -ENODATA;
size = 0;
}
} else if (valid == OBD_MD_FLXATTRLS) {
xattr_name = "list";
size = mo_xattr_list(info->mti_env,
mdt_object_child(info->mti_object),
&LU_BUF_NULL);
} else if (valid == OBD_MD_FLXATTRALL) {
xattr_name = "all";
/* N.B. eadatasize = 0 is not valid for FLXATTRALL */
/* We could calculate accurate sizes, but this would
* introduce a lot of overhead, let's do it later... */
size = info->mti_body->mbo_eadatasize;
req_capsule_set_size(pill, &RMF_EAVALS, RCL_SERVER, size);
req_capsule_set_size(pill, &RMF_EAVALS_LENS, RCL_SERVER, size);
} else {
CDEBUG(D_INFO, "Valid bits: %#llx\n",
info->mti_body->mbo_valid);
RETURN(-EINVAL);
}
if (size < 0) {
if (size != -EOPNOTSUPP && size != -ENOENT)
CERROR("%s: error geting EA size for '%s': rc = %d\n",
mdt_obd_name(info->mti_mdt), xattr_name, size);
RETURN(size);
}
if (req_capsule_has_field(pill, &RMF_ACL, RCL_SERVER))
req_capsule_set_size(pill, &RMF_ACL, RCL_SERVER,
LUSTRE_POSIX_ACL_MAX_SIZE_OLD);
req_capsule_set_size(pill, &RMF_EADATA, RCL_SERVER,
info->mti_body->mbo_eadatasize == 0 ? 0 : size);
rc2 = req_capsule_server_pack(pill);
if (rc2 < 0)
RETURN(rc2);
if (OBD_FAIL_CHECK(OBD_FAIL_MDS_GETXATTR_PACK))
RETURN(-ENOMEM);
RETURN(rc < 0 ? rc : size);
}
int mdt_getxattr(struct mdt_thread_info *info)
{
struct ptlrpc_request *req = mdt_info_req(info);
struct mdt_body *reqbody;
struct mdt_body *repbody = NULL;
struct md_object *next;
struct lu_buf *buf;
int easize, rc;
u64 valid;
ENTRY;
LASSERT(info->mti_object != NULL);
LASSERT(lu_object_assert_exists(&info->mti_object->mot_obj));
CDEBUG(D_INODE, "getxattr "DFID"\n", PFID(&info->mti_body->mbo_fid1));
rc = req_check_sepol(info->mti_pill);
if (rc)
RETURN(err_serious(rc));
reqbody = req_capsule_client_get(info->mti_pill, &RMF_MDT_BODY);
if (reqbody == NULL)
RETURN(err_serious(-EFAULT));
rc = mdt_init_ucred(info, reqbody);
if (rc)
RETURN(err_serious(rc));
next = mdt_object_child(info->mti_object);
easize = mdt_getxattr_pack_reply(info);
if (easize == -ENODATA)
GOTO(out, rc = easize);
else if (easize < 0)
GOTO(out, rc = err_serious(easize));
repbody = req_capsule_server_get(info->mti_pill, &RMF_MDT_BODY);
LASSERT(repbody != NULL);
/* No need further getxattr. */
if (easize == 0 || reqbody->mbo_eadatasize == 0)
GOTO(out, rc = easize);
buf = &info->mti_buf;
buf->lb_buf = req_capsule_server_get(info->mti_pill, &RMF_EADATA);
buf->lb_len = easize;
valid = info->mti_body->mbo_valid & (OBD_MD_FLXATTR | OBD_MD_FLXATTRLS);
if (valid == OBD_MD_FLXATTR) {
const char *xattr_name = req_capsule_client_get(info->mti_pill,
&RMF_NAME);
rc = mo_xattr_get(info->mti_env, next, buf, xattr_name);
if (rc < 0)
GOTO(out, rc);
rc = mdt_nodemap_map_acl(info, buf->lb_buf, rc, xattr_name,
NODEMAP_FS_TO_CLIENT);
} else if (valid == OBD_MD_FLXATTRLS) {
CDEBUG(D_INODE, "listxattr\n");
rc = mo_xattr_list(info->mti_env, next, buf);
if (rc < 0)
CDEBUG(D_INFO, "listxattr failed: %d\n", rc);
} else if (valid == OBD_MD_FLXATTRALL) {
rc = mdt_getxattr_all(info, reqbody, repbody,
buf, next);
} else
LBUG();
EXIT;
out:
if (rc >= 0) {
mdt_counter_incr(req, LPROC_MDT_GETXATTR);
/* LU-11109: Set OBD_MD_FLXATTR on success so that
* newer clients can distinguish between nonexistent
* xattrs and zero length values. */
repbody->mbo_valid |= OBD_MD_FLXATTR;
repbody->mbo_eadatasize = rc;
rc = 0;
}
mdt_exit_ucred(info);
return rc;
}
static int mdt_getxattr_all(struct mdt_thread_info *info,
struct mdt_body *reqbody, struct mdt_body *repbody,
struct lu_buf *buf, struct md_object *next)
{
const struct lu_env *env = info->mti_env;
char *v, *b, *eadatahead, *eadatatail;
__u32 *sizes;
int eadatasize, eavallen = 0, eavallens = 0, rc;
ENTRY;
/*
* The format of the pill is the following:
* EADATA: attr1\0attr2\0...attrn\0
* EAVALS: val1val2...valn
* EAVALS_LENS: 4,4,...4
*/
eadatahead = buf->lb_buf;
/* Fill out EADATA first */
rc = mo_xattr_list(env, next, buf);
if (rc < 0)
GOTO(out_shrink, rc);
eadatasize = rc;
eadatatail = eadatahead + eadatasize;
v = req_capsule_server_get(info->mti_pill, &RMF_EAVALS);
sizes = req_capsule_server_get(info->mti_pill, &RMF_EAVALS_LENS);
/* Fill out EAVALS and EAVALS_LENS */
for (b = eadatahead; b < eadatatail; b += strlen(b) + 1, v += rc) {
buf->lb_buf = v;
buf->lb_len = reqbody->mbo_eadatasize - eavallen;
rc = mo_xattr_get(env, next, buf, b);
if (rc < 0)
GOTO(out_shrink, rc);
rc = mdt_nodemap_map_acl(info, buf->lb_buf, rc, b,
NODEMAP_FS_TO_CLIENT);
if (rc < 0)
GOTO(out_shrink, rc);
sizes[eavallens] = rc;
eavallens++;
eavallen += rc;
}
out_shrink:
if (rc < 0) {
eadatasize = 0;
eavallens = 0;
eavallen = 0;
}
repbody->mbo_aclsize = eavallen;
repbody->mbo_max_mdsize = eavallens;
req_capsule_shrink(info->mti_pill, &RMF_EAVALS, eavallen, RCL_SERVER);
req_capsule_shrink(info->mti_pill, &RMF_EAVALS_LENS,
eavallens * sizeof(__u32), RCL_SERVER);
req_capsule_shrink(info->mti_pill, &RMF_EADATA, eadatasize, RCL_SERVER);
if (rc >= 0)
RETURN(eadatasize);
return rc;
}
