static
int ll_getxattr_common(struct inode *inode, const char *name,
void *buffer, size_t size, __u64 valid)
{
struct ll_sb_info *sbi = ll_i2sbi(inode);
struct ptlrpc_request *req = NULL;
struct mdt_body *body;
int xattr_type, rc;
void *xdata;
struct obd_capa *oc;
struct rmtacl_ctl_entry *rce = NULL;
CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p)\n",
inode->i_ino, inode->i_generation, inode);
/* listxattr have slightly different behavior from of ext3:
* without 'user_xattr' ext3 will list all xattr names but
* filtered out "^user..*"; we list them all for simplicity.
*/
if (!name) {
xattr_type = XATTR_OTHER_T;
goto do_getxattr;
}
xattr_type = get_xattr_type(name);
rc = xattr_type_filter(sbi, xattr_type);
if (rc)
return rc;
/* b15587: ignore security.capability xattr for now */
if ((xattr_type == XATTR_SECURITY_T &&
strcmp(name, "security.capability") == 0))
return -ENODATA;
/* LU-549: Disable security.selinux when selinux is disabled */
if (xattr_type == XATTR_SECURITY_T && !selinux_is_enabled() &&
strcmp(name, "security.selinux") == 0)
return -EOPNOTSUPP;
#ifdef CONFIG_FS_POSIX_ACL
if (sbi->ll_flags & LL_SBI_RMT_CLIENT &&
(xattr_type == XATTR_ACL_ACCESS_T ||
xattr_type == XATTR_ACL_DEFAULT_T)) {
rce = rct_search(&sbi->ll_rct, current_pid());
if (rce == NULL ||
(rce->rce_ops != RMT_LSETFACL &&
rce->rce_ops != RMT_LGETFACL &&
rce->rce_ops != RMT_RSETFACL &&
rce->rce_ops != RMT_RGETFACL))
return -EOPNOTSUPP;
}
/* posix acl is under protection of LOOKUP lock. when calling to this,
* we just have path resolution to the target inode, so we have great
* chance that cached ACL is uptodate.
*/
if (xattr_type == XATTR_ACL_ACCESS_T &&
!(sbi->ll_flags & LL_SBI_RMT_CLIENT)) {
struct ll_inode_info *lli = ll_i2info(inode);
struct posix_acl *acl;
spin_lock(&lli->lli_lock);
acl = posix_acl_dup(lli->lli_posix_acl);
spin_unlock(&lli->lli_lock);
if (!acl)
return -ENODATA;
rc = posix_acl_to_xattr(&init_user_ns, acl, buffer, size);
posix_acl_release(acl);
return rc;
}
if (xattr_type == XATTR_ACL_DEFAULT_T && !S_ISDIR(inode->i_mode))
return -ENODATA;
#endif
do_getxattr:
if (sbi->ll_xattr_cache_enabled && (rce == NULL ||
rce->rce_ops == RMT_LGETFACL ||
rce->rce_ops == RMT_LSETFACL)) {
rc = ll_xattr_cache_get(inode, name, buffer, size, valid);
if (rc < 0)
GOTO(out_xattr, rc);
} else {
oc = ll_mdscapa_get(inode);
rc = md_getxattr(sbi->ll_md_exp, ll_inode2fid(inode), oc,
valid | (rce ? rce_ops2valid(rce->rce_ops) : 0),
name, NULL, 0, size, 0, &req);
capa_put(oc);
if (rc < 0)
GOTO(out_xattr, rc);
body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
LASSERT(body);
/* only detect the xattr size */
if (size == 0)
GOTO(out, rc = body->eadatasize);
if (size < body->eadatasize) {
CERROR("server bug: replied size %u > %u\n",
body->eadatasize, (int)size);
GOTO(out, rc = -ERANGE);
}
if (body->eadatasize == 0)
GOTO(out, rc = -ENODATA);
/* do not need swab xattr data */
xdata = req_capsule_server_sized_get(&req->rq_pill, &RMF_EADATA,
body->eadatasize);
if (!xdata)
GOTO(out, rc = -EFAULT);
memcpy(buffer, xdata, body->eadatasize);
rc = body->eadatasize;
}
#ifdef CONFIG_FS_POSIX_ACL
if (rce && rce->rce_ops == RMT_LSETFACL) {
ext_acl_xattr_header *acl;
acl = lustre_posix_acl_xattr_2ext(
(posix_acl_xattr_header *)buffer, rc);
if (IS_ERR(acl))
GOTO(out, rc = PTR_ERR(acl));
rc = ee_add(&sbi->ll_et, current_pid(), ll_inode2fid(inode),
xattr_type, acl);
if (unlikely(rc < 0)) {
lustre_ext_acl_xattr_free(acl);
GOTO(out, rc);
}
}
#endif
out_xattr:
if (rc == -EOPNOTSUPP && xattr_type == XATTR_USER_T) {
LCONSOLE_INFO(
"%s: disabling user_xattr feature because it is not supported on the server: rc = %d\n",
ll_get_fsname(inode->i_sb, NULL, 0), rc);
sbi->ll_flags &= ~LL_SBI_USER_XATTR;
}
out:
ptlrpc_req_finished(req);
return rc;
}
/**
* Implementation of dt_index_operations::dio_lookup
*
* Look up record by key under a remote index object. It packs lookup update
* into RPC, sends to the remote OUT and waits for the lookup result.
*
* \param[in] env execution environment
* \param[in] dt index object to lookup
* \param[out] rec record in which to return lookup result
* \param[in] key key of index which will be looked up
*
* \retval 1 if the lookup succeeds.
* \retval negative errno if the lookup fails.
*/
static int osp_md_index_lookup(const struct lu_env *env, struct dt_object *dt,
struct dt_rec *rec, const struct dt_key *key)
{
struct lu_buf *lbuf = &osp_env_info(env)->osi_lb2;
struct osp_device *osp = lu2osp_dev(dt->do_lu.lo_dev);
struct dt_device *dt_dev = &osp->opd_dt_dev;
struct osp_update_request *update;
struct object_update_reply *reply;
struct ptlrpc_request *req = NULL;
struct lu_fid *fid;
int rc;
ENTRY;
/* Because it needs send the update buffer right away,
* just create an update buffer, instead of attaching the
* update_remote list of the thandle.
*/
update = osp_update_request_create(dt_dev);
if (IS_ERR(update))
RETURN(PTR_ERR(update));
rc = osp_update_rpc_pack(env, index_lookup, update, OUT_INDEX_LOOKUP,
lu_object_fid(&dt->do_lu), rec, key);
if (rc != 0) {
CERROR("%s: Insert update error: rc = %d\n",
dt_dev->dd_lu_dev.ld_obd->obd_name, rc);
GOTO(out, rc);
}
rc = osp_remote_sync(env, osp, update, &req);
if (rc < 0)
GOTO(out, rc);
reply = req_capsule_server_sized_get(&req->rq_pill,
&RMF_OUT_UPDATE_REPLY,
OUT_UPDATE_REPLY_SIZE);
if (reply->ourp_magic != UPDATE_REPLY_MAGIC) {
CERROR("%s: Wrong version %x expected %x: rc = %d\n",
dt_dev->dd_lu_dev.ld_obd->obd_name,
reply->ourp_magic, UPDATE_REPLY_MAGIC, -EPROTO);
GOTO(out, rc = -EPROTO);
}
rc = object_update_result_data_get(reply, lbuf, 0);
if (rc < 0)
GOTO(out, rc);
if (lbuf->lb_len != sizeof(*fid)) {
CERROR("%s: lookup "DFID" %s wrong size %d\n",
dt_dev->dd_lu_dev.ld_obd->obd_name,
PFID(lu_object_fid(&dt->do_lu)), (char *)key,
(int)lbuf->lb_len);
GOTO(out, rc = -EINVAL);
}
fid = lbuf->lb_buf;
if (ptlrpc_rep_need_swab(req))
lustre_swab_lu_fid(fid);
if (!fid_is_sane(fid)) {
CERROR("%s: lookup "DFID" %s invalid fid "DFID"\n",
dt_dev->dd_lu_dev.ld_obd->obd_name,
PFID(lu_object_fid(&dt->do_lu)), (char *)key, PFID(fid));
GOTO(out, rc = -EINVAL);
}
memcpy(rec, fid, sizeof(*fid));
GOTO(out, rc = 1);
out:
if (req != NULL)
ptlrpc_req_finished(req);
osp_update_request_destroy(update);
return rc;
}
int llu_objects_destroy(struct ptlrpc_request *req, struct inode *dir)
{
struct mdt_body *body;
struct lov_mds_md *eadata;
struct lov_stripe_md *lsm = NULL;
struct obd_trans_info oti = { 0 };
struct obdo *oa;
int rc;
ENTRY;
body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
if (!(body->valid & OBD_MD_FLEASIZE))
RETURN(0);
if (body->eadatasize == 0) {
CERROR("OBD_MD_FLEASIZE set but eadatasize zero\n");
GOTO(out, rc = -EPROTO);
}
/* The MDS sent back the EA because we unlinked the last reference
* to this file. Use this EA to unlink the objects on the OST.
* It's opaque so we don't swab here; we leave it to obd_unpackmd() to
* check it is complete and sensible. */
eadata = req_capsule_server_sized_get(&req->rq_pill, &RMF_MDT_MD,
body->eadatasize);
LASSERT(eadata != NULL);
rc = obd_unpackmd(llu_i2obdexp(dir), &lsm, eadata,body->eadatasize);
if (rc < 0) {
CERROR("obd_unpackmd: %d\n", rc);
GOTO(out, rc);
}
LASSERT(rc >= sizeof(*lsm));
OBDO_ALLOC(oa);
if (oa == NULL)
GOTO(out_free_memmd, rc = -ENOMEM);
oa->o_id = lsm->lsm_object_id;
oa->o_seq = lsm->lsm_object_seq;
oa->o_mode = body->mode & S_IFMT;
oa->o_valid = OBD_MD_FLID | OBD_MD_FLTYPE | OBD_MD_FLGROUP;
obdo_from_inode(oa, NULL, &llu_i2info(dir)->lli_fid, 0);
if (body->valid & OBD_MD_FLCOOKIE) {
oa->o_valid |= OBD_MD_FLCOOKIE;
oti.oti_logcookies =
req_capsule_server_sized_get(&req->rq_pill,
&RMF_LOGCOOKIES,
sizeof(struct llog_cookie) *
lsm->lsm_stripe_count);
if (oti.oti_logcookies == NULL) {
oa->o_valid &= ~OBD_MD_FLCOOKIE;
body->valid &= ~OBD_MD_FLCOOKIE;
}
}
rc = obd_destroy(llu_i2obdexp(dir), oa, lsm, &oti, NULL, NULL);
OBDO_FREE(oa);
if (rc)
CERROR("obd destroy objid 0x"LPX64" error %d\n",
lsm->lsm_object_id, rc);
out_free_memmd:
obd_free_memmd(llu_i2obdexp(dir), &lsm);
out:
return rc;
}
static ssize_t osp_md_read(const struct lu_env *env, struct dt_object *dt,
struct lu_buf *rbuf, loff_t *pos)
{
struct osp_device *osp = lu2osp_dev(dt->do_lu.lo_dev);
struct dt_device *dt_dev = &osp->opd_dt_dev;
struct lu_buf *lbuf = &osp_env_info(env)->osi_lb2;
char *ptr = rbuf->lb_buf;
struct osp_update_request *update;
struct ptlrpc_request *req = NULL;
struct out_read_reply *orr;
struct ptlrpc_bulk_desc *desc;
struct object_update_reply *reply;
__u32 left_size;
int nbufs;
int i;
int rc;
ENTRY;
/* Because it needs send the update buffer right away,
* just create an update buffer, instead of attaching the
* update_remote list of the thandle. */
update = osp_update_request_create(dt_dev);
if (IS_ERR(update))
RETURN(PTR_ERR(update));
rc = osp_update_rpc_pack(env, read, update, OUT_READ,
lu_object_fid(&dt->do_lu),
rbuf->lb_len, *pos);
if (rc != 0) {
CERROR("%s: cannot insert update: rc = %d\n",
dt_dev->dd_lu_dev.ld_obd->obd_name, rc);
GOTO(out_update, rc);
}
CDEBUG(D_INFO, "%s "DFID" read offset %llu size %zu\n",
dt_dev->dd_lu_dev.ld_obd->obd_name,
PFID(lu_object_fid(&dt->do_lu)), *pos, rbuf->lb_len);
rc = osp_prep_update_req(env, osp->opd_obd->u.cli.cl_import, update,
&req);
if (rc != 0)
GOTO(out_update, rc);
nbufs = (rbuf->lb_len + OUT_BULK_BUFFER_SIZE - 1) /
OUT_BULK_BUFFER_SIZE;
/* allocate bulk descriptor */
desc = ptlrpc_prep_bulk_imp(req, nbufs, 1,
PTLRPC_BULK_PUT_SINK | PTLRPC_BULK_BUF_KVEC,
MDS_BULK_PORTAL, &ptlrpc_bulk_kvec_ops);
if (desc == NULL)
GOTO(out, rc = -ENOMEM);
/* split the buffer into small chunk size */
left_size = rbuf->lb_len;
for (i = 0; i < nbufs; i++) {
int read_size;
read_size = left_size > OUT_BULK_BUFFER_SIZE ?
OUT_BULK_BUFFER_SIZE : left_size;
desc->bd_frag_ops->add_iov_frag(desc, ptr, read_size);
ptr += read_size;
}
/* This will only be called with read-only update, and these updates
* might be used to retrieve update log during recovery process, so
* it will be allowed to send during recovery process */
req->rq_allow_replay = 1;
req->rq_bulk_read = 1;
/* send request to master and wait for RPC to complete */
rc = ptlrpc_queue_wait(req);
if (rc != 0)
GOTO(out, rc);
rc = sptlrpc_cli_unwrap_bulk_read(req, req->rq_bulk,
req->rq_bulk->bd_nob_transferred);
if (rc < 0)
GOTO(out, rc);
reply = req_capsule_server_sized_get(&req->rq_pill,
&RMF_OUT_UPDATE_REPLY,
OUT_UPDATE_REPLY_SIZE);
if (reply->ourp_magic != UPDATE_REPLY_MAGIC) {
CERROR("%s: invalid update reply magic %x expected %x:"
" rc = %d\n", dt_dev->dd_lu_dev.ld_obd->obd_name,
reply->ourp_magic, UPDATE_REPLY_MAGIC, -EPROTO);
GOTO(out, rc = -EPROTO);
}
rc = object_update_result_data_get(reply, lbuf, 0);
if (rc < 0)
GOTO(out, rc);
if (lbuf->lb_len < sizeof(*orr))
GOTO(out, rc = -EPROTO);
orr = lbuf->lb_buf;
orr_le_to_cpu(orr, orr);
rc = orr->orr_size;
*pos = orr->orr_offset;
out:
ptlrpc_req_finished(req);
out_update:
osp_update_request_destroy(update);
RETURN(rc);
}
