(2) make some interface parameter const.
}
static int cml_attr_set(const struct lu_context *ctx, struct md_object *mo,
- struct lu_attr *attr)
+ const struct lu_attr *attr)
{
int rc;
ENTRY;
}
static int cml_xattr_set(const struct lu_context *ctx, struct md_object *mo,
- void *buf, int buflen, const char *name)
+ const void *buf, int buflen, const char *name)
{
int rc;
ENTRY;
}
static int cmr_attr_set(const struct lu_context *ctx, struct md_object *mo,
- struct lu_attr *attr)
+ const struct lu_attr *attr)
{
RETURN(-EFAULT);
}
}
static int cmr_xattr_set(const struct lu_context *ctx, struct md_object *mo,
- void *buf, int buflen, const char *name)
+ const void *buf, int buflen, const char *name)
{
RETURN(-EFAULT);
}
*/
int (*do_attr_set)(const struct lu_context *ctxt,
struct dt_object *dt,
- struct lu_attr *attr, struct thandle *handle);
+ const struct lu_attr *attr,
+ struct thandle *handle);
/*
* Return a value of an extended attribute.
*
* precondition: lu_object_exists(ctxt, &dt->do_lu);
*/
int (*do_xattr_set)(const struct lu_context *ctxt,
- struct dt_object *dt, void *buf, int buf_len,
+ struct dt_object *dt,
+ const void *buf, int buf_len,
const char *name, struct thandle *handle);
/*
* Create new object on this device.
__u32 la_flags; /* object flags */
__u32 la_nlink; /* number of persistent references to this
* object */
+#ifdef MDT_CODE
+ __u32 la_rdev; /* real device */
+ __u64 la_valid; /* real device */
+#endif
};
__u32 sa_uid;
__u32 sa_gid;
__u32 sa_attr_flags;
- __u32 sa_padding; /* also fix lustre_swab_mds_rec_setattr */
+ __u32 sa_padding; /* also fix lustre_swab_mdt_rec_setattr */
};
extern void lustre_swab_mdt_rec_setattr (struct mdt_rec_setattr *sa);
extern const struct req_format RQF_MDS_REINT_CREATE;
extern const struct req_format RQF_MDS_REINT_OPEN;
extern const struct req_format RQF_MDS_REINT_UNLINK;
+extern const struct req_format RQF_MDS_REINT_LINK;
+extern const struct req_format RQF_MDS_REINT_RENAME;
extern const struct req_format RQF_MDS_REINT_SETATTR;
extern const struct req_format RQF_LDLM_ENQUEUE;
extern const struct req_format RQF_LDLM_INTENT;
int (*moo_attr_get)(const struct lu_context *ctxt, struct md_object *dt,
struct lu_attr *attr);
int (*moo_attr_set)(const struct lu_context *ctxt, struct md_object *dt,
- struct lu_attr *attr);
+ const struct lu_attr *attr);
int (*moo_xattr_get)(const struct lu_context *ctxt,
struct md_object *obj,
void *buf, int buf_len, const char *name);
int (*moo_xattr_set)(const struct lu_context *ctxt,
- struct md_object *obj,
- void *buf, int buf_len, const char *name);
+ struct md_object *obj, const void *buf,
+ int buf_len, const char *name);
/* part of cross-ref operation */
int (*moo_object_create)(const struct lu_context *,
struct md_object *, struct lu_attr *);
}
static inline int mo_attr_set(const struct lu_context *cx, struct md_object *m,
- struct lu_attr *at)
+ const struct lu_attr *at)
{
LASSERT(m->mo_ops->moo_attr_set);
return m->mo_ops->moo_attr_set(cx, m, at);
}
static inline int mo_xattr_set(const struct lu_context *cx,
- struct md_object *m,
- void *buf, int buf_len, const char *name)
+ struct md_object *m, const void *buf,
+ int buf_len, const char *name)
{
LASSERT(m->mo_ops->moo_xattr_set);
return m->mo_ops->moo_xattr_set(cx, m, buf, buf_len, name);
static int
__mdd_attr_set(const struct lu_context *ctxt, struct md_object *obj,
- struct lu_attr *attr, struct thandle *handle)
+ const struct lu_attr *attr, struct thandle *handle)
{
struct dt_object *next;
static int
mdd_attr_set(const struct lu_context *ctxt,
- struct md_object *obj, struct lu_attr *attr)
+ struct md_object *obj, const struct lu_attr *attr)
{
struct mdd_device *mdd = mdo2mdd(obj);
struct thandle *handle;
static int
__mdd_xattr_set(const struct lu_context *ctxt, struct mdd_device *mdd,
- struct mdd_object *obj, void *buf,
+ struct mdd_object *obj, const void *buf,
int buf_len, const char *name, struct thandle *handle)
{
struct dt_object *next;
}
static int
-mdd_xattr_set(const struct lu_context *ctxt, struct md_object *obj, void *buf,
+mdd_xattr_set(const struct lu_context *ctxt, struct md_object *obj, const void *buf,
int buf_len, const char *name)
{
struct mdd_device *mdd = mdo2mdd(obj);
}
} else if (S_ISLNK(la->la_mode) && (body->valid & OBD_MD_LINKNAME)) {
/* It also uese the mdt_md to hold symname */
- CERROR("DDDDDDDDDDDDDDDDDD rc = %d\n", rc);
int len = min_t(int, la->la_size + 1, body->eadatasize);
req_capsule_set_size(pill, &RMF_MDT_MD, RCL_SERVER, len);
}
RETURN(rc);
}
- repbody = req_capsule_server_get(&info->mti_pill,
- &RMF_MDT_BODY);
+ repbody = req_capsule_server_get(&info->mti_pill, &RMF_MDT_BODY);
mdt_pack_attr2body(repbody, la);
repbody->fid1 = *mdt_object_fid(info->mti_object);
repbody->valid |= OBD_MD_FLID;
#ifdef MDT_CODE
- buffer = req_capsule_server_get(&info->mti_pill,
- &RMF_MDT_MD);
- length = req_capsule_get_size(&info->mti_pill,
- &RMF_MDT_MD,
+ buffer = req_capsule_server_get(&info->mti_pill, &RMF_MDT_MD);
+ length = req_capsule_get_size(&info->mti_pill, &RMF_MDT_MD,
RCL_SERVER);
if ((S_ISREG(la->la_mode) && (reqbody->valid & OBD_MD_FLEASIZE)) ||
repbody->valid |= OBD_MD_LINKNAME;
repbody->eadatasize = rc + 1;
((char*)buffer)[rc] = 0; /* NULL terminate */
- CDEBUG(S_MDS, "read symlink dest %s\n", (char*)buffer);
+ CDEBUG(D_INODE, "read symlink dest %s\n", (char*)buffer);
}
}
return container_of0(d, struct mdt_device, mdt_md_dev.md_lu_dev);
}
-struct ptlrpc_request *mdt_info_req(struct mdt_thread_info *info)
-{
- return info->mti_pill.rc_req;
-}
-
static int mdt_connect(struct mdt_thread_info *info)
{
int result;
static const struct req_format *reint_fmts[REINT_MAX] = {
[REINT_SETATTR] = &RQF_MDS_REINT_SETATTR,
[REINT_CREATE] = &RQF_MDS_REINT_CREATE,
- [REINT_LINK] = NULL, /* XXX not yet */
+ [REINT_LINK] = &RQF_MDS_REINT_LINK,
[REINT_UNLINK] = &RQF_MDS_REINT_UNLINK,
- [REINT_RENAME] = NULL, /* XXX not yet */
- [REINT_OPEN] = &RQF_MDS_REINT_OPEN /* XXX Huang hua */
+ [REINT_RENAME] = &RQF_MDS_REINT_RENAME,
+ [REINT_OPEN] = &RQF_MDS_REINT_OPEN
};
ENTRY;
return -EOPNOTSUPP;
}
-static int mdt_sync(struct mdt_thread_info *info)
-{
- return -EOPNOTSUPP;
-}
-
#ifdef MDT_CODE
static int mdt_device_sync(struct mdt_device *mdt)
{
}
RETURN(rc);
}
+#else
+static int mdt_sync(struct mdt_thread_info *info)
+{
+ return -EOPNOTSUPP;
+}
#endif
ldlm_policy_data_t *policy)
{
struct ldlm_res_id res_id;
- int flags = 0, rc;
+ int flags = 0;
+ int rc;
ENTRY;
LASSERT(ns != NULL);
LDLM_IBITS, policy, mode, &flags,
ldlm_blocking_ast, ldlm_completion_ast, NULL,
NULL, NULL, 0, NULL, lh);
- RETURN (rc == ELDLM_OK ? 0 : -EIO);
+ RETURN(rc == ELDLM_OK ? 0 : -EIO);
}
void fid_unlock(struct ldlm_namespace *ns, const struct lu_fid *f,
}
if (result == 0 && flags & HABEO_CLAVIS) {
- struct ldlm_request *dlm;
+ struct ldlm_request *dlm_req;
LASSERT(h->mh_fmt != NULL);
- dlm = req_capsule_client_get(&info->mti_pill, &RMF_DLM_REQ);
- if (dlm != NULL) {
+ dlm_req = req_capsule_client_get(&info->mti_pill, &RMF_DLM_REQ);
+ if (dlm_req != NULL) {
if (info->mti_mdt->mdt_flags & MDT_CL_COMPAT_RESNAME)
result = mdt_lock_resname_compat(info->mti_mdt,
- dlm);
- info->mti_dlm_req = dlm;
+ dlm_req);
+ info->mti_dlm_req = dlm_req;
} else {
CERROR("Can't unpack dlm request\n");
result = -EFAULT;
if (result == 0 && flags & HABEO_CLAVIS &&
info->mti_mdt->mdt_flags & MDT_CL_COMPAT_RESNAME) {
- struct ldlm_reply *rep;
+ struct ldlm_reply *dlm_rep;
- rep = lustre_msg_buf(req->rq_repmsg, 0, sizeof *rep);
- if (rep != NULL)
- result = mdt_lock_reply_compat(info->mti_mdt, rep);
+ dlm_rep = req_capsule_server_get(&info->mti_pill, &RMF_DLM_REP);
+ if (dlm_rep != NULL)
+ result = mdt_lock_reply_compat(info->mti_mdt, dlm_rep);
}
/* If we're DISCONNECTing, the mds_export_data is already freed */
} mdt_it_flavor[] = {
[MDT_IT_OPEN] = {
.it_fmt = &RQF_LDLM_INTENT,
- .it_flags = HABEO_REFERO,
+ /*.it_flags = HABEO_REFERO,*/
+ .it_flags = 0,
.it_act = mdt_intent_reint,
.it_reint = REINT_OPEN
},
[MDT_IT_OCREAT] = {
.it_fmt = &RQF_LDLM_INTENT,
- .it_flags = HABEO_REFERO,
+ .it_flags = 0,
.it_act = mdt_intent_reint,
.it_reint = REINT_OPEN
},
[MDT_IT_CREATE] = {
.it_fmt = &RQF_LDLM_INTENT,
- .it_flags = HABEO_REFERO,
+ .it_flags = 0,
.it_act = mdt_intent_reint,
.it_reint = REINT_CREATE
},
[MDT_IT_GETATTR] = {
.it_fmt = &RQF_LDLM_INTENT_GETATTR,
- .it_flags = HABEO_CORPUS,
+ .it_flags = 0,
.it_act = mdt_intent_getattr
},
[MDT_IT_READDIR] = {
.it_fmt = NULL,
- .it_flags = HABEO_REFERO,
+ .it_flags = 0,
.it_act = NULL
},
[MDT_IT_LOOKUP] = {
.it_fmt = &RQF_LDLM_INTENT_GETATTR,
- .it_flags = HABEO_CORPUS,
+ .it_flags = 0,
.it_act = mdt_intent_getattr
},
[MDT_IT_UNLINK] = {
.it_fmt = &RQF_LDLM_INTENT_UNLINK,
- .it_flags = HABEO_REFERO,
+ .it_flags = 0,
.it_act = NULL, /* XXX can be mdt_intent_reint, ? */
.it_reint = REINT_UNLINK
},
[MDT_IT_TRUNC] = {
.it_fmt = NULL,
- .it_flags = HABEO_REFERO,
+ .it_flags = 0,
.it_act = NULL
},
[MDT_IT_GETXATTR] = {
.it_fmt = NULL,
- .it_flags = HABEO_REFERO,
+ .it_flags = 0,
.it_act = NULL
}
};
struct ldlm_lock **lockp,
int flags)
{
- __u64 child_bits;
+ __u64 child_bits;
struct ldlm_lock *old_lock = *lockp;
struct ldlm_lock *new_lock = NULL;
struct ptlrpc_request *req = mdt_info_req(info);
struct ldlm_reply *ldlm_rep;
struct mdt_lock_handle lhc = {{0}};
- int rc;
+ int rc;
ENTRY;
struct mdt_reint_record {
mdt_reint_t rr_opcode;
const struct lu_fid *rr_fid1;
- struct lu_fid *rr_fid2;
+ const struct lu_fid *rr_fid2;
const char *rr_name;
const char *rr_tgt;
- __u32 rr_flags;
+ int rr_eadatalen;
+ const void *rr_eadata;
+ int rr_logcookielen;
+ const struct llog_cookie *rr_logcookies;
+
};
struct mdt_reint_reply {
int mdt_reint_rec(struct mdt_thread_info *);
void mdt_pack_attr2body(struct mdt_body *b, struct lu_attr *attr);
const struct lu_fid *mdt_object_fid(struct mdt_object *o);
-struct ptlrpc_request *mdt_info_req (struct mdt_thread_info *info);
+static inline struct ptlrpc_request *mdt_info_req (struct mdt_thread_info *info)
+{
+ return info->mti_pill.rc_req;
+}
int mdt_getxattr(struct mdt_thread_info *info);
int mdt_setxattr(struct mdt_thread_info *info);
/* unpacking */
static int mdt_setattr_unpack(struct mdt_thread_info *info)
{
+#ifdef MDT_CODE
+ struct mdt_rec_setattr *rec;
+ struct lu_attr *attr = &info->mti_attr;
+ struct mdt_reint_record *rr = &info->mti_rr;
+ struct req_capsule *pill = &info->mti_pill;
+ ENTRY;
+
+ rec = req_capsule_client_get(pill, &RMF_REC_SETATTR);
+
+ if (rec == NULL)
+ RETURN (-EFAULT);
+
+ rr->rr_fid1 = &rec->sa_fid;
+ attr->la_valid = rec->sa_valid;
+ attr->la_mode = rec->sa_mode;
+ attr->la_uid = rec->sa_uid;
+ attr->la_gid = rec->sa_gid;
+ attr->la_size = rec->sa_size;
+ attr->la_flags = rec->sa_attr_flags;
+ attr->la_ctime = rec->sa_ctime;
+ attr->la_atime = rec->sa_atime;
+ attr->la_mtime = rec->sa_mtime;
+
+ if (req_capsule_field_present(pill, &RMF_EADATA)) {
+ rr->rr_eadata = req_capsule_client_get(pill, &RMF_EADATA);
+ rr->rr_eadatalen = req_capsule_get_size(pill,
+ &RMF_EADATA,
+ RCL_CLIENT);
+ }
+ if (req_capsule_field_present(pill, &RMF_LOGCOOKIES)) {
+ rr->rr_logcookies = req_capsule_client_get(pill,
+ &RMF_LOGCOOKIES);
+ rr->rr_logcookielen = req_capsule_get_size(pill,
+ &RMF_LOGCOOKIES,
+ RCL_CLIENT);
+ }
+
+ RETURN(0);
+#endif
ENTRY;
RETURN(-EOPNOTSUPP);
}
struct lu_attr *attr = &info->mti_attr;
struct mdt_reint_record *rr = &info->mti_rr;
struct req_capsule *pill = &info->mti_pill;
- int result;
+ int result = 0;
ENTRY;
rec = req_capsule_client_get(pill, &RMF_REC_CREATE);
rr->rr_fid1 = &rec->cr_fid1;
rr->rr_fid2 = &rec->cr_fid2;
attr->la_mode = rec->cr_mode;
-
rr->rr_name = req_capsule_client_get(pill, &RMF_NAME);
- result = 0;
+#ifdef MDT_CODE
+ attr->la_rdev = rec->cr_rdev;
+ attr->la_uid = rec->cr_fsuid;
+ attr->la_gid = rec->cr_fsgid;
+ attr->la_flags = rec->cr_flags;
+ attr->la_ctime = rec->cr_time;
+ if (req_capsule_field_present(pill, &RMF_SYMTGT))
+ rr->rr_tgt = req_capsule_client_get(pill, &RMF_SYMTGT);
+#endif
} else
result = -EFAULT;
RETURN(result);
static int mdt_link_unpack(struct mdt_thread_info *info)
{
+#ifdef MDT_CODE
+ struct mdt_rec_link *rec;
+ struct lu_attr *attr = &info->mti_attr;
+ struct mdt_reint_record *rr = &info->mti_rr;
+ struct req_capsule *pill = &info->mti_pill;
+ ENTRY;
+
+ rec = req_capsule_client_get(pill, &RMF_REC_LINK);
+ if (rec == NULL)
+ RETURN (-EFAULT);
+
+ 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;
+
+ rr->rr_name = req_capsule_client_get(pill, &RMF_NAME);
+ if (rr->rr_name == NULL)
+ RETURN (-EFAULT);
+ RETURN(0);
+#endif
ENTRY;
RETURN(-EOPNOTSUPP);
}
static int mdt_unlink_unpack(struct mdt_thread_info *info)
{
+#ifdef MDT_CODE
+ struct mdt_rec_unlink *rec;
+ struct lu_attr *attr = &info->mti_attr;
+ struct mdt_reint_record *rr = &info->mti_rr;
+ struct req_capsule *pill = &info->mti_pill;
+ ENTRY;
+
+ rec = req_capsule_client_get(pill, &RMF_REC_UNLINK);
+ if (rec == NULL)
+ RETURN (-EFAULT);
+
+ attr->la_uid = rec->ul_fsuid;
+ attr->la_gid = rec->ul_fsgid;
+ rr->rr_fid1 = &rec->ul_fid1;
+ rr->rr_fid2 = &rec->ul_fid2;
+ attr->la_ctime = rec->ul_time;
+ attr->la_mode = rec->ul_mode;
+
+ rr->rr_name = req_capsule_client_get(pill, &RMF_NAME);
+ if (rr->rr_name == NULL)
+ RETURN (-EFAULT);
+ RETURN(0);
+#endif
ENTRY;
RETURN(-EOPNOTSUPP);
}
static int mdt_rename_unpack(struct mdt_thread_info *info)
{
+#ifdef MDT_CODE
+ struct mdt_rec_rename *rec;
+ struct lu_attr *attr = &info->mti_attr;
+ struct mdt_reint_record *rr = &info->mti_rr;
+ struct req_capsule *pill = &info->mti_pill;
+ ENTRY;
+
+ rec = req_capsule_client_get(pill, &RMF_REC_RENAME);
+ if (rec == NULL)
+ RETURN (-EFAULT);
+
+ 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;
+
+ rr->rr_name = req_capsule_client_get(pill, &RMF_NAME);
+ if (rr->rr_name == NULL)
+ RETURN (-EFAULT);
+ rr->rr_tgt = req_capsule_client_get(pill, &RMF_SYMTGT);
+ if (rr->rr_tgt == NULL)
+ RETURN (-EFAULT);
+ RETURN(0);
+#endif
+
ENTRY;
RETURN(-EOPNOTSUPP);
}
rr->rr_fid1 = &rec->cr_fid1;
rr->rr_fid2 = &rec->cr_fid2;
attr->la_mode = rec->cr_mode;
- rr->rr_flags = rec->cr_flags;
+ attr->la_flags = rec->cr_flags;
rr->rr_name = req_capsule_client_get(pill, &RMF_NAME);
if (rr->rr_name == NULL)
static int mdt_reint_setattr(struct mdt_thread_info *info)
{
+#ifdef MDT_CODE
+ struct lu_attr *attr = &info->mti_attr;
+ struct mdt_reint_record *rr = &info->mti_rr;
+ struct req_capsule *pill = &info->mti_pill;
+ struct ptlrpc_request *req = mdt_info_req(info);
+ struct mdt_object *mo;
+ struct mdt_lock_handle *lh;
+ struct lu_attr tmp_attr;
+ struct mdt_body *repbody;
+ int rc;
+ int locked = 0;
+
+ ENTRY;
+
+ DEBUG_REQ(D_INODE, req, "setattr "DFID3" %x", PFID3(rr->rr_fid1),
+ (unsigned int)attr->la_valid);
+
+ /* MDS_CHECK_RESENT */
+
+ rc = req_capsule_pack(pill);
+ if (rc)
+ RETURN(rc);
+
+ if (req->rq_export->exp_connect_flags & OBD_CONNECT_RDONLY)
+ RETURN(-EROFS);
+
+ if (attr->la_valid & ATTR_FROM_OPEN) {
+ mo = mdt_object_find(info->mti_ctxt, info->mti_mdt, rr->rr_fid1);
+ if (IS_ERR(mo))
+ RETURN(rc = PTR_ERR(mo));
+ } else {
+ __u64 lockpart = MDS_INODELOCK_UPDATE;
+ if (attr->la_valid & (ATTR_MODE|ATTR_UID|ATTR_GID))
+ lockpart |= MDS_INODELOCK_LOOKUP;
+
+ lh = &info->mti_lh[MDT_LH_PARENT];
+ lh->mlh_mode = LCK_EX;
+
+ mo = mdt_object_find_lock(info->mti_ctxt, info->mti_mdt,
+ rr->rr_fid1, lh, lockpart);
+
+ if (IS_ERR(mo))
+ RETURN(rc = PTR_ERR(mo));
+ locked = 1;
+ }
+
+ LASSERT(lu_object_exists(info->mti_ctxt, &mo->mot_obj.mo_lu));
+
+ rc = mo_attr_set(info->mti_ctxt, mdt_object_child(mo), attr);
+ if (rc != 0)
+ GOTO(out_unlock, rc);
+
+ rc = mo_attr_get(info->mti_ctxt, mdt_object_child(mo), &tmp_attr);
+ if (rc != 0)
+ GOTO(out_unlock, rc);
+
+ repbody = req_capsule_server_get(&info->mti_pill, &RMF_MDT_BODY);
+ mdt_pack_attr2body(repbody, &tmp_attr);
+ repbody->fid1 = *mdt_object_fid(mo);
+ repbody->valid |= OBD_MD_FLID;
+
+ /* don't return OST-specific attributes if we didn't just set them. */
+ if (attr->la_valid & ATTR_SIZE)
+ repbody->valid |= OBD_MD_FLSIZE | OBD_MD_FLBLOCKS;
+ if (attr->la_valid & (ATTR_MTIME | ATTR_MTIME_SET))
+ repbody->valid |= OBD_MD_FLMTIME;
+ if (attr->la_valid & (ATTR_ATIME | ATTR_ATIME_SET))
+ repbody->valid |= OBD_MD_FLATIME;
+
+ rc = mo_xattr_set(info->mti_ctxt, mdt_object_child(mo),
+ rr->rr_eadata, rr->rr_eadatalen, "lov");
+ if (rc)
+ GOTO(out_unlock, rc);
+
+ /* FIXME Please deal with logcookies here*/
+
+out_unlock:
+ if (locked) {
+ mdt_object_unlock(info->mti_mdt->mdt_namespace, mo, lh);
+ }
+ mdt_object_put(info->mti_ctxt, mo);
+ RETURN(rc);
+#endif
ENTRY;
RETURN(-EOPNOTSUPP);
}
struct mdt_body *body = info->mti_reint_rep.mrr_body;
struct lov_mds_md *lmm = info->mti_reint_rep.mrr_md;
int created = 0;
+ struct lu_fid child_fid;
ENTRY;
lh = &info->mti_lh[MDT_LH_PARENT];
lh->mlh_mode = LCK_PW;
+ req_capsule_pack(&info->mti_pill);
ldlm_rep = req_capsule_server_get(&info->mti_pill, &RMF_DLM_REP);
parent = mdt_object_find_lock(info->mti_ctxt,
RETURN(PTR_ERR(parent));
result = mdo_lookup(info->mti_ctxt, mdt_object_child(parent),
- info->mti_rr.rr_name, info->mti_rr.rr_fid2);
+ info->mti_rr.rr_name, &child_fid);
if (result && result != -ENOENT) {
GOTO(out_parent, result);
}
intent_set_disposition(ldlm_rep, DISP_LOOKUP_POS);
if (result == -ENOENT) {
- if(!(info->mti_rr.rr_flags & MDS_OPEN_CREAT))
+ if(!(info->mti_attr.la_flags & MDS_OPEN_CREAT))
GOTO(out_parent, result);
if (req->rq_export->exp_connect_flags & OBD_CONNECT_RDONLY)
GOTO(out_parent, result = -EROFS);
}
- child = mdt_object_find(info->mti_ctxt, mdt, info->mti_rr.rr_fid2);
+ child = mdt_object_find(info->mti_ctxt, mdt, &child_fid);
if (IS_ERR(child))
GOTO(out_parent, result = PTR_ERR(child));
if (result != 0)
GOTO(out_child, result);
created = 1;
- } else if (info->mti_rr.rr_flags & MDS_OPEN_EXCL &&
- info->mti_rr.rr_flags & MDS_OPEN_CREAT) {
+ } else if (info->mti_attr.la_flags & MDS_OPEN_EXCL &&
+ info->mti_attr.la_flags & MDS_OPEN_CREAT) {
GOTO(out_child, result = -EEXIST);
}
if (info->mti_body->valid & OBD_MD_FLXATTR) {
char *xattr_name = req_capsule_client_get(&info->mti_pill,
&RMF_NAME);
- CDEBUG(S_MDS, "getxattr %s\n", xattr_name);
+ CDEBUG(D_INODE, "getxattr %s\n", xattr_name);
rc = mo_xattr_get(info->mti_ctxt, next,
buf, buflen, xattr_name);
if (rc < 0 && rc != -ENODATA && rc != -EOPNOTSUPP &&
rc != -ERANGE)
- CDEBUG(S_MDS, "getxattr failed: %d\n", rc);
+ CDEBUG(D_INODE, "getxattr failed: %d\n", rc);
} else if (info->mti_body->valid & OBD_MD_FLXATTRLS) {
- CDEBUG(S_MDS, "listxattr\n");
+ CDEBUG(D_INODE, "listxattr\n");
rc = mo_xattr_list(info->mti_ctxt, next, buf, buflen);
if (rc < 0)
&RMF_EADATA
};
+static const struct req_msg_field *mds_reint_open_server[] = {
+ &RMF_MDT_BODY,
+ &RMF_MDT_MD,
+};
+
static const struct req_msg_field *mds_reint_unlink_client[] = {
&RMF_REC_UNLINK,
&RMF_NAME
};
+static const struct req_msg_field *mds_reint_link_client[] = {
+ &RMF_REC_LINK,
+ &RMF_NAME
+};
+
+static const struct req_msg_field *mds_reint_rename_client[] = {
+ &RMF_REC_RENAME,
+ &RMF_NAME,
+ &RMF_SYMTGT
+};
+
+static const struct req_msg_field *mds_reint_rename_or_unlink_server[] = {
+ &RMF_MDT_BODY,
+ &RMF_MDT_MD,
+ &RMF_LOGCOOKIES
+};
+
static const struct req_msg_field *mds_reint_setattr_client[] = {
&RMF_REC_SETATTR,
&RMF_EADATA,
const struct req_format RQF_MDS_REINT_OPEN =
DEFINE_REQ_FMT0("MDS_REINT_OPEN",
- mds_reint_open_client, mdt_body_only);
+ mds_reint_open_client, mds_reint_open_server);
EXPORT_SYMBOL(RQF_MDS_REINT_OPEN);
const struct req_format RQF_MDS_REINT_UNLINK =
- DEFINE_REQ_FMT0("MDS_REINT_UNLINK",
- mds_reint_unlink_client, mdt_body_only);
+ DEFINE_REQ_FMT0("MDS_REINT_UNLINK", mds_reint_unlink_client,
+ mds_reint_rename_or_unlink_server);
EXPORT_SYMBOL(RQF_MDS_REINT_UNLINK);
+const struct req_format RQF_MDS_REINT_LINK =
+ DEFINE_REQ_FMT0("MDS_REINT_LINK",
+ mds_reint_link_client, mdt_body_only);
+EXPORT_SYMBOL(RQF_MDS_REINT_LINK);
+
+const struct req_format RQF_MDS_REINT_RENAME =
+ DEFINE_REQ_FMT0("MDS_REINT_RENAME", mds_reint_rename_client,
+ mds_reint_rename_or_unlink_server);
+EXPORT_SYMBOL(RQF_MDS_REINT_RENAME);
+
const struct req_format RQF_MDS_REINT_SETATTR =
DEFINE_REQ_FMT0("MDS_REINT_SETATTR",
mds_reint_setattr_client, mdt_body_only);
git://git.whamcloud.com / fs / lustre-release.git / commitdiff