static int mdt_rename_unpack(struct mdt_thread_info *info)
{
struct lu_ucred *uc = mdt_ucred(info);
struct mdt_rec_rename *rec;
struct md_attr *ma = &info->mti_attr;
struct lu_attr *attr = &info->mti_attr.ma_attr;
struct mdt_reint_record *rr = &info->mti_rr;
struct req_capsule *pill = info->mti_pill;
int rc;
ENTRY;
CLASSERT(sizeof(struct mdt_rec_rename) == sizeof(struct mdt_rec_reint));
rec = req_capsule_client_get(pill, &RMF_REC_REINT);
if (rec == NULL)
RETURN(-EFAULT);
/* This prior initialization is needed for old_init_ucred_reint() */
uc->uc_fsuid = rec->rn_fsuid;
uc->uc_fsgid = rec->rn_fsgid;
uc->uc_cap = rec->rn_cap;
uc->uc_suppgids[0] = rec->rn_suppgid1;
uc->uc_suppgids[1] = rec->rn_suppgid2;
attr->la_uid = rec->rn_fsuid;
attr->la_gid = rec->rn_fsgid;
rr->rr_fid1 = &rec->rn_fid1;
rr->rr_fid2 = &rec->rn_fid2;
attr->la_ctime = rec->rn_time;
attr->la_mtime = rec->rn_time;
/* rename_tgt contains the mode already */
attr->la_mode = rec->rn_mode;
attr->la_valid = LA_UID | LA_GID | LA_CTIME | LA_MTIME | LA_MODE;
if (req_capsule_get_size(pill, &RMF_CAPA1, RCL_CLIENT))
mdt_set_capainfo(info, 0, rr->rr_fid1,
req_capsule_client_get(pill, &RMF_CAPA1));
if (req_capsule_get_size(pill, &RMF_CAPA2, RCL_CLIENT))
mdt_set_capainfo(info, 1, rr->rr_fid2,
req_capsule_client_get(pill, &RMF_CAPA2));
rc = mdt_name_unpack(pill, &RMF_NAME, &rr->rr_name, 0);
if (rc < 0)
RETURN(rc);
rc = mdt_name_unpack(pill, &RMF_SYMTGT, &rr->rr_tgt_name, 0);
if (rc < 0)
RETURN(rc);
if (rec->rn_bias & MDS_VTX_BYPASS)
ma->ma_attr_flags |= MDS_VTX_BYPASS;
else
ma->ma_attr_flags &= ~MDS_VTX_BYPASS;
info->mti_spec.no_create = !!req_is_replay(mdt_info_req(info));
rc = mdt_dlmreq_unpack(info);
RETURN(rc);
}
static int mdt_rename_unpack(struct mdt_thread_info *info)
{
struct md_ucred *uc = mdt_ucred(info);
struct mdt_rec_rename *rec;
struct md_attr *ma = &info->mti_attr;
struct lu_attr *attr = &info->mti_attr.ma_attr;
struct mdt_reint_record *rr = &info->mti_rr;
struct req_capsule *pill = info->mti_pill;
int rc;
ENTRY;
CLASSERT(sizeof(struct mdt_rec_rename) == sizeof(struct mdt_rec_reint));
rec = req_capsule_client_get(pill, &RMF_REC_REINT);
if (rec == NULL)
RETURN(-EFAULT);
uc->mu_fsuid = rec->rn_fsuid;
uc->mu_fsgid = rec->rn_fsgid;
uc->mu_cap = rec->rn_cap;
uc->mu_suppgids[0] = rec->rn_suppgid1;
uc->mu_suppgids[1] = rec->rn_suppgid2;
attr->la_uid = rec->rn_fsuid;
attr->la_gid = rec->rn_fsgid;
rr->rr_fid1 = &rec->rn_fid1;
rr->rr_fid2 = &rec->rn_fid2;
attr->la_ctime = rec->rn_time;
attr->la_mtime = rec->rn_time;
/* rename_tgt contains the mode already */
attr->la_mode = rec->rn_mode;
attr->la_valid = LA_UID | LA_GID | LA_CTIME | LA_MTIME | LA_MODE;
if (req_capsule_get_size(pill, &RMF_CAPA1, RCL_CLIENT))
mdt_set_capainfo(info, 0, rr->rr_fid1,
req_capsule_client_get(pill, &RMF_CAPA1));
if (req_capsule_get_size(pill, &RMF_CAPA2, RCL_CLIENT))
mdt_set_capainfo(info, 1, rr->rr_fid2,
req_capsule_client_get(pill, &RMF_CAPA2));
info->mti_spec.sp_ck_split = !!(rec->rn_bias & MDS_CHECK_SPLIT);
info->mti_cross_ref = !!(rec->rn_bias & MDS_CROSS_REF);
rr->rr_name = req_capsule_client_get(pill, &RMF_NAME);
rr->rr_tgt = req_capsule_client_get(pill, &RMF_SYMTGT);
if (rr->rr_name == NULL || rr->rr_tgt == NULL)
RETURN(-EFAULT);
rr->rr_namelen = req_capsule_get_size(pill, &RMF_NAME, RCL_CLIENT) - 1;
rr->rr_tgtlen = req_capsule_get_size(pill, &RMF_SYMTGT, RCL_CLIENT) - 1;
if (!info->mti_cross_ref)
LASSERT(rr->rr_namelen > 0 && rr->rr_tgtlen > 0);
if (rec->rn_bias & MDS_VTX_BYPASS)
ma->ma_attr_flags |= MDS_VTX_BYPASS;
else
ma->ma_attr_flags &= ~MDS_VTX_BYPASS;
info->mti_spec.no_create = !!req_is_replay(mdt_info_req(info));
rc = mdt_dlmreq_unpack(info);
RETURN(rc);
}
static int mdt_setxattr_unpack(struct mdt_thread_info *info)
{
struct mdt_reint_record *rr = &info->mti_rr;
struct md_ucred *uc = mdt_ucred(info);
struct lu_attr *attr = &info->mti_attr.ma_attr;
struct req_capsule *pill = info->mti_pill;
struct mdt_rec_setxattr *rec;
ENTRY;
CLASSERT(sizeof(struct mdt_rec_setxattr) ==
sizeof(struct mdt_rec_reint));
rec = req_capsule_client_get(pill, &RMF_REC_REINT);
if (rec == NULL)
RETURN(-EFAULT);
uc->mu_fsuid = rec->sx_fsuid;
uc->mu_fsgid = rec->sx_fsgid;
uc->mu_cap = rec->sx_cap;
uc->mu_suppgids[0] = rec->sx_suppgid1;
uc->mu_suppgids[1] = -1;
rr->rr_opcode = rec->sx_opcode;
rr->rr_fid1 = &rec->sx_fid;
attr->la_valid = rec->sx_valid;
attr->la_ctime = rec->sx_time;
attr->la_size = rec->sx_size;
attr->la_flags = rec->sx_flags;
if (req_capsule_get_size(pill, &RMF_CAPA1, RCL_CLIENT))
mdt_set_capainfo(info, 0, rr->rr_fid1,
req_capsule_client_get(pill, &RMF_CAPA1));
else
mdt_set_capainfo(info, 0, rr->rr_fid1, BYPASS_CAPA);
rr->rr_name = req_capsule_client_get(pill, &RMF_NAME);
if (rr->rr_name == NULL)
RETURN(-EFAULT);
rr->rr_namelen = req_capsule_get_size(pill, &RMF_NAME, RCL_CLIENT) - 1;
LASSERT(rr->rr_namelen > 0);
rr->rr_eadatalen = req_capsule_get_size(pill, &RMF_EADATA, RCL_CLIENT);
if (rr->rr_eadatalen > 0) {
rr->rr_eadata = req_capsule_client_get(pill, &RMF_EADATA);
if (rr->rr_eadata == NULL)
RETURN(-EFAULT);
}
RETURN(0);
}
static int mdt_link_unpack(struct mdt_thread_info *info)
{
struct md_ucred *uc = mdt_ucred(info);
struct mdt_rec_link *rec;
struct lu_attr *attr = &info->mti_attr.ma_attr;
struct mdt_reint_record *rr = &info->mti_rr;
struct req_capsule *pill = info->mti_pill;
int rc;
ENTRY;
CLASSERT(sizeof(struct mdt_rec_link) == sizeof(struct mdt_rec_reint));
rec = req_capsule_client_get(pill, &RMF_REC_REINT);
if (rec == NULL)
RETURN(-EFAULT);
uc->mu_fsuid = rec->lk_fsuid;
uc->mu_fsgid = rec->lk_fsgid;
uc->mu_cap = rec->lk_cap;
uc->mu_suppgids[0] = rec->lk_suppgid1;
uc->mu_suppgids[1] = rec->lk_suppgid2;
attr->la_uid = rec->lk_fsuid;
attr->la_gid = rec->lk_fsgid;
rr->rr_fid1 = &rec->lk_fid1;
rr->rr_fid2 = &rec->lk_fid2;
attr->la_ctime = rec->lk_time;
attr->la_mtime = rec->lk_time;
attr->la_valid = LA_UID | LA_GID | LA_CTIME | LA_MTIME;
if (req_capsule_get_size(pill, &RMF_CAPA1, RCL_CLIENT))
mdt_set_capainfo(info, 0, rr->rr_fid1,
req_capsule_client_get(pill, &RMF_CAPA1));
if (req_capsule_get_size(pill, &RMF_CAPA2, RCL_CLIENT))
mdt_set_capainfo(info, 1, rr->rr_fid2,
req_capsule_client_get(pill, &RMF_CAPA2));
info->mti_spec.sp_ck_split = !!(rec->lk_bias & MDS_CHECK_SPLIT);
info->mti_cross_ref = !!(rec->lk_bias & MDS_CROSS_REF);
rr->rr_name = req_capsule_client_get(pill, &RMF_NAME);
if (rr->rr_name == NULL)
RETURN(-EFAULT);
rr->rr_namelen = req_capsule_get_size(pill, &RMF_NAME, RCL_CLIENT) - 1;
if (!info->mti_cross_ref)
LASSERT(rr->rr_namelen > 0);
rc = mdt_dlmreq_unpack(info);
RETURN(rc);
}
static int mdt_setattr_unpack_rec(struct mdt_thread_info *info)
{
struct lu_ucred *uc = mdt_ucred(info);
struct md_attr *ma = &info->mti_attr;
struct lu_attr *la = &ma->ma_attr;
struct req_capsule *pill = info->mti_pill;
struct mdt_reint_record *rr = &info->mti_rr;
struct mdt_rec_setattr *rec;
ENTRY;
CLASSERT(sizeof(struct mdt_rec_setattr)== sizeof(struct mdt_rec_reint));
rec = req_capsule_client_get(pill, &RMF_REC_REINT);
if (rec == NULL)
RETURN(-EFAULT);
/* This prior initialization is needed for old_init_ucred_reint() */
uc->uc_fsuid = rec->sa_fsuid;
uc->uc_fsgid = rec->sa_fsgid;
uc->uc_cap = rec->sa_cap;
uc->uc_suppgids[0] = rec->sa_suppgid;
uc->uc_suppgids[1] = -1;
rr->rr_fid1 = &rec->sa_fid;
la->la_valid = mdt_attr_valid_xlate(rec->sa_valid, rr, ma);
/* If MDS_ATTR_xTIME is set without MDS_ATTR_xTIME_SET and
* the client does not have OBD_CONNECT_FULL20, convert it
* to LA_xTIME. LU-3036 */
if (!(exp_connect_flags(info->mti_exp) & OBD_CONNECT_FULL20)) {
if (!(rec->sa_valid & MDS_ATTR_ATIME_SET) &&
(rec->sa_valid & MDS_ATTR_ATIME))
la->la_valid |= LA_ATIME;
if (!(rec->sa_valid & MDS_ATTR_MTIME_SET) &&
(rec->sa_valid & MDS_ATTR_MTIME))
la->la_valid |= LA_MTIME;
if (!(rec->sa_valid & MDS_ATTR_CTIME_SET) &&
(rec->sa_valid & MDS_ATTR_CTIME))
la->la_valid |= LA_CTIME;
}
la->la_mode = rec->sa_mode;
la->la_flags = rec->sa_attr_flags;
la->la_uid = rec->sa_uid;
la->la_gid = rec->sa_gid;
la->la_size = rec->sa_size;
la->la_blocks = rec->sa_blocks;
la->la_ctime = rec->sa_ctime;
la->la_atime = rec->sa_atime;
la->la_mtime = rec->sa_mtime;
ma->ma_valid = MA_INODE;
if (rec->sa_bias & MDS_DATA_MODIFIED)
ma->ma_attr_flags |= MDS_DATA_MODIFIED;
else
ma->ma_attr_flags &= ~MDS_DATA_MODIFIED;
if (req_capsule_get_size(pill, &RMF_CAPA1, RCL_CLIENT))
mdt_set_capainfo(info, 0, rr->rr_fid1,
req_capsule_client_get(pill, &RMF_CAPA1));
RETURN(0);
}
static int mdt_link_unpack(struct mdt_thread_info *info)
{
struct lu_ucred *uc = mdt_ucred(info);
struct mdt_rec_link *rec;
struct lu_attr *attr = &info->mti_attr.ma_attr;
struct mdt_reint_record *rr = &info->mti_rr;
struct req_capsule *pill = info->mti_pill;
int rc;
ENTRY;
CLASSERT(sizeof(struct mdt_rec_link) == sizeof(struct mdt_rec_reint));
rec = req_capsule_client_get(pill, &RMF_REC_REINT);
if (rec == NULL)
RETURN(-EFAULT);
/* This prior initialization is needed for old_init_ucred_reint() */
uc->uc_fsuid = rec->lk_fsuid;
uc->uc_fsgid = rec->lk_fsgid;
uc->uc_cap = rec->lk_cap;
uc->uc_suppgids[0] = rec->lk_suppgid1;
uc->uc_suppgids[1] = rec->lk_suppgid2;
attr->la_uid = rec->lk_fsuid;
attr->la_gid = rec->lk_fsgid;
rr->rr_fid1 = &rec->lk_fid1;
rr->rr_fid2 = &rec->lk_fid2;
attr->la_ctime = rec->lk_time;
attr->la_mtime = rec->lk_time;
attr->la_valid = LA_UID | LA_GID | LA_CTIME | LA_MTIME;
if (req_capsule_get_size(pill, &RMF_CAPA1, RCL_CLIENT))
mdt_set_capainfo(info, 0, rr->rr_fid1,
req_capsule_client_get(pill, &RMF_CAPA1));
if (req_capsule_get_size(pill, &RMF_CAPA2, RCL_CLIENT))
mdt_set_capainfo(info, 1, rr->rr_fid2,
req_capsule_client_get(pill, &RMF_CAPA2));
rr->rr_name = req_capsule_client_get(pill, &RMF_NAME);
if (rr->rr_name == NULL)
RETURN(-EFAULT);
rr->rr_namelen = req_capsule_get_size(pill, &RMF_NAME, RCL_CLIENT) - 1;
LASSERT(rr->rr_namelen > 0);
rc = mdt_dlmreq_unpack(info);
RETURN(rc);
}
static int mdt_setattr_unpack_rec(struct mdt_thread_info *info)
{
struct md_ucred *uc = mdt_ucred(info);
struct md_attr *ma = &info->mti_attr;
struct lu_attr *la = &ma->ma_attr;
struct req_capsule *pill = info->mti_pill;
struct mdt_reint_record *rr = &info->mti_rr;
struct mdt_rec_setattr *rec;
ENTRY;
CLASSERT(sizeof(struct mdt_rec_setattr)== sizeof(struct mdt_rec_reint));
rec = req_capsule_client_get(pill, &RMF_REC_REINT);
if (rec == NULL)
RETURN(-EFAULT);
uc->mu_fsuid = rec->sa_fsuid;
uc->mu_fsgid = rec->sa_fsgid;
uc->mu_cap = rec->sa_cap;
uc->mu_suppgids[0] = rec->sa_suppgid;
uc->mu_suppgids[1] = -1;
rr->rr_fid1 = &rec->sa_fid;
la->la_valid = mdt_attr_valid_xlate(attr_unpack(rec->sa_valid), rr, ma);
la->la_mode = rec->sa_mode;
la->la_flags = rec->sa_attr_flags;
la->la_uid = rec->sa_uid;
la->la_gid = rec->sa_gid;
la->la_size = rec->sa_size;
la->la_blocks = rec->sa_blocks;
la->la_ctime = rec->sa_ctime;
la->la_atime = rec->sa_atime;
la->la_mtime = rec->sa_mtime;
ma->ma_valid = MA_INODE;
if (req_capsule_get_size(pill, &RMF_CAPA1, RCL_CLIENT))
mdt_set_capainfo(info, 0, rr->rr_fid1,
req_capsule_client_get(pill, &RMF_CAPA1));
RETURN(0);
}
/*
* 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;
}
static int mdt_create_unpack(struct mdt_thread_info *info)
{
struct md_ucred *uc = mdt_ucred(info);
struct mdt_rec_create *rec;
struct lu_attr *attr = &info->mti_attr.ma_attr;
struct mdt_reint_record *rr = &info->mti_rr;
struct req_capsule *pill = info->mti_pill;
struct md_op_spec *sp = &info->mti_spec;
int rc;
ENTRY;
CLASSERT(sizeof(struct mdt_rec_create) == sizeof(struct mdt_rec_reint));
rec = req_capsule_client_get(pill, &RMF_REC_REINT);
if (rec == NULL)
RETURN(-EFAULT);
uc->mu_fsuid = rec->cr_fsuid;
uc->mu_fsgid = rec->cr_fsgid;
uc->mu_cap = rec->cr_cap;
uc->mu_suppgids[0] = rec->cr_suppgid1;
uc->mu_suppgids[1] = -1;
rr->rr_fid1 = &rec->cr_fid1;
rr->rr_fid2 = &rec->cr_fid2;
attr->la_mode = rec->cr_mode;
attr->la_rdev = rec->cr_rdev;
attr->la_uid = rec->cr_fsuid;
attr->la_gid = rec->cr_fsgid;
attr->la_ctime = rec->cr_time;
attr->la_mtime = rec->cr_time;
attr->la_atime = rec->cr_time;
attr->la_valid = LA_MODE | LA_RDEV | LA_UID | LA_GID |
LA_CTIME | LA_MTIME | LA_ATIME;
memset(&sp->u, 0, sizeof(sp->u));
sp->sp_cr_flags = get_mrc_cr_flags(rec);
sp->sp_ck_split = !!(rec->cr_bias & MDS_CHECK_SPLIT);
info->mti_cross_ref = !!(rec->cr_bias & MDS_CROSS_REF);
if (req_capsule_get_size(pill, &RMF_CAPA1, RCL_CLIENT))
mdt_set_capainfo(info, 0, rr->rr_fid1,
req_capsule_client_get(pill, &RMF_CAPA1));
mdt_set_capainfo(info, 1, rr->rr_fid2, BYPASS_CAPA);
if (!info->mti_cross_ref) {
rr->rr_name = req_capsule_client_get(pill, &RMF_NAME);
rr->rr_namelen = req_capsule_get_size(pill, &RMF_NAME,
RCL_CLIENT) - 1;
LASSERT(rr->rr_name && rr->rr_namelen > 0);
} else {
rr->rr_name = NULL;
rr->rr_namelen = 0;
}
#ifdef CONFIG_FS_POSIX_ACL
if (sp->sp_cr_flags & MDS_CREATE_RMT_ACL) {
if (S_ISDIR(attr->la_mode))
sp->u.sp_pfid = rr->rr_fid1;
req_capsule_extend(pill, &RQF_MDS_REINT_CREATE_RMT_ACL);
LASSERT(req_capsule_field_present(pill, &RMF_EADATA,
RCL_CLIENT));
sp->u.sp_ea.eadata = req_capsule_client_get(pill, &RMF_EADATA);
sp->u.sp_ea.eadatalen = req_capsule_get_size(pill, &RMF_EADATA,
RCL_CLIENT);
sp->u.sp_ea.fid = rr->rr_fid1;
RETURN(0);
}
#endif
if (S_ISDIR(attr->la_mode)) {
/* pass parent fid for cross-ref cases */
sp->u.sp_pfid = rr->rr_fid1;
if (sp->sp_cr_flags & MDS_CREATE_SLAVE_OBJ) {
/* create salve object req, need
* unpack split ea here
*/
req_capsule_extend(pill, &RQF_MDS_REINT_CREATE_SLAVE);
LASSERT(req_capsule_field_present(pill, &RMF_EADATA,
RCL_CLIENT));
sp->u.sp_ea.eadata = req_capsule_client_get(pill,
&RMF_EADATA);
sp->u.sp_ea.eadatalen = req_capsule_get_size(pill,
&RMF_EADATA,
RCL_CLIENT);
sp->u.sp_ea.fid = rr->rr_fid1;
RETURN(0);
}
req_capsule_extend(pill, &RQF_MDS_REINT_CREATE_RMT_ACL);
} else if (S_ISLNK(attr->la_mode)) {
const char *tgt = NULL;
req_capsule_extend(pill, &RQF_MDS_REINT_CREATE_SYM);
if (req_capsule_get_size(pill, &RMF_SYMTGT, RCL_CLIENT)) {
tgt = req_capsule_client_get(pill, &RMF_SYMTGT);
sp->u.sp_symname = tgt;
}
if (tgt == NULL)
RETURN(-EFAULT);
} else {
req_capsule_extend(pill, &RQF_MDS_REINT_CREATE_RMT_ACL);
}
rc = mdt_dlmreq_unpack(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;
}
static int mdt_open_unpack(struct mdt_thread_info *info)
{
struct md_ucred *uc = mdt_ucred(info);
struct mdt_rec_create *rec;
struct lu_attr *attr = &info->mti_attr.ma_attr;
struct req_capsule *pill = info->mti_pill;
struct mdt_reint_record *rr = &info->mti_rr;
struct ptlrpc_request *req = mdt_info_req(info);
struct md_op_spec *sp = &info->mti_spec;
ENTRY;
CLASSERT(sizeof(struct mdt_rec_create) == sizeof(struct mdt_rec_reint));
rec = req_capsule_client_get(pill, &RMF_REC_REINT);
if (rec == NULL)
RETURN(-EFAULT);
uc->mu_fsuid = rec->cr_fsuid;
uc->mu_fsgid = rec->cr_fsgid;
uc->mu_cap = rec->cr_cap;
uc->mu_suppgids[0] = rec->cr_suppgid1;
uc->mu_suppgids[1] = rec->cr_suppgid2;
rr->rr_fid1 = &rec->cr_fid1;
rr->rr_fid2 = &rec->cr_fid2;
rr->rr_handle = &rec->cr_old_handle;
attr->la_mode = rec->cr_mode;
attr->la_rdev = rec->cr_rdev;
attr->la_uid = rec->cr_fsuid;
attr->la_gid = rec->cr_fsgid;
attr->la_ctime = rec->cr_time;
attr->la_mtime = rec->cr_time;
attr->la_atime = rec->cr_time;
attr->la_valid = LA_MODE | LA_RDEV | LA_UID | LA_GID |
LA_CTIME | LA_MTIME | LA_ATIME;
memset(&info->mti_spec.u, 0, sizeof(info->mti_spec.u));
info->mti_spec.sp_cr_flags = get_mrc_cr_flags(rec);
/* Do not trigger ASSERTION if client miss to set such flags. */
if (unlikely(info->mti_spec.sp_cr_flags == 0))
RETURN(-EPROTO);
info->mti_replayepoch = rec->cr_ioepoch;
info->mti_spec.sp_ck_split = !!(rec->cr_bias & MDS_CHECK_SPLIT);
info->mti_cross_ref = !!(rec->cr_bias & MDS_CROSS_REF);
if (req_capsule_get_size(pill, &RMF_CAPA1, RCL_CLIENT))
mdt_set_capainfo(info, 0, rr->rr_fid1,
req_capsule_client_get(pill, &RMF_CAPA1));
if (req_is_replay(req) &&
req_capsule_get_size(pill, &RMF_CAPA2, RCL_CLIENT)) {
#if 0
mdt_set_capainfo(info, 1, rr->rr_fid2,
req_capsule_client_get(pill, &RMF_CAPA2));
#else
/*
* FIXME: capa in replay open request might have expired,
* bypass capa check. Security hole?
*/
mdt_set_capainfo(info, 0, rr->rr_fid1, BYPASS_CAPA);
mdt_set_capainfo(info, 1, rr->rr_fid2, BYPASS_CAPA);
#endif
}
rr->rr_name = req_capsule_client_get(pill, &RMF_NAME);
if (rr->rr_name == NULL)
RETURN(-EFAULT);
rr->rr_namelen = req_capsule_get_size(pill, &RMF_NAME, RCL_CLIENT) - 1;
sp->u.sp_ea.eadatalen = req_capsule_get_size(pill, &RMF_EADATA,
RCL_CLIENT);
if (sp->u.sp_ea.eadatalen) {
sp->u.sp_ea.eadata = req_capsule_client_get(pill, &RMF_EADATA);
sp->no_create = !!req_is_replay(req);
}
RETURN(0);
}
/*
* 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;
}
static int mdt_setxattr_unpack(struct mdt_thread_info *info)
{
struct mdt_reint_record *rr = &info->mti_rr;
struct lu_ucred *uc = mdt_ucred(info);
struct lu_attr *attr = &info->mti_attr.ma_attr;
struct req_capsule *pill = info->mti_pill;
struct mdt_rec_setxattr *rec;
int rc;
ENTRY;
CLASSERT(sizeof(struct mdt_rec_setxattr) ==
sizeof(struct mdt_rec_reint));
rec = req_capsule_client_get(pill, &RMF_REC_REINT);
if (rec == NULL)
RETURN(-EFAULT);
/* This prior initialization is needed for old_init_ucred_reint() */
uc->uc_fsuid = rec->sx_fsuid;
uc->uc_fsgid = rec->sx_fsgid;
uc->uc_cap = rec->sx_cap;
uc->uc_suppgids[0] = rec->sx_suppgid1;
uc->uc_suppgids[1] = -1;
rr->rr_opcode = rec->sx_opcode;
rr->rr_fid1 = &rec->sx_fid;
attr->la_valid = rec->sx_valid;
attr->la_ctime = rec->sx_time;
attr->la_size = rec->sx_size;
attr->la_flags = rec->sx_flags;
if (req_capsule_get_size(pill, &RMF_CAPA1, RCL_CLIENT))
mdt_set_capainfo(info, 0, rr->rr_fid1,
req_capsule_client_get(pill, &RMF_CAPA1));
else
mdt_set_capainfo(info, 0, rr->rr_fid1, BYPASS_CAPA);
rc = mdt_name_unpack(pill, &RMF_NAME, &rr->rr_name, 0);
if (rc < 0)
RETURN(rc);
if (req_capsule_field_present(pill, &RMF_EADATA, RCL_CLIENT)) {
rr->rr_eadatalen = req_capsule_get_size(pill, &RMF_EADATA,
RCL_CLIENT);
if (rr->rr_eadatalen > 0) {
rr->rr_eadata = req_capsule_client_get(pill,
&RMF_EADATA);
if (rr->rr_eadata == NULL)
RETURN(-EFAULT);
} else {
rr->rr_eadata = NULL;
}
} else if (!(attr->la_valid & OBD_MD_FLXATTRRM)) {
CDEBUG(D_INFO, "no xattr data supplied\n");
RETURN(-EFAULT);
}
if (mdt_dlmreq_unpack(info) < 0)
RETURN(-EPROTO);
RETURN(0);
}
static int mdt_open_unpack(struct mdt_thread_info *info)
{
struct lu_ucred *uc = mdt_ucred(info);
struct mdt_rec_create *rec;
struct lu_attr *attr = &info->mti_attr.ma_attr;
struct req_capsule *pill = info->mti_pill;
struct mdt_reint_record *rr = &info->mti_rr;
struct ptlrpc_request *req = mdt_info_req(info);
struct md_op_spec *sp = &info->mti_spec;
ENTRY;
CLASSERT(sizeof(struct mdt_rec_create) == sizeof(struct mdt_rec_reint));
rec = req_capsule_client_get(pill, &RMF_REC_REINT);
if (rec == NULL)
RETURN(-EFAULT);
/* This prior initialization is needed for old_init_ucred_reint() */
uc->uc_fsuid = rec->cr_fsuid;
uc->uc_fsgid = rec->cr_fsgid;
uc->uc_cap = rec->cr_cap;
uc->uc_suppgids[0] = rec->cr_suppgid1;
uc->uc_suppgids[1] = rec->cr_suppgid2;
uc->uc_umask = rec->cr_umask;
rr->rr_fid1 = &rec->cr_fid1;
rr->rr_fid2 = &rec->cr_fid2;
rr->rr_handle = &rec->cr_old_handle;
attr->la_mode = rec->cr_mode;
attr->la_rdev = rec->cr_rdev;
attr->la_uid = rec->cr_fsuid;
attr->la_gid = rec->cr_fsgid;
attr->la_ctime = rec->cr_time;
attr->la_mtime = rec->cr_time;
attr->la_atime = rec->cr_time;
attr->la_valid = LA_MODE | LA_RDEV | LA_UID | LA_GID |
LA_CTIME | LA_MTIME | LA_ATIME;
memset(&info->mti_spec.u, 0, sizeof(info->mti_spec.u));
info->mti_spec.sp_cr_flags = get_mrc_cr_flags(rec);
/* Do not trigger ASSERTION if client miss to set such flags. */
if (unlikely(info->mti_spec.sp_cr_flags == 0))
RETURN(-EPROTO);
info->mti_replayepoch = rec->cr_ioepoch;
info->mti_cross_ref = !!(rec->cr_bias & MDS_CROSS_REF);
if (req_capsule_get_size(pill, &RMF_CAPA1, RCL_CLIENT))
mdt_set_capainfo(info, 0, rr->rr_fid1,
req_capsule_client_get(pill, &RMF_CAPA1));
if (req_is_replay(req) &&
req_capsule_get_size(pill, &RMF_CAPA2, RCL_CLIENT)) {
#if 0
mdt_set_capainfo(info, 1, rr->rr_fid2,
req_capsule_client_get(pill, &RMF_CAPA2));
#else
/*
* FIXME: capa in replay open request might have expired,
* bypass capa check. Security hole?
*/
mdt_set_capainfo(info, 0, rr->rr_fid1, BYPASS_CAPA);
mdt_set_capainfo(info, 1, rr->rr_fid2, BYPASS_CAPA);
#endif
}
mdt_name_unpack(pill, &RMF_NAME, &rr->rr_name, MNF_FIX_ANON);
if (req_capsule_field_present(pill, &RMF_EADATA, RCL_CLIENT)) {
rr->rr_eadatalen = req_capsule_get_size(pill, &RMF_EADATA,
RCL_CLIENT);
if (rr->rr_eadatalen > 0) {
rr->rr_eadata = req_capsule_client_get(pill,
&RMF_EADATA);
sp->u.sp_ea.eadatalen = rr->rr_eadatalen;
sp->u.sp_ea.eadata = rr->rr_eadata;
sp->no_create = !!req_is_replay(req);
mdt_fix_lov_magic(info);
}
/*
* Client default md_size may be 0 right after client start,
* until all osc are connected, set here just some reasonable
* value to prevent misbehavior.
*/
if (rr->rr_eadatalen == 0 &&
!(info->mti_spec.sp_cr_flags & MDS_OPEN_DELAY_CREATE))
rr->rr_eadatalen = MIN_MD_SIZE;
}
RETURN(0);
}
/*
* 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);
if (info->mti_cross_ref) {
/* MDT holding name ask us to add ref. */
lhs = &info->mti_lh[MDT_LH_CHILD];
mdt_lock_reg_init(lhs, LCK_EX);
ms = mdt_object_find_lock(info, rr->rr_fid1, lhs,
MDS_INODELOCK_UPDATE,
MDT_OBJ_MUST_EXIST);
if (IS_ERR(ms))
RETURN(PTR_ERR(ms));
mdt_set_capainfo(info, 0, rr->rr_fid1, BYPASS_CAPA);
rc = mo_ref_add(info->mti_env, mdt_object_child(ms), ma);
mdt_object_unlock_put(info, ms, lhs, rc);
RETURN(rc);
}
/* 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, MDT_OBJ_MUST_EXIST);
if (IS_ERR(mp))
RETURN(PTR_ERR(mp));
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,
MDT_OBJ_MUST_EXIST);
if (IS_ERR(ms))
GOTO(out_unlock_parent, rc = PTR_ERR(ms));
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->rq_export, 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;
}
static int mdt_create_unpack(struct mdt_thread_info *info)
{
struct lu_ucred *uc = mdt_ucred(info);
struct mdt_rec_create *rec;
struct lu_attr *attr = &info->mti_attr.ma_attr;
struct mdt_reint_record *rr = &info->mti_rr;
struct req_capsule *pill = info->mti_pill;
struct md_op_spec *sp = &info->mti_spec;
int rc;
ENTRY;
CLASSERT(sizeof(struct mdt_rec_create) == sizeof(struct mdt_rec_reint));
rec = req_capsule_client_get(pill, &RMF_REC_REINT);
if (rec == NULL)
RETURN(-EFAULT);
/* This prior initialization is needed for old_init_ucred_reint() */
uc->uc_fsuid = rec->cr_fsuid;
uc->uc_fsgid = rec->cr_fsgid;
uc->uc_cap = rec->cr_cap;
uc->uc_suppgids[0] = rec->cr_suppgid1;
uc->uc_suppgids[1] = -1;
uc->uc_umask = rec->cr_umask;
rr->rr_fid1 = &rec->cr_fid1;
rr->rr_fid2 = &rec->cr_fid2;
attr->la_mode = rec->cr_mode;
attr->la_rdev = rec->cr_rdev;
attr->la_uid = rec->cr_fsuid;
attr->la_gid = rec->cr_fsgid;
attr->la_ctime = rec->cr_time;
attr->la_mtime = rec->cr_time;
attr->la_atime = rec->cr_time;
attr->la_valid = LA_MODE | LA_RDEV | LA_UID | LA_GID | LA_TYPE |
LA_CTIME | LA_MTIME | LA_ATIME;
memset(&sp->u, 0, sizeof(sp->u));
sp->sp_cr_flags = get_mrc_cr_flags(rec);
if (req_capsule_get_size(pill, &RMF_CAPA1, RCL_CLIENT))
mdt_set_capainfo(info, 0, rr->rr_fid1,
req_capsule_client_get(pill, &RMF_CAPA1));
mdt_set_capainfo(info, 1, rr->rr_fid2, BYPASS_CAPA);
rc = mdt_name_unpack(pill, &RMF_NAME, &rr->rr_name, 0);
if (rc < 0)
RETURN(rc);
if (S_ISLNK(attr->la_mode)) {
const char *tgt = NULL;
req_capsule_extend(pill, &RQF_MDS_REINT_CREATE_SYM);
if (req_capsule_get_size(pill, &RMF_SYMTGT, RCL_CLIENT)) {
tgt = req_capsule_client_get(pill, &RMF_SYMTGT);
sp->u.sp_symname = tgt;
}
if (tgt == NULL)
RETURN(-EFAULT);
} else {
req_capsule_extend(pill, &RQF_MDS_REINT_CREATE_RMT_ACL);
if (S_ISDIR(attr->la_mode) &&
req_capsule_get_size(pill, &RMF_EADATA, RCL_CLIENT) > 0) {
sp->u.sp_ea.eadata =
req_capsule_client_get(pill, &RMF_EADATA);
sp->u.sp_ea.eadatalen =
req_capsule_get_size(pill, &RMF_EADATA,
RCL_CLIENT);
sp->sp_cr_flags |= MDS_OPEN_HAS_EA;
}
}
rc = mdt_dlmreq_unpack(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: 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;
}