#define rq_user_desc rq_srv.sr_user_desc
#define rq_ops rq_srv.sr_ops
#define rq_rqbd rq_srv.sr_rqbd
+#define rq_reqmsg rq_pill.rc_reqmsg
+#define rq_repmsg rq_pill.rc_repmsg
+#define rq_req_swab_mask rq_pill.rc_req_swab_mask
+#define rq_rep_swab_mask rq_pill.rc_rep_swab_mask
/**
* Represents remote procedure call.
int rq_replen;
/** Pool if request is from preallocated list */
struct ptlrpc_request_pool *rq_pool;
- /** Request message - what client sent */
- struct lustre_msg *rq_reqmsg;
- /** Reply message - server response */
- struct lustre_msg *rq_repmsg;
/** Transaction number */
__u64 rq_transno;
/** xid */
unsigned int rq_reply_off;
/** @} */
- /** Fields that help to see if request and reply were swabbed or not */
- __u32 rq_req_swab_mask;
- __u32 rq_rep_swab_mask;
-
/** how many early replies (for stats) */
int rq_early_count;
/** Server-side, export on which request was received */
/** @} nrs */
/**
- * Returns true if request buffer at offset \a index was already swabbed
- */
-static inline bool lustre_req_swabbed(struct ptlrpc_request *req, size_t index)
-{
- LASSERT(index < sizeof(req->rq_req_swab_mask) * 8);
- return req->rq_req_swab_mask & BIT(index);
-}
-
-/**
- * Returns true if request reply buffer at offset \a index was already swabbed
- */
-static inline bool lustre_rep_swabbed(struct ptlrpc_request *req, size_t index)
-{
- LASSERT(index < sizeof(req->rq_rep_swab_mask) * 8);
- return req->rq_rep_swab_mask & BIT(index);
-}
-
-/**
- * Returns true if request needs to be swabbed into local cpu byteorder
- */
-static inline bool ptlrpc_req_need_swab(struct ptlrpc_request *req)
-{
- return lustre_req_swabbed(req, MSG_PTLRPC_HEADER_OFF);
-}
-
-/**
- * Returns true if request reply needs to be swabbed into local cpu byteorder
- */
-static inline bool ptlrpc_rep_need_swab(struct ptlrpc_request *req)
-{
- return lustre_rep_swabbed(req, MSG_PTLRPC_HEADER_OFF);
-}
-
-/**
- * Mark request buffer at offset \a index that it was already swabbed
- */
-static inline void lustre_set_req_swabbed(struct ptlrpc_request *req,
- size_t index)
-{
- LASSERT(index < sizeof(req->rq_req_swab_mask) * 8);
- LASSERT((req->rq_req_swab_mask & BIT(index)) == 0);
- req->rq_req_swab_mask |= BIT(index);
-}
-
-/**
- * Mark request reply buffer at offset \a index that it was already swabbed
- */
-static inline void lustre_set_rep_swabbed(struct ptlrpc_request *req,
- size_t index)
-{
- LASSERT(index < sizeof(req->rq_rep_swab_mask) * 8);
- LASSERT((req->rq_rep_swab_mask & BIT(index)) == 0);
- req->rq_rep_swab_mask |= BIT(index);
-}
-
-/**
* Convert numerical request phase value \a phase into text string description
*/
static inline const char *
MDS_REG_MAXREQSIZE : OUT_MAXREQSIZE)
#define PTLRPC_MAX_BUFLEN (OST_IO_MAXREQSIZE > MD_MAX_BUFLEN ? \
OST_IO_MAXREQSIZE : MD_MAX_BUFLEN)
-bool ptlrpc_buf_need_swab(struct ptlrpc_request *req, const int inout,
- __u32 index);
-void ptlrpc_buf_set_swabbed(struct ptlrpc_request *req, const int inout,
- __u32 index);
int ptlrpc_unpack_rep_msg(struct ptlrpc_request *req, int len);
int ptlrpc_unpack_req_msg(struct ptlrpc_request *req, int len);
struct req_capsule {
struct ptlrpc_request *rc_req;
- const struct req_format *rc_fmt;
- enum req_location rc_loc;
- __u32 rc_area[RCL_NR][REQ_MAX_FIELD_NR];
+ /** Request message - what client sent */
+ struct lustre_msg *rc_reqmsg;
+ /** Reply message - server response */
+ struct lustre_msg *rc_repmsg;
+ /** Fields that help to see if request and reply were swabved or not */
+ __u32 rc_req_swab_mask;
+ __u32 rc_rep_swab_mask;
+ const struct req_format *rc_fmt;
+ enum req_location rc_loc;
+ __u32 rc_area[RCL_NR][REQ_MAX_FIELD_NR];
};
void req_capsule_init(struct req_capsule *pill, struct ptlrpc_request *req,
int req_capsule_server_grow(struct req_capsule *pill,
const struct req_msg_field *field,
__u32 newlen);
+bool req_capsule_need_swab(struct req_capsule *pill, enum req_location loc,
+ __u32 index);
+void req_capsule_set_swabbed(struct req_capsule *pill, enum req_location loc,
+ __u32 index);
+
+/**
+ * Returns true if request buffer at offset \a index was already swabbed
+ */
+static inline bool req_capsule_req_swabbed(struct req_capsule *pill,
+ size_t index)
+{
+ LASSERT(index < sizeof(pill->rc_req_swab_mask) * 8);
+ return pill->rc_req_swab_mask & BIT(index);
+}
+
+/**
+ * Returns true if request reply buffer at offset \a index was already swabbed
+ */
+static inline bool req_capsule_rep_swabbed(struct req_capsule *pill,
+ size_t index)
+{
+ LASSERT(index < sizeof(pill->rc_rep_swab_mask) * 8);
+ return pill->rc_rep_swab_mask & BIT(index);
+}
+
+/**
+ * Returns true if request needs to be swabbed into local cpu byteorder
+ */
+static inline bool req_capsule_req_need_swab(struct req_capsule *pill)
+{
+ return req_capsule_req_swabbed(pill, MSG_PTLRPC_HEADER_OFF);
+}
+
+/**
+ * Returns true if request reply needs to be swabbed into local cpu byteorder
+ */
+static inline bool req_capsule_rep_need_swab(struct req_capsule *pill)
+{
+ return req_capsule_rep_swabbed(pill, MSG_PTLRPC_HEADER_OFF);
+}
+
+/**
+ * Mark request buffer at offset \a index that it was already swabbed
+ */
+static inline void req_capsule_set_req_swabbed(struct req_capsule *pill,
+ size_t index)
+{
+ LASSERT(index < sizeof(pill->rc_req_swab_mask) * 8);
+ LASSERT((pill->rc_req_swab_mask & BIT(index)) == 0);
+ pill->rc_req_swab_mask |= BIT(index);
+}
+
+/**
+ * Mark request reply buffer at offset \a index that it was already swabbed
+ */
+static inline void req_capsule_set_rep_swabbed(struct req_capsule *pill,
+ size_t index)
+{
+ LASSERT(index < sizeof(pill->rc_rep_swab_mask) * 8);
+ LASSERT((pill->rc_rep_swab_mask & BIT(index)) == 0);
+ pill->rc_rep_swab_mask |= BIT(index);
+}
+
int req_layout_init(void);
void req_layout_fini(void);
#ifdef HAVE_SERVER_SUPPORT
int (*m_init_ea_size)(struct obd_export *, __u32, __u32);
- int (*m_get_lustre_md)(struct obd_export *, struct ptlrpc_request *,
+ int (*m_get_lustre_md)(struct obd_export *, struct req_capsule *,
struct obd_export *, struct obd_export *,
struct lustre_md *);
}
static inline int md_get_lustre_md(struct obd_export *exp,
- struct ptlrpc_request *req,
- struct obd_export *dt_exp,
- struct obd_export *md_exp,
- struct lustre_md *md)
+ struct req_capsule *pill,
+ struct obd_export *dt_exp,
+ struct obd_export *md_exp,
+ struct lustre_md *md)
{
int rc;
if (rc)
return rc;
- return MDP(exp->exp_obd, get_lustre_md)(exp, req, dt_exp, md_exp, md);
+ return MDP(exp->exp_obd, get_lustre_md)(exp, pill, dt_exp, md_exp, md);
}
static inline int md_free_lustre_md(struct obd_export *exp,
}
int ll_revalidate_it_finish(struct ptlrpc_request *request,
- struct lookup_intent *it,
- struct dentry *de)
+ struct lookup_intent *it,
+ struct dentry *de)
{
- int rc = 0;
+ int rc = 0;
+
ENTRY;
- if (!request)
- RETURN(0);
+ if (!request)
+ RETURN(0);
- if (it_disposition(it, DISP_LOOKUP_NEG))
- RETURN(-ENOENT);
+ if (it_disposition(it, DISP_LOOKUP_NEG))
+ RETURN(-ENOENT);
- rc = ll_prep_inode(&de->d_inode, request, NULL, it);
+ rc = ll_prep_inode(&de->d_inode, &request->rq_pill, NULL, it);
- RETURN(rc);
+ RETURN(rc);
}
void ll_lookup_finish_locks(struct lookup_intent *it, struct dentry *dentry)
CFS_FAIL_TIMEOUT(OBD_FAIL_LLITE_SETDIRSTRIPE_PAUSE, cfs_fail_val);
- err = ll_prep_inode(&inode, request, parent->i_sb, NULL);
+ err = ll_prep_inode(&inode, &request->rq_pill, parent->i_sb, NULL);
if (err)
GOTO(out_inode, err);
GOTO(out, rc);
}
- rc = ll_prep_inode(&de->d_inode, req, NULL, itp);
+ rc = ll_prep_inode(&de->d_inode, &req->rq_pill, NULL, itp);
if (!rc && itp->it_lock_mode) {
__u64 bits = 0;
*fid = body->mbo_fid1;
if (inode != NULL)
- rc = ll_prep_inode(inode, req, parent->i_sb, NULL);
+ rc = ll_prep_inode(inode, &req->rq_pill, parent->i_sb, NULL);
out_req:
ptlrpc_req_finished(req);
RETURN(rc);
int ll_remount_fs(struct super_block *sb, int *flags, char *data);
int ll_show_options(struct seq_file *seq, struct dentry *dentry);
void ll_dirty_page_discard_warn(struct page *page, int ioret);
-int ll_prep_inode(struct inode **inode, struct ptlrpc_request *req,
- struct super_block *, struct lookup_intent *);
+int ll_prep_inode(struct inode **inode, struct req_capsule *pill,
+ struct super_block *sb, struct lookup_intent *it);
int ll_obd_statfs(struct inode *inode, void __user *arg);
int ll_get_max_mdsize(struct ll_sb_info *sbi, int *max_mdsize);
int ll_get_default_mdsize(struct ll_sb_info *sbi, int *default_mdsize);
void ll_compute_rootsquash_state(struct ll_sb_info *sbi);
ssize_t ll_copy_user_md(const struct lov_user_md __user *md,
struct lov_user_md **kbuf);
-void ll_open_cleanup(struct super_block *sb, struct ptlrpc_request *open_req);
+void ll_open_cleanup(struct super_block *sb, struct req_capsule *pill);
void ll_dom_finish_open(struct inode *inode, struct ptlrpc_request *req);
GOTO(out_lock_cn_cb, err);
}
- err = md_get_lustre_md(sbi->ll_md_exp, request, sbi->ll_dt_exp,
- sbi->ll_md_exp, &lmd);
+ err = md_get_lustre_md(sbi->ll_md_exp, &request->rq_pill,
+ sbi->ll_dt_exp, sbi->ll_md_exp, &lmd);
if (err) {
CERROR("failed to understand root inode md: rc = %d\n", err);
ptlrpc_req_finished(request);
RETURN(rc);
}
- rc = md_get_lustre_md(sbi->ll_md_exp, request, sbi->ll_dt_exp,
- sbi->ll_md_exp, &md);
+ rc = md_get_lustre_md(sbi->ll_md_exp, &request->rq_pill, sbi->ll_dt_exp,
+ sbi->ll_md_exp, &md);
if (rc) {
ptlrpc_req_finished(request);
RETURN(rc);
* \param[in] sb super block for this file-system
* \param[in] open_req pointer to the original open request
*/
-void ll_open_cleanup(struct super_block *sb, struct ptlrpc_request *open_req)
+void ll_open_cleanup(struct super_block *sb, struct req_capsule *pill)
{
struct mdt_body *body;
struct md_op_data *op_data;
struct obd_export *exp = ll_s2sbi(sb)->ll_md_exp;
ENTRY;
- body = req_capsule_server_get(&open_req->rq_pill, &RMF_MDT_BODY);
+ body = req_capsule_server_get(pill, &RMF_MDT_BODY);
OBD_ALLOC_PTR(op_data);
if (op_data == NULL) {
CWARN("%s: cannot allocate op_data to release open handle for "
EXIT;
}
-int ll_prep_inode(struct inode **inode, struct ptlrpc_request *req,
+int ll_prep_inode(struct inode **inode, struct req_capsule *pill,
struct super_block *sb, struct lookup_intent *it)
{
struct ll_sb_info *sbi = NULL;
LASSERT(*inode || sb);
sbi = sb ? ll_s2sbi(sb) : ll_i2sbi(*inode);
- rc = md_get_lustre_md(sbi->ll_md_exp, req, sbi->ll_dt_exp,
+ rc = md_get_lustre_md(sbi->ll_md_exp, pill, sbi->ll_dt_exp,
sbi->ll_md_exp, &md);
if (rc != 0)
GOTO(out, rc);
if (rc != 0 && it != NULL && it->it_op & IT_OPEN) {
ll_intent_drop_lock(it);
- ll_open_cleanup(sb != NULL ? sb : (*inode)->i_sb, req);
+ ll_open_cleanup(sb != NULL ? sb : (*inode)->i_sb, pill);
}
return rc;
PFID(fid), rc);
RETURN(ERR_PTR(rc));
}
- rc = ll_prep_inode(&inode, req, sb, NULL);
+ rc = ll_prep_inode(&inode, &req->rq_pill, sb, NULL);
ptlrpc_req_finished(req);
if (rc)
RETURN(ERR_PTR(rc));
struct mdt_body *body = req_capsule_server_get(pill,
&RMF_MDT_BODY);
- rc = ll_prep_inode(&inode, request, (*de)->d_sb, it);
+ rc = ll_prep_inode(&inode, &request->rq_pill, (*de)->d_sb, it);
if (rc)
RETURN(rc);
out:
if (rc != 0 && it->it_op & IT_OPEN) {
ll_intent_drop_lock(it);
- ll_open_cleanup((*de)->d_sb, request);
+ ll_open_cleanup((*de)->d_sb, &request->rq_pill);
}
return rc;
LASSERT(it_disposition(it, DISP_ENQ_CREATE_REF));
request = it->it_request;
- it_clear_disposition(it, DISP_ENQ_CREATE_REF);
- rc = ll_prep_inode(&inode, request, dir->i_sb, it);
- if (rc)
- GOTO(out, inode = ERR_PTR(rc));
+ it_clear_disposition(it, DISP_ENQ_CREATE_REF);
+ rc = ll_prep_inode(&inode, &request->rq_pill, dir->i_sb, it);
+ if (rc)
+ GOTO(out, inode = ERR_PTR(rc));
/* Pause to allow for a race with concurrent access by fid */
OBD_FAIL_TIMEOUT(OBD_FAIL_LLITE_CREATE_NODE_PAUSE, cfs_fail_val);
CFS_FAIL_TIMEOUT(OBD_FAIL_LLITE_NEWNODE_PAUSE, cfs_fail_val);
- err = ll_prep_inode(&inode, request, dchild->d_sb, NULL);
+ err = ll_prep_inode(&inode, &request->rq_pill, dchild->d_sb, NULL);
if (err)
GOTO(err_exit, err);
if (rc != 1)
GOTO(out, rc = -EAGAIN);
- rc = ll_prep_inode(&child, req, dir->i_sb, it);
+ rc = ll_prep_inode(&child, &req->rq_pill, dir->i_sb, it);
if (rc)
GOTO(out, rc);
}
static int
-lmv_get_lustre_md(struct obd_export *exp, struct ptlrpc_request *req,
+lmv_get_lustre_md(struct obd_export *exp, struct req_capsule *pill,
struct obd_export *dt_exp, struct obd_export *md_exp,
struct lustre_md *md)
{
if (!tgt || !tgt->ltd_exp)
return -EINVAL;
- return md_get_lustre_md(tgt->ltd_exp, req, dt_exp, md_exp, md);
+ return md_get_lustre_md(tgt->ltd_exp, pill, dt_exp, md_exp, md);
}
static int lmv_free_lustre_md(struct obd_export *exp, struct lustre_md *md)
#include "mdc_internal.h"
-int mdc_unpack_acl(struct ptlrpc_request *req, struct lustre_md *md)
+int mdc_unpack_acl(struct req_capsule *pill, struct lustre_md *md)
{
- struct req_capsule *pill = &req->rq_pill;
struct mdt_body *body = md->body;
struct posix_acl *acl;
void *buf;
}
/* This is needed only for old servers (before 2.14) support */
-int mdc_fill_lvb(struct ptlrpc_request *req, struct ost_lvb *lvb)
+int mdc_fill_lvb(struct req_capsule *pill, struct ost_lvb *lvb)
{
struct mdt_body *body;
/* get LVB data from mdt_body otherwise */
- body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
+ body = req_capsule_server_get(pill, &RMF_MDT_BODY);
if (!body)
RETURN(-EPROTO);
/* needed only for glimpse from an old server (< 2.14) */
if (glimpse && !exp_connect_dom_lvb(exp))
- rc = mdc_fill_lvb(req, &ols->ols_lvb);
+ rc = mdc_fill_lvb(&req->rq_pill, &ols->ols_lvb);
if (glimpse && errcode == ELDLM_LOCK_ABORTED) {
struct ldlm_reply *rep;
int mdc_tunables_init(struct obd_device *obd);
-void mdc_pack_body(struct ptlrpc_request *req, const struct lu_fid *fid,
+void mdc_pack_body(struct req_capsule *pill, const struct lu_fid *fid,
u64 valid, size_t ea_size, u32 suppgid, u32 flags);
-void mdc_swap_layouts_pack(struct ptlrpc_request *req,
+void mdc_swap_layouts_pack(struct req_capsule *pill,
struct md_op_data *op_data);
-void mdc_readdir_pack(struct ptlrpc_request *req, __u64 pgoff, size_t size,
+void mdc_readdir_pack(struct req_capsule *pill, __u64 pgoff, size_t size,
const struct lu_fid *fid);
-void mdc_getattr_pack(struct ptlrpc_request *req, __u64 valid, __u32 flags,
+void mdc_getattr_pack(struct req_capsule *pill, __u64 valid, __u32 flags,
struct md_op_data *data, size_t ea_size);
-void mdc_setattr_pack(struct ptlrpc_request *req, struct md_op_data *op_data,
+void mdc_setattr_pack(struct req_capsule *pill, struct md_op_data *op_data,
void *ea, size_t ealen);
-void mdc_create_pack(struct ptlrpc_request *req, struct md_op_data *op_data,
+void mdc_create_pack(struct req_capsule *pill, struct md_op_data *op_data,
const void *data, size_t datalen, umode_t mode,
uid_t uid, gid_t gid, cfs_cap_t capability, __u64 rdev);
-void mdc_open_pack(struct ptlrpc_request *req, struct md_op_data *op_data,
+void mdc_open_pack(struct req_capsule *pill, struct md_op_data *op_data,
umode_t mode, __u64 rdev, __u64 flags,
const void *data, size_t datalen);
-void mdc_file_secctx_pack(struct ptlrpc_request *req,
+void mdc_file_secctx_pack(struct req_capsule *pill,
const char *secctx_name,
const void *secctx, size_t secctx_size);
-void mdc_file_encctx_pack(struct ptlrpc_request *req,
+void mdc_file_encctx_pack(struct req_capsule *pill,
const void *encctx, size_t encctx_size);
-void mdc_file_sepol_pack(struct ptlrpc_request *req);
+void mdc_file_sepol_pack(struct req_capsule *pill);
-void mdc_unlink_pack(struct ptlrpc_request *req, struct md_op_data *op_data);
-void mdc_link_pack(struct ptlrpc_request *req, struct md_op_data *op_data);
-void mdc_rename_pack(struct ptlrpc_request *req, struct md_op_data *op_data,
+void mdc_unlink_pack(struct req_capsule *pill, struct md_op_data *op_data);
+void mdc_link_pack(struct req_capsule *pill, struct md_op_data *op_data);
+void mdc_rename_pack(struct req_capsule *pill, struct md_op_data *op_data,
const char *old, size_t oldlen,
const char *new, size_t newlen);
-void mdc_migrate_pack(struct ptlrpc_request *req, struct md_op_data *op_data,
+void mdc_migrate_pack(struct req_capsule *pill, struct md_op_data *op_data,
const char *name, size_t namelen);
-void mdc_close_pack(struct ptlrpc_request *req, struct md_op_data *op_data);
+void mdc_close_pack(struct req_capsule *pill, struct md_op_data *op_data);
/* mdc/mdc_locks.c */
int mdc_set_lock_data(struct obd_export *exp,
}
#ifdef CONFIG_LUSTRE_FS_POSIX_ACL
-int mdc_unpack_acl(struct ptlrpc_request *req, struct lustre_md *md);
+int mdc_unpack_acl(struct req_capsule *pill, struct lustre_md *md);
#else
static inline
-int mdc_unpack_acl(struct ptlrpc_request *req, struct lustre_md *md)
+int mdc_unpack_acl(struct req_capsule *pill, struct lustre_md *md)
{
return 0;
}
int mdc_ldlm_blocking_ast(struct ldlm_lock *dlmlock,
struct ldlm_lock_desc *new, void *data, int flag);
int mdc_ldlm_glimpse_ast(struct ldlm_lock *dlmlock, void *data);
-int mdc_fill_lvb(struct ptlrpc_request *req, struct ost_lvb *lvb);
+int mdc_fill_lvb(struct req_capsule *pill, struct ost_lvb *lvb);
/* the minimum inline repsize should be PAGE_SIZE at least */
#define MDC_DOM_DEF_INLINE_REPSIZE max(8192UL, PAGE_SIZE)
b->mbo_capability = cfs_curproc_cap_pack();
}
-void mdc_swap_layouts_pack(struct ptlrpc_request *req,
+void mdc_swap_layouts_pack(struct req_capsule *pill,
struct md_op_data *op_data)
{
- struct mdt_body *b = req_capsule_client_get(&req->rq_pill,
- &RMF_MDT_BODY);
+ struct mdt_body *b = req_capsule_client_get(pill, &RMF_MDT_BODY);
__mdc_pack_body(b, op_data->op_suppgids[0]);
b->mbo_fid1 = op_data->op_fid1;
b->mbo_valid |= OBD_MD_FLID;
}
-void mdc_pack_body(struct ptlrpc_request *req, const struct lu_fid *fid,
+void mdc_pack_body(struct req_capsule *pill, const struct lu_fid *fid,
u64 valid, size_t ea_size, u32 suppgid, u32 flags)
{
- struct mdt_body *b = req_capsule_client_get(&req->rq_pill,
- &RMF_MDT_BODY);
+ struct mdt_body *b = req_capsule_client_get(pill, &RMF_MDT_BODY);
LASSERT(b);
b->mbo_valid = valid;
b->mbo_eadatasize = ea_size;
/**
* Pack a name (path component) into a request
*
- * \param[in] req request
+ * \param[in] pill request pill
* \param[in] field request field (usually RMF_NAME)
* \param[in] name path component
* \param[in] name_len length of path component
* \a name must be '\0' terminated of length \a name_len and represent
* a single path component (not contain '/').
*/
-static void mdc_pack_name(struct ptlrpc_request *req,
+static void mdc_pack_name(struct req_capsule *pill,
const struct req_msg_field *field,
const char *name, size_t name_len)
{
size_t buf_size;
size_t cpy_len;
- buf = req_capsule_client_get(&req->rq_pill, field);
- buf_size = req_capsule_get_size(&req->rq_pill, field, RCL_CLIENT);
+ buf = req_capsule_client_get(pill, field);
+ buf_size = req_capsule_get_size(pill, field, RCL_CLIENT);
LASSERT(name != NULL && name_len != 0 &&
buf != NULL && buf_size == name_len + 1);
LASSERT(lu_name_is_valid_2(buf, cpy_len));
if (cpy_len != name_len)
- CDEBUG(D_DENTRY, "%s: %s len %zd != %zd, concurrent rename?\n",
- req->rq_export->exp_obd->obd_name, buf, name_len,
- cpy_len);
+ CDEBUG(D_DENTRY, "%s len %zd != %zd, concurrent rename?\n",
+ buf, name_len, cpy_len);
}
-void mdc_file_secctx_pack(struct ptlrpc_request *req, const char *secctx_name,
+void mdc_file_secctx_pack(struct req_capsule *pill, const char *secctx_name,
const void *secctx, size_t secctx_size)
{
void *buf;
if (secctx_name == NULL)
return;
- buf = req_capsule_client_get(&req->rq_pill, &RMF_FILE_SECCTX_NAME);
- buf_size = req_capsule_get_size(&req->rq_pill, &RMF_FILE_SECCTX_NAME,
+ buf = req_capsule_client_get(pill, &RMF_FILE_SECCTX_NAME);
+ buf_size = req_capsule_get_size(pill, &RMF_FILE_SECCTX_NAME,
RCL_CLIENT);
LASSERT(buf_size == strlen(secctx_name) + 1);
memcpy(buf, secctx_name, buf_size);
- buf = req_capsule_client_get(&req->rq_pill, &RMF_FILE_SECCTX);
- buf_size = req_capsule_get_size(&req->rq_pill, &RMF_FILE_SECCTX,
+ buf = req_capsule_client_get(pill, &RMF_FILE_SECCTX);
+ buf_size = req_capsule_get_size(pill, &RMF_FILE_SECCTX,
RCL_CLIENT);
LASSERT(buf_size == secctx_size);
memcpy(buf, secctx, buf_size);
}
-void mdc_file_encctx_pack(struct ptlrpc_request *req,
+void mdc_file_encctx_pack(struct req_capsule *pill,
const void *encctx, size_t encctx_size)
{
void *buf;
if (encctx == NULL)
return;
- buf = req_capsule_client_get(&req->rq_pill, &RMF_FILE_ENCCTX);
- buf_size = req_capsule_get_size(&req->rq_pill, &RMF_FILE_ENCCTX,
+ buf = req_capsule_client_get(pill, &RMF_FILE_ENCCTX);
+ buf_size = req_capsule_get_size(pill, &RMF_FILE_ENCCTX,
RCL_CLIENT);
LASSERT(buf_size == encctx_size);
memcpy(buf, encctx, buf_size);
}
-void mdc_file_sepol_pack(struct ptlrpc_request *req)
+void mdc_file_sepol_pack(struct req_capsule *pill)
{
void *buf;
size_t buf_size;
+ struct ptlrpc_request *req = pill->rc_req;
if (strlen(req->rq_sepol) == 0)
return;
- buf = req_capsule_client_get(&req->rq_pill, &RMF_SELINUX_POL);
- buf_size = req_capsule_get_size(&req->rq_pill, &RMF_SELINUX_POL,
+ buf = req_capsule_client_get(pill, &RMF_SELINUX_POL);
+ buf_size = req_capsule_get_size(pill, &RMF_SELINUX_POL,
RCL_CLIENT);
LASSERT(buf_size == strlen(req->rq_sepol) + 1);
snprintf(buf, strlen(req->rq_sepol) + 1, "%s", req->rq_sepol);
}
-void mdc_readdir_pack(struct ptlrpc_request *req, __u64 pgoff, size_t size,
+void mdc_readdir_pack(struct req_capsule *pill, __u64 pgoff, size_t size,
const struct lu_fid *fid)
{
- struct mdt_body *b = req_capsule_client_get(&req->rq_pill,
- &RMF_MDT_BODY);
+ struct mdt_body *b = req_capsule_client_get(pill, &RMF_MDT_BODY);
+
b->mbo_fid1 = *fid;
b->mbo_valid |= OBD_MD_FLID;
b->mbo_size = pgoff; /* !! */
}
/* packing of MDS records */
-void mdc_create_pack(struct ptlrpc_request *req, struct md_op_data *op_data,
+void mdc_create_pack(struct req_capsule *pill, struct md_op_data *op_data,
const void *data, size_t datalen, umode_t mode,
uid_t uid, gid_t gid, cfs_cap_t cap_effective, __u64 rdev)
{
BUILD_BUG_ON(sizeof(struct mdt_rec_reint) !=
sizeof(struct mdt_rec_create));
- rec = req_capsule_client_get(&req->rq_pill, &RMF_REC_REINT);
+ rec = req_capsule_client_get(pill, &RMF_REC_REINT);
rec->cr_opcode = REINT_CREATE;
rec->cr_fsuid = uid;
rec->cr_bias = op_data->op_bias;
rec->cr_umask = current_umask();
- mdc_pack_name(req, &RMF_NAME, op_data->op_name, op_data->op_namelen);
+ mdc_pack_name(pill, &RMF_NAME, op_data->op_name, op_data->op_namelen);
if (data) {
- tmp = req_capsule_client_get(&req->rq_pill, &RMF_EADATA);
+ tmp = req_capsule_client_get(pill, &RMF_EADATA);
memcpy(tmp, data, datalen);
}
- mdc_file_secctx_pack(req, op_data->op_file_secctx_name,
+ mdc_file_secctx_pack(pill, op_data->op_file_secctx_name,
op_data->op_file_secctx,
op_data->op_file_secctx_size);
- mdc_file_encctx_pack(req, op_data->op_file_encctx,
+ mdc_file_encctx_pack(pill, op_data->op_file_encctx,
op_data->op_file_encctx_size);
/* pack SELinux policy info if any */
- mdc_file_sepol_pack(req);
+ mdc_file_sepol_pack(pill);
}
static inline __u64 mds_pack_open_flags(__u64 flags)
}
/* packing of MDS records */
-void mdc_open_pack(struct ptlrpc_request *req, struct md_op_data *op_data,
+void mdc_open_pack(struct req_capsule *pill, struct md_op_data *op_data,
umode_t mode, __u64 rdev, __u64 flags, const void *lmm,
size_t lmmlen)
{
BUILD_BUG_ON(sizeof(struct mdt_rec_reint) !=
sizeof(struct mdt_rec_create));
- rec = req_capsule_client_get(&req->rq_pill, &RMF_REC_REINT);
+ rec = req_capsule_client_get(pill, &RMF_REC_REINT);
/* XXX do something about time, uid, gid */
rec->cr_opcode = REINT_OPEN;
rec->cr_open_handle_old = op_data->op_open_handle;
if (op_data->op_name) {
- mdc_pack_name(req, &RMF_NAME, op_data->op_name,
+ mdc_pack_name(pill, &RMF_NAME, op_data->op_name,
op_data->op_namelen);
if (op_data->op_bias & MDS_CREATE_VOLATILE)
cr_flags |= MDS_OPEN_VOLATILE;
}
- mdc_file_secctx_pack(req, op_data->op_file_secctx_name,
+ mdc_file_secctx_pack(pill, op_data->op_file_secctx_name,
op_data->op_file_secctx,
op_data->op_file_secctx_size);
- mdc_file_encctx_pack(req, op_data->op_file_encctx,
+ mdc_file_encctx_pack(pill, op_data->op_file_encctx,
op_data->op_file_encctx_size);
/* pack SELinux policy info if any */
- mdc_file_sepol_pack(req);
+ mdc_file_sepol_pack(pill);
}
if (lmm) {
cr_flags |= MDS_OPEN_HAS_EA;
- tmp = req_capsule_client_get(&req->rq_pill, &RMF_EADATA);
+ tmp = req_capsule_client_get(pill, &RMF_EADATA);
memcpy(tmp, lmm, lmmlen);
if (cr_flags & MDS_OPEN_PCC) {
LASSERT(op_data != NULL);
epoch->mio_padding = 0;
}
-void mdc_setattr_pack(struct ptlrpc_request *req, struct md_op_data *op_data,
+void mdc_setattr_pack(struct req_capsule *pill, struct md_op_data *op_data,
void *ea, size_t ealen)
{
struct mdt_rec_setattr *rec;
BUILD_BUG_ON(sizeof(struct mdt_rec_reint) !=
sizeof(struct mdt_rec_setattr));
- rec = req_capsule_client_get(&req->rq_pill, &RMF_REC_REINT);
+ rec = req_capsule_client_get(pill, &RMF_REC_REINT);
mdc_setattr_pack_rec(rec, op_data);
if (ealen == 0)
return;
- lum = req_capsule_client_get(&req->rq_pill, &RMF_EADATA);
+ lum = req_capsule_client_get(pill, &RMF_EADATA);
if (ea == NULL) { /* Remove LOV EA */
lum->lmm_magic = cpu_to_le32(LOV_USER_MAGIC_V1);
lum->lmm_stripe_size = 0;
}
}
-void mdc_unlink_pack(struct ptlrpc_request *req, struct md_op_data *op_data)
+void mdc_unlink_pack(struct req_capsule *pill, struct md_op_data *op_data)
{
struct mdt_rec_unlink *rec;
BUILD_BUG_ON(sizeof(struct mdt_rec_reint) !=
sizeof(struct mdt_rec_unlink));
- rec = req_capsule_client_get(&req->rq_pill, &RMF_REC_REINT);
+ rec = req_capsule_client_get(pill, &RMF_REC_REINT);
LASSERT(rec != NULL);
rec->ul_opcode = op_data->op_cli_flags & CLI_RM_ENTRY ?
rec->ul_time = op_data->op_mod_time;
rec->ul_bias = op_data->op_bias;
- mdc_pack_name(req, &RMF_NAME, op_data->op_name, op_data->op_namelen);
+ mdc_pack_name(pill, &RMF_NAME, op_data->op_name, op_data->op_namelen);
/* pack SELinux policy info if any */
- mdc_file_sepol_pack(req);
+ mdc_file_sepol_pack(pill);
}
-void mdc_link_pack(struct ptlrpc_request *req, struct md_op_data *op_data)
+void mdc_link_pack(struct req_capsule *pill, struct md_op_data *op_data)
{
struct mdt_rec_link *rec;
BUILD_BUG_ON(sizeof(struct mdt_rec_reint) !=
sizeof(struct mdt_rec_link));
- rec = req_capsule_client_get(&req->rq_pill, &RMF_REC_REINT);
+ rec = req_capsule_client_get(pill, &RMF_REC_REINT);
LASSERT(rec != NULL);
rec->lk_opcode = REINT_LINK;
rec->lk_time = op_data->op_mod_time;
rec->lk_bias = op_data->op_bias;
- mdc_pack_name(req, &RMF_NAME, op_data->op_name, op_data->op_namelen);
+ mdc_pack_name(pill, &RMF_NAME, op_data->op_name, op_data->op_namelen);
/* pack SELinux policy info if any */
- mdc_file_sepol_pack(req);
+ mdc_file_sepol_pack(pill);
}
-static void mdc_close_intent_pack(struct ptlrpc_request *req,
+static void mdc_close_intent_pack(struct req_capsule *pill,
struct md_op_data *op_data)
{
struct close_data *data;
if (!(bias & (MDS_CLOSE_INTENT | MDS_CLOSE_MIGRATE)))
return;
- data = req_capsule_client_get(&req->rq_pill, &RMF_CLOSE_DATA);
+ data = req_capsule_client_get(pill, &RMF_CLOSE_DATA);
LASSERT(data != NULL);
lock = ldlm_handle2lock(&op_data->op_lease_handle);
} else {
size_t count = sync->resync_count;
- memcpy(req_capsule_client_get(&req->rq_pill, &RMF_U32),
+ memcpy(req_capsule_client_get(pill, &RMF_U32),
op_data->op_data, count * sizeof(__u32));
}
} else if (bias & MDS_PCC_ATTACH) {
}
}
-void mdc_rename_pack(struct ptlrpc_request *req, struct md_op_data *op_data,
+void mdc_rename_pack(struct req_capsule *pill, struct md_op_data *op_data,
const char *old, size_t oldlen,
const char *new, size_t newlen)
{
BUILD_BUG_ON(sizeof(struct mdt_rec_reint) !=
sizeof(struct mdt_rec_rename));
- rec = req_capsule_client_get(&req->rq_pill, &RMF_REC_REINT);
+ rec = req_capsule_client_get(pill, &RMF_REC_REINT);
/* XXX do something about time, uid, gid */
rec->rn_opcode = REINT_RENAME;
rec->rn_mode = op_data->op_mode;
rec->rn_bias = op_data->op_bias;
- mdc_pack_name(req, &RMF_NAME, old, oldlen);
+ mdc_pack_name(pill, &RMF_NAME, old, oldlen);
if (new != NULL)
- mdc_pack_name(req, &RMF_SYMTGT, new, newlen);
+ mdc_pack_name(pill, &RMF_SYMTGT, new, newlen);
/* pack SELinux policy info if any */
- mdc_file_sepol_pack(req);
+ mdc_file_sepol_pack(pill);
}
-void mdc_migrate_pack(struct ptlrpc_request *req, struct md_op_data *op_data,
+void mdc_migrate_pack(struct req_capsule *pill, struct md_op_data *op_data,
const char *name, size_t namelen)
{
struct mdt_rec_rename *rec;
BUILD_BUG_ON(sizeof(struct mdt_rec_reint) !=
sizeof(struct mdt_rec_rename));
- rec = req_capsule_client_get(&req->rq_pill, &RMF_REC_REINT);
+ rec = req_capsule_client_get(pill, &RMF_REC_REINT);
rec->rn_opcode = REINT_MIGRATE;
rec->rn_fsuid = op_data->op_fsuid;
rec->rn_mode = op_data->op_mode;
rec->rn_bias = op_data->op_bias;
- mdc_pack_name(req, &RMF_NAME, name, namelen);
+ mdc_pack_name(pill, &RMF_NAME, name, namelen);
if (op_data->op_bias & MDS_CLOSE_MIGRATE) {
struct mdt_ioepoch *epoch;
- mdc_close_intent_pack(req, op_data);
- epoch = req_capsule_client_get(&req->rq_pill, &RMF_MDT_EPOCH);
+ mdc_close_intent_pack(pill, op_data);
+ epoch = req_capsule_client_get(pill, &RMF_MDT_EPOCH);
mdc_ioepoch_pack(epoch, op_data);
}
- ea = req_capsule_client_get(&req->rq_pill, &RMF_EADATA);
+ ea = req_capsule_client_get(pill, &RMF_EADATA);
memcpy(ea, op_data->op_data, op_data->op_data_size);
}
-void mdc_getattr_pack(struct ptlrpc_request *req, __u64 valid, __u32 flags,
+void mdc_getattr_pack(struct req_capsule *pill, __u64 valid, __u32 flags,
struct md_op_data *op_data, size_t ea_size)
{
- struct mdt_body *b = req_capsule_client_get(&req->rq_pill,
- &RMF_MDT_BODY);
+ struct mdt_body *b = req_capsule_client_get(pill, &RMF_MDT_BODY);
b->mbo_valid = valid;
if (op_data->op_bias & MDS_CROSS_REF)
b->mbo_valid |= OBD_MD_FLID;
if (op_data->op_name != NULL)
- mdc_pack_name(req, &RMF_NAME, op_data->op_name,
+ mdc_pack_name(pill, &RMF_NAME, op_data->op_name,
op_data->op_namelen);
}
-void mdc_close_pack(struct ptlrpc_request *req, struct md_op_data *op_data)
+void mdc_close_pack(struct req_capsule *pill, struct md_op_data *op_data)
{
struct mdt_ioepoch *epoch;
struct mdt_rec_setattr *rec;
- epoch = req_capsule_client_get(&req->rq_pill, &RMF_MDT_EPOCH);
- rec = req_capsule_client_get(&req->rq_pill, &RMF_REC_REINT);
+ epoch = req_capsule_client_get(pill, &RMF_MDT_EPOCH);
+ rec = req_capsule_client_get(pill, &RMF_REC_REINT);
mdc_setattr_pack_rec(rec, op_data);
/*
rec->sa_valid &= ~MDS_ATTR_ATIME;
mdc_ioepoch_pack(epoch, op_data);
- mdc_close_intent_pack(req, op_data);
+ mdc_close_intent_pack(pill, op_data);
}
lit->opc = (__u64)it->it_op;
/* pack the intended request */
- mdc_open_pack(req, op_data, it->it_create_mode, 0, it->it_flags, lmm,
- lmmsize);
+ mdc_open_pack(&req->rq_pill, op_data, it->it_create_mode, 0,
+ it->it_flags, lmm, lmmsize);
req_capsule_set_size(&req->rq_pill, &RMF_MDT_MD, RCL_SERVER,
mdt_md_capsule_size);
#endif
/* pack the intended request */
- mdc_pack_body(req, &op_data->op_fid1, op_data->op_valid,
+ mdc_pack_body(&req->rq_pill, &op_data->op_fid1, op_data->op_valid,
ea_vals_buf_size, -1, 0);
/* get SELinux policy info if any */
- mdc_file_sepol_pack(req);
+ mdc_file_sepol_pack(&req->rq_pill);
req_capsule_set_size(&req->rq_pill, &RMF_EADATA, RCL_SERVER,
GA_DEFAULT_EA_NAME_LEN * GA_DEFAULT_EA_NUM);
easize = obd->u.cli.cl_max_mds_easize;
/* pack the intended request */
- mdc_getattr_pack(req, valid, it->it_flags, op_data, easize);
+ mdc_getattr_pack(&req->rq_pill, valid, it->it_flags, op_data, easize);
req_capsule_set_size(&req->rq_pill, &RMF_MDT_MD, RCL_SERVER, easize);
req_capsule_set_size(&req->rq_pill, &RMF_ACL, RCL_SERVER, acl_bufsize);
CDEBUG(D_INODE, "setting mtime %lld, ctime %lld\n",
(s64)op_data->op_attr.ia_mtime.tv_sec,
(s64)op_data->op_attr.ia_ctime.tv_sec);
- mdc_setattr_pack(req, op_data, ea, ealen);
+ mdc_setattr_pack(&req->rq_pill, op_data, ea, ealen);
req_capsule_set_size(&req->rq_pill, &RMF_ACL, RCL_SERVER, 0);
* mdc_create_pack() fills msg->bufs[1] with name and msg->bufs[2] with
* tgt, for symlinks or lov MD data.
*/
- mdc_create_pack(req, op_data, data, datalen, mode, uid,
- gid, cap_effective, rdev);
+ mdc_create_pack(&req->rq_pill, op_data, data, datalen, mode, uid,
+ gid, cap_effective, rdev);
ptlrpc_request_set_replen(req);
RETURN(rc);
}
- mdc_unlink_pack(req, op_data);
+ mdc_unlink_pack(&req->rq_pill, op_data);
req_capsule_set_size(&req->rq_pill, &RMF_MDT_MD, RCL_SERVER,
obd->u.cli.cl_default_mds_easize);
RETURN(rc);
}
- mdc_link_pack(req, op_data);
- ptlrpc_request_set_replen(req);
+ mdc_link_pack(&req->rq_pill, op_data);
+ ptlrpc_request_set_replen(req);
rc = mdc_reint(req, LUSTRE_IMP_FULL);
*request = req;
ldlm_cli_cancel_list(&cancels, count, req, 0);
if (op_data->op_cli_flags & CLI_MIGRATE)
- mdc_migrate_pack(req, op_data, old, oldlen);
+ mdc_migrate_pack(&req->rq_pill, op_data, old, oldlen);
else
- mdc_rename_pack(req, op_data, old, oldlen, new, newlen);
+ mdc_rename_pack(&req->rq_pill, op_data, old, oldlen,
+ new, newlen);
req_capsule_set_size(&req->rq_pill, &RMF_MDT_MD, RCL_SERVER,
obd->u.cli.cl_default_mds_easize);
ptlrpc_request_free(req);
RETURN(rc);
}
- mdc_pack_body(req, NULL, 0, 0, -1, 0);
+ mdc_pack_body(&req->rq_pill, NULL, 0, 0, -1, 0);
if (fileset != NULL) {
char *name = req_capsule_client_get(&req->rq_pill, &RMF_NAME);
}
again:
- mdc_pack_body(req, &op_data->op_fid1, op_data->op_valid,
+ mdc_pack_body(&req->rq_pill, &op_data->op_fid1, op_data->op_valid,
op_data->op_mode, -1, 0);
req_capsule_set_size(&req->rq_pill, &RMF_ACL, RCL_SERVER, acl_bufsize);
req_capsule_set_size(&req->rq_pill, &RMF_MDT_MD, RCL_SERVER,
}
again:
- mdc_pack_body(req, &op_data->op_fid1, op_data->op_valid,
+ mdc_pack_body(&req->rq_pill, &op_data->op_fid1, op_data->op_valid,
op_data->op_mode, op_data->op_suppgids[0], 0);
req_capsule_set_size(&req->rq_pill, &RMF_MDT_MD, RCL_SERVER,
op_data->op_mode);
rec->sx_size = output_size;
rec->sx_flags = flags;
} else {
- mdc_pack_body(req, fid, valid, output_size, suppgid, flags);
+ mdc_pack_body(&req->rq_pill, fid, valid, output_size,
+ suppgid, flags);
}
if (xattr_name) {
memcpy(tmp, input, input_size);
}
- mdc_file_sepol_pack(req);
+ mdc_file_sepol_pack(&req->rq_pill);
if (req_capsule_has_field(&req->rq_pill, &RMF_EADATA, RCL_SERVER))
req_capsule_set_size(&req->rq_pill, &RMF_EADATA,
return rc;
}
-static int mdc_get_lustre_md(struct obd_export *exp, struct ptlrpc_request *req,
+static int mdc_get_lustre_md(struct obd_export *exp, struct req_capsule *pill,
struct obd_export *dt_exp,
struct obd_export *md_exp,
struct lustre_md *md)
{
- struct req_capsule *pill = &req->rq_pill;
int rc;
ENTRY;
* only when aclsize != 0 there's an actual segment for ACL
* in reply buffer.
*/
- rc = mdc_unpack_acl(req, md);
+ rc = mdc_unpack_acl(pill, md);
if (rc)
GOTO(out, rc);
}
op_data->op_xvalid &= ~(OP_XVALID_LAZYSIZE |
OP_XVALID_LAZYBLOCKS);
- mdc_close_pack(req, op_data);
+ mdc_close_pack(&req->rq_pill, op_data);
req_capsule_set_size(&req->rq_pill, &RMF_MDT_MD, RCL_SERVER,
obd->u.cli.cl_default_mds_easize);
desc->bd_frag_ops->add_kiov_frag(desc, pages[i], 0,
PAGE_SIZE);
- mdc_readdir_pack(req, offset, PAGE_SIZE * npages, fid);
+ mdc_readdir_pack(&req->rq_pill, offset, PAGE_SIZE * npages, fid);
ptlrpc_request_set_replen(req);
rc = ptlrpc_queue_wait(req);
if (req == NULL)
GOTO(out, rc = -ENOMEM);
- mdc_pack_body(req, NULL, 0, 0, -1, 0);
+ mdc_pack_body(&req->rq_pill, NULL, 0, 0, -1, 0);
/* Copy hsm_progress struct */
req_hpk = req_capsule_client_get(&req->rq_pill, &RMF_MDS_HSM_PROGRESS);
RETURN(-ENOMEM);
}
- mdc_pack_body(req, NULL, 0, 0, -1, 0);
+ mdc_pack_body(&req->rq_pill, NULL, 0, 0, -1, 0);
archive_array = req_capsule_client_get(&req->rq_pill,
&RMF_MDS_HSM_ARCHIVE);
RETURN(rc);
}
- mdc_pack_body(req, &op_data->op_fid1, 0, 0,
+ mdc_pack_body(&req->rq_pill, &op_data->op_fid1, 0, 0,
op_data->op_suppgids[0], 0);
ptlrpc_request_set_replen(req);
if (req == NULL)
GOTO(out, rc = -ENOMEM);
- mdc_pack_body(req, NULL, 0, 0, -1, 0);
+ mdc_pack_body(&req->rq_pill, NULL, 0, 0, -1, 0);
ptlrpc_request_set_replen(req);
RETURN(rc);
}
- mdc_pack_body(req, &op_data->op_fid1, 0, 0,
+ mdc_pack_body(&req->rq_pill, &op_data->op_fid1, 0, 0,
op_data->op_suppgids[0], 0);
ptlrpc_request_set_replen(req);
RETURN(rc);
}
- mdc_pack_body(req, &op_data->op_fid1, 0, 0,
+ mdc_pack_body(&req->rq_pill, &op_data->op_fid1, 0, 0,
op_data->op_suppgids[0], 0);
/* Copy states */
RETURN(rc);
}
- mdc_pack_body(req, NULL, 0, 0, -1, 0);
+ mdc_pack_body(&req->rq_pill, NULL, 0, 0, -1, 0);
/* Copy hsm_request struct */
req_hr = req_capsule_client_get(&req->rq_pill, &RMF_MDS_HSM_REQUEST);
RETURN(rc);
}
- mdc_swap_layouts_pack(req, op_data);
+ mdc_swap_layouts_pack(&req->rq_pill, op_data);
payload = req_capsule_client_get(&req->rq_pill, &RMF_SWAP_LAYOUTS);
LASSERT(payload);
if (rc == 0 || rc == -EREMOTE) {
tmp = req_capsule_server_get(&req->rq_pill, &RMF_GETINFO_VAL);
memcpy(val, tmp, vallen);
- if (ptlrpc_rep_need_swab(req)) {
+ if (req_capsule_rep_need_swab(&req->rq_pill)) {
if (KEY_IS(KEY_FID2PATH))
lustre_swab_fid2path(val);
}
RETURN(rc);
}
- mdc_pack_body(req, fid, 0, 0, -1, 0);
+ mdc_pack_body(&req->rq_pill, fid, 0, 0, -1, 0);
ptlrpc_request_set_replen(req);
tmp = req_capsule_client_get(&req->rq_pill, &RMF_FID_ARRAY);
memcpy(tmp, fa->fa_fids, flen);
- mdc_pack_body(req, NULL, 0, 0, -1, 0);
+ mdc_pack_body(&req->rq_pill, NULL, 0, 0, -1, 0);
b = req_capsule_client_get(&req->rq_pill, &RMF_MDT_BODY);
b->mbo_ctime = ktime_get_real_seconds();
tgt_name(tsi->tsi_tgt), vallen);
RETURN(-EINVAL);
}
- if (ptlrpc_req_need_swab(req)) {
+ if (req_capsule_req_need_swab(&req->rq_pill)) {
__swab64s(&cs->cs_recno);
__swab32s(&cs->cs_id);
}
fpin = key + cfs_size_round(sizeof(KEY_FID2PATH));
fpout = val;
- if (ptlrpc_req_need_swab(info->mti_pill->rc_req))
+ if (req_capsule_req_need_swab(info->mti_pill))
lustre_swab_fid2path(fpin);
memcpy(fpout, fpin, sizeof(*fpin));
sizeof(struct lu_fid)) {
/* client sent its root FID, which is normally fileset FID */
root_fid = fpin->gf_u.gf_root_fid;
- if (ptlrpc_req_need_swab(info->mti_pill->rc_req))
+ if (req_capsule_req_need_swab(info->mti_pill))
lustre_swab_lu_fid(root_fid);
if (root_fid != NULL && !fid_is_sane(root_fid))
/* cookie doesn't need to be swapped but it has been swapped
* in lustre_swab_mdt_rec_reint() as rr_mtime, so here it needs
* restoring. */
- if (ptlrpc_req_need_swab(mdt_info_req(info)))
+ if (req_capsule_req_need_swab(pill))
__swab64s(&rec->rs_lease_handle.cookie);
rr->rr_lease_handle = &rec->rs_lease_handle;
if (data == NULL)
RETURN(-EPROTO);
- if (ptlrpc_req_need_swab(mdt_info_req(info)))
+ if (req_capsule_req_need_swab(info->mti_pill))
lustre_swab_close_data_resync_done(&data->cd_resync);
if (!fid_is_zero(&data->cd_fid))
GOTO(out, rc);
}
- mne_swab = ptlrpc_rep_need_swab(req);
+ mne_swab = req_capsule_rep_need_swab(&req->rq_pill);
/* When a nodemap config is received, we build a new nodemap config,
* with new nodemap structs. We keep track of the most recently added
}
fid = lbuf->lb_buf;
- if (ptlrpc_rep_need_swab(req))
+ if (req_capsule_rep_need_swab(&req->rq_pill))
lustre_swab_lu_fid(fid);
if (!fid_is_sane(fid)) {
CERROR("%s: lookup "DFID" %s invalid fid "DFID"\n",
return -EPROTO;
LASSERT(req != NULL);
- if (ptlrpc_req_need_swab(req))
+ if (req_capsule_req_need_swab(&req->rq_pill))
lustre_swab_obdo(wobdo);
lustre_get_wire_obdo(NULL, lobdo, wobdo);
it->ooi_rec_size = ii->ii_recsize;
it->ooi_valid_npages = npages;
- if (ptlrpc_rep_need_swab(req))
+ if (req_capsule_rep_need_swab(&req->rq_pill))
it->ooi_swab = 1;
it->ooi_next = ii->ii_hash_end;
goto out_copy;
}
- LASSERT(req->rq_repdata);
- lsize = ctx_init_parse_reply(req->rq_repdata,
- ptlrpc_rep_need_swab(req),
- param.reply_buf, param.reply_buf_size);
- if (lsize < 0) {
- param.status = (int) lsize;
- goto out_copy;
- }
+ LASSERT(req->rq_repdata);
+ lsize = ctx_init_parse_reply(req->rq_repdata,
+ req_capsule_rep_need_swab(&req->rq_pill),
+ param.reply_buf, param.reply_buf_size);
+ if (lsize < 0) {
+ param.status = (int) lsize;
+ goto out_copy;
+ }
param.status = 0;
param.reply_length = lsize;
RETURN(-EPROTO);
}
- swabbed = ptlrpc_rep_need_swab(req);
+ swabbed = req_capsule_rep_need_swab(&req->rq_pill);
ghdr = gss_swab_header(msg, 0, swabbed);
if (ghdr == NULL) {
LASSERT(req->rq_ctx_init == 0);
LASSERT(msg);
- gctx = container_of(ctx, struct gss_cli_ctx, gc_base);
- swabbed = ptlrpc_rep_need_swab(req);
+ gctx = container_of(ctx, struct gss_cli_ctx, gc_base);
+ swabbed = req_capsule_rep_need_swab(&req->rq_pill);
ghdr = gss_swab_header(msg, 0, swabbed);
if (ghdr == NULL) {
RETURN(SECSVC_DROP);
}
- swabbed = ptlrpc_req_need_swab(req);
+ swabbed = req_capsule_req_need_swab(&req->rq_pill);
/* ctx initiate payload is in last segment */
secdata = lustre_msg_buf(reqbuf, reqbuf->lm_bufcount - 1, 0);
}
verified:
- swabbed = ptlrpc_req_need_swab(req);
+ swabbed = req_capsule_req_need_swab(&req->rq_pill);
/* user descriptor */
if (gw->gw_flags & LUSTRE_GSS_PACK_USER) {
RETURN(SECSVC_OK);
}
if (sptlrpc_unpack_user_desc(req->rq_reqbuf, 2,
- ptlrpc_req_need_swab(req))) {
+ req_capsule_req_need_swab(&req->rq_pill))) {
CERROR("Mal-formed user descriptor, ignore it\n");
RETURN(SECSVC_OK);
}
RETURN(SECSVC_DROP);
}
- swabbed = ptlrpc_req_need_swab(req);
+ swabbed = req_capsule_req_need_swab(&req->rq_pill);
ghdr = gss_swab_header(req->rq_reqbuf, 0, swabbed);
if (ghdr == NULL) {
if (req != NULL && pill == &req->rq_pill && req->rq_pill_init)
return;
- memset(pill, 0, sizeof *pill);
+ pill->rc_fmt = NULL;
pill->rc_req = req;
pill->rc_loc = location;
- req_capsule_init_area(pill);
+ req_capsule_init_area(pill);
- if (req != NULL && pill == &req->rq_pill)
- req->rq_pill_init = 1;
+ if (req != NULL && pill == &req->rq_pill)
+ req->rq_pill_init = 1;
}
EXPORT_SYMBOL(req_capsule_init);
static struct lustre_msg *__req_msg(const struct req_capsule *pill,
enum req_location loc)
{
- struct ptlrpc_request *req;
-
- req = pill->rc_req;
- return loc == RCL_CLIENT ? req->rq_reqmsg : req->rq_repmsg;
+ return loc == RCL_CLIENT ? pill->rc_reqmsg : pill->rc_repmsg;
}
/**
return offset;
}
+void req_capsule_set_swabbed(struct req_capsule *pill, enum req_location loc,
+ __u32 index)
+{
+ if (loc == RCL_CLIENT)
+ req_capsule_set_req_swabbed(pill, index);
+ else
+ req_capsule_set_rep_swabbed(pill, index);
+}
+
+bool req_capsule_need_swab(struct req_capsule *pill, enum req_location loc,
+ __u32 index)
+{
+ if (loc == RCL_CLIENT)
+ return (req_capsule_req_need_swab(pill) &&
+ !req_capsule_req_swabbed(pill, index));
+
+ return (req_capsule_rep_need_swab(pill) &&
+ !req_capsule_rep_swabbed(pill, index));
+}
+
/**
* Helper for __req_capsule_get(); swabs value / array of values and/or dumps
* them if desired.
int size;
int rc = 0;
bool do_swab;
- bool inout = loc == RCL_CLIENT;
bool array = field->rmf_flags & RMF_F_STRUCT_ARRAY;
swabber = swabber ?: field->rmf_swabber;
- if (ptlrpc_buf_need_swab(pill->rc_req, inout, offset) &&
+ if (req_capsule_need_swab(pill, loc, offset) &&
(swabber != NULL || field->rmf_swab_len != NULL) && value != NULL)
do_swab = true;
else
}
}
if (do_swab)
- ptlrpc_buf_set_swabbed(pill->rc_req, inout, offset);
+ req_capsule_set_swabbed(pill, loc, offset);
return rc;
}
}
}
-void ptlrpc_buf_set_swabbed(struct ptlrpc_request *req, const int inout,
- __u32 index)
-{
- if (inout)
- lustre_set_req_swabbed(req, index);
- else
- lustre_set_rep_swabbed(req, index);
-}
-
-bool ptlrpc_buf_need_swab(struct ptlrpc_request *req, const int inout,
- __u32 index)
-{
- if (inout)
- return (ptlrpc_req_need_swab(req) &&
- !lustre_req_swabbed(req, index));
-
- return (ptlrpc_rep_need_swab(req) && !lustre_rep_swabbed(req, index));
-}
-
static inline int lustre_msg_check_version_v2(struct lustre_msg_v2 *msg,
enum lustre_msg_version version)
{
rc = __lustre_unpack_msg(req->rq_reqmsg, len);
if (rc == 1) {
- lustre_set_req_swabbed(req, MSG_PTLRPC_HEADER_OFF);
+ req_capsule_set_req_swabbed(&req->rq_pill,
+ MSG_PTLRPC_HEADER_OFF);
rc = 0;
}
return rc;
rc = __lustre_unpack_msg(req->rq_repmsg, len);
if (rc == 1) {
- lustre_set_rep_swabbed(req, MSG_PTLRPC_HEADER_OFF);
+ req_capsule_set_rep_swabbed(&req->rq_pill,
+ MSG_PTLRPC_HEADER_OFF);
rc = 0;
}
return rc;
}
-static inline int lustre_unpack_ptlrpc_body_v2(struct ptlrpc_request *req,
- const int inout, int offset)
+static inline int
+lustre_unpack_ptlrpc_body_v2(struct ptlrpc_request *req,
+ enum req_location loc, int offset)
{
struct ptlrpc_body *pb;
- struct lustre_msg_v2 *m = inout ? req->rq_reqmsg : req->rq_repmsg;
+ struct lustre_msg_v2 *m;
+
+ m = loc == RCL_CLIENT ? req->rq_reqmsg : req->rq_repmsg;
pb = lustre_msg_buf_v2(m, offset, sizeof(struct ptlrpc_body_v2));
if (!pb) {
CERROR("error unpacking ptlrpc body\n");
return -EFAULT;
}
- if (ptlrpc_buf_need_swab(req, inout, offset)) {
+ if (req_capsule_need_swab(&req->rq_pill, loc, offset)) {
lustre_swab_ptlrpc_body(pb);
- ptlrpc_buf_set_swabbed(req, inout, offset);
+ req_capsule_set_swabbed(&req->rq_pill, loc, offset);
}
if ((pb->pb_version & ~LUSTRE_VERSION_MASK) != PTLRPC_MSG_VERSION) {
return -EINVAL;
}
- if (!inout)
+ if (loc == RCL_SERVER)
pb->pb_status = ptlrpc_status_ntoh(pb->pb_status);
return 0;
{
switch (req->rq_reqmsg->lm_magic) {
case LUSTRE_MSG_MAGIC_V2:
- return lustre_unpack_ptlrpc_body_v2(req, 1, offset);
+ return lustre_unpack_ptlrpc_body_v2(req, RCL_CLIENT, offset);
default:
CERROR("bad lustre msg magic: %08x\n",
req->rq_reqmsg->lm_magic);
{
switch (req->rq_repmsg->lm_magic) {
case LUSTRE_MSG_MAGIC_V2:
- return lustre_unpack_ptlrpc_body_v2(req, 0, offset);
+ return lustre_unpack_ptlrpc_body_v2(req, RCL_SERVER, offset);
default:
CERROR("bad lustre msg magic: %08x\n",
req->rq_repmsg->lm_magic);
switch (req->rq_reqmsg->lm_magic) {
case LUSTRE_MSG_MAGIC_V2:
- return lustre_req_swabbed(req, MSG_PTLRPC_BODY_OFF);
+ return req_capsule_req_swabbed(&req->rq_pill,
+ MSG_PTLRPC_BODY_OFF);
default:
CERROR("bad lustre msg magic: %#08X\n",
req->rq_reqmsg->lm_magic);
switch (req->rq_repmsg->lm_magic) {
case LUSTRE_MSG_MAGIC_V2:
- return lustre_rep_swabbed(req, MSG_PTLRPC_BODY_OFF);
+ return req_capsule_rep_swabbed(&req->rq_pill,
+ MSG_PTLRPC_BODY_OFF);
default:
/* uninitialized yet */
return 0;
if (req->rq_repmsg)
rep_ok = true;
- if (ptlrpc_req_need_swab(req)) {
+ if (req_capsule_req_need_swab(&req->rq_pill)) {
req_ok = req_ok && req_ptlrpc_body_swabbed(req);
rep_ok = rep_ok && rep_ptlrpc_body_swabbed(req);
}
rc = __lustre_unpack_msg(req->rq_repdata, req->rq_repdata_len);
switch (rc) {
case 1:
- lustre_set_rep_swabbed(req, MSG_PTLRPC_HEADER_OFF);
+ req_capsule_set_rep_swabbed(&req->rq_pill,
+ MSG_PTLRPC_HEADER_OFF);
case 0:
break;
default:
rc = __lustre_unpack_msg(msg, req->rq_reqdata_len);
switch (rc) {
case 1:
- lustre_set_req_swabbed(req, MSG_PTLRPC_HEADER_OFF);
+ req_capsule_set_req_swabbed(&req->rq_pill,
+ MSG_PTLRPC_HEADER_OFF);
case 0:
break;
default:
RETURN(-EPROTO);
}
- swabbed = ptlrpc_rep_need_swab(req);
+ swabbed = req_capsule_rep_need_swab(&req->rq_pill);
phdr = lustre_msg_buf(msg, PLAIN_PACK_HDR_OFF, sizeof(*phdr));
if (phdr == NULL) {
RETURN(SECSVC_DROP);
}
- swabbed = ptlrpc_req_need_swab(req);
+ swabbed = req_capsule_req_need_swab(&req->rq_pill);
phdr = lustre_msg_buf(msg, PLAIN_PACK_HDR_OFF, sizeof(*phdr));
if (phdr == NULL) {
if (!*desc)
RETURN(-EFAULT);
- if (ptlrpc_req_need_swab(req))
+ if (req_capsule_req_need_swab(&req->rq_pill))
lustre_swab_gl_lquota_desc(*desc);
/* prepare reply */
req_ii = req_capsule_server_get(&req->rq_pill, &RMF_IDX_INFO);
*ii = *req_ii;
- *need_swab = ptlrpc_rep_need_swab(req);
+ *need_swab = req_capsule_rep_need_swab(&req->rq_pill);
EXIT;
out:
RETURN(PTR_ERR(wobdo));
}
- if (ptlrpc_req_need_swab(tsi->tsi_pill->rc_req))
+ if (req_capsule_req_need_swab(tsi->tsi_pill))
lustre_swab_obdo(wobdo);
lustre_get_wire_obdo(NULL, lobdo, wobdo);
la_from_obdo(attr, lobdo, lobdo->o_valid);
tgt_name(tsi->tsi_tgt), PTR_ERR(fid));
RETURN(PTR_ERR(fid));
}
- if (ptlrpc_req_need_swab(tsi->tsi_pill->rc_req))
+ if (req_capsule_req_need_swab(tsi->tsi_pill))
lustre_swab_lu_fid(fid);
if (!fid_is_sane(fid)) {
CERROR("%s: invalid fid "DFID": rc = %d\n",
attr->la_valid = 0;
attr->la_valid = 0;
- if (ptlrpc_req_need_swab(tsi->tsi_pill->rc_req))
+ if (req_capsule_req_need_swab(tsi->tsi_pill))
lustre_swab_obdo(wobdo);
lustre_get_wire_obdo(NULL, lobdo, wobdo);
la_from_obdo(attr, lobdo, lobdo->o_valid);
RETURN(PTR_ERR(tmp));
}
- if (ptlrpc_req_need_swab(tsi->tsi_pill->rc_req))
+ if (req_capsule_req_need_swab(tsi->tsi_pill))
__swab32s(tmp);
flag = *tmp;
RETURN(PTR_ERR(fid));
}
- if (ptlrpc_req_need_swab(tsi->tsi_pill->rc_req))
+ if (req_capsule_req_need_swab(tsi->tsi_pill))
lustre_swab_lu_fid(fid);
if (!fid_is_sane(fid)) {
RETURN(PTR_ERR(ptype));
}
- if (ptlrpc_req_need_swab(tsi->tsi_pill->rc_req))
+ if (req_capsule_req_need_swab(tsi->tsi_pill))
__swab32s(ptype);
rec->rec_fid = fid;
RETURN(PTR_ERR(tmp));
}
- if (ptlrpc_req_need_swab(tsi->tsi_pill->rc_req))
+ if (req_capsule_req_need_swab(tsi->tsi_pill))
__swab64s(tmp);
pos = *tmp;
int j;
our = update_bufs[i];
- if (ptlrpc_req_need_swab(pill->rc_req))
+ if (req_capsule_req_need_swab(pill))
lustre_swab_object_update_request(our, 0);
if (our->ourq_magic != UPDATE_REQUEST_MAGIC) {
update = object_update_request_get(our, j, NULL);
if (update == NULL)
GOTO(out, rc = err_serious(-EPROTO));
- if (ptlrpc_req_need_swab(pill->rc_req))
+ if (req_capsule_req_need_swab(pill))
lustre_swab_object_update(update);
if (!fid_is_sane(&update->ou_fid)) {
git://git.whamcloud.com / fs / lustre-release.git / commitdiff