#endif
};
-struct mdc_op_data {
+struct md_op_data {
struct lu_fid fid1;
struct lu_fid fid2;
__u64 mod_time;
int mdc_change_cbdata(struct obd_export *exp, struct lu_fid *fid,
ldlm_iterator_t it, void *data);
int mdc_intent_lock(struct obd_export *exp,
- struct mdc_op_data *,
+ struct md_op_data *,
void *lmm, int lmmsize,
struct lookup_intent *, int,
struct ptlrpc_request **reqp,
int lock_type,
struct lookup_intent *it,
int lock_mode,
- struct mdc_op_data *data,
+ struct md_op_data *op_data,
struct lustre_handle *lockh,
void *lmm,
int lmmlen,
int mdc_getattr_name(struct obd_export *exp, struct lu_fid *fid,
const char *filename, int namelen, unsigned long valid,
unsigned int ea_size, struct ptlrpc_request **request);
-int mdc_setattr(struct obd_export *exp, struct mdc_op_data *data,
+int mdc_setattr(struct obd_export *exp, struct md_op_data *op_data,
struct iattr *iattr, void *ea, int ealen, void *ea2, int ea2len,
struct ptlrpc_request **request);
int mdc_setxattr(struct obd_export *exp, struct lu_fid *fid,
void mdc_set_open_replay_data(struct obd_client_handle *och,
struct ptlrpc_request *open_req);
void mdc_clear_open_replay_data(struct obd_client_handle *och);
-int mdc_close(struct obd_export *, struct mdc_op_data *, struct obd_client_handle *,
+int mdc_close(struct obd_export *, struct md_op_data *, struct obd_client_handle *,
struct ptlrpc_request **);
int mdc_readpage(struct obd_export *exp, struct lu_fid *mdc_fid, __u64 offset,
struct page *, struct ptlrpc_request **);
-int mdc_create(struct obd_export *exp, struct mdc_op_data *op_data,
+int mdc_create(struct obd_export *exp, struct md_op_data *op_data,
const void *data, int datalen, int mode, __u32 uid, __u32 gid,
__u32 cap_effective, __u64 rdev,struct ptlrpc_request **request);
-int mdc_unlink(struct obd_export *exp, struct mdc_op_data *data,
+int mdc_unlink(struct obd_export *exp, struct md_op_data *op_data,
struct ptlrpc_request **request);
-int mdc_link(struct obd_export *exp, struct mdc_op_data *data,
+int mdc_link(struct obd_export *exp, struct md_op_data *op_data,
struct ptlrpc_request **);
-int mdc_rename(struct obd_export *exp, struct mdc_op_data *data,
+int mdc_rename(struct obd_export *exp, struct md_op_data *op_data,
const char *old, int oldlen, const char *new, int newlen,
struct ptlrpc_request **request);
int mdc_sync(struct obd_export *exp, struct lu_fid *fid,
int mdc_create_client(struct obd_uuid uuid, struct ptlrpc_client *cl);
int mdc_llog_process(struct obd_export *, char *logname, llog_cb_t, void *data);
-int mdc_done_writing(struct obd_export *exp, struct mdc_op_data *data);
+int mdc_done_writing(struct obd_export *exp, struct md_op_data *op_data);
#endif
struct lustre_handle lockh;
struct mdt_body *body;
struct lookup_intent it = { .it_op = IT_READDIR };
- struct mdc_op_data data = { { 0 } };
+ struct md_op_data op_data = { { 0 } };
struct obd_device *obddev = class_exp2obd(sbi->ll_mdc_exp);
struct ldlm_res_id res_id =
{ .name = {fid_seq(&lli->lli_fid), fid_num(&lli->lli_fid)} };
rc = ldlm_lock_match(obddev->obd_namespace, LDLM_FL_BLOCK_GRANTED,
&res_id, LDLM_IBITS, &policy, LCK_CR, &lockh);
if (!rc) {
- llu_prepare_mdc_op_data(&data, inode, NULL, NULL, 0, 0);
+ llu_prepare_mdc_op_data(&op_data, inode, NULL, NULL, 0, 0);
rc = mdc_enqueue(sbi->ll_mdc_exp, LDLM_IBITS, &it, LCK_CR,
- &data, &lockh, NULL, 0,
+ &op_data, &lockh, NULL, 0,
ldlm_completion_ast, llu_mdc_blocking_ast,
inode, LDLM_FL_CANCEL_ON_BLOCK);
request = (struct ptlrpc_request *)it.d.lustre.it_data;
}
}
-void llu_prepare_mdc_op_data(struct mdc_op_data *data,
+void llu_prepare_mdc_op_data(struct md_op_data *op_data,
struct inode *i1,
struct inode *i2,
const char *name,
{
LASSERT(i1);
- ll_i2gids(data->suppgids, i1, i2);
- data->fid1 = *ll_inode2fid(i1);
+ ll_i2gids(op_data->suppgids, i1, i2);
+ op_data->fid1 = *ll_inode2fid(i1);
if (i2)
- data->fid2 = *ll_inode2fid(i2);
+ op_data->fid2 = *ll_inode2fid(i2);
- data->name = name;
- data->namelen = namelen;
- data->create_mode = mode;
- data->mod_time = CURRENT_TIME;
+ op_data->name = name;
+ op_data->namelen = namelen;
+ op_data->create_mode = mode;
+ op_data->mod_time = CURRENT_TIME;
}
void obdo_refresh_inode(struct inode *dst,
struct ptlrpc_request *req = NULL;
struct obd_client_handle *och = &fd->fd_mds_och;
struct intnl_stat *st = llu_i2stat(inode);
- struct mdc_op_data op_data = { { 0 } };
+ struct md_op_data op_data = { { 0 } };
int rc;
ENTRY;
extern struct fssw_ops llu_fssw_ops;
/* file.c */
-void llu_prepare_mdc_op_data(struct mdc_op_data *data,
+void llu_prepare_mdc_op_data(struct md_op_data *op_data,
struct inode *i1,
struct inode *i2,
const char *name,
{
struct pnode_base *pb = pnode->p_base;
struct it_cb_data icbd;
- struct mdc_op_data op_data;
+ struct md_op_data op_data;
struct ptlrpc_request *req = NULL;
struct lookup_intent lookup_it = { .it_op = IT_LOOKUP };
struct obd_export *exp;
static int llu_lookup_it(struct inode *parent, struct pnode *pnode,
struct lookup_intent *it, int flags)
{
- struct mdc_op_data op_data = { { 0 } };
+ struct md_op_data op_data = { { 0 } };
struct it_cb_data icbd;
struct ptlrpc_request *req = NULL;
struct lookup_intent lookup_it = { .it_op = IT_LOOKUP };
struct llu_sb_info *sbi = llu_i2sbi(inode);
struct intnl_stat *st = llu_i2stat(inode);
struct ptlrpc_request *request = NULL;
- struct mdc_op_data op_data = { { 0 } };
+ struct md_op_data op_data = { { 0 } };
int ia_valid = attr->ia_valid;
int rc = 0;
ENTRY;
int len = qstr->len;
struct ptlrpc_request *request = NULL;
struct llu_sb_info *sbi = llu_i2sbi(dir);
- struct mdc_op_data op_data = { { 0 } };
+ struct md_op_data op_data = { { 0 } };
int err = -EMLINK;
ENTRY;
struct ptlrpc_request *request = NULL;
struct inode *dir = pno->p_parent->p_base->pb_ino;
struct llu_sb_info *sbi = llu_i2sbi(dir);
- struct mdc_op_data op_data = { { 0 } };
+ struct md_op_data op_data = { { 0 } };
int err = -EMLINK;
ENTRY;
const char *name = new->p_base->pb_name.name;
int namelen = new->p_base->pb_name.len;
struct ptlrpc_request *request = NULL;
- struct mdc_op_data op_data = { { 0 } };
+ struct md_op_data op_data = { { 0 } };
int rc;
ENTRY;
int len = qstr->len;
struct inode *target = pno->p_base->pb_ino;
struct ptlrpc_request *request = NULL;
- struct mdc_op_data op_data = { { 0 } };
+ struct md_op_data op_data = { { 0 } };
int rc;
ENTRY;
const char *newname = new->p_base->pb_name.name;
int newnamelen = new->p_base->pb_name.len;
struct ptlrpc_request *request = NULL;
- struct mdc_op_data op_data = { { 0 } };
+ struct md_op_data op_data = { { 0 } };
int rc;
ENTRY;
int len = qstr->len;
struct ptlrpc_request *request = NULL;
struct intnl_stat *st = llu_i2stat(dir);
- struct mdc_op_data op_data = { { 0 } };
+ struct md_op_data op_data = { { 0 } };
int err = -EMLINK;
ENTRY;
const char *name = qstr->name;
int len = qstr->len;
struct ptlrpc_request *request = NULL;
- struct mdc_op_data op_data = { { 0 } };
+ struct md_op_data op_data = { { 0 } };
int rc;
ENTRY;
RETURN(-ENOENT);
sbi = ll_i2sbi(de->d_inode);
- rc = ll_prep_inode(sbi->ll_osc_exp, &de->d_inode, request, offset, NULL);
+ rc = ll_prep_inode(sbi->ll_dt_exp, &de->d_inode, request, offset, NULL);
RETURN(rc);
}
{
int rc;
struct it_cb_data icbd;
- struct mdc_op_data op_data = { { 0 } };
+ struct md_op_data op_data = { { 0 } };
struct ptlrpc_request *req = NULL;
struct lookup_intent lookup_it = { .it_op = IT_LOOKUP };
struct obd_export *exp;
if (de->d_inode == NULL)
RETURN(0);
- exp = ll_i2mdcexp(de->d_inode);
+ exp = ll_i2mdexp(de->d_inode);
icbd.icbd_parent = de->d_parent->d_inode;
icbd.icbd_childp = &de;
parent = de->d_parent->d_inode;
- ll_prepare_mdc_op_data(&op_data, parent, NULL, de->d_name.name,
- de->d_name.len, 0);
+ ll_prepare_md_op_data(&op_data, parent, NULL, de->d_name.name,
+ de->d_name.len, 0);
rc = mdc_intent_lock(exp, &op_data, NULL, 0, it, lookup_flags,
&req, ll_mdc_blocking_ast, 0);
unlock_kernel();
handle = (flag) ? &ldd->lld_mnt_och : &ldd->lld_cwd_och;
- rc = obd_pin(sbi->ll_mdc_exp, &ll_i2info(inode)->lli_fid,
+ rc = obd_pin(sbi->ll_md_exp, &ll_i2info(inode)->lli_fid,
handle, flag);
if (rc) {
return;
}
- rc = obd_unpin(sbi->ll_mdc_exp, &handle, flag);
+ rc = obd_unpin(sbi->ll_md_exp, &handle, flag);
EXIT;
return;
}
CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p) off "LPU64"\n",
inode->i_ino, inode->i_generation, inode, offset);
- rc = mdc_readpage(ll_i2sbi(inode)->ll_mdc_exp, ll_inode2fid(inode),
+ rc = mdc_readpage(ll_i2sbi(inode)->ll_md_exp, ll_inode2fid(inode),
offset, page, &request);
if (!rc) {
body = lustre_msg_buf(request->rq_repmsg, 0, sizeof (*body));
Ebadsize:
CERROR("%s: directory %lu/%u size %llu is not a multiple of %u\n",
- ll_i2mdcexp(dir)->exp_obd->obd_name, dir->i_ino,
+ ll_i2mdexp(dir)->exp_obd->obd_name, dir->i_ino,
dir->i_generation, dir->i_size, chunk_size);
goto fail;
Eshort:
bad_entry:
CERROR("%s: bad entry in directory %lu/%u: %s - "
"offset=%lu+%u, inode=%lu, rec_len=%d, name_len=%d",
- ll_i2mdcexp(dir)->exp_obd->obd_name, dir->i_ino,
+ ll_i2mdexp(dir)->exp_obd->obd_name, dir->i_ino,
dir->i_generation, error, (page->index<<PAGE_CACHE_SHIFT), offs,
(unsigned long)le32_to_cpu(p->inode),
rec_len, p->name_len);
struct ldlm_res_id res_id =
{ .name = { fid_seq(ll_inode2fid(dir)), fid_num(ll_inode2fid(dir)) } };
struct lustre_handle lockh;
- struct obd_device *obddev = class_exp2obd(ll_i2sbi(dir)->ll_mdc_exp);
+ struct obd_device *obddev = class_exp2obd(ll_i2sbi(dir)->ll_md_exp);
struct address_space *mapping = dir->i_mapping;
struct page *page;
ldlm_policy_data_t policy = {.l_inodebits = {MDS_INODELOCK_UPDATE} };
if (!rc) {
struct lookup_intent it = { .it_op = IT_READDIR };
struct ptlrpc_request *request;
- struct mdc_op_data data = { { 0 } };
+ struct md_op_data op_data = { { 0 } };
- ll_prepare_mdc_op_data(&data, dir, NULL, NULL, 0, 0);
+ ll_prepare_md_op_data(&op_data, dir, NULL, NULL, 0, 0);
- rc = mdc_enqueue(ll_i2sbi(dir)->ll_mdc_exp, LDLM_IBITS, &it,
- LCK_CR, &data, &lockh, NULL, 0,
+ rc = mdc_enqueue(ll_i2sbi(dir)->ll_md_exp, LDLM_IBITS, &it,
+ LCK_CR, &op_data, &lockh, NULL, 0,
ldlm_completion_ast, ll_mdc_blocking_ast, dir,
0);
GOTO(out, rc = -EINVAL);
}
- rc = mdc_getattr_name(sbi->ll_mdc_exp, ll_inode2fid(inode),
+ rc = mdc_getattr_name(sbi->ll_md_exp, ll_inode2fid(inode),
filename, namelen, OBD_MD_FLID, 0,
&request);
if (rc < 0) {
}
case LL_IOC_LOV_SETSTRIPE: {
struct ptlrpc_request *request = NULL;
- struct mdc_op_data op_data = { { 0 } };
+ struct md_op_data op_data = { { 0 } };
struct iattr attr = { 0 };
struct lov_user_md lum, *lump = (struct lov_user_md *)arg;
int rc = 0;
- ll_prepare_mdc_op_data(&op_data, inode,
- NULL, NULL, 0, 0);
+ ll_prepare_md_op_data(&op_data, inode,
+ NULL, NULL, 0, 0);
LASSERT(sizeof(lum) == sizeof(*lump));
LASSERT(sizeof(lum.lmm_objects[0]) ==
lustre_swab_lov_user_md(&lum);
/* swabbing is done in lov_setstripe() on server side */
- rc = mdc_setattr(sbi->ll_mdc_exp, &op_data,
+ rc = mdc_setattr(sbi->ll_md_exp, &op_data,
&attr, &lum, sizeof(lum), NULL, 0, &request);
if (rc) {
ptlrpc_req_finished(request);
if (rc)
RETURN(rc);
- rc = mdc_getattr(sbi->ll_mdc_exp, ll_inode2fid(inode),
+ rc = mdc_getattr(sbi->ll_md_exp, ll_inode2fid(inode),
OBD_MD_FLDIREA, lmmsize, &request);
if (rc < 0) {
CDEBUG(D_INFO, "mdc_getattr failed: rc = %d\n", rc);
if (rc)
RETURN(rc);
- rc = mdc_getattr_name(sbi->ll_mdc_exp, ll_inode2fid(inode),
+ rc = mdc_getattr_name(sbi->ll_md_exp, ll_inode2fid(inode),
filename, strlen(filename) + 1,
OBD_MD_FLEASIZE, lmmsize, &request);
if (rc < 0) {
struct lov_user_md_join *lmj;
int lmj_size, i, aindex = 0, rc;
- rc = obd_unpackmd(sbi->ll_osc_exp, &lsm, lmm, lmmsize);
+ rc = obd_unpackmd(sbi->ll_dt_exp, &lsm, lmm, lmmsize);
if (rc < 0)
GOTO(out_req, rc = -ENOMEM);
- rc = obd_checkmd(sbi->ll_osc_exp, sbi->ll_mdc_exp, lsm);
+ rc = obd_checkmd(sbi->ll_dt_exp, sbi->ll_md_exp, lsm);
if (rc)
GOTO(out_free_memmd, rc);
lmm = (struct lov_mds_md *)lmj;
lmmsize = lmj_size;
out_free_memmd:
- obd_free_memmd(sbi->ll_osc_exp, &lsm);
+ obd_free_memmd(sbi->ll_dt_exp, &lsm);
if (rc)
GOTO(out_req, rc);
}
if (!oqctl)
RETURN(-ENOMEM);
oqctl->qc_type = arg;
- rc = obd_quotacheck(sbi->ll_mdc_exp, oqctl);
+ rc = obd_quotacheck(sbi->ll_md_exp, oqctl);
if (rc < 0) {
CDEBUG(D_INFO, "mdc_quotacheck failed: rc %d\n", rc);
error = rc;
}
- rc = obd_quotacheck(sbi->ll_osc_exp, oqctl);
+ rc = obd_quotacheck(sbi->ll_dt_exp, oqctl);
if (rc < 0)
CDEBUG(D_INFO, "osc_quotacheck failed: rc %d\n", rc);
if (!check)
RETURN(-ENOMEM);
- rc = obd_iocontrol(cmd, sbi->ll_mdc_exp, 0, (void *)check,
+ rc = obd_iocontrol(cmd, sbi->ll_md_exp, 0, (void *)check,
NULL);
if (rc) {
CDEBUG(D_QUOTA, "mdc ioctl %d failed: %d\n", cmd, rc);
GOTO(out_poll, rc);
}
- rc = obd_iocontrol(cmd, sbi->ll_osc_exp, 0, (void *)check,
+ rc = obd_iocontrol(cmd, sbi->ll_dt_exp, 0, (void *)check,
NULL);
if (rc) {
CDEBUG(D_QUOTA, "osc ioctl %d failed: %d\n", cmd, rc);
/* XXX: dqb_valid is borrowed as a flag to mark that
* only mds quota is wanted */
if (qctl->qc_dqblk.dqb_valid)
- qctl->obd_uuid = sbi->ll_mdc_exp->exp_obd->
+ qctl->obd_uuid = sbi->ll_md_exp->exp_obd->
u.cli.cl_target_uuid;
break;
case Q_GETINFO:
struct obd_uuid *uuid = &qctl->obd_uuid;
obd = class_find_client_notype(uuid,
- &sbi->ll_osc_exp->exp_obd->obd_uuid);
+ &sbi->ll_dt_exp->exp_obd->obd_uuid);
if (!obd)
GOTO(out_quotactl, rc = -ENOENT);
else
GOTO(out_quotactl, rc = -EINVAL);
- if (sbi->ll_mdc_exp->exp_obd == obd) {
- rc = obd_quotactl(sbi->ll_mdc_exp, oqctl);
+ if (sbi->ll_md_exp->exp_obd == obd) {
+ rc = obd_quotactl(sbi->ll_md_exp, oqctl);
} else {
int i;
struct obd_export *exp;
- struct lov_obd *lov = &sbi->ll_osc_exp->
+ struct lov_obd *lov = &sbi->ll_dt_exp->
exp_obd->u.lov;
for (i = 0; i < lov->desc.ld_tgt_count; i++) {
GOTO(out_quotactl, rc);
}
- rc = obd_quotactl(sbi->ll_mdc_exp, oqctl);
+ rc = obd_quotactl(sbi->ll_md_exp, oqctl);
if (rc && rc != -EBUSY && cmd == Q_QUOTAON) {
oqctl->qc_cmd = Q_QUOTAOFF;
- obd_quotactl(sbi->ll_mdc_exp, oqctl);
+ obd_quotactl(sbi->ll_md_exp, oqctl);
}
QCTL_COPY(qctl, oqctl);
}
#endif /* HAVE_QUOTA_SUPPORT */
case OBD_IOC_GETNAME: {
- struct obd_device *obd = class_exp2obd(sbi->ll_osc_exp);
+ struct obd_device *obd = class_exp2obd(sbi->ll_dt_exp);
if (!obd)
RETURN(-EFAULT);
if (copy_to_user((void *)arg, obd->obd_name,
RETURN(0);
}
default:
- RETURN(obd_iocontrol(cmd, sbi->ll_osc_exp,0,NULL,(void *)arg));
+ RETURN(obd_iocontrol(cmd, sbi->ll_dt_exp,0,NULL,(void *)arg));
}
}
struct ll_file_data *fd = LUSTRE_FPRIVATE(file);
struct ptlrpc_request *req = NULL;
struct obd_client_handle *och = &fd->fd_mds_och;
- struct mdc_op_data op_data;
+ struct md_op_data op_data;
int rc;
ENTRY;
lov_test_and_clear_async_rc(lsm);
lli->lli_async_rc = 0;
- rc = ll_mdc_close(sbi->ll_mdc_exp, inode, file);
+ rc = ll_mdc_close(sbi->ll_md_exp, inode, file);
RETURN(rc);
}
{
struct ll_sb_info *sbi = ll_i2sbi(file->f_dentry->d_inode);
struct lustre_handle lockh;
- struct mdc_op_data data = { { 0 } };
+ struct md_op_data op_data = { { 0 } };
struct dentry *parent = file->f_dentry->d_parent;
const char *name = file->f_dentry->d_name.name;
const int len = file->f_dentry->d_name.len;
if (!parent)
RETURN(-ENOENT);
- ll_prepare_mdc_op_data(&data, parent->d_inode, NULL, name, len, O_RDWR);
+ ll_prepare_md_op_data(&op_data, parent->d_inode, NULL,
+ name, len, O_RDWR);
- rc = mdc_enqueue(sbi->ll_mdc_exp, LDLM_IBITS, itp, LCK_PW, &data,
+ rc = mdc_enqueue(sbi->ll_md_exp, LDLM_IBITS, itp, LCK_PW, &op_data,
&lockh, lmm, lmmsize, ldlm_completion_ast,
ll_mdc_blocking_ast, NULL, 0);
if (rc < 0)
{
struct ll_inode_info *lli = ll_i2info(inode);
struct lov_stripe_md *lsm = lli->lli_smd;
- struct obd_export *exp = ll_i2obdexp(inode);
+ struct obd_export *exp = ll_i2dtexp(inode);
struct {
char name[16];
struct ldlm_lock *lock;
* holding a DLM lock against this file, and resulting size
* will be returned for each stripe. DLM lock on [0, EOF] is
* acquired only if there were no conflicting locks. */
- rc = obd_enqueue(sbi->ll_osc_exp, lli->lli_smd, LDLM_EXTENT, &policy,
+ rc = obd_enqueue(sbi->ll_dt_exp, lli->lli_smd, LDLM_EXTENT, &policy,
LCK_PR, &ast_flags, ll_extent_lock_callback,
ldlm_completion_ast, ll_glimpse_callback, inode,
sizeof(struct ost_lvb), lustre_swab_ost_lvb, &lockh);
ll_inode_size_lock(inode, 1);
inode_init_lvb(inode, &lvb);
- obd_merge_lvb(sbi->ll_osc_exp, lli->lli_smd, &lvb, 0);
+ obd_merge_lvb(sbi->ll_dt_exp, lli->lli_smd, &lvb, 0);
inode->i_size = lvb.lvb_size;
inode->i_blocks = lvb.lvb_blocks;
LTIME_S(inode->i_mtime) = lvb.lvb_mtime;
CDEBUG(D_DLMTRACE, "glimpse: size: %llu, blocks: %lu\n",
inode->i_size, inode->i_blocks);
- obd_cancel(sbi->ll_osc_exp, lli->lli_smd, LCK_PR, &lockh);
+ obd_cancel(sbi->ll_dt_exp, lli->lli_smd, LCK_PR, &lockh);
RETURN(rc);
}
CDEBUG(D_DLMTRACE, "Locking inode %lu, start "LPU64" end "LPU64"\n",
inode->i_ino, policy->l_extent.start, policy->l_extent.end);
- rc = obd_enqueue(sbi->ll_osc_exp, lsm, LDLM_EXTENT, policy, mode,
+ rc = obd_enqueue(sbi->ll_dt_exp, lsm, LDLM_EXTENT, policy, mode,
&ast_flags, ll_extent_lock_callback,
ldlm_completion_ast, ll_glimpse_callback, inode,
sizeof(struct ost_lvb), lustre_swab_ost_lvb, lockh);
ll_inode_size_lock(inode, 1);
inode_init_lvb(inode, &lvb);
- obd_merge_lvb(sbi->ll_osc_exp, lsm, &lvb, 0);
+ obd_merge_lvb(sbi->ll_dt_exp, lsm, &lvb, 0);
if (policy->l_extent.start == 0 &&
policy->l_extent.end == OBD_OBJECT_EOF) {
(sbi->ll_flags & LL_SBI_NOLCK))
RETURN(0);
- rc = obd_cancel(sbi->ll_osc_exp, lsm, mode, lockh);
+ rc = obd_cancel(sbi->ll_dt_exp, lsm, mode, lockh);
RETURN(rc);
}
* correctly in the face of concurrent writes and truncates.
*/
inode_init_lvb(inode, &lvb);
- obd_merge_lvb(ll_i2sbi(inode)->ll_osc_exp, lsm, &lvb, 1);
+ obd_merge_lvb(ll_i2sbi(inode)->ll_dt_exp, lsm, &lvb, 1);
kms = lvb.lvb_size;
if (*ppos + count - 1 > kms) {
/* A glimpse is necessary to determine whether we return a
* correctly in the face of concurrent writes and truncates.
*/
inode_init_lvb(inode, &lvb);
- obd_merge_lvb(ll_i2sbi(inode)->ll_osc_exp, lsm, &lvb, 1);
+ obd_merge_lvb(ll_i2sbi(inode)->ll_dt_exp, lsm, &lvb, 1);
kms = lvb.lvb_size;
if (*ppos + count - 1 > kms) {
/* A glimpse is necessary to determine whether we return a
unsigned long arg)
{
struct ll_inode_info *lli = ll_i2info(inode);
- struct obd_export *exp = ll_i2obdexp(inode);
+ struct obd_export *exp = ll_i2dtexp(inode);
struct ll_recreate_obj ucreatp;
struct obd_trans_info oti = { 0 };
struct obdo *oa = NULL;
{
struct ll_inode_info *lli = ll_i2info(inode);
struct file *f = NULL;
- struct obd_export *exp = ll_i2obdexp(inode);
+ struct obd_export *exp = ll_i2dtexp(inode);
struct lov_stripe_md *lsm;
struct lookup_intent oit = {.it_op = IT_OPEN, .it_flags = flags};
struct ptlrpc_request *req = NULL;
rc = ll_lov_setstripe_ea_info(inode, file, flags, &lum, sizeof(lum));
if (rc == 0) {
put_user(0, &lump->lmm_stripe_count);
- rc = obd_iocontrol(LL_IOC_LOV_GETSTRIPE, ll_i2obdexp(inode),
+ rc = obd_iocontrol(LL_IOC_LOV_GETSTRIPE, ll_i2dtexp(inode),
0, ll_i2info(inode)->lli_smd, lump);
}
RETURN(rc);
if (!lsm)
RETURN(-ENODATA);
- return obd_iocontrol(LL_IOC_LOV_GETSTRIPE, ll_i2obdexp(inode), 0, lsm,
+ return obd_iocontrol(LL_IOC_LOV_GETSTRIPE, ll_i2dtexp(inode), 0, lsm,
(void *)arg);
}
struct ptlrpc_request *req = NULL;
struct ll_file_data *fd;
struct lustre_handle lockh;
- struct mdc_op_data *op_data;
+ struct md_op_data *op_data;
__u32 hsize = head_inode->i_size >> 32;
__u32 tsize = head_inode->i_size;
struct file *f;
f->f_dentry = dget(head_filp->f_dentry);
f->f_vfsmnt = mntget(head_filp->f_vfsmnt);
- ll_prepare_mdc_op_data(op_data, head_inode, tail_parent,
- tail_dentry->d_name.name,
- tail_dentry->d_name.len, 0);
+ ll_prepare_md_op_data(op_data, head_inode, tail_parent,
+ tail_dentry->d_name.name,
+ tail_dentry->d_name.len, 0);
- rc = mdc_enqueue(ll_i2mdcexp(head_inode), LDLM_IBITS, &oit, LCK_PW,
+ rc = mdc_enqueue(ll_i2mdexp(head_inode), LDLM_IBITS, &oit, LCK_PW,
op_data, &lockh, &tsize, 0, ldlm_completion_ast,
ll_mdc_blocking_ast, &hsize, 0);
switch (cleanup_phase) {
case 3:
ll_tree_unlock(&second_tree);
- obd_cancel_unused(ll_i2obdexp(second),
+ obd_cancel_unused(ll_i2dtexp(second),
ll_i2info(second)->lli_smd, 0, NULL);
case 2:
ll_tree_unlock(&first_tree);
- obd_cancel_unused(ll_i2obdexp(first),
+ obd_cancel_unused(ll_i2dtexp(first),
ll_i2info(first)->lli_smd, 0, NULL);
case 1:
filp_close(tail_filp, 0);
if (tail)
iput(tail);
if (head && rc == 0) {
- obd_free_memmd(ll_i2sbi(head)->ll_osc_exp,
+ obd_free_memmd(ll_i2sbi(head)->ll_dt_exp,
&hlli->lli_smd);
hlli->lli_smd = NULL;
}
case EXT3_IOC_SETVERSION:
*/
default:
- RETURN(obd_iocontrol(cmd, ll_i2obdexp(inode), 0, NULL,
+ RETURN(obd_iocontrol(cmd, ll_i2dtexp(inode), 0, NULL,
(void *)arg));
}
}
rc = err;
}
- err = mdc_sync(ll_i2sbi(inode)->ll_mdc_exp,
+ err = mdc_sync(ll_i2sbi(inode)->ll_md_exp,
ll_inode2fid(inode), &req);
if (!rc)
rc = err;
obdo_from_inode(oa, inode, OBD_MD_FLTYPE | OBD_MD_FLATIME |
OBD_MD_FLMTIME | OBD_MD_FLCTIME);
- err = obd_sync(ll_i2sbi(inode)->ll_osc_exp, oa, lsm,
+ err = obd_sync(ll_i2sbi(inode)->ll_dt_exp, oa, lsm,
0, OBD_OBJECT_EOF);
if (!rc)
rc = err;
"start="LPU64", end="LPU64"\n", inode->i_ino, flock.l_flock.pid,
flags, mode, flock.l_flock.start, flock.l_flock.end);
- obddev = sbi->ll_mdc_exp->exp_obd;
- rc = ldlm_cli_enqueue(sbi->ll_mdc_exp, NULL, obddev->obd_namespace,
+ obddev = sbi->ll_md_exp->exp_obd;
+ rc = ldlm_cli_enqueue(sbi->ll_md_exp, NULL, obddev->obd_namespace,
res_id, LDLM_FLOCK, &flock, mode, &flags,
NULL, ldlm_flock_completion_ast, NULL, file_lock,
NULL, 0, NULL, &lockh);
if (!de->d_inode)
RETURN(0);
- obddev = sbi->ll_mdc_exp->exp_obd;
+ obddev = sbi->ll_md_exp->exp_obd;
res_id.name[0] = fid_seq(ll_inode2fid(de->d_inode));
res_id.name[1] = fid_num(ll_inode2fid(de->d_inode));
RETURN(rc);
valid |= OBD_MD_FLEASIZE | OBD_MD_FLMODEASIZE;
}
- rc = mdc_getattr(sbi->ll_mdc_exp, ll_inode2fid(inode),
+ rc = mdc_getattr(sbi->ll_md_exp, ll_inode2fid(inode),
valid, ealen, &req);
if (rc) {
CERROR("failure %d inode %lu\n", rc, inode->i_ino);
RETURN(-abs(rc));
}
- rc = ll_prep_inode(sbi->ll_osc_exp, &inode, req, 0, NULL);
+ rc = ll_prep_inode(sbi->ll_dt_exp, &inode, req, 0, NULL);
if (rc) {
ptlrpc_req_finished(req);
RETURN(rc);
struct ll_inode_info *lli = ll_i2info(inode);
ldlm_policy_data_t policy = { .l_extent = {0, OBD_OBJECT_EOF } };
struct lustre_handle lockh = { 0 };
- struct mdc_op_data op_data;
+ struct md_op_data op_data;
struct obdo obdo;
obd_flag valid;
int rc, ast_flags = 0;
GOTO(out, rc);
}
- rc = ll_lsm_getattr(ll_i2obdexp(inode), lli->lli_smd, &obdo);
+ rc = ll_lsm_getattr(ll_i2dtexp(inode), lli->lli_smd, &obdo);
if (rc) {
CERROR("inode_getattr failed (%d): unable to send DONE_WRITING "
"for inode %lu/%u\n", rc, inode->i_ino,
op_data.blocks = inode->i_blocks;
op_data.valid = OBD_MD_FLID | OBD_MD_FLSIZE | OBD_MD_FLBLOCKS;
- rc = mdc_done_writing(ll_i2sbi(inode)->ll_mdc_exp, &op_data);
+ rc = mdc_done_writing(ll_i2sbi(inode)->ll_md_exp, &op_data);
out:
}
#endif
* grab from interrupt contexts */
spinlock_t ll_lock;
struct obd_uuid ll_sb_uuid;
- struct obd_export *ll_mdc_exp;
- struct obd_export *ll_osc_exp;
+ struct obd_export *ll_md_exp;
+ struct obd_export *ll_dt_exp;
struct proc_dir_entry* ll_proc_root;
struct lu_fid ll_root_fid; /* root object fid */
void *opaque);
int ll_mdc_blocking_ast(struct ldlm_lock *, struct ldlm_lock_desc *,
void *data, int flag);
-void ll_prepare_mdc_op_data(struct mdc_op_data *op_data, struct inode *i1,
- struct inode *i2, const char *name, int namelen,
- int mode);
+void ll_prepare_md_op_data(struct md_op_data *op_data, struct inode *i1,
+ struct inode *i2, const char *name, int namelen,
+ int mode);
/* llite/rw.c */
int ll_prepare_write(struct file *, struct page *, unsigned from, unsigned to);
#endif
/* don't need an addref as the sb_info should be holding one */
-static inline struct obd_export *ll_s2obdexp(struct super_block *sb)
+static inline struct obd_export *ll_s2dtexp(struct super_block *sb)
{
- return ll_s2sbi(sb)->ll_osc_exp;
+ return ll_s2sbi(sb)->ll_dt_exp;
}
/* don't need an addref as the sb_info should be holding one */
-static inline struct obd_export *ll_s2mdcexp(struct super_block *sb)
+static inline struct obd_export *ll_s2mdexp(struct super_block *sb)
{
- return ll_s2sbi(sb)->ll_mdc_exp;
+ return ll_s2sbi(sb)->ll_md_exp;
}
static inline struct client_obd *sbi2mdc(struct ll_sb_info *sbi)
{
- struct obd_device *obd = sbi->ll_mdc_exp->exp_obd;
+ struct obd_device *obd = sbi->ll_md_exp->exp_obd;
if (obd == NULL)
LBUG();
return &obd->u.cli;
return ll_s2sbi(inode->i_sb);
}
-static inline struct obd_export *ll_i2obdexp(struct inode *inode)
+static inline struct obd_export *ll_i2dtexp(struct inode *inode)
{
- return ll_s2obdexp(inode->i_sb);
+ return ll_s2dtexp(inode->i_sb);
}
-static inline struct obd_export *ll_i2mdcexp(struct inode *inode)
+static inline struct obd_export *ll_i2mdexp(struct inode *inode)
{
- return ll_s2mdcexp(inode->i_sb);
+ return ll_s2mdexp(inode->i_sb);
}
static inline struct lu_fid *ll_inode2fid(struct inode *inode)
CERROR("cannot connect to %s: rc = %d\n", mdc, err);
GOTO(out, err);
}
- sbi->ll_mdc_exp = class_conn2export(&mdc_conn);
+ sbi->ll_md_exp = class_conn2export(&mdc_conn);
err = obd_statfs(obd, &osfs, jiffies - HZ);
if (err)
GOTO(out_mdc, err);
/* MDC connect is surely finished by now */
- *data = class_exp2cliimp(sbi->ll_mdc_exp)->imp_connect_data;
- *md_data = class_exp2cliimp(sbi->ll_mdc_exp)->imp_connect_data;
+ *data = class_exp2cliimp(sbi->ll_md_exp)->imp_connect_data;
+ *md_data = class_exp2cliimp(sbi->ll_md_exp)->imp_connect_data;
LASSERT(osfs.os_bsize);
sb->s_blocksize = osfs.os_bsize;
GOTO(out_mdc, err);
}
- sbi->ll_osc_exp = class_conn2export(&osc_conn);
+ sbi->ll_dt_exp = class_conn2export(&osc_conn);
spin_lock(&sbi->ll_lco.lco_lock);
sbi->ll_lco.lco_flags = data->ocd_connect_flags;
spin_unlock(&sbi->ll_lco.lco_lock);
- mdc_init_ea_size(sbi->ll_mdc_exp, sbi->ll_osc_exp);
+ mdc_init_ea_size(sbi->ll_md_exp, sbi->ll_dt_exp);
- err = obd_prep_async_page(sbi->ll_osc_exp, NULL, NULL, NULL,
+ err = obd_prep_async_page(sbi->ll_dt_exp, NULL, NULL, NULL,
0, NULL, NULL, NULL);
if (err < 0) {
LCONSOLE_ERROR("There are no OST's in this filesystem. "
GOTO(out_osc, -ENOMEM);
}
- err = mdc_getstatus(sbi->ll_mdc_exp, &rootfid);
+ err = mdc_getstatus(sbi->ll_md_exp, &rootfid);
if (err) {
CERROR("cannot mds_connect: rc = %d\n", err);
GOTO(out_osc, err);
/* make root inode
* XXX: move this to after cbd setup? */
- err = mdc_getattr(sbi->ll_mdc_exp, &rootfid,
+ err = mdc_getattr(sbi->ll_md_exp, &rootfid,
OBD_MD_FLGETATTR | OBD_MD_FLBLOCKS |
(sbi->ll_flags & LL_SBI_ACL ? OBD_MD_FLACL : 0),
0, &request);
GOTO(out_osc, err);
}
- err = mdc_req2lustre_md(request, 0, sbi->ll_osc_exp, &md);
+ err = mdc_req2lustre_md(request, 0, sbi->ll_dt_exp, &md);
if (err) {
CERROR("failed to understand root inode md: rc = %d\n", err);
ptlrpc_req_finished (request);
ptlrpc_req_finished(request);
if (root == NULL || is_bad_inode(root)) {
- mdc_free_lustre_md(sbi->ll_osc_exp, &md);
+ mdc_free_lustre_md(sbi->ll_dt_exp, &md);
CERROR("lustre_lite: bad iget4 for root\n");
GOTO(out_root, err = -EBADF);
}
if (root)
iput(root);
out_osc:
- obd_disconnect(sbi->ll_osc_exp);
+ obd_disconnect(sbi->ll_dt_exp);
out_mdc:
- obd_disconnect(sbi->ll_mdc_exp);
+ obd_disconnect(sbi->ll_md_exp);
out:
if (data != NULL)
OBD_FREE_PTR(data);
{
int size, rc;
- *lmmsize = obd_size_diskmd(sbi->ll_osc_exp, NULL);
+ *lmmsize = obd_size_diskmd(sbi->ll_dt_exp, NULL);
size = sizeof(int);
- rc = obd_get_info(sbi->ll_mdc_exp, strlen("max_easize"), "max_easize",
+ rc = obd_get_info(sbi->ll_md_exp, strlen("max_easize"), "max_easize",
&size, lmmsize);
if (rc)
CERROR("Get max mdsize error rc %d \n", rc);
dentry_count++;
CERROR("inode %p dump: dev=%s ino=%lu mode=%o count=%u, %d dentries\n",
- inode, ll_i2mdcexp(inode)->exp_obd->obd_name, inode->i_ino,
+ inode, ll_i2mdexp(inode)->exp_obd->obd_name, inode->i_ino,
inode->i_mode, atomic_read(&inode->i_count), dentry_count);
}
prune_deathrow(sbi, 0);
list_del(&sbi->ll_conn_chain);
- obd_disconnect(sbi->ll_osc_exp);
+ obd_disconnect(sbi->ll_dt_exp);
lprocfs_unregister_mountpoint(sbi);
if (sbi->ll_proc_root) {
sbi->ll_proc_root = NULL;
}
- obd_disconnect(sbi->ll_mdc_exp);
+ obd_disconnect(sbi->ll_md_exp);
lustre_throw_orphan_dentries(sb);
EXIT;
cfg.cfg_instance = ll_instance;
lustre_end_log(sb, NULL, &cfg);
- obd = class_exp2obd(sbi->ll_mdc_exp);
+ obd = class_exp2obd(sbi->ll_md_exp);
if (obd) {
int next = 0;
int force = obd->obd_no_recov;
inode->i_generation, inode);
clear_bit(LLI_F_HAVE_MDS_SIZE_LOCK, &(ll_i2info(inode)->lli_flags));
- mdc_change_cbdata(sbi->ll_mdc_exp, ll_inode2fid(inode),
+ mdc_change_cbdata(sbi->ll_md_exp, ll_inode2fid(inode),
null_if_equal, inode);
if (lli->lli_smd) {
- obd_change_cbdata(sbi->ll_osc_exp, lli->lli_smd,
+ obd_change_cbdata(sbi->ll_dt_exp, lli->lli_smd,
null_if_equal, inode);
- obd_free_memmd(sbi->ll_osc_exp, &lli->lli_smd);
+ obd_free_memmd(sbi->ll_dt_exp, &lli->lli_smd);
lli->lli_smd = NULL;
}
struct lov_stripe_md *lsm = lli->lli_smd;
struct ll_sb_info *sbi = ll_i2sbi(inode);
struct ptlrpc_request *request = NULL;
- struct mdc_op_data op_data = { { 0 } };
+ struct md_op_data op_data = { { 0 } };
int ia_valid = attr->ia_valid;
int rc = 0;
ENTRY;
* inode ourselves so we can call obdo_from_inode() always. */
if (ia_valid & (lsm ? ~(ATTR_SIZE | ATTR_FROM_OPEN | ATTR_RAW) : ~0)) {
struct lustre_md md;
- ll_prepare_mdc_op_data(&op_data, inode, NULL, NULL, 0, 0);
+ ll_prepare_md_op_data(&op_data, inode, NULL, NULL, 0, 0);
- rc = mdc_setattr(sbi->ll_mdc_exp, &op_data,
+ rc = mdc_setattr(sbi->ll_md_exp, &op_data,
attr, NULL, 0, NULL, 0, &request);
if (rc) {
RETURN(rc);
}
- rc = mdc_req2lustre_md(request, 0, sbi->ll_osc_exp, &md);
+ rc = mdc_req2lustre_md(request, 0, sbi->ll_dt_exp, &md);
if (rc) {
ptlrpc_req_finished(request);
RETURN(rc);
OBD_MD_FLFID | OBD_MD_FLGENER;
obdo_from_inode(&oa, inode, flags);
- rc = obd_setattr(sbi->ll_osc_exp, &oa, lsm, NULL);
+ rc = obd_setattr(sbi->ll_dt_exp, &oa, lsm, NULL);
if (rc)
CERROR("obd_setattr fails: rc=%d\n", rc);
}
int rc;
ENTRY;
- rc = obd_statfs(class_exp2obd(sbi->ll_mdc_exp), osfs, max_age);
+ rc = obd_statfs(class_exp2obd(sbi->ll_md_exp), osfs, max_age);
if (rc) {
CERROR("mdc_statfs fails: rc = %d\n", rc);
RETURN(rc);
CDEBUG(D_SUPER, "MDC blocks "LPU64"/"LPU64" objects "LPU64"/"LPU64"\n",
osfs->os_bavail, osfs->os_blocks, osfs->os_ffree,osfs->os_files);
- rc = obd_statfs(class_exp2obd(sbi->ll_osc_exp), &obd_osfs, max_age);
+ rc = obd_statfs(class_exp2obd(sbi->ll_dt_exp), &obd_osfs, max_age);
if (rc) {
CERROR("obd_statfs fails: rc = %d\n", rc);
RETURN(rc);
dump_lsm(D_INODE, lli->lli_smd);
LASSERTF(lsm->lsm_magic == LOV_MAGIC_JOIN,
"lsm must be joined lsm %p\n", lsm);
- obd_free_memmd(ll_i2obdexp(inode), &lli->lli_smd);
+ obd_free_memmd(ll_i2dtexp(inode), &lli->lli_smd);
CDEBUG(D_INODE, "replace lsm %p to lli_smd %p for inode %lu%u(%p)\n",
lsm, lli->lli_smd, inode->i_ino, inode->i_generation, inode);
lli->lli_smd = lsm;
LASSERTF(lsm->lsm_xfersize != 0, "%lu\n", lsm->lsm_xfersize);
inode->i_blksize = min(lsm->lsm_xfersize, LL_MAX_BLKSIZE);
if (lli->lli_smd != lsm)
- obd_free_memmd(ll_i2obdexp(inode), &lsm);
+ obd_free_memmd(ll_i2dtexp(inode), &lsm);
} else {
inode->i_blksize = max(inode->i_blksize,
inode->i_sb->s_blocksize);
case EXT3_IOC_GETFLAGS: {
struct mdt_body *body;
- rc = mdc_getattr(sbi->ll_mdc_exp, ll_inode2fid(inode),
+ rc = mdc_getattr(sbi->ll_md_exp, ll_inode2fid(inode),
OBD_MD_FLFLAGS, 0, &req);
if (rc) {
CERROR("failure %d inode %lu\n", rc, inode->i_ino);
RETURN(put_user(flags, (int *)arg));
}
case EXT3_IOC_SETFLAGS: {
- struct mdc_op_data op_data = { { 0 } };
+ struct md_op_data op_data = { { 0 } };
struct iattr attr;
struct obdo *oa;
struct lov_stripe_md *lsm = ll_i2info(inode)->lli_smd;
if (!oa)
RETURN(-ENOMEM);
- ll_prepare_mdc_op_data(&op_data, inode, NULL, NULL, 0, 0);
+ ll_prepare_md_op_data(&op_data, inode, NULL, NULL, 0, 0);
memset(&attr, 0x0, sizeof(attr));
attr.ia_attr_flags = flags;
attr.ia_valid |= ATTR_ATTR_FLAG;
- rc = mdc_setattr(sbi->ll_mdc_exp, &op_data,
+ rc = mdc_setattr(sbi->ll_md_exp, &op_data,
&attr, NULL, 0, NULL, 0, &req);
if (rc || lsm == NULL) {
ptlrpc_req_finished(req);
oa->o_valid = OBD_MD_FLID | OBD_MD_FLFLAGS;
obdo_from_inode(oa, inode, OBD_MD_FLFID | OBD_MD_FLGENER);
- rc = obd_setattr(sbi->ll_osc_exp, oa, lsm, NULL);
+ rc = obd_setattr(sbi->ll_dt_exp, oa, lsm, NULL);
obdo_free(oa);
if (rc) {
if (rc != -EPERM && rc != -EACCES)
CDEBUG(D_VFSTRACE, "VFS Op: superblock %p count %d active %d\n", sb,
sb->s_count, atomic_read(&sb->s_active));
- obd = class_exp2obd(sbi->ll_mdc_exp);
+ obd = class_exp2obd(sbi->ll_md_exp);
if (obd == NULL) {
CERROR("Invalid MDC connection handle "LPX64"\n",
- sbi->ll_mdc_exp->exp_handle.h_cookie);
+ sbi->ll_md_exp->exp_handle.h_cookie);
EXIT;
return;
}
obd->obd_no_recov = 1;
- obd_iocontrol(IOC_OSC_SET_ACTIVE, sbi->ll_mdc_exp, sizeof ioc_data,
+ obd_iocontrol(IOC_OSC_SET_ACTIVE, sbi->ll_md_exp, sizeof ioc_data,
&ioc_data, NULL);
- obd = class_exp2obd(sbi->ll_osc_exp);
+ obd = class_exp2obd(sbi->ll_dt_exp);
if (obd == NULL) {
CERROR("Invalid LOV connection handle "LPX64"\n",
- sbi->ll_osc_exp->exp_handle.h_cookie);
+ sbi->ll_dt_exp->exp_handle.h_cookie);
EXIT;
return;
}
obd->obd_no_recov = 1;
- obd_iocontrol(IOC_OSC_SET_ACTIVE, sbi->ll_osc_exp, sizeof ioc_data,
+ obd_iocontrol(IOC_OSC_SET_ACTIVE, sbi->ll_dt_exp, sizeof ioc_data,
&ioc_data, NULL);
/* Really, we'd like to wait until there are no requests outstanding,
if ((*flags & MS_RDONLY) != (sb->s_flags & MS_RDONLY)) {
read_only = *flags & MS_RDONLY;
- err = obd_set_info(sbi->ll_mdc_exp, strlen("read-only"),
+ err = obd_set_info(sbi->ll_md_exp, strlen("read-only"),
"read-only", sizeof(read_only), &read_only);
if (err) {
CERROR("Failed to change the read-only flag during "
ll_i2info(*inode)->lli_fid = md.body->fid1;
}
- rc = obd_checkmd(exp, ll_i2mdcexp(*inode),
+ rc = obd_checkmd(exp, ll_i2mdexp(*inode),
ll_i2info(*inode)->lli_smd);
out:
RETURN(rc);
if (type == LL_STATFS_MDC) {
if (index > 0)
GOTO(out_statfs, rc = -ENODEV);
- client_obd = class_exp2obd(sbi->ll_mdc_exp);
+ client_obd = class_exp2obd(sbi->ll_md_exp);
} else if (type == LL_STATFS_LOV) {
- lov_obd = class_exp2obd(sbi->ll_osc_exp);
+ lov_obd = class_exp2obd(sbi->ll_dt_exp);
lov = &lov_obd->u.lov;
if (index >= lov->desc.ld_tgt_count)
lov_stripe_lock(lsm);
inode_init_lvb(inode, &lvb);
- obd_merge_lvb(ll_i2obdexp(inode), lsm, &lvb, 1);
+ obd_merge_lvb(ll_i2dtexp(inode), lsm, &lvb, 1);
kms = lvb.lvb_size;
pgoff = ((address - vma->vm_start) >> PAGE_CACHE_SHIFT) + vma->vm_pgoff;
int count;
spin_unlock(&lli->lli_lock);
- count = obd_join_lru(sbi->ll_osc_exp, lsm, 0);
+ count = obd_join_lru(sbi->ll_dt_exp, lsm, 0);
VMA_DEBUG(vma, "split %d unused locks from lru\n", count);
} else {
spin_unlock(&lli->lli_lock);
int count;
spin_unlock(&lli->lli_lock);
- count = obd_join_lru(sbi->ll_osc_exp, lsm, 1);
+ count = obd_join_lru(sbi->ll_dt_exp, lsm, 1);
VMA_DEBUG(vma, "join %d unused locks to lru\n", count);
} else {
spin_unlock(&lli->lli_lock);
valid |= OBD_MD_FLEASIZE;
}
- rc = mdc_getattr(sbi->ll_mdc_exp, fid, valid, eadatalen, &req);
+ rc = mdc_getattr(sbi->ll_md_exp, fid, valid, eadatalen, &req);
if (rc) {
CERROR("can't get object attrs, fid "DFID3", rc %d\n",
PFID3(fid), rc);
return ERR_PTR(rc);
}
- rc = ll_prep_inode(sbi->ll_osc_exp, &inode, req, 0, sb);
+ rc = ll_prep_inode(sbi->ll_dt_exp, &inode, req, 0, sb);
if (rc) {
ptlrpc_req_finished(req);
return ERR_PTR(rc);
else
sbi->ll_flags &= ~LL_SBI_CHECKSUM;
- rc = obd_set_info(sbi->ll_osc_exp, strlen("checksum"), "checksum",
+ rc = obd_set_info(sbi->ll_dt_exp, strlen("checksum"), "checksum",
sizeof(val), &val);
if (rc)
CWARN("Failed to set OSC checksum flags: %d\n", rc);
}
}
-void ll_prepare_mdc_op_data(struct mdc_op_data *op_data, struct inode *i1,
+void ll_prepare_md_op_data(struct md_op_data *op_data, struct inode *i1,
struct inode *i2, const char *name, int namelen,
int mode)
{
if (!it_disposition(it, DISP_LOOKUP_NEG)) {
ENTRY;
- rc = ll_prep_inode(sbi->ll_osc_exp, &inode, request, offset,
+ rc = ll_prep_inode(sbi->ll_dt_exp, &inode, request, offset,
(*de)->d_sb);
if (rc)
RETURN(rc);
struct lookup_intent *it, int lookup_flags)
{
struct dentry *save = dentry, *retval;
- struct mdc_op_data op_data = { { 0 } };
+ struct md_op_data op_data = { { 0 } };
struct it_cb_data icbd;
struct ptlrpc_request *req = NULL;
struct lookup_intent lookup_it = { .it_op = IT_LOOKUP };
}
}
- ll_prepare_mdc_op_data(&op_data, parent, NULL, dentry->d_name.name,
+ ll_prepare_md_op_data(&op_data, parent, NULL, dentry->d_name.name,
dentry->d_name.len, lookup_flags);
it->it_create_mode &= ~current->fs->umask;
- rc = mdc_intent_lock(ll_i2mdcexp(parent), &op_data, NULL, 0, it,
+ rc = mdc_intent_lock(ll_i2mdexp(parent), &op_data, NULL, 0, it,
lookup_flags, &req, ll_mdc_blocking_ast, 0);
if (rc < 0)
LASSERT(it && it->d.lustre.it_disposition);
request = it->d.lustre.it_data;
- rc = ll_prep_inode(sbi->ll_osc_exp, &inode, request, 1, dir->i_sb);
+ rc = ll_prep_inode(sbi->ll_dt_exp, &inode, request, 1, dir->i_sb);
if (rc)
GOTO(out, inode = ERR_PTR(rc));
struct ptlrpc_request *request = NULL;
struct inode *dir = nd->dentry->d_inode;
struct ll_sb_info *sbi = ll_i2sbi(dir);
- struct mdc_op_data op_data = { { 0 } };
+ struct md_op_data op_data = { { 0 } };
int err;
ENTRY;
case S_IFBLK:
case S_IFIFO:
case S_IFSOCK:
- ll_prepare_mdc_op_data(&op_data, dir, NULL,
+ ll_prepare_md_op_data(&op_data, dir, NULL,
nd->last.name, nd->last.len, 0);
- err = mdc_create(sbi->ll_mdc_exp, &op_data, NULL, 0, mode,
+ err = mdc_create(sbi->ll_md_exp, &op_data, NULL, 0, mode,
current->fsuid, current->fsgid,
current->cap_effective, rdev, &request);
if (err == 0)
struct ptlrpc_request *request = NULL;
struct inode *inode = NULL;
struct ll_sb_info *sbi = ll_i2sbi(dir);
- struct mdc_op_data op_data = { { 0 } };
+ struct md_op_data op_data = { { 0 } };
int err;
ENTRY;
LBUG();
}
- ll_prepare_mdc_op_data(&op_data, dir, NULL, dchild->d_name.name,
+ ll_prepare_md_op_data(&op_data, dir, NULL, dchild->d_name.name,
dchild->d_name.len, 0);
- err = mdc_create(sbi->ll_mdc_exp, &op_data, NULL, 0, mode,
+ err = mdc_create(sbi->ll_md_exp, &op_data, NULL, 0, mode,
current->fsuid, current->fsgid,
current->cap_effective, rdev, &request);
if (err)
ll_update_times(request, 0, dir);
- err = ll_prep_inode(sbi->ll_osc_exp, &inode, request, 0,
+ err = ll_prep_inode(sbi->ll_dt_exp, &inode, request, 0,
dchild->d_sb);
if (err)
GOTO(out_err, err);
struct inode *dir = nd->dentry->d_inode;
struct ptlrpc_request *request = NULL;
struct ll_sb_info *sbi = ll_i2sbi(dir);
- struct mdc_op_data op_data = { { 0 } };
+ struct md_op_data op_data = { { 0 } };
int err;
ENTRY;
LBUG();
}
- ll_prepare_mdc_op_data(&op_data, dir, NULL,
+ ll_prepare_md_op_data(&op_data, dir, NULL,
nd->last.name, nd->last.len, 0);
- err = mdc_create(sbi->ll_mdc_exp, &op_data,
+ err = mdc_create(sbi->ll_md_exp, &op_data,
tgt, strlen(tgt) + 1, S_IFLNK | S_IRWXUGO,
current->fsuid, current->fsgid, current->cap_effective,
0, &request);
struct inode *src = srcnd->dentry->d_inode;
struct inode *dir = tgtnd->dentry->d_inode;
struct ptlrpc_request *request = NULL;
- struct mdc_op_data op_data = { { 0 } };
+ struct md_op_data op_data = { { 0 } };
int err;
struct ll_sb_info *sbi = ll_i2sbi(dir);
src->i_ino, src->i_generation, src, dir->i_ino,
dir->i_generation, dir, tgtnd->last.len, tgtnd->last.name);
- ll_prepare_mdc_op_data(&op_data, src, dir, tgtnd->last.name,
+ ll_prepare_md_op_data(&op_data, src, dir, tgtnd->last.name,
tgtnd->last.len, 0);
- err = mdc_link(sbi->ll_mdc_exp, &op_data, &request);
+ err = mdc_link(sbi->ll_md_exp, &op_data, &request);
if (err == 0)
ll_update_times(request, 0, dir);
struct inode *dir = nd->dentry->d_inode;
struct ptlrpc_request *request = NULL;
struct ll_sb_info *sbi = ll_i2sbi(dir);
- struct mdc_op_data op_data = { { 0 } };
+ struct md_op_data op_data = { { 0 } };
int err;
ENTRY;
CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p)\n",
LBUG();
}
- ll_prepare_mdc_op_data(&op_data, dir, NULL,
+ ll_prepare_md_op_data(&op_data, dir, NULL,
nd->last.name, nd->last.len, 0);
- err = mdc_create(sbi->ll_mdc_exp, &op_data, NULL, 0, mode,
+ err = mdc_create(sbi->ll_md_exp, &op_data, NULL, 0, mode,
current->fsuid, current->fsgid, current->cap_effective,
0, &request);
if (err == 0)
{
struct inode *dir = nd->dentry->d_inode;
struct ptlrpc_request *request = NULL;
- struct mdc_op_data op_data = { { 0 } };
+ struct md_op_data op_data = { { 0 } };
struct dentry *dentry;
int rc;
ENTRY;
RETURN(-EBUSY);
}
- ll_prepare_mdc_op_data(&op_data, dir, NULL, nd->last.name,
+ ll_prepare_md_op_data(&op_data, dir, NULL, nd->last.name,
nd->last.len, S_IFDIR);
- rc = mdc_unlink(ll_i2sbi(dir)->ll_mdc_exp, &op_data, &request);
+ rc = mdc_unlink(ll_i2sbi(dir)->ll_md_exp, &op_data, &request);
if (rc == 0)
ll_update_times(request, 0, dir);
ptlrpc_req_finished(request);
GOTO(out, rc = -EPROTO);
}
- rc = obd_unpackmd(ll_i2obdexp(dir), &lsm, eadata, body->eadatasize);
+ rc = obd_unpackmd(ll_i2dtexp(dir), &lsm, eadata, body->eadatasize);
if (rc < 0) {
CERROR("obd_unpackmd: %d\n", rc);
GOTO(out, rc);
}
LASSERT(rc >= sizeof(*lsm));
- rc = obd_checkmd(ll_i2obdexp(dir), ll_i2mdcexp(dir), lsm);
+ rc = obd_checkmd(ll_i2dtexp(dir), ll_i2mdexp(dir), lsm);
if (rc)
GOTO(out_free_memmd, rc);
}
}
- rc = obd_destroy(ll_i2obdexp(dir), oa, lsm, &oti, ll_i2mdcexp(dir));
+ rc = obd_destroy(ll_i2dtexp(dir), oa, lsm, &oti, ll_i2mdexp(dir));
obdo_free(oa);
if (rc)
CERROR("obd destroy objid "LPX64" error %d\n",
lsm->lsm_object_id, rc);
out_free_memmd:
- obd_free_memmd(ll_i2obdexp(dir), &lsm);
+ obd_free_memmd(ll_i2dtexp(dir), &lsm);
out:
return rc;
}
{
struct inode *dir = nd->dentry->d_inode;
struct ptlrpc_request *request = NULL;
- struct mdc_op_data op_data = { { 0 } };
+ struct md_op_data op_data = { { 0 } };
int rc;
ENTRY;
CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p)\n",
nd->last.len, nd->last.name, dir->i_ino, dir->i_generation, dir);
- ll_prepare_mdc_op_data(&op_data, dir, NULL,
+ ll_prepare_md_op_data(&op_data, dir, NULL,
nd->last.name, nd->last.len, 0);
- rc = mdc_unlink(ll_i2sbi(dir)->ll_mdc_exp, &op_data, &request);
+ rc = mdc_unlink(ll_i2sbi(dir)->ll_md_exp, &op_data, &request);
if (rc)
GOTO(out, rc);
struct inode *tgt = tgtnd->dentry->d_inode;
struct ptlrpc_request *request = NULL;
struct ll_sb_info *sbi = ll_i2sbi(src);
- struct mdc_op_data op_data = { { 0 } };
+ struct md_op_data op_data = { { 0 } };
int err;
ENTRY;
CDEBUG(D_VFSTRACE,"VFS Op:oldname=%.*s,src_dir=%lu/%u(%p),newname=%.*s,"
src->i_ino, src->i_generation, src, tgtnd->last.len,
tgtnd->last.name, tgt->i_ino, tgt->i_generation, tgt);
- ll_prepare_mdc_op_data(&op_data, src, tgt, NULL, 0, 0);
+ ll_prepare_md_op_data(&op_data, src, tgt, NULL, 0, 0);
- err = mdc_rename(sbi->ll_mdc_exp, &op_data,
+ err = mdc_rename(sbi->ll_md_exp, &op_data,
srcnd->last.name, srcnd->last.len,
tgtnd->last.name, tgtnd->last.len, &request);
if (!err) {
else
lprocfs_counter_add(ll_i2sbi(inode)->ll_stats,
LPROC_LL_BRW_READ, pg.count);
- rc = obd_brw(cmd, ll_i2obdexp(inode), oa, lsm, 1, &pg, NULL);
+ rc = obd_brw(cmd, ll_i2dtexp(inode), oa, lsm, 1, &pg, NULL);
if (rc == 0)
obdo_to_inode(inode, oa, OBD_MD_FLBLOCKS);
else if (rc != -EIO)
* race condition. */
lov_stripe_lock(lsm);
inode_init_lvb(inode, &lvb);
- obd_merge_lvb(ll_i2obdexp(inode), lsm, &lvb, 0);
+ obd_merge_lvb(ll_i2dtexp(inode), lsm, &lvb, 0);
if (lvb.lvb_size == inode->i_size) {
CDEBUG(D_VFSTRACE, "skipping punch for obj "LPX64", %Lu=%#Lx\n",
lsm->lsm_object_id, inode->i_size, inode->i_size);
GOTO(out_unlock, 0);
}
- obd_adjust_kms(ll_i2obdexp(inode), lsm, inode->i_size, 1);
+ obd_adjust_kms(ll_i2dtexp(inode), lsm, inode->i_size, 1);
lov_stripe_unlock(lsm);
if (unlikely((ll_i2sbi(inode)->ll_flags & LL_SBI_CHECKSUM) &&
ll_inode_size_unlock(inode, 0);
- rc = obd_punch(ll_i2obdexp(inode), &oa, lsm, inode->i_size,
+ rc = obd_punch(ll_i2dtexp(inode), &oa, lsm, inode->i_size,
OBD_OBJECT_EOF, NULL);
if (rc)
CERROR("obd_truncate fails (%d) ino %lu\n", rc, inode->i_ino);
oa.o_valid = OBD_MD_FLID | OBD_MD_FLMODE | OBD_MD_FLTYPE;
obdo_from_inode(&oa, inode, OBD_MD_FLFID | OBD_MD_FLGENER);
- rc = obd_brw(OBD_BRW_CHECK, ll_i2obdexp(inode), &oa, lsm,
+ rc = obd_brw(OBD_BRW_CHECK, ll_i2dtexp(inode), &oa, lsm,
1, &pga, NULL);
if (rc)
RETURN(rc);
* treat it like i_size. */
lov_stripe_lock(lsm);
inode_init_lvb(inode, &lvb);
- obd_merge_lvb(ll_i2obdexp(inode), lsm, &lvb, 0);
+ obd_merge_lvb(ll_i2dtexp(inode), lsm, &lvb, 0);
lov_stripe_unlock(lsm);
if (lvb.lvb_size <= offset) {
LL_CDEBUG_PAGE(D_PAGE, page, "kms "LPU64" <= offset "LPU64"\n",
lov_stripe_lock(lsm);
inode_init_lvb(inode, &lvb);
- obd_merge_lvb(ll_i2obdexp(inode), lsm, &lvb, 1);
+ obd_merge_lvb(ll_i2dtexp(inode), lsm, &lvb, 1);
kms = lvb.lvb_size;
lov_stripe_unlock(lsm);
GOTO(out, llap);
}
- exp = ll_i2obdexp(page->mapping->host);
+ exp = ll_i2dtexp(page->mapping->host);
if (exp == NULL)
RETURN(ERR_PTR(-EINVAL));
if (IS_ERR(llap))
RETURN(PTR_ERR(llap));
- exp = ll_i2obdexp(inode);
+ exp = ll_i2dtexp(inode);
if (exp == NULL)
RETURN(-EINVAL);
LL_CDEBUG_PAGE(D_PAGE, page, "being evicted\n");
- exp = ll_i2obdexp(inode);
+ exp = ll_i2dtexp(inode);
if (exp == NULL) {
CERROR("page %p ind %lu gave null export\n", page, page->index);
EXIT;
flags = LDLM_FL_TEST_LOCK | LDLM_FL_BLOCK_GRANTED;
if (!(fd_flags & LL_FILE_READAHEAD))
flags |= LDLM_FL_CBPENDING;
- matches = obd_match(ll_i2sbi(inode)->ll_osc_exp,
+ matches = obd_match(ll_i2sbi(inode)->ll_dt_exp,
ll_i2info(inode)->lli_smd, LDLM_EXTENT,
&page_extent, LCK_PR | LCK_PW, &flags, inode,
&match_lockh);
lov_stripe_lock(lsm);
inode_init_lvb(inode, &lvb);
- obd_merge_lvb(ll_i2obdexp(inode), lsm, &lvb, 1);
+ obd_merge_lvb(ll_i2dtexp(inode), lsm, &lvb, 1);
kms = lvb.lvb_size;
lov_stripe_unlock(lsm);
if (kms == 0) {
LASSERT(!PageDirty(page));
LASSERT(PageLocked(page));
- exp = ll_i2obdexp(inode);
+ exp = ll_i2dtexp(inode);
if (exp == NULL)
GOTO(out, rc = -EINVAL);
if (rc < 0)
GOTO(out, rc);
- exp = ll_i2obdexp(inode);
+ exp = ll_i2dtexp(inode);
if (exp == NULL)
GOTO(out, rc = -EINVAL);
else
lprocfs_counter_add(ll_i2sbi(inode)->ll_stats,
LPROC_LL_DIRECT_READ, iobuf->length);
- rc = obd_brw_async(rw, ll_i2obdexp(inode), &oa, lsm, iobuf->nr_pages,
+ rc = obd_brw_async(rw, ll_i2dtexp(inode), &oa, lsm, iobuf->nr_pages,
pga, set, NULL);
if (rc) {
CDEBUG(rc == -ENOSPC ? D_INODE : D_ERROR,
rc = iobuf->length;
if (rw == OBD_BRW_WRITE) {
lov_stripe_lock(lsm);
- obd_adjust_kms(ll_i2obdexp(inode), lsm, offset, 0);
+ obd_adjust_kms(ll_i2dtexp(inode), lsm, offset, 0);
lov_stripe_unlock(lsm);
}
}
lprocfs_counter_incr(sbi->ll_stats, LPROC_LL_RELEASE);
- err = ll_mdc_close(sbi->ll_mdc_exp, inode, filp);
+ err = ll_mdc_close(sbi->ll_md_exp, inode, filp);
if (err && rc == 0)
rc = err;
err = ll_local_open(filp, it, fd);
if (rc != 0) {
CERROR("error opening special file: rc %d\n", rc);
- ll_mdc_close(ll_i2sbi(inode)->ll_mdc_exp, inode, filp);
+ ll_mdc_close(ll_i2sbi(inode)->ll_md_exp, inode, filp);
} else if (err) {
if (pfop && *pfop && (*pfop)->release)
(*pfop)->release(inode, filp);
RETURN(0);
}
- rc = mdc_getattr(sbi->ll_mdc_exp, ll_inode2fid(inode),
+ rc = mdc_getattr(sbi->ll_md_exp, ll_inode2fid(inode),
OBD_MD_LINKNAME, symlen, request);
if (rc) {
if (rc != -ENOENT)
if (rc)
RETURN(rc);
- rc = mdc_setxattr(sbi->ll_mdc_exp, ll_inode2fid(inode), valid,
+ rc = mdc_setxattr(sbi->ll_md_exp, ll_inode2fid(inode), valid,
name, value, size, 0, flags, &req);
if (rc) {
if (rc == -EOPNOTSUPP && xattr_type == XATTR_USER_T) {
RETURN(rc);
do_getxattr:
- rc = mdc_getxattr(sbi->ll_mdc_exp, ll_inode2fid(inode), valid,
+ rc = mdc_getxattr(sbi->ll_md_exp, ll_inode2fid(inode), valid,
name, NULL, 0, size, &req);
if (rc) {
if (rc == -EOPNOTSUPP && xattr_type == XATTR_USER_T) {
RETURN(rc);
}
-static int lmv_close(struct obd_export *exp, struct mdc_op_data *op_data,
+static int lmv_close(struct obd_export *exp, struct md_op_data *op_data,
struct obd_client_handle *och,
struct ptlrpc_request **request)
{
return rc;
}
-int lmv_create(struct obd_export *exp, struct mdc_op_data *op_data,
+int lmv_create(struct obd_export *exp, struct md_op_data *op_data,
const void *data, int datalen, int mode, __u32 uid,
__u32 gid, __u64 rdev, struct ptlrpc_request **request)
{
static int
lmv_enqueue_slaves(struct obd_export *exp, int locktype,
struct lookup_intent *it, int lockmode,
- struct mdc_op_data *data, struct lustre_handle *lockh,
+ struct md_op_data *op_data, struct lustre_handle *lockh,
void *lmm, int lmmsize, ldlm_completion_callback cb_compl,
ldlm_blocking_callback cb_blocking, void *cb_data)
{
struct obd_device *obd = exp->exp_obd;
struct lmv_obd *lmv = &obd->u.lmv;
- struct mea *mea = data->mea1;
- struct mdc_op_data *data2;
+ struct mea *mea = op_data->mea1;
+ struct md_op_data *op_data2;
int i, rc, mds;
ENTRY;
- OBD_ALLOC(data2, sizeof(*data2));
- if (data2 == NULL)
+ OBD_ALLOC(op_data2, sizeof(*op_data2));
+ if (op_data2 == NULL)
RETURN(-ENOMEM);
LASSERT(mea != NULL);
for (i = 0; i < mea->mea_count; i++) {
- memset(data2, 0, sizeof(*data2));
- data2->fid1 = mea->mea_ids[i];
- mds = lmv_fld_lookup(obd, &data2->fid1);
+ memset(op_data2, 0, sizeof(*op_data2));
+ op_data2->fid1 = mea->mea_ids[i];
+ mds = lmv_fld_lookup(obd, &op_data2->fid1);
if (lmv->tgts[mds].ltd_exp == NULL)
continue;
rc = md_enqueue(lmv->tgts[mds].ltd_exp, locktype, it,
- lockmode, data2, lockh + i, lmm, lmmsize,
+ lockmode, op_data2, lockh + i, lmm, lmmsize,
cb_compl, cb_blocking, cb_data);
CDEBUG(D_OTHER, "take lock on slave "DFID3" -> %d/%d\n",
GOTO(cleanup, rc = LUSTRE_IT(it)->it_status);
}
- OBD_FREE(data2, sizeof(*data2));
+ OBD_FREE(op_data2, sizeof(*op_data2));
RETURN(0);
cleanup:
- OBD_FREE(data2, sizeof(*data2));
+ OBD_FREE(op_data2, sizeof(*op_data2));
/* drop all taken locks */
while (--i >= 0) {
static int
lmv_enqueue_remote(struct obd_export *exp, int lock_type,
struct lookup_intent *it, int lock_mode,
- struct mdc_op_data *data, struct lustre_handle *lockh,
+ struct md_op_data *op_data, struct lustre_handle *lockh,
void *lmm, int lmmsize, ldlm_completion_callback cb_compl,
ldlm_blocking_callback cb_blocking, void *cb_data)
{
struct obd_device *obd = exp->exp_obd;
struct lmv_obd *lmv = &obd->u.lmv;
struct lustre_handle plock;
- struct mdc_op_data rdata;
+ struct md_op_data rdata;
struct mdt_body *body = NULL;
int i, rc = 0, pmode;
ENTRY;
RETURN(0);
CDEBUG(D_OTHER, "ENQUEUE '%s' on "DFID3" -> "DFID3"\n",
- LL_IT2STR(it), PFID3(&data->fid1), PFID3(&body->fid1));
+ LL_IT2STR(it), PFID3(&op_data->fid1), PFID3(&body->fid1));
/* we got LOOKUP lock, but we really need attrs */
pmode = LUSTRE_IT(it)->it_lock_mode;
LUSTRE_IT(it)->it_data = NULL;
LASSERT((body->valid & OBD_MD_FID) != 0);
- memcpy(&rdata, data, sizeof(rdata));
+ memcpy(&rdata, op_data, sizeof(rdata));
rdata.fid1 = body->fid1;
rdata.name = NULL;
rdata.namelen = 0;
static int
lmv_enqueue(struct obd_export *exp, int lock_type,
struct lookup_intent *it, int lock_mode,
- struct mdc_op_data *data, struct lustre_handle *lockh,
+ struct md_op_data *op_data, struct lustre_handle *lockh,
void *lmm, int lmmsize, ldlm_completion_callback cb_compl,
ldlm_blocking_callback cb_blocking, void *cb_data)
{
if (rc)
RETURN(rc);
- if (data->mea1 && it->it_op == IT_UNLINK) {
+ if (op_data->mea1 && it->it_op == IT_UNLINK) {
rc = lmv_enqueue_slaves(exp, lock_type, it, lock_mode,
- data, lockh, lmm, lmmsize,
+ op_data, lockh, lmm, lmmsize,
cb_compl, cb_blocking, cb_data);
RETURN(rc);
}
- if (data->namelen) {
- obj = lmv_grab_obj(obd, &data->fid1);
+ if (op_data->namelen) {
+ obj = lmv_grab_obj(obd, &op_data->fid1);
if (obj) {
/* directory is splitted. look for right mds for this
* name */
mds = raw_name2idx(obj->lo_hashtype, obj->lo_objcount,
- (char *)data->name, data->namelen);
- data->fid1 = obj->lo_objs[mds].li_fid;
+ (char *)op_data->name, op_data->namelen);
+ op_data->fid1 = obj->lo_objs[mds].li_fid;
lmv_put_obj(obj);
}
}
CDEBUG(D_OTHER, "ENQUEUE '%s' on "DFID3"\n", LL_IT2STR(it),
- PFID3(&data->fid1));
+ PFID3(&op_data->fid1));
- mds = lmv_fld_lookup(obd, &data->fid1);
+ mds = lmv_fld_lookup(obd, &op_data->fid1);
rc = md_enqueue(lmv->tgts[mds].ltd_exp,
- lock_type, it, lock_mode, data, lockh, lmm,
+ lock_type, it, lock_mode, op_data, lockh, lmm,
lmmsize, cb_compl, cb_blocking, cb_data);
if (rc == 0 && it->it_op == IT_OPEN)
rc = lmv_enqueue_remote(exp, lock_type, it, lock_mode,
- data, lockh, lmm, lmmsize,
+ op_data, lockh, lmm, lmmsize,
cb_compl, cb_blocking, cb_data);
RETURN(rc);
}
}
/*
- * llite passes fid of an target inode in data->fid1 and id of directory in
- * data->fid2
+ * llite passes fid of an target inode in op_data->fid1 and id of directory in
+ * op_data->fid2
*/
-static int lmv_link(struct obd_export *exp, struct mdc_op_data *data,
+static int lmv_link(struct obd_export *exp, struct md_op_data *op_data,
struct ptlrpc_request **request)
{
struct obd_device *obd = exp->exp_obd;
if (rc)
RETURN(rc);
- if (data->namelen != 0) {
+ if (op_data->namelen != 0) {
/* usual link request */
- obj = lmv_grab_obj(obd, &data->fid2);
+ obj = lmv_grab_obj(obd, &op_data->fid2);
if (obj) {
rc = raw_name2idx(obj->lo_hashtype, obj->lo_objcount,
- data->name, data->namelen);
- data->fid2 = obj->lo_objs[rc].li_fid;
+ op_data->name, op_data->namelen);
+ op_data->fid2 = obj->lo_objs[rc].li_fid;
lmv_put_obj(obj);
}
- mds = lmv_fld_lookup(obd, &data->fid2);
+ mds = lmv_fld_lookup(obd, &op_data->fid2);
CDEBUG(D_OTHER,"link "DFID3":%*s to "DFID3"\n",
- PFID3(&data->fid2), data->namelen, data->name,
- PFID3(&data->fid1));
+ PFID3(&op_data->fid2), op_data->namelen,
+ op_data->name, PFID3(&op_data->fid1));
} else {
- mds = lmv_fld_lookup(obd, &data->fid1);
+ mds = lmv_fld_lookup(obd, &op_data->fid1);
/* request from MDS to acquire i_links for inode by fid1 */
CDEBUG(D_OTHER, "inc i_nlinks for "DFID3"\n",
- PFID3(&data->fid1));
+ PFID3(&op_data->fid1));
}
CDEBUG(D_OTHER, "forward to MDS #%u ("DFID3")\n",
- mds, PFID3(&data->fid1));
- rc = md_link(lmv->tgts[mds].ltd_exp, data, request);
+ mds, PFID3(&op_data->fid1));
+ rc = md_link(lmv->tgts[mds].ltd_exp, op_data, request);
RETURN(rc);
}
-static int lmv_rename(struct obd_export *exp, struct mdc_op_data *data,
+static int lmv_rename(struct obd_export *exp, struct md_op_data *op_data,
const char *old, int oldlen, const char *new, int newlen,
struct ptlrpc_request **request)
{
ENTRY;
CDEBUG(D_OTHER, "rename %*s in "DFID3" to %*s in "DFID3"\n",
- oldlen, old, PFID3(&data->fid1), newlen, new,
- PFID3(&data->fid2));
+ oldlen, old, PFID3(&op_data->fid1), newlen, new,
+ PFID3(&op_data->fid2));
rc = lmv_check_connect(obd);
if (rc)
CDEBUG(D_OTHER,
"create %*s(%d/%d) in "DFID3" pointing "
"to "DFID3"\n", newlen, new, oldlen, newlen,
- PFID3(&data->fid2), PFID3(&data->fid1));
+ PFID3(&op_data->fid2), PFID3(&op_data->fid1));
- mds = lmv_fld_lookup(obd, &data->fid2);
+ mds = lmv_fld_lookup(obd, &op_data->fid2);
/*
* target directory can be splitted, sowe should forward request
* to the right MDS.
*/
- obj = lmv_grab_obj(obd, &data->fid2);
+ obj = lmv_grab_obj(obd, &op_data->fid2);
if (obj) {
mds = raw_name2idx(obj->lo_hashtype, obj->lo_objcount,
(char *)new, newlen);
- data->fid2 = obj->lo_objs[mds].li_fid;
+ op_data->fid2 = obj->lo_objs[mds].li_fid;
CDEBUG(D_OTHER, "forward to MDS #%u ("DFID3")\n", mds,
- PFID3(&data->fid2));
+ PFID3(&op_data->fid2));
lmv_put_obj(obj);
}
goto request;
}
- obj = lmv_grab_obj(obd, &data->fid1);
+ obj = lmv_grab_obj(obd, &op_data->fid1);
if (obj) {
/*
* directory is already splitted, so we have to forward request
*/
mds = raw_name2idx(obj->lo_hashtype, obj->lo_objcount,
(char *)old, oldlen);
- data->fid1 = obj->lo_objs[mds].li_fid;
+ op_data->fid1 = obj->lo_objs[mds].li_fid;
CDEBUG(D_OTHER, "forward to MDS #%u ("DFID3")\n", mds,
- PFID3(&data->fid1));
+ PFID3(&op_data->fid1));
lmv_put_obj(obj);
}
- obj = lmv_grab_obj(obd, &data->fid2);
+ obj = lmv_grab_obj(obd, &op_data->fid2);
if (obj) {
/*
* directory is already splitted, so we have to forward request
mds = raw_name2idx(obj->lo_hashtype, obj->lo_objcount,
(char *)new, newlen);
- data->fid2 = obj->lo_objs[mds].li_fid;
+ op_data->fid2 = obj->lo_objs[mds].li_fid;
CDEBUG(D_OTHER, "forward to MDS #%u ("DFID3")\n", mds,
- PFID3(&data->fid2));
+ PFID3(&op_data->fid2));
lmv_put_obj(obj);
}
- mds = lmv_fld_lookup(obd, &data->fid1);
+ mds = lmv_fld_lookup(obd, &op_data->fid1);
request:
- if (mds != lmv_fld_lookup(obd, &data->fid2)) {
+ if (mds != lmv_fld_lookup(obd, &op_data->fid2)) {
CDEBUG(D_OTHER,"cross-node rename "DFID3"/%*s to "DFID3"/%*s\n",
- PFID3(&data->fid1), oldlen, old, PFID3(&data->fid2),
+ PFID3(&op_data->fid1), oldlen, old, PFID3(&op_data->fid2),
newlen, new);
}
- rc = md_rename(lmv->tgts[mds].ltd_exp, data, old, oldlen,
+ rc = md_rename(lmv->tgts[mds].ltd_exp, op_data, old, oldlen,
new, newlen, request);
RETURN(rc);
}
-static int lmv_setattr(struct obd_export *exp, struct mdc_op_data *data,
+static int lmv_setattr(struct obd_export *exp, struct md_op_data *op_data,
struct iattr *iattr, void *ea, int ealen, void *ea2,
int ea2len, void *ea3, int ea3len,
struct ptlrpc_request **request)
if (rc)
RETURN(rc);
- obj = lmv_grab_obj(obd, &data->fid1);
+ obj = lmv_grab_obj(obd, &op_data->fid1);
CDEBUG(D_OTHER, "SETATTR for "DFID3", valid 0x%x%s\n",
- PFID3(&data->fid1), iattr->ia_valid, obj ? ", splitted" : "");
+ PFID3(&op_data->fid1), iattr->ia_valid, obj ? ", splitted" : "");
if (obj) {
for (i = 0; i < obj->lo_objcount; i++) {
- data->fid1 = obj->lo_objs[i].li_fid;
+ op_data->fid1 = obj->lo_objs[i].li_fid;
- mds = lmv_fld_lookup(obd, &data->fid1);
+ mds = lmv_fld_lookup(obd, &op_data->fid1);
rc = md_setattr(lmv->tgts[mds].ltd_exp,
- data, iattr, ea, ealen, ea2, ea2len,
+ op_data, iattr, ea, ealen, ea2, ea2len,
ea3, ea3len, &req);
if (lu_fid_eq(&obj->lo_fid, &obj->lo_objs[i].li_fid)) {
}
lmv_put_obj(obj);
} else {
- mds = lmv_fld_lookup(obd, &data->fid1);
+ mds = lmv_fld_lookup(obd, &op_data->fid1);
LASSERT(mds < lmv->desc.ld_tgt_count);
rc = md_setattr(lmv->tgts[mds].ltd_exp,
- data, iattr, ea, ealen, ea2, ea2len, ea3,
+ op_data, iattr, ea, ealen, ea2, ea2len, ea3,
ea3len, request);
if (rc == 0) {
body = lustre_msg_buf((*request)->rq_repmsg, 0,
RETURN(rc);
}
-static int lmv_unlink_slaves(struct obd_export *exp, struct mdc_op_data *data,
+static int lmv_unlink_slaves(struct obd_export *exp, struct md_op_data *op_data,
struct ptlrpc_request **req)
{
struct obd_device *obd = exp->exp_obd;
struct lmv_obd *lmv = &obd->u.lmv;
- struct mea *mea = data->mea1;
- struct mdc_op_data *data2;
+ struct mea *mea = op_data->mea1;
+ struct md_op_data *op_data2;
int i, mds, rc = 0;
ENTRY;
- OBD_ALLOC(data2, sizeof(*data2));
- if (data2 == NULL)
+ OBD_ALLOC(op_data2, sizeof(*op_data2));
+ if (op_data2 == NULL)
RETURN(-ENOMEM);
LASSERT(mea != NULL);
for (i = 0; i < mea->mea_count; i++) {
- memset(data2, 0, sizeof(*data2));
- data2->fid1 = mea->mea_ids[i];
- data2->create_mode = MDS_MODE_DONT_LOCK | S_IFDIR;
+ memset(op_data2, 0, sizeof(*op_data2));
+ op_data2->fid1 = mea->mea_ids[i];
+ op_data2->create_mode = MDS_MODE_DONT_LOCK | S_IFDIR;
- mds = lmv_fld_lookup(obd, &data2->fid1);
+ mds = lmv_fld_lookup(obd, &op_data2->fid1);
if (lmv->tgts[mds].ltd_exp == NULL)
continue;
rc = md_unlink(lmv->tgts[mds].ltd_exp,
- data2, req);
+ op_data2, req);
CDEBUG(D_OTHER, "unlink slave "DFID3" -> %d\n",
PFID3(&mea->mea_ids[i]), rc);
if (rc)
RETURN(rc);
}
- OBD_FREE(data2, sizeof(*data2));
+ OBD_FREE(op_data2, sizeof(*op_data2));
RETURN(rc);
}
RETURN(0);
}
-static int lmv_unlink(struct obd_export *exp, struct mdc_op_data *data,
+static int lmv_unlink(struct obd_export *exp, struct md_op_data *op_data,
struct ptlrpc_request **request)
{
struct obd_device *obd = exp->exp_obd;
if (rc)
RETURN(rc);
- if (data->namelen == 0 && data->mea1 != NULL) {
+ if (op_data->namelen == 0 && op_data->mea1 != NULL) {
/* mds asks to remove slave objects */
- rc = lmv_unlink_slaves(exp, data, request);
+ rc = lmv_unlink_slaves(exp, op_data, request);
RETURN(rc);
}
- if (data->namelen != 0) {
+ if (op_data->namelen != 0) {
struct lmv_obj *obj;
- obj = lmv_grab_obj(obd, &data->fid1);
+ obj = lmv_grab_obj(obd, &op_data->fid1);
if (obj) {
i = raw_name2idx(obj->lo_hashtype, obj->lo_objcount,
- data->name, data->namelen);
- data->fid1 = obj->lo_objs[i].li_fid;
+ op_data->name, op_data->namelen);
+ op_data->fid1 = obj->lo_objs[i].li_fid;
lmv_put_obj(obj);
}
CDEBUG(D_OTHER, "unlink '%*s' in "DFID3" -> %u\n",
- data->namelen, data->name, PFID3(&data->fid1),
+ op_data->namelen, op_data->name, PFID3(&op_data->fid1),
i);
} else {
CDEBUG(D_OTHER, "drop i_nlink on "DFID3"\n",
- PFID3(&data->fid1));
+ PFID3(&op_data->fid1));
}
- i = lmv_fld_lookup(obd, &data->fid1);
- rc = md_unlink(lmv->tgts[i].ltd_exp, data, request);
+ i = lmv_fld_lookup(obd, &op_data->fid1);
+ rc = md_unlink(lmv->tgts[i].ltd_exp, op_data, request);
RETURN(rc);
}
void mdc_readdir_pack(struct ptlrpc_request *req, int pos, __u64 offset,
__u32 size, struct lu_fid *fid);
void mdc_getattr_pack(struct ptlrpc_request *req, int valid, int offset,
- int flags, struct mdc_op_data *data);
+ int flags, struct md_op_data *op_data);
void mdc_setattr_pack(struct ptlrpc_request *req, int offset,
- struct mdc_op_data *data,
+ struct md_op_data *op_data,
struct iattr *iattr, void *ea, int ealen,
void *ea2, int ea2len);
void mdc_create_pack(struct ptlrpc_request *req, int offset,
- struct mdc_op_data *op_data, const void *data, int datalen,
+ struct md_op_data *op_data, const void *data, int datalen,
__u32 mode, __u32 uid, __u32 gid, __u32 cap_effective,
__u64 rdev);
void mdc_open_pack(struct ptlrpc_request *req, int offset,
- struct mdc_op_data *op_data, __u32 mode, __u64 rdev,
+ struct md_op_data *op_data, __u32 mode, __u64 rdev,
__u32 flags, const void *data, int datalen);
void mdc_join_pack(struct ptlrpc_request *req, int offset,
- struct mdc_op_data *op_data, __u64 head_size);
+ struct md_op_data *op_data, __u64 head_size);
void mdc_unlink_pack(struct ptlrpc_request *req, int offset,
- struct mdc_op_data *data);
+ struct md_op_data *op_data);
void mdc_link_pack(struct ptlrpc_request *req, int offset,
- struct mdc_op_data *data);
+ struct md_op_data *op_data);
void mdc_rename_pack(struct ptlrpc_request *req, int offset,
- struct mdc_op_data *data,
+ struct md_op_data *op_data,
const char *old, int oldlen, const char *new, int newlen);
-void mdc_close_pack(struct ptlrpc_request *req, int offset, struct mdc_op_data *op_data,
+void mdc_close_pack(struct ptlrpc_request *req, int offset, struct md_op_data *op_data,
int valid, struct obd_client_handle *och);
struct mdc_open_data {
}
/* packing of MDS records */
void mdc_create_pack(struct ptlrpc_request *req, int offset,
- struct mdc_op_data *op_data, const void *data, int datalen,
+ struct md_op_data *op_data, const void *data, int datalen,
__u32 mode, __u32 uid, __u32 gid, __u32 cap_effective,
__u64 rdev)
{
/* packing of MDS records */
void mdc_join_pack(struct ptlrpc_request *req, int offset,
- struct mdc_op_data *op_data, __u64 head_size)
+ struct md_op_data *op_data, __u64 head_size)
{
struct mdt_rec_join *rec;
}
void mdc_open_pack(struct ptlrpc_request *req, int offset,
- struct mdc_op_data *op_data, __u32 mode, __u64 rdev,
+ struct md_op_data *op_data, __u32 mode, __u64 rdev,
__u32 flags, const void *lmm, int lmmlen)
{
struct mdt_rec_create *rec;
}
void mdc_setattr_pack(struct ptlrpc_request *req, int offset,
- struct mdc_op_data *data, struct iattr *iattr,
+ struct md_op_data *op_data, struct iattr *iattr,
void *ea, int ealen, void *ea2, int ea2len)
{
struct mdt_rec_setattr *rec = lustre_msg_buf(req->rq_reqmsg, offset,
rec->sa_fsuid = current->fsuid;
rec->sa_fsgid = current->fsgid;
rec->sa_cap = current->cap_effective;
- rec->sa_fid = data->fid1;
+ rec->sa_fid = op_data->fid1;
rec->sa_suppgid = -1;
if (iattr) {
if ((iattr->ia_valid & ATTR_GID) && in_group_p(iattr->ia_gid))
rec->sa_suppgid = iattr->ia_gid;
else
- rec->sa_suppgid = data->suppgids[0];
+ rec->sa_suppgid = op_data->suppgids[0];
}
if (ealen == 0)
}
void mdc_unlink_pack(struct ptlrpc_request *req, int offset,
- struct mdc_op_data *data)
+ struct md_op_data *op_data)
{
struct mdt_rec_unlink *rec;
char *tmp;
rec->ul_fsuid = current->fsuid;
rec->ul_fsgid = current->fsgid;
rec->ul_cap = current->cap_effective;
- rec->ul_mode = data->create_mode;
- rec->ul_suppgid = data->suppgids[0];
- rec->ul_fid1 = data->fid1;
- rec->ul_fid2 = data->fid2;
- rec->ul_time = data->mod_time;
+ rec->ul_mode = op_data->create_mode;
+ rec->ul_suppgid = op_data->suppgids[0];
+ rec->ul_fid1 = op_data->fid1;
+ rec->ul_fid2 = op_data->fid2;
+ rec->ul_time = op_data->mod_time;
- tmp = lustre_msg_buf(req->rq_reqmsg, offset + 1, data->namelen + 1);
+ tmp = lustre_msg_buf(req->rq_reqmsg, offset + 1, op_data->namelen + 1);
LASSERT (tmp != NULL);
- LOGL0(data->name, data->namelen, tmp);
+ LOGL0(op_data->name, op_data->namelen, tmp);
}
void mdc_link_pack(struct ptlrpc_request *req, int offset,
- struct mdc_op_data *data)
+ struct md_op_data *op_data)
{
struct mdt_rec_link *rec;
char *tmp;
rec->lk_fsuid = current->fsuid;
rec->lk_fsgid = current->fsgid;
rec->lk_cap = current->cap_effective;
- rec->lk_suppgid1 = data->suppgids[0];
- rec->lk_suppgid2 = data->suppgids[1];
- rec->lk_fid1 = data->fid1;
- rec->lk_fid2 = data->fid2;
- rec->lk_time = data->mod_time;
-
- tmp = lustre_msg_buf(req->rq_reqmsg, offset + 1, data->namelen + 1);
- LOGL0(data->name, data->namelen, tmp);
+ rec->lk_suppgid1 = op_data->suppgids[0];
+ rec->lk_suppgid2 = op_data->suppgids[1];
+ rec->lk_fid1 = op_data->fid1;
+ rec->lk_fid2 = op_data->fid2;
+ rec->lk_time = op_data->mod_time;
+
+ tmp = lustre_msg_buf(req->rq_reqmsg, offset + 1, op_data->namelen + 1);
+ LOGL0(op_data->name, op_data->namelen, tmp);
}
void mdc_rename_pack(struct ptlrpc_request *req, int offset,
- struct mdc_op_data *data,
+ struct md_op_data *op_data,
const char *old, int oldlen, const char *new, int newlen)
{
struct mdt_rec_rename *rec;
rec->rn_fsuid = current->fsuid;
rec->rn_fsgid = current->fsgid;
rec->rn_cap = current->cap_effective;
- rec->rn_suppgid1 = data->suppgids[0];
- rec->rn_suppgid2 = data->suppgids[1];
- rec->rn_fid1 = data->fid1;
- rec->rn_fid2 = data->fid2;
- rec->rn_time = data->mod_time;
+ rec->rn_suppgid1 = op_data->suppgids[0];
+ rec->rn_suppgid2 = op_data->suppgids[1];
+ rec->rn_fid1 = op_data->fid1;
+ rec->rn_fid2 = op_data->fid2;
+ rec->rn_time = op_data->mod_time;
tmp = lustre_msg_buf(req->rq_reqmsg, offset + 1, oldlen + 1);
LOGL0(old, oldlen, tmp);
}
void mdc_getattr_pack(struct ptlrpc_request *req, int offset, int valid,
- int flags, struct mdc_op_data *data)
+ int flags, struct md_op_data *op_data)
{
struct mdt_body *b;
b = lustre_msg_buf(req->rq_reqmsg, offset, sizeof (*b));
b->capability = current->cap_effective;
b->valid = valid;
b->flags = flags;
- b->suppgid = data->suppgids[0];
+ b->suppgid = op_data->suppgids[0];
- b->fid1 = data->fid1;
- if (data->name) {
+ b->fid1 = op_data->fid1;
+ if (op_data->name) {
char *tmp;
tmp = lustre_msg_buf(req->rq_reqmsg, offset + 1,
- data->namelen + 1);
- LOGL0(data->name, data->namelen, tmp);
+ op_data->namelen + 1);
+ LOGL0(op_data->name, op_data->namelen, tmp);
}
}
void mdc_close_pack(struct ptlrpc_request *req, int offset,
- struct mdc_op_data *op_data, int valid,
+ struct md_op_data *op_data, int valid,
struct obd_client_handle *och)
{
struct mdt_body *body;
int lock_type,
struct lookup_intent *it,
int lock_mode,
- struct mdc_op_data *data,
+ struct md_op_data *op_data,
struct lustre_handle *lockh,
void *lmm,
int lmmsize,
struct ptlrpc_request *req;
struct obd_device *obddev = class_exp2obd(exp);
struct ldlm_res_id res_id =
- { .name = {fid_seq(&data->fid1), fid_num(&data->fid1)} };
+ { .name = {fid_seq(&op_data->fid1), fid_num(&op_data->fid1)} };
ldlm_policy_data_t policy = { .l_inodebits = { MDS_INODELOCK_LOOKUP } };
struct ldlm_request *lockreq;
struct ldlm_intent *lit;
it->it_create_mode |= S_IFREG;
size[req_buffers++] = sizeof(struct mdt_rec_create);
- size[req_buffers++] = data->namelen + 1;
+ size[req_buffers++] = op_data->namelen + 1;
/* As an optimization, we allocate an RPC request buffer for
* at least a default-sized LOV EA even if we aren't sending
* one. We grow the whole request to the next power-of-two
req_buffers, size, NULL);
/* when joining file, cb_data and lmm args together
* indicate the head file size*/
- mdc_join_pack(req, req_buffers - 1, data,
+ mdc_join_pack(req, req_buffers - 1, op_data,
(head_size << 32) | tsize);
cb_data = NULL;
lmm = NULL;
lit->opc = (__u64)it->it_op;
/* pack the intended request */
- mdc_open_pack(req, MDS_REQ_INTENT_REC_OFF, data,
+ mdc_open_pack(req, MDS_REQ_INTENT_REC_OFF, op_data,
it->it_create_mode, 0,
it->it_flags, lmm, lmmsize);
repsize[repbufcnt++] = LUSTRE_POSIX_ACL_MAX_SIZE;
} else if (it->it_op & IT_UNLINK) {
size[req_buffers++] = sizeof(struct mdt_rec_unlink);
- size[req_buffers++] = data->namelen + 1;
+ size[req_buffers++] = op_data->namelen + 1;
policy.l_inodebits.bits = MDS_INODELOCK_UPDATE;
req = ptlrpc_prep_req(class_exp2cliimp(exp), LUSTRE_DLM_VERSION,
LDLM_ENQUEUE, req_buffers, size, NULL);
lit->opc = (__u64)it->it_op;
/* pack the intended request */
- mdc_unlink_pack(req, MDS_REQ_INTENT_REC_OFF, data);
+ mdc_unlink_pack(req, MDS_REQ_INTENT_REC_OFF, op_data);
/* get ready for the reply */
repsize[repbufcnt++] = obddev->u.cli.cl_max_mds_cookiesize;
} else if (it->it_op & (IT_GETATTR | IT_LOOKUP)) {
obd_valid valid = OBD_MD_FLGETATTR | OBD_MD_FLEASIZE |
OBD_MD_FLACL | OBD_MD_FLMODEASIZE;
size[req_buffers++] = sizeof(struct mdt_body);
- size[req_buffers++] = data->namelen + 1;
+ size[req_buffers++] = op_data->namelen + 1;
if (it->it_op & IT_GETATTR)
policy.l_inodebits.bits = MDS_INODELOCK_UPDATE;
/* pack the intended request */
mdc_getattr_pack(req, MDS_REQ_INTENT_REC_OFF, valid,
- it->it_flags, data);
+ it->it_flags, op_data);
/* get ready for the reply */
repsize[repbufcnt++] = LUSTRE_POSIX_ACL_MAX_SIZE;
} else if (it->it_op == IT_READDIR) {
* Else, if DISP_LOOKUP_EXECD then d.lustre.it_status is the rc of the
* child lookup.
*/
-int mdc_intent_lock(struct obd_export *exp, struct mdc_op_data *op_data,
+int mdc_intent_lock(struct obd_export *exp, struct md_op_data *op_data,
void *lmm, int lmmsize, struct lookup_intent *it,
int lookup_flags, struct ptlrpc_request **reqp,
ldlm_blocking_callback cb_blocking, int extra_lock_flags)
* If it is called with iattr->ia_valid & ATTR_FROM_OPEN, then it is a
* magic open-path setattr that should take the setattr semaphore and
* go to the setattr portal. */
-int mdc_setattr(struct obd_export *exp, struct mdc_op_data *data,
+int mdc_setattr(struct obd_export *exp, struct md_op_data *op_data,
struct iattr *iattr, void *ea, int ealen, void *ea2, int ea2len,
struct ptlrpc_request **request)
{
if (iattr->ia_valid & (ATTR_MTIME | ATTR_CTIME))
CDEBUG(D_INODE, "setting mtime %lu, ctime %lu\n",
LTIME_S(iattr->ia_mtime), LTIME_S(iattr->ia_ctime));
- mdc_setattr_pack(req, MDS_REQ_REC_OFF, data, iattr, ea, ealen, ea2, ea2len);
+ mdc_setattr_pack(req, MDS_REQ_REC_OFF, op_data, iattr, ea, ealen, ea2, ea2len);
size[0] = sizeof(struct mdt_body);
req->rq_replen = lustre_msg_size(1, size);
RETURN(rc);
}
-int mdc_create(struct obd_export *exp, struct mdc_op_data *op_data,
+int mdc_create(struct obd_export *exp, struct md_op_data *op_data,
const void *data, int datalen, int mode, __u32 uid, __u32 gid,
__u32 cap_effective, __u64 rdev, struct ptlrpc_request **request)
{
RETURN(rc);
}
-int mdc_unlink(struct obd_export *exp, struct mdc_op_data *data,
+int mdc_unlink(struct obd_export *exp, struct md_op_data *op_data,
struct ptlrpc_request **request)
{
struct obd_device *obd = class_exp2obd(exp);
struct ptlrpc_request *req = *request;
- int rc, size[] = { sizeof(struct mdt_rec_unlink), data->namelen + 1};
+ int rc, size[] = { sizeof(struct mdt_rec_unlink), op_data->namelen + 1};
ENTRY;
LASSERT(req == NULL);
size[2] = obd->u.cli.cl_max_mds_cookiesize;
req->rq_replen = lustre_msg_size(3, size);
- mdc_unlink_pack(req, MDS_REQ_REC_OFF, data);
+ mdc_unlink_pack(req, MDS_REQ_REC_OFF, op_data);
rc = mdc_reint(req, obd->u.cli.cl_rpc_lock, LUSTRE_IMP_FULL);
if (rc == -ERESTARTSYS)
RETURN(rc);
}
-int mdc_link(struct obd_export *exp, struct mdc_op_data *data,
+int mdc_link(struct obd_export *exp, struct md_op_data *op_data,
struct ptlrpc_request **request)
{
struct obd_device *obd = exp->exp_obd;
struct ptlrpc_request *req;
- int rc, size[] = { sizeof(struct mdt_rec_link), data->namelen + 1};
+ int rc, size[] = { sizeof(struct mdt_rec_link), op_data->namelen + 1};
ENTRY;
req = ptlrpc_prep_req(class_exp2cliimp(exp), LUSTRE_MDS_VERSION,
if (req == NULL)
RETURN(-ENOMEM);
- mdc_link_pack(req, MDS_REQ_REC_OFF, data);
+ mdc_link_pack(req, MDS_REQ_REC_OFF, op_data);
size[0] = sizeof(struct mdt_body);
req->rq_replen = lustre_msg_size(1, size);
RETURN(rc);
}
-int mdc_rename(struct obd_export *exp, struct mdc_op_data *data,
+int mdc_rename(struct obd_export *exp, struct md_op_data *op_data,
const char *old, int oldlen, const char *new, int newlen,
struct ptlrpc_request **request)
{
if (req == NULL)
RETURN(-ENOMEM);
- mdc_rename_pack(req, MDS_REQ_REC_OFF, data, old, oldlen, new, newlen);
+ mdc_rename_pack(req, MDS_REQ_REC_OFF, op_data, old, oldlen, new, newlen);
size[0] = sizeof(struct mdt_body);
size[1] = obd->u.cli.cl_max_mds_easize;
spin_unlock(&open_req->rq_lock);
}
-int mdc_close(struct obd_export *exp, struct mdc_op_data *op_data,
+int mdc_close(struct obd_export *exp, struct md_op_data *op_data,
struct obd_client_handle *och, struct ptlrpc_request **request)
{
struct obd_device *obd = class_exp2obd(exp);
return rc;
}
-int mdc_done_writing(struct obd_export *exp, struct mdc_op_data *op_data)
+int mdc_done_writing(struct obd_export *exp, struct md_op_data *op_data)
{
struct ptlrpc_request *req;
struct mdt_body *body;
git://git.whamcloud.com / fs / lustre-release.git / commitdiff