From f75d2a1fc9b17b384bbcbc13bcb80ba10412cf29 Mon Sep 17 00:00:00 2001 From: Qian Yingjin Date: Tue, 17 Nov 2020 23:12:44 +0800 Subject: [PATCH] LU-14138 ptlrpc: move more members in PTLRPC request into pill Some data members in the data structure @ptlrpc_request can be moved into the data structure @rep_capsule: /** Request message - what client sent */ struct lustre_msg *rq_reqmsg; /** Reply message - server response */ struct lustre_msg *rq_repmsg; /** Fields that help to see if request and reply were swabbed */ __u32 rq_req_swab_mask; __u32 rq_rep_swab_mask; After these data structures are reconstructed, @rep_capsule can be more common used and it makes pack and unpack sub requests in a batch PtlRPC request for the coming batch metadata processing more easily. Signed-off-by: Qian Yingjin Change-Id: Ib6d942b79ebf1a444d63b55ad4bc94813cf947c7 Reviewed-on: https://review.whamcloud.com/40669 Tested-by: jenkins Tested-by: Maloo Reviewed-by: Alexey Lyashkov Reviewed-by: Andreas Dilger Reviewed-by: James Simmons --- lustre/include/lustre_net.h | 72 +----------------- lustre/include/lustre_req_layout.h | 76 ++++++++++++++++++- lustre/include/obd.h | 2 +- lustre/include/obd_class.h | 10 +-- lustre/llite/dcache.c | 19 ++--- lustre/llite/dir.c | 2 +- lustre/llite/file.c | 4 +- lustre/llite/llite_internal.h | 6 +- lustre/llite/llite_lib.c | 18 ++--- lustre/llite/llite_nfs.c | 2 +- lustre/llite/namei.c | 14 ++-- lustre/llite/statahead.c | 2 +- lustre/lmv/lmv_obd.c | 4 +- lustre/mdc/mdc_acl.c | 3 +- lustre/mdc/mdc_dev.c | 6 +- lustre/mdc/mdc_internal.h | 36 ++++----- lustre/mdc/mdc_lib.c | 145 ++++++++++++++++++------------------- lustre/mdc/mdc_locks.c | 10 +-- lustre/mdc/mdc_reint.c | 17 +++-- lustre/mdc/mdc_request.c | 42 +++++------ lustre/mdt/mdt_handler.c | 6 +- lustre/mdt/mdt_lib.c | 2 +- lustre/mdt/mdt_open.c | 2 +- lustre/mgc/mgc_request.c | 2 +- lustre/osp/osp_md_object.c | 2 +- lustre/osp/osp_object.c | 4 +- lustre/ptlrpc/gss/gss_cli_upcall.c | 16 ++-- lustre/ptlrpc/gss/sec_gss.c | 14 ++-- lustre/ptlrpc/layout.c | 38 +++++++--- lustre/ptlrpc/pack_generic.c | 52 +++++-------- lustre/ptlrpc/sec.c | 6 +- lustre/ptlrpc/sec_plain.c | 4 +- lustre/quota/qsd_lock.c | 2 +- lustre/quota/qsd_request.c | 2 +- lustre/target/out_handler.c | 18 ++--- 35 files changed, 335 insertions(+), 325 deletions(-) diff --git a/lustre/include/lustre_net.h b/lustre/include/lustre_net.h index 843061e..ed068b4 100644 --- a/lustre/include/lustre_net.h +++ b/lustre/include/lustre_net.h @@ -943,6 +943,10 @@ struct ptlrpc_srv_req { #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. @@ -1029,10 +1033,6 @@ struct ptlrpc_request { 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 */ @@ -1103,10 +1103,6 @@ struct ptlrpc_request { 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 */ @@ -1186,62 +1182,6 @@ static inline bool ptlrpc_nrs_req_can_move(struct ptlrpc_request *req) /** @} 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 * @@ -2308,10 +2248,6 @@ int ptlrpc_reconnect_import(struct obd_import *imp); 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); diff --git a/lustre/include/lustre_req_layout.h b/lustre/include/lustre_req_layout.h index 38fed78..57c74aa 100644 --- a/lustre/include/lustre_req_layout.h +++ b/lustre/include/lustre_req_layout.h @@ -62,9 +62,16 @@ enum req_location { 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, @@ -125,6 +132,69 @@ void req_capsule_shrink(struct req_capsule *pill, 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 diff --git a/lustre/include/obd.h b/lustre/include/obd.h index 49ab370..e4daa4c 100644 --- a/lustre/include/obd.h +++ b/lustre/include/obd.h @@ -1175,7 +1175,7 @@ struct md_ops { 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 *); diff --git a/lustre/include/obd_class.h b/lustre/include/obd_class.h index 6be7628..a1b087e 100644 --- a/lustre/include/obd_class.h +++ b/lustre/include/obd_class.h @@ -1571,10 +1571,10 @@ static inline int md_unlink(struct obd_export *exp, struct md_op_data *op_data, } 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; @@ -1582,7 +1582,7 @@ static inline int md_get_lustre_md(struct obd_export *exp, 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, diff --git a/lustre/llite/dcache.c b/lustre/llite/dcache.c index c7186c1..7116920 100644 --- a/lustre/llite/dcache.c +++ b/lustre/llite/dcache.c @@ -238,21 +238,22 @@ void ll_prune_aliases(struct inode *inode) } 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) diff --git a/lustre/llite/dir.c b/lustre/llite/dir.c index 5db622e..95fd4b2 100644 --- a/lustre/llite/dir.c +++ b/lustre/llite/dir.c @@ -511,7 +511,7 @@ static int ll_dir_setdirstripe(struct dentry *dparent, struct lmv_user_md *lump, 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); diff --git a/lustre/llite/file.c b/lustre/llite/file.c index 2a3f726..c923c83 100644 --- a/lustre/llite/file.c +++ b/lustre/llite/file.c @@ -660,7 +660,7 @@ retry: 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; @@ -4626,7 +4626,7 @@ int ll_get_fid_by_name(struct inode *parent, const char *name, *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); diff --git a/lustre/llite/llite_internal.h b/lustre/llite/llite_internal.h index 78f6b97..dc297e4 100644 --- a/lustre/llite/llite_internal.h +++ b/lustre/llite/llite_internal.h @@ -1212,8 +1212,8 @@ void ll_umount_begin(struct super_block *sb); 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); @@ -1230,7 +1230,7 @@ int ll_get_obd_name(struct inode *inode, unsigned int cmd, unsigned long arg); 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); diff --git a/lustre/llite/llite_lib.c b/lustre/llite/llite_lib.c index c11da6c..819c072 100644 --- a/lustre/llite/llite_lib.c +++ b/lustre/llite/llite_lib.c @@ -663,8 +663,8 @@ static int client_common_fill_super(struct super_block *sb, char *md, char *dt) 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); @@ -1812,8 +1812,8 @@ static int ll_md_setattr(struct dentry *dentry, struct md_op_data *op_data) 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); @@ -2859,7 +2859,7 @@ int ll_remount_fs(struct super_block *sb, int *flags, char *data) * \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; @@ -2867,7 +2867,7 @@ void ll_open_cleanup(struct super_block *sb, struct ptlrpc_request *open_req) 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 " @@ -2886,7 +2886,7 @@ void ll_open_cleanup(struct super_block *sb, struct ptlrpc_request *open_req) 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; @@ -2898,7 +2898,7 @@ int ll_prep_inode(struct inode **inode, struct ptlrpc_request *req, 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); @@ -2988,7 +2988,7 @@ out: 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; diff --git a/lustre/llite/llite_nfs.c b/lustre/llite/llite_nfs.c index 5380b37..1415cbd 100644 --- a/lustre/llite/llite_nfs.c +++ b/lustre/llite/llite_nfs.c @@ -103,7 +103,7 @@ struct inode *search_inode_for_lustre(struct super_block *sb, 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)); diff --git a/lustre/llite/namei.c b/lustre/llite/namei.c index bcfdf37..3409c16 100644 --- a/lustre/llite/namei.c +++ b/lustre/llite/namei.c @@ -661,7 +661,7 @@ static int ll_lookup_it_finish(struct ptlrpc_request *request, 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); @@ -801,7 +801,7 @@ static int ll_lookup_it_finish(struct ptlrpc_request *request, 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; @@ -1262,10 +1262,10 @@ static struct inode *ll_create_node(struct inode *dir, struct lookup_intent *it) 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); @@ -1498,7 +1498,7 @@ again: 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); diff --git a/lustre/llite/statahead.c b/lustre/llite/statahead.c index 0d2de9a..775c488 100644 --- a/lustre/llite/statahead.c +++ b/lustre/llite/statahead.c @@ -672,7 +672,7 @@ static void sa_instantiate(struct ll_statahead_info *sai, 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); diff --git a/lustre/lmv/lmv_obd.c b/lustre/lmv/lmv_obd.c index d231ed9..ed44459 100644 --- a/lustre/lmv/lmv_obd.c +++ b/lustre/lmv/lmv_obd.c @@ -3425,7 +3425,7 @@ lmv_lock_match(struct obd_export *exp, __u64 flags, } 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) { @@ -3435,7 +3435,7 @@ lmv_get_lustre_md(struct obd_export *exp, struct ptlrpc_request *req, 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) diff --git a/lustre/mdc/mdc_acl.c b/lustre/mdc/mdc_acl.c index 6814045..8126390 100644 --- a/lustre/mdc/mdc_acl.c +++ b/lustre/mdc/mdc_acl.c @@ -24,9 +24,8 @@ #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; diff --git a/lustre/mdc/mdc_dev.c b/lustre/mdc/mdc_dev.c index b23470b..970c550 100644 --- a/lustre/mdc/mdc_dev.c +++ b/lustre/mdc/mdc_dev.c @@ -578,12 +578,12 @@ static int mdc_lock_upcall(void *cookie, struct lustre_handle *lockh, } /* 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); @@ -607,7 +607,7 @@ int mdc_enqueue_fini(struct obd_export *exp, struct ptlrpc_request *req, /* 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; diff --git a/lustre/mdc/mdc_internal.h b/lustre/mdc/mdc_internal.h index 1d251fe..ab94861 100644 --- a/lustre/mdc/mdc_internal.h +++ b/lustre/mdc/mdc_internal.h @@ -36,37 +36,37 @@ 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, @@ -157,10 +157,10 @@ static inline int mdc_prep_elc_req(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; } @@ -189,7 +189,7 @@ extern struct lu_device_type mdc_device_type; 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) diff --git a/lustre/mdc/mdc_lib.c b/lustre/mdc/mdc_lib.c index b8bd169..8c3fafe 100644 --- a/lustre/mdc/mdc_lib.c +++ b/lustre/mdc/mdc_lib.c @@ -57,11 +57,10 @@ static void __mdc_pack_body(struct mdt_body *b, __u32 suppgid) 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; @@ -69,11 +68,10 @@ void mdc_swap_layouts_pack(struct ptlrpc_request *req, 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; @@ -88,7 +86,7 @@ void mdc_pack_body(struct ptlrpc_request *req, const struct lu_fid *fid, /** * 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 @@ -98,7 +96,7 @@ void mdc_pack_body(struct ptlrpc_request *req, const struct lu_fid *fid, * \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) { @@ -106,8 +104,8 @@ static void mdc_pack_name(struct ptlrpc_request *req, 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); @@ -116,12 +114,11 @@ static void mdc_pack_name(struct ptlrpc_request *req, 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; @@ -130,22 +127,22 @@ void mdc_file_secctx_pack(struct ptlrpc_request *req, const char *secctx_name, 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; @@ -154,35 +151,36 @@ void mdc_file_encctx_pack(struct ptlrpc_request *req, 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; /* !! */ @@ -192,7 +190,7 @@ void mdc_readdir_pack(struct ptlrpc_request *req, __u64 pgoff, size_t size, } /* 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) { @@ -202,7 +200,7 @@ void mdc_create_pack(struct ptlrpc_request *req, struct md_op_data *op_data, 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; @@ -227,21 +225,21 @@ void mdc_create_pack(struct ptlrpc_request *req, struct md_op_data *op_data, 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) @@ -278,7 +276,7 @@ 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) { @@ -288,7 +286,7 @@ void mdc_open_pack(struct ptlrpc_request *req, struct md_op_data *op_data, 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; @@ -309,27 +307,27 @@ void mdc_open_pack(struct ptlrpc_request *req, struct md_op_data *op_data, 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); @@ -430,7 +428,7 @@ static void mdc_ioepoch_pack(struct mdt_ioepoch *epoch, 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; @@ -438,13 +436,13 @@ void mdc_setattr_pack(struct ptlrpc_request *req, struct md_op_data *op_data, 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; @@ -456,13 +454,13 @@ void mdc_setattr_pack(struct ptlrpc_request *req, struct md_op_data *op_data, } } -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 ? @@ -478,19 +476,19 @@ void mdc_unlink_pack(struct ptlrpc_request *req, struct md_op_data *op_data) 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; @@ -504,13 +502,13 @@ void mdc_link_pack(struct ptlrpc_request *req, struct md_op_data *op_data) 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; @@ -520,7 +518,7 @@ static void mdc_close_intent_pack(struct ptlrpc_request *req, 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); @@ -547,7 +545,7 @@ static void mdc_close_intent_pack(struct ptlrpc_request *req, } 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) { @@ -555,7 +553,7 @@ static void mdc_close_intent_pack(struct ptlrpc_request *req, } } -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) { @@ -563,7 +561,7 @@ void mdc_rename_pack(struct ptlrpc_request *req, struct md_op_data *op_data, 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; @@ -578,16 +576,16 @@ void mdc_rename_pack(struct ptlrpc_request *req, struct md_op_data *op_data, 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; @@ -595,7 +593,7 @@ void mdc_migrate_pack(struct ptlrpc_request *req, struct md_op_data *op_data, 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; @@ -609,25 +607,24 @@ void mdc_migrate_pack(struct ptlrpc_request *req, struct md_op_data *op_data, 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) @@ -641,17 +638,17 @@ void mdc_getattr_pack(struct ptlrpc_request *req, __u64 valid, __u32 flags, 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); /* @@ -667,5 +664,5 @@ void mdc_close_pack(struct ptlrpc_request *req, struct md_op_data *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); } diff --git a/lustre/mdc/mdc_locks.c b/lustre/mdc/mdc_locks.c index d2c6d15..ac4574c 100644 --- a/lustre/mdc/mdc_locks.c +++ b/lustre/mdc/mdc_locks.c @@ -351,8 +351,8 @@ mdc_intent_open_pack(struct obd_export *exp, struct lookup_intent *it, 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); @@ -492,11 +492,11 @@ mdc_intent_getxattr_pack(struct obd_export *exp, struct lookup_intent *it, #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); @@ -565,7 +565,7 @@ mdc_intent_getattr_pack(struct obd_export *exp, struct lookup_intent *it, 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); diff --git a/lustre/mdc/mdc_reint.c b/lustre/mdc/mdc_reint.c index 2b923fe..1a7a270 100644 --- a/lustre/mdc/mdc_reint.c +++ b/lustre/mdc/mdc_reint.c @@ -142,7 +142,7 @@ int mdc_setattr(struct obd_export *exp, struct md_op_data *op_data, 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); @@ -232,8 +232,8 @@ rebuild: * 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); @@ -329,7 +329,7 @@ int mdc_unlink(struct obd_export *exp, struct md_op_data *op_data, 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); @@ -387,8 +387,8 @@ int mdc_link(struct obd_export *exp, struct md_op_data *op_data, 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; @@ -464,9 +464,10 @@ int mdc_rename(struct obd_export *exp, struct md_op_data *op_data, 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); diff --git a/lustre/mdc/mdc_request.c b/lustre/mdc/mdc_request.c index 439c6ae..8942e68 100644 --- a/lustre/mdc/mdc_request.c +++ b/lustre/mdc/mdc_request.c @@ -121,7 +121,7 @@ static int mdc_get_root(struct obd_export *exp, const char *fileset, 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); @@ -230,7 +230,7 @@ static int mdc_getattr(struct obd_export *exp, struct md_op_data *op_data, } 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, @@ -286,7 +286,7 @@ static int mdc_getattr_name(struct obd_export *exp, struct md_op_data *op_data, } 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); @@ -394,7 +394,8 @@ static int mdc_xattr_common(struct obd_export *exp,const struct req_format *fmt, 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) { @@ -406,7 +407,7 @@ static int mdc_xattr_common(struct obd_export *exp,const struct req_format *fmt, 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, @@ -506,12 +507,11 @@ out: 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; @@ -611,7 +611,7 @@ static int mdc_get_lustre_md(struct obd_export *exp, struct ptlrpc_request *req, * 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); } @@ -935,7 +935,7 @@ static int mdc_close(struct obd_export *exp, struct md_op_data *op_data, 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); @@ -1032,7 +1032,7 @@ restart_bulk: 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); @@ -1710,7 +1710,7 @@ static int mdc_ioc_hsm_progress(struct obd_export *exp, 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); @@ -1767,7 +1767,7 @@ static int mdc_ioc_hsm_ct_register(struct obd_import *imp, __u32 archive_count, 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); @@ -1809,7 +1809,7 @@ static int mdc_ioc_hsm_current_action(struct obd_export *exp, 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); @@ -1843,7 +1843,7 @@ static int mdc_ioc_hsm_ct_unregister(struct obd_import *imp) 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); @@ -1874,7 +1874,7 @@ static int mdc_ioc_hsm_state_get(struct obd_export *exp, 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); @@ -1915,7 +1915,7 @@ static int mdc_ioc_hsm_state_set(struct obd_export *exp, 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 */ @@ -1963,7 +1963,7 @@ static int mdc_ioc_hsm_request(struct obd_export *exp, 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); @@ -2090,7 +2090,7 @@ static int mdc_ioc_swap_layouts(struct obd_export *exp, 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); @@ -2273,7 +2273,7 @@ static int mdc_get_info_rpc(struct obd_export *exp, 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); } @@ -2542,7 +2542,7 @@ static int mdc_fsync(struct obd_export *exp, const struct lu_fid *fid, 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); @@ -2611,7 +2611,7 @@ static int mdc_rmfid(struct obd_export *exp, struct fid_array *fa, 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(); diff --git a/lustre/mdt/mdt_handler.c b/lustre/mdt/mdt_handler.c index a74ce0b..2f5d16b 100644 --- a/lustre/mdt/mdt_handler.c +++ b/lustre/mdt/mdt_handler.c @@ -2470,7 +2470,7 @@ static int mdt_set_info(struct tgt_session_info *tsi) 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); } @@ -6980,7 +6980,7 @@ static int mdt_rpc_fid2path(struct mdt_thread_info *info, void *key, int keylen, 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)); @@ -6991,7 +6991,7 @@ static int mdt_rpc_fid2path(struct mdt_thread_info *info, void *key, int keylen, 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)) diff --git a/lustre/mdt/mdt_lib.c b/lustre/mdt/mdt_lib.c index fe6c933..ca86fcb 100644 --- a/lustre/mdt/mdt_lib.c +++ b/lustre/mdt/mdt_lib.c @@ -1775,7 +1775,7 @@ static int mdt_resync_unpack(struct mdt_thread_info *info) /* 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; diff --git a/lustre/mdt/mdt_open.c b/lustre/mdt/mdt_open.c index d1392e5..f7c2d55 100644 --- a/lustre/mdt/mdt_open.c +++ b/lustre/mdt/mdt_open.c @@ -2269,7 +2269,7 @@ static int mdt_close_resync_done(struct mdt_thread_info *info, 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)) diff --git a/lustre/mgc/mgc_request.c b/lustre/mgc/mgc_request.c index e0714c3..72c52de 100644 --- a/lustre/mgc/mgc_request.c +++ b/lustre/mgc/mgc_request.c @@ -1763,7 +1763,7 @@ again: 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 diff --git a/lustre/osp/osp_md_object.c b/lustre/osp/osp_md_object.c index 6ee2c99..ac1554a 100644 --- a/lustre/osp/osp_md_object.c +++ b/lustre/osp/osp_md_object.c @@ -518,7 +518,7 @@ static int osp_md_index_lookup(const struct lu_env *env, struct dt_object *dt, } 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", diff --git a/lustre/osp/osp_object.c b/lustre/osp/osp_object.c index 0139379..7c52b7e 100644 --- a/lustre/osp/osp_object.c +++ b/lustre/osp/osp_object.c @@ -427,7 +427,7 @@ static int osp_get_attr_from_reply(const struct lu_env *env, 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); @@ -1895,7 +1895,7 @@ static int osp_it_fetch(const struct lu_env *env, struct osp_it *it) 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; diff --git a/lustre/ptlrpc/gss/gss_cli_upcall.c b/lustre/ptlrpc/gss/gss_cli_upcall.c index 356473c..04eab5a 100644 --- a/lustre/ptlrpc/gss/gss_cli_upcall.c +++ b/lustre/ptlrpc/gss/gss_cli_upcall.c @@ -345,14 +345,14 @@ int gss_do_ctx_init_rpc(char __user *buffer, unsigned long count) 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; diff --git a/lustre/ptlrpc/gss/sec_gss.c b/lustre/ptlrpc/gss/sec_gss.c index 4c801a6..6f6a978 100644 --- a/lustre/ptlrpc/gss/sec_gss.c +++ b/lustre/ptlrpc/gss/sec_gss.c @@ -760,7 +760,7 @@ int gss_cli_ctx_verify(struct ptlrpc_cli_ctx *ctx, 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) { @@ -969,8 +969,8 @@ int gss_cli_ctx_unseal(struct ptlrpc_cli_ctx *ctx, 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) { @@ -2008,7 +2008,7 @@ int gss_svc_handle_init(struct ptlrpc_request *req, 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); @@ -2134,7 +2134,7 @@ int gss_svc_verify_request(struct ptlrpc_request *req, } 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) { @@ -2333,7 +2333,7 @@ int gss_svc_handle_destroy(struct ptlrpc_request *req, 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); } @@ -2361,7 +2361,7 @@ int gss_svc_accept(struct ptlrpc_sec_policy *policy, struct ptlrpc_request *req) 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) { diff --git a/lustre/ptlrpc/layout.c b/lustre/ptlrpc/layout.c index 04ffea8..7abd631 100644 --- a/lustre/ptlrpc/layout.c +++ b/lustre/ptlrpc/layout.c @@ -1861,13 +1861,13 @@ void req_capsule_init(struct req_capsule *pill, 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); @@ -1885,10 +1885,7 @@ static int __req_format_is_sane(const struct req_format *fmt) 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; } /** @@ -1989,6 +1986,26 @@ __u32 __req_capsule_offset(const struct req_capsule *pill, 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. @@ -2006,12 +2023,11 @@ swabber_dumper_helper(struct req_capsule *pill, 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 @@ -2072,7 +2088,7 @@ swabber_dumper_helper(struct req_capsule *pill, } } if (do_swab) - ptlrpc_buf_set_swabbed(pill->rc_req, inout, offset); + req_capsule_set_swabbed(pill, loc, offset); return rc; } diff --git a/lustre/ptlrpc/pack_generic.c b/lustre/ptlrpc/pack_generic.c index bfa1d8f..58447af 100644 --- a/lustre/ptlrpc/pack_generic.c +++ b/lustre/ptlrpc/pack_generic.c @@ -70,25 +70,6 @@ __u32 lustre_msg_hdr_size(__u32 magic, __u32 count) } } -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) { @@ -661,7 +642,8 @@ int ptlrpc_unpack_req_msg(struct ptlrpc_request *req, int len) 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; @@ -673,26 +655,30 @@ int ptlrpc_unpack_rep_msg(struct ptlrpc_request *req, int len) 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) { @@ -700,7 +686,7 @@ static inline int lustre_unpack_ptlrpc_body_v2(struct ptlrpc_request *req, return -EINVAL; } - if (!inout) + if (loc == RCL_SERVER) pb->pb_status = ptlrpc_status_ntoh(pb->pb_status); return 0; @@ -710,7 +696,7 @@ int lustre_unpack_req_ptlrpc_body(struct ptlrpc_request *req, int offset) { 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); @@ -722,7 +708,7 @@ int lustre_unpack_rep_ptlrpc_body(struct ptlrpc_request *req, int offset) { 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); @@ -2747,7 +2733,8 @@ static inline int req_ptlrpc_body_swabbed(struct ptlrpc_request *req) 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); @@ -2762,7 +2749,8 @@ static inline int rep_ptlrpc_body_swabbed(struct ptlrpc_request *req) 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; @@ -2784,7 +2772,7 @@ void _debug_req(struct ptlrpc_request *req, 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); } diff --git a/lustre/ptlrpc/sec.c b/lustre/ptlrpc/sec.c index 17dcbf5..85e31a7 100644 --- a/lustre/ptlrpc/sec.c +++ b/lustre/ptlrpc/sec.c @@ -1059,7 +1059,8 @@ static int do_cli_unwrap_reply(struct ptlrpc_request *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: @@ -2231,7 +2232,8 @@ int sptlrpc_svc_unwrap_request(struct ptlrpc_request *req) 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: diff --git a/lustre/ptlrpc/sec_plain.c b/lustre/ptlrpc/sec_plain.c index 97165bb..f1141a0 100644 --- a/lustre/ptlrpc/sec_plain.c +++ b/lustre/ptlrpc/sec_plain.c @@ -223,7 +223,7 @@ int plain_ctx_verify(struct ptlrpc_cli_ctx *ctx, struct ptlrpc_request *req) 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) { @@ -749,7 +749,7 @@ static int plain_accept(struct ptlrpc_request *req) 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) { diff --git a/lustre/quota/qsd_lock.c b/lustre/quota/qsd_lock.c index 7921f0e..6bb125b 100644 --- a/lustre/quota/qsd_lock.c +++ b/lustre/quota/qsd_lock.c @@ -154,7 +154,7 @@ static int qsd_common_glimpse_ast(struct ptlrpc_request *req, 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 */ diff --git a/lustre/quota/qsd_request.c b/lustre/quota/qsd_request.c index 8f451f8..fd60cfc 100644 --- a/lustre/quota/qsd_request.c +++ b/lustre/quota/qsd_request.c @@ -425,7 +425,7 @@ int qsd_fetch_index(const struct lu_env *env, struct obd_export *exp, 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: diff --git a/lustre/target/out_handler.c b/lustre/target/out_handler.c index 448de3b..45de5bc 100644 --- a/lustre/target/out_handler.c +++ b/lustre/target/out_handler.c @@ -121,7 +121,7 @@ static int out_create(struct tgt_session_info *tsi) 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); @@ -134,7 +134,7 @@ static int out_create(struct tgt_session_info *tsi) 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", @@ -177,7 +177,7 @@ static int out_attr_set(struct tgt_session_info *tsi) 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); @@ -443,7 +443,7 @@ static int out_xattr_set(struct tgt_session_info *tsi) 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; @@ -540,7 +540,7 @@ static int out_index_insert(struct tgt_session_info *tsi) 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)) { @@ -556,7 +556,7 @@ static int out_index_insert(struct tgt_session_info *tsi) 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; @@ -657,7 +657,7 @@ static int out_write(struct tgt_session_info *tsi) 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; @@ -1054,7 +1054,7 @@ int out_handle(struct tgt_session_info *tsi) 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) { @@ -1071,7 +1071,7 @@ int out_handle(struct tgt_session_info *tsi) 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)) { -- 1.8.3.1