/* 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_create_pack_capa(struct mdt_thread_info *info, int rc,
struct mdt_object *object,
struct mdt_body *repbody)
{
ENTRY;
/* for cross-ref mkdir, mds capa has been fetched from remote obj, then
* we won't go to below*/
if (repbody->valid & OBD_MD_FLMDSCAPA)
RETURN(rc);
if (rc == 0 && info->mti_mdt->mdt_opts.mo_mds_capa &&
exp_connect_flags(info->mti_exp) & OBD_CONNECT_MDS_CAPA) {
struct lustre_capa *capa;
capa = req_capsule_server_get(info->mti_pill, &RMF_CAPA1);
LASSERT(capa);
capa->lc_opc = CAPA_OPC_MDS_DEFAULT;
rc = mo_capa_get(info->mti_env, mdt_object_child(object), capa,
0);
if (rc == 0)
repbody->valid |= OBD_MD_FLMDSCAPA;
}
RETURN(rc);
}
/**
* Lookup with version checking.
*
* This checks version of 'name'. Many reint functions uses 'name' for child not
* FID, therefore we need to get object by name and check its version.
*/
int mdt_lookup_version_check(struct mdt_thread_info *info,
struct mdt_object *p, struct lu_name *lname,
struct lu_fid *fid, int idx)
{
int rc, vbrc;
rc = mdo_lookup(info->mti_env, mdt_object_child(p), lname, fid,
&info->mti_spec);
/* Check version only during replay */
if (!req_is_replay(mdt_info_req(info)))
return rc;
info->mti_ver[idx] = ENOENT_VERSION;
if (rc == 0) {
struct mdt_object *child;
child = mdt_object_find(info->mti_env, info->mti_mdt, fid);
if (likely(!IS_ERR(child))) {
mdt_obj_version_get(info, child, &info->mti_ver[idx]);
mdt_object_put(info->mti_env, child);
}
}
vbrc = mdt_version_check(mdt_info_req(info), info->mti_ver[idx], idx);
return vbrc ? vbrc : rc;
}
/*
* This is is_subdir() variant, it is CMD if cmm forwards it to correct
* target. Source should not be ancestor of target dir. May be other rename
* checks can be moved here later.
*/
static int mdt_rename_sanity(struct mdt_thread_info *info, struct lu_fid *fid)
{
struct mdt_reint_record *rr = &info->mti_rr;
struct lu_fid dst_fid = *rr->rr_fid2;
struct mdt_object *dst;
int rc = 0;
ENTRY;
do {
LASSERT(fid_is_sane(&dst_fid));
dst = mdt_object_find(info->mti_env, info->mti_mdt, &dst_fid);
if (!IS_ERR(dst)) {
rc = mdo_is_subdir(info->mti_env,
mdt_object_child(dst), fid,
&dst_fid);
mdt_object_put(info->mti_env, dst);
if (rc != -EREMOTE && rc < 0) {
CERROR("Failed mdo_is_subdir(), rc %d\n", rc);
} else {
/* check the found fid */
if (lu_fid_eq(&dst_fid, fid))
rc = -EINVAL;
}
} else {
rc = PTR_ERR(dst);
}
} while (rc == -EREMOTE);
RETURN(rc);
}
/* if object is dying, pack the lov/llog data,
* parameter info->mti_attr should be valid at this point! */
int mdt_handle_last_unlink(struct mdt_thread_info *info, struct mdt_object *mo,
const struct md_attr *ma)
{
struct mdt_body *repbody;
const struct lu_attr *la = &ma->ma_attr;
int rc;
ENTRY;
repbody = req_capsule_server_get(info->mti_pill, &RMF_MDT_BODY);
LASSERT(repbody != NULL);
if (ma->ma_valid & MA_INODE)
mdt_pack_attr2body(info, repbody, la, mdt_object_fid(mo));
if (ma->ma_valid & MA_LOV) {
__u32 mode;
if (mdt_object_exists(mo) < 0)
/* If it is a remote object, and we do not retrieve
* EA back unlink reg file*/
mode = S_IFREG;
else
mode = lu_object_attr(&mo->mot_obj.mo_lu);
LASSERT(ma->ma_lmm_size);
mdt_dump_lmm(D_INFO, ma->ma_lmm);
repbody->eadatasize = ma->ma_lmm_size;
if (S_ISREG(mode))
repbody->valid |= OBD_MD_FLEASIZE;
else if (S_ISDIR(mode))
repbody->valid |= OBD_MD_FLDIREA;
else
LBUG();
}
if (ma->ma_cookie_size && (ma->ma_valid & MA_COOKIE)) {
repbody->aclsize = ma->ma_cookie_size;
repbody->valid |= OBD_MD_FLCOOKIE;
}
if (info->mti_mdt->mdt_opts.mo_oss_capa &&
info->mti_exp->exp_connect_flags & OBD_CONNECT_OSS_CAPA &&
repbody->valid & OBD_MD_FLEASIZE) {
struct lustre_capa *capa;
capa = req_capsule_server_get(info->mti_pill, &RMF_CAPA2);
LASSERT(capa);
capa->lc_opc = CAPA_OPC_OSS_DESTROY;
rc = mo_capa_get(info->mti_env, mdt_object_child(mo), capa, 0);
if (rc)
RETURN(rc);
repbody->valid |= OBD_MD_FLOSSCAPA;
}
RETURN(0);
}
int mdt_attr_set(struct mdt_thread_info *info, struct mdt_object *mo,
struct md_attr *ma, int flags)
{
struct mdt_lock_handle *lh;
int do_vbr = ma->ma_attr.la_valid & (LA_MODE|LA_UID|LA_GID|LA_FLAGS);
__u64 lockpart = MDS_INODELOCK_UPDATE;
int rc;
ENTRY;
/* attr shouldn't be set on remote object */
LASSERT(!mdt_object_remote(mo));
lh = &info->mti_lh[MDT_LH_PARENT];
mdt_lock_reg_init(lh, LCK_PW);
/* Even though the new MDT will grant PERM lock to the old
* client, but the old client will almost ignore that during
* So it needs to revoke both LOOKUP and PERM lock here, so
* both new and old client can cancel the dcache */
if (ma->ma_attr.la_valid & (LA_MODE|LA_UID|LA_GID))
lockpart |= MDS_INODELOCK_LOOKUP | MDS_INODELOCK_PERM;
rc = mdt_object_lock(info, mo, lh, lockpart, MDT_LOCAL_LOCK);
if (rc != 0)
RETURN(rc);
if (mdt_object_exists(mo) == 0)
GOTO(out_unlock, rc = -ENOENT);
/* all attrs are packed into mti_attr in unpack_setattr */
mdt_fail_write(info->mti_env, info->mti_mdt->mdt_bottom,
OBD_FAIL_MDS_REINT_SETATTR_WRITE);
/* This is only for set ctime when rename's source is on remote MDS. */
if (unlikely(ma->ma_attr.la_valid == LA_CTIME))
ma->ma_attr_flags |= MDS_VTX_BYPASS;
/* VBR: update version if attr changed are important for recovery */
if (do_vbr) {
/* update on-disk version of changed object */
info->mti_mos = mo;
rc = mdt_version_get_check_save(info, mo, 0);
if (rc)
GOTO(out_unlock, rc);
}
/* all attrs are packed into mti_attr in unpack_setattr */
rc = mo_attr_set(info->mti_env, mdt_object_child(mo), ma);
if (rc != 0)
GOTO(out_unlock, rc);
EXIT;
out_unlock:
mdt_object_unlock(info, mo, lh, rc);
return rc;
}
/* Partial request to create object only */
static int mdt_md_mkobj(struct mdt_thread_info *info)
{
struct mdt_device *mdt = info->mti_mdt;
struct mdt_object *o;
struct mdt_body *repbody;
struct md_attr *ma = &info->mti_attr;
int rc;
ENTRY;
DEBUG_REQ(D_INODE, mdt_info_req(info), "Partial create "DFID"",
PFID(info->mti_rr.rr_fid2));
repbody = req_capsule_server_get(info->mti_pill, &RMF_MDT_BODY);
o = mdt_object_find(info->mti_env, mdt, info->mti_rr.rr_fid2,
MDT_OBJ_MAY_NOT_EXIST);
if (!IS_ERR(o)) {
struct md_object *next = mdt_object_child(o);
ma->ma_need = MA_INODE;
ma->ma_valid = 0;
/*
* Cross-ref create can encounter already created obj in case of
* recovery, just get attr in that case.
*/
if (mdt_object_exists(o) == 1) {
rc = mo_attr_get(info->mti_env, next, ma);
} else {
/*
* Here, NO permission check for object_create,
* such check has been done on the original MDS.
*/
rc = mo_object_create(info->mti_env, next,
&info->mti_spec, ma);
}
if (rc == 0) {
/* Return fid & attr to client. */
if (ma->ma_valid & MA_INODE)
mdt_pack_attr2body(info, repbody, &ma->ma_attr,
mdt_object_fid(o));
}
mdt_object_put(info->mti_env, o);
} else
rc = PTR_ERR(o);
mdt_create_pack_capa(info, rc, o, repbody);
RETURN(rc);
}
/* if object is dying, pack the lov/llog data,
* parameter info->mti_attr should be valid at this point! */
int mdt_handle_last_unlink(struct mdt_thread_info *info, struct mdt_object *mo,
const struct md_attr *ma)
{
struct mdt_body *repbody;
const struct lu_attr *la = &ma->ma_attr;
int rc;
ENTRY;
repbody = req_capsule_server_get(info->mti_pill, &RMF_MDT_BODY);
LASSERT(repbody != NULL);
if (ma->ma_valid & MA_INODE)
mdt_pack_attr2body(info, repbody, la, mdt_object_fid(mo));
if (ma->ma_valid & MA_LOV) {
CERROR("No need in LOV EA upon unlink\n");
dump_stack();
}
repbody->eadatasize = 0;
if (ma->ma_cookie_size && (ma->ma_valid & MA_COOKIE)) {
repbody->aclsize = ma->ma_cookie_size;
repbody->valid |= OBD_MD_FLCOOKIE;
}
if (info->mti_mdt->mdt_opts.mo_oss_capa &&
exp_connect_flags(info->mti_exp) & OBD_CONNECT_OSS_CAPA &&
repbody->valid & OBD_MD_FLEASIZE) {
struct lustre_capa *capa;
capa = req_capsule_server_get(info->mti_pill, &RMF_CAPA2);
LASSERT(capa);
capa->lc_opc = CAPA_OPC_OSS_DESTROY;
rc = mo_capa_get(info->mti_env, mdt_object_child(mo), capa, 0);
if (rc)
RETURN(rc);
repbody->valid |= OBD_MD_FLOSSCAPA;
}
RETURN(0);
}
/**
* Update on-disk HSM attributes.
*/
int mdt_hsm_attr_set(struct mdt_thread_info *info, struct mdt_object *obj,
const struct md_hsm *mh)
{
struct md_object *next = mdt_object_child(obj);
struct lu_buf *buf = &info->mti_buf;
struct hsm_attrs *attrs;
int rc;
ENTRY;
attrs = (struct hsm_attrs *)info->mti_xattr_buf;
CLASSERT(sizeof(info->mti_xattr_buf) >= sizeof(*attrs));
/* pack HSM attributes */
lustre_hsm2buf(info->mti_xattr_buf, mh);
/* update HSM attributes */
buf->lb_buf = attrs;
buf->lb_len = sizeof(*attrs);
rc = mo_xattr_set(info->mti_env, next, buf, XATTR_NAME_HSM, 0);
RETURN(rc);
}
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;
}
/* partial operation for rename */
static int mdt_reint_rename_tgt(struct mdt_thread_info *info)
{
struct mdt_reint_record *rr = &info->mti_rr;
struct ptlrpc_request *req = mdt_info_req(info);
struct md_attr *ma = &info->mti_attr;
struct mdt_object *mtgtdir;
struct mdt_object *mtgt = NULL;
struct mdt_lock_handle *lh_tgtdir;
struct mdt_lock_handle *lh_tgt = NULL;
struct lu_fid *tgt_fid = &info->mti_tmp_fid1;
struct lu_name *lname;
int rc;
ENTRY;
DEBUG_REQ(D_INODE, req, "rename_tgt: insert (%s->"DFID") in "DFID,
rr->rr_tgt, PFID(rr->rr_fid2), PFID(rr->rr_fid1));
/* step 1: lookup & lock the tgt dir. */
lh_tgtdir = &info->mti_lh[MDT_LH_PARENT];
mdt_lock_pdo_init(lh_tgtdir, LCK_PW, rr->rr_tgt,
rr->rr_tgtlen);
mtgtdir = mdt_object_find_lock(info, rr->rr_fid1, lh_tgtdir,
MDS_INODELOCK_UPDATE,
MDT_OBJ_MUST_EXIST);
if (IS_ERR(mtgtdir))
RETURN(PTR_ERR(mtgtdir));
/* step 2: find & lock the target object if exists. */
mdt_set_capainfo(info, 0, rr->rr_fid1, BYPASS_CAPA);
lname = mdt_name(info->mti_env, (char *)rr->rr_tgt, rr->rr_tgtlen);
rc = mdo_lookup(info->mti_env, mdt_object_child(mtgtdir),
lname, tgt_fid, &info->mti_spec);
if (rc != 0 && rc != -ENOENT) {
GOTO(out_unlock_tgtdir, rc);
} else if (rc == 0) {
/*
* In case of replay that name can be already inserted, check
* that and do nothing if so.
*/
if (lu_fid_eq(tgt_fid, rr->rr_fid2))
GOTO(out_unlock_tgtdir, rc);
lh_tgt = &info->mti_lh[MDT_LH_CHILD];
mdt_lock_reg_init(lh_tgt, LCK_EX);
mtgt = mdt_object_find_lock(info, tgt_fid, lh_tgt,
MDS_INODELOCK_LOOKUP,
MDT_OBJ_MUST_EXIST);
if (IS_ERR(mtgt))
GOTO(out_unlock_tgtdir, rc = PTR_ERR(mtgt));
mdt_reint_init_ma(info, ma);
if (!ma->ma_lmm || !ma->ma_cookie)
GOTO(out_unlock_tgt, rc = -EINVAL);
rc = mdo_rename_tgt(info->mti_env, mdt_object_child(mtgtdir),
mdt_object_child(mtgt), rr->rr_fid2,
lname, ma);
} else /* -ENOENT */ {
rc = mdo_name_insert(info->mti_env, mdt_object_child(mtgtdir),
lname, rr->rr_fid2, ma);
}
/* handle last link of tgt object */
if (rc == 0 && mtgt)
mdt_handle_last_unlink(info, mtgt, ma);
EXIT;
out_unlock_tgt:
if (mtgt)
mdt_object_unlock_put(info, mtgt, lh_tgt, rc);
out_unlock_tgtdir:
mdt_object_unlock_put(info, mtgtdir, lh_tgtdir, rc);
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);
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);
}
/*
* VBR: we save three versions in reply:
* 0 - parent. Check that parent version is the same during replay.
* 1 - name. Version of 'name' if file exists with the same name or
* ENOENT_VERSION, it is needed because file may appear due to missed replays.
* 2 - child. Version of child by FID. Must be ENOENT. It is mostly sanity
* check.
*/
static int mdt_md_create(struct mdt_thread_info *info)
{
struct mdt_device *mdt = info->mti_mdt;
struct mdt_object *parent;
struct mdt_object *child;
struct mdt_lock_handle *lh;
struct mdt_body *repbody;
struct md_attr *ma = &info->mti_attr;
struct mdt_reint_record *rr = &info->mti_rr;
struct lu_name *lname;
int rc;
ENTRY;
DEBUG_REQ(D_INODE, mdt_info_req(info), "Create (%s->"DFID") in "DFID,
rr->rr_name, PFID(rr->rr_fid2), PFID(rr->rr_fid1));
repbody = req_capsule_server_get(info->mti_pill, &RMF_MDT_BODY);
lh = &info->mti_lh[MDT_LH_PARENT];
mdt_lock_pdo_init(lh, LCK_PW, rr->rr_name, rr->rr_namelen);
parent = mdt_object_find_lock(info, rr->rr_fid1, lh,
MDS_INODELOCK_UPDATE);
if (IS_ERR(parent))
RETURN(PTR_ERR(parent));
if (mdt_object_obf(parent))
GOTO(out_put_parent, rc = -EPERM);
rc = mdt_version_get_check_save(info, parent, 0);
if (rc)
GOTO(out_put_parent, rc);
/*
* Check child name version during replay.
* During create replay a file may exist with same name.
*/
lname = mdt_name(info->mti_env, (char *)rr->rr_name, rr->rr_namelen);
rc = mdt_lookup_version_check(info, parent, lname,
&info->mti_tmp_fid1, 1);
if (rc == 0)
GOTO(out_put_parent, rc = -EEXIST);
/* -ENOENT is expected here */
if (rc != -ENOENT)
GOTO(out_put_parent, rc);
/* save version of file name for replay, it must be ENOENT here */
mdt_enoent_version_save(info, 1);
child = mdt_object_new(info->mti_env, mdt, rr->rr_fid2);
if (likely(!IS_ERR(child))) {
struct md_object *next = mdt_object_child(parent);
if (mdt_object_remote(child)) {
struct seq_server_site *ss;
struct lu_ucred *uc = mdt_ucred(info);
if (!md_capable(uc, CFS_CAP_SYS_ADMIN)) {
CERROR("%s: Creating remote dir is only "
"permitted for administrator: rc = %d\n",
mdt2obd_dev(mdt)->obd_name, -EPERM);
GOTO(out_put_child, rc = -EPERM);
}
ss = mdt_seq_site(mdt);
if (ss->ss_node_id != 0 &&
mdt->mdt_enable_remote_dir == 0) {
CERROR("%s: remote dir is only permitted on"
" MDT0 or set_param"
" mdt.*.enable_remote_dir=1\n",
mdt2obd_dev(mdt)->obd_name);
GOTO(out_put_child, rc = -EPERM);
}
}
ma->ma_need = MA_INODE;
ma->ma_valid = 0;
/* capa for cross-ref will be stored here */
ma->ma_capa = req_capsule_server_get(info->mti_pill,
&RMF_CAPA1);
LASSERT(ma->ma_capa);
mdt_fail_write(info->mti_env, info->mti_mdt->mdt_bottom,
OBD_FAIL_MDS_REINT_CREATE_WRITE);
/* Version of child will be updated on disk. */
info->mti_mos = child;
rc = mdt_version_get_check_save(info, child, 2);
if (rc)
GOTO(out_put_child, rc);
/* Let lower layer know current lock mode. */
info->mti_spec.sp_cr_mode =
mdt_dlm_mode2mdl_mode(lh->mlh_pdo_mode);
/*
* Do not perform lookup sanity check. We know that name does
* not exist.
*/
info->mti_spec.sp_cr_lookup = 0;
info->mti_spec.sp_feat = &dt_directory_features;
rc = mdo_create(info->mti_env, next, lname,
mdt_object_child(child),
&info->mti_spec, ma);
if (rc == 0)
rc = mdt_attr_get_complex(info, child, ma);
if (rc == 0) {
/* Return fid & attr to client. */
if (ma->ma_valid & MA_INODE)
mdt_pack_attr2body(info, repbody, &ma->ma_attr,
mdt_object_fid(child));
}
out_put_child:
mdt_object_put(info->mti_env, child);
} else {
rc = PTR_ERR(child);
}
mdt_create_pack_capa(info, rc, child, repbody);
out_put_parent:
mdt_object_unlock_put(info, parent, lh, rc);
RETURN(rc);
}
/*
* VBR: rename versions in reply: 0 - src parent; 1 - tgt parent;
* 2 - src child; 3 - tgt child.
* Update on disk version of src child.
*/
static int mdt_reint_rename(struct mdt_thread_info *info,
struct mdt_lock_handle *lhc)
{
struct mdt_reint_record *rr = &info->mti_rr;
struct md_attr *ma = &info->mti_attr;
struct ptlrpc_request *req = mdt_info_req(info);
struct mdt_object *msrcdir;
struct mdt_object *mtgtdir;
struct mdt_object *mold;
struct mdt_object *mnew = NULL;
struct mdt_lock_handle *lh_srcdirp;
struct mdt_lock_handle *lh_tgtdirp;
struct mdt_lock_handle *lh_oldp;
struct mdt_lock_handle *lh_newp;
struct lu_fid *old_fid = &info->mti_tmp_fid1;
struct lu_fid *new_fid = &info->mti_tmp_fid2;
struct lustre_handle rename_lh = { 0 };
struct lu_name slname = { 0 };
struct lu_name *lname;
int rc;
ENTRY;
if (info->mti_dlm_req)
ldlm_request_cancel(req, info->mti_dlm_req, 0);
DEBUG_REQ(D_INODE, req, "rename "DFID"/%s to "DFID"/%s",
PFID(rr->rr_fid1), rr->rr_name,
PFID(rr->rr_fid2), rr->rr_tgt);
rc = mdt_rename_lock(info, &rename_lh);
if (rc) {
CERROR("Can't lock FS for rename, rc %d\n", rc);
RETURN(rc);
}
lh_newp = &info->mti_lh[MDT_LH_NEW];
/* step 1: lock the source dir. */
lh_srcdirp = &info->mti_lh[MDT_LH_PARENT];
mdt_lock_pdo_init(lh_srcdirp, LCK_PW, rr->rr_name,
rr->rr_namelen);
msrcdir = mdt_object_find_lock(info, rr->rr_fid1, lh_srcdirp,
MDS_INODELOCK_UPDATE);
if (IS_ERR(msrcdir))
GOTO(out_rename_lock, rc = PTR_ERR(msrcdir));
if (mdt_object_obf(msrcdir))
GOTO(out_unlock_source, rc = -EPERM);
rc = mdt_version_get_check_save(info, msrcdir, 0);
if (rc)
GOTO(out_unlock_source, rc);
/* step 2: find & lock the target dir. */
lh_tgtdirp = &info->mti_lh[MDT_LH_CHILD];
mdt_lock_pdo_init(lh_tgtdirp, LCK_PW, rr->rr_tgt,
rr->rr_tgtlen);
if (lu_fid_eq(rr->rr_fid1, rr->rr_fid2)) {
mdt_object_get(info->mti_env, msrcdir);
mtgtdir = msrcdir;
if (lh_tgtdirp->mlh_pdo_hash != lh_srcdirp->mlh_pdo_hash) {
rc = mdt_pdir_hash_lock(info, lh_tgtdirp, mtgtdir,
MDS_INODELOCK_UPDATE);
if (rc)
GOTO(out_unlock_source, rc);
OBD_FAIL_TIMEOUT(OBD_FAIL_MDS_PDO_LOCK2, 10);
}
} else {
mtgtdir = mdt_object_find(info->mti_env, info->mti_mdt,
rr->rr_fid2);
if (IS_ERR(mtgtdir))
GOTO(out_unlock_source, rc = PTR_ERR(mtgtdir));
if (mdt_object_obf(mtgtdir))
GOTO(out_put_target, rc = -EPERM);
/* check early, the real version will be saved after locking */
rc = mdt_version_get_check(info, mtgtdir, 1);
if (rc)
GOTO(out_put_target, rc);
if (unlikely(mdt_object_remote(mtgtdir))) {
CDEBUG(D_INFO, "Source dir "DFID" target dir "DFID
"on different MDTs\n", PFID(rr->rr_fid1),
PFID(rr->rr_fid2));
GOTO(out_put_target, rc = -EXDEV);
} else {
if (likely(mdt_object_exists(mtgtdir))) {
/* we lock the target dir if it is local */
rc = mdt_object_lock(info, mtgtdir, lh_tgtdirp,
MDS_INODELOCK_UPDATE,
MDT_LOCAL_LOCK);
if (rc != 0)
GOTO(out_put_target, rc);
/* get and save correct version after locking */
mdt_version_get_save(info, mtgtdir, 1);
} else {
GOTO(out_put_target, rc = -ESTALE);
}
}
}
/* step 3: find & lock the old object. */
lname = mdt_name(info->mti_env, (char *)rr->rr_name, rr->rr_namelen);
mdt_name_copy(&slname, lname);
fid_zero(old_fid);
rc = mdt_lookup_version_check(info, msrcdir, &slname, old_fid, 2);
if (rc != 0)
GOTO(out_unlock_target, rc);
if (lu_fid_eq(old_fid, rr->rr_fid1) || lu_fid_eq(old_fid, rr->rr_fid2))
GOTO(out_unlock_target, rc = -EINVAL);
mold = mdt_object_find(info->mti_env, info->mti_mdt, old_fid);
if (IS_ERR(mold))
GOTO(out_unlock_target, rc = PTR_ERR(mold));
if (mdt_object_remote(mold)) {
mdt_object_put(info->mti_env, mold);
CDEBUG(D_INFO, "Source child "DFID" is on another MDT\n",
PFID(old_fid));
GOTO(out_unlock_target, rc = -EXDEV);
}
if (mdt_object_obf(mold)) {
mdt_object_put(info->mti_env, mold);
GOTO(out_unlock_target, rc = -EPERM);
}
lh_oldp = &info->mti_lh[MDT_LH_OLD];
mdt_lock_reg_init(lh_oldp, LCK_EX);
rc = mdt_object_lock(info, mold, lh_oldp, MDS_INODELOCK_LOOKUP,
MDT_CROSS_LOCK);
if (rc != 0) {
mdt_object_put(info->mti_env, mold);
GOTO(out_unlock_target, rc);
}
info->mti_mos = mold;
/* save version after locking */
mdt_version_get_save(info, mold, 2);
mdt_set_capainfo(info, 2, old_fid, BYPASS_CAPA);
/* step 4: find & lock the new object. */
/* new target object may not exist now */
lname = mdt_name(info->mti_env, (char *)rr->rr_tgt, rr->rr_tgtlen);
/* lookup with version checking */
fid_zero(new_fid);
rc = mdt_lookup_version_check(info, mtgtdir, lname, new_fid, 3);
if (rc == 0) {
/* the new_fid should have been filled at this moment */
if (lu_fid_eq(old_fid, new_fid))
GOTO(out_unlock_old, rc);
if (lu_fid_eq(new_fid, rr->rr_fid1) ||
lu_fid_eq(new_fid, rr->rr_fid2))
GOTO(out_unlock_old, rc = -EINVAL);
mdt_lock_reg_init(lh_newp, LCK_EX);
mnew = mdt_object_find(info->mti_env, info->mti_mdt, new_fid);
if (IS_ERR(mnew))
GOTO(out_unlock_old, rc = PTR_ERR(mnew));
if (mdt_object_obf(mnew)) {
mdt_object_put(info->mti_env, mnew);
GOTO(out_unlock_old, rc = -EPERM);
}
if (mdt_object_remote(mnew)) {
mdt_object_put(info->mti_env, mnew);
CDEBUG(D_INFO, "src child "DFID" is on another MDT\n",
PFID(new_fid));
GOTO(out_unlock_old, rc = -EXDEV);
}
rc = mdt_object_lock(info, mnew, lh_newp,
MDS_INODELOCK_FULL, MDT_CROSS_LOCK);
if (rc != 0) {
mdt_object_put(info->mti_env, mnew);
GOTO(out_unlock_old, rc);
}
/* get and save version after locking */
mdt_version_get_save(info, mnew, 3);
mdt_set_capainfo(info, 3, new_fid, BYPASS_CAPA);
} else if (rc != -EREMOTE && rc != -ENOENT) {
GOTO(out_unlock_old, rc);
} else {
mdt_enoent_version_save(info, 3);
}
/* step 5: rename it */
mdt_reint_init_ma(info, ma);
mdt_fail_write(info->mti_env, info->mti_mdt->mdt_bottom,
OBD_FAIL_MDS_REINT_RENAME_WRITE);
/* Check if @dst is subdir of @src. */
rc = mdt_rename_sanity(info, old_fid);
if (rc)
GOTO(out_unlock_new, rc);
rc = mdo_rename(info->mti_env, mdt_object_child(msrcdir),
mdt_object_child(mtgtdir), old_fid, &slname,
(mnew ? mdt_object_child(mnew) : NULL),
lname, ma);
/* handle last link of tgt object */
if (rc == 0) {
mdt_counter_incr(req, LPROC_MDT_RENAME);
if (mnew)
mdt_handle_last_unlink(info, mnew, ma);
mdt_rename_counter_tally(info, info->mti_mdt, req,
msrcdir, mtgtdir);
}
EXIT;
out_unlock_new:
if (mnew)
mdt_object_unlock_put(info, mnew, lh_newp, rc);
out_unlock_old:
mdt_object_unlock_put(info, mold, lh_oldp, rc);
out_unlock_target:
mdt_object_unlock(info, mtgtdir, lh_tgtdirp, rc);
out_put_target:
mdt_object_put(info->mti_env, mtgtdir);
out_unlock_source:
mdt_object_unlock_put(info, msrcdir, lh_srcdirp, rc);
out_rename_lock:
if (lustre_handle_is_used(&rename_lh))
mdt_rename_unlock(&rename_lh);
return rc;
}
/*
* VBR: save parent version in reply and child version getting by its name.
* Version of child is getting and checking during its lookup. If
*/
static int mdt_reint_unlink(struct mdt_thread_info *info,
struct mdt_lock_handle *lhc)
{
struct mdt_reint_record *rr = &info->mti_rr;
struct ptlrpc_request *req = mdt_info_req(info);
struct md_attr *ma = &info->mti_attr;
struct lu_fid *child_fid = &info->mti_tmp_fid1;
struct mdt_object *mp;
struct mdt_object *mc;
struct mdt_lock_handle *parent_lh;
struct mdt_lock_handle *child_lh;
struct lu_name *lname;
int rc;
int no_name = 0;
ENTRY;
DEBUG_REQ(D_INODE, req, "unlink "DFID"/%s", PFID(rr->rr_fid1),
rr->rr_name);
if (info->mti_dlm_req)
ldlm_request_cancel(req, info->mti_dlm_req, 0);
if (OBD_FAIL_CHECK(OBD_FAIL_MDS_REINT_UNLINK))
RETURN(err_serious(-ENOENT));
if (fid_is_obf(rr->rr_fid1) || fid_is_dot_lustre(rr->rr_fid1))
RETURN(-EPERM);
/*
* step 1: Found the parent.
*/
mp = mdt_object_find(info->mti_env, info->mti_mdt, rr->rr_fid1);
if (IS_ERR(mp)) {
rc = PTR_ERR(mp);
GOTO(out, rc);
}
parent_lh = &info->mti_lh[MDT_LH_PARENT];
lname = mdt_name(info->mti_env, (char *)rr->rr_name, rr->rr_namelen);
if (mdt_object_remote(mp)) {
mdt_lock_reg_init(parent_lh, LCK_EX);
rc = mdt_remote_object_lock(info, mp, &parent_lh->mlh_rreg_lh,
parent_lh->mlh_rreg_mode,
MDS_INODELOCK_UPDATE);
if (rc != ELDLM_OK)
GOTO(put_parent, rc);
} else {
mdt_lock_pdo_init(parent_lh, LCK_PW, rr->rr_name,
rr->rr_namelen);
rc = mdt_object_lock(info, mp, parent_lh, MDS_INODELOCK_UPDATE,
MDT_LOCAL_LOCK);
if (rc)
GOTO(put_parent, rc);
rc = mdt_version_get_check_save(info, mp, 0);
if (rc)
GOTO(unlock_parent, rc);
}
/* step 2: find & lock the child */
/* lookup child object along with version checking */
fid_zero(child_fid);
rc = mdt_lookup_version_check(info, mp, lname, child_fid, 1);
if (rc != 0) {
/* Name might not be able to find during resend of
* remote unlink, considering following case.
* dir_A is a remote directory, the name entry of
* dir_A is on MDT0, the directory is on MDT1,
*
* 1. client sends unlink req to MDT1.
* 2. MDT1 sends name delete update to MDT0.
* 3. name entry is being deleted in MDT0 synchronously.
* 4. MDT1 is restarted.
* 5. client resends unlink req to MDT1. So it can not
* find the name entry on MDT0 anymore.
* In this case, MDT1 only needs to destory the local
* directory.
* */
if (mdt_object_remote(mp) && rc == -ENOENT &&
!fid_is_zero(rr->rr_fid2) &&
lustre_msg_get_flags(req->rq_reqmsg) & MSG_RESENT) {
no_name = 1;
*child_fid = *rr->rr_fid2;
} else {
GOTO(unlock_parent, rc);
}
}
if (fid_is_obf(child_fid) || fid_is_dot_lustre(child_fid))
GOTO(unlock_parent, rc = -EPERM);
mdt_reint_init_ma(info, ma);
/* We will lock the child regardless it is local or remote. No harm. */
mc = mdt_object_find(info->mti_env, info->mti_mdt, child_fid);
if (IS_ERR(mc))
GOTO(unlock_parent, rc = PTR_ERR(mc));
child_lh = &info->mti_lh[MDT_LH_CHILD];
mdt_lock_reg_init(child_lh, LCK_EX);
if (mdt_object_remote(mc)) {
struct mdt_body *repbody;
if (!fid_is_zero(rr->rr_fid2)) {
CDEBUG(D_INFO, "%s: name %s can not find "DFID"\n",
mdt_obd_name(info->mti_mdt),
(char *)rr->rr_name, PFID(mdt_object_fid(mc)));
GOTO(put_child, rc = -ENOENT);
}
CDEBUG(D_INFO, "%s: name %s: "DFID" is another MDT\n",
mdt_obd_name(info->mti_mdt),
(char *)rr->rr_name, PFID(mdt_object_fid(mc)));
if (!mdt_is_dne_client(req->rq_export))
/* Return -EIO for old client */
GOTO(put_child, rc = -EIO);
if (info->mti_spec.sp_rm_entry) {
struct lu_ucred *uc = mdt_ucred(info);
if (!md_capable(uc, CFS_CAP_SYS_ADMIN)) {
CERROR("%s: unlink remote entry is only "
"permitted for administrator: rc = %d\n",
mdt_obd_name(info->mti_mdt),
-EPERM);
GOTO(put_child, rc = -EPERM);
}
ma->ma_need = MA_INODE;
ma->ma_valid = 0;
mdt_set_capainfo(info, 1, child_fid, BYPASS_CAPA);
rc = mdo_unlink(info->mti_env, mdt_object_child(mp),
NULL, lname, ma, no_name);
GOTO(put_child, rc);
}
/* Revoke the LOOKUP lock of the remote object granted by
* this MDT. Since the unlink will happen on another MDT,
* it will release the LOOKUP lock right away. Then What
* would happen if another client try to grab the LOOKUP
* lock at the same time with unlink XXX */
mdt_object_lock(info, mc, child_lh, MDS_INODELOCK_LOOKUP,
MDT_CROSS_LOCK);
repbody = req_capsule_server_get(info->mti_pill, &RMF_MDT_BODY);
LASSERT(repbody != NULL);
repbody->fid1 = *mdt_object_fid(mc);
repbody->valid |= (OBD_MD_FLID | OBD_MD_MDS);
GOTO(unlock_child, rc = -EREMOTE);
} else if (info->mti_spec.sp_rm_entry) {
rc = -EPERM;
CDEBUG(D_INFO, "%s: no rm_entry on local dir '%s': rc = %d\n",
mdt_obd_name(info->mti_mdt), (char *)rr->rr_name, rc);
GOTO(put_child, rc);
}
/* We used to acquire MDS_INODELOCK_FULL here but we can't do
* this now because a running HSM restore on the child (unlink
* victim) will hold the layout lock. See LU-4002. */
rc = mdt_object_lock(info, mc, child_lh,
MDS_INODELOCK_LOOKUP | MDS_INODELOCK_UPDATE,
MDT_CROSS_LOCK);
if (rc != 0)
GOTO(put_child, rc);
mdt_fail_write(info->mti_env, info->mti_mdt->mdt_bottom,
OBD_FAIL_MDS_REINT_UNLINK_WRITE);
/* save version when object is locked */
mdt_version_get_save(info, mc, 1);
/*
* Now we can only make sure we need MA_INODE, in mdd layer, will check
* whether need MA_LOV and MA_COOKIE.
*/
ma->ma_need = MA_INODE;
ma->ma_valid = 0;
mdt_set_capainfo(info, 1, child_fid, BYPASS_CAPA);
mutex_lock(&mc->mot_lov_mutex);
rc = mdo_unlink(info->mti_env, mdt_object_child(mp),
mdt_object_child(mc), lname, ma, no_name);
mutex_unlock(&mc->mot_lov_mutex);
if (rc == 0 && !lu_object_is_dying(&mc->mot_header))
rc = mdt_attr_get_complex(info, mc, ma);
if (rc == 0)
mdt_handle_last_unlink(info, mc, ma);
if (ma->ma_valid & MA_INODE) {
switch (ma->ma_attr.la_mode & S_IFMT) {
case S_IFDIR:
mdt_counter_incr(req, LPROC_MDT_RMDIR);
break;
case S_IFREG:
case S_IFLNK:
case S_IFCHR:
case S_IFBLK:
case S_IFIFO:
case S_IFSOCK:
mdt_counter_incr(req, LPROC_MDT_UNLINK);
break;
default:
LASSERTF(0, "bad file type %o unlinking\n",
ma->ma_attr.la_mode);
}
}
EXIT;
unlock_child:
mdt_object_unlock(info, mc, child_lh, rc);
put_child:
mdt_object_put(info->mti_env, mc);
unlock_parent:
mdt_object_unlock(info, mp, parent_lh, rc);
put_parent:
mdt_object_put(info->mti_env, mp);
out:
return rc;
}
/* shrink dir layout after migration */
static int mdt_dir_layout_shrink(struct mdt_thread_info *info)
{
const struct lu_env *env = info->mti_env;
struct mdt_device *mdt = info->mti_mdt;
struct lu_ucred *uc = mdt_ucred(info);
struct mdt_reint_record *rr = &info->mti_rr;
struct lmv_user_md *lmu = rr->rr_eadata;
__u32 lum_stripe_count = lmu->lum_stripe_count;
struct lu_buf *buf = &info->mti_buf;
struct lmv_mds_md_v1 *lmv;
struct md_attr *ma = &info->mti_attr;
struct ldlm_enqueue_info *einfo = &info->mti_einfo[0];
struct mdt_object *pobj = NULL;
struct mdt_object *obj;
struct mdt_lock_handle *lhp = NULL;
struct mdt_lock_handle *lhc;
int rc;
ENTRY;
if (!mdt->mdt_enable_dir_migration)
RETURN(-EPERM);
if (!md_capable(uc, CFS_CAP_SYS_ADMIN) &&
uc->uc_gid != mdt->mdt_enable_remote_dir_gid &&
mdt->mdt_enable_remote_dir_gid != -1)
RETURN(-EPERM);
/* mti_big_lmm is used to save LMV, but it may be uninitialized. */
if (unlikely(!info->mti_big_lmm)) {
info->mti_big_lmmsize = lmv_mds_md_size(64, LMV_MAGIC);
OBD_ALLOC(info->mti_big_lmm, info->mti_big_lmmsize);
if (!info->mti_big_lmm)
RETURN(-ENOMEM);
}
obj = mdt_object_find(env, mdt, rr->rr_fid1);
if (IS_ERR(obj))
RETURN(PTR_ERR(obj));
/* get parent from PFID */
rc = mdt_attr_get_pfid(info, obj, &ma->ma_pfid);
if (rc)
GOTO(put_obj, rc);
pobj = mdt_object_find(env, mdt, &ma->ma_pfid);
if (IS_ERR(pobj))
GOTO(put_obj, rc = PTR_ERR(pobj));
/* revoke object remote LOOKUP lock */
if (mdt_object_remote(pobj)) {
rc = mdt_revoke_remote_lookup_lock(info, pobj, obj);
if (rc)
GOTO(put_pobj, rc);
}
/*
* lock parent if dir will be shrunk to 1 stripe, because dir will be
* converted to normal directory, as will change dir fid and update
* namespace of parent.
*/
lhp = &info->mti_lh[MDT_LH_PARENT];
mdt_lock_reg_init(lhp, LCK_PW);
if (le32_to_cpu(lmu->lum_stripe_count) < 2) {
rc = mdt_reint_object_lock(info, pobj, lhp,
MDS_INODELOCK_UPDATE, true);
if (rc)
GOTO(put_pobj, rc);
}
/* lock object */
lhc = &info->mti_lh[MDT_LH_CHILD];
mdt_lock_reg_init(lhc, LCK_EX);
rc = mdt_reint_striped_lock(info, obj, lhc, MDS_INODELOCK_FULL, einfo,
true);
if (rc)
GOTO(unlock_pobj, rc);
ma->ma_lmv = info->mti_big_lmm;
ma->ma_lmv_size = info->mti_big_lmmsize;
ma->ma_valid = 0;
rc = mdt_stripe_get(info, obj, ma, XATTR_NAME_LMV);
if (rc)
GOTO(unlock_obj, rc);
/* user may run 'lfs migrate' multiple times, so it's shrunk already */
if (!(ma->ma_valid & MA_LMV))
GOTO(unlock_obj, rc = -EALREADY);
lmv = &ma->ma_lmv->lmv_md_v1;
/* ditto */
if (!(le32_to_cpu(lmv->lmv_hash_type) & LMV_HASH_FLAG_MIGRATION))
GOTO(unlock_obj, rc = -EALREADY);
lum_stripe_count = lmu->lum_stripe_count;
if (!lum_stripe_count)
lum_stripe_count = cpu_to_le32(1);
if (lmv->lmv_migrate_offset != lum_stripe_count) {
CERROR("%s: "DFID" migrate mdt count mismatch %u != %u\n",
mdt_obd_name(info->mti_mdt), PFID(rr->rr_fid1),
lmv->lmv_migrate_offset, lmu->lum_stripe_count);
GOTO(unlock_obj, rc = -EINVAL);
}
if (lmv->lmv_master_mdt_index != lmu->lum_stripe_offset) {
CERROR("%s: "DFID" migrate mdt index mismatch %u != %u\n",
mdt_obd_name(info->mti_mdt), PFID(rr->rr_fid1),
lmv->lmv_master_mdt_index, lmu->lum_stripe_offset);
GOTO(unlock_obj, rc = -EINVAL);
}
if (lum_stripe_count > 1 &&
(lmv->lmv_hash_type & cpu_to_le32(LMV_HASH_TYPE_MASK)) !=
lmu->lum_hash_type) {
CERROR("%s: "DFID" migrate mdt hash mismatch %u != %u\n",
mdt_obd_name(info->mti_mdt), PFID(rr->rr_fid1),
lmv->lmv_hash_type, lmu->lum_hash_type);
GOTO(unlock_obj, rc = -EINVAL);
}
buf->lb_buf = rr->rr_eadata;
buf->lb_len = rr->rr_eadatalen;
rc = mo_xattr_set(env, mdt_object_child(obj), buf, XATTR_NAME_LMV, 0);
GOTO(unlock_obj, rc);
unlock_obj:
mdt_reint_striped_unlock(info, obj, lhc, einfo, rc);
unlock_pobj:
mdt_object_unlock(info, pobj, lhp, rc);
put_pobj:
mdt_object_put(env, pobj);
put_obj:
mdt_object_put(env, obj);
return rc;
}
static int mdt_reint_setattr(struct mdt_thread_info *info,
struct mdt_lock_handle *lhc)
{
struct md_attr *ma = &info->mti_attr;
struct mdt_reint_record *rr = &info->mti_rr;
struct ptlrpc_request *req = mdt_info_req(info);
struct mdt_export_data *med = &req->rq_export->exp_mdt_data;
struct mdt_file_data *mfd;
struct mdt_object *mo;
struct mdt_body *repbody;
int som_au, rc, rc2;
ENTRY;
DEBUG_REQ(D_INODE, req, "setattr "DFID" %x", PFID(rr->rr_fid1),
(unsigned int)ma->ma_attr.la_valid);
if (info->mti_dlm_req)
ldlm_request_cancel(req, info->mti_dlm_req, 0);
repbody = req_capsule_server_get(info->mti_pill, &RMF_MDT_BODY);
mo = mdt_object_find(info->mti_env, info->mti_mdt, rr->rr_fid1);
if (IS_ERR(mo))
GOTO(out, rc = PTR_ERR(mo));
if (mdt_object_obf(mo))
GOTO(out_put, rc = -EPERM);
/* start a log jounal handle if needed */
if (!(mdt_conn_flags(info) & OBD_CONNECT_SOM)) {
if ((ma->ma_attr.la_valid & LA_SIZE) ||
(rr->rr_flags & MRF_OPEN_TRUNC)) {
/* Check write access for the O_TRUNC case */
if (mdt_write_read(mo) < 0)
GOTO(out_put, rc = -ETXTBSY);
}
} else if (info->mti_ioepoch &&
(info->mti_ioepoch->flags & MF_EPOCH_OPEN)) {
/* Truncate case. IOEpoch is opened. */
rc = mdt_write_get(mo);
if (rc)
GOTO(out_put, rc);
mfd = mdt_mfd_new();
if (mfd == NULL) {
mdt_write_put(mo);
GOTO(out_put, rc = -ENOMEM);
}
mdt_ioepoch_open(info, mo, 0);
repbody->ioepoch = mo->mot_ioepoch;
mdt_object_get(info->mti_env, mo);
mdt_mfd_set_mode(mfd, MDS_FMODE_TRUNC);
mfd->mfd_object = mo;
mfd->mfd_xid = req->rq_xid;
spin_lock(&med->med_open_lock);
cfs_list_add(&mfd->mfd_list, &med->med_open_head);
spin_unlock(&med->med_open_lock);
repbody->handle.cookie = mfd->mfd_handle.h_cookie;
}
som_au = info->mti_ioepoch && info->mti_ioepoch->flags & MF_SOM_CHANGE;
if (som_au) {
/* SOM Attribute update case. Find the proper mfd and update
* SOM attributes on the proper object. */
LASSERT(mdt_conn_flags(info) & OBD_CONNECT_SOM);
LASSERT(info->mti_ioepoch);
spin_lock(&med->med_open_lock);
mfd = mdt_handle2mfd(info, &info->mti_ioepoch->handle);
if (mfd == NULL) {
spin_unlock(&med->med_open_lock);
CDEBUG(D_INODE, "no handle for file close: "
"fid = "DFID": cookie = "LPX64"\n",
PFID(info->mti_rr.rr_fid1),
info->mti_ioepoch->handle.cookie);
GOTO(out_put, rc = -ESTALE);
}
LASSERT(mfd->mfd_mode == MDS_FMODE_SOM);
LASSERT(!(info->mti_ioepoch->flags & MF_EPOCH_CLOSE));
class_handle_unhash(&mfd->mfd_handle);
cfs_list_del_init(&mfd->mfd_list);
spin_unlock(&med->med_open_lock);
mdt_mfd_close(info, mfd);
} else if ((ma->ma_valid & MA_INODE) && ma->ma_attr.la_valid) {
LASSERT((ma->ma_valid & MA_LOV) == 0);
rc = mdt_attr_set(info, mo, ma, rr->rr_flags);
if (rc)
GOTO(out_put, rc);
} else if ((ma->ma_valid & MA_LOV) && (ma->ma_valid & MA_INODE)) {
struct lu_buf *buf = &info->mti_buf;
LASSERT(ma->ma_attr.la_valid == 0);
buf->lb_buf = ma->ma_lmm;
buf->lb_len = ma->ma_lmm_size;
rc = mo_xattr_set(info->mti_env, mdt_object_child(mo),
buf, XATTR_NAME_LOV, 0);
if (rc)
GOTO(out_put, rc);
} else
LBUG();
/* If file data is modified, add the dirty flag */
if (ma->ma_attr_flags & MDS_DATA_MODIFIED)
rc = mdt_add_dirty_flag(info, mo, ma);
ma->ma_need = MA_INODE;
ma->ma_valid = 0;
rc = mdt_attr_get_complex(info, mo, ma);
if (rc != 0)
GOTO(out_put, rc);
mdt_pack_attr2body(info, repbody, &ma->ma_attr, mdt_object_fid(mo));
if (info->mti_mdt->mdt_opts.mo_oss_capa &&
exp_connect_flags(info->mti_exp) & OBD_CONNECT_OSS_CAPA &&
S_ISREG(lu_object_attr(&mo->mot_obj.mo_lu)) &&
(ma->ma_attr.la_valid & LA_SIZE) && !som_au) {
struct lustre_capa *capa;
capa = req_capsule_server_get(info->mti_pill, &RMF_CAPA2);
LASSERT(capa);
capa->lc_opc = CAPA_OPC_OSS_DEFAULT | CAPA_OPC_OSS_TRUNC;
rc = mo_capa_get(info->mti_env, mdt_object_child(mo), capa, 0);
if (rc)
GOTO(out_put, rc);
repbody->valid |= OBD_MD_FLOSSCAPA;
}
EXIT;
out_put:
mdt_object_put(info->mti_env, mo);
out:
if (rc == 0)
mdt_counter_incr(req, LPROC_MDT_SETATTR);
mdt_client_compatibility(info);
rc2 = mdt_fix_reply(info);
if (rc == 0)
rc = rc2;
return rc;
}
int mdt_reint_setxattr(struct mdt_thread_info *info,
struct mdt_lock_handle *unused)
{
struct ptlrpc_request *req = mdt_info_req(info);
struct mdt_lock_handle *lh;
const struct lu_env *env = info->mti_env;
struct lu_buf *buf = &info->mti_buf;
struct mdt_reint_record *rr = &info->mti_rr;
struct md_attr *ma = &info->mti_attr;
struct lu_attr *attr = &info->mti_attr.ma_attr;
struct mdt_object *obj;
struct md_object *child;
__u64 valid = attr->la_valid;
const char *xattr_name = rr->rr_name.ln_name;
int xattr_len = rr->rr_eadatalen;
__u64 lockpart = MDS_INODELOCK_UPDATE;
int rc;
ENTRY;
CDEBUG(D_INODE, "setxattr for "DFID": %s %s\n", PFID(rr->rr_fid1),
valid & OBD_MD_FLXATTR ? "set" : "remove", xattr_name);
if (info->mti_dlm_req)
ldlm_request_cancel(req, info->mti_dlm_req, 0, LATF_SKIP);
if (OBD_FAIL_CHECK(OBD_FAIL_MDS_SETXATTR))
RETURN(err_serious(-ENOMEM));
rc = mdt_init_ucred_reint(info);
if (rc != 0)
RETURN(rc);
if (strncmp(xattr_name, XATTR_USER_PREFIX,
sizeof(XATTR_USER_PREFIX) - 1) == 0) {
if (!(exp_connect_flags(req->rq_export) & OBD_CONNECT_XATTR))
GOTO(out, rc = -EOPNOTSUPP);
} else if (strncmp(xattr_name, XATTR_TRUSTED_PREFIX,
sizeof(XATTR_TRUSTED_PREFIX) - 1) == 0) {
/* setxattr(LMV) with lum is used to shrink dir layout */
if (strcmp(xattr_name, XATTR_NAME_LMV) == 0) {
__u32 *magic = rr->rr_eadata;
/* we don't let to remove LMV? */
if (!rr->rr_eadata)
GOTO(out, rc = 0);
if (le32_to_cpu(*magic) == LMV_USER_MAGIC ||
le32_to_cpu(*magic) == LMV_USER_MAGIC_SPECIFIC) {
rc = mdt_dir_layout_shrink(info);
GOTO(out, rc);
}
}
if (!md_capable(mdt_ucred(info), CFS_CAP_SYS_ADMIN))
GOTO(out, rc = -EPERM);
if (strcmp(xattr_name, XATTR_NAME_LOV) == 0 ||
strcmp(xattr_name, XATTR_NAME_LMA) == 0 ||
strcmp(xattr_name, XATTR_NAME_LMV) == 0 ||
strcmp(xattr_name, XATTR_NAME_LINK) == 0 ||
strcmp(xattr_name, XATTR_NAME_FID) == 0 ||
strcmp(xattr_name, XATTR_NAME_VERSION) == 0 ||
strcmp(xattr_name, XATTR_NAME_SOM) == 0 ||
strcmp(xattr_name, XATTR_NAME_HSM) == 0 ||
strcmp(xattr_name, XATTR_NAME_LFSCK_NAMESPACE) == 0)
GOTO(out, rc = 0);
} else if ((valid & OBD_MD_FLXATTR) &&
(strcmp(xattr_name, XATTR_NAME_ACL_ACCESS) == 0 ||
strcmp(xattr_name, XATTR_NAME_ACL_DEFAULT) == 0)) {
rc = mdt_nodemap_map_acl(info, rr->rr_eadata, xattr_len,
xattr_name, NODEMAP_CLIENT_TO_FS);
if (rc < 0)
GOTO(out, rc);
/* ACLs were mapped out, return an error so the user knows */
if (rc != xattr_len)
GOTO(out, rc = -EPERM);
} else if ((strlen(xattr_name) > strlen(XATTR_LUSTRE_LOV) + 1) &&
strncmp(xattr_name, XATTR_LUSTRE_LOV,
strlen(XATTR_LUSTRE_LOV)) == 0) {
if (strncmp(xattr_name, XATTR_LUSTRE_LOV".add",
strlen(XATTR_LUSTRE_LOV".add")) &&
strncmp(xattr_name, XATTR_LUSTRE_LOV".set",
strlen(XATTR_LUSTRE_LOV".set")) &&
strncmp(xattr_name, XATTR_LUSTRE_LOV".del",
strlen(XATTR_LUSTRE_LOV".del"))) {
CERROR("%s: invalid xattr name: %s\n",
mdt_obd_name(info->mti_mdt), xattr_name);
GOTO(out, rc = -EINVAL);
}
lockpart |= MDS_INODELOCK_LAYOUT;
}
/* Revoke all clients' lookup lock, since the access
* permissions for this inode is changed when ACL_ACCESS is
* set. This isn't needed for ACL_DEFAULT, since that does
* not change the access permissions of this inode, nor any
* other existing inodes. It is setting the ACLs inherited
* by new directories/files at create time. */
/* We need revoke both LOOKUP|PERM lock here, see mdt_attr_set. */
if (!strcmp(xattr_name, XATTR_NAME_ACL_ACCESS))
lockpart |= MDS_INODELOCK_PERM | MDS_INODELOCK_LOOKUP;
/* We need to take the lock on behalf of old clients so that newer
* clients flush their xattr caches */
else
lockpart |= MDS_INODELOCK_XATTR;
lh = &info->mti_lh[MDT_LH_PARENT];
/* ACLs were sent to clients under LCK_CR locks, so taking LCK_EX
* to cancel them. */
mdt_lock_reg_init(lh, LCK_EX);
obj = mdt_object_find_lock(info, rr->rr_fid1, lh, lockpart);
if (IS_ERR(obj))
GOTO(out, rc = PTR_ERR(obj));
tgt_vbr_obj_set(env, mdt_obj2dt(obj));
rc = mdt_version_get_check_save(info, obj, 0);
if (rc)
GOTO(out_unlock, rc);
if (unlikely(!(valid & OBD_MD_FLCTIME))) {
/* This isn't strictly an error, but all current clients
* should set OBD_MD_FLCTIME when setting attributes. */
CWARN("%s: client miss to set OBD_MD_FLCTIME when "
"setxattr %s: [object "DFID"] [valid %llu]\n",
mdt_obd_name(info->mti_mdt), xattr_name,
PFID(rr->rr_fid1), valid);
attr->la_ctime = ktime_get_real_seconds();
}
attr->la_valid = LA_CTIME;
child = mdt_object_child(obj);
if (valid & OBD_MD_FLXATTR) {
int flags = 0;
if (attr->la_flags & XATTR_REPLACE)
flags |= LU_XATTR_REPLACE;
if (attr->la_flags & XATTR_CREATE)
flags |= LU_XATTR_CREATE;
mdt_fail_write(env, info->mti_mdt->mdt_bottom,
OBD_FAIL_MDS_SETXATTR_WRITE);
buf->lb_buf = rr->rr_eadata;
buf->lb_len = xattr_len;
rc = mo_xattr_set(env, child, buf, xattr_name, flags);
/* update ctime after xattr changed */
if (rc == 0) {
ma->ma_attr_flags |= MDS_PERM_BYPASS;
mo_attr_set(env, child, ma);
}
} else if (valid & OBD_MD_FLXATTRRM) {
rc = mo_xattr_del(env, child, xattr_name);
/* update ctime after xattr changed */
if (rc == 0) {
ma->ma_attr_flags |= MDS_PERM_BYPASS;
mo_attr_set(env, child, ma);
}
} else {
CDEBUG(D_INFO, "valid bits: %#llx\n", valid);
rc = -EINVAL;
}
if (rc == 0)
mdt_counter_incr(req, LPROC_MDT_SETXATTR);
EXIT;
out_unlock:
mdt_object_unlock_put(info, obj, lh, rc);
out:
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);
}
int mdt_reint_setxattr(struct mdt_thread_info *info,
struct mdt_lock_handle *unused)
{
struct ptlrpc_request *req = mdt_info_req(info);
struct md_ucred *uc = mdt_ucred(info);
struct mdt_lock_handle *lh;
const struct lu_env *env = info->mti_env;
struct lu_buf *buf = &info->mti_buf;
struct mdt_reint_record *rr = &info->mti_rr;
struct md_attr *ma = &info->mti_attr;
struct lu_attr *attr = &info->mti_attr.ma_attr;
struct mdt_object *obj;
struct md_object *child;
__u64 valid = attr->la_valid;
const char *xattr_name = rr->rr_name;
int xattr_len = rr->rr_eadatalen;
__u64 lockpart;
int rc;
posix_acl_xattr_header *new_xattr = NULL;
__u32 remote = exp_connect_rmtclient(info->mti_exp);
__u32 perm;
ENTRY;
CDEBUG(D_INODE, "setxattr for "DFID"\n", PFID(rr->rr_fid1));
if (OBD_FAIL_CHECK(OBD_FAIL_MDS_SETXATTR))
RETURN(err_serious(-ENOMEM));
CDEBUG(D_INODE, "%s xattr %s\n",
valid & OBD_MD_FLXATTR ? "set" : "remove", xattr_name);
rc = mdt_init_ucred_reint(info);
if (rc != 0)
RETURN(rc);
if (valid & OBD_MD_FLRMTRSETFACL) {
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));
}
if (strncmp(xattr_name, XATTR_USER_PREFIX,
sizeof(XATTR_USER_PREFIX) - 1) == 0) {
if (!(req->rq_export->exp_connect_flags & OBD_CONNECT_XATTR))
GOTO(out, rc = -EOPNOTSUPP);
if (strcmp(xattr_name, XATTR_NAME_LOV) == 0)
GOTO(out, rc = -EACCES);
if (strcmp(xattr_name, XATTR_NAME_LMA) == 0)
GOTO(out, rc = 0);
if (strcmp(xattr_name, XATTR_NAME_LINK) == 0)
GOTO(out, rc = 0);
} else if ((valid & OBD_MD_FLXATTR) &&
(strncmp(xattr_name, XATTR_NAME_ACL_ACCESS,
sizeof(XATTR_NAME_ACL_ACCESS) - 1) == 0 ||
strncmp(xattr_name, XATTR_NAME_ACL_DEFAULT,
sizeof(XATTR_NAME_ACL_DEFAULT) - 1) == 0)) {
/* currently lustre limit acl access size */
if (xattr_len > LUSTRE_POSIX_ACL_MAX_SIZE)
GOTO(out, -ERANGE);
}
lockpart = MDS_INODELOCK_UPDATE;
/* Revoke all clients' lookup lock, since the access
* permissions for this inode is changed when ACL_ACCESS is
* set. This isn't needed for ACL_DEFAULT, since that does
* not change the access permissions of this inode, nor any
* other existing inodes. It is setting the ACLs inherited
* by new directories/files at create time. */
if (!strcmp(xattr_name, XATTR_NAME_ACL_ACCESS))
lockpart |= MDS_INODELOCK_LOOKUP;
lh = &info->mti_lh[MDT_LH_PARENT];
/* ACLs were sent to clients under LCK_CR locks, so taking LCK_EX
* to cancel them. */
mdt_lock_reg_init(lh, LCK_EX);
obj = mdt_object_find_lock(info, rr->rr_fid1, lh, lockpart);
if (IS_ERR(obj))
GOTO(out, rc = PTR_ERR(obj));
info->mti_mos = obj;
rc = mdt_version_get_check_save(info, obj, 0);
if (rc)
GOTO(out_unlock, rc);
if (unlikely(!(valid & OBD_MD_FLCTIME))) {
/* This isn't strictly an error, but all current clients
* should set OBD_MD_FLCTIME when setting attributes. */
CWARN("%s: client miss to set OBD_MD_FLCTIME when "
"setxattr %s: [object "DFID"] [valid "LPU64"]\n",
info->mti_exp->exp_obd->obd_name, xattr_name,
PFID(rr->rr_fid1), valid);
attr->la_ctime = cfs_time_current_sec();
}
attr->la_valid = LA_CTIME;
child = mdt_object_child(obj);
if (valid & OBD_MD_FLXATTR) {
char *xattr = (void *)rr->rr_eadata;
if (xattr_len > 0) {
int flags = 0;
if (valid & OBD_MD_FLRMTLSETFACL) {
if (unlikely(!remote))
GOTO(out_unlock, rc = -EINVAL);
xattr_len = mdt_rmtlsetfacl(info, child,
xattr_name,
(ext_acl_xattr_header *)xattr,
&new_xattr);
if (xattr_len < 0)
GOTO(out_unlock, rc = xattr_len);
xattr = (char *)new_xattr;
}
if (attr->la_flags & XATTR_REPLACE)
flags |= LU_XATTR_REPLACE;
if (attr->la_flags & XATTR_CREATE)
flags |= LU_XATTR_CREATE;
mdt_fail_write(env, info->mti_mdt->mdt_bottom,
OBD_FAIL_MDS_SETXATTR_WRITE);
buf->lb_buf = xattr;
buf->lb_len = xattr_len;
rc = mo_xattr_set(env, child, buf, xattr_name, flags);
/* update ctime after xattr changed */
if (rc == 0) {
ma->ma_attr_flags |= MDS_PERM_BYPASS;
mo_attr_set(env, child, ma);
}
}
} else if (valid & OBD_MD_FLXATTRRM) {
rc = mo_xattr_del(env, child, xattr_name);
/* update ctime after xattr changed */
if (rc == 0) {
ma->ma_attr_flags |= MDS_PERM_BYPASS;
mo_attr_set(env, child, ma);
}
} else {
CDEBUG(D_INFO, "valid bits: "LPX64"\n", valid);
rc = -EINVAL;
}
if (rc == 0)
mdt_counter_incr(req->rq_export, LPROC_MDT_SETXATTR);
EXIT;
out_unlock:
mdt_object_unlock_put(info, obj, lh, rc);
if (unlikely(new_xattr != NULL))
lustre_posix_acl_xattr_free(new_xattr, xattr_len);
out:
mdt_exit_ucred(info);
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 lu_ucred *uc = lu_ucred(info->mti_env);
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;
obd_valid 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->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->uc_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;
valid = info->mti_body->valid & (OBD_MD_FLXATTR | OBD_MD_FLXATTRLS);
if (valid == OBD_MD_FLXATTR) {
char *xattr_name = req_capsule_client_get(info->mti_pill,
&RMF_NAME);
rc = mdt_getxattr_one(info, xattr_name, next, buf, med, uc);
} 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);
repbody->eadatasize = rc;
rc = 0;
}
mdt_exit_ucred(info);
return rc;
}
/*
* VBR: save parent version in reply and child version getting by its name.
* Version of child is getting and checking during its lookup. If
*/
static int mdt_reint_unlink(struct mdt_thread_info *info,
struct mdt_lock_handle *lhc)
{
struct mdt_reint_record *rr = &info->mti_rr;
struct ptlrpc_request *req = mdt_info_req(info);
struct md_attr *ma = &info->mti_attr;
struct lu_fid *child_fid = &info->mti_tmp_fid1;
struct mdt_object *mp;
struct mdt_object *mc;
struct mdt_lock_handle *parent_lh;
struct mdt_lock_handle *child_lh;
struct lu_name *lname;
int rc;
ENTRY;
DEBUG_REQ(D_INODE, req, "unlink "DFID"/%s", PFID(rr->rr_fid1),
rr->rr_name);
if (info->mti_dlm_req)
ldlm_request_cancel(req, info->mti_dlm_req, 0);
if (OBD_FAIL_CHECK(OBD_FAIL_MDS_REINT_UNLINK))
RETURN(err_serious(-ENOENT));
/*
* step 1: lock the parent. Note, this may be child in case of
* remote operation denoted by ->mti_cross_ref flag.
*/
parent_lh = &info->mti_lh[MDT_LH_PARENT];
if (info->mti_cross_ref) {
/*
* Init reg lock for cross ref case when we need to do only
* ref del locally.
*/
mdt_lock_reg_init(parent_lh, LCK_PW);
} else {
mdt_lock_pdo_init(parent_lh, LCK_PW, rr->rr_name,
rr->rr_namelen);
}
mp = mdt_object_find_lock(info, rr->rr_fid1, parent_lh,
MDS_INODELOCK_UPDATE, MDT_OBJ_MUST_EXIST);
if (IS_ERR(mp)) {
rc = PTR_ERR(mp);
/* errors are possible here in cross-ref cases, see below */
if (info->mti_cross_ref)
rc = 0;
GOTO(out, rc);
}
rc = mdt_version_get_check_save(info, mp, 0);
if (rc)
GOTO(out_unlock_parent, rc);
mdt_reint_init_ma(info, ma);
if (!ma->ma_lmm || !ma->ma_cookie)
GOTO(out_unlock_parent, rc = -EINVAL);
if (info->mti_cross_ref) {
/*
* Remote partial operation. It is possible that replay may
* happen on parent MDT and this operation will be repeated.
* Therefore the object absense is allowed case and nothing
* should be done here.
*/
if (mdt_object_exists(mp) > 0) {
mdt_set_capainfo(info, 0, rr->rr_fid1, BYPASS_CAPA);
rc = mo_ref_del(info->mti_env,
mdt_object_child(mp), ma);
if (rc == 0)
mdt_handle_last_unlink(info, mp, ma);
} else
rc = 0;
GOTO(out_unlock_parent, rc);
}
/* step 2: find & lock the child */
lname = mdt_name(info->mti_env, (char *)rr->rr_name, rr->rr_namelen);
/* lookup child object along with version checking */
rc = mdt_lookup_version_check(info, mp, lname, child_fid, 1);
if (rc != 0)
GOTO(out_unlock_parent, rc);
/* We will lock the child regardless it is local or remote. No harm. */
mc = mdt_object_find(info->mti_env, info->mti_mdt, child_fid,
MDT_OBJ_MUST_EXIST);
if (IS_ERR(mc))
GOTO(out_unlock_parent, rc = PTR_ERR(mc));
child_lh = &info->mti_lh[MDT_LH_CHILD];
mdt_lock_reg_init(child_lh, LCK_EX);
rc = mdt_object_lock(info, mc, child_lh, MDS_INODELOCK_FULL,
MDT_CROSS_LOCK);
if (rc != 0) {
mdt_object_put(info->mti_env, mc);
GOTO(out_unlock_parent, rc);
}
mdt_fail_write(info->mti_env, info->mti_mdt->mdt_bottom,
OBD_FAIL_MDS_REINT_UNLINK_WRITE);
/* save version when object is locked */
mdt_version_get_save(info, mc, 1);
/*
* Now we can only make sure we need MA_INODE, in mdd layer, will check
* whether need MA_LOV and MA_COOKIE.
*/
ma->ma_need = MA_INODE;
ma->ma_valid = 0;
mdt_set_capainfo(info, 1, child_fid, BYPASS_CAPA);
rc = mdo_unlink(info->mti_env, mdt_object_child(mp),
mdt_object_child(mc), lname, ma);
if (rc == 0)
mdt_handle_last_unlink(info, mc, ma);
if (ma->ma_valid & MA_INODE) {
switch (ma->ma_attr.la_mode & S_IFMT) {
case S_IFDIR:
mdt_counter_incr(req->rq_export, LPROC_MDT_RMDIR);
break;
case S_IFREG:
case S_IFLNK:
case S_IFCHR:
case S_IFBLK:
case S_IFIFO:
case S_IFSOCK:
mdt_counter_incr(req->rq_export, LPROC_MDT_UNLINK);
break;
default:
LASSERTF(0, "bad file type %o unlinking\n",
ma->ma_attr.la_mode);
}
}
EXIT;
mdt_object_unlock_put(info, mc, child_lh, rc);
out_unlock_parent:
mdt_object_unlock_put(info, mp, parent_lh, rc);
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;
}
/*
* VBR: save parent version in reply and child version getting by its name.
* Version of child is getting and checking during its lookup. If
*/
static int mdt_reint_unlink(struct mdt_thread_info *info,
struct mdt_lock_handle *lhc)
{
struct mdt_reint_record *rr = &info->mti_rr;
struct ptlrpc_request *req = mdt_info_req(info);
struct md_attr *ma = &info->mti_attr;
struct lu_fid *child_fid = &info->mti_tmp_fid1;
struct mdt_object *mp;
struct mdt_object *mc;
struct mdt_lock_handle *parent_lh;
struct mdt_lock_handle *child_lh;
struct lu_name *lname;
int rc;
ENTRY;
DEBUG_REQ(D_INODE, req, "unlink "DFID"/%s", PFID(rr->rr_fid1),
rr->rr_name);
if (info->mti_dlm_req)
ldlm_request_cancel(req, info->mti_dlm_req, 0);
if (OBD_FAIL_CHECK(OBD_FAIL_MDS_REINT_UNLINK))
RETURN(err_serious(-ENOENT));
/*
* step 1: Found the parent.
*/
mp = mdt_object_find(info->mti_env, info->mti_mdt, rr->rr_fid1);
if (IS_ERR(mp)) {
rc = PTR_ERR(mp);
GOTO(out, rc);
}
if (mdt_object_obf(mp))
GOTO(put_parent, rc = -EPERM);
parent_lh = &info->mti_lh[MDT_LH_PARENT];
lname = mdt_name(info->mti_env, (char *)rr->rr_name, rr->rr_namelen);
if (mdt_object_remote(mp)) {
mdt_lock_reg_init(parent_lh, LCK_EX);
rc = mdt_remote_object_lock(info, mp, &parent_lh->mlh_rreg_lh,
parent_lh->mlh_rreg_mode,
MDS_INODELOCK_UPDATE);
if (rc != ELDLM_OK)
GOTO(put_parent, rc);
} else {
mdt_lock_pdo_init(parent_lh, LCK_PW, rr->rr_name,
rr->rr_namelen);
rc = mdt_object_lock(info, mp, parent_lh, MDS_INODELOCK_UPDATE,
MDT_LOCAL_LOCK);
if (rc)
GOTO(put_parent, rc);
rc = mdt_version_get_check_save(info, mp, 0);
if (rc)
GOTO(unlock_parent, rc);
}
/* step 2: find & lock the child */
/* lookup child object along with version checking */
fid_zero(child_fid);
rc = mdt_lookup_version_check(info, mp, lname, child_fid, 1);
if (rc != 0)
GOTO(unlock_parent, rc);
mdt_reint_init_ma(info, ma);
/* We will lock the child regardless it is local or remote. No harm. */
mc = mdt_object_find(info->mti_env, info->mti_mdt, child_fid);
if (IS_ERR(mc))
GOTO(unlock_parent, rc = PTR_ERR(mc));
child_lh = &info->mti_lh[MDT_LH_CHILD];
mdt_lock_reg_init(child_lh, LCK_EX);
if (mdt_object_remote(mc)) {
struct mdt_body *repbody;
if (!fid_is_zero(rr->rr_fid2)) {
CDEBUG(D_INFO, "%s: name %s can not find "DFID"\n",
mdt2obd_dev(info->mti_mdt)->obd_name,
(char *)rr->rr_name, PFID(mdt_object_fid(mc)));
GOTO(unlock_parent, rc = -ENOENT);
}
CDEBUG(D_INFO, "%s: name %s: "DFID" is another MDT\n",
mdt2obd_dev(info->mti_mdt)->obd_name,
(char *)rr->rr_name, PFID(mdt_object_fid(mc)));
if (info->mti_spec.sp_rm_entry) {
struct lu_ucred *uc = mdt_ucred(info);
if (!md_capable(uc, CFS_CAP_SYS_ADMIN)) {
CERROR("%s: unlink remote entry is only "
"permitted for administrator: rc = %d\n",
mdt2obd_dev(info->mti_mdt)->obd_name,
-EPERM);
GOTO(unlock_parent, rc = -EPERM);
}
ma->ma_need = MA_INODE;
ma->ma_valid = 0;
mdt_set_capainfo(info, 1, child_fid, BYPASS_CAPA);
rc = mdo_unlink(info->mti_env, mdt_object_child(mp),
NULL, lname, ma);
mdt_object_put(info->mti_env, mc);
GOTO(unlock_parent, rc);
}
/* Revoke the LOOKUP lock of the remote object granted by
* this MDT. Since the unlink will happen on another MDT,
* it will release the LOOKUP lock right away. Then What
* would happen if another client try to grab the LOOKUP
* lock at the same time with unlink XXX */
mdt_object_lock(info, mc, child_lh, MDS_INODELOCK_LOOKUP,
MDT_CROSS_LOCK);
repbody = req_capsule_server_get(info->mti_pill, &RMF_MDT_BODY);
LASSERT(repbody != NULL);
repbody->fid1 = *mdt_object_fid(mc);
repbody->valid |= (OBD_MD_FLID | OBD_MD_MDS);
mdt_object_unlock_put(info, mc, child_lh, rc);
GOTO(unlock_parent, rc = -EREMOTE);
} else if (info->mti_spec.sp_rm_entry) {
CERROR("%s: lfs rmdir should not be used on local dir %s\n",
mdt2obd_dev(info->mti_mdt)->obd_name,
(char *)rr->rr_name);
mdt_object_put(info->mti_env, mc);
GOTO(unlock_parent, rc = -EPERM);
}
rc = mdt_object_lock(info, mc, child_lh, MDS_INODELOCK_FULL,
MDT_CROSS_LOCK);
if (rc != 0) {
mdt_object_put(info->mti_env, mc);
GOTO(unlock_parent, rc);
}
mdt_fail_write(info->mti_env, info->mti_mdt->mdt_bottom,
OBD_FAIL_MDS_REINT_UNLINK_WRITE);
/* save version when object is locked */
mdt_version_get_save(info, mc, 1);
/*
* Now we can only make sure we need MA_INODE, in mdd layer, will check
* whether need MA_LOV and MA_COOKIE.
*/
ma->ma_need = MA_INODE;
ma->ma_valid = 0;
mdt_set_capainfo(info, 1, child_fid, BYPASS_CAPA);
rc = mdo_unlink(info->mti_env, mdt_object_child(mp),
mdt_object_child(mc), lname, ma);
if (rc == 0 && !lu_object_is_dying(&mc->mot_header))
rc = mdt_attr_get_complex(info, mc, ma);
if (rc == 0)
mdt_handle_last_unlink(info, mc, ma);
if (ma->ma_valid & MA_INODE) {
switch (ma->ma_attr.la_mode & S_IFMT) {
case S_IFDIR:
mdt_counter_incr(req, LPROC_MDT_RMDIR);
break;
case S_IFREG:
case S_IFLNK:
case S_IFCHR:
case S_IFBLK:
case S_IFIFO:
case S_IFSOCK:
mdt_counter_incr(req, LPROC_MDT_UNLINK);
break;
default:
LASSERTF(0, "bad file type %o unlinking\n",
ma->ma_attr.la_mode);
}
}
EXIT;
mdt_object_unlock_put(info, mc, child_lh, rc);
unlock_parent:
mdt_object_unlock(info, mp, parent_lh, rc);
put_parent:
mdt_object_put(info->mti_env, mp);
out:
return rc;
}
/*
* VBR: save versions in reply: 0 - parent; 1 - child by fid; 2 - target by
* name.
*/
static int mdt_reint_link(struct mdt_thread_info *info,
struct mdt_lock_handle *lhc)
{
struct mdt_reint_record *rr = &info->mti_rr;
struct ptlrpc_request *req = mdt_info_req(info);
struct md_attr *ma = &info->mti_attr;
struct mdt_object *ms;
struct mdt_object *mp;
struct mdt_lock_handle *lhs;
struct mdt_lock_handle *lhp;
struct lu_name *lname;
int rc;
ENTRY;
DEBUG_REQ(D_INODE, req, "link "DFID" to "DFID"/%s",
PFID(rr->rr_fid1), PFID(rr->rr_fid2), rr->rr_name);
if (OBD_FAIL_CHECK(OBD_FAIL_MDS_REINT_LINK))
RETURN(err_serious(-ENOENT));
if (info->mti_dlm_req)
ldlm_request_cancel(req, info->mti_dlm_req, 0);
/* Invalid case so return error immediately instead of
* processing it */
if (lu_fid_eq(rr->rr_fid1, rr->rr_fid2))
RETURN(-EPERM);
/* step 1: find & lock the target parent dir */
lhp = &info->mti_lh[MDT_LH_PARENT];
mdt_lock_pdo_init(lhp, LCK_PW, rr->rr_name,
rr->rr_namelen);
mp = mdt_object_find_lock(info, rr->rr_fid2, lhp,
MDS_INODELOCK_UPDATE);
if (IS_ERR(mp))
RETURN(PTR_ERR(mp));
if (mdt_object_obf(mp))
GOTO(out_unlock_parent, rc = -EPERM);
rc = mdt_version_get_check_save(info, mp, 0);
if (rc)
GOTO(out_unlock_parent, rc);
/* step 2: find & lock the source */
lhs = &info->mti_lh[MDT_LH_CHILD];
mdt_lock_reg_init(lhs, LCK_EX);
ms = mdt_object_find(info->mti_env, info->mti_mdt, rr->rr_fid1);
if (IS_ERR(ms))
GOTO(out_unlock_parent, rc = PTR_ERR(ms));
if (mdt_object_remote(ms)) {
mdt_object_put(info->mti_env, ms);
CERROR("Target directory "DFID" is on another MDT\n",
PFID(rr->rr_fid1));
GOTO(out_unlock_parent, rc = -EXDEV);
}
rc = mdt_object_lock(info, ms, lhs, MDS_INODELOCK_UPDATE,
MDT_CROSS_LOCK);
if (rc != 0) {
mdt_object_put(info->mti_env, ms);
GOTO(out_unlock_parent, rc);
}
/* step 3: link it */
mdt_fail_write(info->mti_env, info->mti_mdt->mdt_bottom,
OBD_FAIL_MDS_REINT_LINK_WRITE);
info->mti_mos = ms;
rc = mdt_version_get_check_save(info, ms, 1);
if (rc)
GOTO(out_unlock_child, rc);
lname = mdt_name(info->mti_env, (char *)rr->rr_name, rr->rr_namelen);
/** check target version by name during replay */
rc = mdt_lookup_version_check(info, mp, lname, &info->mti_tmp_fid1, 2);
if (rc != 0 && rc != -ENOENT)
GOTO(out_unlock_child, rc);
/* save version of file name for replay, it must be ENOENT here */
if (!req_is_replay(mdt_info_req(info))) {
info->mti_ver[2] = ENOENT_VERSION;
mdt_version_save(mdt_info_req(info), info->mti_ver[2], 2);
}
rc = mdo_link(info->mti_env, mdt_object_child(mp),
mdt_object_child(ms), lname, ma);
if (rc == 0)
mdt_counter_incr(req, LPROC_MDT_LINK);
EXIT;
out_unlock_child:
mdt_object_unlock_put(info, ms, lhs, rc);
out_unlock_parent:
mdt_object_unlock_put(info, mp, lhp, rc);
return rc;
}
/*
* VBR: we save three versions in reply:
* 0 - parent. Check that parent version is the same during replay.
* 1 - name. Version of 'name' if file exists with the same name or
* ENOENT_VERSION, it is needed because file may appear due to missed replays.
* 2 - child. Version of child by FID. Must be ENOENT. It is mostly sanity
* check.
*/
static int mdt_md_create(struct mdt_thread_info *info)
{
struct mdt_device *mdt = info->mti_mdt;
struct mdt_object *parent;
struct mdt_object *child;
struct mdt_lock_handle *lh;
struct mdt_body *repbody;
struct md_attr *ma = &info->mti_attr;
struct mdt_reint_record *rr = &info->mti_rr;
struct lu_name *lname;
int rc;
ENTRY;
DEBUG_REQ(D_INODE, mdt_info_req(info), "Create (%s->"DFID") in "DFID,
rr->rr_name, PFID(rr->rr_fid2), PFID(rr->rr_fid1));
repbody = req_capsule_server_get(info->mti_pill, &RMF_MDT_BODY);
lh = &info->mti_lh[MDT_LH_PARENT];
mdt_lock_pdo_init(lh, LCK_PW, rr->rr_name, rr->rr_namelen);
parent = mdt_object_find_lock(info, rr->rr_fid1, lh,
MDS_INODELOCK_UPDATE, MDT_OBJ_MUST_EXIST);
if (IS_ERR(parent))
RETURN(PTR_ERR(parent));
rc = mdt_version_get_check_save(info, parent, 0);
if (rc)
GOTO(out_put_parent, rc);
/*
* Check child name version during replay.
* During create replay a file may exist with same name.
*/
lname = mdt_name(info->mti_env, (char *)rr->rr_name, rr->rr_namelen);
rc = mdt_lookup_version_check(info, parent, lname,
&info->mti_tmp_fid1, 1);
/* -ENOENT is expected here */
if (rc != 0 && rc != -ENOENT)
GOTO(out_put_parent, rc);
/* save version of file name for replay, it must be ENOENT here */
mdt_enoent_version_save(info, 1);
child = mdt_object_find(info->mti_env, mdt, rr->rr_fid2,
MDT_OBJ_MAY_NOT_EXIST);
if (likely(!IS_ERR(child))) {
struct md_object *next = mdt_object_child(parent);
ma->ma_need = MA_INODE;
ma->ma_valid = 0;
/* capa for cross-ref will be stored here */
ma->ma_capa = req_capsule_server_get(info->mti_pill,
&RMF_CAPA1);
LASSERT(ma->ma_capa);
mdt_fail_write(info->mti_env, info->mti_mdt->mdt_bottom,
OBD_FAIL_MDS_REINT_CREATE_WRITE);
/* Version of child will be updated on disk. */
info->mti_mos = child;
rc = mdt_version_get_check_save(info, child, 2);
if (rc)
GOTO(out_put_child, rc);
/* Let lower layer know current lock mode. */
info->mti_spec.sp_cr_mode =
mdt_dlm_mode2mdl_mode(lh->mlh_pdo_mode);
/*
* Do perform lookup sanity check. We do not know if name exists
* or not.
*/
info->mti_spec.sp_cr_lookup = 1;
info->mti_spec.sp_feat = &dt_directory_features;
rc = mdo_create(info->mti_env, next, lname,
mdt_object_child(child),
&info->mti_spec, ma);
if (rc == 0) {
/* Return fid & attr to client. */
if (ma->ma_valid & MA_INODE)
mdt_pack_attr2body(info, repbody, &ma->ma_attr,
mdt_object_fid(child));
}
out_put_child:
mdt_object_put(info->mti_env, child);
} else {
rc = PTR_ERR(child);
}
mdt_create_pack_capa(info, rc, child, repbody);
out_put_parent:
mdt_object_unlock_put(info, parent, lh, rc);
RETURN(rc);
}