From fd908da92ccd9aab4ffc3d2463301831260c0474 Mon Sep 17 00:00:00 2001 From: huanghua Date: Thu, 7 Feb 2008 08:07:16 +0000 Subject: [PATCH] b=14149 i=yong.fan i=rahul.deshmukh i=nikita.danilov - use req_capsule interface for client. - add some interoperability support on server side. --- lustre/cmm/mdc_device.c | 3 +- lustre/cmm/mdc_object.c | 25 +- lustre/fid/fid_handler.c | 27 +- lustre/fid/fid_internal.h | 3 +- lustre/fid/fid_lib.c | 8 +- lustre/fid/fid_request.c | 28 +- lustre/fld/fld_handler.c | 25 +- lustre/fld/fld_internal.h | 9 +- lustre/fld/fld_request.c | 29 +- lustre/include/lu_object.h | 1 - lustre/include/lustre/lustre_idl.h | 140 +++-- lustre/include/lustre_cfg.h | 2 +- lustre/include/lustre_dlm.h | 17 +- lustre/include/lustre_mdt.h | 2 +- lustre/include/lustre_net.h | 31 +- lustre/include/lustre_req_layout.h | 127 +++-- lustre/include/obd.h | 2 +- lustre/include/obd_class.h | 5 +- lustre/ldlm/ldlm_lib.c | 104 ++-- lustre/ldlm/ldlm_lockd.c | 199 +++---- lustre/ldlm/ldlm_request.c | 264 ++++----- lustre/liblustre/dir.c | 5 +- lustre/liblustre/file.c | 27 +- lustre/liblustre/llite_lib.c | 2 +- lustre/liblustre/namei.c | 7 +- lustre/liblustre/rw.c | 12 +- lustre/liblustre/super.c | 18 +- lustre/llite/dcache.c | 14 +- lustre/llite/dir.c | 76 +-- lustre/llite/file.c | 40 +- lustre/llite/llite_internal.h | 7 +- lustre/llite/llite_lib.c | 39 +- lustre/llite/llite_nfs.c | 5 +- lustre/llite/namei.c | 55 +- lustre/llite/remote_perm.c | 5 +- lustre/llite/symlink.c | 10 +- lustre/llite/xattr.c | 19 +- lustre/lmv/lmv_intent.c | 46 +- lustre/lmv/lmv_internal.h | 9 +- lustre/lmv/lmv_obd.c | 23 +- lustre/lmv/lmv_object.c | 2 +- lustre/mdc/mdc_internal.h | 78 +-- lustre/mdc/mdc_lib.c | 303 ++++++----- lustre/mdc/mdc_locks.c | 487 +++++++++-------- lustre/mdc/mdc_reint.c | 246 ++++----- lustre/mdc/mdc_request.c | 1043 +++++++++++++++++------------------- lustre/mdd/mdd_object.c | 4 +- lustre/mds/mds_lov.c | 4 +- lustre/mdt/mdt_handler.c | 230 ++++---- lustre/mdt/mdt_idmap.c | 4 +- lustre/mdt/mdt_internal.h | 25 +- lustre/mdt/mdt_lib.c | 147 +++-- lustre/mdt/mdt_open.c | 56 +- lustre/mdt/mdt_recovery.c | 21 +- lustre/mdt/mdt_reint.c | 62 +-- lustre/mdt/mdt_xattr.c | 81 ++- lustre/mgc/mgc_request.c | 24 +- lustre/mgs/mgs_handler.c | 51 +- lustre/obdclass/obd_mount.c | 4 + lustre/obdfilter/filter.c | 8 + lustre/obdfilter/filter_lvb.c | 4 +- lustre/osc/osc_request.c | 480 ++++++++++------- lustre/ost/ost_handler.c | 28 +- lustre/ptlrpc/client.c | 169 ++++-- lustre/ptlrpc/gss/gss_cli_upcall.c | 22 +- lustre/ptlrpc/import.c | 61 ++- lustre/ptlrpc/layout.c | 767 +++++++++++++++++++++----- lustre/ptlrpc/llog_client.c | 209 ++++---- lustre/ptlrpc/llog_net.c | 35 +- lustre/ptlrpc/llog_server.c | 247 ++++----- lustre/ptlrpc/lproc_ptlrpc.c | 11 +- lustre/ptlrpc/pack_generic.c | 144 ++--- lustre/ptlrpc/pinger.c | 39 +- lustre/ptlrpc/ptlrpc_module.c | 13 +- lustre/ptlrpc/recov_thread.c | 38 +- lustre/ptlrpc/wiretest.c | 2 +- lustre/quota/quota_check.c | 33 +- lustre/quota/quota_context.c | 47 +- lustre/quota/quota_ctl.c | 23 +- lustre/utils/req-layout.c | 16 +- lustre/utils/wiretest.c | 4 +- 81 files changed, 3749 insertions(+), 2993 deletions(-) diff --git a/lustre/cmm/mdc_device.c b/lustre/cmm/mdc_device.c index 7352cd6..9ecc428 100644 --- a/lustre/cmm/mdc_device.c +++ b/lustre/cmm/mdc_device.c @@ -136,7 +136,8 @@ static int mdc_obd_add(const struct lu_env *env, OBD_CONNECT_MDS_CAPA | OBD_CONNECT_OSS_CAPA | OBD_CONNECT_IBITS | - OBD_CONNECT_MDS_MDS; + OBD_CONNECT_MDS_MDS | + OBD_CONNECT_FID; rc = obd_connect(env, conn, mdc, &mdc->obd_uuid, ocd); OBD_FREE_PTR(ocd); if (rc) { diff --git a/lustre/cmm/mdc_object.c b/lustre/cmm/mdc_object.c index fde11da..808f540 100644 --- a/lustre/cmm/mdc_object.c +++ b/lustre/cmm/mdc_object.c @@ -154,7 +154,7 @@ static int mdc_req2attr_update(const struct lu_env *env, mci = mdc_info_get(env); req = mci->mci_req; LASSERT(req); - body = lustre_msg_buf(req->rq_repmsg, REPLY_REC_OFF, sizeof(*body)); + body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY); LASSERT(body); mdc_body2attr(body, ma); @@ -162,8 +162,7 @@ static int mdc_req2attr_update(const struct lu_env *env, struct lustre_capa *capa; /* create for cross-ref will fetch mds capa from remote obj */ - capa = lustre_msg_buf(req->rq_repmsg, REPLY_REC_OFF + 1, - sizeof(*capa)); + capa = req_capsule_server_get(&req->rq_pill, &RMF_CAPA1); LASSERT(capa != NULL); LASSERT(ma->ma_capa != NULL); *ma->ma_capa = *capa; @@ -177,12 +176,10 @@ static int mdc_req2attr_update(const struct lu_env *env, RETURN(-EPROTO); } - lov = lustre_swab_repbuf(req, REPLY_REC_OFF + 1, - body->eadatasize, NULL); - if (lov == NULL) { - CERROR("Can't unpack MDS EA data\n"); + lov = req_capsule_server_sized_get(&req->rq_pill, &RMF_MDT_MD, + body->eadatasize); + if (lov == NULL) RETURN(-EPROTO); - } LASSERT(ma->ma_lmm != NULL); LASSERT(ma->ma_lmm_size >= body->eadatasize); @@ -198,12 +195,10 @@ static int mdc_req2attr_update(const struct lu_env *env, RETURN(-EPROTO); } - cookie = lustre_msg_buf(req->rq_repmsg, - REPLY_REC_OFF + 2, body->aclsize); - if (cookie == NULL) { - CERROR("Can't unpack unlink cookie data\n"); + cookie = req_capsule_server_sized_get(&req->rq_pill, &RMF_ACL, + body->aclsize); + if (cookie == NULL) RETURN(-EPROTO); - } LASSERT(ma->ma_cookie != NULL); LASSERT(ma->ma_cookie_size == body->aclsize); @@ -561,8 +556,8 @@ static int mdc_is_subdir(const struct lu_env *env, struct md_object *mo, rc = md_is_subdir(mc->mc_desc.cl_exp, lu_object_fid(&mo->mo_lu), fid, &mci->mci_req); if (rc == 0 || rc == -EREMOTE) { - body = lustre_msg_buf(mci->mci_req->rq_repmsg, REPLY_REC_OFF, - sizeof(*body)); + body = req_capsule_server_get(&mci->mci_req->rq_pill, + &RMF_MDT_BODY); LASSERT(body->valid & OBD_MD_FLID); CDEBUG(D_INFO, "Remote mdo_is_subdir(), new src "DFID"\n", diff --git a/lustre/fid/fid_handler.c b/lustre/fid/fid_handler.c index 5a576d1..73a20a7 100644 --- a/lustre/fid/fid_handler.c +++ b/lustre/fid/fid_handler.c @@ -330,20 +330,18 @@ static int seq_req_handle(struct ptlrpc_request *req, site = req->rq_export->exp_obd->obd_lu_dev->ld_site; LASSERT(site != NULL); - rc = req_capsule_pack(&info->sti_pill); + rc = req_capsule_server_pack(info->sti_pill); if (rc) RETURN(err_serious(rc)); - opc = req_capsule_client_get(&info->sti_pill, - &RMF_SEQ_OPC); + opc = req_capsule_client_get(info->sti_pill, &RMF_SEQ_OPC); if (opc != NULL) { - out = req_capsule_server_get(&info->sti_pill, - &RMF_SEQ_RANGE); + out = req_capsule_server_get(info->sti_pill, &RMF_SEQ_RANGE); if (out == NULL) RETURN(err_serious(-EPROTO)); if (lustre_msg_get_flags(req->rq_reqmsg) & MSG_REPLAY) { - in = req_capsule_client_get(&info->sti_pill, + in = req_capsule_client_get(info->sti_pill, &RMF_SEQ_RANGE); LASSERT(!range_is_zero(in) && range_is_sane(in)); @@ -365,22 +363,15 @@ LU_CONTEXT_KEY_DEFINE(seq, LCT_MD_THREAD); static void seq_thread_info_init(struct ptlrpc_request *req, struct seq_thread_info *info) { - int i; - - /* Mark rep buffer as req-layout stuff expects */ - for (i = 0; i < ARRAY_SIZE(info->sti_rep_buf_size); i++) - info->sti_rep_buf_size[i] = -1; - + info->sti_pill = &req->rq_pill; /* Init request capsule */ - req_capsule_init(&info->sti_pill, req, RCL_SERVER, - info->sti_rep_buf_size); - - req_capsule_set(&info->sti_pill, &RQF_SEQ_QUERY); + req_capsule_init(info->sti_pill, req, RCL_SERVER); + req_capsule_set(info->sti_pill, &RQF_SEQ_QUERY); } static void seq_thread_info_fini(struct seq_thread_info *info) { - req_capsule_fini(&info->sti_pill); + req_capsule_fini(info->sti_pill); } static int seq_handle(struct ptlrpc_request *req) @@ -407,7 +398,7 @@ static int seq_handle(struct ptlrpc_request *req) */ int seq_query(struct com_thread_info *info) { - return seq_handle(info->cti_pill.rc_req); + return seq_handle(info->cti_pill->rc_req); } EXPORT_SYMBOL(seq_query); diff --git a/lustre/fid/fid_internal.h b/lustre/fid/fid_internal.h index 73d5959..39f795e 100644 --- a/lustre/fid/fid_internal.h +++ b/lustre/fid/fid_internal.h @@ -37,10 +37,9 @@ #ifdef __KERNEL__ struct seq_thread_info { + struct req_capsule *sti_pill; struct txn_param sti_txn; - struct req_capsule sti_pill; struct lu_range sti_space; - int sti_rep_buf_size[REQ_MAX_FIELD_NR]; struct lu_buf sti_buf; }; diff --git a/lustre/fid/fid_lib.c b/lustre/fid/fid_lib.c index 71cd00e..cf33390 100644 --- a/lustre/fid/fid_lib.c +++ b/lustre/fid/fid_lib.c @@ -44,12 +44,12 @@ #include /* - * Sequence space, starts from 0x400 to have first 0x400 sequences used for - * special purposes. This means that if we have seq-with 10000 fids, we have - * ~10M fids reserved for special purposes (igifs, etc.). + * Sequence space, starts from 0x100000000ULL to have first 0x100000000ULL + * sequences used for special purposes. + * Those fids are reserved for special purposes (igifs, etc.). */ const struct lu_range LUSTRE_SEQ_SPACE_RANGE = { - (0x400), + (0x100000000ULL), ((__u64)~0ULL) }; EXPORT_SYMBOL(LUSTRE_SEQ_SPACE_RANGE); diff --git a/lustre/fid/fid_request.c b/lustre/fid/fid_request.c index 5c40363..3910422 100644 --- a/lustre/fid/fid_request.c +++ b/lustre/fid/fid_request.c @@ -53,37 +53,30 @@ static int seq_client_rpc(struct lu_client_seq *seq, struct lu_range *input, struct lu_range *output, __u32 opc, const char *opcname) { - int rc, size[3] = { sizeof(struct ptlrpc_body), - sizeof(__u32), - sizeof(struct lu_range) }; - struct obd_export *exp = seq->lcs_exp; + struct obd_export *exp = seq->lcs_exp; struct ptlrpc_request *req; - struct lu_range *out, *in; - struct req_capsule pill; - __u32 *op; + struct lu_range *out, *in; + __u32 *op; + int rc; ENTRY; - req = ptlrpc_prep_req(class_exp2cliimp(exp), LUSTRE_MDS_VERSION, - SEQ_QUERY, 3, size, NULL); + req = ptlrpc_request_alloc_pack(class_exp2cliimp(exp), &RQF_SEQ_QUERY, + LUSTRE_MDS_VERSION, SEQ_QUERY); if (req == NULL) RETURN(-ENOMEM); - req_capsule_init(&pill, req, RCL_CLIENT, NULL); - req_capsule_set(&pill, &RQF_SEQ_QUERY); - /* Init operation code */ - op = req_capsule_client_get(&pill, &RMF_SEQ_OPC); + op = req_capsule_client_get(&req->rq_pill, &RMF_SEQ_OPC); *op = opc; /* Zero out input range, this is not recovery yet. */ - in = req_capsule_client_get(&pill, &RMF_SEQ_RANGE); + in = req_capsule_client_get(&req->rq_pill, &RMF_SEQ_RANGE); if (input != NULL) *in = *input; else range_zero(in); - size[1] = sizeof(struct lu_range); - ptlrpc_req_set_repsize(req, 2, size); + ptlrpc_request_set_replen(req); if (seq->lcs_type == LUSTRE_SEQ_METADATA) { req->rq_request_portal = (opc == SEQ_ALLOC_SUPER) ? @@ -100,7 +93,7 @@ static int seq_client_rpc(struct lu_client_seq *seq, struct lu_range *input, if (rc) GOTO(out_req, rc); - out = req_capsule_server_get(&pill, &RMF_SEQ_RANGE); + out = req_capsule_server_get(&req->rq_pill, &RMF_SEQ_RANGE); *output = *out; if (!range_is_sane(output)) { @@ -121,7 +114,6 @@ static int seq_client_rpc(struct lu_client_seq *seq, struct lu_range *input, EXIT; out_req: - req_capsule_fini(&pill); ptlrpc_req_finished(req); return rc; } diff --git a/lustre/fld/fld_handler.c b/lustre/fld/fld_handler.c index 00c9d12..b60e11a 100644 --- a/lustre/fld/fld_handler.c +++ b/lustre/fld/fld_handler.c @@ -200,16 +200,16 @@ static int fld_req_handle(struct ptlrpc_request *req, site = req->rq_export->exp_obd->obd_lu_dev->ld_site; - rc = req_capsule_pack(&info->fti_pill); + rc = req_capsule_server_pack(info->fti_pill); if (rc) RETURN(err_serious(rc)); - opc = req_capsule_client_get(&info->fti_pill, &RMF_FLD_OPC); + opc = req_capsule_client_get(info->fti_pill, &RMF_FLD_OPC); if (opc != NULL) { - in = req_capsule_client_get(&info->fti_pill, &RMF_FLD_MDFLD); + in = req_capsule_client_get(info->fti_pill, &RMF_FLD_MDFLD); if (in == NULL) RETURN(err_serious(-EPROTO)); - out = req_capsule_server_get(&info->fti_pill, &RMF_FLD_MDFLD); + out = req_capsule_server_get(info->fti_pill, &RMF_FLD_MDFLD); if (out == NULL) RETURN(err_serious(-EPROTO)); *out = *in; @@ -226,24 +226,17 @@ static int fld_req_handle(struct ptlrpc_request *req, static void fld_thread_info_init(struct ptlrpc_request *req, struct fld_thread_info *info) { - int i; - info->fti_flags = lustre_msg_get_flags(req->rq_reqmsg); - /* Mark rep buffer as req-layout stuff expects. */ - for (i = 0; i < ARRAY_SIZE(info->fti_rep_buf_size); i++) - info->fti_rep_buf_size[i] = -1; - + info->fti_pill = &req->rq_pill; /* Init request capsule. */ - req_capsule_init(&info->fti_pill, req, RCL_SERVER, - info->fti_rep_buf_size); - - req_capsule_set(&info->fti_pill, &RQF_FLD_QUERY); + req_capsule_init(info->fti_pill, req, RCL_SERVER); + req_capsule_set(info->fti_pill, &RQF_FLD_QUERY); } static void fld_thread_info_fini(struct fld_thread_info *info) { - req_capsule_fini(&info->fti_pill); + req_capsule_fini(info->fti_pill); } static int fld_handle(struct ptlrpc_request *req) @@ -270,7 +263,7 @@ static int fld_handle(struct ptlrpc_request *req) */ int fld_query(struct com_thread_info *info) { - return fld_handle(info->cti_pill.rc_req); + return fld_handle(info->cti_pill->rc_req); } EXPORT_SYMBOL(fld_query); diff --git a/lustre/fld/fld_internal.h b/lustre/fld/fld_internal.h index 421b5c9..4fbd6c2 100644 --- a/lustre/fld/fld_internal.h +++ b/lustre/fld/fld_internal.h @@ -78,11 +78,10 @@ extern struct lu_fld_hash fld_hash[]; #ifdef __KERNEL__ struct fld_thread_info { - struct req_capsule fti_pill; - int fti_rep_buf_size[REQ_MAX_FIELD_NR]; - __u64 fti_key; - __u64 fti_rec; - __u32 fti_flags; + struct req_capsule *fti_pill; + __u64 fti_key; + __u64 fti_rec; + __u32 fti_flags; }; int fld_index_init(struct lu_server_fld *fld, diff --git a/lustre/fld/fld_request.c b/lustre/fld/fld_request.c index ba57d51f..8a6a186 100644 --- a/lustre/fld/fld_request.c +++ b/lustre/fld/fld_request.c @@ -435,36 +435,26 @@ EXPORT_SYMBOL(fld_client_fini); static int fld_client_rpc(struct obd_export *exp, struct md_fld *mf, __u32 fld_op) { - int size[3] = { sizeof(struct ptlrpc_body), - sizeof(__u32), - sizeof(struct md_fld) }; struct ptlrpc_request *req; - struct req_capsule pill; - struct md_fld *pmf; - __u32 *op; - int rc; + struct md_fld *pmf; + __u32 *op; + int rc; ENTRY; LASSERT(exp != NULL); - req = ptlrpc_prep_req(class_exp2cliimp(exp), - LUSTRE_MDS_VERSION, - FLD_QUERY, 3, size, - NULL); + req = ptlrpc_request_alloc_pack(class_exp2cliimp(exp), &RQF_FLD_QUERY, + LUSTRE_MDS_VERSION, FLD_QUERY); if (req == NULL) RETURN(-ENOMEM); - req_capsule_init(&pill, req, RCL_CLIENT, NULL); - req_capsule_set(&pill, &RQF_FLD_QUERY); - - op = req_capsule_client_get(&pill, &RMF_FLD_OPC); + op = req_capsule_client_get(&req->rq_pill, &RMF_FLD_OPC); *op = fld_op; - pmf = req_capsule_client_get(&pill, &RMF_FLD_MDFLD); + pmf = req_capsule_client_get(&req->rq_pill, &RMF_FLD_MDFLD); *pmf = *mf; - size[1] = sizeof(struct md_fld); - ptlrpc_req_set_repsize(req, 2, size); + ptlrpc_request_set_replen(req); req->rq_request_portal = FLD_REQUEST_PORTAL; if (fld_op != FLD_LOOKUP) @@ -477,13 +467,12 @@ static int fld_client_rpc(struct obd_export *exp, if (rc) GOTO(out_req, rc); - pmf = req_capsule_server_get(&pill, &RMF_FLD_MDFLD); + pmf = req_capsule_server_get(&req->rq_pill, &RMF_FLD_MDFLD); if (pmf == NULL) GOTO(out_req, rc = -EFAULT); *mf = *pmf; EXIT; out_req: - req_capsule_fini(&pill); ptlrpc_req_finished(req); return rc; } diff --git a/lustre/include/lu_object.h b/lustre/include/lu_object.h index 50d7de4..e472e0d 100644 --- a/lustre/include/lu_object.h +++ b/lustre/include/lu_object.h @@ -376,7 +376,6 @@ struct lu_attr { __u64 la_valid; /* valid bits */ }; - /* * Layer in the layered object. */ diff --git a/lustre/include/lustre/lustre_idl.h b/lustre/include/lustre/lustre_idl.h index c877670d..6b2bf7c 100644 --- a/lustre/include/lustre/lustre_idl.h +++ b/lustre/include/lustre/lustre_idl.h @@ -549,6 +549,7 @@ extern void lustre_swab_ptlrpc_body(struct ptlrpc_body *pb); #define OBD_CONNECT_LRU_RESIZE 0x02000000ULL /* Lru resize feature. */ #define OBD_CONNECT_MDS_MDS 0x04000000ULL /* MDS-MDS connection*/ #define OBD_CONNECT_REAL 0x08000000ULL /* real connection */ +#define OBD_CONNECT_FID 0x10000000ULL /* FID is supported by server */ #define OBD_CONNECT_CKSUM 0x20000000ULL /* support several cksum algos */ /* also update obd_connect_names[] for lprocfs_rd_connect_flags() @@ -568,15 +569,17 @@ extern void lustre_swab_ptlrpc_body(struct ptlrpc_body *pb); OBD_CONNECT_RMT_CLIENT | \ OBD_CONNECT_MDS_CAPA | OBD_CONNECT_OSS_CAPA | \ OBD_CONNECT_MDS_MDS | OBD_CONNECT_CANCELSET | \ + OBD_CONNECT_FID | \ LRU_RESIZE_CONNECT_FLAG) #define OST_CONNECT_SUPPORTED (OBD_CONNECT_SRVLOCK | OBD_CONNECT_GRANT | \ OBD_CONNECT_REQPORTAL | OBD_CONNECT_VERSION | \ OBD_CONNECT_TRUNCLOCK | OBD_CONNECT_INDEX | \ OBD_CONNECT_BRW_SIZE | OBD_CONNECT_QUOTA64 | \ OBD_CONNECT_OSS_CAPA | OBD_CONNECT_CANCELSET | \ + OBD_CONNECT_FID | \ LRU_RESIZE_CONNECT_FLAG) #define ECHO_CONNECT_SUPPORTED (0) -#define MGS_CONNECT_SUPPORTED (OBD_CONNECT_VERSION) +#define MGS_CONNECT_SUPPORTED (OBD_CONNECT_VERSION | OBD_CONNECT_FID) #define MAX_QUOTA_COUNT32 (0xffffffffULL) @@ -939,7 +942,7 @@ typedef enum { MDS_QUOTACHECK = 47, MDS_QUOTACTL = 48, MDS_GETXATTR = 49, - MDS_SETXATTR = 50, + MDS_SETXATTR = 50, /* obsolete, now it's MDS_REINT op */ MDS_WRITEPAGE = 51, MDS_IS_SUBDIR = 52, MDS_LAST_OPC @@ -958,6 +961,9 @@ typedef enum { REINT_UNLINK = 4, REINT_RENAME = 5, REINT_OPEN = 6, + REINT_SETXATTR = 7, +// REINT_CLOSE = 8, +// REINT_WRITE = 9, REINT_MAX } mds_reint_t, mdt_reint_t; @@ -1076,6 +1082,7 @@ struct mdt_body { __u64 ctime; __u64 blocks; /* XID, in the case of MDS_READPAGE */ __u64 ioepoch; + __u64 ino; /* for 1.6 compatibility */ __u32 fsuid; __u32 fsgid; __u32 capability; @@ -1085,11 +1092,13 @@ struct mdt_body { __u32 flags; /* from vfs for pin/unpin, MDS_BFLAG for close */ __u32 rdev; __u32 nlink; /* #bytes to read in the case of MDS_READPAGE */ + __u32 generation; /* for 1.6 compatibility */ __u32 suppgid; __u32 eadatasize; __u32 aclsize; __u32 max_mdsize; - __u32 max_cookiesize; /* also fix lustre_swab_mdt_body */ + __u32 max_cookiesize; + __u32 padding_4; /* also fix lustre_swab_mdt_body */ }; struct mds_body { @@ -1213,18 +1222,22 @@ struct mdt_rec_setattr { __u32 sa_fsgid; __u32 sa_cap; __u32 sa_suppgid; - __u32 sa_mode; + __u32 sa_padding_1; struct lu_fid sa_fid; __u64 sa_valid; + __u32 sa_uid; + __u32 sa_gid; __u64 sa_size; __u64 sa_blocks; __u64 sa_mtime; __u64 sa_atime; __u64 sa_ctime; - __u32 sa_uid; - __u32 sa_gid; __u32 sa_attr_flags; - __u32 sa_padding; /* also fix lustre_swab_mds_rec_setattr */ + __u32 sa_mode; + __u32 sa_padding_2; + __u32 sa_padding_3; + __u32 sa_padding_4; + __u32 sa_padding_5; }; extern void lustre_swab_mdt_rec_setattr (struct mdt_rec_setattr *sa); @@ -1349,18 +1362,21 @@ struct mdt_rec_create { __u32 cr_fsuid; __u32 cr_fsgid; __u32 cr_cap; - __u32 cr_flags; /* for use with open */ - __u32 cr_mode; - struct lustre_handle cr_old_handle; /* u64 handle in case of open replay */ + __u32 cr_suppgid1; + __u32 cr_suppgid2; struct lu_fid cr_fid1; struct lu_fid cr_fid2; + struct lustre_handle cr_old_handle; /* u64 handle in case of open replay */ __u64 cr_time; __u64 cr_rdev; __u64 cr_ioepoch; - __u32 cr_suppgid1; - __u32 cr_suppgid2; + __u64 cr_padding_1; /* pad for 64 bits*/ + __u32 cr_mode; __u32 cr_bias; - __u32 cr_padding_1; /* pad for 64 bits*/ + __u32 cr_flags; /* for use with open */ + __u32 cr_padding_2; + __u32 cr_padding_3; + __u32 cr_padding_4; }; extern void lustre_swab_mdt_rec_create (struct mdt_rec_create *cr); @@ -1393,14 +1409,18 @@ struct mdt_rec_link { struct lu_fid lk_fid1; struct lu_fid lk_fid2; __u64 lk_time; + __u64 lk_padding_1; + __u64 lk_padding_2; + __u64 lk_padding_3; + __u64 lk_padding_4; __u32 lk_bias; - __u32 lk_padding_2; /* also fix lustre_swab_mds_rec_link */ - __u32 lk_padding_3; /* also fix lustre_swab_mds_rec_link */ - __u32 lk_padding_4; /* also fix lustre_swab_mds_rec_link */ + __u32 lk_padding_5; + __u32 lk_padding_6; + __u32 lk_padding_7; + __u32 lk_padding_8; + __u32 lk_padding_9; }; -extern void lustre_swab_mdt_rec_link (struct mdt_rec_link *lk); - struct mds_rec_unlink { __u32 ul_opcode; __u32 ul_fsuid; @@ -1424,19 +1444,23 @@ struct mdt_rec_unlink { __u32 ul_fsuid; __u32 ul_fsgid; __u32 ul_cap; - __u32 ul_suppgid; - __u32 ul_mode; + __u32 ul_suppgid1; + __u32 ul_suppgid2; struct lu_fid ul_fid1; struct lu_fid ul_fid2; __u64 ul_time; + __u64 ul_padding_2; + __u64 ul_padding_3; + __u64 ul_padding_4; + __u64 ul_padding_5; __u32 ul_bias; - __u32 ul_padding_2; /* also fix lustre_swab_mds_rec_unlink */ - __u32 ul_padding_3; /* also fix lustre_swab_mds_rec_unlink */ - __u32 ul_padding_4; /* also fix lustre_swab_mds_rec_unlink */ + __u32 ul_mode; + __u32 ul_padding_6; + __u32 ul_padding_7; + __u32 ul_padding_8; + __u32 ul_padding_9; }; -extern void lustre_swab_mdt_rec_unlink (struct mdt_rec_unlink *ul); - struct mds_rec_rename { __u32 rn_opcode; __u32 rn_fsuid; @@ -1465,15 +1489,66 @@ struct mdt_rec_rename { struct lu_fid rn_fid1; struct lu_fid rn_fid2; __u64 rn_time; - __u32 rn_mode; /* cross-ref rename has mode */ + __u64 rn_padding_1; + __u64 rn_padding_2; + __u64 rn_padding_3; + __u64 rn_padding_4; __u32 rn_bias; /* some operation flags */ - __u32 rn_padding_3; /* also fix lustre_swab_mdt_rec_rename */ - __u32 rn_padding_4; /* also fix lustre_swab_mdt_rec_rename */ -}; - -extern void lustre_swab_mdt_rec_rename (struct mdt_rec_rename *rn); + __u32 rn_mode; /* cross-ref rename has mode */ + __u32 rn_padding_5; + __u32 rn_padding_6; + __u32 rn_padding_7; + __u32 rn_padding_8; +}; + +struct mdt_rec_setxattr { + __u32 sx_opcode; + __u32 sx_fsuid; + __u32 sx_fsgid; + __u32 sx_cap; + __u32 sx_suppgid1; + __u32 sx_suppgid2; + struct lu_fid sx_fid; + __u64 sx_padding_1; /* These three members are lu_fid size */ + __u32 sx_padding_2; + __u32 sx_padding_3; + __u64 sx_valid; + __u64 sx_padding_4; + __u64 sx_padding_5; + __u64 sx_padding_6; + __u64 sx_padding_7; + __u32 sx_size; + __u32 sx_flags; + __u32 sx_padding_8; + __u32 sx_padding_9; + __u32 sx_padding_10; + __u32 sx_padding_11; +}; + +struct mdt_rec_reint { + __u32 rr_opcode; + __u32 rr_fsuid; + __u32 rr_fsgid; + __u32 rr_cap; + __u32 rr_suppgid1; + __u32 rr_suppgid2; + struct lu_fid rr_fid1; + struct lu_fid rr_fid2; + __u64 rr_mtime; + __u64 rr_atime; + __u64 rr_ctime; + __u64 rr_size; + __u64 rr_blocks; + __u32 rr_bias; + __u32 rr_mode; + __u32 rr_padding_1; /* also fix lustre_swab_mdt_rec_reint */ + __u32 rr_padding_2; /* also fix lustre_swab_mdt_rec_reint */ + __u32 rr_padding_3; /* also fix lustre_swab_mdt_rec_reint */ + __u32 rr_padding_4; /* also fix lustre_swab_mdt_rec_reint */ +}; + +extern void lustre_swab_mdt_rec_reint(struct mdt_rec_reint *rr); -/* begin adding MDT by huanghua@clusterfs.com */ struct lmv_desc { __u32 ld_tgt_count; /* how many MDS's */ __u32 ld_active_tgt_count; /* how many active */ @@ -1481,7 +1556,6 @@ struct lmv_desc { }; extern void lustre_swab_lmv_desc (struct lmv_desc *ld); -/* end adding MDT by huanghua@clusterfs.com */ struct md_fld { seqno_t mf_seq; diff --git a/lustre/include/lustre_cfg.h b/lustre/include/lustre_cfg.h index 5432519..386fe3e 100644 --- a/lustre/include/lustre_cfg.h +++ b/lustre/include/lustre_cfg.h @@ -58,7 +58,7 @@ enum lcfg_command_type { LCFG_LOV_ADD_INA = 0x00ce013, LCFG_ADD_MDC = 0x00cf014, LCFG_DEL_MDC = 0x00cf015, - LCFG_SPTLRPC_CONF = 0x00cf016, + LCFG_SPTLRPC_CONF = 0x00ce016, }; struct lustre_cfg_bufs { diff --git a/lustre/include/lustre_dlm.h b/lustre/include/lustre_dlm.h index 5c59d5b..b79c0d6 100644 --- a/lustre/include/lustre_dlm.h +++ b/lustre/include/lustre_dlm.h @@ -726,13 +726,14 @@ int ldlm_cli_enqueue(struct obd_export *exp, struct ptlrpc_request **reqp, ldlm_policy_data_t *policy, int *flags, void *lvb, __u32 lvb_len, void *lvb_swabber, struct lustre_handle *lockh, int async); -struct ptlrpc_request *ldlm_prep_enqueue_req(struct obd_export *exp, - int bufcount, int *size, - struct list_head *head, int count); -struct ptlrpc_request *ldlm_prep_elc_req(struct obd_export *exp, int version, - int opc, int bufcount, int *size, - int bufoff, int canceloff, - struct list_head *cancels, int count); +int ldlm_prep_enqueue_req(struct obd_export *exp, + struct ptlrpc_request *req, + struct list_head *cancels, + int count); +int ldlm_prep_elc_req(struct obd_export *exp, + struct ptlrpc_request *req, + int version, int opc, int canceloff, + struct list_head *cancels, int count); int ldlm_handle_enqueue0(struct ldlm_namespace *ns, struct ptlrpc_request *req, const struct ldlm_request *dlm_req, const struct ldlm_callback_suite *cbs); @@ -773,7 +774,7 @@ int ldlm_cancel_resource_local(struct ldlm_resource *res, ldlm_mode_t mode, int lock_flags, int cancel_flags, void *opaque); int ldlm_cli_cancel_list(struct list_head *head, int count, - struct ptlrpc_request *req, int off, int flags); + struct ptlrpc_request *req, int flags); /* mds/handler.c */ /* This has to be here because recursive inclusion sucks. */ diff --git a/lustre/include/lustre_mdt.h b/lustre/include/lustre_mdt.h index 06ed6b18..28d6beb 100644 --- a/lustre/include/lustre_mdt.h +++ b/lustre/include/lustre_mdt.h @@ -37,7 +37,7 @@ struct com_thread_info { /* * for req-layout interface. */ - struct req_capsule cti_pill; + struct req_capsule *cti_pill; }; enum { diff --git a/lustre/include/lustre_net.h b/lustre/include/lustre_net.h index ca69a55..1a9768d 100644 --- a/lustre/include/lustre_net.h +++ b/lustre/include/lustre_net.h @@ -42,6 +42,7 @@ #include #include #include +#include /* MD flags we _always_ use */ #define PTLRPC_MD_OPTIONS 0 @@ -418,6 +419,9 @@ struct ptlrpc_request { struct ptlrpc_request_pool *rq_pool; /* Pool if request from preallocated list */ struct lu_context rq_session; + + /* request format */ + struct req_capsule rq_pill; }; static inline void ptlrpc_close_replay_seq(struct ptlrpc_request *req) @@ -771,14 +775,27 @@ void ptlrpc_free_rq_pool(struct ptlrpc_request_pool *pool); void ptlrpc_add_rqs_to_pool(struct ptlrpc_request_pool *pool, int num_rq); struct ptlrpc_request_pool *ptlrpc_init_rq_pool(int, int, void (*populate_pool)(struct ptlrpc_request_pool *, int)); +struct ptlrpc_request *ptlrpc_request_alloc(struct obd_import *imp, + const struct req_format *format); +struct ptlrpc_request *ptlrpc_request_alloc_pool(struct obd_import *imp, + struct ptlrpc_request_pool *, + const struct req_format *format); +void ptlrpc_request_free(struct ptlrpc_request *request); +int ptlrpc_request_pack(struct ptlrpc_request *request, + __u32 version, int opcode); +struct ptlrpc_request *ptlrpc_request_alloc_pack(struct obd_import *imp, + const struct req_format *format, + __u32 version, int opcode); +int ptlrpc_request_bufs_pack(struct ptlrpc_request *request, + __u32 version, int opcode, char **bufs, + struct ptlrpc_cli_ctx *ctx); struct ptlrpc_request *ptlrpc_prep_req(struct obd_import *imp, __u32 version, int opcode, int count, int *lengths, char **bufs); struct ptlrpc_request *ptlrpc_prep_req_pool(struct obd_import *imp, __u32 version, int opcode, int count, int *lengths, char **bufs, - struct ptlrpc_request_pool *pool, - struct ptlrpc_cli_ctx *ctx); + struct ptlrpc_request_pool *pool); void ptlrpc_free_req(struct ptlrpc_request *request); void ptlrpc_req_finished(struct ptlrpc_request *request); void ptlrpc_req_finished_with_imp_lock(struct ptlrpc_request *request); @@ -912,6 +929,8 @@ void lustre_msg_set_last_committed(struct lustre_msg *msg,__u64 last_committed); void lustre_msg_set_transno(struct lustre_msg *msg, __u64 transno); void lustre_msg_set_status(struct lustre_msg *msg, __u32 status); void lustre_msg_set_conn_cnt(struct lustre_msg *msg, __u32 conn_cnt); +void ptlrpc_req_set_repsize(struct ptlrpc_request *req, int count, int *sizes); +void ptlrpc_request_set_replen(struct ptlrpc_request *req); static inline void lustre_shrink_reply(struct ptlrpc_request *req, int segment, @@ -958,14 +977,6 @@ static inline int ptlrpc_req_get_repsize(struct ptlrpc_request *req) } } -static inline void -ptlrpc_req_set_repsize(struct ptlrpc_request *req, int count, int *lens) -{ - req->rq_replen = lustre_msg_size(req->rq_reqmsg->lm_magic, count, lens); - if (req->rq_reqmsg->lm_magic == LUSTRE_MSG_MAGIC_V2) - req->rq_reqmsg->lm_repsize = req->rq_replen; -} - /* ldlm/ldlm_lib.c */ int client_obd_setup(struct obd_device *obddev, struct lustre_cfg *lcfg); int client_obd_cleanup(struct obd_device *obddev); diff --git a/lustre/include/lustre_req_layout.h b/lustre/include/lustre_req_layout.h index a087e27..eb5cde5b 100644 --- a/lustre/include/lustre_req_layout.h +++ b/lustre/include/lustre_req_layout.h @@ -41,19 +41,15 @@ enum req_location { RCL_NR }; +/* Maximal number of fields (buffers) in a request message. */ +#define REQ_MAX_FIELD_NR 9 + struct req_capsule { struct ptlrpc_request *rc_req; const struct req_format *rc_fmt; __u32 rc_swabbed; enum req_location rc_loc; - int *rc_area; -}; - -enum { - /* - * Maximal number of fields (buffers) in a request message. - */ - REQ_MAX_FIELD_NR = 8 + int rc_area[RCL_NR][REQ_MAX_FIELD_NR]; }; #if !defined(__REQ_LAYOUT_USER__) @@ -62,20 +58,34 @@ enum { #include void req_capsule_init(struct req_capsule *pill, struct ptlrpc_request *req, - enum req_location location, int *area); + enum req_location location); void req_capsule_fini(struct req_capsule *pill); void req_capsule_set(struct req_capsule *pill, const struct req_format *fmt); -int req_capsule_pack(struct req_capsule *pill); +void req_capsule_init_area(struct req_capsule *pill); +int req_capsule_filled_sizes(struct req_capsule *pill, enum req_location loc); +int req_capsule_server_pack(struct req_capsule *pill); void *req_capsule_client_get(struct req_capsule *pill, const struct req_msg_field *field); +void *req_capsule_client_swab_get(struct req_capsule *pill, + const struct req_msg_field *field, + void (*swabber)(void*)); +void *req_capsule_client_sized_get(struct req_capsule *pill, + const struct req_msg_field *field, + int len); void *req_capsule_server_get(struct req_capsule *pill, const struct req_msg_field *field); +void *req_capsule_server_sized_get(struct req_capsule *pill, + const struct req_msg_field *field, + int len); +void *req_capsule_server_swab_get(struct req_capsule *pill, + const struct req_msg_field *field, + void *swabber); const void *req_capsule_other_get(struct req_capsule *pill, const struct req_msg_field *field); -void req_capsule_set_size(const struct req_capsule *pill, +void req_capsule_set_size(struct req_capsule *pill, const struct req_msg_field *field, enum req_location loc, int size); int req_capsule_get_size(const struct req_capsule *pill, @@ -89,12 +99,10 @@ int req_capsule_has_field(const struct req_capsule *pill, int req_capsule_field_present(const struct req_capsule *pill, const struct req_msg_field *field, enum req_location loc); - -int req_capsule_shrink(const struct req_capsule *pill, - const struct req_msg_field *field, - const unsigned int newlen, - const int adjust, - const int move_data); +void req_capsule_shrink(struct req_capsule *pill, + const struct req_msg_field *field, + unsigned int newlen, + enum req_location loc); int req_layout_init(void); void req_layout_fini(void); @@ -102,16 +110,29 @@ void req_layout_fini(void); /* __REQ_LAYOUT_USER__ */ #endif +extern const struct req_format RQF_OBD_PING; +extern const struct req_format RQF_SEC_CTX; +/* MGS req_format */ +extern const struct req_format RQF_MGS_TARGET_REG; +extern const struct req_format RQF_MGS_SET_INFO; +/* fid/fld req_format */ extern const struct req_format RQF_SEQ_QUERY; extern const struct req_format RQF_FLD_QUERY; -extern const struct req_format RQF_MDS_GETSTATUS; +/* MDS req_format */ +extern const struct req_format RQF_MDS_CONNECT; +extern const struct req_format RQF_MDS_DISCONNECT; extern const struct req_format RQF_MDS_STATFS; +extern const struct req_format RQF_MDS_GETSTATUS; extern const struct req_format RQF_MDS_SYNC; extern const struct req_format RQF_MDS_GETXATTR; -extern const struct req_format RQF_MDS_SETXATTR; extern const struct req_format RQF_MDS_GETATTR; +/* + * This is format of direct (non-intent) MDS_GETATTR_NAME request. + */ +extern const struct req_format RQF_MDS_GETATTR_NAME; extern const struct req_format RQF_MDS_CLOSE; extern const struct req_format RQF_MDS_PIN; +extern const struct req_format RQF_MDS_UNPIN; extern const struct req_format RQF_MDS_CONNECT; extern const struct req_format RQF_MDS_DISCONNECT; extern const struct req_format RQF_MDS_SET_INFO; @@ -119,11 +140,6 @@ extern const struct req_format RQF_MDS_READPAGE; extern const struct req_format RQF_MDS_WRITEPAGE; extern const struct req_format RQF_MDS_IS_SUBDIR; extern const struct req_format RQF_MDS_DONE_WRITING; - -/* - * This is format of direct (non-intent) MDS_GETATTR_NAME request. - */ -extern const struct req_format RQF_MDS_GETATTR_NAME; extern const struct req_format RQF_MDS_REINT; extern const struct req_format RQF_MDS_REINT_CREATE; extern const struct req_format RQF_MDS_REINT_CREATE_RMT_ACL; @@ -134,12 +150,50 @@ extern const struct req_format RQF_MDS_REINT_UNLINK; extern const struct req_format RQF_MDS_REINT_LINK; extern const struct req_format RQF_MDS_REINT_RENAME; extern const struct req_format RQF_MDS_REINT_SETATTR; +extern const struct req_format RQF_MDS_REINT_SETXATTR; +extern const struct req_format RQF_MDS_QUOTACHECK; +extern const struct req_format RQF_MDS_QUOTACTL; +extern const struct req_format RQF_MDS_QUOTA_DQACQ; +extern const struct req_format RQF_QC_CALLBACK; +/* OST req_format */ +extern const struct req_format RQF_OST_CONNECT; +extern const struct req_format RQF_OST_DISCONNECT; +extern const struct req_format RQF_OST_QUOTACHECK; +extern const struct req_format RQF_OST_QUOTACTL; +extern const struct req_format RQF_OST_GETATTR; +extern const struct req_format RQF_OST_SETATTR; +extern const struct req_format RQF_OST_CREATE; +extern const struct req_format RQF_OST_PUNCH; +extern const struct req_format RQF_OST_SYNC; +extern const struct req_format RQF_OST_DESTROY; +extern const struct req_format RQF_OST_BRW; +extern const struct req_format RQF_OST_STATFS; +extern const struct req_format RQF_OST_SET_INFO; +extern const struct req_format RQF_OST_GET_INFO; + +/* LDLM req_format */ extern const struct req_format RQF_LDLM_ENQUEUE; +extern const struct req_format RQF_LDLM_ENQUEUE_LVB; +extern const struct req_format RQF_LDLM_CONVERT; extern const struct req_format RQF_LDLM_INTENT; extern const struct req_format RQF_LDLM_INTENT_GETATTR; extern const struct req_format RQF_LDLM_INTENT_OPEN; extern const struct req_format RQF_LDLM_INTENT_CREATE; extern const struct req_format RQF_LDLM_INTENT_UNLINK; +extern const struct req_format RQF_LDLM_CANCEL; +extern const struct req_format RQF_LDLM_CALLBACK; +extern const struct req_format RQF_LDLM_CP_CALLBACK; +extern const struct req_format RQF_LDLM_BL_CALLBACK; +extern const struct req_format RQF_LDLM_GL_CALLBACK; +/* LOG req_format */ +extern const struct req_format RQF_LOG_CANCEL; +extern const struct req_format RQF_LLOG_CATINFO; +extern const struct req_format RQF_LLOG_ORIGIN_HANDLE_CREATE; +extern const struct req_format RQF_LLOG_ORIGIN_HANDLE_DESTROY; +extern const struct req_format RQF_LLOG_ORIGIN_HANDLE_NEXT_BLOCK; +extern const struct req_format RQF_LLOG_ORIGIN_HANDLE_PREV_BLOCK; +extern const struct req_format RQF_LLOG_ORIGIN_HANDLE_READ_HEADER; +extern const struct req_format RQF_LLOG_ORIGIN_CONNECT; extern const struct req_msg_field RMF_PTLRPC_BODY; extern const struct req_msg_field RMF_MDT_BODY; @@ -158,19 +212,20 @@ extern const struct req_msg_field RMF_CONN; extern const struct req_msg_field RMF_CONNECT_DATA; extern const struct req_msg_field RMF_DLM_REQ; extern const struct req_msg_field RMF_DLM_REP; +extern const struct req_msg_field RMF_DLM_LVB; extern const struct req_msg_field RMF_LDLM_INTENT; extern const struct req_msg_field RMF_MDT_MD; -extern const struct req_msg_field RMF_REC_CREATE; -extern const struct req_msg_field RMF_REC_LINK; -extern const struct req_msg_field RMF_REC_UNLINK; -extern const struct req_msg_field RMF_REC_RENAME; -extern const struct req_msg_field RMF_REC_SETATTR; +extern const struct req_msg_field RMF_REC_REINT; +extern const struct req_msg_field RMF_REC_JOINFILE; extern const struct req_msg_field RMF_EADATA; extern const struct req_msg_field RMF_ACL; extern const struct req_msg_field RMF_LOGCOOKIES; -extern const struct req_msg_field RMF_REINT_OPC; extern const struct req_msg_field RMF_CAPA1; extern const struct req_msg_field RMF_CAPA2; +extern const struct req_msg_field RMF_OBD_QUOTACHECK; +extern const struct req_msg_field RMF_OBD_QUOTACTL; +extern const struct req_msg_field RMF_QUNIT_DATA; +extern const struct req_msg_field RMF_STRING; /* seq-mgr fields */ extern const struct req_msg_field RMF_SEQ_OPC; @@ -180,4 +235,16 @@ extern const struct req_msg_field RMF_SEQ_RANGE; extern const struct req_msg_field RMF_FLD_OPC; extern const struct req_msg_field RMF_FLD_MDFLD; +extern const struct req_msg_field RMF_LLOGD_BODY; +extern const struct req_msg_field RMF_LLOG_LOG_HDR; +extern const struct req_msg_field RMF_LLOGD_CONN_BODY; + +extern const struct req_msg_field RMF_MGS_TARGET_INFO; +extern const struct req_msg_field RMF_MGS_SEND_PARAM; + +extern const struct req_msg_field RMF_OST_BODY; +extern const struct req_msg_field RMF_OBD_IOOBJ; +extern const struct req_msg_field RMF_OBD_ID; +extern const struct req_msg_field RMF_NIOBUF_REMOTE; + #endif /* _LUSTRE_REQ_LAYOUT_H__ */ diff --git a/lustre/include/obd.h b/lustre/include/obd.h index 7ef0ee7..b325680 100644 --- a/lustre/include/obd.h +++ b/lustre/include/obd.h @@ -1324,7 +1324,7 @@ struct md_ops { int (*m_init_ea_size)(struct obd_export *, int, int, int); int (*m_get_lustre_md)(struct obd_export *, struct ptlrpc_request *, - int, struct obd_export *, struct obd_export *, + struct obd_export *, struct obd_export *, struct lustre_md *); int (*m_free_lustre_md)(struct obd_export *, struct lustre_md *); diff --git a/lustre/include/obd_class.h b/lustre/include/obd_class.h index 8915c2a..f3f9c4d 100644 --- a/lustre/include/obd_class.h +++ b/lustre/include/obd_class.h @@ -1869,15 +1869,14 @@ 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, - int offset, struct obd_export *dt_exp, + struct obd_export *dt_exp, struct obd_export *md_exp, struct lustre_md *md) { ENTRY; EXP_CHECK_MD_OP(exp, get_lustre_md); EXP_MD_COUNTER_INCREMENT(exp, get_lustre_md); - RETURN(MDP(exp->exp_obd, get_lustre_md)(exp, req, offset, - dt_exp, md_exp, md)); + RETURN(MDP(exp->exp_obd, get_lustre_md)(exp, req, dt_exp, md_exp, md)); } static inline int md_free_lustre_md(struct obd_export *exp, diff --git a/lustre/ldlm/ldlm_lib.c b/lustre/ldlm/ldlm_lib.c index 197791e..923401a 100644 --- a/lustre/ldlm/ldlm_lib.c +++ b/lustre/ldlm/ldlm_lib.c @@ -575,26 +575,25 @@ int target_handle_connect(struct ptlrpc_request *req) struct obd_export *export = NULL; struct obd_import *revimp; struct lustre_handle conn; + struct lustre_handle *tmp; struct obd_uuid tgtuuid; struct obd_uuid cluuid; struct obd_uuid remote_uuid; - char *str, *tmp; + char *str; int rc = 0; int initial_conn = 0; - struct obd_connect_data *data; - int size[2] = { sizeof(struct ptlrpc_body), sizeof(*data) }; + struct obd_connect_data *data, *tmpdata; ENTRY; OBD_RACE(OBD_FAIL_TGT_CONN_RACE); - lustre_set_req_swabbed(req, REQ_REC_OFF); - str = lustre_msg_string(req->rq_reqmsg, REQ_REC_OFF, sizeof(tgtuuid)-1); + str = req_capsule_client_get(&req->rq_pill, &RMF_TGTUUID); if (str == NULL) { DEBUG_REQ(D_ERROR, req, "bad target UUID for connect"); GOTO(out, rc = -EINVAL); } - obd_str2uuid (&tgtuuid, str); + obd_str2uuid(&tgtuuid, str); target = class_uuid2obd(&tgtuuid); if (!target) target = class_name2obd(str); @@ -620,15 +619,14 @@ int target_handle_connect(struct ptlrpc_request *req) Really, class_uuid2obd should take the ref. */ targref = class_incref(target); - lustre_set_req_swabbed(req, REQ_REC_OFF + 1); - str = lustre_msg_string(req->rq_reqmsg, REQ_REC_OFF + 1, - sizeof(cluuid) - 1); + + str = req_capsule_client_get(&req->rq_pill, &RMF_CLUUID); if (str == NULL) { DEBUG_REQ(D_ERROR, req, "bad client UUID for connect"); GOTO(out, rc = -EINVAL); } - obd_str2uuid (&cluuid, str); + obd_str2uuid(&cluuid, str); /* XXX extract a nettype and format accordingly */ switch (sizeof(lnet_nid_t)) { @@ -645,19 +643,17 @@ int target_handle_connect(struct ptlrpc_request *req) LBUG(); } - tmp = lustre_msg_buf(req->rq_reqmsg, REQ_REC_OFF + 2, sizeof conn); + tmp = req_capsule_client_get(&req->rq_pill, &RMF_CONN); if (tmp == NULL) GOTO(out, rc = -EPROTO); - memcpy(&conn, tmp, sizeof conn); - - data = lustre_swab_reqbuf(req, REQ_REC_OFF + 3, sizeof(*data), - lustre_swab_connect); + conn = *tmp; + data = req_capsule_client_get(&req->rq_pill, &RMF_CONNECT_DATA); if (!data) GOTO(out, rc = -EPROTO); - rc = lustre_pack_reply(req, 2, size, NULL); + rc = req_capsule_server_pack(&req->rq_pill); if (rc) GOTO(out, rc); @@ -678,10 +674,10 @@ int target_handle_connect(struct ptlrpc_request *req) OBD_OCD_VERSION_MINOR(data->ocd_version), OBD_OCD_VERSION_PATCH(data->ocd_version), OBD_OCD_VERSION_FIX(data->ocd_version)); - data = lustre_msg_buf(req->rq_repmsg, REPLY_REC_OFF, - offsetof(typeof(*data), - ocd_version) + - sizeof(data->ocd_version)); + data = req_capsule_server_sized_get(&req->rq_pill, + &RMF_CONNECT_DATA, + offsetof(typeof(*data), ocd_version) + + sizeof(data->ocd_version)); if (data) { data->ocd_connect_flags = OBD_CONNECT_VERSION; data->ocd_version = LUSTRE_VERSION_CODE; @@ -789,13 +785,16 @@ int target_handle_connect(struct ptlrpc_request *req) if (export == NULL) { if (target->obd_recovering) { + cfs_time_t t; + + t = cfs_timer_deadline(&target->obd_recovery_timer); + t = cfs_time_sub(t, cfs_time_current()); CERROR("%s: denying connection for new client %s (%s): " "%d clients in recovery for %lds\n", target->obd_name, libcfs_nid2str(req->rq_peer.nid), cluuid.uuid, target->obd_recoverable_clients, - cfs_duration_sec(cfs_time_sub(cfs_timer_deadline(&target->obd_recovery_timer), - cfs_time_current()))); + cfs_duration_sec(t)); rc = -EBUSY; } else { dont_check_exports: @@ -810,11 +809,13 @@ dont_check_exports: GOTO(out, rc); /* Return only the parts of obd_connect_data that we understand, so the * client knows that we don't understand the rest. */ - if (data) - memcpy(lustre_msg_buf(req->rq_repmsg, REPLY_REC_OFF, - sizeof(*data)), - data, sizeof(*data)); - + if (data) { + tmpdata = req_capsule_server_get(&req->rq_pill, + &RMF_CONNECT_DATA); + //data->ocd_connect_flags &= OBD_CONNECT_SUPPORTED; + *tmpdata = *data; + } + /* If all else goes well, this is our RPC return code. */ req->rq_status = 0; @@ -901,9 +902,8 @@ dont_check_exports: wake_up(&target->obd_next_transno_waitq); } spin_unlock_bh(&target->obd_processing_task_lock); - memcpy(&conn, - lustre_msg_buf(req->rq_reqmsg, REQ_REC_OFF + 2, sizeof conn), - sizeof conn); + tmp = req_capsule_client_get(&req->rq_pill, &RMF_CONN); + conn = *tmp; if (export->exp_imp_reverse != NULL) { /* destroyed import can be still referenced in ctxt */ @@ -973,7 +973,7 @@ int target_handle_disconnect(struct ptlrpc_request *req) int rc; ENTRY; - rc = lustre_pack_reply(req, 1, NULL, NULL); + rc = req_capsule_server_pack(&req->rq_pill); if (rc) RETURN(rc); @@ -1951,7 +1951,7 @@ void target_send_reply(struct ptlrpc_request *req, int rc, int fail_id) int target_handle_ping(struct ptlrpc_request *req) { obd_ping(req->rq_export); - return lustre_pack_reply(req, 1, NULL, NULL); + return req_capsule_server_pack(&req->rq_pill); } void target_committed_to_req(struct ptlrpc_request *req) @@ -1983,12 +1983,9 @@ int target_handle_qc_callback(struct ptlrpc_request *req) struct obd_quotactl *oqctl; struct client_obd *cli = &req->rq_export->exp_obd->u.cli; - oqctl = lustre_swab_reqbuf(req, REQ_REC_OFF, sizeof(*oqctl), - lustre_swab_obd_quotactl); - if (oqctl == NULL) { - CERROR("Can't unpack obd_quotactl\n"); + oqctl = req_capsule_client_get(&req->rq_pill, &RMF_OBD_QUOTACTL); + if (oqctl == NULL) RETURN(-EPROTO); - } cli->cl_qchk_stat = oqctl->qc_stat; @@ -2005,13 +2002,13 @@ int target_handle_dqacq_callback(struct ptlrpc_request *req) void* rep; struct qunit_data_old *qdata_old; int rc = 0; - int repsize[2] = { sizeof(struct ptlrpc_body), - sizeof(struct qunit_data) }; ENTRY; - rc = lustre_pack_reply(req, 2, repsize, NULL); - if (rc) + rc = req_capsule_server_pack(&req->rq_pill); + if (rc) { + CERROR("packing reply failed!: rc = %d\n", rc); RETURN(rc); + } LASSERT(req->rq_export); @@ -2019,25 +2016,24 @@ int target_handle_dqacq_callback(struct ptlrpc_request *req) if ((req->rq_export->exp_connect_flags & OBD_CONNECT_QUOTA64) && !OBD_FAIL_CHECK(OBD_FAIL_QUOTA_QD_COUNT_32BIT)) { CDEBUG(D_QUOTA, "qd_count is 64bit!\n"); - rep = lustre_msg_buf(req->rq_repmsg, REPLY_REC_OFF, - sizeof(struct qunit_data)); + rep = req_capsule_server_get(&req->rq_pill, + &RMF_QUNIT_DATA); LASSERT(rep); - qdata = lustre_swab_reqbuf(req, REQ_REC_OFF, sizeof(*qdata), - lustre_swab_qdata); + qdata = req_capsule_client_swab_get(&req->rq_pill, + &RMF_QUNIT_DATA, + (void*)lustre_swab_qdata); } else { CDEBUG(D_QUOTA, "qd_count is 32bit!\n"); - rep = lustre_msg_buf(req->rq_repmsg, REPLY_REC_OFF, - sizeof(struct qunit_data_old)); + rep = req_capsule_server_get(&req->rq_pill, &RMF_QUNIT_DATA); LASSERT(rep); - qdata_old = lustre_swab_reqbuf(req, REQ_REC_OFF, sizeof(*qdata_old), - lustre_swab_qdata_old); + qdata_old = req_capsule_client_swab_get(&req->rq_pill, + &RMF_QUNIT_DATA, + (void*)lustre_swab_qdata_old); qdata = lustre_quota_old_to_new(qdata_old); } - if (qdata == NULL) { - CERROR("Can't unpack qunit_data\n"); + if (qdata == NULL) RETURN(-EPROTO); - } /* we use the observer */ LASSERT(obd->obd_observer && obd->obd_observer->obd_observer); @@ -2054,10 +2050,10 @@ int target_handle_dqacq_callback(struct ptlrpc_request *req) /* the qd_count might be changed in lqc_handler */ if ((req->rq_export->exp_connect_flags & OBD_CONNECT_QUOTA64) && !OBD_FAIL_CHECK(OBD_FAIL_QUOTA_QD_COUNT_32BIT)) { - memcpy(rep,qdata,sizeof(*qdata)); + memcpy(rep, qdata, sizeof(*qdata)); } else { qdata_old = lustre_quota_new_to_old(qdata); - memcpy(rep,qdata_old,sizeof(*qdata_old)); + memcpy(rep, qdata_old, sizeof(*qdata_old)); } req->rq_status = rc; rc = ptlrpc_reply(req); diff --git a/lustre/ldlm/ldlm_lockd.c b/lustre/ldlm/ldlm_lockd.c index 23cb151..8ef4562 100644 --- a/lustre/ldlm/ldlm_lockd.c +++ b/lustre/ldlm/ldlm_lockd.c @@ -583,17 +583,15 @@ int ldlm_server_blocking_ast(struct ldlm_lock *lock, void *data, int flag) { struct ldlm_cb_set_arg *arg = data; - struct ldlm_request *body; - struct ptlrpc_request *req; - int size[] = { [MSG_PTLRPC_BODY_OFF] = sizeof(struct ptlrpc_body), - [DLM_LOCKREQ_OFF] = sizeof(*body) }; - int instant_cancel = 0, rc; + struct ldlm_request *body; + struct ptlrpc_request *req; + int instant_cancel = 0; + int rc = 0; ENTRY; - if (flag == LDLM_CB_CANCELING) { + if (flag == LDLM_CB_CANCELING) /* Don't need to do anything here. */ RETURN(0); - } LASSERT(lock); LASSERT(data != NULL); @@ -602,9 +600,9 @@ int ldlm_server_blocking_ast(struct ldlm_lock *lock, ldlm_lock_dump(D_ERROR, lock, 0); } - req = ptlrpc_prep_req(lock->l_export->exp_imp_reverse, - LUSTRE_DLM_VERSION, LDLM_BL_CALLBACK, 2, size, - NULL); + req = ptlrpc_request_alloc_pack(lock->l_export->exp_imp_reverse, + &RQF_LDLM_BL_CALLBACK, + LUSTRE_DLM_VERSION, LDLM_BL_CALLBACK); if (req == NULL) RETURN(-ENOMEM); @@ -633,14 +631,14 @@ int ldlm_server_blocking_ast(struct ldlm_lock *lock, if (lock->l_flags & LDLM_FL_CANCEL_ON_BLOCK) instant_cancel = 1; - body = lustre_msg_buf(req->rq_reqmsg, DLM_LOCKREQ_OFF, sizeof(*body)); + body = req_capsule_client_get(&req->rq_pill, &RMF_DLM_REQ); body->lock_handle[0] = lock->l_remote_handle; body->lock_desc = *desc; body->lock_flags |= (lock->l_flags & LDLM_AST_FLAGS); LDLM_DEBUG(lock, "server preparing blocking AST"); - ptlrpc_req_set_repsize(req, 1, NULL); + ptlrpc_request_set_replen(req); if (instant_cancel) { unlock_res(lock->l_resource); ldlm_lock_cancel(lock); @@ -665,13 +663,12 @@ int ldlm_server_blocking_ast(struct ldlm_lock *lock, int ldlm_server_completion_ast(struct ldlm_lock *lock, int flags, void *data) { struct ldlm_cb_set_arg *arg = data; - struct ldlm_request *body; - struct ptlrpc_request *req; - struct timeval granted_time; - long total_enqueue_wait; - int size[3] = { [MSG_PTLRPC_BODY_OFF] = sizeof(struct ptlrpc_body), - [DLM_LOCKREQ_OFF] = sizeof(*body) }; - int rc, buffers = 2, instant_cancel = 0; + struct ldlm_request *body; + struct ptlrpc_request *req; + struct timeval granted_time; + long total_enqueue_wait; + int instant_cancel = 0; + int rc = 0; ENTRY; LASSERT(lock != NULL); @@ -685,34 +682,35 @@ int ldlm_server_completion_ast(struct ldlm_lock *lock, int flags, void *data) LDLM_ERROR(lock, "enqueue wait took %luus from %lu", total_enqueue_wait, lock->l_enqueued_time.tv_sec); + req = ptlrpc_request_alloc(lock->l_export->exp_imp_reverse, + &RQF_LDLM_CP_CALLBACK); + if (req == NULL) + RETURN(-ENOMEM); + lock_res_and_lock(lock); - if (lock->l_resource->lr_lvb_len) { - size[DLM_REQ_REC_OFF] = lock->l_resource->lr_lvb_len; - buffers = 3; - } + if (lock->l_resource->lr_lvb_len) + req_capsule_set_size(&req->rq_pill, &RMF_DLM_LVB, RCL_CLIENT, + lock->l_resource->lr_lvb_len); unlock_res_and_lock(lock); - req = ptlrpc_prep_req(lock->l_export->exp_imp_reverse, - LUSTRE_DLM_VERSION, LDLM_CP_CALLBACK, buffers, - size, NULL); - if (req == NULL) - RETURN(-ENOMEM); + rc = ptlrpc_request_pack(req, LUSTRE_DLM_VERSION, LDLM_CP_CALLBACK); + if (rc) { + ptlrpc_request_free(req); + RETURN(rc); + } req->rq_async_args.pointer_arg[0] = arg; req->rq_async_args.pointer_arg[1] = lock; req->rq_interpret_reply = ldlm_cb_interpret; req->rq_no_resend = 1; + body = req_capsule_client_get(&req->rq_pill, &RMF_DLM_REQ); - body = lustre_msg_buf(req->rq_reqmsg, DLM_LOCKREQ_OFF, sizeof(*body)); body->lock_handle[0] = lock->l_remote_handle; body->lock_flags = flags; ldlm_lock2desc(lock, &body->lock_desc); + if (lock->l_resource->lr_lvb_len) { + void *lvb = req_capsule_client_get(&req->rq_pill, &RMF_DLM_LVB); - if (buffers == 3) { - void *lvb; - - lvb = lustre_msg_buf(req->rq_reqmsg, DLM_REQ_REC_OFF, - lock->l_resource->lr_lvb_len); lock_res_and_lock(lock); memcpy(lvb, lock->l_resource->lr_lvb_data, lock->l_resource->lr_lvb_len); @@ -722,8 +720,7 @@ int ldlm_server_completion_ast(struct ldlm_lock *lock, int flags, void *data) LDLM_DEBUG(lock, "server preparing completion AST (after %ldus wait)", total_enqueue_wait); - ptlrpc_req_set_repsize(req, 1, NULL); - + ptlrpc_request_set_replen(req); req->rq_send_state = LUSTRE_IMP_FULL; req->rq_timeout = ldlm_get_rq_timeout(ldlm_timeout, obd_timeout); @@ -761,31 +758,32 @@ int ldlm_server_completion_ast(struct ldlm_lock *lock, int flags, void *data) int ldlm_server_glimpse_ast(struct ldlm_lock *lock, void *data) { - struct ldlm_resource *res = lock->l_resource; - struct ldlm_request *body; + struct ldlm_resource *res = lock->l_resource; + struct ldlm_request *body; struct ptlrpc_request *req; - int size[] = { [MSG_PTLRPC_BODY_OFF] = sizeof(struct ptlrpc_body), - [DLM_LOCKREQ_OFF] = sizeof(*body) }; - int rc = 0; + int rc; ENTRY; LASSERT(lock != NULL); - req = ptlrpc_prep_req(lock->l_export->exp_imp_reverse, - LUSTRE_DLM_VERSION, LDLM_GL_CALLBACK, 2, size, - NULL); + req = ptlrpc_request_alloc_pack(lock->l_export->exp_imp_reverse, + &RQF_LDLM_GL_CALLBACK, + LUSTRE_DLM_VERSION, LDLM_GL_CALLBACK); + if (req == NULL) RETURN(-ENOMEM); - body = lustre_msg_buf(req->rq_reqmsg, DLM_LOCKREQ_OFF, sizeof(*body)); + body = req_capsule_client_get(&req->rq_pill, &RMF_DLM_REQ); body->lock_handle[0] = lock->l_remote_handle; ldlm_lock2desc(lock, &body->lock_desc); lock_res_and_lock(lock); - size[REPLY_REC_OFF] = lock->l_resource->lr_lvb_len; + req_capsule_set_size(&req->rq_pill, &RMF_DLM_LVB, RCL_SERVER, + lock->l_resource->lr_lvb_len); unlock_res_and_lock(lock); res = lock->l_resource; - ptlrpc_req_set_repsize(req, 2, size); + ptlrpc_request_set_replen(req); + req->rq_send_state = LUSTRE_IMP_FULL; req->rq_timeout = ldlm_get_rq_timeout(ldlm_timeout, obd_timeout); @@ -832,7 +830,7 @@ extern unsigned long long lu_time_stamp_get(void); #define lu_time_stamp_get() time(NULL) #endif -static void ldlm_svc_get_eopc(struct ldlm_request *dlm_req, +static void ldlm_svc_get_eopc(const struct ldlm_request *dlm_req, struct lprocfs_stats *srv_stats) { int lock_type = 0, op = 0; @@ -876,13 +874,11 @@ int ldlm_handle_enqueue0(struct ldlm_namespace *ns, const struct ldlm_callback_suite *cbs) { struct ldlm_reply *dlm_rep; - int size[3] = { [MSG_PTLRPC_BODY_OFF] = sizeof(struct ptlrpc_body), - [DLM_LOCKREPLY_OFF] = sizeof(*dlm_rep) }; - int rc = 0; __u32 flags; ldlm_error_t err = ELDLM_OK; struct ldlm_lock *lock = NULL; void *cookie = NULL; + int rc = 0; ENTRY; LDLM_DEBUG_NOLOCK("server-side enqueue handler START"); @@ -991,19 +987,18 @@ existing_lock: * local_lock_enqueue by the policy function. */ cookie = req; } else { - int buffers = 2; - lock_res_and_lock(lock); if (lock->l_resource->lr_lvb_len) { - size[DLM_REPLY_REC_OFF] = lock->l_resource->lr_lvb_len; - buffers = 3; + req_capsule_set_size(&req->rq_pill, &RMF_DLM_LVB, + RCL_SERVER, + lock->l_resource->lr_lvb_len); } unlock_res_and_lock(lock); if (OBD_FAIL_CHECK(OBD_FAIL_LDLM_ENQUEUE_EXTENT_ERR)) GOTO(out, rc = -ENOMEM); - rc = lustre_pack_reply(req, buffers, size, NULL); + rc = req_capsule_server_pack(&req->rq_pill); if (rc) GOTO(out, rc); } @@ -1017,8 +1012,7 @@ existing_lock: if (err) GOTO(out, err); - dlm_rep = lustre_msg_buf(req->rq_repmsg, DLM_LOCKREPLY_OFF, - sizeof(*dlm_rep)); + dlm_rep = req_capsule_server_get(&req->rq_pill, &RMF_DLM_REP); dlm_rep->lock_flags = flags; ldlm_lock2desc(lock, &dlm_rep->lock_desc); @@ -1071,9 +1065,9 @@ existing_lock: LDLM_ERROR(lock, "sync lock"); if (dlm_req->lock_flags & LDLM_FL_HAS_INTENT) { struct ldlm_intent *it; - it = lustre_msg_buf(req->rq_reqmsg, - DLM_INTENT_IT_OFF, - sizeof(*it)); + + it = req_capsule_client_get(&req->rq_pill, + &RMF_LDLM_INTENT); if (it != NULL) { CERROR("This is intent %s ("LPU64")\n", ldlm_it2str(it->opc), it->opc); @@ -1102,16 +1096,16 @@ existing_lock: lock_res_and_lock(lock); if (rc == 0) { - size[DLM_REPLY_REC_OFF] = lock->l_resource->lr_lvb_len; - if (size[DLM_REPLY_REC_OFF] > 0) { - void *lvb = lustre_msg_buf(req->rq_repmsg, - DLM_REPLY_REC_OFF, - size[DLM_REPLY_REC_OFF]); + if (lock->l_resource->lr_lvb_len > 0) { + void *lvb; + + lvb = req_capsule_server_get(&req->rq_pill, + &RMF_DLM_LVB); LASSERTF(lvb != NULL, "req %p, lock %p\n", req, lock); memcpy(lvb, lock->l_resource->lr_lvb_data, - size[DLM_REPLY_REC_OFF]); + lock->l_resource->lr_lvb_len); } } else { ldlm_resource_unlink_lock(lock); @@ -1136,21 +1130,19 @@ int ldlm_handle_enqueue(struct ptlrpc_request *req, ldlm_blocking_callback blocking_callback, ldlm_glimpse_callback glimpse_callback) { - int rc; struct ldlm_request *dlm_req; struct ldlm_callback_suite cbs = { .lcs_completion = completion_callback, .lcs_blocking = blocking_callback, .lcs_glimpse = glimpse_callback }; + int rc; - dlm_req = lustre_swab_reqbuf(req, DLM_LOCKREQ_OFF, - sizeof *dlm_req, lustre_swab_ldlm_request); + dlm_req = req_capsule_client_get(&req->rq_pill, &RMF_DLM_REQ); if (dlm_req != NULL) { rc = ldlm_handle_enqueue0(req->rq_export->exp_obd->obd_namespace, req, dlm_req, &cbs); } else { - CERROR ("Can't unpack dlm_req\n"); rc = -EFAULT; } return rc; @@ -1162,20 +1154,17 @@ int ldlm_handle_convert0(struct ptlrpc_request *req, struct ldlm_reply *dlm_rep; struct ldlm_lock *lock; int rc; - int size[2] = { [MSG_PTLRPC_BODY_OFF] = sizeof(struct ptlrpc_body), - [DLM_LOCKREPLY_OFF] = sizeof(*dlm_rep) }; ENTRY; if (req->rq_export && req->rq_export->exp_ldlm_stats) lprocfs_counter_incr(req->rq_export->exp_ldlm_stats, LDLM_CONVERT - LDLM_FIRST_OPC); - rc = lustre_pack_reply(req, 2, size, NULL); + rc = req_capsule_server_pack(&req->rq_pill); if (rc) RETURN(rc); - dlm_rep = lustre_msg_buf(req->rq_repmsg, DLM_LOCKREPLY_OFF, - sizeof(*dlm_rep)); + dlm_rep = req_capsule_server_get(&req->rq_pill, &RMF_DLM_REP); dlm_rep->lock_flags = dlm_req->lock_flags; lock = ldlm_handle2lock(&dlm_req->lock_handle[0]); @@ -1214,8 +1203,7 @@ int ldlm_handle_convert(struct ptlrpc_request *req) int rc; struct ldlm_request *dlm_req; - dlm_req = lustre_swab_reqbuf(req, DLM_LOCKREQ_OFF, sizeof *dlm_req, - lustre_swab_ldlm_request); + dlm_req = req_capsule_client_get(&req->rq_pill, &RMF_DLM_REQ); if (dlm_req != NULL) { rc = ldlm_handle_convert0(req, dlm_req); } else { @@ -1286,10 +1274,9 @@ int ldlm_handle_cancel(struct ptlrpc_request *req) int rc; ENTRY; - dlm_req = lustre_swab_reqbuf(req, DLM_LOCKREQ_OFF, sizeof(*dlm_req), - lustre_swab_ldlm_request); + dlm_req = req_capsule_client_get(&req->rq_pill, &RMF_DLM_REQ); if (dlm_req == NULL) { - CERROR("bad request buffer for cancel\n"); + CDEBUG(D_INFO, "bad request buffer for cancel\n"); RETURN(-EFAULT); } @@ -1297,7 +1284,7 @@ int ldlm_handle_cancel(struct ptlrpc_request *req) lprocfs_counter_incr(req->rq_export->exp_ldlm_stats, LDLM_CANCEL - LDLM_FIRST_OPC); - rc = lustre_pack_reply(req, 1, NULL, NULL); + rc = req_capsule_server_pack(&req->rq_pill); if (rc) RETURN(rc); @@ -1385,13 +1372,14 @@ static void ldlm_handle_cp_callback(struct ptlrpc_request *req, } if (lock->l_lvb_len) { - void *lvb; - lvb = lustre_swab_reqbuf(req, DLM_REQ_REC_OFF, lock->l_lvb_len, - lock->l_lvb_swabber); - if (lvb == NULL) { + if (req_capsule_get_size(&req->rq_pill, &RMF_DLM_LVB, + RCL_CLIENT) < lock->l_lvb_len) { LDLM_ERROR(lock, "completion AST did not contain " "expected LVB!"); } else { + void *lvb = req_capsule_client_swab_get(&req->rq_pill, + &RMF_DLM_LVB, + (void *)lock->l_lvb_swabber); memcpy(lock->l_lvb_data, lvb, lock->l_lvb_len); } } @@ -1522,6 +1510,7 @@ int ldlm_bl_to_thread_list(struct ldlm_namespace *ns, struct ldlm_lock_desc *ld, #endif } +/* TODO: handle requests in a similar way as MDT: see mdt_handle_common() */ static int ldlm_callback_handler(struct ptlrpc_request *req) { struct ldlm_namespace *ns; @@ -1535,6 +1524,8 @@ static int ldlm_callback_handler(struct ptlrpc_request *req) * incoming request message body, but I am responsible for the * message buffers. */ + req_capsule_init(&req->rq_pill, req, RCL_SERVER); + if (req->rq_export == NULL) { struct ldlm_request *dlm_req; @@ -1545,9 +1536,8 @@ static int ldlm_callback_handler(struct ptlrpc_request *req) libcfs_id2str(req->rq_peer), lustre_msg_get_handle(req->rq_reqmsg)->cookie); - dlm_req = lustre_swab_reqbuf(req, DLM_LOCKREQ_OFF, - sizeof(*dlm_req), - lustre_swab_ldlm_request); + req_capsule_set(&req->rq_pill, &RQF_LDLM_CALLBACK); + dlm_req = req_capsule_client_get(&req->rq_pill, &RMF_DLM_REQ); if (dlm_req != NULL) CDEBUG(D_RPCTRACE, "--> lock cookie: "LPX64"\n", dlm_req->lock_handle[0].cookie); @@ -1573,12 +1563,14 @@ static int ldlm_callback_handler(struct ptlrpc_request *req) RETURN(0); break; case OBD_LOG_CANCEL: /* remove this eventually - for 1.4.0 compat */ + req_capsule_set(&req->rq_pill, &RQF_LOG_CANCEL); if (OBD_FAIL_CHECK(OBD_FAIL_OBD_LOG_CANCEL_NET)) RETURN(0); rc = llog_origin_handle_cancel(req); ldlm_callback_reply(req, rc); RETURN(0); case OBD_QC_CALLBACK: + req_capsule_set(&req->rq_pill, &RQF_QC_CALLBACK); if (OBD_FAIL_CHECK(OBD_FAIL_OBD_QC_CALLBACK_NET)) RETURN(0); rc = target_handle_qc_callback(req); @@ -1587,21 +1579,27 @@ static int ldlm_callback_handler(struct ptlrpc_request *req) case QUOTA_DQACQ: case QUOTA_DQREL: /* reply in handler */ + req_capsule_set(&req->rq_pill, &RQF_MDS_QUOTA_DQACQ); rc = target_handle_dqacq_callback(req); RETURN(0); case LLOG_ORIGIN_HANDLE_CREATE: + req_capsule_set(&req->rq_pill, &RQF_LLOG_ORIGIN_HANDLE_CREATE); if (OBD_FAIL_CHECK(OBD_FAIL_OBD_LOGD_NET)) RETURN(0); rc = llog_origin_handle_create(req); ldlm_callback_reply(req, rc); RETURN(0); case LLOG_ORIGIN_HANDLE_NEXT_BLOCK: + req_capsule_set(&req->rq_pill, + &RQF_LLOG_ORIGIN_HANDLE_NEXT_BLOCK); if (OBD_FAIL_CHECK(OBD_FAIL_OBD_LOGD_NET)) RETURN(0); rc = llog_origin_handle_next_block(req); ldlm_callback_reply(req, rc); RETURN(0); case LLOG_ORIGIN_HANDLE_READ_HEADER: + req_capsule_set(&req->rq_pill, + &RQF_LLOG_ORIGIN_HANDLE_READ_HEADER); if (OBD_FAIL_CHECK(OBD_FAIL_OBD_LOGD_NET)) RETURN(0); rc = llog_origin_handle_read_header(req); @@ -1626,12 +1624,12 @@ static int ldlm_callback_handler(struct ptlrpc_request *req) ns = req->rq_export->exp_obd->obd_namespace; LASSERT(ns != NULL); - dlm_req = lustre_swab_reqbuf(req, DLM_LOCKREQ_OFF, sizeof(*dlm_req), - lustre_swab_ldlm_request); + req_capsule_set(&req->rq_pill, &RQF_LDLM_CALLBACK); + + dlm_req = req_capsule_client_get(&req->rq_pill, &RMF_DLM_REQ); if (dlm_req == NULL) { - CERROR ("can't unpack dlm_req\n"); ldlm_callback_reply(req, -EPROTO); - RETURN (0); + RETURN(0); } lock = ldlm_handle2lock_ns(ns, &dlm_req->lock_handle[0]); @@ -1675,6 +1673,7 @@ static int ldlm_callback_handler(struct ptlrpc_request *req) switch (lustre_msg_get_opc(req->rq_reqmsg)) { case LDLM_BL_CALLBACK: CDEBUG(D_INODE, "blocking ast\n"); + req_capsule_extend(&req->rq_pill, &RQF_LDLM_BL_CALLBACK); if (!(lock->l_flags & LDLM_FL_CANCEL_ON_BLOCK)) ldlm_callback_reply(req, 0); if (ldlm_bl_to_thread_lock(ns, &dlm_req->lock_desc, lock)) @@ -1682,11 +1681,13 @@ static int ldlm_callback_handler(struct ptlrpc_request *req) break; case LDLM_CP_CALLBACK: CDEBUG(D_INODE, "completion ast\n"); + req_capsule_extend(&req->rq_pill, &RQF_LDLM_CP_CALLBACK); ldlm_callback_reply(req, 0); ldlm_handle_cp_callback(req, ns, dlm_req, lock); break; case LDLM_GL_CALLBACK: CDEBUG(D_INODE, "glimpse ast\n"); + req_capsule_extend(&req->rq_pill, &RQF_LDLM_GL_CALLBACK); ldlm_handle_gl_callback(req, ns, dlm_req, lock); break; default: @@ -1706,6 +1707,8 @@ static int ldlm_cancel_handler(struct ptlrpc_request *req) * incoming request message body, but I am responsible for the * message buffers. */ + req_capsule_init(&req->rq_pill, req, RCL_SERVER); + if (req->rq_export == NULL) { struct ldlm_request *dlm_req; @@ -1714,9 +1717,8 @@ static int ldlm_cancel_handler(struct ptlrpc_request *req) libcfs_id2str(req->rq_peer), lustre_msg_get_handle(req->rq_reqmsg)->cookie); - dlm_req = lustre_swab_reqbuf(req, DLM_LOCKREQ_OFF, - sizeof(*dlm_req), - lustre_swab_ldlm_request); + req_capsule_set(&req->rq_pill, &RQF_LDLM_CALLBACK); + dlm_req = req_capsule_client_get(&req->rq_pill, &RMF_DLM_REQ); if (dlm_req != NULL) ldlm_lock_dump_handle(D_ERROR, &dlm_req->lock_handle[0]); @@ -1728,6 +1730,7 @@ static int ldlm_cancel_handler(struct ptlrpc_request *req) /* XXX FIXME move this back to mds/handler.c, bug 249 */ case LDLM_CANCEL: + req_capsule_set(&req->rq_pill, &RQF_LDLM_CANCEL); CDEBUG(D_INODE, "cancel\n"); if (OBD_FAIL_CHECK(OBD_FAIL_LDLM_CANCEL)) RETURN(0); @@ -1736,6 +1739,7 @@ static int ldlm_cancel_handler(struct ptlrpc_request *req) break; RETURN(0); case OBD_LOG_CANCEL: + req_capsule_set(&req->rq_pill, &RQF_LOG_CANCEL); if (OBD_FAIL_CHECK(OBD_FAIL_OBD_LOG_CANCEL_NET)) RETURN(0); rc = llog_origin_handle_cancel(req); @@ -1744,6 +1748,7 @@ static int ldlm_cancel_handler(struct ptlrpc_request *req) default: CERROR("invalid opcode %d\n", lustre_msg_get_opc(req->rq_reqmsg)); + req_capsule_set(&req->rq_pill, &RQF_LDLM_CALLBACK); ldlm_callback_reply(req, -EINVAL); } @@ -1920,7 +1925,7 @@ static int ldlm_bl_thread_main(void *arg) * Thus lock is marked LDLM_FL_CANCELING, and already * canceled locally. */ ldlm_cli_cancel_list(&blwi->blwi_head, - blwi->blwi_count, NULL, 0, 0); + blwi->blwi_count, NULL, 0); } else { ldlm_handle_bl_callback(blwi->blwi_ns, &blwi->blwi_ld, blwi->blwi_lock); diff --git a/lustre/ldlm/ldlm_request.c b/lustre/ldlm/ldlm_request.c index 852cea8..7110846 100644 --- a/lustre/ldlm/ldlm_request.c +++ b/lustre/ldlm/ldlm_request.c @@ -346,19 +346,19 @@ int ldlm_cli_enqueue_fini(struct obd_export *exp, struct ptlrpc_request *req, rc == ELDLM_LOCK_ABORTED ? "ABORTED" : "FAILED"); if (rc == ELDLM_LOCK_ABORTED) { /* Before we return, swab the reply */ - reply = lustre_swab_repbuf(req, DLM_LOCKREPLY_OFF, - sizeof(*reply), - lustre_swab_ldlm_reply); - if (reply == NULL) { - CERROR("Can't unpack ldlm_reply\n"); + reply = req_capsule_server_get(&req->rq_pill, + &RMF_DLM_REP); + if (reply == NULL) rc = -EPROTO; - } if (lvb_len) { - void *tmplvb; - tmplvb = lustre_swab_repbuf(req, - DLM_REPLY_REC_OFF, - lvb_len, - lvb_swabber); + struct ost_lvb *tmplvb; + + req_capsule_set_size(&req->rq_pill, + &RMF_DLM_LVB, RCL_SERVER, + lvb_len); + tmplvb = req_capsule_server_swab_get(&req->rq_pill, + &RMF_DLM_LVB, + lvb_swabber); if (tmplvb == NULL) GOTO(cleanup, rc = -EPROTO); if (lvb != NULL) @@ -368,12 +368,9 @@ int ldlm_cli_enqueue_fini(struct obd_export *exp, struct ptlrpc_request *req, GOTO(cleanup, rc); } - reply = lustre_swab_repbuf(req, DLM_LOCKREPLY_OFF, sizeof(*reply), - lustre_swab_ldlm_reply); - if (reply == NULL) { - CERROR("Can't unpack ldlm_reply\n"); + reply = req_capsule_server_get(&req->rq_pill, &RMF_DLM_REP); + if (reply == NULL) GOTO(cleanup, rc = -EPROTO); - } /* lock enqueued on the server */ cleanup_phase = 0; @@ -447,8 +444,12 @@ int ldlm_cli_enqueue_fini(struct obd_export *exp, struct ptlrpc_request *req, * clobber the LVB with an older one. */ if (lvb_len && (lock->l_req_mode != lock->l_granted_mode)) { void *tmplvb; - tmplvb = lustre_swab_repbuf(req, DLM_REPLY_REC_OFF, lvb_len, - lvb_swabber); + + req_capsule_set_size(&req->rq_pill, &RMF_DLM_LVB, RCL_SERVER, + lvb_len); + tmplvb = req_capsule_server_swab_get(&req->rq_pill, + &RMF_DLM_LVB, + lvb_swabber); if (tmplvb == NULL) GOTO(cleanup, rc = -EPROTO); memcpy(lock->l_lvb_data, tmplvb, lvb_len); @@ -511,24 +512,25 @@ static inline int ldlm_cancel_handles_avail(struct obd_export *exp) /* Cancel lru locks and pack them into the enqueue request. Pack there the given * @count locks in @cancels. */ -struct ptlrpc_request *ldlm_prep_elc_req(struct obd_export *exp, int version, - int opc, int bufcount, int *size, - int bufoff, int canceloff, - struct list_head *cancels, int count) +int ldlm_prep_elc_req(struct obd_export *exp, struct ptlrpc_request *req, + int version, int opc, int canceloff, + struct list_head *cancels, int count) { - struct ldlm_namespace *ns = exp->exp_obd->obd_namespace; - int flags, avail, to_free, pack = 0; - struct ldlm_request *dlm = NULL; - struct ptlrpc_request *req; - CFS_LIST_HEAD(head); + struct ldlm_namespace *ns = exp->exp_obd->obd_namespace; + struct req_capsule *pill = &req->rq_pill; + struct ldlm_request *dlm = NULL; + int flags, avail, to_free, bufcount, pack = 0; + int rc; ENTRY; - if (cancels == NULL) - cancels = &head; + + LASSERT(cancels != NULL); + if (exp_connect_cancelset(exp)) { /* Estimate the amount of available space in the request. */ - avail = ldlm_req_handles_avail(exp, size, bufcount, - bufoff, canceloff); + bufcount = req_capsule_filled_sizes(pill, RCL_CLIENT); + avail = ldlm_req_handles_avail(exp, pill->rc_area[RCL_CLIENT], + bufcount, bufcount - 1, canceloff); flags = ns_connect_lru_resize(ns) ? LDLM_CANCEL_LRUR : LDLM_CANCEL_AGED; to_free = !ns_connect_lru_resize(ns) && @@ -544,14 +546,20 @@ struct ptlrpc_request *ldlm_prep_elc_req(struct obd_export *exp, int version, pack = count; else pack = avail; - size[bufoff] = ldlm_request_bufsize(pack, opc); + req_capsule_set_size(&req->rq_pill, &RMF_DLM_REQ, RCL_CLIENT, + ldlm_request_bufsize(count, opc)); } - req = ptlrpc_prep_req(class_exp2cliimp(exp), version, - opc, bufcount, size, NULL); - if (exp_connect_cancelset(exp) && req) { + + rc = ptlrpc_request_pack(req, version, opc); + if (rc) { + ldlm_lock_list_put(cancels, l_bl_ast, count); + RETURN(rc); + } + + if (exp_connect_cancelset(exp)) { if (canceloff) { - dlm = lustre_msg_buf(req->rq_reqmsg, bufoff, - sizeof(*dlm)); + dlm = req_capsule_client_get(pill, &RMF_DLM_REQ); + LASSERT(dlm); /* Skip first lock handler in ldlm_request_pack(), * this method will incrment @lock_count according * to the lock handle amount actually written to @@ -559,22 +567,21 @@ struct ptlrpc_request *ldlm_prep_elc_req(struct obd_export *exp, int version, dlm->lock_count = canceloff; } /* Pack into the request @pack lock handles. */ - ldlm_cli_cancel_list(cancels, pack, req, bufoff, 0); + ldlm_cli_cancel_list(cancels, pack, req, 0); /* Prepare and send separate cancel rpc for others. */ - ldlm_cli_cancel_list(cancels, count - pack, NULL, 0, 0); + ldlm_cli_cancel_list(cancels, count - pack, NULL, 0); } else { ldlm_lock_list_put(cancels, l_bl_ast, count); } - RETURN(req); + RETURN(0); } -struct ptlrpc_request *ldlm_prep_enqueue_req(struct obd_export *exp, - int bufcount, int *size, - struct list_head *cancels, - int count) +int ldlm_prep_enqueue_req(struct obd_export *exp, + struct ptlrpc_request *req, + struct list_head *cancels, + int count) { - return ldlm_prep_elc_req(exp, LUSTRE_DLM_VERSION, LDLM_ENQUEUE, - bufcount, size, DLM_LOCKREQ_OFF, + return ldlm_prep_elc_req(exp, req, LUSTRE_DLM_VERSION, LDLM_ENQUEUE, LDLM_ENQUEUE_CANCEL_OFF, cancels, count); } @@ -592,14 +599,11 @@ int ldlm_cli_enqueue(struct obd_export *exp, struct ptlrpc_request **reqp, struct lustre_handle *lockh, int async) { struct ldlm_namespace *ns = exp->exp_obd->obd_namespace; - struct ldlm_lock *lock; - struct ldlm_request *body; - struct ldlm_reply *reply; - int size[3] = { [MSG_PTLRPC_BODY_OFF] = sizeof(struct ptlrpc_body), - [DLM_LOCKREQ_OFF] = sizeof(*body), - [DLM_REPLY_REC_OFF] = lvb_len }; - int is_replay = *flags & LDLM_FL_REPLAY; - int req_passed_in = 1, rc, err; + struct ldlm_lock *lock; + struct ldlm_request *body; + int is_replay = *flags & LDLM_FL_REPLAY; + int req_passed_in = 1; + int rc, err; struct ptlrpc_request *req; ENTRY; @@ -646,7 +650,10 @@ int ldlm_cli_enqueue(struct obd_export *exp, struct ptlrpc_request **reqp, /* lock not sent to server yet */ if (reqp == NULL || *reqp == NULL) { - req = ldlm_prep_enqueue_req(exp, 2, size, NULL, 0); + req = ptlrpc_request_alloc_pack(class_exp2cliimp(exp), + &RQF_LDLM_ENQUEUE, + LUSTRE_DLM_VERSION, + LDLM_ENQUEUE); if (req == NULL) { failed_lock_cleanup(ns, lock, lockh, einfo->ei_mode); LDLM_LOCK_PUT(lock); @@ -656,12 +663,13 @@ int ldlm_cli_enqueue(struct obd_export *exp, struct ptlrpc_request **reqp, if (reqp) *reqp = req; } else { + int len; + req = *reqp; - LASSERTF(lustre_msg_buflen(req->rq_reqmsg, DLM_LOCKREQ_OFF) >= - sizeof(*body), "buflen[%d] = %d, not "LPSZ"\n", - DLM_LOCKREQ_OFF, - lustre_msg_buflen(req->rq_reqmsg, DLM_LOCKREQ_OFF), - sizeof(*body)); + len = req_capsule_get_size(&req->rq_pill, &RMF_DLM_REQ, + RCL_CLIENT); + LASSERTF(len >= sizeof(*body), "buflen[%d] = %d, not %d\n", + DLM_LOCKREQ_OFF, len, sizeof(*body)); } lock->l_conn_export = exp; @@ -669,15 +677,20 @@ int ldlm_cli_enqueue(struct obd_export *exp, struct ptlrpc_request **reqp, lock->l_blocking_ast = einfo->ei_cb_bl; /* Dump lock data into the request buffer */ - body = lustre_msg_buf(req->rq_reqmsg, DLM_LOCKREQ_OFF, sizeof(*body)); + body = req_capsule_client_get(&req->rq_pill, &RMF_DLM_REQ); ldlm_lock2desc(lock, &body->lock_desc); body->lock_flags = *flags; body->lock_handle[0] = *lockh; /* Continue as normal. */ if (!req_passed_in) { - size[DLM_LOCKREPLY_OFF] = sizeof(*reply); - ptlrpc_req_set_repsize(req, 2 + (lvb_len > 0), size); + if (lvb_len > 0) { + req_capsule_extend(&req->rq_pill, + &RQF_LDLM_ENQUEUE_LVB); + req_capsule_set_size(&req->rq_pill, &RMF_DLM_LVB, + RCL_SERVER, lvb_len); + } + ptlrpc_request_set_replen(req); } /* @@ -745,14 +758,12 @@ static int ldlm_cli_convert_local(struct ldlm_lock *lock, int new_mode, accounting */ int ldlm_cli_convert(struct lustre_handle *lockh, int new_mode, __u32 *flags) { - struct ldlm_request *body; - struct ldlm_reply *reply; - struct ldlm_lock *lock; - struct ldlm_resource *res; + struct ldlm_request *body; + struct ldlm_reply *reply; + struct ldlm_lock *lock; + struct ldlm_resource *res; struct ptlrpc_request *req; - int size[2] = { [MSG_PTLRPC_BODY_OFF] = sizeof(struct ptlrpc_body), - [DLM_LOCKREQ_OFF] = sizeof(*body) }; - int rc; + int rc; ENTRY; lock = ldlm_handle2lock(lockh); @@ -767,30 +778,29 @@ int ldlm_cli_convert(struct lustre_handle *lockh, int new_mode, __u32 *flags) LDLM_DEBUG(lock, "client-side convert"); - req = ptlrpc_prep_req(class_exp2cliimp(lock->l_conn_export), - LUSTRE_DLM_VERSION, LDLM_CONVERT, 2, size, NULL); - if (!req) - GOTO(out, rc = -ENOMEM); + req = ptlrpc_request_alloc_pack(class_exp2cliimp(lock->l_conn_export), + &RQF_LDLM_CONVERT, LUSTRE_DLM_VERSION, + LDLM_CONVERT); + if (req == NULL) { + LDLM_LOCK_PUT(lock); + RETURN(-ENOMEM); + } - body = lustre_msg_buf(req->rq_reqmsg, DLM_LOCKREQ_OFF, sizeof(*body)); + body = req_capsule_client_get(&req->rq_pill, &RMF_DLM_REQ); body->lock_handle[0] = lock->l_remote_handle; body->lock_desc.l_req_mode = new_mode; body->lock_flags = *flags; - size[DLM_LOCKREPLY_OFF] = sizeof(*reply); - ptlrpc_req_set_repsize(req, 2, size); + ptlrpc_request_set_replen(req); rc = ptlrpc_queue_wait(req); if (rc != ELDLM_OK) GOTO(out, rc); - reply = lustre_swab_repbuf(req, DLM_LOCKREPLY_OFF, sizeof(*reply), - lustre_swab_ldlm_reply); - if (reply == NULL) { - CERROR ("Can't unpack ldlm_reply\n"); - GOTO (out, rc = -EPROTO); - } + reply = req_capsule_server_get(&req->rq_pill, &RMF_DLM_REP); + if (reply == NULL) + GOTO(out, rc = -EPROTO); if (req->rq_status) GOTO(out, rc = req->rq_status); @@ -862,7 +872,7 @@ static int ldlm_cli_cancel_local(struct ldlm_lock *lock) /* Pack @count locks in @head into ldlm_request buffer at the offset @off, of the request @req. */ -static void ldlm_cancel_pack(struct ptlrpc_request *req, int off, +static void ldlm_cancel_pack(struct ptlrpc_request *req, struct list_head *head, int count) { struct ldlm_request *dlm; @@ -870,11 +880,11 @@ static void ldlm_cancel_pack(struct ptlrpc_request *req, int off, int max, packed = 0; ENTRY; - dlm = lustre_msg_buf(req->rq_reqmsg, off, sizeof(*dlm)); + dlm = req_capsule_client_get(&req->rq_pill, &RMF_DLM_REQ); LASSERT(dlm != NULL); /* Check the room in the request buffer. */ - max = lustre_msg_buflen(req->rq_reqmsg, off) - + max = req_capsule_get_size(&req->rq_pill, &RMF_DLM_REQ, RCL_CLIENT) - sizeof(struct ldlm_request); max /= sizeof(struct lustre_handle); max += LDLM_LOCKREQ_HANDLES; @@ -902,9 +912,6 @@ int ldlm_cli_cancel_req(struct obd_export *exp, struct list_head *cancels, int count, int flags) { struct ptlrpc_request *req = NULL; - struct ldlm_request *body; - int size[2] = { [MSG_PTLRPC_BODY_OFF] = sizeof(struct ptlrpc_body), - [DLM_LOCKREQ_OFF] = sizeof(*body) }; struct obd_import *imp; int free, sent = 0; int rc = 0; @@ -916,12 +923,9 @@ int ldlm_cli_cancel_req(struct obd_export *exp, struct list_head *cancels, if (OBD_FAIL_CHECK(OBD_FAIL_LDLM_CANCEL_RACE)) RETURN(count); - free = ldlm_req_handles_avail(exp, size, 2, DLM_LOCKREQ_OFF, 0); - if (count > free) - count = free; - - size[DLM_LOCKREQ_OFF] = ldlm_request_bufsize(count, LDLM_CANCEL); while (1) { + int bufcount; + struct req_capsule *pill; imp = class_exp2cliimp(exp); if (imp == NULL || imp->imp_invalid) { CDEBUG(D_DLMTRACE, @@ -929,11 +933,26 @@ int ldlm_cli_cancel_req(struct obd_export *exp, struct list_head *cancels, RETURN(count); } - req = ptlrpc_prep_req(imp, LUSTRE_DLM_VERSION, LDLM_CANCEL, 2, - size, NULL); - if (!req) + req = ptlrpc_request_alloc(imp, &RQF_LDLM_CANCEL); + if (req == NULL) GOTO(out, rc = -ENOMEM); + pill = &req->rq_pill; + bufcount = req_capsule_filled_sizes(pill, RCL_CLIENT); + + free = ldlm_req_handles_avail(exp, pill->rc_area[RCL_CLIENT], + bufcount, bufcount, 0); + if (count > free) + count = free; + + req_capsule_set_size(&req->rq_pill, &RMF_DLM_REQ, RCL_CLIENT, + ldlm_request_bufsize(count, LDLM_CANCEL)); + + rc = ptlrpc_request_pack(req, LUSTRE_DLM_VERSION, LDLM_CANCEL); + if (rc) { + ptlrpc_request_free(req); + GOTO(out, rc); + } req->rq_no_resend = 1; req->rq_no_delay = 1; @@ -941,11 +960,9 @@ int ldlm_cli_cancel_req(struct obd_export *exp, struct list_head *cancels, req->rq_request_portal = LDLM_CANCEL_REQUEST_PORTAL; req->rq_reply_portal = LDLM_CANCEL_REPLY_PORTAL; - body = lustre_msg_buf(req->rq_reqmsg, DLM_LOCKREQ_OFF, - sizeof(*body)); - ldlm_cancel_pack(req, DLM_LOCKREQ_OFF, cancels, count); + ldlm_cancel_pack(req, cancels, count); - ptlrpc_req_set_repsize(req, 1, NULL); + ptlrpc_request_set_replen(req); if (flags & LDLM_FL_ASYNC) { ptlrpcd_add_req(req); sent = count; @@ -1076,7 +1093,7 @@ int ldlm_cli_cancel(struct lustre_handle *lockh) count += ldlm_cancel_lru_local(ns, &cancels, 0, avail - 1, LDLM_FL_BL_AST, flags); } - ldlm_cli_cancel_list(&cancels, count, NULL, 0, 0); + ldlm_cli_cancel_list(&cancels, count, NULL, 0); RETURN(0); } @@ -1116,7 +1133,7 @@ static int ldlm_cancel_list(struct list_head *cancels, int count, int flags) } if (bl_ast > 0) { count -= bl_ast; - ldlm_cli_cancel_list(&head, bl_ast, NULL, 0, 0); + ldlm_cli_cancel_list(&head, bl_ast, NULL, 0); } RETURN(count); @@ -1384,7 +1401,7 @@ int ldlm_cancel_lru(struct ldlm_namespace *ns, int nr, ldlm_sync_t sync, /* If an error occured in ASYNC mode, or * this is SYNC mode, cancel the list. */ - ldlm_cli_cancel_list(&cancels, count, NULL, 0, 0); + ldlm_cli_cancel_list(&cancels, count, NULL, 0); RETURN(count); } @@ -1455,7 +1472,7 @@ int ldlm_cancel_resource_local(struct ldlm_resource *res, * buffer at the offset @off. * Destroy @cancels at the end. */ int ldlm_cli_cancel_list(struct list_head *cancels, int count, - struct ptlrpc_request *req, int off, int flags) + struct ptlrpc_request *req, int flags) { struct ldlm_lock *lock; int res = 0; @@ -1477,7 +1494,7 @@ int ldlm_cli_cancel_list(struct list_head *cancels, int count, if (exp_connect_cancelset(lock->l_conn_export)) { res = count; if (req) - ldlm_cancel_pack(req, off, cancels, count); + ldlm_cancel_pack(req, cancels, count); else res = ldlm_cli_cancel_req(lock->l_conn_export, cancels, count, @@ -1519,7 +1536,7 @@ int ldlm_cli_cancel_unused_resource(struct ldlm_namespace *ns, count = ldlm_cancel_resource_local(res, &cancels, policy, mode, 0, flags, opaque); - rc = ldlm_cli_cancel_list(&cancels, count, NULL, 0, flags); + rc = ldlm_cli_cancel_list(&cancels, count, NULL, flags); if (rc != ELDLM_OK) CERROR("ldlm_cli_cancel_unused_resource: %d\n", rc); @@ -1773,7 +1790,7 @@ static int ldlm_chain_lock_for_replay(struct ldlm_lock *lock, void *closure) static int replay_lock_interpret(struct ptlrpc_request *req, struct ldlm_async_args *aa, int rc) { - struct ldlm_lock *lock; + struct ldlm_lock *lock; struct ldlm_reply *reply; ENTRY; @@ -1782,12 +1799,9 @@ static int replay_lock_interpret(struct ptlrpc_request *req, GOTO(out, rc); - reply = lustre_swab_repbuf(req, DLM_LOCKREPLY_OFF, sizeof(*reply), - lustre_swab_ldlm_reply); - if (reply == NULL) { - CERROR("Can't unpack ldlm_reply\n"); - GOTO (out, rc = -EPROTO); - } + reply = req_capsule_server_get(&req->rq_pill, &RMF_DLM_REP); + if (reply == NULL) + GOTO(out, rc = -EPROTO); lock = ldlm_handle2lock(&aa->lock_handle); if (!lock) { @@ -1814,11 +1828,8 @@ out: static int replay_one_lock(struct obd_import *imp, struct ldlm_lock *lock) { struct ptlrpc_request *req; - struct ldlm_request *body; - struct ldlm_reply *reply; struct ldlm_async_args *aa; - int buffers = 2; - int size[3] = { sizeof(struct ptlrpc_body) }; + struct ldlm_request *body; int flags; ENTRY; @@ -1860,26 +1871,25 @@ static int replay_one_lock(struct obd_import *imp, struct ldlm_lock *lock) else flags = LDLM_FL_REPLAY; - size[DLM_LOCKREQ_OFF] = sizeof(*body); - req = ptlrpc_prep_req(imp, LUSTRE_DLM_VERSION, LDLM_ENQUEUE, 2, size, - NULL); - if (!req) + req = ptlrpc_request_alloc_pack(imp, &RQF_LDLM_ENQUEUE, + LUSTRE_DLM_VERSION, LDLM_ENQUEUE); + if (req == NULL) RETURN(-ENOMEM); /* We're part of recovery, so don't wait for it. */ req->rq_send_state = LUSTRE_IMP_REPLAY_LOCKS; - body = lustre_msg_buf(req->rq_reqmsg, DLM_LOCKREQ_OFF, sizeof(*body)); + body = req_capsule_client_get(&req->rq_pill, &RMF_DLM_REQ); ldlm_lock2desc(lock, &body->lock_desc); body->lock_flags = flags; ldlm_lock2handle(lock, &body->lock_handle[0]); - size[DLM_LOCKREPLY_OFF] = sizeof(*reply); if (lock->l_lvb_len != 0) { - buffers = 3; - size[DLM_REPLY_REC_OFF] = lock->l_lvb_len; + req_capsule_extend(&req->rq_pill, &RQF_LDLM_ENQUEUE_LVB); + req_capsule_set_size(&req->rq_pill, &RMF_DLM_LVB, RCL_SERVER, + lock->l_lvb_len); } - ptlrpc_req_set_repsize(req, buffers, size); + ptlrpc_request_set_replen(req); /* notify the server we've replayed all requests. * also, we mark the request to be put on a dedicated * queue to be processed after all request replayes. diff --git a/lustre/liblustre/dir.c b/lustre/liblustre/dir.c index fdeabf3..a297c9b 100644 --- a/lustre/liblustre/dir.c +++ b/lustre/liblustre/dir.c @@ -105,11 +105,8 @@ static int llu_dir_do_readpage(struct inode *inode, struct page *page) rc = md_readpage(sbi->ll_md_exp, &lli->lli_fid, NULL, offset, page, &request); if (!rc) { - body = lustre_msg_buf(request->rq_repmsg, REPLY_REC_OFF, - sizeof(*body)); + body = req_capsule_server_get(&request->rq_pill, &RMF_MDT_BODY); LASSERT(body != NULL); /* checked by md_readpage() */ - /* swabbed by md_readpage() */ - LASSERT(lustre_rep_swabbed(request, REPLY_REC_OFF)); if (body->valid & OBD_MD_FLSIZE) st->st_size = body->size; diff --git a/lustre/liblustre/file.c b/lustre/liblustre/file.c index cf5267b..25b425b 100644 --- a/lustre/liblustre/file.c +++ b/lustre/liblustre/file.c @@ -146,10 +146,8 @@ int llu_local_open(struct llu_inode_info *lli, struct lookup_intent *it) struct mdt_body *body; ENTRY; - body = lustre_msg_buf(req->rq_repmsg, DLM_REPLY_REC_OFF, sizeof(*body)); - LASSERT(body != NULL); /* reply already checked out */ - /* and swabbed down */ - LASSERT(lustre_rep_swabbed(req, DLM_REPLY_REC_OFF)); + body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY); + LASSERT(body != NULL); /* already opened? */ if (lli->lli_open_count++) @@ -246,7 +244,7 @@ int llu_iop_open(struct pnode *pnode, int flags, mode_t mode) RETURN(rc); } -int llu_objects_destroy(struct ptlrpc_request *request, struct inode *dir) +int llu_objects_destroy(struct ptlrpc_request *req, struct inode *dir) { struct mdt_body *body; struct lov_mds_md *eadata; @@ -256,8 +254,7 @@ int llu_objects_destroy(struct ptlrpc_request *request, struct inode *dir) int rc; ENTRY; - /* req is swabbed so this is safe */ - body = lustre_msg_buf(request->rq_repmsg, REPLY_REC_OFF, sizeof(*body)); + body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY); if (!(body->valid & OBD_MD_FLEASIZE)) RETURN(0); @@ -271,13 +268,10 @@ int llu_objects_destroy(struct ptlrpc_request *request, struct inode *dir) * to this file. Use this EA to unlink the objects on the OST. * It's opaque so we don't swab here; we leave it to obd_unpackmd() to * check it is complete and sensible. */ - eadata = lustre_swab_repbuf(request, REPLY_REC_OFF+1, body->eadatasize, - NULL); + eadata = req_capsule_server_sized_get(&req->rq_pill, &RMF_MDT_MD, + body->eadatasize); + LASSERT(eadata != NULL); - if (eadata == NULL) { - CERROR("Can't unpack MDS EA data\n"); - GOTO(out, rc = -EPROTO); - } rc = obd_unpackmd(llu_i2obdexp(dir), &lsm, eadata,body->eadatasize); if (rc < 0) { @@ -298,9 +292,10 @@ int llu_objects_destroy(struct ptlrpc_request *request, struct inode *dir) if (body->valid & OBD_MD_FLCOOKIE) { oa->o_valid |= OBD_MD_FLCOOKIE; oti.oti_logcookies = - lustre_msg_buf(request->rq_repmsg, REPLY_REC_OFF + 2, - sizeof(struct llog_cookie) * - lsm->lsm_stripe_count); + req_capsule_server_sized_get(&req->rq_pill, + &RMF_LOGCOOKIES, + sizeof(struct llog_cookie) * + lsm->lsm_stripe_count); if (oti.oti_logcookies == NULL) { oa->o_valid &= ~OBD_MD_FLCOOKIE; body->valid &= ~OBD_MD_FLCOOKIE; diff --git a/lustre/liblustre/llite_lib.c b/lustre/liblustre/llite_lib.c index 486f874..9e5de90 100644 --- a/lustre/liblustre/llite_lib.c +++ b/lustre/liblustre/llite_lib.c @@ -157,7 +157,7 @@ int liblustre_process_log(struct config_llog_instance *cfg, if (ocd == NULL) GOTO(out_cleanup, rc = -ENOMEM); - ocd->ocd_connect_flags = OBD_CONNECT_VERSION; + ocd->ocd_connect_flags = OBD_CONNECT_VERSION | OBD_CONNECT_FID; #ifdef LIBLUSTRE_POSIX_ACL ocd->ocd_connect_flags |= OBD_CONNECT_ACL; #endif diff --git a/lustre/liblustre/namei.c b/lustre/liblustre/namei.c index ad90650..a09bb97 100644 --- a/lustre/liblustre/namei.c +++ b/lustre/liblustre/namei.c @@ -173,7 +173,6 @@ int llu_md_blocking_ast(struct ldlm_lock *lock, } static int pnode_revalidate_finish(struct ptlrpc_request *req, - int offset, struct lookup_intent *it, struct pnode *pnode) { @@ -191,7 +190,7 @@ static int pnode_revalidate_finish(struct ptlrpc_request *req, RETURN(-ENOENT); rc = md_get_lustre_md(llu_i2sbi(inode)->ll_md_exp, req, - offset, llu_i2sbi(inode)->ll_dt_exp, + llu_i2sbi(inode)->ll_dt_exp, llu_i2sbi(inode)->ll_md_exp, &md); if (rc) RETURN(rc); @@ -265,7 +264,7 @@ static int llu_pb_revalidate(struct pnode *pnode, int flags, if (rc < 0) GOTO(out, rc = 0); - rc = pnode_revalidate_finish(req, DLM_REPLY_REC_OFF, it, pnode); + rc = pnode_revalidate_finish(req, it, pnode); if (rc != 0) { ll_intent_release(it); GOTO(out, rc = 0); @@ -335,7 +334,7 @@ static int lookup_it_finish(struct ptlrpc_request *request, int offset, if (it_disposition(it, DISP_OPEN_CREATE)) ptlrpc_req_finished(request); - rc = md_get_lustre_md(sbi->ll_md_exp, request, offset, + rc = md_get_lustre_md(sbi->ll_md_exp, request, sbi->ll_dt_exp, sbi->ll_md_exp, &md); if (rc) RETURN(rc); diff --git a/lustre/liblustre/rw.c b/lustre/liblustre/rw.c index 7d91ef8..021a592 100644 --- a/lustre/liblustre/rw.c +++ b/lustre/liblustre/rw.c @@ -179,7 +179,6 @@ static int llu_glimpse_callback(struct ldlm_lock *lock, void *reqp) struct inode *inode = llu_inode_from_lock(lock); struct llu_inode_info *lli; struct ost_lvb *lvb; - int size[2] = { sizeof(struct ptlrpc_body), sizeof(*lvb) }; int rc, stripe = 0; ENTRY; @@ -195,11 +194,16 @@ static int llu_glimpse_callback(struct ldlm_lock *lock, void *reqp) if (lli->lli_smd->lsm_stripe_count > 1) stripe = llu_lock_to_stripe_offset(inode, lock); - rc = lustre_pack_reply(req, 2, size, NULL); - if (rc) + req_capsule_extend(&req->rq_pill, &RQF_LDLM_GL_CALLBACK); + req_capsule_set_size(&req->rq_pill, &RMF_DLM_LVB, RCL_SERVER, + sizeof(*lvb)); + rc = req_capsule_server_pack(&req->rq_pill); + if (rc) { + CERROR("failed pack reply: %d\n", rc); GOTO(iput, rc); + } - lvb = lustre_msg_buf(req->rq_repmsg, REPLY_REC_OFF, sizeof(*lvb)); + lvb = req_capsule_server_get(&req->rq_pill, &RMF_DLM_LVB); lvb->lvb_size = lli->lli_smd->lsm_oinfo[stripe]->loi_kms; LDLM_DEBUG(lock, "i_size: %llu -> stripe number %u -> kms "LPU64, diff --git a/lustre/liblustre/super.c b/lustre/liblustre/super.c index e24258c..d4b1fd5 100644 --- a/lustre/liblustre/super.c +++ b/lustre/liblustre/super.c @@ -465,7 +465,7 @@ static int llu_inode_revalidate(struct inode *inode) (long long)llu_i2stat(inode)->st_ino); RETURN(-abs(rc)); } - rc = md_get_lustre_md(sbi->ll_md_exp, req, REPLY_REC_OFF, + rc = md_get_lustre_md(sbi->ll_md_exp, req, sbi->ll_dt_exp, sbi->ll_md_exp, &md); /* XXX Too paranoid? */ @@ -642,7 +642,7 @@ int llu_md_setattr(struct inode *inode, struct md_op_data *op_data, RETURN(rc); } - rc = md_get_lustre_md(sbi->ll_md_exp, request, REPLY_REC_OFF, + rc = md_get_lustre_md(sbi->ll_md_exp, request, sbi->ll_dt_exp, sbi->ll_md_exp, &md); if (rc) { ptlrpc_req_finished(request); @@ -993,10 +993,8 @@ static int llu_readlink_internal(struct inode *inode, RETURN(rc); } - body = lustre_msg_buf((*request)->rq_repmsg, REPLY_REC_OFF, - sizeof(*body)); + body = req_capsule_server_get(&(*request)->rq_pill, &RMF_MDT_BODY); LASSERT(body != NULL); - LASSERT(lustre_rep_swabbed(*request, REPLY_REC_OFF)); if ((body->valid & OBD_MD_LINKNAME) == 0) { CERROR ("OBD_MD_LINKNAME not set on reply\n"); @@ -1010,8 +1008,7 @@ static int llu_readlink_internal(struct inode *inode, GOTO(failed, rc = -EPROTO); } - *symname = lustre_msg_buf((*request)->rq_repmsg, REPLY_REC_OFF + 1, - symlen); + *symname = req_capsule_server_get(&(*request)->rq_pill, &RMF_MDT_MD); if (*symname == NULL || strnlen(*symname, symlen) != symlen - 1) { /* not full/NULL terminated */ @@ -1791,7 +1788,7 @@ static int llu_lov_setstripe_ea_info(struct inode *ino, int flags, } rc = md_get_lustre_md(sbi->ll_md_exp, req, - DLM_REPLY_REC_OFF, sbi->ll_dt_exp, sbi->ll_md_exp, &md); + sbi->ll_dt_exp, sbi->ll_md_exp, &md); if (rc) GOTO(out, rc); @@ -2074,7 +2071,8 @@ llu_fsswop_mount(const char *source, obd_set_info_async(obd->obd_self_export, strlen("async"), "async", sizeof(async), &async, NULL); - ocd.ocd_connect_flags = OBD_CONNECT_IBITS | OBD_CONNECT_VERSION; + ocd.ocd_connect_flags = OBD_CONNECT_IBITS | OBD_CONNECT_VERSION | + OBD_CONNECT_FID; #ifdef LIBLUSTRE_POSIX_ACL ocd.ocd_connect_flags |= OBD_CONNECT_ACL; #endif @@ -2138,7 +2136,7 @@ llu_fsswop_mount(const char *source, GOTO(out_dt, err); } - err = md_get_lustre_md(sbi->ll_md_exp, request, REPLY_REC_OFF, + err = md_get_lustre_md(sbi->ll_md_exp, request, sbi->ll_dt_exp, sbi->ll_md_exp, &md); if (err) { CERROR("failed to understand root inode md: rc = %d\n",err); diff --git a/lustre/llite/dcache.c b/lustre/llite/dcache.c index 1a16669..42bce6f 100644 --- a/lustre/llite/dcache.c +++ b/lustre/llite/dcache.c @@ -269,7 +269,7 @@ restart: } int ll_revalidate_it_finish(struct ptlrpc_request *request, - int offset, struct lookup_intent *it, + struct lookup_intent *it, struct dentry *de) { int rc = 0; @@ -281,8 +281,7 @@ int ll_revalidate_it_finish(struct ptlrpc_request *request, if (it_disposition(it, DISP_LOOKUP_NEG)) RETURN(-ENOENT); - rc = ll_prep_inode(&de->d_inode, - request, offset, NULL); + rc = ll_prep_inode(&de->d_inode, request, NULL); RETURN(rc); } @@ -468,7 +467,7 @@ do_lock: } revalidate_finish: - rc = ll_revalidate_it_finish(req, DLM_REPLY_REC_OFF, it, de); + rc = ll_revalidate_it_finish(req, it, de); if (rc != 0) { if (rc != -ESTALE && rc != -ENOENT) ll_intent_release(it); @@ -556,11 +555,10 @@ do_lookup: rc = md_intent_lock(exp, op_data, NULL, 0, it, 0, &req, ll_md_blocking_ast, 0); if (rc >= 0) { - struct mdt_body *mdt_body = lustre_msg_buf(req->rq_repmsg, - DLM_REPLY_REC_OFF, - sizeof(*mdt_body)); + struct mdt_body *mdt_body; struct lu_fid fid = {.f_seq = 0, .f_oid = 0, .f_ver = 0}; - + mdt_body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY); + if (de->d_inode) fid = *ll_inode2fid(de->d_inode); diff --git a/lustre/llite/dir.c b/lustre/llite/dir.c index 9f5f22a..c230e02 100644 --- a/lustre/llite/dir.c +++ b/lustre/llite/dir.c @@ -153,14 +153,10 @@ static int ll_dir_readpage(struct file *file, struct page *page) oc, hash, page, &request); capa_put(oc); if (!rc) { - body = lustre_msg_buf(request->rq_repmsg, REPLY_REC_OFF, - sizeof(*body)); + body = req_capsule_server_get(&request->rq_pill, &RMF_MDT_BODY); /* Checked by mdc_readpage() */ LASSERT(body != NULL); - /* Swabbed by mdc_readpage() */ - LASSERT(lustre_rep_swabbed(request, REPLY_REC_OFF)); - if (body->valid & OBD_MD_FLSIZE) { ll_inode_size_lock(inode, 0); i_size_write(inode, body->size); @@ -640,10 +636,8 @@ int ll_dir_getstripe(struct inode *inode, struct lov_mds_md **lmmp, GOTO(out, rc); } - body = lustre_msg_buf(req->rq_repmsg, REPLY_REC_OFF, sizeof(*body)); - LASSERT(body != NULL); /* checked by md_getattr_name */ - /* swabbed by mdc_getattr_name */ - LASSERT(lustre_rep_swabbed(req, REPLY_REC_OFF)); + body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY); + LASSERT(body != NULL); lmmsize = body->eadatasize; @@ -652,9 +646,9 @@ int ll_dir_getstripe(struct inode *inode, struct lov_mds_md **lmmp, GOTO(out, rc = -ENODATA); } - lmm = lustre_msg_buf(req->rq_repmsg, REPLY_REC_OFF + 1, lmmsize); + lmm = req_capsule_server_sized_get(&req->rq_pill, + &RMF_MDT_MD, lmmsize); LASSERT(lmm != NULL); - LASSERT(lustre_rep_swabbed(req, REPLY_REC_OFF + 1)); /* * This is coming from the MDS, so is probably in @@ -782,11 +776,9 @@ static int ll_dir_ioctl(struct inode *inode, struct file *file, } if (request) { - body = lustre_msg_buf(request->rq_repmsg, - REPLY_REC_OFF, sizeof(*body)); - LASSERT(body != NULL); /* checked by md_getattr_name */ - /* swabbed by md_getattr_name */ - LASSERT(lustre_rep_swabbed(request, REPLY_REC_OFF)); + body = req_capsule_server_get(&request->rq_pill, + &RMF_MDT_BODY); + LASSERT(body != NULL); } else { GOTO(out_req, rc); } @@ -894,11 +886,10 @@ static int ll_dir_ioctl(struct inode *inode, struct file *file, } case OBD_IOC_LLOG_CATINFO: { struct ptlrpc_request *req = NULL; - char *buf = NULL; - int rc, len = 0; - char *bufs[3] = { NULL }, *str; - int lens[3] = { sizeof(struct ptlrpc_body) }; - int size[2] = { sizeof(struct ptlrpc_body) }; + char *buf = NULL; + char *str; + int len = 0; + int rc; rc = obd_ioctl_getdata(&buf, &len, (void *)arg); if (rc) @@ -910,29 +901,38 @@ static int ll_dir_ioctl(struct inode *inode, struct file *file, RETURN(-EINVAL); } - lens[REQ_REC_OFF] = data->ioc_inllen1; - bufs[REQ_REC_OFF] = data->ioc_inlbuf1; - if (data->ioc_inllen2) { - lens[REQ_REC_OFF + 1] = data->ioc_inllen2; - bufs[REQ_REC_OFF + 1] = data->ioc_inlbuf2; - } else { - lens[REQ_REC_OFF + 1] = 0; - bufs[REQ_REC_OFF + 1] = NULL; + req = ptlrpc_request_alloc(sbi2mdc(sbi)->cl_import, + &RQF_LLOG_CATINFO); + if (req == NULL) + GOTO(out_catinfo, rc = -ENOMEM); + + req_capsule_set_size(&req->rq_pill, &RMF_NAME, RCL_CLIENT, + data->ioc_inllen1); + req_capsule_set_size(&req->rq_pill, &RMF_STRING, RCL_CLIENT, + data->ioc_inllen2); + + rc = ptlrpc_request_pack(req, LUSTRE_LOG_VERSION, LLOG_CATINFO); + if (rc) { + ptlrpc_request_free(req); + GOTO(out_catinfo, rc); } - req = ptlrpc_prep_req(sbi2mdc(sbi)->cl_import, - LUSTRE_LOG_VERSION, LLOG_CATINFO, 3, lens, - bufs); - if (!req) - GOTO(out_catinfo, rc = -ENOMEM); + str = req_capsule_client_get(&req->rq_pill, &RMF_NAME); + memcpy(str, data->ioc_inlbuf1, data->ioc_inllen1); + if (data->ioc_inllen2) { + str = req_capsule_client_get(&req->rq_pill, + &RMF_STRING); + memcpy(str, data->ioc_inlbuf2, data->ioc_inllen2); + } - size[REPLY_REC_OFF] = data->ioc_plen1; - ptlrpc_req_set_repsize(req, 2, size); + req_capsule_set_size(&req->rq_pill, &RMF_STRING, RCL_SERVER, + data->ioc_plen1); + ptlrpc_request_set_replen(req); rc = ptlrpc_queue_wait(req); if (!rc) { - str = lustre_msg_string(req->rq_repmsg, REPLY_REC_OFF, - data->ioc_plen1); + str = req_capsule_server_get(&req->rq_pill, + &RMF_STRING); rc = copy_to_user(data->ioc_pbuf1, str, data->ioc_plen1); } ptlrpc_req_finished(req); diff --git a/lustre/llite/file.c b/lustre/llite/file.c index f21e44f..598c994 100644 --- a/lustre/llite/file.c +++ b/lustre/llite/file.c @@ -376,8 +376,7 @@ static int ll_intent_file_open(struct file *file, void *lmm, &itp->d.lustre.it_lock_handle, file->f_dentry->d_inode); - rc = ll_prep_inode(&file->f_dentry->d_inode, req, DLM_REPLY_REC_OFF, - NULL); + rc = ll_prep_inode(&file->f_dentry->d_inode, req, NULL); out: ptlrpc_req_finished(itp->d.lustre.it_data); @@ -396,11 +395,8 @@ static int ll_och_fill(struct obd_export *md_exp, struct ll_inode_info *lli, LASSERT(och); - body = lustre_msg_buf(req->rq_repmsg, DLM_REPLY_REC_OFF, sizeof(*body)); - /* reply already checked out */ - LASSERT(body != NULL); - /* and swabbed in md_enqueue */ - LASSERT(lustre_rep_swabbed(req, DLM_REPLY_REC_OFF)); + body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY); + LASSERT(body != NULL); /* reply already checked out */ memcpy(&och->och_fh, &body->handle, sizeof(body->handle)); och->och_magic = OBD_CLIENT_HANDLE_MAGIC; @@ -431,15 +427,11 @@ int ll_local_open(struct file *file, struct lookup_intent *it, if (rc) RETURN(rc); - body = lustre_msg_buf(req->rq_repmsg, - DLM_REPLY_REC_OFF, sizeof(*body)); - + body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY); if ((it->it_flags & FMODE_WRITE) && (body->valid & OBD_MD_FLSIZE)) - { CDEBUG(D_INODE, "Epoch "LPU64" opened on "DFID"\n", lli->lli_ioepoch, PFID(&lli->lli_fid)); - } } LUSTRE_FPRIVATE(file) = fd; @@ -1034,7 +1026,6 @@ static int ll_glimpse_callback(struct ldlm_lock *lock, void *reqp) struct lov_stripe_md *lsm; struct ost_lvb *lvb; int rc, stripe; - int size[2] = { sizeof(struct ptlrpc_body), sizeof(*lvb) }; ENTRY; if (inode == NULL) @@ -1051,11 +1042,16 @@ static int ll_glimpse_callback(struct ldlm_lock *lock, void *reqp) if (stripe < 0) GOTO(iput, rc = -ELDLM_NO_LOCK_DATA); - rc = lustre_pack_reply(req, 2, size, NULL); - if (rc) + req_capsule_extend(&req->rq_pill, &RQF_LDLM_GL_CALLBACK); + req_capsule_set_size(&req->rq_pill, &RMF_DLM_LVB, RCL_SERVER, + sizeof(*lvb)); + rc = req_capsule_server_pack(&req->rq_pill); + if (rc) { + CERROR("lustre_pack_reply: %d\n", rc); GOTO(iput, rc); + } - lvb = lustre_msg_buf(req->rq_repmsg, REPLY_REC_OFF, sizeof(*lvb)); + lvb = req_capsule_server_get(&req->rq_pill, &RMF_DLM_LVB); lvb->lvb_size = lli->lli_smd->lsm_oinfo[stripe]->loi_kms; lvb->lvb_mtime = LTIME_S(inode->i_mtime); lvb->lvb_atime = LTIME_S(inode->i_atime); @@ -1814,10 +1810,8 @@ int ll_lov_getstripe_ea_info(struct inode *inode, const char *filename, GOTO(out, rc); } - body = lustre_msg_buf(req->rq_repmsg, REPLY_REC_OFF, sizeof(*body)); + body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY); LASSERT(body != NULL); /* checked by mdc_getattr_name */ - /* swabbed by mdc_getattr_name */ - LASSERT(lustre_rep_swabbed(req, REPLY_REC_OFF)); lmmsize = body->eadatasize; @@ -1826,9 +1820,8 @@ int ll_lov_getstripe_ea_info(struct inode *inode, const char *filename, GOTO(out, rc = -ENODATA); } - lmm = lustre_msg_buf(req->rq_repmsg, REPLY_REC_OFF + 1, lmmsize); + lmm = req_capsule_server_sized_get(&req->rq_pill, &RMF_MDT_MD, lmmsize); LASSERT(lmm != NULL); - LASSERT(lustre_rep_swabbed(req, REPLY_REC_OFF + 1)); /* * This is coming from the MDS, so is probably in @@ -2645,7 +2638,7 @@ int ll_inode_revalidate_it(struct dentry *dentry, struct lookup_intent *it) GOTO (out, rc); } - rc = ll_revalidate_it_finish(req, DLM_REPLY_REC_OFF, &oit, dentry); + rc = ll_revalidate_it_finish(req, &oit, dentry); if (rc != 0) { ll_intent_release(&oit); GOTO(out, rc); @@ -2686,8 +2679,7 @@ int ll_inode_revalidate_it(struct dentry *dentry, struct lookup_intent *it) RETURN(rc); } - rc = ll_prep_inode(&inode, req, REPLY_REC_OFF, - NULL); + rc = ll_prep_inode(&inode, req, NULL); if (rc) GOTO(out, rc); } diff --git a/lustre/llite/llite_internal.h b/lustre/llite/llite_internal.h index 64022e5..e81d275 100644 --- a/lustre/llite/llite_internal.h +++ b/lustre/llite/llite_internal.h @@ -497,7 +497,8 @@ extern struct file_operations ll_dir_operations; extern struct inode_operations ll_dir_inode_operations; /* llite/namei.c */ -int ll_objects_destroy(struct ptlrpc_request *request, struct inode *dir); +int ll_objects_destroy(struct ptlrpc_request *request, + struct inode *dir); struct inode *ll_iget(struct super_block *sb, ino_t hash, struct lustre_md *lic); struct dentry *ll_find_alias(struct inode *, struct dentry *); @@ -590,7 +591,7 @@ void ll_unhash_aliases(struct inode *); void ll_frob_intent(struct lookup_intent **itp, struct lookup_intent *deft); void ll_lookup_finish_locks(struct lookup_intent *it, struct dentry *dentry); int ll_dcompare(struct dentry *parent, struct qstr *d_name, struct qstr *name); -int ll_revalidate_it_finish(struct ptlrpc_request *request, int offset, +int ll_revalidate_it_finish(struct ptlrpc_request *request, struct lookup_intent *it, struct dentry *de); /* llite/llite_lib.c */ @@ -625,7 +626,7 @@ void ll_umount_begin(struct super_block *sb); #endif int ll_remount_fs(struct super_block *sb, int *flags, char *data); int ll_prep_inode(struct inode **inode, struct ptlrpc_request *req, - int offset, struct super_block *); + struct super_block *); void lustre_dump_dentry(struct dentry *, int recur); void lustre_dump_inode(struct inode *); struct ll_async_page *llite_pglist_next_llap(struct ll_sb_info *sbi, diff --git a/lustre/llite/llite_lib.c b/lustre/llite/llite_lib.c index 0f91ebc..eb45e5b 100644 --- a/lustre/llite/llite_lib.c +++ b/lustre/llite/llite_lib.c @@ -196,11 +196,12 @@ static int client_common_fill_super(struct super_block *sb, char *md, char *dt) } /* indicate the features supported by this client */ - data->ocd_connect_flags = OBD_CONNECT_IBITS | OBD_CONNECT_NODEVOH | - OBD_CONNECT_JOIN | - OBD_CONNECT_ATTRFID | OBD_CONNECT_VERSION | - OBD_CONNECT_MDS_CAPA | OBD_CONNECT_OSS_CAPA | - OBD_CONNECT_CANCELSET; + data->ocd_connect_flags = OBD_CONNECT_IBITS | OBD_CONNECT_NODEVOH | + OBD_CONNECT_JOIN | OBD_CONNECT_ATTRFID | + OBD_CONNECT_VERSION | OBD_CONNECT_MDS_CAPA | + OBD_CONNECT_OSS_CAPA | OBD_CONNECT_CANCELSET| + OBD_CONNECT_FID; + #ifdef HAVE_LRU_RESIZE_SUPPORT if (sbi->ll_flags & LL_SBI_LRU_RESIZE) data->ocd_connect_flags |= OBD_CONNECT_LRU_RESIZE; @@ -361,9 +362,9 @@ static int client_common_fill_super(struct super_block *sb, char *md, char *dt) GOTO(out_md_fid, err = -ENODEV); } - data->ocd_connect_flags = OBD_CONNECT_GRANT | OBD_CONNECT_VERSION | + data->ocd_connect_flags = OBD_CONNECT_GRANT | OBD_CONNECT_VERSION | OBD_CONNECT_REQPORTAL | OBD_CONNECT_BRW_SIZE | - OBD_CONNECT_CANCELSET; + OBD_CONNECT_CANCELSET | OBD_CONNECT_FID; if (sbi->ll_flags & LL_SBI_OSS_CAPA) data->ocd_connect_flags |= OBD_CONNECT_OSS_CAPA; @@ -451,9 +452,8 @@ static int client_common_fill_super(struct super_block *sb, char *md, char *dt) GOTO(out_dt_fid, err); } memset(&lmd, 0, sizeof(lmd)); - err = md_get_lustre_md(sbi->ll_md_exp, request, - REPLY_REC_OFF, sbi->ll_dt_exp, sbi->ll_md_exp, - &lmd); + err = md_get_lustre_md(sbi->ll_md_exp, request, 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); @@ -1175,8 +1175,8 @@ int ll_md_setattr(struct inode *inode, struct md_op_data *op_data, RETURN(rc); } - rc = md_get_lustre_md(sbi->ll_md_exp, request, REPLY_REC_OFF, - sbi->ll_dt_exp, sbi->ll_md_exp, &md); + rc = md_get_lustre_md(sbi->ll_md_exp, request, sbi->ll_dt_exp, + sbi->ll_md_exp, &md); if (rc) { ptlrpc_req_finished(request); RETURN(rc); @@ -1830,11 +1830,11 @@ int ll_iocontrol(struct inode *inode, struct file *file, RETURN(-abs(rc)); } - body = lustre_msg_buf(req->rq_repmsg, REPLY_REC_OFF, - sizeof(*body)); + body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY); + flags = body->flags; - ptlrpc_req_finished (req); + ptlrpc_req_finished(req); RETURN(put_user(flags, (int *)arg)); } @@ -1997,8 +1997,9 @@ int ll_remount_fs(struct super_block *sb, int *flags, char *data) return 0; } -int ll_prep_inode(struct inode **inode, struct ptlrpc_request *req, - int offset, struct super_block *sb) +int ll_prep_inode(struct inode **inode, + struct ptlrpc_request *req, + struct super_block *sb) { struct ll_sb_info *sbi = NULL; struct lustre_md md; @@ -2010,8 +2011,8 @@ int ll_prep_inode(struct inode **inode, struct ptlrpc_request *req, prune_deathrow(sbi, 1); memset(&md, 0, sizeof(struct lustre_md)); - rc = md_get_lustre_md(sbi->ll_md_exp, req, offset, - sbi->ll_dt_exp, sbi->ll_md_exp, &md); + rc = md_get_lustre_md(sbi->ll_md_exp, req, sbi->ll_dt_exp, + sbi->ll_md_exp, &md); if (rc) RETURN(rc); diff --git a/lustre/llite/llite_nfs.c b/lustre/llite/llite_nfs.c index afd0c9b..8892862 100644 --- a/lustre/llite/llite_nfs.c +++ b/lustre/llite/llite_nfs.c @@ -70,7 +70,7 @@ static struct inode *search_inode_for_lustre(struct super_block *sb, RETURN(ERR_PTR(rc)); } - rc = ll_prep_inode(&inode, req, REPLY_REC_OFF, sb); + rc = ll_prep_inode(&inode, req, sb); ptlrpc_req_finished(req); if (rc) RETURN(ERR_PTR(rc)); @@ -219,8 +219,7 @@ static struct dentry *ll_get_parent(struct dentry *dchild) CERROR("failure %d inode %lu get parent\n", rc, dir->i_ino); RETURN(ERR_PTR(rc)); } - body = lustre_msg_buf(req->rq_repmsg, REPLY_REC_OFF, sizeof(*body)); - + body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY); LASSERT(body->valid & OBD_MD_FLID); CDEBUG(D_INFO, "parent for "DFID" is "DFID"\n", diff --git a/lustre/llite/namei.c b/lustre/llite/namei.c index c4cc5ed..17388df 100644 --- a/lustre/llite/namei.c +++ b/lustre/llite/namei.c @@ -360,8 +360,9 @@ struct dentry *ll_find_alias(struct inode *inode, struct dentry *de) return de; } -static int lookup_it_finish(struct ptlrpc_request *request, int offset, - struct lookup_intent *it, void *data) +static int lookup_it_finish(struct ptlrpc_request *request, + struct lookup_intent *it, + void *data) { struct it_cb_data *icbd = data; struct dentry **de = icbd->icbd_childp; @@ -375,8 +376,7 @@ static int lookup_it_finish(struct ptlrpc_request *request, int offset, if (!it_disposition(it, DISP_LOOKUP_NEG)) { ENTRY; - rc = ll_prep_inode(&inode, request, offset, - (*de)->d_sb); + rc = ll_prep_inode(&inode, request, (*de)->d_sb); if (rc) RETURN(rc); @@ -478,7 +478,7 @@ static struct dentry *ll_lookup_it(struct inode *parent, struct dentry *dentry, if (rc < 0) GOTO(out, retval = ERR_PTR(rc)); - rc = lookup_it_finish(req, DLM_REPLY_REC_OFF, it, &icbd); + rc = lookup_it_finish(req, it, &icbd); if (rc != 0) { ll_intent_release(it); GOTO(out, retval = ERR_PTR(rc)); @@ -647,7 +647,7 @@ static struct inode *ll_create_node(struct inode *dir, const char *name, LASSERT(it_disposition(it, DISP_ENQ_CREATE_REF)); request = it->d.lustre.it_data; it_clear_disposition(it, DISP_ENQ_CREATE_REF); - rc = ll_prep_inode(&inode, request, DLM_REPLY_REC_OFF, dir->i_sb); + rc = ll_prep_inode(&inode, request, dir->i_sb); if (rc) GOTO(out, inode = ERR_PTR(rc)); @@ -712,13 +712,13 @@ static int ll_create_it(struct inode *dir, struct dentry *dentry, int mode, RETURN(0); } -static void ll_update_times(struct ptlrpc_request *request, int offset, +static void ll_update_times(struct ptlrpc_request *request, struct inode *inode) { - struct mdt_body *body = lustre_msg_buf(request->rq_repmsg, offset, - sizeof(*body)); - LASSERT(body); + struct mdt_body *body = req_capsule_server_get(&request->rq_pill, + &RMF_MDT_BODY); + LASSERT(body); /* mtime is always updated with ctime, but can be set in past. As write and utime(2) may happen within 1 second, and utime's mtime has a priority over write's one, so take mtime from mds @@ -763,11 +763,10 @@ static int ll_new_node(struct inode *dir, struct qstr *name, if (err) GOTO(err_exit, err); - ll_update_times(request, REPLY_REC_OFF, dir); + ll_update_times(request, dir); if (dchild) { - err = ll_prep_inode(&inode, request, REPLY_REC_OFF, - dchild->d_sb); + err = ll_prep_inode(&inode, request, dchild->d_sb); if (err) GOTO(err_exit, err); @@ -900,7 +899,7 @@ static int ll_link_generic(struct inode *src, struct inode *dir, if (dchild) d_drop(dchild); - ll_update_times(request, REPLY_REC_OFF, dir); + ll_update_times(request, dir); EXIT; out: ptlrpc_req_finished(request); @@ -962,7 +961,7 @@ static int ll_rmdir_generic(struct inode *dir, struct dentry *dparent, rc = md_unlink(ll_i2sbi(dir)->ll_md_exp, op_data, &request); ll_finish_md_op_data(op_data); if (rc == 0) - ll_update_times(request, REPLY_REC_OFF, dir); + ll_update_times(request, dir); ptlrpc_req_finished(request); RETURN(rc); } @@ -978,8 +977,7 @@ int ll_objects_destroy(struct ptlrpc_request *request, struct inode *dir) ENTRY; /* req is swabbed so this is safe */ - body = lustre_msg_buf(request->rq_repmsg, REPLY_REC_OFF, sizeof(*body)); - + body = req_capsule_server_get(&request->rq_pill, &RMF_MDT_BODY); if (!(body->valid & OBD_MD_FLEASIZE)) RETURN(0); @@ -992,13 +990,9 @@ int ll_objects_destroy(struct ptlrpc_request *request, struct inode *dir) * to this file. Use this EA to unlink the objects on the OST. * It's opaque so we don't swab here; we leave it to obd_unpackmd() to * check it is complete and sensible. */ - eadata = lustre_swab_repbuf(request, REPLY_REC_OFF + 1, - body->eadatasize, NULL); + eadata = req_capsule_server_sized_get(&request->rq_pill, &RMF_MDT_MD, + body->eadatasize); LASSERT(eadata != NULL); - if (eadata == NULL) { - CERROR("Can't unpack MDS EA data\n"); - GOTO(out, rc = -EPROTO); - } rc = obd_unpackmd(ll_i2dtexp(dir), &lsm, eadata, body->eadatasize); if (rc < 0) { @@ -1022,10 +1016,11 @@ int ll_objects_destroy(struct ptlrpc_request *request, struct inode *dir) if (body->valid & OBD_MD_FLCOOKIE) { oa->o_valid |= OBD_MD_FLCOOKIE; - oti.oti_logcookies = - lustre_msg_buf(request->rq_repmsg, REPLY_REC_OFF + 2, - sizeof(struct llog_cookie) * - lsm->lsm_stripe_count); + oti.oti_logcookies = + req_capsule_server_sized_get(&request->rq_pill, + &RMF_LOGCOOKIES, + sizeof(struct llog_cookie) * + lsm->lsm_stripe_count); if (oti.oti_logcookies == NULL) { oa->o_valid &= ~OBD_MD_FLCOOKIE; body->valid &= ~OBD_MD_FLCOOKIE; @@ -1071,7 +1066,7 @@ static int ll_unlink_generic(struct inode *dir, struct dentry *dparent, if (rc) GOTO(out, rc); - ll_update_times(request, REPLY_REC_OFF, dir); + ll_update_times(request, dir); rc = ll_objects_destroy(request, dir); out: @@ -1110,8 +1105,8 @@ static int ll_rename_generic(struct inode *src, struct dentry *src_dparent, tgt_name->name, tgt_name->len, &request); ll_finish_md_op_data(op_data); if (!err) { - ll_update_times(request, REPLY_REC_OFF, src); - ll_update_times(request, REPLY_REC_OFF, tgt); + ll_update_times(request, src); + ll_update_times(request, tgt); err = ll_objects_destroy(request, src); } diff --git a/lustre/llite/remote_perm.c b/lustre/llite/remote_perm.c index e87239d..20cfa35 100644 --- a/lustre/llite/remote_perm.c +++ b/lustre/llite/remote_perm.c @@ -100,7 +100,7 @@ static inline int remote_perm_hashfunc(uid_t uid) } /* NB: setxid permission is not checked here, instead it's done on - * MDT when client get remote permission. (lookup/mdc_get_remote_perm). */ + * MDT when client get remote permission. */ static int do_check_remote_perm(struct ll_inode_info *lli, int mask) { struct hlist_head *head; @@ -271,9 +271,8 @@ check: RETURN(rc); } - perm = lustre_msg_buf(req->rq_repmsg, REPLY_REC_OFF + 1, sizeof(*perm)); + perm = req_capsule_server_get(&req->rq_pill, &RMF_ACL); LASSERT(perm); - LASSERT(lustre_rep_swabbed(req, REPLY_REC_OFF + 1)); rc = ll_update_remote_perm(inode, perm); up(&lli->lli_rmtperm_sem); diff --git a/lustre/llite/symlink.c b/lustre/llite/symlink.c index 7c9c1d3..033e712 100644 --- a/lustre/llite/symlink.c +++ b/lustre/llite/symlink.c @@ -57,11 +57,8 @@ static int ll_readlink_internal(struct inode *inode, GOTO (failed, rc); } - body = lustre_msg_buf((*request)->rq_repmsg, REPLY_REC_OFF, - sizeof(*body)); + body = req_capsule_server_get(&(*request)->rq_pill, &RMF_MDT_BODY); LASSERT(body != NULL); - LASSERT(lustre_rep_swabbed(*request, REPLY_REC_OFF)); - if ((body->valid & OBD_MD_LINKNAME) == 0) { CERROR("OBD_MD_LINKNAME not set on reply\n"); GOTO(failed, rc = -EPROTO); @@ -74,10 +71,9 @@ static int ll_readlink_internal(struct inode *inode, GOTO(failed, rc = -EPROTO); } - *symname = lustre_msg_buf((*request)->rq_repmsg, REPLY_REC_OFF + 1, - symlen); + *symname = req_capsule_server_get(&(*request)->rq_pill, &RMF_MDT_MD); if (*symname == NULL || - strnlen (*symname, symlen) != symlen - 1) { + strnlen(*symname, symlen) != symlen - 1) { /* not full/NULL terminated */ CERROR("inode %lu: symlink not NULL terminated string" "of length %d\n", inode->i_ino, symlen - 1); diff --git a/lustre/llite/xattr.c b/lustre/llite/xattr.c index db1bd85..933834f 100644 --- a/lustre/llite/xattr.c +++ b/lustre/llite/xattr.c @@ -326,9 +326,8 @@ do_getxattr: RETURN(rc); } - body = lustre_msg_buf(req->rq_repmsg, REPLY_REC_OFF, sizeof(*body)); + body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY); LASSERT(body); - LASSERT(lustre_rep_swabbed(req, REPLY_REC_OFF)); /* only detect the xattr size */ if (size == 0) @@ -340,21 +339,11 @@ do_getxattr: GOTO(out, rc = -ERANGE); } - if (lustre_msg_bufcount(req->rq_repmsg) < 3) { - CERROR("reply bufcount %u\n", - lustre_msg_bufcount(req->rq_repmsg)); - GOTO(out, rc = -EFAULT); - } - /* do not need swab xattr data */ - lustre_set_rep_swabbed(req, REPLY_REC_OFF + 1); - xdata = lustre_msg_buf(req->rq_repmsg, REPLY_REC_OFF + 1, - body->eadatasize); - if (!xdata) { - CERROR("can't extract: %u : %u\n", body->eadatasize, - lustre_msg_buflen(req->rq_repmsg, REPLY_REC_OFF + 1)); + xdata = req_capsule_server_sized_get(&req->rq_pill, &RMF_EADATA, + body->eadatasize); + if (!xdata) GOTO(out, rc = -EFAULT); - } #ifdef CONFIG_FS_POSIX_ACL if (body->eadatasize >= 0 && rce && rce->rce_ops == RMT_LSETFACL) { diff --git a/lustre/lmv/lmv_intent.c b/lustre/lmv/lmv_intent.c index 206cb11..6b0c365 100644 --- a/lustre/lmv/lmv_intent.c +++ b/lustre/lmv/lmv_intent.c @@ -73,10 +73,8 @@ int lmv_intent_remote(struct obd_export *exp, void *lmm, int pmode, rc = 0; ENTRY; - body = lustre_msg_buf((*reqp)->rq_repmsg, - DLM_REPLY_REC_OFF, sizeof(*body)); + body = req_capsule_server_get(&(*reqp)->rq_pill, &RMF_DLM_REP); LASSERT(body != NULL); - LASSERT(lustre_rep_swabbed(*reqp, DLM_REPLY_REC_OFF)); if (!(body->valid & OBD_MD_MDS)) RETURN(0); @@ -315,17 +313,15 @@ repeat: /* caller may use attrs MDS returns on IT_OPEN lock request so, we have * to update them for split dir */ - body = lustre_msg_buf((*reqp)->rq_repmsg, - DLM_REPLY_REC_OFF, sizeof(*body)); + body = req_capsule_server_get(&(*reqp)->rq_pill, &RMF_DLM_REP); LASSERT(body != NULL); - LASSERT(lustre_rep_swabbed(*reqp, DLM_REPLY_REC_OFF)); /* could not find object, FID is not present in response. */ if (!(body->valid & OBD_MD_FLID)) GOTO(out_free_sop_data, rc = 0); obj = lmv_obj_grab(obd, &body->fid1); - if (!obj && (mea = lmv_get_mea(*reqp, DLM_REPLY_REC_OFF))) { + if (!obj && (mea = lmv_get_mea(*reqp))) { /* FIXME: capability for remote! */ /* wow! this is split dir, we'd like to handle it */ obj = lmv_obj_create(exp, &body->fid1, mea); @@ -484,10 +480,8 @@ int lmv_intent_getattr(struct obd_export *exp, struct md_op_data *op_data, LASSERT(*reqp); LASSERT((*reqp)->rq_repmsg); - body = lustre_msg_buf((*reqp)->rq_repmsg, - DLM_REPLY_REC_OFF, sizeof(*body)); + body = req_capsule_server_get(&(*reqp)->rq_pill, &RMF_MDT_BODY); LASSERT(body != NULL); - LASSERT(lustre_rep_swabbed(*reqp, DLM_REPLY_REC_OFF)); /* could not find object, FID is not present in response. */ if (!(body->valid & OBD_MD_FLID)) @@ -495,7 +489,7 @@ int lmv_intent_getattr(struct obd_export *exp, struct md_op_data *op_data, obj2 = lmv_obj_grab(obd, &body->fid1); - if (!obj2 && (mea = lmv_get_mea(*reqp, DLM_REPLY_REC_OFF))) { + if (!obj2 && (mea = lmv_get_mea(*reqp))) { /* FIXME remote capability! */ /* wow! this is split dir, we'd like to handle it. */ @@ -553,10 +547,8 @@ int lmv_lookup_slaves(struct obd_export *exp, struct ptlrpc_request **reqp) if (op_data == NULL) RETURN(-ENOMEM); - body = lustre_msg_buf((*reqp)->rq_repmsg, - DLM_REPLY_REC_OFF, sizeof(*body)); + body = req_capsule_server_get(&(*reqp)->rq_pill, &RMF_MDT_BODY); LASSERT(body != NULL); - LASSERT(lustre_rep_swabbed(*reqp, DLM_REPLY_REC_OFF)); LASSERT((body->valid & OBD_MD_FLID) != 0); obj = lmv_obj_grab(obd, &body->fid1); @@ -612,10 +604,8 @@ int lmv_lookup_slaves(struct obd_export *exp, struct ptlrpc_request **reqp) lock->l_ast_data = lmv_obj_get(obj); - body2 = lustre_msg_buf(req->rq_repmsg, - DLM_REPLY_REC_OFF, sizeof(*body2)); + body2 = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY); LASSERT(body2 != NULL); - LASSERT(lustre_rep_swabbed(req, DLM_REPLY_REC_OFF)); obj->lo_inodes[i].li_size = body2->size; @@ -788,12 +778,10 @@ repeat: rc = lmv_intent_remote(exp, lmm, lmmsize, it, flags, reqp, cb_blocking, extra_lock_flags); - if (rc == 0 && (mea = lmv_get_mea(*reqp, DLM_REPLY_REC_OFF))) { + if (rc == 0 && (mea = lmv_get_mea(*reqp))) { /* Wow! This is split dir, we'd like to handle it. */ - body = lustre_msg_buf((*reqp)->rq_repmsg, - DLM_REPLY_REC_OFF, sizeof(*body)); + body = req_capsule_server_get(&(*reqp)->rq_pill, &RMF_MDT_BODY); LASSERT(body != NULL); - LASSERT(lustre_rep_swabbed(*reqp, DLM_REPLY_REC_OFF)); LASSERT((body->valid & OBD_MD_FLID) != 0); obj = lmv_obj_grab(obd, &body->fid1); @@ -914,12 +902,10 @@ int lmv_revalidate_slaves(struct obd_export *exp, struct ptlrpc_request **reqp, * It even got the reply refresh attrs * from that reply. */ - body = lustre_msg_buf(mreq->rq_repmsg, - DLM_REPLY_REC_OFF, - sizeof(*body)); + body = req_capsule_server_get( + &mreq->rq_pill, + &RMF_MDT_BODY); LASSERT(body != NULL); - LASSERT(lustre_rep_swabbed( - mreq, DLM_REPLY_REC_OFF)); goto update; } /* take already cached attrs into account */ @@ -979,10 +965,8 @@ int lmv_revalidate_slaves(struct obd_export *exp, struct ptlrpc_request **reqp, *reqp = req; } - body = lustre_msg_buf(req->rq_repmsg, - DLM_REPLY_REC_OFF, sizeof(*body)); + body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY); LASSERT(body != NULL); - LASSERT(lustre_rep_swabbed(req, DLM_REPLY_REC_OFF)); update: obj->lo_inodes[i].li_size = body->size; @@ -1009,10 +993,8 @@ release_lock: CDEBUG(D_OTHER, "return refreshed attrs: size = %lu\n", (unsigned long)size); - body = lustre_msg_buf((*reqp)->rq_repmsg, - DLM_REPLY_REC_OFF, sizeof(*body)); + body = req_capsule_server_get(&(*reqp)->rq_pill, &RMF_MDT_BODY); LASSERT(body != NULL); - LASSERT(lustre_rep_swabbed(*reqp, DLM_REPLY_REC_OFF)); body->size = size; diff --git a/lustre/lmv/lmv_internal.h b/lustre/lmv/lmv_internal.h index d4cce7f..76f4053 100644 --- a/lustre/lmv/lmv_internal.h +++ b/lustre/lmv/lmv_internal.h @@ -147,21 +147,20 @@ int lmv_alloc_slave_fids(struct obd_device *obd, struct lu_fid *pid, struct md_op_data *op, struct lu_fid *fid); static inline struct lmv_stripe_md * -lmv_get_mea(struct ptlrpc_request *req, int offset) +lmv_get_mea(struct ptlrpc_request *req) { struct mdt_body *body; struct lmv_stripe_md *mea; LASSERT(req); - body = lustre_msg_buf(req->rq_repmsg, offset, sizeof(*body)); - LASSERT(lustre_rep_swabbed(req, offset)); + body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY); if (!body || !S_ISDIR(body->mode) || !body->eadatasize) return NULL; - mea = lustre_msg_buf(req->rq_repmsg, offset + 1, - body->eadatasize); + mea = req_capsule_server_sized_get(&req->rq_pill, &RMF_MDT_MD, + body->eadatasize); LASSERT(mea != NULL); if (mea->mea_count == 0) diff --git a/lustre/lmv/lmv_obd.c b/lustre/lmv/lmv_obd.c index 783f4b6..0db253c 100644 --- a/lustre/lmv/lmv_obd.c +++ b/lustre/lmv/lmv_obd.c @@ -1195,10 +1195,9 @@ static int lmv_getattr(struct obd_export *exp, const struct lu_fid *fid, RETURN(rc); } - body = lustre_msg_buf((*request)->rq_repmsg, REPLY_REC_OFF, - sizeof(*body)); + body = req_capsule_server_get(&(*request)->rq_pill, + &RMF_MDT_BODY); LASSERT(body != NULL); - LASSERT(lustre_rep_swabbed(*request, REPLY_REC_OFF)); lmv_obj_lock(obj); @@ -1304,7 +1303,7 @@ int lmv_handle_split(struct obd_export *exp, const struct lu_fid *fid) GOTO(cleanup, rc); } - rc = md_get_lustre_md(tgt_exp, req, 1, NULL, exp, &md); + rc = md_get_lustre_md(tgt_exp, req, NULL, exp, &md); if (rc) { CERROR("mdc_get_lustre_md() failed, error %d\n", rc); GOTO(cleanup, rc); @@ -1514,10 +1513,8 @@ lmv_enqueue_remote(struct obd_export *exp, struct ldlm_enqueue_info *einfo, int rc = 0, pmode; ENTRY; - body = lustre_msg_buf(req->rq_repmsg, - DLM_REPLY_REC_OFF, sizeof(*body)); + body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY); LASSERT(body != NULL); - LASSERT(lustre_rep_swabbed(req, DLM_REPLY_REC_OFF)); if (!(body->valid & OBD_MD_MDS)) RETURN(0); @@ -1659,10 +1656,9 @@ repeat: rc = md_getattr_name(tgt_exp, &rid, oc, filename, namelen, valid, ea_size, suppgid, request); if (rc == 0) { - body = lustre_msg_buf((*request)->rq_repmsg, - REQ_REC_OFF, sizeof(*body)); + body = req_capsule_server_get(&(*request)->rq_pill, + &RMF_MDT_BODY); LASSERT(body != NULL); - LASSERT(lustre_rep_swabbed(*request, REQ_REC_OFF)); if (body->valid & OBD_MD_MDS) { struct ptlrpc_request *req = NULL; @@ -2741,16 +2737,15 @@ ldlm_mode_t lmv_lock_match(struct obd_export *exp, int flags, } int lmv_get_lustre_md(struct obd_export *exp, struct ptlrpc_request *req, - int offset, struct obd_export *dt_exp, - struct obd_export *md_exp, struct lustre_md *md) + struct obd_export *dt_exp, struct obd_export *md_exp, + struct lustre_md *md) { struct obd_device *obd = exp->exp_obd; struct lmv_obd *lmv = &obd->u.lmv; int rc; ENTRY; - rc = md_get_lustre_md(lmv->tgts[0].ltd_exp, req, offset, dt_exp, md_exp, - md); + rc = md_get_lustre_md(lmv->tgts[0].ltd_exp, req, dt_exp, md_exp, md); RETURN(rc); } diff --git a/lustre/lmv/lmv_object.c b/lustre/lmv/lmv_object.c index 68c4bca..922eea5 100644 --- a/lustre/lmv/lmv_object.c +++ b/lustre/lmv/lmv_object.c @@ -328,7 +328,7 @@ lmv_obj_create(struct obd_export *exp, const struct lu_fid *fid, GOTO(cleanup, obj = ERR_PTR(rc)); } - rc = md_get_lustre_md(exp, req, 0, NULL, exp, &md); + rc = md_get_lustre_md(exp, req, NULL, exp, &md); if (rc) { CERROR("mdc_get_lustre_md() failed, error %d\n", rc); GOTO(cleanup, obj = ERR_PTR(rc)); diff --git a/lustre/mdc/mdc_internal.h b/lustre/mdc/mdc_internal.h index dda6f11..2bf1326 100644 --- a/lustre/mdc/mdc_internal.h +++ b/lustre/mdc/mdc_internal.h @@ -35,43 +35,36 @@ static inline void lprocfs_mdc_init_vars(struct lprocfs_static_vars *lvars) memset(lvars, 0, sizeof(*lvars)); } #endif -void mdc_pack_req_body(struct ptlrpc_request *req, int offset, - __u64 valid, const struct lu_fid *fid, - struct obd_capa *oc, int ea_size, - __u32 suppgid, int flags); -void mdc_pack_capa(struct ptlrpc_request *req, int offset, struct obd_capa *oc); -void mdc_pack_rep_body(struct ptlrpc_request *); -void mdc_is_subdir_pack(struct ptlrpc_request *req, int offset, - const struct lu_fid *pfid, const struct lu_fid *cfid, - int flags); -void mdc_readdir_pack(struct ptlrpc_request *req, int pos, __u64 offset, - __u32 size, const struct lu_fid *fid, - struct obd_capa *oc); -void mdc_getattr_pack(struct ptlrpc_request *req, int offset, __u64 valid, - int flags, struct md_op_data *data); -void mdc_setattr_pack(struct ptlrpc_request *req, int offset, - struct md_op_data *op_data, - void *ea, int ealen, void *ea2, int ea2len); -void mdc_create_pack(struct ptlrpc_request *req, int offset, - struct md_op_data *op_data, const void *data, int datalen, - __u32 mode, __u32 uid, __u32 gid, __u32 cap_effective, - __u64 rdev); -void mdc_open_pack(struct ptlrpc_request *req, int offset, - struct md_op_data *op_data, __u32 mode, __u64 rdev, - __u32 flags, const void *data, int datalen); -void mdc_join_pack(struct ptlrpc_request *req, int offset, - struct md_op_data *op_data, __u64 head_size); -void mdc_unlink_pack(struct ptlrpc_request *req, int offset, - struct md_op_data *op_data); -void mdc_link_pack(struct ptlrpc_request *req, int offset, - struct md_op_data *op_data); -void mdc_rename_pack(struct ptlrpc_request *req, int offset, - struct md_op_data *op_data, + +void mdc_pack_body(struct ptlrpc_request *req, const struct lu_fid *fid, + struct obd_capa *oc, __u64 valid, int ea_size, + __u32 suppgid, int flags); +void mdc_pack_capa(struct ptlrpc_request *req, const struct req_msg_field *field, + struct obd_capa *oc); +int mdc_pack_req(struct ptlrpc_request *req, int version, int opc); +void mdc_is_subdir_pack(struct ptlrpc_request *req, const struct lu_fid *pfid, + const struct lu_fid *cfid, int flags); +void mdc_readdir_pack(struct ptlrpc_request *req, __u64 pgoff, __u32 size, + const struct lu_fid *fid, struct obd_capa *oc); +void mdc_getattr_pack(struct ptlrpc_request *req, __u64 valid, int flags, + struct md_op_data *data); +void mdc_setattr_pack(struct ptlrpc_request *req, struct md_op_data *op_data, + void *ea, int ealen, void *ea2, int ea2len); +void mdc_create_pack(struct ptlrpc_request *req, struct md_op_data *op_data, + const void *data, int datalen, __u32 mode, __u32 uid, + __u32 gid, __u32 cap_effective, __u64 rdev); +void mdc_open_pack(struct ptlrpc_request *req, struct md_op_data *op_data, + __u32 mode, __u64 rdev, __u32 flags, const void *data, + int datalen); +void mdc_join_pack(struct ptlrpc_request *req, struct md_op_data *op_data, + __u64 head_size); +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, const char *old, int oldlen, const char *new, int newlen); -void mdc_close_pack(struct ptlrpc_request *req, int offset, - struct md_op_data *op_data); -void mdc_exit_request(struct client_obd *cli); +void mdc_close_pack(struct ptlrpc_request *req, struct md_op_data *op_data); void mdc_enter_request(struct client_obd *cli); +void mdc_exit_request(struct client_obd *cli); static inline int client_is_remote(struct obd_export *exp) { @@ -127,8 +120,7 @@ int mdc_open(struct obd_export *exp, obd_id ino, int type, int flags, struct obd_client_handle; int mdc_get_lustre_md(struct obd_export *md_exp, struct ptlrpc_request *req, - int offset, struct obd_export *dt_exp, - struct obd_export *lmv_exp, + struct obd_export *dt_exp, struct obd_export *lmv_exp, struct lustre_md *md); int mdc_free_lustre_md(struct obd_export *exp, struct lustre_md *md); @@ -157,6 +149,18 @@ int mdc_unlink(struct obd_export *exp, struct md_op_data *op_data, int mdc_cancel_unused(struct obd_export *exp, const struct lu_fid *fid, ldlm_policy_data_t *policy, ldlm_mode_t mode, int flags, void *opaque); + +static inline void mdc_set_capa_size(struct ptlrpc_request *req, + const struct req_msg_field *field, + struct obd_capa *oc) +{ + if (oc == NULL) + req_capsule_set_size(&req->rq_pill, field, RCL_CLIENT, 0); + else + /* it is already calculated as sizeof struct obd_capa */ + ; +} + ldlm_mode_t mdc_lock_match(struct obd_export *exp, int flags, const struct lu_fid *fid, ldlm_type_t type, ldlm_policy_data_t *policy, ldlm_mode_t mode, diff --git a/lustre/mdc/mdc_lib.c b/lustre/mdc/mdc_lib.c index 66e5ad3..de09e61 100644 --- a/lustre/mdc/mdc_lib.c +++ b/lustre/mdc/mdc_lib.c @@ -38,7 +38,7 @@ #endif #endif -static void mdc_pack_body(struct mdt_body *b, __u32 suppgid) +static void __mdc_pack_body(struct mdt_body *b, __u32 suppgid) { LASSERT (b != NULL); @@ -50,97 +50,102 @@ static void mdc_pack_body(struct mdt_body *b, __u32 suppgid) b->capability = current->cap_effective; } -void mdc_pack_capa(struct ptlrpc_request *req, int offset, struct obd_capa *oc) +void mdc_pack_capa(struct ptlrpc_request *req, const struct req_msg_field *field, + struct obd_capa *oc) { + struct req_capsule *pill = &req->rq_pill; struct lustre_capa *c; if (oc == NULL) { - LASSERT(lustre_msg_buflen(req->rq_reqmsg, offset) == 0); + LASSERT(req_capsule_get_size(pill, field, RCL_CLIENT) == 0); return; } - c = lustre_msg_buf(req->rq_reqmsg, offset, sizeof(*c)); + c = req_capsule_client_get(pill, field); LASSERT(c != NULL); capa_cpy(c, oc); DEBUG_CAPA(D_SEC, c, "pack"); } -void mdc_is_subdir_pack(struct ptlrpc_request *req, int offset, - const struct lu_fid *pfid, +void mdc_is_subdir_pack(struct ptlrpc_request *req, const struct lu_fid *pfid, const struct lu_fid *cfid, int flags) { - struct mdt_body *b = lustre_msg_buf(req->rq_reqmsg, offset, sizeof(*b)); + struct mdt_body *b = req_capsule_client_get(&req->rq_pill, + &RMF_MDT_BODY); - if (pfid) + if (pfid) { b->fid1 = *pfid; + b->valid = OBD_MD_FLID; + } if (cfid) b->fid2 = *cfid; - b->valid = OBD_MD_FLID; b->flags = flags; } -void mdc_pack_req_body(struct ptlrpc_request *req, int offset, - __u64 valid, const struct lu_fid *fid, - struct obd_capa *oc, int ea_size, __u32 suppgid, - int flags) +void mdc_pack_body(struct ptlrpc_request *req, + const struct lu_fid *fid, struct obd_capa *oc, + __u64 valid, int ea_size, __u32 suppgid, int flags) { - struct mdt_body *b = lustre_msg_buf(req->rq_reqmsg, offset, sizeof(*b)); - + struct mdt_body *b = req_capsule_client_get(&req->rq_pill, + &RMF_MDT_BODY); + LASSERT(b != NULL); b->valid = valid; b->eadatasize = ea_size; b->flags = flags; - mdc_pack_body(b, suppgid); + __mdc_pack_body(b, suppgid); if (fid) { b->fid1 = *fid; - mdc_pack_capa(req, offset + 1, oc); + b->valid |= OBD_MD_FLID; + mdc_pack_capa(req, &RMF_CAPA1, oc); } } -void mdc_readdir_pack(struct ptlrpc_request *req, int offset, __u64 pgoff, +void mdc_readdir_pack(struct ptlrpc_request *req, __u64 pgoff, __u32 size, const struct lu_fid *fid, struct obd_capa *oc) { - struct mdt_body *b; - - b = lustre_msg_buf(req->rq_reqmsg, offset, sizeof(*b)); + struct mdt_body *b = req_capsule_client_get(&req->rq_pill, + &RMF_MDT_BODY); b->fid1 = *fid; + b->valid |= OBD_MD_FLID; b->size = pgoff; /* !! */ b->nlink = size; /* !! */ - mdc_pack_body(b, -1); - mdc_pack_capa(req, offset + 1, oc); + __mdc_pack_body(b, -1); + mdc_pack_capa(req, &RMF_CAPA1, oc); } /* packing of MDS records */ -void mdc_create_pack(struct ptlrpc_request *req, int offset, - struct md_op_data *op_data, const void *data, int datalen, - __u32 mode, __u32 uid, __u32 gid, __u32 cap_effective, - __u64 rdev) +void mdc_create_pack(struct ptlrpc_request *req, struct md_op_data *op_data, + const void *data, int datalen, __u32 mode, + __u32 uid, __u32 gid, __u32 cap_effective, __u64 rdev) { struct mdt_rec_create *rec; - char *tmp; - - rec = lustre_msg_buf(req->rq_reqmsg, offset, sizeof(*rec)); - - rec->cr_opcode = REINT_CREATE; - rec->cr_fsuid = uid; - rec->cr_fsgid = gid; - rec->cr_cap = cap_effective; - rec->cr_fid1 = op_data->op_fid1; - rec->cr_fid2 = op_data->op_fid2; - rec->cr_mode = mode; - rec->cr_rdev = rdev; - rec->cr_time = op_data->op_mod_time; + char *tmp; + + CLASSERT(sizeof(struct mdt_rec_reint) == sizeof(struct mdt_rec_create)); + rec = req_capsule_client_get(&req->rq_pill, &RMF_REC_REINT); + + + rec->cr_opcode = REINT_CREATE; + rec->cr_fsuid = uid; + rec->cr_fsgid = gid; + rec->cr_cap = cap_effective; + rec->cr_fid1 = op_data->op_fid1; + rec->cr_fid2 = op_data->op_fid2; + rec->cr_mode = mode; + rec->cr_rdev = rdev; + rec->cr_time = op_data->op_mod_time; rec->cr_suppgid1 = op_data->op_suppgids[0]; rec->cr_suppgid2 = op_data->op_suppgids[1]; - rec->cr_flags = op_data->op_flags & ~MF_SOM_LOCAL_FLAGS; - rec->cr_bias = op_data->op_bias; + rec->cr_flags = op_data->op_flags & ~MF_SOM_LOCAL_FLAGS; + rec->cr_bias = op_data->op_bias; - mdc_pack_capa(req, offset + 1, op_data->op_capa1); + mdc_pack_capa(req, &RMF_CAPA1, op_data->op_capa1); - tmp = lustre_msg_buf(req->rq_reqmsg, offset + 2, op_data->op_namelen + 1); + tmp = req_capsule_client_get(&req->rq_pill, &RMF_NAME); LOGL0(op_data->op_name, op_data->op_namelen, tmp); if (data) { - tmp = lustre_msg_buf(req->rq_reqmsg, offset + 3, datalen); + tmp = req_capsule_client_get(&req->rq_pill, &RMF_EADATA); memcpy(tmp, data, datalen); } } @@ -175,49 +180,51 @@ static __u32 mds_pack_open_flags(__u32 flags) } /* packing of MDS records */ -void mdc_join_pack(struct ptlrpc_request *req, int offset, - struct md_op_data *op_data, __u64 head_size) +void mdc_join_pack(struct ptlrpc_request *req, + struct md_op_data *op_data, + __u64 head_size) { struct mdt_rec_join *rec; - rec = lustre_msg_buf(req->rq_reqmsg, offset, sizeof(*rec)); + rec = req_capsule_client_get(&req->rq_pill, &RMF_REC_JOINFILE); LASSERT(rec != NULL); rec->jr_fid = op_data->op_fid2; rec->jr_headsize = head_size; } -void mdc_open_pack(struct ptlrpc_request *req, int offset, - struct md_op_data *op_data, __u32 mode, __u64 rdev, - __u32 flags, const void *lmm, int lmmlen) +void mdc_open_pack(struct ptlrpc_request *req, struct md_op_data *op_data, + __u32 mode, __u64 rdev, __u32 flags, const void *lmm, + int lmmlen) { struct mdt_rec_create *rec; char *tmp; - rec = lustre_msg_buf(req->rq_reqmsg, offset, sizeof (*rec)); + + CLASSERT(sizeof(struct mdt_rec_reint) == sizeof(struct mdt_rec_create)); + rec = req_capsule_client_get(&req->rq_pill, &RMF_REC_REINT); /* XXX do something about time, uid, gid */ - rec->cr_opcode = REINT_OPEN; - rec->cr_fsuid = current->fsuid; - rec->cr_fsgid = current->fsgid; - rec->cr_cap = current->cap_effective; + rec->cr_opcode = REINT_OPEN; + rec->cr_fsuid = current->fsuid; + rec->cr_fsgid = current->fsgid; + rec->cr_cap = current->cap_effective; if (op_data != NULL) { rec->cr_fid1 = op_data->op_fid1; rec->cr_fid2 = op_data->op_fid2; } - rec->cr_mode = mode; - rec->cr_flags = mds_pack_open_flags(flags); - rec->cr_time = op_data->op_mod_time; - rec->cr_rdev = rdev; + rec->cr_mode = mode; + rec->cr_flags = mds_pack_open_flags(flags); + rec->cr_rdev = rdev; + rec->cr_time = op_data->op_mod_time; rec->cr_suppgid1 = op_data->op_suppgids[0]; rec->cr_suppgid2 = op_data->op_suppgids[1]; - rec->cr_bias = op_data->op_bias; + rec->cr_bias = op_data->op_bias; - mdc_pack_capa(req, offset + 1, op_data->op_capa1); + mdc_pack_capa(req, &RMF_CAPA1, op_data->op_capa1); /* the next buffer is child capa, which is used for replay, * will be packed from the data in reply message. */ if (op_data->op_name) { - tmp = lustre_msg_buf(req->rq_reqmsg, offset + 3, - op_data->op_namelen + 1); + tmp = req_capsule_client_get(&req->rq_pill, &RMF_NAME); LOGL0(op_data->op_name, op_data->op_namelen, tmp); } @@ -227,7 +234,7 @@ void mdc_open_pack(struct ptlrpc_request *req, int offset, /*XXX a hack for liblustre to set EA (LL_IOC_LOV_SETSTRIPE) */ rec->cr_fid2 = op_data->op_fid2; #endif - tmp = lustre_msg_buf(req->rq_reqmsg, offset + 4, lmmlen); + tmp = req_capsule_client_get(&req->rq_pill, &RMF_EADATA); memcpy (tmp, lmm, lmmlen); } } @@ -276,22 +283,22 @@ static inline __u64 attr_pack(unsigned int ia_valid) { static void mdc_setattr_pack_rec(struct mdt_rec_setattr *rec, struct md_op_data *op_data) { - rec->sa_opcode = REINT_SETATTR; - rec->sa_fsuid = current->fsuid; - rec->sa_fsgid = current->fsgid; - rec->sa_cap = current->cap_effective; + rec->sa_opcode = REINT_SETATTR; + rec->sa_fsuid = current->fsuid; + rec->sa_fsgid = current->fsgid; + rec->sa_cap = current->cap_effective; rec->sa_suppgid = -1; - rec->sa_fid = op_data->op_fid1; - rec->sa_valid = attr_pack(op_data->op_attr.ia_valid); - rec->sa_mode = op_data->op_attr.ia_mode; - rec->sa_uid = op_data->op_attr.ia_uid; - rec->sa_gid = op_data->op_attr.ia_gid; - rec->sa_size = op_data->op_attr.ia_size; + rec->sa_fid = op_data->op_fid1; + rec->sa_valid = attr_pack(op_data->op_attr.ia_valid); + rec->sa_mode = op_data->op_attr.ia_mode; + rec->sa_uid = op_data->op_attr.ia_uid; + rec->sa_gid = op_data->op_attr.ia_gid; + rec->sa_size = op_data->op_attr.ia_size; rec->sa_blocks = op_data->op_attr_blocks; - rec->sa_atime = LTIME_S(op_data->op_attr.ia_atime); - rec->sa_mtime = LTIME_S(op_data->op_attr.ia_mtime); - rec->sa_ctime = LTIME_S(op_data->op_attr.ia_ctime); + rec->sa_atime = LTIME_S(op_data->op_attr.ia_atime); + rec->sa_mtime = LTIME_S(op_data->op_attr.ia_mtime); + rec->sa_ctime = LTIME_S(op_data->op_attr.ia_ctime); rec->sa_attr_flags = ((struct ll_iattr *)&op_data->op_attr)->ia_attr_flags; if ((op_data->op_attr.ia_valid & ATTR_GID) && in_group_p(op_data->op_attr.ia_gid)) @@ -307,127 +314,129 @@ static void mdc_epoch_pack(struct mdt_epoch *epoch, struct md_op_data *op_data) epoch->flags = op_data->op_flags & ~MF_SOM_LOCAL_FLAGS; } -void mdc_setattr_pack(struct ptlrpc_request *req, int offset, - struct md_op_data *op_data, void *ea, - int ealen, void *ea2, int ea2len) +void mdc_setattr_pack(struct ptlrpc_request *req, struct md_op_data *op_data, + void *ea, int ealen, void *ea2, int ea2len) { struct mdt_rec_setattr *rec; struct mdt_epoch *epoch; - rec = lustre_msg_buf(req->rq_reqmsg, offset, sizeof (*rec)); + CLASSERT(sizeof(struct mdt_rec_reint) ==sizeof(struct mdt_rec_setattr)); + rec = req_capsule_client_get(&req->rq_pill, &RMF_REC_REINT); mdc_setattr_pack_rec(rec, op_data); - mdc_pack_capa(req, offset + 1, op_data->op_capa1); + mdc_pack_capa(req, &RMF_CAPA1, op_data->op_capa1); if (op_data->op_flags & (MF_SOM_CHANGE | MF_EPOCH_OPEN)) { - epoch = lustre_msg_buf(req->rq_reqmsg, offset + 2, - sizeof(*epoch)); + epoch = req_capsule_client_get(&req->rq_pill, &RMF_MDT_EPOCH); mdc_epoch_pack(epoch, op_data); } if (ealen == 0) return; - memcpy(lustre_msg_buf(req->rq_reqmsg, offset + 3, ealen), ea, ealen); + memcpy(req_capsule_client_get(&req->rq_pill, &RMF_EADATA), ea, ealen); if (ea2len == 0) return; - memcpy(lustre_msg_buf(req->rq_reqmsg, offset + 4, ea2len), ea2, ea2len); + memcpy(req_capsule_client_get(&req->rq_pill, &RMF_LOGCOOKIES), ea2, + ea2len); } -void mdc_unlink_pack(struct ptlrpc_request *req, int offset, - struct md_op_data *op_data) +void mdc_unlink_pack(struct ptlrpc_request *req, struct md_op_data *op_data) { struct mdt_rec_unlink *rec; char *tmp; - - rec = lustre_msg_buf(req->rq_reqmsg, offset, sizeof (*rec)); + + CLASSERT(sizeof(struct mdt_rec_reint) == sizeof(struct mdt_rec_unlink)); + rec = req_capsule_client_get(&req->rq_pill, &RMF_REC_REINT); LASSERT (rec != NULL); - rec->ul_opcode = REINT_UNLINK; - rec->ul_fsuid = op_data->op_fsuid;//current->fsuid; - rec->ul_fsgid = op_data->op_fsgid;//current->fsgid; - rec->ul_cap = op_data->op_cap;//current->cap_effective; - rec->ul_mode = op_data->op_mode; - rec->ul_suppgid = op_data->op_suppgids[0]; - rec->ul_fid1 = op_data->op_fid1; - rec->ul_fid2 = op_data->op_fid2; - rec->ul_time = op_data->op_mod_time; - rec->ul_bias = op_data->op_bias; - - mdc_pack_capa(req, offset + 1, op_data->op_capa1); - - tmp = lustre_msg_buf(req->rq_reqmsg, offset + 2, op_data->op_namelen + 1); + rec->ul_opcode = REINT_UNLINK; + rec->ul_fsuid = op_data->op_fsuid; + rec->ul_fsgid = op_data->op_fsgid; + rec->ul_cap = op_data->op_cap; + rec->ul_mode = op_data->op_mode; + rec->ul_suppgid1= op_data->op_suppgids[0]; + rec->ul_suppgid2= -1; + rec->ul_fid1 = op_data->op_fid1; + rec->ul_fid2 = op_data->op_fid2; + rec->ul_time = op_data->op_mod_time; + rec->ul_bias = op_data->op_bias; + + mdc_pack_capa(req, &RMF_CAPA1, op_data->op_capa1); + + tmp = req_capsule_client_get(&req->rq_pill, &RMF_NAME); LASSERT(tmp != NULL); LOGL0(op_data->op_name, op_data->op_namelen, tmp); } -void mdc_link_pack(struct ptlrpc_request *req, int offset, - struct md_op_data *op_data) +void mdc_link_pack(struct ptlrpc_request *req, struct md_op_data *op_data) { struct mdt_rec_link *rec; char *tmp; - rec = lustre_msg_buf(req->rq_reqmsg, offset, sizeof (*rec)); + CLASSERT(sizeof(struct mdt_rec_reint) == sizeof(struct mdt_rec_link)); + rec = req_capsule_client_get(&req->rq_pill, &RMF_REC_REINT); + LASSERT (rec != NULL); - rec->lk_opcode = REINT_LINK; - rec->lk_fsuid = op_data->op_fsuid;//current->fsuid; - rec->lk_fsgid = op_data->op_fsgid;//current->fsgid; - rec->lk_cap = op_data->op_cap;//current->cap_effective; + rec->lk_opcode = REINT_LINK; + rec->lk_fsuid = op_data->op_fsuid;//current->fsuid; + rec->lk_fsgid = op_data->op_fsgid;//current->fsgid; + rec->lk_cap = op_data->op_cap;//current->cap_effective; rec->lk_suppgid1 = op_data->op_suppgids[0]; rec->lk_suppgid2 = op_data->op_suppgids[1]; - rec->lk_fid1 = op_data->op_fid1; - rec->lk_fid2 = op_data->op_fid2; - rec->lk_time = op_data->op_mod_time; - rec->lk_bias = op_data->op_bias; + rec->lk_fid1 = op_data->op_fid1; + rec->lk_fid2 = op_data->op_fid2; + rec->lk_time = op_data->op_mod_time; + rec->lk_bias = op_data->op_bias; - mdc_pack_capa(req, offset + 1, op_data->op_capa1); - mdc_pack_capa(req, offset + 2, op_data->op_capa2); + mdc_pack_capa(req, &RMF_CAPA1, op_data->op_capa1); + mdc_pack_capa(req, &RMF_CAPA2, op_data->op_capa2); - tmp = lustre_msg_buf(req->rq_reqmsg, offset + 3, op_data->op_namelen + 1); + tmp = req_capsule_client_get(&req->rq_pill, &RMF_NAME); LOGL0(op_data->op_name, op_data->op_namelen, tmp); } -void mdc_rename_pack(struct ptlrpc_request *req, int offset, - struct md_op_data *op_data, +void mdc_rename_pack(struct ptlrpc_request *req, struct md_op_data *op_data, const char *old, int oldlen, const char *new, int newlen) { struct mdt_rec_rename *rec; char *tmp; - rec = lustre_msg_buf(req->rq_reqmsg, offset, sizeof (*rec)); + CLASSERT(sizeof(struct mdt_rec_reint) == sizeof(struct mdt_rec_rename)); + rec = req_capsule_client_get(&req->rq_pill, &RMF_REC_REINT); /* XXX do something about time, uid, gid */ - rec->rn_opcode = REINT_RENAME; - rec->rn_fsuid = op_data->op_fsuid;//current->fsuid; - rec->rn_fsgid = op_data->op_fsgid;//current->fsgid; - rec->rn_cap = op_data->op_cap;//current->cap_effective; + rec->rn_opcode = REINT_RENAME; + rec->rn_fsuid = op_data->op_fsuid; + rec->rn_fsgid = op_data->op_fsgid; + rec->rn_cap = op_data->op_cap; rec->rn_suppgid1 = op_data->op_suppgids[0]; rec->rn_suppgid2 = op_data->op_suppgids[1]; - rec->rn_fid1 = op_data->op_fid1; - rec->rn_fid2 = op_data->op_fid2; - rec->rn_time = op_data->op_mod_time; - rec->rn_mode = op_data->op_mode; - rec->rn_bias = op_data->op_bias; + rec->rn_fid1 = op_data->op_fid1; + rec->rn_fid2 = op_data->op_fid2; + rec->rn_time = op_data->op_mod_time; + rec->rn_mode = op_data->op_mode; + rec->rn_bias = op_data->op_bias; - mdc_pack_capa(req, offset + 1, op_data->op_capa1); - mdc_pack_capa(req, offset + 2, op_data->op_capa2); + mdc_pack_capa(req, &RMF_CAPA1, op_data->op_capa1); + mdc_pack_capa(req, &RMF_CAPA2, op_data->op_capa2); - tmp = lustre_msg_buf(req->rq_reqmsg, offset + 3, oldlen + 1); + tmp = req_capsule_client_get(&req->rq_pill, &RMF_NAME); LOGL0(old, oldlen, tmp); if (new) { - tmp = lustre_msg_buf(req->rq_reqmsg, offset + 4, newlen + 1); + tmp = req_capsule_client_get(&req->rq_pill, &RMF_SYMTGT); LOGL0(new, newlen, tmp); } } -void mdc_getattr_pack(struct ptlrpc_request *req, int offset, __u64 valid, - int flags, struct md_op_data *op_data) +void mdc_getattr_pack(struct ptlrpc_request *req, __u64 valid, int flags, + struct md_op_data *op_data) { - struct mdt_body *b; - b = lustre_msg_buf(req->rq_reqmsg, offset, sizeof (*b)); + struct mdt_body *b = req_capsule_client_get(&req->rq_pill, + &RMF_MDT_BODY); b->fsuid = current->fsuid; b->fsgid = current->fsgid; @@ -442,28 +451,26 @@ void mdc_getattr_pack(struct ptlrpc_request *req, int offset, __u64 valid, b->fid1 = op_data->op_fid1; b->fid2 = op_data->op_fid2; + b->valid |= OBD_MD_FLID; - mdc_pack_capa(req, offset + 1, op_data->op_capa1); + mdc_pack_capa(req, &RMF_CAPA1, op_data->op_capa1); if (op_data->op_name) { - char *tmp; - tmp = lustre_msg_buf(req->rq_reqmsg, offset + 2, - op_data->op_namelen + 1); + char *tmp = req_capsule_client_get(&req->rq_pill, &RMF_NAME); LOGL0(op_data->op_name, op_data->op_namelen, tmp); } } -void mdc_close_pack(struct ptlrpc_request *req, int offset, - struct md_op_data *op_data) +void mdc_close_pack(struct ptlrpc_request *req, struct md_op_data *op_data) { struct mdt_epoch *epoch; struct mdt_rec_setattr *rec; - epoch = lustre_msg_buf(req->rq_reqmsg, offset, sizeof(*epoch)); - rec = lustre_msg_buf(req->rq_reqmsg, offset + 1, sizeof(*rec)); + epoch = req_capsule_client_get(&req->rq_pill, &RMF_MDT_EPOCH); + rec = req_capsule_client_get(&req->rq_pill, &RMF_REC_REINT); mdc_setattr_pack_rec(rec, op_data); - mdc_pack_capa(req, offset + 2, op_data->op_capa1); + mdc_pack_capa(req, &RMF_CAPA1, op_data->op_capa1); mdc_epoch_pack(epoch, op_data); } diff --git a/lustre/mdc/mdc_locks.c b/lustre/mdc/mdc_locks.c index 73b3d73..70aca4a 100644 --- a/lustre/mdc/mdc_locks.c +++ b/lustre/mdc/mdc_locks.c @@ -226,11 +226,11 @@ static inline void mdc_clear_replay_flag(struct ptlrpc_request *req, int rc) * but this is incredibly unlikely, and questionable whether the client * could do MDS recovery under OOM anyways... */ static void mdc_realloc_openmsg(struct ptlrpc_request *req, - struct mdt_body *body, int size[9]) + struct mdt_body *body) { int rc; - ENTRY; + /* FIXME: remove this explicit offset. */ rc = sptlrpc_cli_enlarge_reqbuf(req, DLM_INTENT_REC_OFF + 4, body->eadatasize); if (rc) { @@ -239,196 +239,270 @@ static void mdc_realloc_openmsg(struct ptlrpc_request *req, body->valid &= ~OBD_MD_FLEASIZE; body->eadatasize = 0; } - EXIT; } -/* We always reserve enough space in the reply packet for a stripe MD, because - * we don't know in advance the file type. */ -int mdc_enqueue(struct obd_export *exp, struct ldlm_enqueue_info *einfo, - struct lookup_intent *it, struct md_op_data *op_data, - struct lustre_handle *lockh, void *lmm, int lmmsize, - int extra_lock_flags) +static struct ptlrpc_request *mdc_intent_open_pack(struct obd_export *exp, + struct lookup_intent *it, + struct md_op_data *op_data, + void *lmm, int lmmsize, + void *cb_data) { struct ptlrpc_request *req; - struct obd_device *obddev = class_exp2obd(exp); - struct ldlm_res_id res_id = - { .name = {fid_seq(&op_data->op_fid1), - fid_oid(&op_data->op_fid1), - fid_ver(&op_data->op_fid1)} }; - ldlm_policy_data_t policy = { .l_inodebits = { MDS_INODELOCK_LOOKUP } }; - struct ldlm_request *lockreq; - struct ldlm_intent *lit; - struct ldlm_reply *lockrep; - int size[9] = { [MSG_PTLRPC_BODY_OFF] = sizeof(struct ptlrpc_body), - [DLM_LOCKREQ_OFF] = sizeof(*lockreq), - [DLM_INTENT_IT_OFF] = sizeof(*lit), - 0, 0, 0, 0, 0, 0 }; - int repsize[7] = { [MSG_PTLRPC_BODY_OFF] = sizeof(struct ptlrpc_body), - [DLM_LOCKREPLY_OFF] = sizeof(*lockrep), - [DLM_REPLY_REC_OFF] = sizeof(struct mdt_body), - [DLM_REPLY_REC_OFF+1] = obddev->u.cli. - cl_max_mds_easize, - 0, 0, 0 }; - int flags = extra_lock_flags | LDLM_FL_HAS_INTENT; - int repbufcnt = 4, rc; + struct obd_device *obddev = class_exp2obd(exp); + struct ldlm_intent *lit; + int joinfile = !!((it->it_flags & O_JOIN_FILE) && + op_data->op_data); + CFS_LIST_HEAD(cancels); + int count = 0; + int mode; + int rc; ENTRY; - LASSERTF(einfo->ei_type == LDLM_IBITS,"lock type %d\n", einfo->ei_type); + it->it_create_mode = (it->it_create_mode & ~S_IFMT) | S_IFREG; - if (it->it_op & IT_OPEN) { - int do_join = (!!(it->it_flags & O_JOIN_FILE) && - op_data->op_data); - CFS_LIST_HEAD(cancels); - int count = 0; - int mode; - - it->it_create_mode = (it->it_create_mode & ~S_IFMT) | S_IFREG; - - size[DLM_INTENT_REC_OFF] = sizeof(struct mdt_rec_create); - /* parent capability */ - size[DLM_INTENT_REC_OFF + 1] = op_data->op_capa1 ? - sizeof(struct lustre_capa) : 0; - /* child capability, used for replay only */ - size[DLM_INTENT_REC_OFF + 2] = sizeof(struct lustre_capa); - size[DLM_INTENT_REC_OFF + 3] = op_data->op_namelen + 1; - /* As an optimization, we allocate an RPC request buffer for - * at least a default-sized LOV EA even if we aren't sending - * one. - */ - size[DLM_INTENT_REC_OFF + 4] = max(lmmsize, - obddev->u.cli.cl_default_mds_easize); - - /* XXX: openlock is not cancelled for cross-refs. */ - /* If inode is known, cancel conflicting OPEN locks. */ - if (fid_is_sane(&op_data->op_fid2)) { - if (it->it_flags & (FMODE_WRITE|MDS_OPEN_TRUNC)) - mode = LCK_CW; + /* XXX: openlock is not cancelled for cross-refs. */ + /* If inode is known, cancel conflicting OPEN locks. */ + if (fid_is_sane(&op_data->op_fid2)) { + if (it->it_flags & (FMODE_WRITE|MDS_OPEN_TRUNC)) + mode = LCK_CW; #ifdef FMODE_EXEC - else if (it->it_flags & FMODE_EXEC) - mode = LCK_PR; + else if (it->it_flags & FMODE_EXEC) + mode = LCK_PR; #endif - else - mode = LCK_CR; - count = mdc_resource_get_unused(exp, &op_data->op_fid2, - &cancels, mode, - MDS_INODELOCK_OPEN); - } - - /* If CREATE or JOIN_FILE, cancel parent's UPDATE lock. */ - if (it->it_op & IT_CREAT || do_join) - mode = LCK_EX; else mode = LCK_CR; - count += mdc_resource_get_unused(exp, &op_data->op_fid1, - &cancels, mode, - MDS_INODELOCK_UPDATE); + count = mdc_resource_get_unused(exp, &op_data->op_fid2, + &cancels, mode, + MDS_INODELOCK_OPEN); + } - if (do_join) - size[DLM_INTENT_REC_OFF + 5] = - sizeof(struct mdt_rec_join); - else - it->it_flags &= ~O_JOIN_FILE; + /* If CREATE or JOIN_FILE, cancel parent's UPDATE lock. */ + if (it->it_op & IT_CREAT || joinfile) + mode = LCK_EX; + else + mode = LCK_CR; + count += mdc_resource_get_unused(exp, &op_data->op_fid1, + &cancels, mode, + MDS_INODELOCK_UPDATE); + + req = ptlrpc_request_alloc(class_exp2cliimp(exp), + &RQF_LDLM_INTENT_OPEN); + if (req == NULL) { + ldlm_lock_list_put(&cancels, l_bl_ast, count); + RETURN(ERR_PTR(-ENOMEM)); + } - req = ldlm_prep_enqueue_req(exp, 8 + do_join, size, &cancels, - count); - if (!req) - RETURN(-ENOMEM); + /* parent capability */ + mdc_set_capa_size(req, &RMF_CAPA1, op_data->op_capa1); + /* child capability, reserve the size according to parent capa, it will + * be filled after we get the reply */ + mdc_set_capa_size(req, &RMF_CAPA2, op_data->op_capa1); + + req_capsule_set_size(&req->rq_pill, &RMF_NAME, RCL_CLIENT, + op_data->op_namelen + 1); + req_capsule_set_size(&req->rq_pill, &RMF_EADATA, RCL_CLIENT, + max(lmmsize, obddev->u.cli.cl_default_mds_easize)); + if (!joinfile) { + req_capsule_set_size(&req->rq_pill, &RMF_REC_JOINFILE, + RCL_CLIENT, 0); + } - if (do_join) { - /* join is like an unlink of the tail */ - policy.l_inodebits.bits = MDS_INODELOCK_UPDATE; - mdc_join_pack(req, DLM_INTENT_REC_OFF + 5, op_data, - (*(__u64 *)op_data->op_data)); - } + if (exp_connect_cancelset(exp) && count) { + req_capsule_set_size(&req->rq_pill, &RMF_DLM_REQ, RCL_CLIENT, + ldlm_request_bufsize(count, LDLM_ENQUEUE)); + } - spin_lock(&req->rq_lock); - req->rq_replay = 1; - spin_unlock(&req->rq_lock); + rc = ptlrpc_request_pack(req, LUSTRE_DLM_VERSION, LDLM_ENQUEUE); + if (rc) { + ptlrpc_request_free(req); + ldlm_lock_list_put(&cancels, l_bl_ast, count); + return NULL; + } + if (exp_connect_cancelset(exp) && req) + ldlm_cli_cancel_list(&cancels, count, req, 0); - /* pack the intent */ - lit = lustre_msg_buf(req->rq_reqmsg, DLM_INTENT_IT_OFF, - sizeof(*lit)); - lit->opc = (__u64)it->it_op; - - /* pack the intended request */ - mdc_open_pack(req, DLM_INTENT_REC_OFF, op_data, - it->it_create_mode, 0, it->it_flags, - lmm, lmmsize); - - /* for remote client, fetch remote perm for current user */ - repsize[repbufcnt++] = client_is_remote(exp) ? - sizeof(struct mdt_remote_perm) : - LUSTRE_POSIX_ACL_MAX_SIZE; - repsize[repbufcnt++] = sizeof(struct lustre_capa); - repsize[repbufcnt++] = sizeof(struct lustre_capa); - } else if (it->it_op & IT_UNLINK) { - size[DLM_INTENT_REC_OFF] = sizeof(struct mdt_rec_unlink); - size[DLM_INTENT_REC_OFF + 1] = op_data->op_capa1 ? - sizeof(struct lustre_capa) : 0; - size[DLM_INTENT_REC_OFF + 2] = op_data->op_namelen + 1; - policy.l_inodebits.bits = MDS_INODELOCK_UPDATE; - req = ldlm_prep_enqueue_req(exp, 6, size, NULL, 0); - if (!req) - RETURN(-ENOMEM); - - /* pack the intent */ - lit = lustre_msg_buf(req->rq_reqmsg, DLM_INTENT_IT_OFF, - sizeof(*lit)); - lit->opc = (__u64)it->it_op; - - /* pack the intended request */ - mdc_unlink_pack(req, DLM_INTENT_REC_OFF, op_data); - - repsize[repbufcnt++] = obddev->u.cli.cl_max_mds_cookiesize; - } else if (it->it_op & (IT_GETATTR | IT_LOOKUP)) { - obd_valid valid = OBD_MD_FLGETATTR | OBD_MD_FLEASIZE | - OBD_MD_FLMODEASIZE | OBD_MD_FLDIREA | - OBD_MD_FLMDSCAPA | OBD_MD_MEA; - valid |= client_is_remote(exp) ? OBD_MD_FLRMTPERM : - OBD_MD_FLACL; - size[DLM_INTENT_REC_OFF] = sizeof(struct mdt_body); - size[DLM_INTENT_REC_OFF + 1] = op_data->op_capa1 ? - sizeof(struct lustre_capa) : 0; - size[DLM_INTENT_REC_OFF + 2] = op_data->op_namelen + 1; - - if (it->it_op & IT_GETATTR) - policy.l_inodebits.bits = MDS_INODELOCK_UPDATE; + if (joinfile) { + __u64 head_size = *(__u64 *)op_data->op_data; + mdc_join_pack(req, op_data, head_size); + } + + spin_lock(&req->rq_lock); + req->rq_replay = 1; + spin_unlock(&req->rq_lock); + + /* pack the intent */ + lit = req_capsule_client_get(&req->rq_pill, &RMF_LDLM_INTENT); + 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); + + /* for remote client, fetch remote perm for current user */ + if (client_is_remote(exp)) + req_capsule_set_size(&req->rq_pill, &RMF_ACL, RCL_SERVER, + sizeof(struct mdt_remote_perm)); + ptlrpc_request_set_replen(req); + return req; +} + +static struct ptlrpc_request *mdc_intent_unlink_pack(struct obd_export *exp, + struct lookup_intent *it, + struct md_op_data *op_data) +{ + struct ptlrpc_request *req; + struct obd_device *obddev = class_exp2obd(exp); + struct ldlm_intent *lit; + int rc; + ENTRY; + + req = ptlrpc_request_alloc(class_exp2cliimp(exp), + &RQF_LDLM_INTENT_UNLINK); + if (req == NULL) + RETURN(ERR_PTR(-ENOMEM)); + + mdc_set_capa_size(req, &RMF_CAPA1, op_data->op_capa1); + req_capsule_set_size(&req->rq_pill, &RMF_NAME, RCL_CLIENT, + op_data->op_namelen + 1); + + rc = ptlrpc_request_pack(req, LUSTRE_DLM_VERSION, LDLM_ENQUEUE); + if (rc) { + ptlrpc_request_free(req); + RETURN(ERR_PTR(rc)); + } + + /* pack the intent */ + lit = req_capsule_client_get(&req->rq_pill, &RMF_LDLM_INTENT); + lit->opc = (__u64)it->it_op; + + /* pack the intended request */ + mdc_unlink_pack(req, op_data); + + req_capsule_set_size(&req->rq_pill, &RMF_MDT_MD, RCL_SERVER, + obddev->u.cli.cl_max_mds_easize); + req_capsule_set_size(&req->rq_pill, &RMF_ACL, RCL_SERVER, + obddev->u.cli.cl_max_mds_cookiesize); + ptlrpc_request_set_replen(req); + RETURN(req); +} - req = ldlm_prep_enqueue_req(exp, 6, size, NULL, 0); - if (!req) - RETURN(-ENOMEM); +static struct ptlrpc_request *mdc_intent_getattr_pack(struct obd_export *exp, + struct lookup_intent *it, + struct md_op_data *op_data) +{ + struct ptlrpc_request *req; + struct obd_device *obddev = class_exp2obd(exp); + obd_valid valid = OBD_MD_FLGETATTR | OBD_MD_FLEASIZE | + OBD_MD_FLMODEASIZE | OBD_MD_FLDIREA | + OBD_MD_FLMDSCAPA | OBD_MD_MEA | + (client_is_remote(exp) ? + OBD_MD_FLRMTPERM : OBD_MD_FLACL); + struct ldlm_intent *lit; + int rc; + ENTRY; - /* pack the intent */ - lit = lustre_msg_buf(req->rq_reqmsg, DLM_INTENT_IT_OFF, - sizeof(*lit)); - lit->opc = (__u64)it->it_op; + req = ptlrpc_request_alloc(class_exp2cliimp(exp), + &RQF_LDLM_INTENT_GETATTR); + if (req == NULL) + RETURN(ERR_PTR(-ENOMEM)); - /* pack the intended request */ - mdc_getattr_pack(req, DLM_INTENT_REC_OFF, valid, - it->it_flags, op_data); + mdc_set_capa_size(req, &RMF_CAPA1, op_data->op_capa1); + req_capsule_set_size(&req->rq_pill, &RMF_NAME, RCL_CLIENT, + op_data->op_namelen + 1); + + rc = ptlrpc_request_pack(req, LUSTRE_DLM_VERSION, LDLM_ENQUEUE); + if (rc) { + ptlrpc_request_free(req); + RETURN(ERR_PTR(rc)); + } - repsize[repbufcnt++] = client_is_remote(exp) ? - sizeof(struct mdt_remote_perm) : - LUSTRE_POSIX_ACL_MAX_SIZE; - repsize[repbufcnt++] = sizeof(struct lustre_capa); - } else if (it->it_op == IT_READDIR) { + /* pack the intent */ + lit = req_capsule_client_get(&req->rq_pill, &RMF_LDLM_INTENT); + lit->opc = (__u64)it->it_op; + + /* pack the intended request */ + mdc_getattr_pack(req, valid, it->it_flags, op_data); + + req_capsule_set_size(&req->rq_pill, &RMF_MDT_MD, RCL_SERVER, + obddev->u.cli.cl_max_mds_easize); + if (client_is_remote(exp)) + req_capsule_set_size(&req->rq_pill, &RMF_ACL, RCL_SERVER, + sizeof(struct mdt_remote_perm)); + ptlrpc_request_set_replen(req); + RETURN(req); +} + +static struct ptlrpc_request *ldlm_enqueue_pack(struct obd_export *exp) +{ + struct ptlrpc_request *req; + ENTRY; + + req = ptlrpc_request_alloc_pack(class_exp2cliimp(exp), + &RQF_LDLM_ENQUEUE, LUSTRE_DLM_VERSION, + LDLM_ENQUEUE); + if (req == NULL) + RETURN(ERR_PTR(-ENOMEM)); + + ptlrpc_request_set_replen(req); + RETURN(req); +} + +/* We always reserve enough space in the reply packet for a stripe MD, because + * we don't know in advance the file type. */ +int mdc_enqueue(struct obd_export *exp, struct ldlm_enqueue_info *einfo, + struct lookup_intent *it, struct md_op_data *op_data, + struct lustre_handle *lockh, void *lmm, int lmmsize, + int extra_lock_flags) +{ + struct obd_device *obddev = class_exp2obd(exp); + struct ptlrpc_request *req; + struct req_capsule *pill; + struct ldlm_request *lockreq; + struct ldlm_reply *lockrep; + int flags = extra_lock_flags | LDLM_FL_HAS_INTENT; + int rc; + struct ldlm_res_id res_id = + { .name = {fid_seq(&op_data->op_fid1), + fid_oid(&op_data->op_fid1), + fid_ver(&op_data->op_fid1)} }; + ldlm_policy_data_t policy = { .l_inodebits = { MDS_INODELOCK_LOOKUP } }; + ENTRY; + + LASSERTF(einfo->ei_type == LDLM_IBITS,"lock type %d\n", einfo->ei_type); + + if (it->it_op & (IT_UNLINK | IT_GETATTR | IT_READDIR)) policy.l_inodebits.bits = MDS_INODELOCK_UPDATE; - req = ldlm_prep_enqueue_req(exp, 2, size, NULL, 0); - if (!req) - RETURN(-ENOMEM); - repbufcnt = 2; - } else { + if (it->it_op & IT_OPEN) { + int joinfile = !!((it->it_flags & O_JOIN_FILE) && + op_data->op_data); + + req = mdc_intent_open_pack(exp, it, op_data, lmm, lmmsize, + einfo->ei_cbdata); + if (!joinfile) { + policy.l_inodebits.bits = MDS_INODELOCK_UPDATE; + einfo->ei_cbdata = NULL; + lmm = NULL; + } else + it->it_flags &= ~O_JOIN_FILE; + } else if (it->it_op & IT_UNLINK) + req = mdc_intent_unlink_pack(exp, it, op_data); + else if (it->it_op & (IT_GETATTR | IT_LOOKUP)) + req = mdc_intent_getattr_pack(exp, it, op_data); + else if (it->it_op == IT_READDIR) + req = ldlm_enqueue_pack(exp); + else { LBUG(); RETURN(-EINVAL); } - /* get ready for the reply */ - ptlrpc_req_set_repsize(req, repbufcnt, repsize); + if (IS_ERR(req)) + RETURN(PTR_ERR(req)); + pill = &req->rq_pill; - /* It is important to obtain rpc_lock first (if applicable), so that - * threads that are serialised with rpc_lock are not polluting our - * rpcs in flight counter */ + /* It is important to obtain rpc_lock first (if applicable), so that + * threads that are serialised with rpc_lock are not polluting our + * rpcs in flight counter */ mdc_get_rpc_lock(obddev->u.cli.cl_rpc_lock, it); mdc_enter_request(&obddev->u.cli); rc = ldlm_cli_enqueue(exp, &req, einfo, &res_id, &policy, &flags, NULL, @@ -439,8 +513,7 @@ int mdc_enqueue(struct obd_export *exp, struct ldlm_enqueue_info *einfo, /* Similarly, if we're going to replay this request, we don't want to * actually get a lock, just perform the intent. */ if (req->rq_transno || req->rq_replay) { - lockreq = lustre_msg_buf(req->rq_reqmsg, DLM_LOCKREQ_OFF, - sizeof(*lockreq)); + lockreq = req_capsule_client_get(pill, &RMF_DLM_REQ); lockreq->lock_flags |= LDLM_FL_INTENT_ONLY; } @@ -468,11 +541,8 @@ int mdc_enqueue(struct obd_export *exp, struct ldlm_enqueue_info *einfo, LDLM_LOCK_PUT(lock); } - lockrep = lustre_msg_buf(req->rq_repmsg, DLM_LOCKREPLY_OFF, - sizeof(*lockrep)); + lockrep = req_capsule_server_get(pill, &RMF_DLM_REP); LASSERT(lockrep != NULL); /* checked by ldlm_cli_enqueue() */ - /* swabbed by ldlm_cli_enqueue() */ - LASSERT(lustre_rep_swabbed(req, DLM_LOCKREPLY_OFF)); it->d.lustre.it_disposition = (int)lockrep->lock_policy_res1; it->d.lustre.it_status = (int)lockrep->lock_policy_res2; @@ -497,13 +567,10 @@ int mdc_enqueue(struct obd_export *exp, struct ldlm_enqueue_info *einfo, it->it_op,it->d.lustre.it_disposition,it->d.lustre.it_status); /* We know what to expect, so we do any byte flipping required here */ - LASSERT(repbufcnt == 7 || repbufcnt == 6 || repbufcnt == 2); - if (repbufcnt >= 6) { - int reply_off = DLM_REPLY_REC_OFF; + if (it->it_op & (IT_OPEN | IT_UNLINK | IT_LOOKUP | IT_GETATTR)) { struct mdt_body *body; - body = lustre_swab_repbuf(req, reply_off++, sizeof(*body), - lustre_swab_mdt_body); + body = req_capsule_server_get(pill, &RMF_MDT_BODY); if (body == NULL) { CERROR ("Can't swab mdt_body\n"); RETURN (-EPROTO); @@ -527,12 +594,11 @@ int mdc_enqueue(struct obd_export *exp, struct ldlm_enqueue_info *einfo, * The eadata is opaque; just check that it is there. * Eventually, obd_unpackmd() will check the contents. */ - eadata = lustre_swab_repbuf(req, reply_off++, - body->eadatasize, NULL); - if (eadata == NULL) { - CERROR("Missing/short eadata\n"); + eadata = req_capsule_server_sized_get(pill, &RMF_MDT_MD, + body->eadatasize); + if (eadata == NULL) RETURN(-EPROTO); - } + if (body->valid & OBD_MD_FLMODEASIZE) { if (obddev->u.cli.cl_max_mds_easize < body->max_mdsize) { @@ -560,46 +626,40 @@ int mdc_enqueue(struct obd_export *exp, struct ldlm_enqueue_info *einfo, * (for example error one). */ if ((it->it_op & IT_OPEN) && req->rq_replay) { - if (lustre_msg_buflen(req->rq_reqmsg, - DLM_INTENT_REC_OFF + 4) < - body->eadatasize) - mdc_realloc_openmsg(req, body, size); - - lmm = lustre_msg_buf(req->rq_reqmsg, - DLM_INTENT_REC_OFF + 4, - body->eadatasize); + if (req_capsule_get_size(pill, &RMF_EADATA, + RCL_CLIENT) < + body->eadatasize) { + mdc_realloc_openmsg(req, body); + req_capsule_set_size(pill, &RMF_EADATA, + RCL_CLIENT, + body->eadatasize); + } + lmm = req_capsule_client_get(pill, &RMF_EADATA); if (lmm) memcpy(lmm, eadata, body->eadatasize); } } + if (body->valid & OBD_MD_FLRMTPERM) { struct mdt_remote_perm *perm; LASSERT(client_is_remote(exp)); - perm = lustre_swab_repbuf(req, reply_off++, - sizeof(*perm), - lustre_swab_mdt_remote_perm); - if (perm == NULL) { - CERROR("missing remote permission!\n"); + perm = req_capsule_server_get(pill, &RMF_ACL); + if (perm == NULL) RETURN(-EPROTO); - } - } else if ((body->valid & OBD_MD_FLACL) && body->aclsize) { - reply_off++; + + lustre_swab_mdt_remote_perm(perm); } if (body->valid & OBD_MD_FLMDSCAPA) { struct lustre_capa *capa, *p; - capa = lustre_unpack_capa(req->rq_repmsg, reply_off++); - if (capa == NULL) { - CERROR("Missing/short MDS capability\n"); + capa = req_capsule_server_get(pill, &RMF_CAPA1); + if (capa == NULL) RETURN(-EPROTO); - } if (it->it_op & IT_OPEN) { /* client fid capa will be checked in replay */ - p = lustre_msg_buf(req->rq_reqmsg, - DLM_INTENT_REC_OFF + 2, - sizeof(*p)); + p = req_capsule_client_get(pill, &RMF_CAPA2); LASSERT(p); *p = *capa; } @@ -607,11 +667,9 @@ int mdc_enqueue(struct obd_export *exp, struct ldlm_enqueue_info *einfo, if (body->valid & OBD_MD_FLOSSCAPA) { struct lustre_capa *capa; - capa = lustre_unpack_capa(req->rq_repmsg, reply_off++); - if (capa == NULL) { - CERROR("Missing/short OSS capability\n"); + capa = req_capsule_server_get(pill, &RMF_CAPA2); + if (capa == NULL) RETURN(-EPROTO); - } } } @@ -748,17 +806,14 @@ int mdc_intent_lock(struct obd_export *exp, struct md_op_data *op_data, if (rc) RETURN(rc); - mdt_body = lustre_msg_buf(request->rq_repmsg, DLM_REPLY_REC_OFF, - sizeof(*mdt_body)); - /* mdc_enqueue checked */ - LASSERT(mdt_body != NULL); - /* mdc_enqueue swabbed */ - LASSERT(lustre_rep_swabbed(request, 1)); + mdt_body = req_capsule_server_get(&request->rq_pill, &RMF_MDT_BODY); + LASSERT(mdt_body != NULL); /* mdc_enqueue checked */ /* If we were revalidating a fid/name pair, mark the intent in * case we fail and get called again from lookup */ - if (fid_is_sane(&op_data->op_fid2) && (it->it_flags & O_CHECK_STALE) && - (it->it_op != IT_GETATTR)) { + if (fid_is_sane(&op_data->op_fid2) && + (it->it_flags & O_CHECK_STALE) && + it->it_op != IT_GETATTR) { it_set_disposition(it, DISP_ENQ_COMPLETE); /* Also: did we find the same inode? */ diff --git a/lustre/mdc/mdc_reint.c b/lustre/mdc/mdc_reint.c index ee27032..9a81e2c 100644 --- a/lustre/mdc/mdc_reint.c +++ b/lustre/mdc/mdc_reint.c @@ -43,7 +43,8 @@ /* mdc_setattr does its own semaphore handling */ static int mdc_reint(struct ptlrpc_request *request, - struct mdc_rpc_lock *rpc_lock, int level) + struct mdc_rpc_lock *rpc_lock, + int level) { int rc; @@ -54,10 +55,7 @@ static int mdc_reint(struct ptlrpc_request *request, mdc_put_rpc_lock(rpc_lock, NULL); if (rc) CDEBUG(D_INFO, "error in handling %d\n", rc); - else if (!lustre_swab_repbuf(request, REPLY_REC_OFF, - sizeof(struct mdt_body), - lustre_swab_mdt_body)) { - CERROR ("Can't unpack mdt_body\n"); + else if (!req_capsule_server_get(&request->rq_pill, &RMF_MDT_BODY)) { rc = -EPROTO; } return rc; @@ -90,12 +88,11 @@ int mdc_resource_get_unused(struct obd_export *exp, struct lu_fid *fid, RETURN(count); } -struct ptlrpc_request *mdc_prep_elc_req(struct obd_export *exp, - int bufcount, int *size, int off, - struct list_head *cancels, int count) +static int mdc_prep_elc_req(struct obd_export *exp, struct ptlrpc_request *req, + struct list_head *cancels, int count) { - return ldlm_prep_elc_req(exp, LUSTRE_MDS_VERSION, MDS_REINT, - bufcount, size, off, 0, cancels, count); + return ldlm_prep_elc_req(exp, req, LUSTRE_MDS_VERSION, MDS_REINT, + 0, cancels, count); } /* If mdc_setattr is called with an 'iattr', then it is a normal RPC that @@ -110,29 +107,14 @@ int mdc_setattr(struct obd_export *exp, struct md_op_data *op_data, { CFS_LIST_HEAD(cancels); struct ptlrpc_request *req; - struct mdt_rec_setattr *rec; struct mdc_rpc_lock *rpc_lock; struct obd_device *obd = exp->exp_obd; - int size[7] = { sizeof(struct ptlrpc_body), - sizeof(*rec), 0, 0, ealen, ea2len, 0 }; - int count = 0, bufcount = 4, rc; + int count = 0, rc; __u64 bits; ENTRY; LASSERT(op_data != NULL); - size[REQ_REC_OFF + 1] = op_data->op_capa1 ? - sizeof(struct lustre_capa) : 0; - - if (op_data->op_flags & (MF_SOM_CHANGE | MF_EPOCH_OPEN)) - size[REQ_REC_OFF + 2] = sizeof(struct mdt_epoch); - - if (ealen > 0) { - bufcount++; - if (ea2len > 0) - bufcount++; - } - bits = MDS_INODELOCK_UPDATE; if (op_data->op_attr.ia_valid & (ATTR_MODE|ATTR_UID|ATTR_GID)) bits |= MDS_INODELOCK_LOOKUP; @@ -140,13 +122,26 @@ int mdc_setattr(struct obd_export *exp, struct md_op_data *op_data, (fid_is_sane(&op_data->op_fid1))) count = mdc_resource_get_unused(exp, &op_data->op_fid1, &cancels, LCK_EX, bits); - if (exp_connect_cancelset(exp) && count) - bufcount = 7; - req = mdc_prep_elc_req(exp, bufcount, size, - REQ_REC_OFF + 5, &cancels, count); - - if (req == NULL) + req = ptlrpc_request_alloc(class_exp2cliimp(exp), + &RQF_MDS_REINT_SETATTR); + if (req == NULL) { + ldlm_lock_list_put(&cancels, l_bl_ast, count); RETURN(-ENOMEM); + } + mdc_set_capa_size(req, &RMF_CAPA1, op_data->op_capa1); + if ((op_data->op_flags & (MF_SOM_CHANGE | MF_EPOCH_OPEN)) == 0) + req_capsule_set_size(&req->rq_pill, &RMF_MDT_EPOCH, RCL_CLIENT, + 0); + req_capsule_set_size(&req->rq_pill, &RMF_EADATA, RCL_CLIENT, ealen); + req_capsule_set_size(&req->rq_pill, &RMF_LOGCOOKIES, RCL_CLIENT, + ea2len); + + rc = mdc_prep_elc_req(exp, req, &cancels, count); + if (rc) { + ldlm_lock_list_put(&cancels, l_bl_ast, count); + ptlrpc_request_free(req); + RETURN(rc); + } if (op_data->op_attr.ia_valid & ATTR_FROM_OPEN) { req->rq_request_portal = MDS_SETATTR_PORTAL; //XXX FIXME bug 249 @@ -159,11 +154,9 @@ int mdc_setattr(struct obd_export *exp, struct md_op_data *op_data, CDEBUG(D_INODE, "setting mtime %lu, ctime %lu\n", LTIME_S(op_data->op_attr.ia_mtime), LTIME_S(op_data->op_attr.ia_ctime)); - mdc_setattr_pack(req, REQ_REC_OFF, op_data, ea, ealen, ea2, ea2len); + mdc_setattr_pack(req, op_data, ea, ealen, ea2, ea2len); - size[REPLY_REC_OFF] = sizeof(struct mdt_body); - size[REPLY_REC_OFF + 1] = sizeof(struct lustre_capa); - ptlrpc_req_set_repsize(req, 3, size); + ptlrpc_request_set_replen(req); if (mod && (op_data->op_flags & MF_EPOCH_OPEN) && req->rq_import->imp_replayable) { @@ -201,12 +194,8 @@ int mdc_create(struct obd_export *exp, struct md_op_data *op_data, const void *data, int datalen, int mode, __u32 uid, __u32 gid, __u32 cap_effective, __u64 rdev, struct ptlrpc_request **request) { - int size[6] = { sizeof(struct ptlrpc_body), - sizeof(struct mdt_rec_create), - 0, op_data->op_namelen + 1, 0, 0 }; - struct obd_device *obd = exp->exp_obd; - int level, bufcount = 4, rc; struct ptlrpc_request *req; + int level, rc; int count = 0; CFS_LIST_HEAD(cancels); ENTRY; @@ -224,41 +213,43 @@ int mdc_create(struct obd_export *exp, struct md_op_data *op_data, } } - size[REQ_REC_OFF + 1] = op_data->op_capa1 ? - sizeof(struct lustre_capa) : 0; - - if (data && datalen) { - size[bufcount] = datalen; - bufcount++; - } - if ((op_data->op_flags & MF_MDC_CANCEL_FID1) && (fid_is_sane(&op_data->op_fid1))) count = mdc_resource_get_unused(exp, &op_data->op_fid1, &cancels, LCK_EX, MDS_INODELOCK_UPDATE); - if (exp_connect_cancelset(exp) && count) - bufcount = 6; - req = mdc_prep_elc_req(exp, bufcount, size, - REQ_REC_OFF + 4, &cancels, count); - if (req == NULL) + req = ptlrpc_request_alloc(class_exp2cliimp(exp), + &RQF_MDS_REINT_CREATE_RMT_ACL); + if (req == NULL) { + ldlm_lock_list_put(&cancels, l_bl_ast, count); RETURN(-ENOMEM); + } + mdc_set_capa_size(req, &RMF_CAPA1, op_data->op_capa1); + req_capsule_set_size(&req->rq_pill, &RMF_NAME, RCL_CLIENT, + op_data->op_namelen + 1); + req_capsule_set_size(&req->rq_pill, &RMF_EADATA, RCL_CLIENT, + data && datalen ? datalen : 0); + + rc = mdc_prep_elc_req(exp, req, &cancels, count); + if (rc) { + ldlm_lock_list_put(&cancels, l_bl_ast, count); + ptlrpc_request_free(req); + RETURN(rc); + } /* * 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, REQ_REC_OFF, op_data, data, datalen, mode, uid, + mdc_create_pack(req, op_data, data, datalen, mode, uid, gid, cap_effective, rdev); - size[REPLY_REC_OFF] = sizeof(struct mdt_body); - size[REPLY_REC_OFF + 1] = sizeof(struct lustre_capa); - ptlrpc_req_set_repsize(req, 3, size); + ptlrpc_request_set_replen(req); level = LUSTRE_IMP_FULL; resend: - rc = mdc_reint(req, obd->u.cli.cl_rpc_lock, level); + rc = mdc_reint(req, exp->exp_obd->u.cli.cl_rpc_lock, level); /* Resend if we were told to. */ if (rc == -ERESTARTSYS) { @@ -268,16 +259,13 @@ int mdc_create(struct obd_export *exp, struct md_op_data *op_data, struct mdt_body *body; struct lustre_capa *capa; - body = lustre_msg_buf(req->rq_repmsg, REPLY_REC_OFF, - sizeof(*body)); + body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY); LASSERT(body); if (body->valid & OBD_MD_FLMDSCAPA) { - capa = lustre_unpack_capa(req->rq_repmsg, - REPLY_REC_OFF + 1); - if (capa == NULL) { - CERROR("Missing/short MDS capability\n"); + capa = req_capsule_server_get(&req->rq_pill, + &RMF_CAPA1); + if (capa == NULL) rc = -EPROTO; - } } } @@ -291,17 +279,11 @@ int mdc_unlink(struct obd_export *exp, struct md_op_data *op_data, CFS_LIST_HEAD(cancels); struct obd_device *obd = class_exp2obd(exp); struct ptlrpc_request *req = *request; - int size[5] = { sizeof(struct ptlrpc_body), - sizeof(struct mdt_rec_unlink), - 0, op_data->op_namelen + 1, 0 }; - int count = 0, rc, bufcount = 4; + int count = 0, rc; ENTRY; LASSERT(req == NULL); - size[REQ_REC_OFF + 1] = op_data->op_capa1 ? - sizeof(struct lustre_capa) : 0; - if ((op_data->op_flags & MF_MDC_CANCEL_FID1) && (fid_is_sane(&op_data->op_fid1))) count = mdc_resource_get_unused(exp, &op_data->op_fid1, @@ -312,22 +294,32 @@ int mdc_unlink(struct obd_export *exp, struct md_op_data *op_data, count += mdc_resource_get_unused(exp, &op_data->op_fid3, &cancels, LCK_EX, MDS_INODELOCK_FULL); - if (exp_connect_cancelset(exp) && count) - bufcount = 5; - - req = mdc_prep_elc_req(exp, bufcount, size, - REQ_REC_OFF + 3, &cancels, count); - - if (req == NULL) + req = ptlrpc_request_alloc(class_exp2cliimp(exp), + &RQF_MDS_REINT_UNLINK); + if (req == NULL) { + ldlm_lock_list_put(&cancels, l_bl_ast, count); RETURN(-ENOMEM); - *request = req; + } + mdc_set_capa_size(req, &RMF_CAPA1, op_data->op_capa1); + req_capsule_set_size(&req->rq_pill, &RMF_NAME, RCL_CLIENT, + op_data->op_namelen + 1); + + rc = mdc_prep_elc_req(exp, req, &cancels, count); + if (rc) { + ldlm_lock_list_put(&cancels, l_bl_ast, count); + ptlrpc_request_free(req); + RETURN(rc); + } + + mdc_unlink_pack(req, op_data); - size[REPLY_REC_OFF] = sizeof(struct mdt_body); - size[REPLY_REC_OFF + 1] = obd->u.cli.cl_max_mds_easize; - size[REPLY_REC_OFF + 2] = obd->u.cli.cl_max_mds_cookiesize; - ptlrpc_req_set_repsize(req, 4, size); + req_capsule_set_size(&req->rq_pill, &RMF_MDT_MD, RCL_SERVER, + obd->u.cli.cl_max_mds_easize); + req_capsule_set_size(&req->rq_pill, &RMF_LOGCOOKIES, RCL_SERVER, + obd->u.cli.cl_max_mds_cookiesize); + ptlrpc_request_set_replen(req); - mdc_unlink_pack(req, REQ_REC_OFF, op_data); + *request = req; rc = mdc_reint(req, obd->u.cli.cl_rpc_lock, LUSTRE_IMP_FULL); if (rc == -ERESTARTSYS) @@ -341,17 +333,9 @@ int mdc_link(struct obd_export *exp, struct md_op_data *op_data, CFS_LIST_HEAD(cancels); struct obd_device *obd = exp->exp_obd; struct ptlrpc_request *req; - int size[6] = { sizeof(struct ptlrpc_body), - sizeof(struct mdt_rec_link), - 0, 0, op_data->op_namelen + 1, 0 }; - int count = 0, rc, bufcount = 5; + int count = 0, rc; ENTRY; - size[REQ_REC_OFF + 1] = op_data->op_capa1 ? - sizeof(struct lustre_capa) : 0; - size[REQ_REC_OFF + 2] = op_data->op_capa2 ? - sizeof(struct lustre_capa) : 0; - if ((op_data->op_flags & MF_MDC_CANCEL_FID2) && (fid_is_sane(&op_data->op_fid2))) count = mdc_resource_get_unused(exp, &op_data->op_fid2, @@ -362,18 +346,26 @@ int mdc_link(struct obd_export *exp, struct md_op_data *op_data, count += mdc_resource_get_unused(exp, &op_data->op_fid1, &cancels, LCK_EX, MDS_INODELOCK_UPDATE); - if (exp_connect_cancelset(exp) && count) - bufcount = 6; - req = mdc_prep_elc_req(exp, bufcount, size, - REQ_REC_OFF + 4, &cancels, count); - if (req == NULL) + req = ptlrpc_request_alloc(class_exp2cliimp(exp), &RQF_MDS_REINT_LINK); + if (req == NULL) { + ldlm_lock_list_put(&cancels, l_bl_ast, count); RETURN(-ENOMEM); + } + mdc_set_capa_size(req, &RMF_CAPA1, op_data->op_capa1); + mdc_set_capa_size(req, &RMF_CAPA2, op_data->op_capa2); + req_capsule_set_size(&req->rq_pill, &RMF_NAME, RCL_CLIENT, + op_data->op_namelen + 1); + + rc = mdc_prep_elc_req(exp, req, &cancels, count); + if (rc) { + ldlm_lock_list_put(&cancels, l_bl_ast, count); + ptlrpc_request_free(req); + RETURN(rc); + } - mdc_link_pack(req, REQ_REC_OFF, op_data); - - size[REPLY_REC_OFF] = sizeof(struct mdt_body); - ptlrpc_req_set_repsize(req, 2, size); + mdc_link_pack(req, op_data); + ptlrpc_request_set_replen(req); rc = mdc_reint(req, obd->u.cli.cl_rpc_lock, LUSTRE_IMP_FULL); *request = req; @@ -390,17 +382,9 @@ int mdc_rename(struct obd_export *exp, struct md_op_data *op_data, CFS_LIST_HEAD(cancels); struct obd_device *obd = exp->exp_obd; struct ptlrpc_request *req; - int size[7] = { sizeof(struct ptlrpc_body), - sizeof(struct mdt_rec_rename), - 0, 0, oldlen + 1, newlen + 1, 0 }; - int count = 0, rc, bufcount = 6; + int count = 0, rc; ENTRY; - size[REQ_REC_OFF + 1] = op_data->op_capa1 ? - sizeof(struct lustre_capa) : 0; - size[REQ_REC_OFF + 2] = op_data->op_capa2 ? - sizeof(struct lustre_capa) : 0; - if ((op_data->op_flags & MF_MDC_CANCEL_FID1) && (fid_is_sane(&op_data->op_fid1))) count = mdc_resource_get_unused(exp, &op_data->op_fid1, @@ -421,20 +405,36 @@ int mdc_rename(struct obd_export *exp, struct md_op_data *op_data, count += mdc_resource_get_unused(exp, &op_data->op_fid4, &cancels, LCK_EX, MDS_INODELOCK_FULL); - if (exp_connect_cancelset(exp) && count) - bufcount = 7; - req = mdc_prep_elc_req(exp, bufcount, size, - REQ_REC_OFF + 5, &cancels, count); - if (req == NULL) + req = ptlrpc_request_alloc(class_exp2cliimp(exp), + &RQF_MDS_REINT_RENAME); + if (req == NULL) { + ldlm_lock_list_put(&cancels, l_bl_ast, count); RETURN(-ENOMEM); + } + + mdc_set_capa_size(req, &RMF_CAPA1, op_data->op_capa1); + mdc_set_capa_size(req, &RMF_CAPA2, op_data->op_capa2); + req_capsule_set_size(&req->rq_pill, &RMF_NAME, RCL_CLIENT, oldlen + 1); + req_capsule_set_size(&req->rq_pill, &RMF_SYMTGT, RCL_CLIENT, newlen+1); + + rc = mdc_prep_elc_req(exp, req, &cancels, count); + if (rc) { + ldlm_lock_list_put(&cancels, l_bl_ast, count); + ptlrpc_request_free(req); + RETURN(rc); + } + + if (exp_connect_cancelset(exp) && req) + ldlm_cli_cancel_list(&cancels, count, req, 0); - mdc_rename_pack(req, REQ_REC_OFF, op_data, old, oldlen, new, newlen); + mdc_rename_pack(req, op_data, old, oldlen, new, newlen); - size[REPLY_REC_OFF] = sizeof(struct mdt_body); - size[REPLY_REC_OFF + 1] = obd->u.cli.cl_max_mds_easize; - size[REPLY_REC_OFF + 2] = obd->u.cli.cl_max_mds_cookiesize; - ptlrpc_req_set_repsize(req, 4, size); + req_capsule_set_size(&req->rq_pill, &RMF_MDT_MD, RCL_SERVER, + obd->u.cli.cl_max_mds_easize); + req_capsule_set_size(&req->rq_pill, &RMF_LOGCOOKIES, RCL_SERVER, + obd->u.cli.cl_max_mds_cookiesize); + ptlrpc_request_set_replen(req); rc = mdc_reint(req, obd->u.cli.cl_rpc_lock, LUSTRE_IMP_FULL); *request = req; diff --git a/lustre/mdc/mdc_request.c b/lustre/mdc/mdc_request.c index b72e700..953e148 100644 --- a/lustre/mdc/mdc_request.c +++ b/lustre/mdc/mdc_request.c @@ -55,21 +55,19 @@ extern quota_interface_t mdc_quota_interface; static int mdc_cleanup(struct obd_device *obd); static struct obd_capa *mdc_unpack_capa(struct ptlrpc_request *req, - unsigned int offset) + const struct req_msg_field *field) { struct lustre_capa *capa; struct obd_capa *oc; /* swabbed already in mdc_enqueue */ - capa = lustre_msg_buf(req->rq_repmsg, offset, sizeof(*capa)); - if (capa == NULL) { - CERROR("missing capa at offset %d failed!\n", offset); - return ERR_PTR(-EFAULT); - } + capa = req_capsule_server_get(&req->rq_pill, field); + if (capa == NULL) + return ERR_PTR(-EPROTO); oc = alloc_capa(CAPA_SITE_CLIENT); if (!oc) { - CERROR("alloc capa failed!\n"); + CDEBUG(D_INFO, "alloc capa failed!\n"); return ERR_PTR(-ENOMEM); } oc->c_capa = *capa; @@ -83,52 +81,46 @@ static int send_getstatus(struct obd_import *imp, struct lu_fid *rootfid, struct obd_capa **pc, int level, int msg_flags) { struct ptlrpc_request *req; - struct mdt_body *body; - int rc, size[3] = { sizeof(struct ptlrpc_body), - sizeof(*body), - sizeof(struct lustre_capa) }; + struct mdt_body *body; + int rc; ENTRY; - req = ptlrpc_prep_req(imp, LUSTRE_MDS_VERSION, MDS_GETSTATUS, 2, size, - NULL); - if (!req) - GOTO(out, rc = -ENOMEM); - - req->rq_send_state = level; - ptlrpc_req_set_repsize(req, 3, size); + req = ptlrpc_request_alloc_pack(imp, &RQF_MDS_GETSTATUS, + LUSTRE_MDS_VERSION, MDS_GETSTATUS); + if (req == NULL) + RETURN(-ENOMEM); - mdc_pack_req_body(req, REQ_REC_OFF, 0, NULL, NULL, 0, -1, 0); + mdc_pack_body(req, NULL, NULL, 0, 0, -1, 0); lustre_msg_add_flags(req->rq_reqmsg, msg_flags); - rc = ptlrpc_queue_wait(req); + req->rq_send_state = level; - if (!rc) { - body = lustre_swab_repbuf(req, REPLY_REC_OFF, sizeof(*body), - lustre_swab_mdt_body); - if (body == NULL) { - CERROR ("Can't extract mdt_body\n"); - GOTO (out, rc = -EPROTO); - } + ptlrpc_request_set_replen(req); - *rootfid = body->fid1; + rc = ptlrpc_queue_wait(req); + if (rc) + GOTO(out, rc); - if (body->valid & OBD_MD_FLMDSCAPA) { - struct obd_capa *oc; + body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY); + if (body == NULL) + GOTO(out, rc = -EPROTO); - oc = mdc_unpack_capa(req, REPLY_REC_OFF + 1); - if (IS_ERR(oc)) - GOTO(out, rc = PTR_ERR(oc)); - *pc = oc; - } + if (body->valid & OBD_MD_FLMDSCAPA) { + struct obd_capa *oc; - CDEBUG(D_NET, "root fid="DFID", last_committed="LPU64 - ", last_xid="LPU64"\n", - PFID(rootfid), - lustre_msg_get_last_committed(req->rq_repmsg), - lustre_msg_get_last_xid(req->rq_repmsg)); + oc = mdc_unpack_capa(req, &RMF_CAPA1); + if (IS_ERR(oc)) + GOTO(out, rc = PTR_ERR(oc)); + *pc = oc; } + *rootfid = body->fid1; + CDEBUG(D_NET, + "root fid="DFID", last_committed="LPU64", last_xid="LPU64"\n", + PFID(rootfid), + lustre_msg_get_last_committed(req->rq_repmsg), + lustre_msg_get_last_xid(req->rq_repmsg)); EXIT; - out: +out: ptlrpc_req_finished(req); return rc; } @@ -151,52 +143,32 @@ int mdc_getstatus(struct obd_export *exp, struct lu_fid *rootfid, * of fields. This issue will be fixed later when client gets awar of RPC * layouts. --umka */ -static int mdc_getattr_common(struct obd_export *exp, unsigned int ea_size, - unsigned int acl_size, int mdscapa, +static int mdc_getattr_common(struct obd_export *exp, struct ptlrpc_request *req) { - struct mdt_body *body; - void *eadata; - int size[5] = { sizeof(struct ptlrpc_body), - sizeof(*body), - ea_size, - acl_size, - sizeof(struct lustre_capa) }; - int offset, rc; + struct req_capsule *pill = &req->rq_pill; + struct mdt_body *body; + void *eadata; + int rc; ENTRY; /* Request message already built. */ - if (ea_size) - CDEBUG(D_INODE, "reserved %u bytes for MD/symlink in packet\n", - ea_size); - if (acl_size) - CDEBUG(D_INODE, "reserved %u bytes for ACL\n", acl_size); - - ptlrpc_req_set_repsize(req, 5, size); - rc = ptlrpc_queue_wait(req); if (rc != 0) - RETURN (rc); + RETURN(rc); - body = lustre_swab_repbuf(req, REPLY_REC_OFF, sizeof(*body), - lustre_swab_mdt_body); - if (body == NULL) { - CERROR ("Can't unpack mdt_body\n"); - RETURN (-EPROTO); - } + /* sanity check for the reply */ + body = req_capsule_server_get(pill, &RMF_MDT_BODY); + if (body == NULL) + RETURN(-EPROTO); CDEBUG(D_NET, "mode: %o\n", body->mode); - offset = REPLY_REC_OFF + 1; - lustre_set_rep_swabbed(req, offset); if (body->eadatasize != 0) { - /* reply indicates presence of eadata; check it's there... */ - eadata = lustre_msg_buf(req->rq_repmsg, offset++, - body->eadatasize); - if (eadata == NULL) { - CERROR ("Missing/short eadata\n"); - RETURN (-EPROTO); - } + eadata = req_capsule_server_sized_get(pill, &RMF_MDT_MD, + body->eadatasize); + if (eadata == NULL) + RETURN(-EPROTO); } if (body->valid & OBD_MD_FLMODEASIZE) { @@ -208,20 +180,21 @@ static int mdc_getattr_common(struct obd_export *exp, unsigned int ea_size, cli->cl_max_mds_cookiesize = body->max_cookiesize; } - offset += !!body->aclsize; + if (body->valid & OBD_MD_FLRMTPERM) { + struct mdt_remote_perm *perm; + perm = req_capsule_server_get(pill, &RMF_ACL); + if (perm == NULL) + RETURN(-EPROTO); + } if (body->valid & OBD_MD_FLMDSCAPA) { struct lustre_capa *capa; - - LASSERT(mdscapa); - capa = lustre_unpack_capa(req->rq_repmsg, offset++); - if (capa == NULL) { - CERROR("Missing/short client MDS capability\n"); + capa = req_capsule_server_get(pill, &RMF_CAPA1); + if (capa == NULL) RETURN(-EPROTO); - } } - RETURN (0); + RETURN(0); } int mdc_getattr(struct obd_export *exp, const struct lu_fid *fid, @@ -229,40 +202,37 @@ int mdc_getattr(struct obd_export *exp, const struct lu_fid *fid, struct ptlrpc_request **request) { struct ptlrpc_request *req; - int size[3] = { sizeof(struct ptlrpc_body), sizeof(struct mdt_body) }; - int acl_size = 0, rc; + int rc; ENTRY; - size[REQ_REC_OFF + 1] = oc ? sizeof(struct lustre_capa) : 0; + *request = NULL; + req = ptlrpc_request_alloc(class_exp2cliimp(exp), &RQF_MDS_GETATTR); + if (req == NULL) + RETURN(-ENOMEM); - /* - * XXX: Do we need to make another request here? We just did a getattr - * to do the lookup in the first place. - */ - req = ptlrpc_prep_req(class_exp2cliimp(exp), LUSTRE_MDS_VERSION, - MDS_GETATTR, 3, size, NULL); - if (!req) - GOTO(out, rc = -ENOMEM); + mdc_set_capa_size(req, &RMF_CAPA1, oc); + + rc = ptlrpc_request_pack(req, LUSTRE_MDS_VERSION, MDS_GETATTR); + if (rc) { + ptlrpc_request_free(req); + RETURN(rc); + } - mdc_pack_req_body(req, REQ_REC_OFF, valid, fid, oc, ea_size, -1, - MDS_BFLAG_EXT_FLAGS/*request "new" flags(bug 9486)*/); + /* MDS_BFLAG_EXT_FLAGS: request "new" flags(bug 9486) */ + mdc_pack_body(req, fid, oc, valid, ea_size, -1, MDS_BFLAG_EXT_FLAGS); + req_capsule_set_size(&req->rq_pill, &RMF_MDT_MD, RCL_SERVER, ea_size); if (valid & OBD_MD_FLRMTPERM) - acl_size = sizeof(struct mdt_remote_perm); - - /* Currently only root inode will call us with FLACL */ - else if (valid & OBD_MD_FLACL) - acl_size = LUSTRE_POSIX_ACL_MAX_SIZE; + req_capsule_set_size(&req->rq_pill, &RMF_ACL, RCL_SERVER, + sizeof(struct mdt_remote_perm)); + ptlrpc_request_set_replen(req); - rc = mdc_getattr_common(exp, ea_size, acl_size, - !!(valid & OBD_MD_FLMDSCAPA), req); - if (rc != 0) { - ptlrpc_req_finished (req); - req = NULL; - } - out: - *request = req; - RETURN (rc); + rc = mdc_getattr_common(exp, req); + if (rc) + ptlrpc_req_finished(req); + else + *request = req; + RETURN(rc); } int mdc_getattr_name(struct obd_export *exp, const struct lu_fid *fid, @@ -271,291 +241,292 @@ int mdc_getattr_name(struct obd_export *exp, const struct lu_fid *fid, struct ptlrpc_request **request) { struct ptlrpc_request *req; - struct mdt_body *body; - int size[4] = { sizeof(struct ptlrpc_body), sizeof(*body), 0, namelen}; - int rc; + int rc; ENTRY; - size[REQ_REC_OFF + 1] = oc ? sizeof(struct lustre_capa) : 0; + *request = NULL; + req = ptlrpc_request_alloc(class_exp2cliimp(exp), + &RQF_MDS_GETATTR_NAME); + if (req == NULL) + RETURN(-ENOMEM); - req = ptlrpc_prep_req(class_exp2cliimp(exp), LUSTRE_MDS_VERSION, - MDS_GETATTR_NAME, 4, size, NULL); - if (!req) - GOTO(out, rc = -ENOMEM); + mdc_set_capa_size(req, &RMF_CAPA1, oc); + req_capsule_set_size(&req->rq_pill, &RMF_NAME, RCL_CLIENT, namelen); + + rc = ptlrpc_request_pack(req, LUSTRE_MDS_VERSION, MDS_GETATTR_NAME); + if (rc) { + ptlrpc_request_free(req); + RETURN(rc); + } - mdc_pack_req_body(req, REQ_REC_OFF, valid, fid, oc, ea_size, suppgid, - MDS_BFLAG_EXT_FLAGS/*request "new" flags(bug 9486)*/); + /* MDS_BFLAG_EXT_FLAGS: request "new" flags(bug 9486) */ + mdc_pack_body(req, fid, oc, valid, ea_size, suppgid, + MDS_BFLAG_EXT_FLAGS); if (filename) { + char *name = req_capsule_client_get(&req->rq_pill, &RMF_NAME); LASSERT(strnlen(filename, namelen) == namelen - 1); - memcpy(lustre_msg_buf(req->rq_reqmsg, REQ_REC_OFF + 2, namelen), - filename, namelen); + memcpy(name, filename, namelen); } - rc = mdc_getattr_common(exp, ea_size, 0, !!(valid & OBD_MD_FLMDSCAPA), - req); - if (rc != 0) { - ptlrpc_req_finished (req); - req = NULL; - } - out: - *request = req; + req_capsule_set_size(&req->rq_pill, &RMF_MDT_MD, RCL_SERVER, ea_size); + ptlrpc_request_set_replen(req); + + rc = mdc_getattr_common(exp, req); + if (rc) + ptlrpc_req_finished(req); + else + *request = req; RETURN(rc); } -static int mdc_is_subdir(struct obd_export *exp, const struct lu_fid *pfid, - const struct lu_fid *cfid, struct ptlrpc_request **request) +static int mdc_is_subdir(struct obd_export *exp, + const struct lu_fid *pfid, + const struct lu_fid *cfid, + struct ptlrpc_request **request) { - int size[2] = { sizeof(struct ptlrpc_body), - sizeof(struct mdt_body) }; - struct ptlrpc_request *req; - struct mdt_body *body; - int rc; + struct ptlrpc_request *req; + int rc; + ENTRY; - req = ptlrpc_prep_req(class_exp2cliimp(exp), LUSTRE_MDS_VERSION, - MDS_IS_SUBDIR, 2, size, NULL); - if (!req) - GOTO(out, rc = -ENOMEM); + *request = NULL; + req = ptlrpc_request_alloc_pack(class_exp2cliimp(exp), + &RQF_MDS_IS_SUBDIR, LUSTRE_MDS_VERSION, + MDS_IS_SUBDIR); + if (req == NULL) + RETURN(-ENOMEM); - mdc_is_subdir_pack(req, REQ_REC_OFF, pfid, cfid, 0); + mdc_is_subdir_pack(req, pfid, cfid, 0); + ptlrpc_request_set_replen(req); - ptlrpc_req_set_repsize(req, 2, size); rc = ptlrpc_queue_wait(req); - if (rc != 0 && rc != -EREMOTE) - GOTO(out, rc); - - body = lustre_swab_repbuf(req, REPLY_REC_OFF, sizeof(*body), - lustre_swab_mdt_body); - if (body == NULL) { - CERROR ("Can't unpack mdt_body\n"); - GOTO(out, rc = -EPROTO); - } - EXIT; - out: - *request = req; - return rc; + if (rc && rc != -EREMOTE) + ptlrpc_req_finished(req); + else + *request = req; + RETURN(rc); } -static -int mdc_xattr_common(struct obd_export *exp, const struct lu_fid *fid, - struct obd_capa *oc, - int opcode, obd_valid valid, const char *xattr_name, - const char *input, int input_size, int output_size, - int flags, __u32 suppgid, struct ptlrpc_request **request) +static int mdc_xattr_common(struct obd_export *exp,const struct req_format *fmt, + const struct lu_fid *fid, + struct obd_capa *oc, int opcode, obd_valid valid, + const char *xattr_name, const char *input, + int input_size, int output_size, int flags, + __u32 suppgid, struct ptlrpc_request **request) { struct ptlrpc_request *req; - int size[5] = { sizeof(struct ptlrpc_body), sizeof(struct mdt_body) }; - int bufcnt = 3, offset = REQ_REC_OFF + 2; - int rc, xattr_namelen = 0; - void *tmp; + int xattr_namelen = 0; + char *tmp; + int rc; ENTRY; - size[REQ_REC_OFF + 1] = oc ? sizeof(struct lustre_capa) : 0; + *request = NULL; + req = ptlrpc_request_alloc(class_exp2cliimp(exp), fmt); + if (req == NULL) + RETURN(-ENOMEM); + + mdc_set_capa_size(req, &RMF_CAPA1, oc); if (xattr_name) { xattr_namelen = strlen(xattr_name) + 1; - size[bufcnt++] = xattr_namelen; + req_capsule_set_size(&req->rq_pill, &RMF_NAME, RCL_CLIENT, + xattr_namelen); } if (input_size) { LASSERT(input); - size[bufcnt++] = input_size; + req_capsule_set_size(&req->rq_pill, &RMF_EADATA, RCL_CLIENT, + input_size); } - req = ptlrpc_prep_req(class_exp2cliimp(exp), LUSTRE_MDS_VERSION, - opcode, bufcnt, size, NULL); - if (!req) - GOTO(out, rc = -ENOMEM); + rc = ptlrpc_request_pack(req, LUSTRE_MDS_VERSION, opcode); + if (rc) { + ptlrpc_request_free(req); + RETURN(rc); + } - /* request data */ - mdc_pack_req_body(req, REQ_REC_OFF, valid, fid, oc, output_size, - suppgid, flags); + if (opcode == MDS_REINT) { + struct mdt_rec_setxattr *rec; + CLASSERT(sizeof(struct mdt_rec_setxattr) == + sizeof(struct mdt_rec_reint)); + rec = req_capsule_client_get(&req->rq_pill, &RMF_REC_REINT); + rec->sx_opcode = REINT_SETXATTR; + /* TODO: + * cfs_curproc_fs{u,g}id() should replace + * current->fs{u,g}id for portability. + */ + rec->sx_fsuid = current->fsuid; + rec->sx_fsgid = current->fsgid; + rec->sx_cap = current->cap_effective; + rec->sx_suppgid1 = suppgid; + rec->sx_suppgid1 = -1; + rec->sx_fid = *fid; + rec->sx_valid = valid; + rec->sx_size = output_size; + rec->sx_flags = flags; + + mdc_pack_capa(req, &RMF_CAPA1, oc); + } else { + mdc_pack_body(req, fid, oc, valid, output_size, suppgid, flags); + } if (xattr_name) { - tmp = lustre_msg_buf(req->rq_reqmsg, offset++, xattr_namelen); + tmp = req_capsule_client_get(&req->rq_pill, &RMF_NAME); memcpy(tmp, xattr_name, xattr_namelen); } if (input_size) { - tmp = lustre_msg_buf(req->rq_reqmsg, offset++, input_size); + tmp = req_capsule_client_get(&req->rq_pill, &RMF_EADATA); memcpy(tmp, input, input_size); } - /* reply buffers */ - if (opcode == MDS_GETXATTR) { - size[REPLY_REC_OFF] = sizeof(struct mdt_body); - bufcnt = 2; - } else { - bufcnt = 1; - } - - /* we do this even output_size is 0, because server is doing that */ - size[bufcnt++] = output_size; - ptlrpc_req_set_repsize(req, bufcnt, size); + if (req_capsule_has_field(&req->rq_pill, &RMF_EADATA, RCL_SERVER)) + req_capsule_set_size(&req->rq_pill, &RMF_EADATA, + RCL_SERVER, output_size); + ptlrpc_request_set_replen(req); /* make rpc */ - if (opcode == MDS_SETXATTR) + if (opcode == MDS_REINT) mdc_get_rpc_lock(exp->exp_obd->u.cli.cl_rpc_lock, NULL); rc = ptlrpc_queue_wait(req); - if (opcode == MDS_SETXATTR) + if (opcode == MDS_REINT) mdc_put_rpc_lock(exp->exp_obd->u.cli.cl_rpc_lock, NULL); - if (rc != 0) - GOTO(err_out, rc); - - if (opcode == MDS_GETXATTR) { - struct mdt_body * body = lustre_swab_repbuf(req, REPLY_REC_OFF, - sizeof(*body), lustre_swab_mdt_body); - if (body == NULL) { - CERROR ("Can't unpack mdt_body\n"); - GOTO(err_out, rc = -EPROTO); - } - } -out: - *request = req; - RETURN (rc); -err_out: - ptlrpc_req_finished(req); - req = NULL; - goto out; + if (rc) + ptlrpc_req_finished(req); + else + *request = req; + RETURN(rc); } int mdc_setxattr(struct obd_export *exp, const struct lu_fid *fid, struct obd_capa *oc, obd_valid valid, const char *xattr_name, - const char *input, int input_size, int output_size, int flags, - __u32 suppgid, struct ptlrpc_request **request) + const char *input, int input_size, int output_size, + int flags, __u32 suppgid, struct ptlrpc_request **request) { - return mdc_xattr_common(exp, fid, oc, MDS_SETXATTR, valid, xattr_name, - input, input_size, output_size, flags, suppgid, - request); + return mdc_xattr_common(exp, &RQF_MDS_REINT_SETXATTR, + fid, oc, MDS_REINT, valid, xattr_name, + input, input_size, output_size, flags, + suppgid, request); } int mdc_getxattr(struct obd_export *exp, const struct lu_fid *fid, struct obd_capa *oc, obd_valid valid, const char *xattr_name, - const char *input, int input_size, int output_size, int flags, - struct ptlrpc_request **request) + const char *input, int input_size, int output_size, + int flags, struct ptlrpc_request **request) { - return mdc_xattr_common(exp, fid, oc, MDS_GETXATTR, valid, xattr_name, - input, input_size, output_size, flags, -1, - request); + return mdc_xattr_common(exp, &RQF_MDS_GETXATTR, + fid, oc, MDS_GETXATTR, valid, xattr_name, + input, input_size, output_size, flags, + -1, request); } #ifdef CONFIG_FS_POSIX_ACL -static -int mdc_unpack_acl(struct obd_export *exp, struct ptlrpc_request *req, - struct lustre_md *md, unsigned int offset) +static int mdc_unpack_acl(struct ptlrpc_request *req, struct lustre_md *md) { - struct mdt_body *body = md->body; - struct posix_acl *acl; - void *buf; - int rc; + struct req_capsule *pill = &req->rq_pill; + struct mdt_body *body = md->body; + struct posix_acl *acl; + void *buf; + int rc; + ENTRY; if (!body->aclsize) - return 0; + RETURN(0); - buf = lustre_msg_buf(req->rq_repmsg, offset, body->aclsize); - if (!buf) { - CERROR("aclsize %u, bufcount %u, bufsize %u\n", - body->aclsize, lustre_msg_bufcount(req->rq_repmsg), - (lustre_msg_bufcount(req->rq_repmsg) <= offset) ? - -1 : lustre_msg_buflen(req->rq_repmsg, offset)); - return -EPROTO; - } + buf = req_capsule_server_sized_get(pill, &RMF_ACL, body->aclsize); + + if (!buf) + RETURN(-EPROTO); acl = posix_acl_from_xattr(buf, body->aclsize); if (IS_ERR(acl)) { rc = PTR_ERR(acl); CERROR("convert xattr to acl: %d\n", rc); - return rc; + RETURN(rc); } rc = posix_acl_valid(acl); if (rc) { CERROR("validate acl: %d\n", rc); posix_acl_release(acl); - return rc; + RETURN(rc); } md->posix_acl = acl; - return 0; + RETURN(0); } #else -#define mdc_unpack_acl(exp, req, md, offset) 0 +#define mdc_unpack_acl(req, md) 0 #endif int mdc_get_lustre_md(struct obd_export *exp, struct ptlrpc_request *req, - int offset, struct obd_export *dt_exp, - struct obd_export *md_exp, + struct obd_export *dt_exp, struct obd_export *md_exp, struct lustre_md *md) { + struct req_capsule *pill = &req->rq_pill; int rc; ENTRY; LASSERT(md); memset(md, 0, sizeof(*md)); - md->body = lustre_msg_buf(req->rq_repmsg, offset, sizeof (*md->body)); - LASSERT (md->body != NULL); - LASSERT(lustre_rep_swabbed(req, offset)); - offset++; + md->body = req_capsule_server_get(pill, &RMF_MDT_BODY); + LASSERT(md->body != NULL); if (md->body->valid & OBD_MD_FLEASIZE) { int lmmsize; struct lov_mds_md *lmm; if (!S_ISREG(md->body->mode)) { - CERROR("OBD_MD_FLEASIZE set, should be a regular file, " - "but is not\n"); + CDEBUG(D_INFO, "OBD_MD_FLEASIZE set, should be a " + "regular file, but is not\n"); GOTO(out, rc = -EPROTO); } if (md->body->eadatasize == 0) { - CERROR("OBD_MD_FLEASIZE set, but eadatasize 0\n"); + CDEBUG(D_INFO, "OBD_MD_FLEASIZE set, " + "but eadatasize 0\n"); GOTO(out, rc = -EPROTO); } lmmsize = md->body->eadatasize; - lmm = lustre_msg_buf(req->rq_repmsg, offset, lmmsize); - if (!lmm) { - CERROR ("incorrect message: lmm == 0\n"); + lmm = req_capsule_server_sized_get(pill, &RMF_MDT_MD, lmmsize); + if (!lmm) GOTO(out, rc = -EPROTO); - } - LASSERT(lustre_rep_swabbed(req, offset)); rc = obd_unpackmd(dt_exp, &md->lsm, lmm, lmmsize); if (rc < 0) GOTO(out, rc); if (rc < sizeof(*md->lsm)) { - CERROR ("lsm size too small: rc < sizeof (*md->lsm) " - "(%d < "LPSZ")\n", rc, sizeof(*md->lsm)); + CDEBUG(D_INFO, "lsm size too small: " + "rc < sizeof (*md->lsm) (%d < "LPSZ")\n", + rc, sizeof(*md->lsm)); GOTO(out, rc = -EPROTO); } - offset++; } else if (md->body->valid & OBD_MD_FLDIREA) { int lmvsize; struct lov_mds_md *lmv; if(!S_ISDIR(md->body->mode)) { - CERROR("OBD_MD_FLDIREA set, should be a directory, but " - "is not\n"); + CDEBUG(D_INFO, "OBD_MD_FLDIREA set, should be a " + "directory, but is not\n"); GOTO(out, rc = -EPROTO); } if (md->body->eadatasize == 0) { - CERROR("OBD_MD_FLDIREA is set, but eadatasize 0\n"); + CDEBUG(D_INFO, "OBD_MD_FLDIREA is set, " + "but eadatasize 0\n"); RETURN(-EPROTO); } if (md->body->valid & OBD_MD_MEA) { lmvsize = md->body->eadatasize; - lmv = lustre_msg_buf(req->rq_repmsg, offset, lmvsize); - if (!lmv) { - CERROR ("incorrect message: lmv == 0\n"); + lmv = req_capsule_server_sized_get(pill, &RMF_MDT_MD, + lmvsize); + if (!lmv) GOTO(out, rc = -EPROTO); - } - - LASSERT(lustre_rep_swabbed(req, offset)); rc = obd_unpackmd(md_exp, (void *)&md->mea, lmv, lmvsize); @@ -563,31 +534,28 @@ int mdc_get_lustre_md(struct obd_export *exp, struct ptlrpc_request *req, GOTO(out, rc); if (rc < sizeof(*md->mea)) { - CERROR ("size too small: rc < sizeof(*md->mea) " - "(%d < %d)\n", rc, sizeof(*md->mea)); + CDEBUG(D_INFO, "size too small: " + "rc < sizeof(*md->mea) (%d < %d)\n", + rc, sizeof(*md->mea)); GOTO(out, rc = -EPROTO); } } - offset++; } rc = 0; - /* remote permission */ if (md->body->valid & OBD_MD_FLRMTPERM) { - md->remote_perm = lustre_msg_buf(req->rq_repmsg, offset++, - sizeof(struct mdt_remote_perm)); - if (!md->remote_perm) { - CERROR ("incorrect message: remote_perm == 0\n"); + /* remote permission */ + md->remote_perm = req_capsule_server_get(pill, &RMF_ACL); + if (!md->remote_perm) GOTO(out, rc = -EPROTO); - } } - - /* for ACL, it's possible that FLACL is set but aclsize is zero. only - * when aclsize != 0 there's an actual segment for ACL in reply - * buffer. */ else if (md->body->valid & OBD_MD_FLACL) { + /* for ACL, it's possible that FLACL is set but aclsize is zero. + * only when aclsize != 0 there's an actual segment for ACL + * in reply buffer. + */ if (md->body->aclsize) { - rc = mdc_unpack_acl(dt_exp, req, md, offset++); + rc = mdc_unpack_acl(req, md); if (rc) GOTO(out, rc); #ifdef CONFIG_FS_POSIX_ACL @@ -596,9 +564,8 @@ int mdc_get_lustre_md(struct obd_export *exp, struct ptlrpc_request *req, #endif } } - if (md->body->valid & OBD_MD_FLMDSCAPA) { - struct obd_capa *oc = mdc_unpack_capa(req, offset++); + struct obd_capa *oc = mdc_unpack_capa(req, &RMF_CAPA1); if (IS_ERR(oc)) GOTO(out, rc = PTR_ERR(oc)); @@ -606,7 +573,7 @@ int mdc_get_lustre_md(struct obd_export *exp, struct ptlrpc_request *req, } if (md->body->valid & OBD_MD_FLOSSCAPA) { - struct obd_capa *oc = mdc_unpack_capa(req, offset++); + struct obd_capa *oc = mdc_unpack_capa(req, &RMF_CAPA2); if (IS_ERR(oc)) GOTO(out, rc = PTR_ERR(oc)); @@ -651,8 +618,7 @@ static void mdc_replay_open(struct ptlrpc_request *req) return; } - body = lustre_swab_repbuf(req, DLM_REPLY_REC_OFF, sizeof(*body), - lustre_swab_mdt_body); + body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY); LASSERT(body != NULL); och = mod->mod_och; @@ -667,14 +633,13 @@ static void mdc_replay_open(struct ptlrpc_request *req) old = *file_fh; *file_fh = body->handle; } - list_for_each_entry_safe(cur, tmp, &mod->mod_replay_list, rq_mod_list) { int opc = lustre_msg_get_opc(cur->rq_reqmsg); struct mdt_epoch *epoch = NULL; if (opc == MDS_CLOSE || opc == MDS_DONE_WRITING) { - epoch = lustre_msg_buf(cur->rq_reqmsg, - REQ_REC_OFF, sizeof(*epoch)); + epoch = req_capsule_client_get(&cur->rq_pill, + &RMF_MDT_EPOCH); LASSERT(epoch); DEBUG_REQ(D_HA, cur, "updating %s body with new fh", opc == MDS_CLOSE ? "CLOSE" : "DONE_WRITING"); @@ -682,12 +647,12 @@ static void mdc_replay_open(struct ptlrpc_request *req) struct mdt_rec_setattr *rec; /* Check this is REINT_SETATTR. */ - rec = lustre_msg_buf(req->rq_reqmsg, REQ_REC_OFF, - sizeof (*rec)); + rec = req_capsule_client_get(&cur->rq_pill, + &RMF_REC_REINT); LASSERT(rec && rec->sa_opcode == REINT_SETATTR); - epoch = lustre_msg_buf(cur->rq_reqmsg, - REQ_REC_OFF + 2, sizeof(*epoch)); + epoch = req_capsule_client_get(&cur->rq_pill, + &RMF_MDT_EPOCH); LASSERT(epoch); DEBUG_REQ(D_HA, cur, "updating REINT_SETATTR body " "with new fh"); @@ -744,27 +709,22 @@ int mdc_set_open_replay_data(struct obd_export *exp, struct obd_client_handle *och, struct ptlrpc_request *open_req) { - struct md_open_data *mod; - struct mdt_rec_create *rec = lustre_msg_buf(open_req->rq_reqmsg, - DLM_INTENT_REC_OFF, - sizeof(*rec)); - struct mdt_body *body = lustre_msg_buf(open_req->rq_repmsg, - DLM_REPLY_REC_OFF, - sizeof(*body)); - struct obd_import *imp = open_req->rq_import; + struct md_open_data *mod; + struct mdt_rec_create *rec; + struct mdt_body *body; + struct obd_import *imp = open_req->rq_import; ENTRY; + rec = req_capsule_client_get(&open_req->rq_pill, &RMF_REC_REINT); + body = req_capsule_server_get(&open_req->rq_pill, &RMF_MDT_BODY); LASSERT(rec != NULL); - /* Incoming message in my byte order (it's been swabbed). */ - LASSERT(lustre_rep_swabbed(open_req, DLM_REPLY_REC_OFF)); - /* Outgoing messages always in my byte order. */ LASSERT(body != NULL); /*Only the import is replayable, we set replay_open data */ if (och && imp->imp_replayable) { - OBD_ALLOC(mod, sizeof(*mod)); + OBD_ALLOC_PTR(mod); if (mod == NULL) { DEBUG_REQ(D_ERROR, open_req, "Can't allocate md_open_data"); @@ -824,24 +784,23 @@ int mdc_clear_open_replay_data(struct obd_export *exp, int mdc_close(struct obd_export *exp, struct md_op_data *op_data, struct md_open_data *mod, struct ptlrpc_request **request) { - struct obd_device *obd = class_exp2obd(exp); - int reqsize[4] = { sizeof(struct ptlrpc_body), - sizeof(struct mdt_epoch), - sizeof(struct mdt_rec_setattr)}; - int repsize[4] = { sizeof(struct ptlrpc_body), - sizeof(struct mdt_body), - obd->u.cli.cl_max_mds_easize, - obd->u.cli.cl_max_mds_cookiesize }; + struct obd_device *obd = class_exp2obd(exp); struct ptlrpc_request *req; - int rc; + int rc; ENTRY; - reqsize[REQ_REC_OFF + 2] = op_data->op_capa1 ? - sizeof(struct lustre_capa) : 0; - req = ptlrpc_prep_req(class_exp2cliimp(exp), LUSTRE_MDS_VERSION, - MDS_CLOSE, 4, reqsize, NULL); + *request = NULL; + req = ptlrpc_request_alloc(class_exp2cliimp(exp), &RQF_MDS_CLOSE); if (req == NULL) - GOTO(out, rc = -ENOMEM); + RETURN(-ENOMEM); + + mdc_set_capa_size(req, &RMF_CAPA1, op_data->op_capa1); + + rc = ptlrpc_request_pack(req, LUSTRE_MDS_VERSION, MDS_CLOSE); + if (rc) { + ptlrpc_request_free(req); + RETURN(rc); + } /* To avoid a livelock (bug 7034), we need to send CLOSE RPCs to a * portal whose threads are not taking any DLM locks and are therefore @@ -855,8 +814,8 @@ int mdc_close(struct obd_export *exp, struct md_op_data *op_data, else CDEBUG(D_HA, "couldn't find open req; expecting close error\n"); - mdc_close_pack(req, REQ_REC_OFF, op_data); - ptlrpc_req_set_repsize(req, 4, repsize); + mdc_close_pack(req, op_data); + ptlrpc_request_set_replen(req); req->rq_commit_cb = mdc_commit_delayed; req->rq_replay = 1; LASSERT(req->rq_cb_data == NULL); @@ -870,8 +829,10 @@ int mdc_close(struct obd_export *exp, struct md_op_data *op_data, CDEBUG(D_RPCTRACE, "request failed to send: %p, %d\n", req, req->rq_status); if (rc == 0) - rc = req->rq_status ? req->rq_status : -EIO; + rc = req->rq_status ?: -EIO; } else if (rc == 0 || rc == -EAGAIN) { + struct mdt_body *body; + rc = lustre_msg_get_status(req->rq_repmsg); if (lustre_msg_get_type(req->rq_repmsg) == PTL_RPC_MSG_ERR) { DEBUG_REQ(D_ERROR, req, "type == PTL_RPC_MSG_ERR, err " @@ -884,45 +845,44 @@ int mdc_close(struct obd_export *exp, struct md_op_data *op_data, "but close succeeded with replayable imp" "Please tell CFS.\n"); } - if (!lustre_swab_repbuf(req, REPLY_REC_OFF, - sizeof(struct mdt_body), - lustre_swab_mdt_body)) { - CERROR("Error unpacking mdt_body\n"); + + body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY); + if (body == NULL) rc = -EPROTO; - } } EXIT; - *request = req; - out: if (rc != 0 && rc != -EAGAIN && req && req->rq_commit_cb) req->rq_commit_cb(req); + *request = req; return rc; } int mdc_done_writing(struct obd_export *exp, struct md_op_data *op_data, struct md_open_data *mod) { - struct obd_device *obd = class_exp2obd(exp); + struct obd_device *obd = class_exp2obd(exp); struct ptlrpc_request *req; - int size[4] = { sizeof(struct ptlrpc_body), - sizeof(struct mdt_epoch), - sizeof(struct mdt_rec_setattr)}; - int repsize[2] = { sizeof(struct ptlrpc_body), - sizeof(struct mdt_body)}; - int rc; + int rc; ENTRY; - if (op_data->op_capa1) - size[REQ_REC_OFF + 2] = sizeof(struct lustre_capa); - req = ptlrpc_prep_req(class_exp2cliimp(exp), LUSTRE_MDS_VERSION, - MDS_DONE_WRITING, 4, size, NULL); + req = ptlrpc_request_alloc(class_exp2cliimp(exp), + &RQF_MDS_DONE_WRITING); if (req == NULL) RETURN(-ENOMEM); - mdc_close_pack(req, REQ_REC_OFF, op_data); - + mdc_set_capa_size(req, &RMF_CAPA1, op_data->op_capa1); + rc = ptlrpc_request_pack(req, LUSTRE_MDS_VERSION, MDS_DONE_WRITING); + if (rc) { + ptlrpc_request_free(req); + RETURN(rc); + } + + /* XXX: add DONE_WRITING request to och -- when Size-on-MDS + * recovery will be ready. */ + mdc_close_pack(req, op_data); + ptlrpc_request_set_replen(req); req->rq_replay = 1; req->rq_cb_data = mod; req->rq_commit_cb = mdc_commit_delayed; @@ -931,7 +891,6 @@ int mdc_done_writing(struct obd_export *exp, struct md_op_data *op_data, else CDEBUG(D_HA, "couldn't find open req; expecting close error\n"); - ptlrpc_req_set_repsize(req, 2, repsize); mdc_get_rpc_lock(obd->u.cli.cl_close_lock, NULL); rc = ptlrpc_queue_wait(req); mdc_put_rpc_lock(obd->u.cli.cl_close_lock, NULL); @@ -952,18 +911,23 @@ int mdc_done_writing(struct obd_export *exp, struct md_op_data *op_data, int mdc_sendpage(struct obd_export *exp, const struct lu_fid *fid, const struct page *page, int offset) { - int rc, size[3] = { sizeof(struct ptlrpc_body), sizeof(struct mdt_body) }; - struct obd_import *imp = class_exp2cliimp(exp); - struct ptlrpc_bulk_desc *desc = NULL; - struct ptlrpc_request *req = NULL; + struct ptlrpc_request *req; + struct ptlrpc_bulk_desc *desc; + int rc; ENTRY; - CDEBUG(D_INODE, "object: "DFID"\n", PFID(fid)); - - req = ptlrpc_prep_req(imp, LUSTRE_MDS_VERSION, MDS_WRITEPAGE, 3, - size, NULL); + req = ptlrpc_request_alloc(class_exp2cliimp(exp), &RQF_MDS_WRITEPAGE); if (req == NULL) - GOTO(out, rc = -ENOMEM); + RETURN(-ENOMEM); + + /* FIXME: capa doesn't support split yet */ + mdc_set_capa_size(req, &RMF_CAPA1, NULL); + + rc = ptlrpc_request_pack(req, LUSTRE_MDS_VERSION, MDS_WRITEPAGE); + if (rc) { + ptlrpc_request_free(req); + RETURN(rc); + } req->rq_request_portal = MDS_READPAGE_PORTAL; @@ -973,14 +937,13 @@ int mdc_sendpage(struct obd_export *exp, const struct lu_fid *fid, /* NB req now owns desc and will free it when it gets freed. */ ptlrpc_prep_bulk_page(desc, (struct page *)page, 0, offset); - mdc_readdir_pack(req, REQ_REC_OFF, 0, offset, fid, NULL); + mdc_readdir_pack(req, 0, offset, fid, NULL); - ptlrpc_req_set_repsize(req, 2, size); + ptlrpc_request_set_replen(req); rc = ptlrpc_queue_wait(req); - EXIT; + GOTO(out, rc); out: - if (req != NULL) - ptlrpc_req_finished(req); + ptlrpc_req_finished(req); return rc; } EXPORT_SYMBOL(mdc_sendpage); @@ -990,56 +953,52 @@ int mdc_readpage(struct obd_export *exp, const struct lu_fid *fid, struct obd_capa *oc, __u64 offset, struct page *page, struct ptlrpc_request **request) { - int rc, size[3] = { sizeof(struct ptlrpc_body), sizeof(struct mdt_body) }; - struct obd_import *imp = class_exp2cliimp(exp); - struct ptlrpc_bulk_desc *desc = NULL; - struct ptlrpc_request *req = NULL; - struct mdt_body *body; + struct ptlrpc_request *req; + struct ptlrpc_bulk_desc *desc; + int rc; ENTRY; - CDEBUG(D_INODE, "object: "DFID"\n", PFID(fid)); - - size[REQ_REC_OFF + 1] = oc ? sizeof(struct lustre_capa) : 0; - req = ptlrpc_prep_req(imp, LUSTRE_MDS_VERSION, MDS_READPAGE, 3, size, - NULL); + *request = NULL; + req = ptlrpc_request_alloc(class_exp2cliimp(exp), &RQF_MDS_READPAGE); if (req == NULL) - GOTO(out, rc = -ENOMEM); + RETURN(-ENOMEM); + + mdc_set_capa_size(req, &RMF_CAPA1, oc); + + rc = ptlrpc_request_pack(req, LUSTRE_MDS_VERSION, MDS_READPAGE); + if (rc) { + ptlrpc_request_free(req); + RETURN(rc); + } /* XXX FIXME bug 249 */ req->rq_request_portal = MDS_READPAGE_PORTAL; - desc = ptlrpc_prep_bulk_imp(req, 1, BULK_PUT_SINK, MDS_BULK_PORTAL); - if (desc == NULL) - GOTO(out, rc = -ENOMEM); + if (desc == NULL) { + ptlrpc_request_free(req); + RETURN(-ENOMEM); + } /* NB req now owns desc and will free it when it gets freed */ ptlrpc_prep_bulk_page(desc, page, 0, CFS_PAGE_SIZE); - mdc_readdir_pack(req, REQ_REC_OFF, offset, CFS_PAGE_SIZE, fid, oc); + mdc_readdir_pack(req, offset, CFS_PAGE_SIZE, fid, oc); - ptlrpc_req_set_repsize(req, 2, size); + ptlrpc_request_set_replen(req); rc = ptlrpc_queue_wait(req); + if (rc) { + ptlrpc_req_finished(req); + RETURN(rc); + } - if (rc == 0) { - body = lustre_swab_repbuf(req, REPLY_REC_OFF, sizeof(*body), - lustre_swab_mdt_body); - if (body == NULL) { - CERROR("Can't unpack mdt_body\n"); - GOTO(out, rc = -EPROTO); - } - - if (req->rq_bulk->bd_nob_transferred != CFS_PAGE_SIZE) { - CERROR ("Unexpected # bytes transferred: %d" - " (%ld expected)\n", - req->rq_bulk->bd_nob_transferred, - CFS_PAGE_SIZE); - GOTO(out, rc = -EPROTO); - } + if (req->rq_bulk->bd_nob_transferred != CFS_PAGE_SIZE) { + CERROR("Unexpected # bytes transferred: %d (%ld expected)\n", + req->rq_bulk->bd_nob_transferred, CFS_PAGE_SIZE); + ptlrpc_req_finished(req); + RETURN(-EPROTO); } - EXIT; - out: *request = req; - return rc; + RETURN(0); } static int mdc_iocontrol(unsigned int cmd, struct obd_export *exp, int len, @@ -1093,12 +1052,70 @@ out: return rc; } -int mdc_set_info_async(struct obd_export *exp, obd_count keylen, - void *key, obd_count vallen, void *val, +static int do_set_info_async(struct obd_export *exp, + obd_count keylen, void *key, + obd_count vallen, void *val, + struct ptlrpc_request_set *set) +{ + struct obd_import *imp = class_exp2cliimp(exp); + struct ptlrpc_request *req; + char *tmp; + int rc; + ENTRY; + + if (vallen != sizeof(int)) + RETURN(-EINVAL); + + spin_lock(&imp->imp_lock); + if (*((int *)val)) { + imp->imp_connect_flags_orig |= OBD_CONNECT_RDONLY; + imp->imp_connect_data.ocd_connect_flags |= OBD_CONNECT_RDONLY; + } else { + imp->imp_connect_flags_orig &= ~OBD_CONNECT_RDONLY; + imp->imp_connect_data.ocd_connect_flags &= ~OBD_CONNECT_RDONLY; + } + spin_unlock(&imp->imp_lock); + + req = ptlrpc_request_alloc(imp, &RQF_MDS_SET_INFO); + if (req == NULL) + RETURN(-ENOMEM); + + req_capsule_set_size(&req->rq_pill, &RMF_SETINFO_KEY, + RCL_CLIENT, keylen); + req_capsule_set_size(&req->rq_pill, &RMF_SETINFO_VAL, + RCL_CLIENT, vallen); + rc = ptlrpc_request_pack(req, LUSTRE_MDS_VERSION, MDS_SET_INFO); + if (rc) { + ptlrpc_request_free(req); + RETURN(rc); + } + + tmp = req_capsule_client_get(&req->rq_pill, &RMF_SETINFO_KEY); + memcpy(tmp, key, keylen); + tmp = req_capsule_client_get(&req->rq_pill, &RMF_SETINFO_VAL); + memcpy(tmp, val, vallen); + + ptlrpc_request_set_replen(req); + + if (set) { + ptlrpc_set_add_req(set, req); + ptlrpc_check_set(set); + } else { + rc = ptlrpc_queue_wait(req); + ptlrpc_req_finished(req); + } + + RETURN(rc); +} + +int mdc_set_info_async(struct obd_export *exp, + obd_count keylen, void *key, + obd_count vallen, void *val, struct ptlrpc_request_set *set) { struct obd_import *imp = class_exp2cliimp(exp); - int rc = -EINVAL; + int rc = -EINVAL; + ENTRY; if (KEY_IS(KEY_INIT_RECOV)) { if (vallen != sizeof(int)) @@ -1124,40 +1141,7 @@ int mdc_set_info_async(struct obd_export *exp, obd_count keylen, RETURN(0); } if (KEY_IS(KEY_READ_ONLY)) { - struct ptlrpc_request *req; - int size[3] = { sizeof(struct ptlrpc_body), keylen, vallen }; - char *bufs[3] = { NULL, key, val }; - - if (vallen != sizeof(int)) - RETURN(-EINVAL); - - spin_lock(&imp->imp_lock); - if (*((int *)val)) { - imp->imp_connect_flags_orig |= OBD_CONNECT_RDONLY; - imp->imp_connect_data.ocd_connect_flags |= - OBD_CONNECT_RDONLY; - } else { - imp->imp_connect_flags_orig &= ~OBD_CONNECT_RDONLY; - imp->imp_connect_data.ocd_connect_flags &= - ~OBD_CONNECT_RDONLY; - } - spin_unlock(&imp->imp_lock); - - req = ptlrpc_prep_req(imp, LUSTRE_MDS_VERSION, MDS_SET_INFO, - 3, size, bufs); - if (req == NULL) - RETURN(-ENOMEM); - - ptlrpc_req_set_repsize(req, 1, NULL); - if (set) { - rc = 0; - ptlrpc_set_add_req(set, req); - ptlrpc_check_set(set); - } else { - rc = ptlrpc_queue_wait(req); - ptlrpc_req_finished(req); - } - + rc = do_set_info_async(exp, keylen, key, vallen, val, set); RETURN(rc); } if (KEY_IS(KEY_FLUSH_CTX)) { @@ -1214,129 +1198,117 @@ static int mdc_statfs(struct obd_device *obd, struct obd_statfs *osfs, __u64 max_age) { struct ptlrpc_request *req; - struct obd_statfs *msfs; - int rc, size[2] = { sizeof(struct ptlrpc_body), sizeof(*msfs) }; + struct obd_statfs *msfs; + int rc; ENTRY; - /* We could possibly pass max_age in the request (as an absolute - * timestamp or a "seconds.usec ago") so the target can avoid doing - * extra calls into the filesystem if that isn't necessary (e.g. - * during mount that would help a bit). Having relative timestamps - * is not so great if request processing is slow, while absolute - * timestamps are not ideal because they need time synchronization. */ - req = ptlrpc_prep_req(obd->u.cli.cl_import, LUSTRE_MDS_VERSION, - MDS_STATFS, 1, NULL, NULL); - if (!req) + req = ptlrpc_request_alloc_pack(obd->u.cli.cl_import, &RQF_MDS_STATFS, + LUSTRE_MDS_VERSION, MDS_STATFS); + if (req == NULL) RETURN(-ENOMEM); - ptlrpc_req_set_repsize(req, 2, size); + ptlrpc_request_set_replen(req); rc = ptlrpc_queue_wait(req); - if (rc) { /* check connection error first */ if (obd->u.cli.cl_import->imp_connect_error) rc = obd->u.cli.cl_import->imp_connect_error; - GOTO(out, rc); } - msfs = lustre_swab_repbuf(req, REPLY_REC_OFF, sizeof(*msfs), - lustre_swab_obd_statfs); - if (msfs == NULL) { - CERROR("Can't unpack obd_statfs\n"); + msfs = req_capsule_server_get(&req->rq_pill, &RMF_OBD_STATFS); + if (msfs == NULL) GOTO(out, rc = -EPROTO); - } - memcpy(osfs, msfs, sizeof(*msfs)); + *osfs = *msfs; EXIT; out: ptlrpc_req_finished(req); - return rc; } static int mdc_pin(struct obd_export *exp, const struct lu_fid *fid, - struct obd_capa *oc, - struct obd_client_handle *handle, int flag) + struct obd_capa *oc, struct obd_client_handle *handle, + int flags) { struct ptlrpc_request *req; - struct mdt_body *body; - int rc, size[3] = { sizeof(struct ptlrpc_body), sizeof(*body) }; + struct mdt_body *body; + int rc; ENTRY; - size[REQ_REC_OFF + 1] = oc ? sizeof(struct lustre_capa) : 0; - req = ptlrpc_prep_req(class_exp2cliimp(exp), LUSTRE_MDS_VERSION, - MDS_PIN, 3, size, NULL); + req = ptlrpc_request_alloc(class_exp2cliimp(exp), &RQF_MDS_PIN); if (req == NULL) RETURN(-ENOMEM); - body = lustre_msg_buf(req->rq_reqmsg, REQ_REC_OFF, sizeof (*body)); - body->fid1 = *fid; - body->flags = flag; - mdc_pack_capa(req, REQ_REC_OFF + 1, oc); + mdc_set_capa_size(req, &RMF_CAPA1, oc); + + rc = ptlrpc_request_pack(req, LUSTRE_MDS_VERSION, MDS_PIN); + if (rc) { + ptlrpc_request_free(req); + RETURN(rc); + } - ptlrpc_req_set_repsize(req, 2, size); + mdc_pack_body(req, fid, oc, 0, 0, -1, flags); + + ptlrpc_request_set_replen(req); mdc_get_rpc_lock(exp->exp_obd->u.cli.cl_rpc_lock, NULL); rc = ptlrpc_queue_wait(req); mdc_put_rpc_lock(exp->exp_obd->u.cli.cl_rpc_lock, NULL); if (rc) { - CERROR("pin failed: %d\n", rc); - ptlrpc_req_finished(req); - RETURN(rc); + CERROR("Pin failed: %d\n", rc); + GOTO(err_out, rc); } - body = lustre_swab_repbuf(req, REPLY_REC_OFF, sizeof(*body), - lustre_swab_mdt_body); - if (body == NULL) { - ptlrpc_req_finished(req); - RETURN(rc); - } + body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY); + if (body == NULL) + GOTO(err_out, rc = -EPROTO); - memcpy(&handle->och_fh, &body->handle, sizeof(body->handle)); + handle->och_fh = body->handle; handle->och_magic = OBD_CLIENT_HANDLE_MAGIC; - OBD_ALLOC(handle->och_mod, sizeof(*handle->och_mod)); + OBD_ALLOC_PTR(handle->och_mod); if (handle->och_mod == NULL) { - DEBUG_REQ(D_ERROR, req, "can't allocate md_open_data"); - RETURN(-ENOMEM); + DEBUG_REQ(D_ERROR, req, "can't allocate mdc_open_data"); + GOTO(err_out, rc = -ENOMEM); } - /* will be dropped by unpin */ CFS_INIT_LIST_HEAD(&handle->och_mod->mod_replay_list); list_add_tail(&req->rq_mod_list, &handle->och_mod->mod_replay_list); + RETURN(0); + +err_out: + ptlrpc_req_finished(req); RETURN(rc); } -static int mdc_unpin(struct obd_export *exp, - struct obd_client_handle *handle, int flag) +static int mdc_unpin(struct obd_export *exp, struct obd_client_handle *handle, + int flag) { struct ptlrpc_request *req; - struct mdt_body *body; - int rc, size[2] = { sizeof(struct ptlrpc_body), sizeof(*body) }; + struct mdt_body *body; + int rc; ENTRY; - if (handle->och_magic != OBD_CLIENT_HANDLE_MAGIC) - RETURN(0); - - req = ptlrpc_prep_req(class_exp2cliimp(exp), LUSTRE_MDS_VERSION, - MDS_CLOSE, 2, size, NULL); + req = ptlrpc_request_alloc_pack(class_exp2cliimp(exp), &RQF_MDS_UNPIN, + LUSTRE_MDS_VERSION, MDS_UNPIN); if (req == NULL) RETURN(-ENOMEM); - body = lustre_msg_buf(req->rq_reqmsg, REQ_REC_OFF, sizeof(*body)); - memcpy(&body->handle, &handle->och_fh, sizeof(body->handle)); + body = req_capsule_client_get(&req->rq_pill, &RMF_MDT_BODY); + body->handle = handle->och_fh; body->flags = flag; - ptlrpc_req_set_repsize(req, 1, NULL); + ptlrpc_request_set_replen(req); + mdc_get_rpc_lock(exp->exp_obd->u.cli.cl_rpc_lock, NULL); rc = ptlrpc_queue_wait(req); mdc_put_rpc_lock(exp->exp_obd->u.cli.cl_rpc_lock, NULL); if (rc != 0) - CERROR("unpin failed: %d\n", rc); + CERROR("Unpin failed: %d\n", rc); ptlrpc_req_finished(req); @@ -1355,26 +1327,31 @@ int mdc_sync(struct obd_export *exp, const struct lu_fid *fid, struct obd_capa *oc, struct ptlrpc_request **request) { struct ptlrpc_request *req; - int size[3] = { sizeof(struct ptlrpc_body), sizeof(struct mdt_body) }; - int rc; + int rc; ENTRY; - size[REQ_REC_OFF + 1] = oc ? sizeof(struct lustre_capa) : 0; - req = ptlrpc_prep_req(class_exp2cliimp(exp), LUSTRE_MDS_VERSION, - MDS_SYNC, 3, size, NULL); - if (!req) - RETURN(rc = -ENOMEM); + *request = NULL; + req = ptlrpc_request_alloc(class_exp2cliimp(exp), &RQF_MDS_SYNC); + if (req == NULL) + RETURN(-ENOMEM); + + mdc_set_capa_size(req, &RMF_CAPA1, oc); + + rc = ptlrpc_request_pack(req, LUSTRE_MDS_VERSION, MDS_SYNC); + if (rc) { + ptlrpc_request_free(req); + RETURN(rc); + } - mdc_pack_req_body(req, REQ_REC_OFF, 0, fid, oc, 0, -1, 0); + mdc_pack_body(req, fid, oc, 0, 0, -1, 0); - ptlrpc_req_set_repsize(req, 2, size); + ptlrpc_request_set_replen(req); rc = ptlrpc_queue_wait(req); - if (rc || request == NULL) + if (rc) ptlrpc_req_finished(req); else *request = req; - RETURN(rc); } @@ -1616,9 +1593,8 @@ static int mdc_cleanup(struct obd_device *obd) static int mdc_llog_init(struct obd_device *obd, struct obd_llogs *llogs, - struct obd_device *tgt, - int count, struct llog_catid *logid, - struct obd_uuid *uuid) + struct obd_device *tgt, int count, + struct llog_catid *logid, struct obd_uuid *uuid) { struct llog_ctxt *ctxt; int rc; @@ -1674,48 +1650,39 @@ static int mdc_process_config(struct obd_device *obd, obd_count len, void *buf) return(rc); } + /* get remote permission for current user on fid */ int mdc_get_remote_perm(struct obd_export *exp, const struct lu_fid *fid, struct obd_capa *oc, __u32 suppgid, struct ptlrpc_request **request) { - struct ptlrpc_request *req; - struct mdt_body *body; - struct mdt_remote_perm *perm; - int size[5] = { sizeof(struct ptlrpc_body), sizeof(*body) }; - int rc; + struct ptlrpc_request *req; + int rc; ENTRY; - size[REQ_REC_OFF + 1] = oc ? sizeof(struct lustre_capa) : 0; - *request = NULL; - req = ptlrpc_prep_req(class_exp2cliimp(exp), LUSTRE_MDS_VERSION, - MDS_GETATTR, 3, size, NULL); - if (!req) + req = ptlrpc_request_alloc(class_exp2cliimp(exp), &RQF_MDS_GETATTR); + if (req == NULL) RETURN(-ENOMEM); - mdc_pack_req_body(req, REQ_REC_OFF, OBD_MD_FLRMTPERM, fid, oc, 0, - suppgid, 0); + mdc_set_capa_size(req, &RMF_CAPA1, oc); - size[REPLY_REC_OFF + 1] = sizeof(*perm); - ptlrpc_req_set_repsize(req, 5, size); - rc = ptlrpc_queue_wait(req); + rc = ptlrpc_request_pack(req, LUSTRE_MDS_VERSION, MDS_GETATTR); if (rc) { - ptlrpc_req_finished(req); + ptlrpc_request_free(req); RETURN(rc); } - body = lustre_swab_repbuf(req, REPLY_REC_OFF, sizeof(*body), - lustre_swab_mdt_body); - LASSERT(body); - LASSERT(body->valid & OBD_MD_FLRMTPERM); + mdc_pack_body(req, fid, oc, OBD_MD_FLRMTPERM, 0, suppgid, 0); - perm = lustre_swab_repbuf(req, REPLY_REC_OFF + 1, sizeof(*perm), - lustre_swab_mdt_remote_perm); - LASSERT(perm); + ptlrpc_request_set_replen(req); - *request = req; - RETURN(0); + rc = ptlrpc_queue_wait(req); + if (rc) + ptlrpc_req_finished(req); + else + *request = req; + RETURN(rc); } static int mdc_interpret_renew_capa(struct ptlrpc_request *req, void *unused, @@ -1730,15 +1697,14 @@ static int mdc_interpret_renew_capa(struct ptlrpc_request *req, void *unused, if (status) GOTO(out, capa = ERR_PTR(status)); - body = lustre_swab_repbuf(req, REPLY_REC_OFF, sizeof(*body), - lustre_swab_mdt_body); + body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY); if (body == NULL) GOTO(out, capa = ERR_PTR(-EFAULT)); if ((body->valid & OBD_MD_FLOSSCAPA) == 0) GOTO(out, capa = ERR_PTR(-ENOENT)); - capa = lustre_unpack_capa(req->rq_repmsg, REPLY_REC_OFF + 1); + capa = req_capsule_server_get(&req->rq_pill, &RMF_CAPA2); if (!capa) GOTO(out, capa = ERR_PTR(-EFAULT)); EXIT; @@ -1751,32 +1717,31 @@ static int mdc_renew_capa(struct obd_export *exp, struct obd_capa *oc, renew_capa_cb_t cb) { struct ptlrpc_request *req; - int size[5] = { sizeof(struct ptlrpc_body), - sizeof(struct mdt_body), - sizeof(struct lustre_capa) }; ENTRY; - req = ptlrpc_prep_req(class_exp2cliimp(exp), LUSTRE_MDS_VERSION, - MDS_GETATTR, 3, size, NULL); - if (!req) + req = ptlrpc_request_alloc_pack(class_exp2cliimp(exp), &RQF_MDS_GETATTR, + LUSTRE_MDS_VERSION, MDS_GETATTR); + if (req == NULL) RETURN(-ENOMEM); - mdc_pack_req_body(req, REQ_REC_OFF, OBD_MD_FLOSSCAPA, - &oc->c_capa.lc_fid, oc, 0, -1, 0); + /* NB, OBD_MD_FLOSSCAPA is set here, but it doesn't necessarily mean the + * capa to renew is oss capa. + */ + mdc_pack_body(req, &oc->c_capa.lc_fid, oc, OBD_MD_FLOSSCAPA, 0, -1, 0); + ptlrpc_request_set_replen(req); - ptlrpc_req_set_repsize(req, 5, size); req->rq_async_args.pointer_arg[0] = oc; req->rq_async_args.pointer_arg[1] = cb; req->rq_interpret_reply = mdc_interpret_renew_capa; ptlrpcd_add_req(req); - RETURN(0); } static int mdc_connect(const struct lu_env *env, struct lustre_handle *dlm_handle, struct obd_device *obd, struct obd_uuid *cluuid, - struct obd_connect_data *data) { + struct obd_connect_data *data) +{ struct obd_import *imp = obd->u.cli.cl_import; /* mds-mds import features */ diff --git a/lustre/mdd/mdd_object.c b/lustre/mdd/mdd_object.c index 758a1fc..9240034 100644 --- a/lustre/mdd/mdd_object.c +++ b/lustre/mdd/mdd_object.c @@ -1407,8 +1407,8 @@ static int __mdd_readpage(const struct lu_env *env, struct mdd_object *obj, */ iops = &next->do_index_ops->dio_it; it = iops->init(env, next, 0, mdd_object_capa(env, obj)); - if (it == NULL) - return -ENOMEM; + if (IS_ERR(it)) + return PTR_ERR(it); rc = iops->load(env, it, rdpg->rp_hash); diff --git a/lustre/mds/mds_lov.c b/lustre/mds/mds_lov.c index 3c58c2c..9846d22 100644 --- a/lustre/mds/mds_lov.c +++ b/lustre/mds/mds_lov.c @@ -527,9 +527,9 @@ int mds_lov_connect(struct obd_device *obd, char * lov_name) OBD_ALLOC(data, sizeof(*data)); if (data == NULL) RETURN(-ENOMEM); - data->ocd_connect_flags = OBD_CONNECT_VERSION | OBD_CONNECT_INDEX | + data->ocd_connect_flags = OBD_CONNECT_VERSION | OBD_CONNECT_INDEX | OBD_CONNECT_REQPORTAL | OBD_CONNECT_QUOTA64 | - OBD_CONNECT_OSS_CAPA; + OBD_CONNECT_OSS_CAPA | OBD_CONNECT_FID; #ifdef HAVE_LRU_RESIZE_SUPPORT data->ocd_connect_flags |= OBD_CONNECT_LRU_RESIZE; #endif diff --git a/lustre/mdt/mdt_handler.c b/lustre/mdt/mdt_handler.c index 001583f..34620b8 100644 --- a/lustre/mdt/mdt_handler.c +++ b/lustre/mdt/mdt_handler.c @@ -288,7 +288,7 @@ static int mdt_getstatus(struct mdt_thread_info *info) if (OBD_FAIL_CHECK(OBD_FAIL_MDS_GETSTATUS_PACK)) RETURN(err_serious(-ENOMEM)); - repbody = req_capsule_server_get(&info->mti_pill, &RMF_MDT_BODY); + repbody = req_capsule_server_get(info->mti_pill, &RMF_MDT_BODY); rc = next->md_ops->mdo_root_get(info->mti_env, next, &repbody->fid1); if (rc != 0) RETURN(rc); @@ -303,7 +303,7 @@ static int mdt_getstatus(struct mdt_thread_info *info) if (IS_ERR(root)) RETURN(PTR_ERR(root)); - capa = req_capsule_server_get(&info->mti_pill, &RMF_CAPA1); + capa = req_capsule_server_get(info->mti_pill, &RMF_CAPA1); LASSERT(capa); capa->lc_opc = CAPA_OPC_MDS_DEFAULT; @@ -336,7 +336,7 @@ static int mdt_statfs(struct mdt_thread_info *info) if (OBD_FAIL_CHECK(OBD_FAIL_MDS_STATFS_PACK)) { rc = err_serious(-ENOMEM); } else { - osfs = req_capsule_server_get(&info->mti_pill,&RMF_OBD_STATFS); + osfs = req_capsule_server_get(info->mti_pill, &RMF_OBD_STATFS); rc = next->md_ops->mdo_statfs(info->mti_env, next, &info->mti_u.ksfs); statfs_pack(osfs, &info->mti_u.ksfs); @@ -349,7 +349,7 @@ void mdt_pack_size2body(struct mdt_thread_info *info, struct mdt_object *o) struct mdt_body *b; struct lu_attr *attr = &info->mti_attr.ma_attr; - b = req_capsule_server_get(&info->mti_pill, &RMF_MDT_BODY); + b = req_capsule_server_get(info->mti_pill, &RMF_MDT_BODY); /* Check if Size-on-MDS is enabled. */ if ((mdt_conn_flags(info) & OBD_CONNECT_SOM) && @@ -387,7 +387,13 @@ void mdt_pack_attr2body(struct mdt_thread_info *info, struct mdt_body *b, if (fid) { b->fid1 = *fid; b->valid |= OBD_MD_FLID; - CDEBUG(D_INODE, ""DFID": nlink=%d, mode=%o, size="LPU64"\n", + + /* FIXME: these should be fixed when new igif ready.*/ + b->ino = fid_oid(fid); /* 1.6 compatibility */ + b->generation = fid_ver(fid); /* 1.6 compatibility */ + b->valid |= OBD_MD_FLGENER; /* 1.6 compatibility */ + + CDEBUG(D_INODE, DFID": nlink=%d, mode=%o, size="LPU64"\n", PFID(fid), b->nlink, b->mode, b->size); } @@ -411,7 +417,7 @@ static int mdt_getattr_internal(struct mdt_thread_info *info, struct mdt_export_data *med = &req->rq_export->exp_mdt_data; struct md_attr *ma = &info->mti_attr; struct lu_attr *la = &ma->ma_attr; - struct req_capsule *pill = &info->mti_pill; + struct req_capsule *pill = info->mti_pill; const struct lu_env *env = info->mti_env; struct mdt_body *repbody; struct lu_buf *buffer = &info->mti_buf; @@ -559,7 +565,7 @@ static int mdt_getattr_internal(struct mdt_thread_info *info, info->mti_mdt->mdt_opts.mo_mds_capa) { struct lustre_capa *capa; - capa = req_capsule_server_get(&info->mti_pill, &RMF_CAPA1); + capa = req_capsule_server_get(pill, &RMF_CAPA1); LASSERT(capa); capa->lc_opc = CAPA_OPC_MDS_DEFAULT; rc = mo_capa_get(env, next, capa, 0); @@ -586,27 +592,26 @@ static int mdt_renew_capa(struct mdt_thread_info *info) if (!obj || !mdt->mdt_opts.mo_mds_capa) RETURN(0); - body = req_capsule_server_get(&info->mti_pill, &RMF_MDT_BODY); + body = req_capsule_server_get(info->mti_pill, &RMF_MDT_BODY); LASSERT(body != NULL); - c = req_capsule_client_get(&info->mti_pill, &RMF_CAPA1); + c = req_capsule_client_get(info->mti_pill, &RMF_CAPA1); LASSERT(c); - capa = req_capsule_server_get(&info->mti_pill, &RMF_CAPA1); + capa = req_capsule_server_get(info->mti_pill, &RMF_CAPA2); LASSERT(capa); *capa = *c; rc = mo_capa_get(info->mti_env, mdt_object_child(obj), capa, 1); if (rc == 0) body->valid |= OBD_MD_FLOSSCAPA; - RETURN(rc); } static int mdt_getattr(struct mdt_thread_info *info) { struct mdt_object *obj = info->mti_object; - struct req_capsule *pill = &info->mti_pill; + struct req_capsule *pill = info->mti_pill; struct mdt_body *reqbody; struct mdt_body *repbody; mode_t mode; @@ -618,14 +623,11 @@ static int mdt_getattr(struct mdt_thread_info *info) LASSERT(reqbody); if (reqbody->valid & OBD_MD_FLOSSCAPA) { - rc = req_capsule_pack(pill); + rc = req_capsule_server_pack(pill); if (unlikely(rc)) - rc = err_serious(rc); - else { - rc = mdt_renew_capa(info); - mdt_shrink_reply(info); - } - GOTO(out, rc); + RETURN(err_serious(rc)); + rc = mdt_renew_capa(info); + GOTO(out_shrink, rc); } LASSERT(obj != NULL); @@ -640,9 +642,9 @@ static int mdt_getattr(struct mdt_thread_info *info) req_capsule_set_size(pill, &RMF_MDT_MD, RCL_SERVER, md_size); - rc = req_capsule_pack(pill); + rc = req_capsule_server_pack(pill); if (unlikely(rc != 0)) - GOTO(out, rc = err_serious(rc)); + RETURN(err_serious(rc)); repbody = req_capsule_server_get(pill, &RMF_MDT_BODY); LASSERT(repbody != NULL); @@ -670,14 +672,13 @@ static int mdt_getattr(struct mdt_thread_info *info) EXIT; out_shrink: mdt_shrink_reply(info); -out: return rc; } static int mdt_is_subdir(struct mdt_thread_info *info) { struct mdt_object *o = info->mti_object; - struct req_capsule *pill = &info->mti_pill; + struct req_capsule *pill = info->mti_pill; const struct mdt_body *body = info->mti_body; struct mdt_body *repbody; int rc; @@ -730,11 +731,10 @@ static int mdt_raw_lookup(struct mdt_thread_info *info, } else mdt_set_disposition(info, ldlm_rep, DISP_LOOKUP_POS); - repbody = req_capsule_server_get(&info->mti_pill, &RMF_MDT_BODY); + repbody = req_capsule_server_get(info->mti_pill, &RMF_MDT_BODY); #endif if (rc == 0) { - repbody = req_capsule_server_get(&info->mti_pill, - &RMF_MDT_BODY); + repbody = req_capsule_server_get(info->mti_pill, &RMF_MDT_BODY); repbody->fid1 = *child_fid; repbody->valid = OBD_MD_FLID; } @@ -774,11 +774,11 @@ static int mdt_getattr_name_lock(struct mdt_thread_info *info, lustre_msg_get_flags(req->rq_reqmsg) & MSG_RESENT)); LASSERT(parent != NULL); - name = req_capsule_client_get(&info->mti_pill, &RMF_NAME); + name = req_capsule_client_get(info->mti_pill, &RMF_NAME); if (name == NULL) RETURN(err_serious(-EFAULT)); - namelen = req_capsule_get_size(&info->mti_pill, &RMF_NAME, + namelen = req_capsule_get_size(info->mti_pill, &RMF_NAME, RCL_CLIENT) - 1; LASSERT(namelen >= 0); @@ -786,7 +786,7 @@ static int mdt_getattr_name_lock(struct mdt_thread_info *info, * otherwise do not allow empty name, that is the name must contain * at least one character and the terminating '\0'*/ if (namelen == 0) { - reqbody =req_capsule_client_get(&info->mti_pill, &RMF_MDT_BODY); + reqbody =req_capsule_client_get(info->mti_pill, &RMF_MDT_BODY); LASSERT(fid_is_sane(&reqbody->fid2)); name = NULL; @@ -860,7 +860,7 @@ static int mdt_getattr_name_lock(struct mdt_thread_info *info, if (unlikely(rc != 0)) mdt_object_unlock(info, child, lhc, 1); } - GOTO(out, rc); + RETURN(rc); } /* step 1: lock parent */ @@ -964,7 +964,7 @@ relock: * Pack Size-on-MDS inode attributes to the body if * update lock is given. */ - repbody = req_capsule_server_get(&info->mti_pill, + repbody = req_capsule_server_get(info->mti_pill, &RMF_MDT_BODY); ma = &info->mti_attr.ma_attr; if (lock->l_policy_data.l_inodebits.bits & @@ -978,7 +978,6 @@ out_child: mdt_object_put(info->mti_env, child); out_parent: mdt_object_unlock(info, parent, lhp, 1); -out: return rc; } @@ -991,9 +990,9 @@ static int mdt_getattr_name(struct mdt_thread_info *info) int rc; ENTRY; - reqbody = req_capsule_client_get(&info->mti_pill, &RMF_MDT_BODY); + reqbody = req_capsule_client_get(info->mti_pill, &RMF_MDT_BODY); LASSERT(reqbody != NULL); - repbody = req_capsule_server_get(&info->mti_pill, &RMF_MDT_BODY); + repbody = req_capsule_server_get(info->mti_pill, &RMF_MDT_BODY); LASSERT(repbody != NULL); info->mti_spec.sp_ck_split = !!(reqbody->valid & OBD_MD_FLCKSPLIT); @@ -1003,7 +1002,7 @@ static int mdt_getattr_name(struct mdt_thread_info *info) rc = mdt_init_ucred(info, reqbody); if (unlikely(rc)) - GOTO(out, rc); + GOTO(out_shrink, rc); rc = mdt_getattr_name_lock(info, lhc, MDS_INODELOCK_UPDATE, NULL); if (lustre_handle_is_used(&lhc->mlh_reg_lh)) { @@ -1012,7 +1011,7 @@ static int mdt_getattr_name(struct mdt_thread_info *info) } mdt_exit_ucred(info); EXIT; -out: +out_shrink: mdt_shrink_reply(info); return rc; } @@ -1032,20 +1031,20 @@ static int mdt_set_info(struct mdt_thread_info *info) int keylen, rc = 0; ENTRY; - rc = lustre_pack_reply(req, 1, NULL, NULL); + rc = req_capsule_server_pack(info->mti_pill); if (rc) RETURN(rc); - key = req_capsule_client_get(&info->mti_pill, &RMF_SETINFO_KEY); + key = req_capsule_client_get(info->mti_pill, &RMF_SETINFO_KEY); if (key == NULL) { DEBUG_REQ(D_HA, req, "no set_info key"); RETURN(-EFAULT); } - keylen = req_capsule_get_size(&info->mti_pill, &RMF_SETINFO_KEY, + keylen = req_capsule_get_size(info->mti_pill, &RMF_SETINFO_KEY, RCL_CLIENT); - val = req_capsule_client_get(&info->mti_pill, &RMF_SETINFO_VAL); + val = req_capsule_client_get(info->mti_pill, &RMF_SETINFO_VAL); if (val == NULL) { DEBUG_REQ(D_HA, req, "no set_info val"); RETURN(-EFAULT); @@ -1113,7 +1112,7 @@ static int mdt_sendpage(struct mdt_thread_info *info, desc = ptlrpc_prep_bulk_exp(req, rdpg->rp_npages, BULK_PUT_SOURCE, MDS_BULK_PORTAL); if (desc == NULL) - GOTO(out, rc = -ENOMEM); + RETURN(-ENOMEM); for (i = 0, tmpcount = rdpg->rp_count; i < rdpg->rp_npages; i++, tmpcount -= tmpsize) { @@ -1154,7 +1153,6 @@ abort_bulk: ptlrpc_abort_bulk(desc); free_desc: ptlrpc_free_bulk(desc); -out: return rc; } @@ -1259,7 +1257,7 @@ static int mdt_writepage(struct mdt_thread_info *info) ENTRY; - reqbody = req_capsule_client_get(&info->mti_pill, &RMF_MDT_BODY); + reqbody = req_capsule_client_get(info->mti_pill, &RMF_MDT_BODY); if (reqbody == NULL) RETURN(err_serious(-EFAULT)); @@ -1342,8 +1340,8 @@ static int mdt_readpage(struct mdt_thread_info *info) if (OBD_FAIL_CHECK(OBD_FAIL_MDS_READPAGE_PACK)) RETURN(err_serious(-ENOMEM)); - reqbody = req_capsule_client_get(&info->mti_pill, &RMF_MDT_BODY); - repbody = req_capsule_server_get(&info->mti_pill, &RMF_MDT_BODY); + reqbody = req_capsule_client_get(info->mti_pill, &RMF_MDT_BODY); + repbody = req_capsule_server_get(info->mti_pill, &RMF_MDT_BODY); if (reqbody == NULL || repbody == NULL) RETURN(err_serious(-EFAULT)); @@ -1396,25 +1394,21 @@ static int mdt_reint_internal(struct mdt_thread_info *info, struct mdt_lock_handle *lhc, __u32 op) { - struct req_capsule *pill = &info->mti_pill; + struct req_capsule *pill = info->mti_pill; struct mdt_device *mdt = info->mti_mdt; struct mdt_body *repbody; - int need_shrink = 0; - int rc; + int rc = 0; ENTRY; /* pack reply */ - if (req_capsule_has_field(pill, &RMF_MDT_MD, RCL_SERVER)) { + if (req_capsule_has_field(pill, &RMF_MDT_MD, RCL_SERVER)) req_capsule_set_size(pill, &RMF_MDT_MD, RCL_SERVER, mdt->mdt_max_mdsize); - need_shrink = 1; - } - if (req_capsule_has_field(pill, &RMF_LOGCOOKIES, RCL_SERVER)) { + if (req_capsule_has_field(pill, &RMF_LOGCOOKIES, RCL_SERVER)) req_capsule_set_size(pill, &RMF_LOGCOOKIES, RCL_SERVER, mdt->mdt_max_cookiesize); - need_shrink = 1; - } - rc = req_capsule_pack(pill); + + rc = req_capsule_server_pack(pill); if (rc != 0) { CERROR("Can't pack response, rc %d\n", rc); RETURN(err_serious(rc)); @@ -1444,35 +1438,32 @@ static int mdt_reint_internal(struct mdt_thread_info *info, if (rc != 0) GOTO(out_ucred, rc = err_serious(rc)); - need_shrink = 0; if (mdt_check_resent(info, mdt_reconstruct, lhc)) { rc = lustre_msg_get_status(mdt_info_req(info)->rq_repmsg); GOTO(out_ucred, rc); } - rc = mdt_reint_rec(info, lhc); EXIT; out_ucred: mdt_exit_ucred(info); out_shrink: - if (need_shrink) - mdt_shrink_reply(info); + mdt_shrink_reply(info); return rc; } static long mdt_reint_opcode(struct mdt_thread_info *info, const struct req_format **fmt) { - __u32 *ptr; + struct mdt_rec_reint *rec; long opc; opc = err_serious(-EFAULT); - ptr = req_capsule_client_get(&info->mti_pill, &RMF_REINT_OPC); - if (ptr != NULL) { - opc = *ptr; + rec = req_capsule_client_get(info->mti_pill, &RMF_REC_REINT); + if (rec != NULL) { + opc = rec->rr_opcode; DEBUG_REQ(D_INODE, mdt_info_req(info), "reint opt = %ld", opc); if (opc < REINT_MAX && fmt[opc] != NULL) - req_capsule_extend(&info->mti_pill, fmt[opc]); + req_capsule_extend(info->mti_pill, fmt[opc]); else { CERROR("Unsupported opc: %ld\n", opc); opc = err_serious(opc); @@ -1487,12 +1478,13 @@ static int mdt_reint(struct mdt_thread_info *info) int rc; static const struct req_format *reint_fmts[REINT_MAX] = { - [REINT_SETATTR] = &RQF_MDS_REINT_SETATTR, - [REINT_CREATE] = &RQF_MDS_REINT_CREATE, - [REINT_LINK] = &RQF_MDS_REINT_LINK, - [REINT_UNLINK] = &RQF_MDS_REINT_UNLINK, - [REINT_RENAME] = &RQF_MDS_REINT_RENAME, - [REINT_OPEN] = &RQF_MDS_REINT_OPEN + [REINT_SETATTR] = &RQF_MDS_REINT_SETATTR, + [REINT_CREATE] = &RQF_MDS_REINT_CREATE, + [REINT_LINK] = &RQF_MDS_REINT_LINK, + [REINT_UNLINK] = &RQF_MDS_REINT_UNLINK, + [REINT_RENAME] = &RQF_MDS_REINT_RENAME, + [REINT_OPEN] = &RQF_MDS_REINT_OPEN, + [REINT_SETXATTR] = &RQF_MDS_REINT_SETXATTR }; ENTRY; @@ -1528,7 +1520,7 @@ static int mdt_object_sync(struct mdt_thread_info *info) static int mdt_sync(struct mdt_thread_info *info) { - struct req_capsule *pill = &info->mti_pill; + struct req_capsule *pill = info->mti_pill; struct mdt_body *body; int rc; ENTRY; @@ -1545,7 +1537,7 @@ static int mdt_sync(struct mdt_thread_info *info) if (fid_seq(&body->fid1) == 0) { /* sync the whole device */ - rc = req_capsule_pack(pill); + rc = req_capsule_server_pack(pill); if (rc == 0) rc = mdt_device_sync(info); else @@ -1595,6 +1587,9 @@ static int mdt_obd_ping(struct mdt_thread_info *info) { int rc; ENTRY; + + req_capsule_set(info->mti_pill, &RQF_OBD_PING); + rc = target_handle_ping(mdt_info_req(info)); if (rc < 0) rc = err_serious(rc); @@ -1716,6 +1711,7 @@ struct mdt_object *mdt_object_find(const struct lu_env *env, struct mdt_object *m; ENTRY; + CDEBUG(D_INFO, "Find object for "DFID"\n", PFID(f)); o = lu_object_find(env, d->mdt_md_dev.md_lu_dev.ld_site, f); if (unlikely(IS_ERR(o))) m = (struct mdt_object *)o; @@ -1926,17 +1922,21 @@ static int mdt_body_unpack(struct mdt_thread_info *info, __u32 flags) const struct lu_env *env; struct req_capsule *pill; int rc; + ENTRY; env = info->mti_env; - pill = &info->mti_pill; + pill = info->mti_pill; body = info->mti_body = req_capsule_client_get(pill, &RMF_MDT_BODY); if (body == NULL) - return -EFAULT; + RETURN(-EFAULT); + + if (!(body->valid & OBD_MD_FLID)) + RETURN(0); if (!fid_is_sane(&body->fid1)) { CERROR("Invalid fid: "DFID"\n", PFID(&body->fid1)); - return -EINVAL; + RETURN(-EINVAL); } /* @@ -1967,16 +1967,14 @@ static int mdt_body_unpack(struct mdt_thread_info *info, __u32 flags) } else rc = PTR_ERR(obj); - return rc; + RETURN(rc); } static int mdt_unpack_req_pack_rep(struct mdt_thread_info *info, __u32 flags) { - struct req_capsule *pill; + struct req_capsule *pill = info->mti_pill; int rc; - ENTRY; - pill = &info->mti_pill; if (req_capsule_has_field(pill, &RMF_MDT_BODY, RCL_CLIENT)) rc = mdt_body_unpack(info, flags); @@ -1994,7 +1992,7 @@ static int mdt_unpack_req_pack_rep(struct mdt_thread_info *info, __u32 flags) req_capsule_set_size(pill, &RMF_LOGCOOKIES, RCL_SERVER, mdt->mdt_max_cookiesize); - rc = req_capsule_pack(pill); + rc = req_capsule_server_pack(pill); } RETURN(rc); } @@ -2050,7 +2048,7 @@ static int mdt_req_handle(struct mdt_thread_info *info, LASSERT(ergo(flags & (HABEO_CORPUS|HABEO_REFERO), h->mh_fmt != NULL)); if (h->mh_fmt != NULL) { - req_capsule_set(&info->mti_pill, h->mh_fmt); + req_capsule_set(info->mti_pill, h->mh_fmt); rc = mdt_unpack_req_pack_rep(info, flags); } @@ -2064,14 +2062,13 @@ static int mdt_req_handle(struct mdt_thread_info *info, LASSERT(h->mh_fmt != NULL); - dlm_req = req_capsule_client_get(&info->mti_pill, &RMF_DLM_REQ); + dlm_req = req_capsule_client_get(info->mti_pill, &RMF_DLM_REQ); if (dlm_req != NULL) { if (info->mti_mdt->mdt_opts.mo_compat_resname) rc = mdt_lock_resname_compat(info->mti_mdt, dlm_req); info->mti_dlm_req = dlm_req; } else { - CERROR("Can't unpack dlm request\n"); rc = -EFAULT; } } @@ -2111,7 +2108,7 @@ static int mdt_req_handle(struct mdt_thread_info *info, info->mti_mdt->mdt_opts.mo_compat_resname) { struct ldlm_reply *dlmrep; - dlmrep = req_capsule_server_get(&info->mti_pill, &RMF_DLM_REP); + dlmrep = req_capsule_server_get(info->mti_pill, &RMF_DLM_REP); if (dlmrep != NULL) rc = mdt_lock_reply_compat(info->mti_mdt, dlmrep); } @@ -2155,11 +2152,8 @@ static void mdt_thread_info_init(struct ptlrpc_request *req, int i; struct md_capainfo *ci; - info->mti_rep_buf_nr = ARRAY_SIZE(info->mti_rep_buf_size); - for (i = 0; i < ARRAY_SIZE(info->mti_rep_buf_size); i++) - info->mti_rep_buf_size[i] = -1; - req_capsule_init(&info->mti_pill, req, RCL_SERVER, - info->mti_rep_buf_size); + req_capsule_init(&req->rq_pill, req, RCL_SERVER); + info->mti_pill = &req->rq_pill; /* lock handle */ for (i = 0; i < ARRAY_SIZE(info->mti_lh); i++) @@ -2195,7 +2189,7 @@ static void mdt_thread_info_fini(struct mdt_thread_info *info) { int i; - req_capsule_fini(&info->mti_pill); + req_capsule_fini(info->mti_pill); if (info->mti_object != NULL) { mdt_object_put(info->mti_env, info->mti_object); info->mti_object = NULL; @@ -2615,7 +2609,7 @@ static void mdt_intent_fixup_resent(struct mdt_thread_info *info, if (!(lustre_msg_get_flags(req->rq_reqmsg) & MSG_RESENT)) return; - dlmreq = req_capsule_client_get(&info->mti_pill, &RMF_DLM_REQ); + dlmreq = req_capsule_client_get(info->mti_pill, &RMF_DLM_REQ); remote_hdl = dlmreq->lock_handle[0]; spin_lock(&exp->exp_ldlm_data.led_lock); @@ -2673,10 +2667,10 @@ static int mdt_intent_getattr(enum mdt_it_code opcode, int rc; ENTRY; - reqbody = req_capsule_client_get(&info->mti_pill, &RMF_MDT_BODY); + reqbody = req_capsule_client_get(info->mti_pill, &RMF_MDT_BODY); LASSERT(reqbody); - repbody = req_capsule_server_get(&info->mti_pill, &RMF_MDT_BODY); + repbody = req_capsule_server_get(info->mti_pill, &RMF_MDT_BODY); LASSERT(repbody); info->mti_spec.sp_ck_split = !!(reqbody->valid & OBD_MD_FLCKSPLIT); @@ -2693,15 +2687,15 @@ static int mdt_intent_getattr(enum mdt_it_code opcode, break; default: CERROR("Unhandled till now"); - GOTO(out, rc = -EINVAL); + GOTO(out_shrink, rc = -EINVAL); } rc = mdt_init_ucred(info, reqbody); if (rc) - GOTO(out, rc); + GOTO(out_shrink, rc); - req = info->mti_pill.rc_req; - ldlm_rep = req_capsule_server_get(&info->mti_pill, &RMF_DLM_REP); + req = info->mti_pill->rc_req; + ldlm_rep = req_capsule_server_get(info->mti_pill, &RMF_DLM_REP); mdt_set_disposition(info, ldlm_rep, DISP_IT_EXECD); /* Get lock from request for possible resent case. */ @@ -2722,7 +2716,7 @@ static int mdt_intent_getattr(enum mdt_it_code opcode, EXIT; out_ucred: mdt_exit_ucred(info); -out: +out_shrink: mdt_shrink_reply(info); return rc; } @@ -2746,12 +2740,12 @@ static int mdt_intent_reint(enum mdt_it_code opcode, opc = mdt_reint_opcode(info, intent_fmts); if (opc < 0) - GOTO(out, rc = opc); + RETURN(opc); if (mdt_it_flavor[opcode].it_reint != opc) { CERROR("Reint code %ld doesn't match intent: %d\n", opc, opcode); - GOTO(out, rc = err_serious(-EPROTO)); + RETURN(err_serious(-EPROTO)); } /* Get lock from request for possible resent case. */ @@ -2761,9 +2755,9 @@ static int mdt_intent_reint(enum mdt_it_code opcode, /* Check whether the reply has been packed successfully. */ if (mdt_info_req(info)->rq_repmsg != NULL) - rep = req_capsule_server_get(&info->mti_pill, &RMF_DLM_REP); + rep = req_capsule_server_get(info->mti_pill, &RMF_DLM_REP); if (rep == NULL) - GOTO(out, rc = err_serious(-EFAULT)); + RETURN(err_serious(-EFAULT)); /* MDC expects this in any case */ if (rc != 0) @@ -2774,15 +2768,13 @@ static int mdt_intent_reint(enum mdt_it_code opcode, LASSERT(lustre_handle_is_used(&lhc->mlh_reg_lh)); rep->lock_policy_res2 = 0; rc = mdt_intent_lock_replace(info, lockp, NULL, lhc, flags); - GOTO(out, rc); + RETURN(rc); } rep->lock_policy_res2 = clear_serious(rc); lhc->mlh_reg_lh.cookie = 0ull; rc = ELDLM_LOCK_ABORTED; - EXIT; -out: - return rc; + RETURN(rc); } static int mdt_intent_code(long itcode) @@ -2838,7 +2830,7 @@ static int mdt_intent_opc(long itopc, struct mdt_thread_info *info, if (opc < 0) RETURN(-EINVAL); - pill = &info->mti_pill; + pill = info->mti_pill; flv = &mdt_it_flavor[opc]; if (flv->it_fmt != NULL) @@ -2849,13 +2841,14 @@ static int mdt_intent_opc(long itopc, struct mdt_thread_info *info, struct ptlrpc_request *req = mdt_info_req(info); if (flv->it_flags & MUTABOR && req->rq_export->exp_connect_flags & OBD_CONNECT_RDONLY) - rc = -EROFS; + RETURN(-EROFS); } if (rc == 0 && flv->it_act != NULL) { /* execute policy */ rc = flv->it_act(opc, info, lockp, flags); - } else + } else { rc = -EOPNOTSUPP; + } RETURN(rc); } @@ -2876,7 +2869,7 @@ static int mdt_intent_policy(struct ldlm_namespace *ns, info = lu_context_key_get(&req->rq_svc_thread->t_env->le_ctx, &mdt_thread_key); LASSERT(info != NULL); - pill = &info->mti_pill; + pill = info->mti_pill; LASSERT(pill->rc_req == req); if (req->rq_reqmsg->lm_bufcount > DLM_INTENT_IT_OFF) { @@ -2911,7 +2904,7 @@ static int mdt_intent_policy(struct ldlm_namespace *ns, } else { /* No intent was provided */ LASSERT(pill->rc_fmt == &RQF_LDLM_ENQUEUE); - rc = req_capsule_pack(pill); + rc = req_capsule_server_pack(pill); if (rc) rc = err_serious(rc); } @@ -4179,6 +4172,12 @@ static int mdt_connect_internal(struct obd_export *exp, return -EBADE; } + if ((exp->exp_connect_flags & OBD_CONNECT_FID) == 0) { + CWARN("%s: MDS requires FID support, but client not\n", + mdt->mdt_md_dev.md_lu_dev.ld_obd->obd_name); + return -EBADE; + } + return 0; } @@ -4201,7 +4200,7 @@ static int mdt_obd_connect(const struct lu_env *env, RETURN(-EINVAL); info = lu_context_key_get(&env->le_ctx, &mdt_thread_key); - req = info->mti_pill.rc_req; + req = info->mti_pill->rc_req; mdt = mdt_dev(obd->obd_lu_dev); rc = class_connect(conn, obd, cluuid); @@ -4274,7 +4273,7 @@ static int mdt_obd_reconnect(const struct lu_env *env, RETURN(-EINVAL); info = lu_context_key_get(&env->le_ctx, &mdt_thread_key); - req = info->mti_pill.rc_req; + req = info->mti_pill->rc_req; mdt = mdt_dev(obd->obd_lu_dev); CDEBUG(D_SEC, "from %s\n", sptlrpc_part2name(req->rq_sp_from)); @@ -4724,7 +4723,6 @@ DEF_MDT_HNDL_F(0, SET_INFO, mdt_set_info), DEF_MDT_HNDL_F(0 |HABEO_REFERO, GETSTATUS, mdt_getstatus), DEF_MDT_HNDL_F(HABEO_CORPUS, GETATTR, mdt_getattr), DEF_MDT_HNDL_F(HABEO_CORPUS|HABEO_REFERO, GETATTR_NAME, mdt_getattr_name), -DEF_MDT_HNDL_F(HABEO_CORPUS|MUTABOR, SETXATTR, mdt_setxattr), DEF_MDT_HNDL_F(HABEO_CORPUS, GETXATTR, mdt_getxattr), DEF_MDT_HNDL_F(0 |HABEO_REFERO, STATFS, mdt_statfs), DEF_MDT_HNDL_F(0 |MUTABOR, REINT, mdt_reint), @@ -4733,8 +4731,8 @@ DEF_MDT_HNDL_F(HABEO_CORPUS, DONE_WRITING, mdt_done_writing), DEF_MDT_HNDL_F(0 |HABEO_REFERO, PIN, mdt_pin), DEF_MDT_HNDL_0(0, SYNC, mdt_sync), DEF_MDT_HNDL_F(HABEO_CORPUS|HABEO_REFERO, IS_SUBDIR, mdt_is_subdir), -DEF_MDT_HNDL_0(0, QUOTACHECK, mdt_quotacheck_handle), -DEF_MDT_HNDL_0(0, QUOTACTL, mdt_quotactl_handle) +DEF_MDT_HNDL_F(0, QUOTACHECK, mdt_quotacheck_handle), +DEF_MDT_HNDL_F(0, QUOTACTL, mdt_quotactl_handle) }; #define DEF_OBD_HNDL(flags, name, fn) \ diff --git a/lustre/mdt/mdt_idmap.c b/lustre/mdt/mdt_idmap.c index d7d602c..c7a4c31 100644 --- a/lustre/mdt/mdt_idmap.c +++ b/lustre/mdt/mdt_idmap.c @@ -68,8 +68,8 @@ int mdt_init_idmap(struct mdt_thread_info *info) int rc = 0, remote; ENTRY; - data = req_capsule_client_get(&info->mti_pill, &RMF_CONNECT_DATA); - reply = req_capsule_server_get(&info->mti_pill, &RMF_CONNECT_DATA); + data = req_capsule_client_get(info->mti_pill, &RMF_CONNECT_DATA); + reply = req_capsule_server_get(info->mti_pill, &RMF_CONNECT_DATA); if (data == NULL || reply == NULL) RETURN(-EFAULT); diff --git a/lustre/mdt/mdt_internal.h b/lustre/mdt/mdt_internal.h index 1745876..d943076 100644 --- a/lustre/mdt/mdt_internal.h +++ b/lustre/mdt/mdt_internal.h @@ -268,27 +268,18 @@ enum mdt_reint_flag { struct mdt_thread_info { /* * XXX: Part One: - * The following members will be filled expilictly + * The following members will be filled explicitly * with specific data in mdt_thread_info_init(). */ - - /* - * for req-layout interface. This field should be first to be compatible - * with "struct com_thread_info" in seq and fld. + /* TODO: move this into mdt_session_key(with LCT_SESSION), because + * request handling may migrate from one server thread to another. */ - struct req_capsule mti_pill; + struct req_capsule *mti_pill; + /* although we have export in req, there are cases when it is not * available, e.g. closing files upon export destroy */ struct obd_export *mti_exp; /* - * number of buffers in reply message. - */ - int mti_rep_buf_nr; - /* - * sizes of reply buffers. - */ - int mti_rep_buf_size[REQ_MAX_FIELD_NR]; - /* * A couple of lock handles. */ struct mdt_lock_handle mti_lh[MDT_LH_NR]; @@ -442,12 +433,13 @@ static inline struct md_device_operations *mdt_child_ops(struct mdt_device * m) static inline struct md_object *mdt_object_child(struct mdt_object *o) { + LASSERT(o); return lu2md(lu_object_next(&o->mot_obj.mo_lu)); } static inline struct ptlrpc_request *mdt_info_req(struct mdt_thread_info *info) { - return info->mti_pill.rc_req; + return info->mti_pill ? info->mti_pill->rc_req : NULL; } static inline __u64 mdt_conn_flags(struct mdt_thread_info *info) @@ -530,7 +522,8 @@ void mdt_pack_attr2body(struct mdt_thread_info *info, struct mdt_body *b, const struct lu_attr *attr, const struct lu_fid *fid); int mdt_getxattr(struct mdt_thread_info *info); -int mdt_setxattr(struct mdt_thread_info *info); +int mdt_reint_setxattr(struct mdt_thread_info *info, + struct mdt_lock_handle *lh); void mdt_lock_handle_init(struct mdt_lock_handle *lh); void mdt_lock_handle_fini(struct mdt_lock_handle *lh); diff --git a/lustre/mdt/mdt_lib.c b/lustre/mdt/mdt_lib.c index 37cb8f0..410ad51 100644 --- a/lustre/mdt/mdt_lib.c +++ b/lustre/mdt/mdt_lib.c @@ -471,9 +471,10 @@ void mdt_dump_lmm(int level, const struct lov_mds_md *lmm) void mdt_shrink_reply(struct mdt_thread_info *info) { - struct req_capsule *pill = &info->mti_pill; - struct mdt_body *body; - int acl_size, md_size, adjust = 0; + struct req_capsule *pill = info->mti_pill; + struct mdt_body *body; + int md_size; + int acl_size; ENTRY; body = req_capsule_server_get(pill, &RMF_MDT_BODY); @@ -487,10 +488,10 @@ void mdt_shrink_reply(struct mdt_thread_info *info) acl_size = body->aclsize; CDEBUG(D_INFO, "Shrink to md_size = %d cookie/acl_size = %d" - " MDSCAPA = %d, OSSCAPA = %d\n", + " MDSCAPA = "LPX64", OSSCAPA = "LPX64"\n", md_size, acl_size, - (int)(body->valid & OBD_MD_FLMDSCAPA), - (int)(body->valid & OBD_MD_FLOSSCAPA)); + body->valid & OBD_MD_FLMDSCAPA, + body->valid & OBD_MD_FLOSSCAPA); /* &RMF_MDT_BODY, &RMF_MDT_MD, @@ -499,33 +500,23 @@ void mdt_shrink_reply(struct mdt_thread_info *info) (optional) &RMF_CAPA2, (optional) something else */ - adjust += req_capsule_shrink(pill, &RMF_MDT_MD, - md_size, adjust, 1); + if (req_capsule_has_field(pill, &RMF_MDT_MD, RCL_SERVER)) + req_capsule_shrink(pill, &RMF_MDT_MD, md_size, + RCL_SERVER); if (req_capsule_has_field(pill, &RMF_ACL, RCL_SERVER)) - adjust += req_capsule_shrink(pill, &RMF_ACL, - acl_size, adjust, 1); + req_capsule_shrink(pill, &RMF_ACL, acl_size, RCL_SERVER); else if (req_capsule_has_field(pill, &RMF_LOGCOOKIES, RCL_SERVER)) - adjust += req_capsule_shrink(pill, &RMF_LOGCOOKIES, - acl_size, adjust, 1); - - /* RMF_CAPA1 on server-side maybe for OBD_MD_FLMDSCAPA or - * OBD_MD_FLOSSCAPA. If RMF_CAPA2 exist also, RMF_CAPA1 is - * for OBD_MD_FLMDSCAPA only. */ - if (req_capsule_has_field(pill, &RMF_CAPA1, RCL_SERVER)) { - if ((req_capsule_has_field(pill, &RMF_CAPA2, RCL_SERVER) && - !(body->valid & OBD_MD_FLMDSCAPA)) || - (!req_capsule_has_field(pill, &RMF_CAPA2, RCL_SERVER) && - !(body->valid & OBD_MD_FLMDSCAPA) && - !(body->valid & OBD_MD_FLOSSCAPA))) - adjust += req_capsule_shrink(pill, &RMF_CAPA1, - 0, adjust, 1); - } + req_capsule_shrink(pill, &RMF_LOGCOOKIES, + acl_size, RCL_SERVER); + + if (req_capsule_has_field(pill, &RMF_CAPA1, RCL_SERVER) && + !(body->valid & OBD_MD_FLMDSCAPA)) + req_capsule_shrink(pill, &RMF_CAPA1, 0, RCL_SERVER); - /* RMF_CAPA2 on server-side is for OBD_MD_FLOSSCAPA only. */ - if ((req_capsule_has_field(pill, &RMF_CAPA2, RCL_SERVER) && - !(body->valid & OBD_MD_FLOSSCAPA))) - adjust += req_capsule_shrink(pill, &RMF_CAPA2, 0, adjust, 0); + if (req_capsule_has_field(pill, &RMF_CAPA2, RCL_SERVER) && + !(body->valid & OBD_MD_FLOSSCAPA)) + req_capsule_shrink(pill, &RMF_CAPA2, 0, RCL_SERVER); /* * Some more field should be shrinked if needed. @@ -544,7 +535,7 @@ int mdt_handle_last_unlink(struct mdt_thread_info *info, struct mdt_object *mo, const struct lu_attr *la = &ma->ma_attr; ENTRY; - repbody = req_capsule_server_get(&info->mti_pill, &RMF_MDT_BODY); + repbody = req_capsule_server_get(info->mti_pill, &RMF_MDT_BODY); LASSERT(repbody != NULL); if (ma->ma_valid & MA_INODE) @@ -670,12 +661,13 @@ static int mdt_setattr_unpack_rec(struct mdt_thread_info *info) struct md_ucred *uc = mdt_ucred(info); struct md_attr *ma = &info->mti_attr; struct lu_attr *la = &ma->ma_attr; - struct req_capsule *pill = &info->mti_pill; + struct req_capsule *pill = info->mti_pill; struct mdt_reint_record *rr = &info->mti_rr; struct mdt_rec_setattr *rec; ENTRY; - rec = req_capsule_client_get(pill, &RMF_REC_SETATTR); + CLASSERT(sizeof(struct mdt_rec_setattr)== sizeof(struct mdt_rec_reint)); + rec = req_capsule_client_get(pill, &RMF_REC_REINT); if (rec == NULL) RETURN(-EFAULT); @@ -707,7 +699,7 @@ static int mdt_setattr_unpack_rec(struct mdt_thread_info *info) static int mdt_epoch_unpack(struct mdt_thread_info *info) { - struct req_capsule *pill = &info->mti_pill; + struct req_capsule *pill = info->mti_pill; ENTRY; if (req_capsule_get_size(pill, &RMF_MDT_EPOCH, RCL_CLIENT)) @@ -718,7 +710,7 @@ static int mdt_epoch_unpack(struct mdt_thread_info *info) } static inline int mdt_dlmreq_unpack(struct mdt_thread_info *info) { - struct req_capsule *pill = &info->mti_pill; + struct req_capsule *pill = info->mti_pill; if (req_capsule_get_size(pill, &RMF_DLM_REQ, RCL_CLIENT)) { info->mti_dlm_req = req_capsule_client_get(pill, &RMF_DLM_REQ); @@ -732,7 +724,7 @@ static inline int mdt_dlmreq_unpack(struct mdt_thread_info *info) { static int mdt_setattr_unpack(struct mdt_thread_info *info) { struct md_attr *ma = &info->mti_attr; - struct req_capsule *pill = &info->mti_pill; + struct req_capsule *pill = info->mti_pill; int rc; ENTRY; @@ -778,12 +770,13 @@ static int mdt_create_unpack(struct mdt_thread_info *info) struct mdt_rec_create *rec; struct lu_attr *attr = &info->mti_attr.ma_attr; struct mdt_reint_record *rr = &info->mti_rr; - struct req_capsule *pill = &info->mti_pill; + struct req_capsule *pill = info->mti_pill; struct md_op_spec *sp = &info->mti_spec; int rc; ENTRY; - rec = req_capsule_client_get(pill, &RMF_REC_CREATE); + CLASSERT(sizeof(struct mdt_rec_create) == sizeof(struct mdt_rec_reint)); + rec = req_capsule_client_get(pill, &RMF_REC_REINT); if (rec == NULL) RETURN(-EFAULT); @@ -816,7 +809,7 @@ static int mdt_create_unpack(struct mdt_thread_info *info) rr->rr_name = req_capsule_client_get(pill, &RMF_NAME); rr->rr_namelen = req_capsule_get_size(pill, &RMF_NAME, RCL_CLIENT) - 1; - LASSERT(rr->rr_namelen > 0); + LASSERT(rr->rr_name && rr->rr_namelen > 0); #ifdef CONFIG_FS_POSIX_ACL if (sp->sp_cr_flags & MDS_CREATE_RMT_ACL) { @@ -827,7 +820,7 @@ static int mdt_create_unpack(struct mdt_thread_info *info) RCL_CLIENT)); sp->u.sp_ea.eadata = req_capsule_client_get(pill, &RMF_EADATA); sp->u.sp_ea.eadatalen = req_capsule_get_size(pill, &RMF_EADATA, - RCL_CLIENT); + RCL_CLIENT); sp->u.sp_ea.fid = rr->rr_fid1; RETURN(0); } @@ -874,11 +867,12 @@ static int mdt_link_unpack(struct mdt_thread_info *info) struct mdt_rec_link *rec; struct lu_attr *attr = &info->mti_attr.ma_attr; struct mdt_reint_record *rr = &info->mti_rr; - struct req_capsule *pill = &info->mti_pill; + struct req_capsule *pill = info->mti_pill; int rc; ENTRY; - rec = req_capsule_client_get(pill, &RMF_REC_LINK); + CLASSERT(sizeof(struct mdt_rec_link) == sizeof(struct mdt_rec_reint)); + rec = req_capsule_client_get(pill, &RMF_REC_REINT); if (rec == NULL) RETURN(-EFAULT); @@ -922,18 +916,19 @@ static int mdt_unlink_unpack(struct mdt_thread_info *info) struct md_attr *ma = &info->mti_attr; struct lu_attr *attr = &info->mti_attr.ma_attr; struct mdt_reint_record *rr = &info->mti_rr; - struct req_capsule *pill = &info->mti_pill; + struct req_capsule *pill = info->mti_pill; int rc; ENTRY; - rec = req_capsule_client_get(pill, &RMF_REC_UNLINK); + CLASSERT(sizeof(struct mdt_rec_unlink) == sizeof(struct mdt_rec_reint)); + rec = req_capsule_client_get(pill, &RMF_REC_REINT); if (rec == NULL) RETURN(-EFAULT); uc->mu_fsuid = rec->ul_fsuid; uc->mu_fsgid = rec->ul_fsgid; uc->mu_cap = rec->ul_cap; - uc->mu_suppgids[0] = rec->ul_suppgid; + uc->mu_suppgids[0] = rec->ul_suppgid1; uc->mu_suppgids[1] = -1; attr->la_uid = rec->ul_fsuid; @@ -972,11 +967,12 @@ static int mdt_rename_unpack(struct mdt_thread_info *info) struct md_attr *ma = &info->mti_attr; struct lu_attr *attr = &info->mti_attr.ma_attr; struct mdt_reint_record *rr = &info->mti_rr; - struct req_capsule *pill = &info->mti_pill; + struct req_capsule *pill = info->mti_pill; int rc; ENTRY; - rec = req_capsule_client_get(pill, &RMF_REC_RENAME); + CLASSERT(sizeof(struct mdt_rec_rename) == sizeof(struct mdt_rec_reint)); + rec = req_capsule_client_get(pill, &RMF_REC_REINT); if (rec == NULL) RETURN(-EFAULT); @@ -1027,13 +1023,14 @@ static int mdt_open_unpack(struct mdt_thread_info *info) struct md_ucred *uc = mdt_ucred(info); struct mdt_rec_create *rec; struct lu_attr *attr = &info->mti_attr.ma_attr; - struct req_capsule *pill = &info->mti_pill; + struct req_capsule *pill = info->mti_pill; struct mdt_reint_record *rr = &info->mti_rr; struct ptlrpc_request *req = mdt_info_req(info); struct md_op_spec *sp = &info->mti_spec; ENTRY; - rec = req_capsule_client_get(pill, &RMF_REC_CREATE); + CLASSERT(sizeof(struct mdt_rec_create) == sizeof(struct mdt_rec_reint)); + rec = req_capsule_client_get(pill, &RMF_REC_REINT); if (rec == NULL) RETURN(-EFAULT); @@ -1096,6 +1093,57 @@ static int mdt_open_unpack(struct mdt_thread_info *info) RETURN(0); } +static int mdt_setxattr_unpack(struct mdt_thread_info *info) +{ + struct mdt_reint_record *rr = &info->mti_rr; + struct md_ucred *uc = mdt_ucred(info); + struct lu_attr *attr = &info->mti_attr.ma_attr; + struct req_capsule *pill = info->mti_pill; + struct mdt_rec_setxattr *rec; + ENTRY; + + + CLASSERT(sizeof(struct mdt_rec_setxattr) == + sizeof(struct mdt_rec_reint)); + + rec = req_capsule_client_get(pill, &RMF_REC_REINT); + if (rec == NULL) + RETURN(-EFAULT); + + uc->mu_fsuid = rec->sx_fsuid; + uc->mu_fsgid = rec->sx_fsgid; + uc->mu_cap = rec->sx_cap; + uc->mu_suppgids[0] = uc->mu_suppgids[1] = -1; + + rr->rr_opcode = rec->sx_opcode; + rr->rr_fid1 = &rec->sx_fid; + attr->la_valid = rec->sx_valid; + attr->la_size = rec->sx_size; + attr->la_flags = rec->sx_flags; + + if (req_capsule_get_size(pill, &RMF_CAPA1, RCL_CLIENT)) + mdt_set_capainfo(info, 0, rr->rr_fid1, + req_capsule_client_get(pill, &RMF_CAPA1)); + else + mdt_set_capainfo(info, 0, rr->rr_fid1, BYPASS_CAPA); + + rr->rr_name = req_capsule_client_get(pill, &RMF_NAME); + if (rr->rr_name == NULL) + RETURN(-EFAULT); + rr->rr_namelen = req_capsule_get_size(pill, &RMF_NAME, RCL_CLIENT) - 1; + LASSERT(rr->rr_namelen > 0); + + rr->rr_eadatalen = req_capsule_get_size(pill, &RMF_EADATA, RCL_CLIENT); + if (rr->rr_eadatalen > 0) { + rr->rr_eadata = req_capsule_client_get(pill, &RMF_EADATA); + if (rr->rr_eadata == NULL) + RETURN(-EFAULT); + } + + RETURN(0); +} + + typedef int (*reint_unpacker)(struct mdt_thread_info *info); static reint_unpacker mdt_reint_unpackers[REINT_MAX] = { @@ -1104,7 +1152,8 @@ static reint_unpacker mdt_reint_unpackers[REINT_MAX] = { [REINT_LINK] = mdt_link_unpack, [REINT_UNLINK] = mdt_unlink_unpack, [REINT_RENAME] = mdt_rename_unpack, - [REINT_OPEN] = mdt_open_unpack + [REINT_OPEN] = mdt_open_unpack, + [REINT_SETXATTR] = mdt_setxattr_unpack }; int mdt_reint_unpack(struct mdt_thread_info *info, __u32 op) diff --git a/lustre/mdt/mdt_open.c b/lustre/mdt/mdt_open.c index ed74be0..3c992d9 100644 --- a/lustre/mdt/mdt_open.c +++ b/lustre/mdt/mdt_open.c @@ -377,7 +377,7 @@ static int mdt_mfd_open(struct mdt_thread_info *info, struct mdt_object *p, int rc = 0, isdir, isreg; ENTRY; - repbody = req_capsule_server_get(&info->mti_pill, &RMF_MDT_BODY); + repbody = req_capsule_server_get(info->mti_pill, &RMF_MDT_BODY); isreg = S_ISREG(la->la_mode); isdir = S_ISDIR(la->la_mode); @@ -387,7 +387,7 @@ static int mdt_mfd_open(struct mdt_thread_info *info, struct mdt_object *p, * above attr get, these size might be zero, so reset it, to * retrieve the MD after create obj. */ - ma->ma_lmm_size = req_capsule_get_size(&info->mti_pill, + ma->ma_lmm_size = req_capsule_get_size(info->mti_pill, &RMF_MDT_MD, RCL_SERVER); /* in replay case, p == NULL */ @@ -500,7 +500,7 @@ static int mdt_finish_open(struct mdt_thread_info *info, LASSERT(ma->ma_valid & MA_INODE); - repbody = req_capsule_server_get(&info->mti_pill, &RMF_MDT_BODY); + repbody = req_capsule_server_get(info->mti_pill, &RMF_MDT_BODY); isreg = S_ISREG(la->la_mode); isdir = S_ISDIR(la->la_mode); @@ -508,7 +508,7 @@ static int mdt_finish_open(struct mdt_thread_info *info, mdt_pack_attr2body(info, repbody, la, mdt_object_fid(o)); if (med->med_rmtclient) { - void *buf = req_capsule_server_get(&info->mti_pill, &RMF_ACL); + void *buf = req_capsule_server_get(info->mti_pill, &RMF_ACL); rc = mdt_pack_remote_perm(info, o, buf); if (rc) { @@ -525,8 +525,8 @@ static int mdt_finish_open(struct mdt_thread_info *info, struct md_object *next = mdt_object_child(o); struct lu_buf *buf = &info->mti_buf; - buf->lb_buf = req_capsule_server_get(&info->mti_pill, &RMF_ACL); - buf->lb_len = req_capsule_get_size(&info->mti_pill, &RMF_ACL, + buf->lb_buf = req_capsule_server_get(info->mti_pill, &RMF_ACL); + buf->lb_len = req_capsule_get_size(info->mti_pill, &RMF_ACL, RCL_SERVER); if (buf->lb_len > 0) { rc = mo_xattr_get(env, next, buf, @@ -553,7 +553,7 @@ static int mdt_finish_open(struct mdt_thread_info *info, if (mdt->mdt_opts.mo_mds_capa) { struct lustre_capa *capa; - capa = req_capsule_server_get(&info->mti_pill, &RMF_CAPA1); + capa = req_capsule_server_get(info->mti_pill, &RMF_CAPA1); LASSERT(capa); capa->lc_opc = CAPA_OPC_MDS_DEFAULT; capa->lc_uid = 0; @@ -566,7 +566,7 @@ static int mdt_finish_open(struct mdt_thread_info *info, S_ISREG(lu_object_attr(&o->mot_obj.mo_lu))) { struct lustre_capa *capa; - capa = req_capsule_server_get(&info->mti_pill, &RMF_CAPA2); + capa = req_capsule_server_get(info->mti_pill, &RMF_CAPA2); LASSERT(capa); capa->lc_opc = CAPA_OPC_OSS_DEFAULT | capa_open_opc(flags); capa->lc_uid = 0; @@ -648,7 +648,7 @@ void mdt_reconstruct_open(struct mdt_thread_info *info, { const struct lu_env *env = info->mti_env; struct mdt_device *mdt = info->mti_mdt; - struct req_capsule *pill = &info->mti_pill; + struct req_capsule *pill = info->mti_pill; struct ptlrpc_request *req = mdt_info_req(info); struct mdt_export_data *med = &req->rq_export->exp_mdt_data; struct mdt_client_data *mcd = med->med_mcd; @@ -679,11 +679,9 @@ void mdt_reconstruct_open(struct mdt_thread_info *info, ldlm_rep->lock_policy_res1, req->rq_status); if (mdt_get_disposition(ldlm_rep, DISP_OPEN_CREATE) && - req->rq_status != 0) { + req->rq_status != 0) /* We did not create successfully, return error to client. */ - mdt_shrink_reply(info); GOTO(out, rc = req->rq_status); - } if (mdt_get_disposition(ldlm_rep, DISP_OPEN_CREATE)) { /* @@ -719,7 +717,6 @@ void mdt_reconstruct_open(struct mdt_thread_info *info, } mdt_object_put(env, parent); mdt_object_put(env, child); - mdt_shrink_reply(info); GOTO(out, rc); } else { regular_open: @@ -763,7 +760,7 @@ static int mdt_open_by_fid(struct mdt_thread_info* info, } else { /* the child object was created on remote server */ struct mdt_body *repbody; - repbody = req_capsule_server_get(&info->mti_pill, &RMF_MDT_BODY); + repbody = req_capsule_server_get(info->mti_pill, &RMF_MDT_BODY); repbody->fid1 = *rr->rr_fid2; repbody->valid |= (OBD_MD_FLID | OBD_MD_MDS); rc = 0; @@ -848,16 +845,16 @@ int mdt_reint_open(struct mdt_thread_info *info, struct mdt_lock_handle *lhc) OBD_FAIL_TIMEOUT_ORSET(OBD_FAIL_MDS_PAUSE_OPEN, OBD_FAIL_ONCE, (obd_timeout + 1) / 4); - repbody = req_capsule_server_get(&info->mti_pill, &RMF_MDT_BODY); + repbody = req_capsule_server_get(info->mti_pill, &RMF_MDT_BODY); - ma->ma_lmm = req_capsule_server_get(&info->mti_pill, &RMF_MDT_MD); - ma->ma_lmm_size = req_capsule_get_size(&info->mti_pill, &RMF_MDT_MD, + ma->ma_lmm = req_capsule_server_get(info->mti_pill, &RMF_MDT_MD); + ma->ma_lmm_size = req_capsule_get_size(info->mti_pill, &RMF_MDT_MD, RCL_SERVER); ma->ma_need = MA_INODE | MA_LOV; ma->ma_valid = 0; - LASSERT(info->mti_pill.rc_fmt == &RQF_LDLM_INTENT_OPEN); - ldlm_rep = req_capsule_server_get(&info->mti_pill, &RMF_DLM_REP); + LASSERT(info->mti_pill->rc_fmt == &RQF_LDLM_INTENT_OPEN); + ldlm_rep = req_capsule_server_get(info->mti_pill, &RMF_DLM_REP); /* TODO: JOIN file */ if (create_flags & MDS_OPEN_JOIN_FILE) { @@ -1059,7 +1056,6 @@ out_child: out_parent: mdt_object_unlock_put(info, parent, lh, result); out: - mdt_shrink_reply(info); if (result) lustre_msg_set_transno(req->rq_repmsg, 0); return result; @@ -1162,26 +1158,26 @@ int mdt_close(struct mdt_thread_info *info) LASSERT(info->mti_epoch); - req_capsule_set_size(&info->mti_pill, &RMF_MDT_MD, RCL_SERVER, + req_capsule_set_size(info->mti_pill, &RMF_MDT_MD, RCL_SERVER, info->mti_mdt->mdt_max_mdsize); - req_capsule_set_size(&info->mti_pill, &RMF_LOGCOOKIES, RCL_SERVER, + req_capsule_set_size(info->mti_pill, &RMF_LOGCOOKIES, RCL_SERVER, info->mti_mdt->mdt_max_cookiesize); - rc = req_capsule_pack(&info->mti_pill); + rc = req_capsule_server_pack(info->mti_pill); if (mdt_check_resent(info, mdt_reconstruct_generic, NULL)) RETURN(lustre_msg_get_status(req->rq_repmsg)); /* Continue to close handle even if we can not pack reply */ if (rc == 0) { - repbody = req_capsule_server_get(&info->mti_pill, + repbody = req_capsule_server_get(info->mti_pill, &RMF_MDT_BODY); - ma->ma_lmm = req_capsule_server_get(&info->mti_pill, + ma->ma_lmm = req_capsule_server_get(info->mti_pill, &RMF_MDT_MD); - ma->ma_lmm_size = req_capsule_get_size(&info->mti_pill, + ma->ma_lmm_size = req_capsule_get_size(info->mti_pill, &RMF_MDT_MD, RCL_SERVER); - ma->ma_cookie = req_capsule_server_get(&info->mti_pill, + ma->ma_cookie = req_capsule_server_get(info->mti_pill, &RMF_LOGCOOKIES); - ma->ma_cookie_size = req_capsule_get_size(&info->mti_pill, + ma->ma_cookie_size = req_capsule_get_size(info->mti_pill, &RMF_LOGCOOKIES, RCL_SERVER); ma->ma_need = MA_INODE | MA_LOV | MA_COOKIE; @@ -1230,11 +1226,11 @@ int mdt_done_writing(struct mdt_thread_info *info) int rc; ENTRY; - rc = req_capsule_pack(&info->mti_pill); + rc = req_capsule_server_pack(info->mti_pill); if (rc) RETURN(err_serious(rc)); - repbody = req_capsule_server_get(&info->mti_pill, + repbody = req_capsule_server_get(info->mti_pill, &RMF_MDT_BODY); repbody->eadatasize = 0; repbody->aclsize = 0; diff --git a/lustre/mdt/mdt_recovery.c b/lustre/mdt/mdt_recovery.c index ed05c2a..ec934aa 100644 --- a/lustre/mdt/mdt_recovery.c +++ b/lustre/mdt/mdt_recovery.c @@ -1049,7 +1049,7 @@ static void mdt_reconstruct_create(struct mdt_thread_info *mti, child = mdt_object_find(mti->mti_env, mdt, mti->mti_rr.rr_fid2); LASSERT(!IS_ERR(child)); - body = req_capsule_server_get(&mti->mti_pill, &RMF_MDT_BODY); + body = req_capsule_server_get(mti->mti_pill, &RMF_MDT_BODY); rc = mo_attr_get(mti->mti_env, mdt_object_child(child), &mti->mti_attr); if (rc == -EREMOTE) { /* object was created on remote server */ @@ -1073,7 +1073,7 @@ static void mdt_reconstruct_setattr(struct mdt_thread_info *mti, if (req->rq_status) return; - body = req_capsule_server_get(&mti->mti_pill, &RMF_MDT_BODY); + body = req_capsule_server_get(mti->mti_pill, &RMF_MDT_BODY); obj = mdt_object_find(mti->mti_env, mdt, mti->mti_rr.rr_fid1); LASSERT(!IS_ERR(obj)); mo_attr_get(mti->mti_env, mdt_object_child(obj), &mti->mti_attr); @@ -1083,7 +1083,7 @@ static void mdt_reconstruct_setattr(struct mdt_thread_info *mti, struct mdt_file_data *mfd; struct mdt_body *repbody; - repbody = req_capsule_server_get(&mti->mti_pill, &RMF_MDT_BODY); + repbody = req_capsule_server_get(mti->mti_pill, &RMF_MDT_BODY); repbody->ioepoch = obj->mot_ioepoch; spin_lock(&med->med_open_lock); list_for_each_entry(mfd, &med->med_open_head, mfd_list) { @@ -1098,11 +1098,11 @@ static void mdt_reconstruct_setattr(struct mdt_thread_info *mti, mdt_object_put(mti->mti_env, obj); } -static void mdt_reconstruct_with_shrink(struct mdt_thread_info *mti, - struct mdt_lock_handle *lhc) +static void mdt_reconstruct_setxattr(struct mdt_thread_info *mti, + struct mdt_lock_handle *lhc) { - mdt_reconstruct_generic(mti, lhc); - mdt_shrink_reply(mti); + /* reply nothing */ + req_capsule_shrink(mti->mti_pill, &RMF_EADATA, 0, RCL_SERVER); } typedef void (*mdt_reconstructor)(struct mdt_thread_info *mti, @@ -1112,9 +1112,10 @@ static mdt_reconstructor reconstructors[REINT_MAX] = { [REINT_SETATTR] = mdt_reconstruct_setattr, [REINT_CREATE] = mdt_reconstruct_create, [REINT_LINK] = mdt_reconstruct_generic, - [REINT_UNLINK] = mdt_reconstruct_with_shrink, - [REINT_RENAME] = mdt_reconstruct_with_shrink, - [REINT_OPEN] = mdt_reconstruct_open + [REINT_UNLINK] = mdt_reconstruct_generic, + [REINT_RENAME] = mdt_reconstruct_generic, + [REINT_OPEN] = mdt_reconstruct_open, + [REINT_SETXATTR] = mdt_reconstruct_setxattr }; void mdt_reconstruct(struct mdt_thread_info *mti, diff --git a/lustre/mdt/mdt_reint.c b/lustre/mdt/mdt_reint.c index 8a0a9f0..fb9f7eb 100644 --- a/lustre/mdt/mdt_reint.c +++ b/lustre/mdt/mdt_reint.c @@ -41,13 +41,13 @@ static inline void mdt_reint_init_ma(struct mdt_thread_info *info, struct md_attr *ma) { - ma->ma_lmm = req_capsule_server_get(&info->mti_pill, &RMF_MDT_MD); - ma->ma_lmm_size = req_capsule_get_size(&info->mti_pill, + ma->ma_lmm = req_capsule_server_get(info->mti_pill, &RMF_MDT_MD); + ma->ma_lmm_size = req_capsule_get_size(info->mti_pill, &RMF_MDT_MD, RCL_SERVER); - ma->ma_cookie = req_capsule_server_get(&info->mti_pill, + ma->ma_cookie = req_capsule_server_get(info->mti_pill, &RMF_LOGCOOKIES); - ma->ma_cookie_size = req_capsule_get_size(&info->mti_pill, + ma->ma_cookie_size = req_capsule_get_size(info->mti_pill, &RMF_LOGCOOKIES, RCL_SERVER); @@ -69,7 +69,7 @@ static int mdt_create_pack_capa(struct mdt_thread_info *info, int rc, if (rc == 0 && info->mti_mdt->mdt_opts.mo_mds_capa) { struct lustre_capa *capa; - capa = req_capsule_server_get(&info->mti_pill, &RMF_CAPA1); + capa = req_capsule_server_get(info->mti_pill, &RMF_CAPA1); LASSERT(capa); capa->lc_opc = CAPA_OPC_MDS_DEFAULT; rc = mo_capa_get(info->mti_env, mdt_object_child(object), capa, @@ -77,8 +77,6 @@ static int mdt_create_pack_capa(struct mdt_thread_info *info, int rc, if (rc == 0) repbody->valid |= OBD_MD_FLMDSCAPA; } - if (!(repbody->valid & OBD_MD_FLMDSCAPA)) - lustre_shrink_reply(mdt_info_req(info), REPLY_REC_OFF+1, 0, 1); RETURN(rc); } @@ -99,7 +97,7 @@ static int mdt_md_create(struct mdt_thread_info *info) DEBUG_REQ(D_INODE, mdt_info_req(info), "Create (%s->"DFID") in "DFID, rr->rr_name, PFID(rr->rr_fid2), PFID(rr->rr_fid1)); - repbody = req_capsule_server_get(&info->mti_pill, &RMF_MDT_BODY); + repbody = req_capsule_server_get(info->mti_pill, &RMF_MDT_BODY); lh = &info->mti_lh[MDT_LH_PARENT]; mdt_lock_pdo_init(lh, LCK_PW, rr->rr_name, rr->rr_namelen); @@ -116,7 +114,7 @@ static int mdt_md_create(struct mdt_thread_info *info) ma->ma_need = MA_INODE; ma->ma_valid = 0; /* capa for cross-ref will be stored here */ - ma->ma_capa = req_capsule_server_get(&info->mti_pill, + ma->ma_capa = req_capsule_server_get(info->mti_pill, &RMF_CAPA1); LASSERT(ma->ma_capa); @@ -166,7 +164,7 @@ static int mdt_md_mkobj(struct mdt_thread_info *info) DEBUG_REQ(D_INODE, mdt_info_req(info), "Partial create "DFID"", PFID(info->mti_rr.rr_fid2)); - repbody = req_capsule_server_get(&info->mti_pill, &RMF_MDT_BODY); + repbody = req_capsule_server_get(info->mti_pill, &RMF_MDT_BODY); o = mdt_object_find(info->mti_env, mdt, info->mti_rr.rr_fid2); if (!IS_ERR(o)) { @@ -297,7 +295,7 @@ static int mdt_reint_setattr(struct mdt_thread_info *info, if (info->mti_dlm_req) ldlm_request_cancel(req, info->mti_dlm_req, 0); - repbody = req_capsule_server_get(&info->mti_pill, &RMF_MDT_BODY); + repbody = req_capsule_server_get(info->mti_pill, &RMF_MDT_BODY); mo = mdt_object_find(info->mti_env, info->mti_mdt, rr->rr_fid1); if (IS_ERR(mo)) GOTO(out, rc = PTR_ERR(mo)); @@ -377,7 +375,7 @@ static int mdt_reint_setattr(struct mdt_thread_info *info, (ma->ma_attr.la_valid & LA_SIZE)) { struct lustre_capa *capa; - capa = req_capsule_server_get(&info->mti_pill, &RMF_CAPA1); + capa = req_capsule_server_get(info->mti_pill, &RMF_CAPA2); LASSERT(capa); capa->lc_opc = CAPA_OPC_OSS_DEFAULT | CAPA_OPC_OSS_TRUNC; rc = mo_capa_get(info->mti_env, mdt_object_child(mo), capa, 0); @@ -390,6 +388,7 @@ static int mdt_reint_setattr(struct mdt_thread_info *info, out_put: mdt_object_put(info->mti_env, mo); out: + mdt_shrink_reply(info); return rc; } @@ -400,7 +399,7 @@ static int mdt_reint_create(struct mdt_thread_info *info, ENTRY; if (OBD_FAIL_CHECK(OBD_FAIL_MDS_REINT_CREATE)) - GOTO(out, rc = err_serious(-ESTALE)); + RETURN(err_serious(-ESTALE)); if (info->mti_dlm_req) ldlm_request_cancel(mdt_info_req(info), info->mti_dlm_req, 0); @@ -427,9 +426,7 @@ static int mdt_reint_create(struct mdt_thread_info *info, default: rc = err_serious(-EOPNOTSUPP); } - EXIT; -out: - return rc; + RETURN(rc); } static int mdt_reint_unlink(struct mdt_thread_info *info, @@ -454,7 +451,7 @@ static int mdt_reint_unlink(struct mdt_thread_info *info, ldlm_request_cancel(req, info->mti_dlm_req, 0); if (OBD_FAIL_CHECK(OBD_FAIL_MDS_REINT_UNLINK)) - GOTO(out, rc = err_serious(-ENOENT)); + RETURN(err_serious(-ENOENT)); /* step 1: lock the parent */ parent_lh = &info->mti_lh[MDT_LH_PARENT]; @@ -532,7 +529,6 @@ static int mdt_reint_unlink(struct mdt_thread_info *info, out_unlock_parent: mdt_object_unlock_put(info, mp, parent_lh, rc); out: - mdt_shrink_reply(info); return rc; } @@ -554,7 +550,7 @@ static int mdt_reint_link(struct mdt_thread_info *info, PFID(rr->rr_fid1), PFID(rr->rr_fid2), rr->rr_name); if (OBD_FAIL_CHECK(OBD_FAIL_MDS_REINT_LINK)) - GOTO(out, rc = err_serious(-ENOENT)); + RETURN(err_serious(-ENOENT)); if (info->mti_dlm_req) ldlm_request_cancel(req, info->mti_dlm_req, 0); @@ -566,18 +562,18 @@ static int mdt_reint_link(struct mdt_thread_info *info, ms = mdt_object_find_lock(info, rr->rr_fid1, lhs, MDS_INODELOCK_UPDATE); if (IS_ERR(ms)) - GOTO(out, rc = PTR_ERR(ms)); + RETURN(PTR_ERR(ms)); mdt_set_capainfo(info, 0, rr->rr_fid1, BYPASS_CAPA); rc = mo_ref_add(info->mti_env, mdt_object_child(ms), ma); mdt_object_unlock_put(info, ms, lhs, rc); - GOTO(out, rc); + RETURN(rc); } /* Invalid case so return error immediately instead of * processing it */ if (lu_fid_eq(rr->rr_fid1, rr->rr_fid2)) - GOTO(out, rc = -EPERM); + RETURN(-EPERM); /* step 1: find & lock the target parent dir */ lhp = &info->mti_lh[MDT_LH_PARENT]; @@ -586,7 +582,7 @@ static int mdt_reint_link(struct mdt_thread_info *info, mp = mdt_object_find_lock(info, rr->rr_fid2, lhp, MDS_INODELOCK_UPDATE); if (IS_ERR(mp)) - GOTO(out, rc = PTR_ERR(mp)); + RETURN(PTR_ERR(mp)); /* step 2: find & lock the source */ lhs = &info->mti_lh[MDT_LH_CHILD]; @@ -615,7 +611,6 @@ static int mdt_reint_link(struct mdt_thread_info *info, mdt_object_unlock_put(info, ms, lhs, rc); out_unlock_parent: mdt_object_unlock_put(info, mp, lhp, rc); -out: return rc; } @@ -644,7 +639,7 @@ static int mdt_reint_rename_tgt(struct mdt_thread_info *info) mtgtdir = mdt_object_find_lock(info, rr->rr_fid1, lh_tgtdir, MDS_INODELOCK_UPDATE); if (IS_ERR(mtgtdir)) - GOTO(out, rc = PTR_ERR(mtgtdir)); + RETURN(PTR_ERR(mtgtdir)); /* step 2: find & lock the target object if exists. */ mdt_set_capainfo(info, 0, rr->rr_fid1, BYPASS_CAPA); @@ -691,8 +686,6 @@ out_unlock_tgt: mdt_object_unlock_put(info, mtgt, lh_tgt, rc); out_unlock_tgtdir: mdt_object_unlock_put(info, mtgtdir, lh_tgtdir, rc); -out: - mdt_shrink_reply(info); return rc; } @@ -831,7 +824,7 @@ static int mdt_reint_rename(struct mdt_thread_info *info, rc = mdt_rename_lock(info, &rename_lh); if (rc) { CERROR("Can't lock FS for rename, rc %d\n", rc); - GOTO(out, rc); + RETURN(rc); } lh_newp = &info->mti_lh[MDT_LH_NEW]; @@ -960,8 +953,6 @@ out_unlock_source: mdt_object_unlock_put(info, msrcdir, lh_srcdirp, rc); out_rename_lock: mdt_rename_unlock(&rename_lh); -out: - mdt_shrink_reply(info); return rc; } @@ -970,11 +961,12 @@ typedef int (*mdt_reinter)(struct mdt_thread_info *info, static mdt_reinter reinters[REINT_MAX] = { [REINT_SETATTR] = mdt_reint_setattr, - [REINT_CREATE] = mdt_reint_create, - [REINT_LINK] = mdt_reint_link, - [REINT_UNLINK] = mdt_reint_unlink, - [REINT_RENAME] = mdt_reint_rename, - [REINT_OPEN] = mdt_reint_open + [REINT_CREATE] = mdt_reint_create, + [REINT_LINK] = mdt_reint_link, + [REINT_UNLINK] = mdt_reint_unlink, + [REINT_RENAME] = mdt_reint_rename, + [REINT_OPEN] = mdt_reint_open, + [REINT_SETXATTR] = mdt_reint_setxattr }; int mdt_reint_rec(struct mdt_thread_info *info, diff --git a/lustre/mdt/mdt_xattr.c b/lustre/mdt/mdt_xattr.c index b9682a6..2aaaeaf 100644 --- a/lustre/mdt/mdt_xattr.c +++ b/lustre/mdt/mdt_xattr.c @@ -47,7 +47,7 @@ /* return EADATA length to the caller. negative value means error */ static int mdt_getxattr_pack_reply(struct mdt_thread_info * info) { - struct req_capsule *pill = &info->mti_pill ; + struct req_capsule *pill = info->mti_pill ; struct ptlrpc_request *req = mdt_info_req(info); char *xattr_name; __u64 valid = info->mti_body->valid; @@ -76,7 +76,7 @@ static int mdt_getxattr_pack_reply(struct mdt_thread_info * info) mdt_object_child(info->mti_object), &LU_BUF_NULL); } else { - CERROR("Valid bits: "LPX64"\n", info->mti_body->valid); + CDEBUG(D_INFO, "Valid bits: "LPX64"\n", info->mti_body->valid); RETURN(-EINVAL); } @@ -84,7 +84,7 @@ static int mdt_getxattr_pack_reply(struct mdt_thread_info * info) if (size == -ENODATA) size = 0; else if (size != -EOPNOTSUPP) { - CERROR("Error geting EA size: %d\n", size); + CDEBUG(D_INFO, "Error geting EA size: %d\n", size); RETURN(size); } } @@ -96,7 +96,7 @@ static int mdt_getxattr_pack_reply(struct mdt_thread_info * info) req_capsule_set_size(pill, &RMF_EADATA, RCL_SERVER, min_t(int, size, info->mti_body->eadatasize)); - rc = req_capsule_pack(pill); + rc = req_capsule_server_pack(pill); if (rc) { LASSERT(rc < 0); RETURN(rc); @@ -122,7 +122,7 @@ int mdt_getxattr(struct mdt_thread_info *info) CDEBUG(D_INODE, "getxattr "DFID"\n", PFID(&info->mti_body->fid1)); - reqbody = req_capsule_client_get(&info->mti_pill, &RMF_MDT_BODY); + reqbody = req_capsule_client_get(info->mti_pill, &RMF_MDT_BODY); if (reqbody == NULL) RETURN(err_serious(-EFAULT)); @@ -151,7 +151,7 @@ int mdt_getxattr(struct mdt_thread_info *info) if (easize < 0) GOTO(out, rc = err_serious(easize)); - repbody = req_capsule_server_get(&info->mti_pill, &RMF_MDT_BODY); + repbody = req_capsule_server_get(info->mti_pill, &RMF_MDT_BODY); LASSERT(repbody != NULL); /* No need further getxattr. */ @@ -159,12 +159,12 @@ int mdt_getxattr(struct mdt_thread_info *info) GOTO(out, rc = easize); buf = &info->mti_buf; - buf->lb_buf = req_capsule_server_get(&info->mti_pill, &RMF_EADATA); + buf->lb_buf = req_capsule_server_get(info->mti_pill, &RMF_EADATA); buf->lb_len = easize; if (info->mti_body->valid & OBD_MD_FLXATTR) { int flags = CFS_IC_NOTHING; - char *xattr_name = req_capsule_client_get(&info->mti_pill, + char *xattr_name = req_capsule_client_get(info->mti_pill, &RMF_NAME); CDEBUG(D_INODE, "getxattr %s\n", xattr_name); @@ -196,7 +196,7 @@ int mdt_getxattr(struct mdt_thread_info *info) rc = mo_xattr_list(info->mti_env, next, buf); if (rc < 0) - CERROR("listxattr failed: %d\n", rc); + CDEBUG(D_INFO, "listxattr failed: %d\n", rc); } else LBUG(); @@ -210,7 +210,7 @@ out: return rc; } -static int mdt_rmtlsetfacl(struct mdt_thread_info *info, char *xattr_name, +static int mdt_rmtlsetfacl(struct mdt_thread_info *info, const char *xattr_name, ext_acl_xattr_header *header, posix_acl_xattr_header **out) { @@ -242,7 +242,7 @@ static int mdt_rmtlsetfacl(struct mdt_thread_info *info, char *xattr_name, if (rc < 0) { CERROR("getxattr failed: %d\n", rc); GOTO(_out, rc); - } + } } else buf->lb_buf = NULL; @@ -253,45 +253,46 @@ static int mdt_rmtlsetfacl(struct mdt_thread_info *info, char *xattr_name, _out: if (rc <= 0 && buf->lb_buf != NULL) OBD_FREE(buf->lb_buf, buf->lb_len); - return rc; } -int mdt_setxattr(struct mdt_thread_info *info) +int mdt_reint_setxattr(struct mdt_thread_info *info, + struct mdt_lock_handle *unused) { struct ptlrpc_request *req = mdt_info_req(info); struct mdt_export_data *med = mdt_req2med(req); struct md_ucred *uc = mdt_ucred(info); - struct mdt_body *reqbody; const char user_string[] = "user."; const char trust_string[] = "trusted."; struct mdt_lock_handle *lh; - struct req_capsule *pill = &info->mti_pill; - struct mdt_object *obj = info->mti_object; - struct mdt_body *body = (struct mdt_body *)info->mti_body; + struct req_capsule *pill = info->mti_pill; const struct lu_env *env = info->mti_env; - struct md_object *child = mdt_object_child(obj); struct lu_buf *buf = &info->mti_buf; - __u64 valid = body->valid; - char *xattr_name; + struct mdt_reint_record *rr = &info->mti_rr; + struct lu_attr *attr = &info->mti_attr.ma_attr; + struct mdt_object *obj; + struct md_object *child; + __u64 valid = attr->la_valid; + const char *xattr_name; int xattr_len = 0; __u64 lockpart; int rc; posix_acl_xattr_header *new_xattr = NULL; ENTRY; - CDEBUG(D_INODE, "setxattr "DFID"\n", PFID(&body->fid1)); + CDEBUG(D_INODE, "setxattr for "DFID"\n", PFID(rr->rr_fid1)); if (OBD_FAIL_CHECK(OBD_FAIL_MDS_SETXATTR)) RETURN(err_serious(-ENOMEM)); - reqbody = req_capsule_client_get(pill, &RMF_MDT_BODY); - if (reqbody == NULL) - RETURN(err_serious(-EFAULT)); + xattr_name = rr->rr_name; - rc = mdt_init_ucred(info, reqbody); - if (rc) - RETURN(err_serious(rc)); + CDEBUG(D_INODE, "%s xattr %s\n", + valid & OBD_MD_FLXATTR ? "set" : "remove", xattr_name); + + rc = mdt_init_ucred_reint(info); + if (rc != 0) + RETURN(rc); if (valid & OBD_MD_FLRMTRSETFACL) { __u32 perm = mdt_identity_get_perm(uc->mu_identity, @@ -303,18 +304,11 @@ int mdt_setxattr(struct mdt_thread_info *info) GOTO(out, rc = err_serious(-EPERM)); } - rc = req_capsule_pack(pill); - if (rc < 0) - GOTO(out, rc = err_serious(rc)); - /* various sanity check for xattr name */ xattr_name = req_capsule_client_get(pill, &RMF_NAME); if (!xattr_name) GOTO(out, rc = err_serious(-EFAULT)); - CDEBUG(D_INODE, "%s xattr %s\n", - body->valid & OBD_MD_FLXATTR ? "set" : "remove", xattr_name); - if (strncmp(xattr_name, trust_string, sizeof(trust_string) - 1) == 0) { if (strcmp(xattr_name + 8, XATTR_NAME_LOV) == 0) GOTO(out, rc = -EACCES); @@ -331,20 +325,23 @@ int mdt_setxattr(struct mdt_thread_info *info) lh = &info->mti_lh[MDT_LH_PARENT]; mdt_lock_reg_init(lh, LCK_PW); - rc = mdt_object_lock(info, obj, lh, lockpart, MDT_LOCAL_LOCK); - if (rc != 0) - GOTO(out, rc); + obj = mdt_object_find_lock(info, rr->rr_fid1, lh, lockpart); + if (IS_ERR(obj)) + GOTO(out, rc = PTR_ERR(obj)); + child = mdt_object_child(obj); if ((valid & OBD_MD_FLXATTR) == OBD_MD_FLXATTR) { char * xattr; + if (!req_capsule_field_present(pill, &RMF_EADATA, RCL_CLIENT)) { - CERROR("no xattr data supplied\n"); + CDEBUG(D_INFO, "no xattr data supplied\n"); GOTO(out_unlock, rc = -EFAULT); } xattr_len = req_capsule_get_size(pill, &RMF_EADATA, RCL_CLIENT); if (xattr_len) { int flags = 0; + xattr = req_capsule_client_get(pill, &RMF_EADATA); if (valid & OBD_MD_FLRMTLSETFACL) { @@ -358,10 +355,10 @@ int mdt_setxattr(struct mdt_thread_info *info) xattr = (char *)new_xattr; } - if (body->flags & XATTR_REPLACE) + if (attr->la_flags & XATTR_REPLACE) flags |= LU_XATTR_REPLACE; - if (body->flags & XATTR_CREATE) + if (attr->la_flags & XATTR_CREATE) flags |= LU_XATTR_CREATE; mdt_fail_write(env, info->mti_mdt->mdt_bottom, @@ -374,14 +371,14 @@ int mdt_setxattr(struct mdt_thread_info *info) } else if ((valid & OBD_MD_FLXATTRRM) == OBD_MD_FLXATTRRM) { rc = mo_xattr_del(env, child, xattr_name); } else { - CERROR("valid bits: "LPX64"\n", body->valid); + CDEBUG(D_INFO, "valid bits: "LPX64"\n", valid); rc = -EINVAL; } EXIT; out_unlock: + mdt_object_unlock_put(info, obj, lh, rc); if (unlikely(new_xattr != NULL)) lustre_posix_acl_xattr_free(new_xattr, xattr_len); - mdt_object_unlock(info, obj, lh, rc); out: mdt_exit_ucred(info); return rc; diff --git a/lustre/mgc/mgc_request.c b/lustre/mgc/mgc_request.c index 65c8610..e6a8056 100644 --- a/lustre/mgc/mgc_request.c +++ b/lustre/mgc/mgc_request.c @@ -733,32 +733,28 @@ out: static int mgc_target_register(struct obd_export *exp, struct mgs_target_info *mti) { - struct ptlrpc_request *req; + struct ptlrpc_request *req; struct mgs_target_info *req_mti, *rep_mti; - int size[] = { sizeof(struct ptlrpc_body), sizeof(*req_mti) }; - int rep_size[] = { sizeof(struct ptlrpc_body), sizeof(*mti) }; - int rc; + int rc; ENTRY; - req = ptlrpc_prep_req(class_exp2cliimp(exp), LUSTRE_MGS_VERSION, - MGS_TARGET_REG, 2, size, NULL); - if (!req) + req = ptlrpc_request_alloc_pack(class_exp2cliimp(exp), + &RQF_MGS_TARGET_REG, LUSTRE_MGS_VERSION, + MGS_TARGET_REG); + if (req == NULL) RETURN(-ENOMEM); - req_mti = lustre_msg_buf(req->rq_reqmsg, REQ_REC_OFF, sizeof(*req_mti)); - if (!req_mti) - RETURN(-ENOMEM); + req_mti = req_capsule_client_get(&req->rq_pill, &RMF_MGS_TARGET_INFO); memcpy(req_mti, mti, sizeof(*req_mti)); - ptlrpc_req_set_repsize(req, 2, rep_size); + ptlrpc_request_set_replen(req); CDEBUG(D_MGC, "register %s\n", mti->mti_svname); rc = ptlrpc_queue_wait(req); if (!rc) { - rep_mti = lustre_swab_repbuf(req, REPLY_REC_OFF, - sizeof(*rep_mti), - lustre_swab_mgs_target_info); + rep_mti = req_capsule_server_get(&req->rq_pill, + &RMF_MGS_TARGET_INFO); memcpy(mti, rep_mti, sizeof(*rep_mti)); CDEBUG(D_MGC, "register %s got index = %d\n", mti->mti_svname, mti->mti_stripe_index); diff --git a/lustre/mgs/mgs_handler.c b/lustre/mgs/mgs_handler.c index 1efe1ab..c05800b 100644 --- a/lustre/mgs/mgs_handler.c +++ b/lustre/mgs/mgs_handler.c @@ -73,6 +73,11 @@ static int mgs_connect(const struct lu_env *env, data->ocd_version = LUSTRE_VERSION_CODE; } + if ((exp->exp_connect_flags & OBD_CONNECT_FID) == 0) { + CWARN("MGS requires FID support, but client not\n"); + rc = -EBADE; + } + if (rc) { class_disconnect(exp); } else { @@ -353,13 +358,10 @@ static int mgs_handle_target_reg(struct ptlrpc_request *req) struct obd_device *obd = req->rq_export->exp_obd; struct lustre_handle lockh; struct mgs_target_info *mti, *rep_mti; - int rep_size[] = { sizeof(struct ptlrpc_body), sizeof(*mti) }; int rc = 0, lockrc; ENTRY; - mti = lustre_swab_reqbuf(req, REQ_REC_OFF, sizeof(*mti), - lustre_swab_mgs_target_info); - + mti = req_capsule_client_get(&req->rq_pill, &RMF_MGS_TARGET_INFO); if (!(mti->mti_flags & (LDD_F_WRITECONF | LDD_F_UPGRADE14 | LDD_F_UPDATE))) { /* We're just here as a startup ping. */ @@ -449,11 +451,13 @@ out: out_nolock: CDEBUG(D_MGS, "replying with %s, index=%d, rc=%d\n", mti->mti_svname, mti->mti_stripe_index, rc); - lustre_pack_reply(req, 2, rep_size, NULL); + rc = req_capsule_server_pack(&req->rq_pill); + if (rc) + RETURN(rc); + /* send back the whole mti in the reply */ - rep_mti = lustre_msg_buf(req->rq_repmsg, REPLY_REC_OFF, - sizeof(*rep_mti)); - memcpy(rep_mti, mti, sizeof(*rep_mti)); + rep_mti = req_capsule_server_get(&req->rq_pill, &RMF_MGS_TARGET_INFO); + *rep_mti = *mti; /* Flush logs to disk */ fsfilt_sync(obd, obd->u.mgs.mgs_sb); @@ -465,14 +469,14 @@ static int mgs_set_info_rpc(struct ptlrpc_request *req) struct obd_device *obd = req->rq_export->exp_obd; struct mgs_send_param *msp, *rep_msp; struct lustre_handle lockh; - int rep_size[] = { sizeof(struct ptlrpc_body), sizeof(*msp) }; int lockrc, rc; struct lustre_cfg_bufs bufs; struct lustre_cfg *lcfg; char fsname[MTI_NAME_MAXLEN]; ENTRY; - msp = lustre_swab_reqbuf(req, REQ_REC_OFF, sizeof(*msp), NULL); + msp = req_capsule_client_get(&req->rq_pill, &RMF_MGS_SEND_PARAM); + LASSERT(msp); /* Construct lustre_cfg structure to pass to function mgs_setparam */ lustre_cfg_bufs_reset(&bufs, NULL); @@ -500,20 +504,22 @@ static int mgs_set_info_rpc(struct ptlrpc_request *req) } lustre_cfg_free(lcfg); - lustre_pack_reply(req, 2, rep_size, NULL); - rep_msp = lustre_msg_buf(req->rq_repmsg, REPLY_REC_OFF, - sizeof(*rep_msp)); - memcpy(rep_msp, msp, sizeof(*rep_msp)); - + rc = req_capsule_server_pack(&req->rq_pill); + if (rc == 0) { + rep_msp = req_capsule_server_get(&req->rq_pill, &RMF_MGS_SEND_PARAM); + rep_msp = msp; + } RETURN(rc); } +/* TODO: handle requests in a similar way as MDT: see mdt_handle_common() */ int mgs_handle(struct ptlrpc_request *req) { int fail = OBD_FAIL_MGS_ALL_REPLY_NET; int opc, rc = 0; ENTRY; + req_capsule_init(&req->rq_pill, req, RCL_SERVER); OBD_FAIL_TIMEOUT(OBD_FAIL_MGS_SLOW_REQUEST_NET, 2); LASSERT(current->journal_info == NULL); @@ -530,6 +536,8 @@ int mgs_handle(struct ptlrpc_request *req) switch (opc) { case MGS_CONNECT: DEBUG_REQ(D_MGS, req, "connect"); + /* MGS and MDS have same request format for connect */ + req_capsule_set(&req->rq_pill, &RQF_MDS_CONNECT); rc = target_handle_connect(req); if (!rc && (lustre_msg_get_conn_cnt(req->rq_reqmsg) > 1)) /* Make clients trying to reconnect after a MGS restart @@ -539,11 +547,14 @@ int mgs_handle(struct ptlrpc_request *req) break; case MGS_DISCONNECT: DEBUG_REQ(D_MGS, req, "disconnect"); + /* MGS and MDS have same request format for disconnect */ + req_capsule_set(&req->rq_pill, &RQF_MDS_DISCONNECT); rc = target_handle_disconnect(req); req->rq_status = rc; /* superfluous? */ break; case MGS_TARGET_REG: DEBUG_REQ(D_MGS, req, "target add"); + req_capsule_set(&req->rq_pill, &RQF_MGS_TARGET_REG); rc = mgs_handle_target_reg(req); break; case MGS_TARGET_DEL: @@ -551,11 +562,14 @@ int mgs_handle(struct ptlrpc_request *req) //rc = mgs_handle_target_del(req); break; case MGS_SET_INFO: + DEBUG_REQ(D_MGS, req, "set_info"); + req_capsule_set(&req->rq_pill, &RQF_MGS_SET_INFO); rc = mgs_set_info_rpc(req); break; case LDLM_ENQUEUE: DEBUG_REQ(D_MGS, req, "enqueue"); + req_capsule_set(&req->rq_pill, &RQF_LDLM_ENQUEUE); rc = ldlm_handle_enqueue(req, ldlm_server_completion_ast, ldlm_server_blocking_ast, NULL); break; @@ -568,6 +582,7 @@ int mgs_handle(struct ptlrpc_request *req) case OBD_PING: DEBUG_REQ(D_INFO, req, "ping"); + req_capsule_set(&req->rq_pill, &RQF_OBD_PING); rc = target_handle_ping(req); break; case OBD_LOG_CANCEL: @@ -577,14 +592,19 @@ int mgs_handle(struct ptlrpc_request *req) case LLOG_ORIGIN_HANDLE_CREATE: DEBUG_REQ(D_MGS, req, "llog_init"); + req_capsule_set(&req->rq_pill, &RQF_LLOG_ORIGIN_HANDLE_CREATE); rc = llog_origin_handle_create(req); break; case LLOG_ORIGIN_HANDLE_NEXT_BLOCK: DEBUG_REQ(D_MGS, req, "llog next block"); + req_capsule_set(&req->rq_pill, + &RQF_LLOG_ORIGIN_HANDLE_NEXT_BLOCK); rc = llog_origin_handle_next_block(req); break; case LLOG_ORIGIN_HANDLE_READ_HEADER: DEBUG_REQ(D_MGS, req, "llog read header"); + req_capsule_set(&req->rq_pill, + &RQF_LLOG_ORIGIN_HANDLE_READ_HEADER); rc = llog_origin_handle_read_header(req); break; case LLOG_ORIGIN_HANDLE_CLOSE: @@ -593,6 +613,7 @@ int mgs_handle(struct ptlrpc_request *req) break; case LLOG_CATINFO: DEBUG_REQ(D_MGS, req, "llog catinfo"); + req_capsule_set(&req->rq_pill, &RQF_LLOG_CATINFO); rc = llog_catinfo(req); break; default: diff --git a/lustre/obdclass/obd_mount.c b/lustre/obdclass/obd_mount.c index 9af2524..572c4f4 100644 --- a/lustre/obdclass/obd_mount.c +++ b/lustre/obdclass/obd_mount.c @@ -723,6 +723,10 @@ static int lustre_start_mgc(struct super_block *sb) /* nonfatal */ CERROR("can't set %s %d\n", KEY_INIT_RECOV_BACKUP, rc); /* We connect to the MGS at setup, and don't disconnect until cleanup */ + + ocd.ocd_connect_flags = OBD_CONNECT_VERSION | OBD_CONNECT_FID; + ocd.ocd_version = LUSTRE_VERSION_CODE; + rc = obd_connect(NULL, &mgc_conn, obd, &(obd->obd_uuid), &ocd); if (rc) { CERROR("connect failed %d\n", rc); diff --git a/lustre/obdfilter/filter.c b/lustre/obdfilter/filter.c index 457447a..fdebc42 100644 --- a/lustre/obdfilter/filter.c +++ b/lustre/obdfilter/filter.c @@ -2377,6 +2377,14 @@ static int filter_connect_internal(struct obd_export *exp, exp->exp_connect_flags = data->ocd_connect_flags; data->ocd_version = LUSTRE_VERSION_CODE; + if ((exp->exp_connect_flags & OBD_CONNECT_FID) == 0) { + CWARN("%s: OST requires FID support (flag="LPX64 + "), but client not\n", + exp->exp_obd->obd_name, + exp->exp_connect_flags); + RETURN(-EBADF); + } + if (exp->exp_connect_flags & OBD_CONNECT_GRANT) { struct filter_export_data *fed = &exp->exp_filter_data; obd_size left, want; diff --git a/lustre/obdfilter/filter_lvb.c b/lustre/obdfilter/filter_lvb.c index a24175d..06e0ee2 100644 --- a/lustre/obdfilter/filter_lvb.c +++ b/lustre/obdfilter/filter_lvb.c @@ -86,8 +86,8 @@ static int filter_lvbo_init(struct ldlm_resource *res) inode_init_lvb(dentry->d_inode, lvb); - CDEBUG(D_DLMTRACE, "res: "LPU64" initial lvb size: "LPU64", " - "mtime: "LPU64", blocks: "LPU64"\n", + CDEBUG(D_DLMTRACE, "res: "LPX64" initial lvb size: "LPX64", " + "mtime: "LPX64", blocks: "LPX64"\n", res->lr_name.name[0], lvb->lvb_size, lvb->lvb_mtime, lvb->lvb_blocks); diff --git a/lustre/osc/osc_request.c b/lustre/osc/osc_request.c index 1ee17bd..1f1c42b 100644 --- a/lustre/osc/osc_request.c +++ b/lustre/osc/osc_request.c @@ -153,7 +153,7 @@ static int osc_unpackmd(struct obd_export *exp, struct lov_stripe_md **lsmp, RETURN(lsm_size); } -static inline void osc_pack_capa(struct ptlrpc_request *req, int offset, +static inline void osc_pack_capa(struct ptlrpc_request *req, struct ost_body *body, void *capa) { struct obd_capa *oc = (struct obd_capa *)capa; @@ -162,21 +162,34 @@ static inline void osc_pack_capa(struct ptlrpc_request *req, int offset, if (!capa) return; - c = lustre_msg_buf(req->rq_reqmsg, offset, sizeof(*c)); + c = req_capsule_client_get(&req->rq_pill, &RMF_CAPA1); LASSERT(c); capa_cpy(c, oc); body->oa.o_valid |= OBD_MD_FLOSSCAPA; DEBUG_CAPA(D_SEC, c, "pack"); } -static inline void osc_pack_req_body(struct ptlrpc_request *req, int offset, +static inline void osc_pack_req_body(struct ptlrpc_request *req, struct obd_info *oinfo) { struct ost_body *body; - body = lustre_msg_buf(req->rq_reqmsg, offset, sizeof(*body)); + body = req_capsule_client_get(&req->rq_pill, &RMF_OST_BODY); + LASSERT(body); + body->oa = *oinfo->oi_oa; - osc_pack_capa(req, offset + 1, body, oinfo->oi_capa); + osc_pack_capa(req, body, oinfo->oi_capa); +} + +static inline void osc_set_capa_size(struct ptlrpc_request *req, + const struct req_msg_field *field, + struct obd_capa *oc) +{ + if (oc == NULL) + req_capsule_set_size(&req->rq_pill, field, RCL_CLIENT, 0); + else + /* it is already calculated as sizeof struct obd_capa */ + ; } static int osc_getattr_interpret(struct ptlrpc_request *req, @@ -198,7 +211,7 @@ static int osc_getattr_interpret(struct ptlrpc_request *req, aa->aa_oi->oi_oa->o_blksize = PTLRPC_MAX_BRW_SIZE; aa->aa_oi->oi_oa->o_valid |= OBD_MD_FLBLKSZ; } else { - CERROR("can't unpack ost_body\n"); + CDEBUG(D_INFO, "can't unpack ost_body\n"); rc = -EPROTO; aa->aa_oi->oi_oa->o_valid = 0; } @@ -211,20 +224,24 @@ static int osc_getattr_async(struct obd_export *exp, struct obd_info *oinfo, struct ptlrpc_request_set *set) { struct ptlrpc_request *req; - struct ost_body *body; - int size[3] = { sizeof(struct ptlrpc_body), sizeof(*body) }; struct osc_async_args *aa; + int rc; ENTRY; - size[REQ_REC_OFF + 1] = oinfo->oi_capa ? sizeof(struct lustre_capa) : 0; - req = ptlrpc_prep_req(class_exp2cliimp(exp), LUSTRE_OST_VERSION, - OST_GETATTR, 3, size,NULL); - if (!req) + req = ptlrpc_request_alloc(class_exp2cliimp(exp), &RQF_OST_GETATTR); + if (req == NULL) RETURN(-ENOMEM); - osc_pack_req_body(req, REQ_REC_OFF, oinfo); + osc_set_capa_size(req, &RMF_CAPA1, oinfo->oi_capa); + rc = ptlrpc_request_pack(req, LUSTRE_OST_VERSION, OST_GETATTR); + if (rc) { + ptlrpc_request_free(req); + RETURN(rc); + } - ptlrpc_req_set_repsize(req, 2, size); + osc_pack_req_body(req, oinfo); + + ptlrpc_request_set_replen(req); req->rq_interpret_reply = osc_getattr_interpret; CLASSERT(sizeof(*aa) <= sizeof(req->rq_async_args)); @@ -232,38 +249,38 @@ static int osc_getattr_async(struct obd_export *exp, struct obd_info *oinfo, aa->aa_oi = oinfo; ptlrpc_set_add_req(set, req); - RETURN (0); + RETURN(0); } static int osc_getattr(struct obd_export *exp, struct obd_info *oinfo) { struct ptlrpc_request *req; - struct ost_body *body; - int rc, size[3] = { sizeof(struct ptlrpc_body), sizeof(*body) }; + struct ost_body *body; + int rc; ENTRY; - size[REQ_REC_OFF + 1] = oinfo->oi_capa ? sizeof(struct lustre_capa) : 0; - req = ptlrpc_prep_req(class_exp2cliimp(exp), LUSTRE_OST_VERSION, - OST_GETATTR, 3, size, NULL); - if (!req) + req = ptlrpc_request_alloc(class_exp2cliimp(exp), &RQF_OST_GETATTR); + if (req == NULL) RETURN(-ENOMEM); - osc_pack_req_body(req, REQ_REC_OFF, oinfo); + osc_set_capa_size(req, &RMF_CAPA1, oinfo->oi_capa); + rc = ptlrpc_request_pack(req, LUSTRE_OST_VERSION, OST_GETATTR); + if (rc) { + ptlrpc_request_free(req); + RETURN(rc); + } - ptlrpc_req_set_repsize(req, 2, size); + osc_pack_req_body(req, oinfo); + ptlrpc_request_set_replen(req); + rc = ptlrpc_queue_wait(req); - if (rc) { - CERROR("%s failed: rc = %d\n", __FUNCTION__, rc); + if (rc) GOTO(out, rc); - } - body = lustre_swab_repbuf(req, REPLY_REC_OFF, sizeof(*body), - lustre_swab_ost_body); - if (body == NULL) { - CERROR ("can't unpack ost_body\n"); - GOTO (out, rc = -EPROTO); - } + body = req_capsule_server_get(&req->rq_pill, &RMF_OST_BODY); + if (body == NULL) + GOTO(out, rc = -EPROTO); CDEBUG(D_INODE, "mode: %o\n", body->oa.o_mode); *oinfo->oi_oa = body->oa; @@ -282,28 +299,34 @@ static int osc_setattr(struct obd_export *exp, struct obd_info *oinfo, struct obd_trans_info *oti) { struct ptlrpc_request *req; - struct ost_body *body; - int rc, size[3] = { sizeof(struct ptlrpc_body), sizeof(*body) }; + struct ost_body *body; + int rc; ENTRY; LASSERT(!(oinfo->oi_oa->o_valid & OBD_MD_FLGROUP) || oinfo->oi_oa->o_gr > 0); - size[REQ_REC_OFF + 1] = oinfo->oi_capa ? sizeof(struct lustre_capa) : 0; - req = ptlrpc_prep_req(class_exp2cliimp(exp), LUSTRE_OST_VERSION, - OST_SETATTR, 3, size, NULL); - if (!req) + + req = ptlrpc_request_alloc(class_exp2cliimp(exp), &RQF_OST_SETATTR); + if (req == NULL) RETURN(-ENOMEM); - osc_pack_req_body(req, REQ_REC_OFF, oinfo); + osc_set_capa_size(req, &RMF_CAPA1, oinfo->oi_capa); + rc = ptlrpc_request_pack(req, LUSTRE_OST_VERSION, OST_SETATTR); + if (rc) { + ptlrpc_request_free(req); + RETURN(rc); + } + + osc_pack_req_body(req, oinfo); - ptlrpc_req_set_repsize(req, 2, size); + ptlrpc_request_set_replen(req); + rc = ptlrpc_queue_wait(req); if (rc) GOTO(out, rc); - body = lustre_swab_repbuf(req, REPLY_REC_OFF, sizeof(*body), - lustre_swab_ost_body); + body = req_capsule_server_get(&req->rq_pill, &RMF_OST_BODY); if (body == NULL) GOTO(out, rc = -EPROTO); @@ -324,12 +347,9 @@ static int osc_setattr_interpret(struct ptlrpc_request *req, if (rc != 0) GOTO(out, rc); - body = lustre_swab_repbuf(req, REPLY_REC_OFF, sizeof(*body), - lustre_swab_ost_body); - if (body == NULL) { - CERROR("can't unpack ost_body\n"); + body = req_capsule_server_get(&req->rq_pill, &RMF_OST_BODY); + if (body == NULL) GOTO(out, rc = -EPROTO); - } *aa->aa_oi->oi_oa = body->oa; out: @@ -342,23 +362,30 @@ static int osc_setattr_async(struct obd_export *exp, struct obd_info *oinfo, struct ptlrpc_request_set *rqset) { struct ptlrpc_request *req; - int size[3] = { sizeof(struct ptlrpc_body), sizeof(struct ost_body) }; struct osc_async_args *aa; + int rc; ENTRY; - size[REQ_REC_OFF + 1] = oinfo->oi_capa ? sizeof(struct lustre_capa) : 0; - req = ptlrpc_prep_req(class_exp2cliimp(exp), LUSTRE_OST_VERSION, - OST_SETATTR, 3, size, NULL); - if (!req) + req = ptlrpc_request_alloc(class_exp2cliimp(exp), &RQF_OST_SETATTR); + if (req == NULL) RETURN(-ENOMEM); - osc_pack_req_body(req, REQ_REC_OFF, oinfo); + osc_set_capa_size(req, &RMF_CAPA1, oinfo->oi_capa); + rc = ptlrpc_request_pack(req, LUSTRE_OST_VERSION, OST_SETATTR); + if (rc) { + ptlrpc_request_free(req); + RETURN(rc); + } + + osc_pack_req_body(req, oinfo); + + ptlrpc_request_set_replen(req); + if (oinfo->oi_oa->o_valid & OBD_MD_FLCOOKIE) { LASSERT(oti); *obdo_logcookie(oinfo->oi_oa) = *oti->oti_logcookies; } - ptlrpc_req_set_repsize(req, 2, size); /* do mds to ost setattr asynchronouly */ if (!rqset) { /* Do not wait for response. */ @@ -380,9 +407,9 @@ int osc_real_create(struct obd_export *exp, struct obdo *oa, struct lov_stripe_md **ea, struct obd_trans_info *oti) { struct ptlrpc_request *req; - struct ost_body *body; - struct lov_stripe_md *lsm; - int rc, size[2] = { sizeof(struct ptlrpc_body), sizeof(*body) }; + struct ost_body *body; + struct lov_stripe_md *lsm; + int rc; ENTRY; LASSERT(oa); @@ -395,15 +422,22 @@ int osc_real_create(struct obd_export *exp, struct obdo *oa, RETURN(rc); } - req = ptlrpc_prep_req(class_exp2cliimp(exp), LUSTRE_OST_VERSION, - OST_CREATE, 2, size, NULL); - if (!req) + req = ptlrpc_request_alloc(class_exp2cliimp(exp), &RQF_OST_CREATE); + if (req == NULL) GOTO(out, rc = -ENOMEM); - body = lustre_msg_buf(req->rq_reqmsg, REQ_REC_OFF, sizeof(*body)); + rc = ptlrpc_request_pack(req, LUSTRE_OST_VERSION, OST_CREATE); + if (rc) { + ptlrpc_request_free(req); + GOTO(out, rc); + } + + body = req_capsule_client_get(&req->rq_pill, &RMF_OST_BODY); + LASSERT(body); body->oa = *oa; - ptlrpc_req_set_repsize(req, 2, size); + ptlrpc_request_set_replen(req); + if (oa->o_valid & OBD_MD_FLINLINE) { LASSERT((oa->o_valid & OBD_MD_FLFLAGS) && oa->o_flags == OBD_FL_DELORPHAN); @@ -417,12 +451,9 @@ int osc_real_create(struct obd_export *exp, struct obdo *oa, if (rc) GOTO(out_req, rc); - body = lustre_swab_repbuf(req, REPLY_REC_OFF, sizeof(*body), - lustre_swab_ost_body); - if (body == NULL) { - CERROR ("can't unpack ost_body\n"); - GOTO (out_req, rc = -EPROTO); - } + body = req_capsule_server_get(&req->rq_pill, &RMF_OST_BODY); + if (body == NULL) + GOTO(out_req, rc = -EPROTO); *oa = body->oa; @@ -467,12 +498,9 @@ static int osc_punch_interpret(struct ptlrpc_request *req, if (rc != 0) GOTO(out, rc); - body = lustre_swab_repbuf(req, REPLY_REC_OFF, sizeof (*body), - lustre_swab_ost_body); - if (body == NULL) { - CERROR ("can't unpack ost_body\n"); + body = req_capsule_server_get(&req->rq_pill, &RMF_OST_BODY); + if (body == NULL) GOTO(out, rc = -EPROTO); - } *aa->aa_oi->oi_oa = body->oa; out: @@ -486,31 +514,36 @@ static int osc_punch(struct obd_export *exp, struct obd_info *oinfo, { struct ptlrpc_request *req; struct osc_async_args *aa; - struct ost_body *body; - int size[3] = { sizeof(struct ptlrpc_body), sizeof(*body) }; + struct ost_body *body; + int rc; ENTRY; if (!oinfo->oi_oa) { - CERROR("oa NULL\n"); + CDEBUG(D_INFO, "oa NULL\n"); RETURN(-EINVAL); } - size[REQ_REC_OFF + 1] = oinfo->oi_capa? sizeof(struct lustre_capa) : 0; - req = ptlrpc_prep_req(class_exp2cliimp(exp), LUSTRE_OST_VERSION, - OST_PUNCH, 3, size, NULL); - if (!req) + req = ptlrpc_request_alloc(class_exp2cliimp(exp), &RQF_OST_PUNCH); + if (req == NULL) RETURN(-ENOMEM); + osc_set_capa_size(req, &RMF_CAPA1, oinfo->oi_capa); + rc = ptlrpc_request_pack(req, LUSTRE_OST_VERSION, OST_PUNCH); + if (rc) { + ptlrpc_request_free(req); + RETURN(rc); + } req->rq_request_portal = OST_IO_PORTAL; /* bug 7198 */ + osc_pack_req_body(req, oinfo); - osc_pack_req_body(req, REQ_REC_OFF, oinfo); /* overload the size and blocks fields in the oa with start/end */ - body = lustre_msg_buf(req->rq_reqmsg, REQ_REC_OFF, sizeof(*body)); + body = req_capsule_client_get(&req->rq_pill, &RMF_OST_BODY); + LASSERT(body); body->oa.o_size = oinfo->oi_policy.l_extent.start; body->oa.o_blocks = oinfo->oi_policy.l_extent.end; body->oa.o_valid |= (OBD_MD_FLSIZE | OBD_MD_FLBLOCKS); + ptlrpc_request_set_replen(req); - ptlrpc_req_set_repsize(req, 2, size); req->rq_interpret_reply = osc_punch_interpret; CLASSERT (sizeof(*aa) <= sizeof(req->rq_async_args)); @@ -526,43 +559,44 @@ static int osc_sync(struct obd_export *exp, struct obdo *oa, void *capa) { struct ptlrpc_request *req; - struct ost_body *body; - int rc, size[3] = { sizeof(struct ptlrpc_body), sizeof(*body) }; + struct ost_body *body; + int rc; ENTRY; if (!oa) { - CERROR("oa NULL\n"); + CDEBUG(D_INFO, "oa NULL\n"); RETURN(-EINVAL); } - size[REQ_REC_OFF + 1] = capa ? sizeof(struct lustre_capa) : 0; - - req = ptlrpc_prep_req(class_exp2cliimp(exp), LUSTRE_OST_VERSION, - OST_SYNC, 3, size, NULL); - if (!req) + req = ptlrpc_request_alloc(class_exp2cliimp(exp), &RQF_OST_SYNC); + if (req == NULL) RETURN(-ENOMEM); + osc_set_capa_size(req, &RMF_CAPA1, capa); + rc = ptlrpc_request_pack(req, LUSTRE_OST_VERSION, OST_SYNC); + if (rc) { + ptlrpc_request_free(req); + RETURN(rc); + } + /* overload the size and blocks fields in the oa with start/end */ - body = lustre_msg_buf(req->rq_reqmsg, REQ_REC_OFF, sizeof(*body)); + body = req_capsule_client_get(&req->rq_pill, &RMF_OST_BODY); + LASSERT(body); body->oa = *oa; body->oa.o_size = start; body->oa.o_blocks = end; body->oa.o_valid |= (OBD_MD_FLSIZE | OBD_MD_FLBLOCKS); + osc_pack_capa(req, body, capa); - osc_pack_capa(req, REQ_REC_OFF + 1, body, capa); - - ptlrpc_req_set_repsize(req, 2, size); + ptlrpc_request_set_replen(req); rc = ptlrpc_queue_wait(req); if (rc) GOTO(out, rc); - body = lustre_swab_repbuf(req, REPLY_REC_OFF, sizeof(*body), - lustre_swab_ost_body); - if (body == NULL) { - CERROR ("can't unpack ost_body\n"); - GOTO (out, rc = -EPROTO); - } + body = req_capsule_server_get(&req->rq_pill, &RMF_OST_BODY); + if (body == NULL) + GOTO(out, rc = -EPROTO); *oa = body->oa; @@ -636,38 +670,46 @@ static int osc_destroy(struct obd_export *exp, struct obdo *oa, struct lov_stripe_md *ea, struct obd_trans_info *oti, struct obd_export *md_export) { - CFS_LIST_HEAD(cancels); + struct client_obd *cli = &exp->exp_obd->u.cli; struct ptlrpc_request *req; - struct ost_body *body; - int size[3] = { sizeof(struct ptlrpc_body), sizeof(*body), 0 }; - int count, bufcount = 2; - struct client_obd *cli = &exp->exp_obd->u.cli; + struct ost_body *body; + CFS_LIST_HEAD(cancels); + int rc, count; ENTRY; if (!oa) { - CERROR("oa NULL\n"); + CDEBUG(D_INFO, "oa NULL\n"); RETURN(-EINVAL); } count = osc_resource_get_unused(exp, oa, &cancels, LCK_PW, LDLM_FL_DISCARD_DATA); - if (exp_connect_cancelset(exp) && count) - bufcount = 3; - req = ldlm_prep_elc_req(exp, LUSTRE_OST_VERSION, OST_DESTROY, bufcount, - size, REQ_REC_OFF + 1, 0, &cancels, count); - if (!req) + + req = ptlrpc_request_alloc(class_exp2cliimp(exp), &RQF_OST_DESTROY); + if (req == NULL) { + ldlm_lock_list_put(&cancels, l_bl_ast, count); RETURN(-ENOMEM); + } + + rc = ldlm_prep_elc_req(exp, req, LUSTRE_OST_VERSION, OST_DESTROY, + 0, &cancels, count); + if (rc) { + ldlm_lock_list_put(&cancels, l_bl_ast, count); + ptlrpc_request_free(req); + RETURN(rc); + } req->rq_request_portal = OST_IO_PORTAL; /* bug 7198 */ req->rq_interpret_reply = osc_destroy_interpret; - body = lustre_msg_buf(req->rq_reqmsg, REQ_REC_OFF, sizeof(*body)); if (oti != NULL && oa->o_valid & OBD_MD_FLCOOKIE) memcpy(obdo_logcookie(oa), oti->oti_logcookies, sizeof(*oti->oti_logcookies)); + body = req_capsule_client_get(&req->rq_pill, &RMF_OST_BODY); + LASSERT(body); body->oa = *oa; - ptlrpc_req_set_repsize(req, 2, size); + ptlrpc_request_set_replen(req); if (!osc_can_send_destroy(cli)) { struct l_wait_info lwi = { 0 }; @@ -889,7 +931,7 @@ static int check_write_rcs(struct ptlrpc_request *req, remote_rcs = lustre_swab_repbuf(req, REQ_REC_OFF + 1, sizeof(*remote_rcs) * niocount, NULL); if (remote_rcs == NULL) { - CERROR("Missing/short RC vector on BRW_WRITE reply\n"); + CDEBUG(D_INFO, "Missing/short RC vector on BRW_WRITE reply\n"); return(-EPROTO); } if (lustre_msg_swabbed(req->rq_repmsg)) @@ -901,7 +943,7 @@ static int check_write_rcs(struct ptlrpc_request *req, return(remote_rcs[i]); if (remote_rcs[i] != 0) { - CERROR("rc[%d] invalid (%d) req %p\n", + CDEBUG(D_INFO, "rc[%d] invalid (%d) req %p\n", i, remote_rcs[i], req); return(-EPROTO); } @@ -977,11 +1019,9 @@ static int osc_brw_prep_request(int cmd, struct client_obd *cli,struct obdo *oa, struct ost_body *body; struct obd_ioobj *ioobj; struct niobuf_remote *niobuf; - int size[5] = { sizeof(struct ptlrpc_body), sizeof(*body) }; int niocount, i, requested_nob, opc, rc; - struct ptlrpc_request_pool *pool; - struct lustre_capa *capa; struct osc_brw_async_args *aa; + struct req_capsule *pill; ENTRY; if (OBD_FAIL_CHECK(OBD_FAIL_OSC_BRW_PREP_REQ)) @@ -991,55 +1031,55 @@ static int osc_brw_prep_request(int cmd, struct client_obd *cli,struct obdo *oa, if ((cmd & OBD_BRW_WRITE) != 0) { opc = OST_WRITE; - pool = cli->cl_import->imp_rq_pool; + req = ptlrpc_request_alloc_pool(cli->cl_import, + cli->cl_import->imp_rq_pool, + &RQF_OST_BRW); } else { opc = OST_READ; - pool = NULL; + req = ptlrpc_request_alloc(cli->cl_import, &RQF_OST_BRW); } + if (req == NULL) + RETURN(-ENOMEM); + for (niocount = i = 1; i < page_count; i++) { if (!can_merge_pages(pga[i - 1], pga[i])) niocount++; } - size[REQ_REC_OFF + 1] = sizeof(*ioobj); - size[REQ_REC_OFF + 2] = niocount * sizeof(*niobuf); - if (ocapa) - size[REQ_REC_OFF + 3] = sizeof(*capa); - - req = ptlrpc_prep_req_pool(cli->cl_import, LUSTRE_OST_VERSION, opc, 5, - size, NULL, pool, NULL); - if (req == NULL) - RETURN (-ENOMEM); + pill = &req->rq_pill; + req_capsule_set_size(pill, &RMF_NIOBUF_REMOTE, RCL_CLIENT, + niocount * sizeof(*niobuf)); + osc_set_capa_size(req, &RMF_CAPA1, ocapa); + rc = ptlrpc_request_pack(req, LUSTRE_OST_VERSION, opc); + if (rc) { + ptlrpc_request_free(req); + RETURN(rc); + } req->rq_request_portal = OST_IO_PORTAL; /* bug 7198 */ if (opc == OST_WRITE) - desc = ptlrpc_prep_bulk_imp (req, page_count, - BULK_GET_SOURCE, OST_BULK_PORTAL); + desc = ptlrpc_prep_bulk_imp(req, page_count, + BULK_GET_SOURCE, OST_BULK_PORTAL); else - desc = ptlrpc_prep_bulk_imp (req, page_count, - BULK_PUT_SINK, OST_BULK_PORTAL); + desc = ptlrpc_prep_bulk_imp(req, page_count, + BULK_PUT_SINK, OST_BULK_PORTAL); + if (desc == NULL) GOTO(out, rc = -ENOMEM); /* NB request now owns desc and will free it when it gets freed */ - body = lustre_msg_buf(req->rq_reqmsg, REQ_REC_OFF, sizeof(*body)); - ioobj = lustre_msg_buf(req->rq_reqmsg, REQ_REC_OFF + 1, sizeof(*ioobj)); - niobuf = lustre_msg_buf(req->rq_reqmsg, REQ_REC_OFF + 2, - niocount * sizeof(*niobuf)); + body = req_capsule_client_get(pill, &RMF_OST_BODY); + ioobj = req_capsule_client_get(pill, &RMF_OBD_IOOBJ); + niobuf = req_capsule_client_get(pill, &RMF_NIOBUF_REMOTE); + LASSERT(body && ioobj && niobuf); body->oa = *oa; obdo_to_ioobj(oa, ioobj); ioobj->ioo_bufcnt = niocount; - if (ocapa) { - capa = lustre_msg_buf(req->rq_reqmsg, REQ_REC_OFF + 3, - sizeof(*capa)); - capa_cpy(capa, ocapa); - body->oa.o_valid |= OBD_MD_FLOSSCAPA; - } - + osc_pack_capa(req, body, ocapa); LASSERT (page_count > 0); for (requested_nob = i = 0; i < page_count; i++, niobuf++) { struct brw_page *pg = pga[i]; @@ -1102,15 +1142,16 @@ static int osc_brw_prep_request(int cmd, struct client_obd *cli,struct obdo *oa, } oa->o_cksum = body->oa.o_cksum; /* 1 RC per niobuf */ - size[REPLY_REC_OFF + 1] = sizeof(__u32) * niocount; - ptlrpc_req_set_repsize(req, 3, size); + req_capsule_set_size(pill, &RMF_NIOBUF_REMOTE, RCL_SERVER, + sizeof(__u32) * niocount); } else { if (unlikely(cli->cl_checksum) && req->rq_flvr.sf_bulk_csum == BULK_CSUM_ALG_NULL) body->oa.o_valid |= OBD_MD_FLCKSUM; + req_capsule_set_size(pill, &RMF_NIOBUF_REMOTE, RCL_SERVER, 0); /* 1 RC for the whole I/O */ - ptlrpc_req_set_repsize(req, 2, size); } + ptlrpc_request_set_replen(req); CLASSERT(sizeof(*aa) <= sizeof(req->rq_async_args)); aa = (struct osc_brw_async_args *)&req->rq_async_args; @@ -1124,11 +1165,11 @@ static int osc_brw_prep_request(int cmd, struct client_obd *cli,struct obdo *oa, INIT_LIST_HEAD(&aa->aa_oaps); *reqp = req; - RETURN (0); + RETURN(0); out: - ptlrpc_req_finished (req); - RETURN (rc); + ptlrpc_req_finished(req); + RETURN(rc); } static int check_write_checksum(struct obdo *oa, const lnet_process_id_t *peer, @@ -1189,7 +1230,7 @@ static int osc_brw_fini_request(struct ptlrpc_request *req, int rc) body = lustre_swab_repbuf(req, REPLY_REC_OFF, sizeof(*body), lustre_swab_ost_body); if (body == NULL) { - CERROR ("Can't unpack body\n"); + CDEBUG(D_INFO, "Can't unpack body\n"); RETURN(-EPROTO); } @@ -1210,7 +1251,7 @@ static int osc_brw_fini_request(struct ptlrpc_request *req, int rc) if (lustre_msg_get_opc(req->rq_reqmsg) == OST_WRITE) { if (rc > 0) { - CERROR ("Unexpected +ve rc %d\n", rc); + CERROR("Unexpected +ve rc %d\n", rc); RETURN(-EPROTO); } LASSERT(req->rq_bulk->bd_nob == aa->aa_requested_nob); @@ -2848,11 +2889,9 @@ static int osc_enqueue_fini(struct ptlrpc_request *req, struct obd_info *oinfo, /* The request was created before ldlm_cli_enqueue call. */ if (rc == ELDLM_LOCK_ABORTED) { struct ldlm_reply *rep; + rep = req_capsule_server_get(&req->rq_pill, + &RMF_DLM_REP); - /* swabbed by ldlm_cli_enqueue() */ - LASSERT(lustre_rep_swabbed(req, DLM_LOCKREPLY_OFF)); - rep = lustre_msg_buf(req->rq_repmsg, DLM_LOCKREPLY_OFF, - sizeof(*rep)); LASSERT(rep != NULL); if (rep->lock_policy_res1) rc = rep->lock_policy_res1; @@ -2917,7 +2956,6 @@ static int osc_enqueue(struct obd_export *exp, struct obd_info *oinfo, { struct ldlm_res_id res_id = { .name = {0} }; struct obd_device *obd = exp->exp_obd; - struct ldlm_reply *rep; struct ptlrpc_request *req = NULL; int intent = oinfo->oi_flags & LDLM_FL_HAS_INTENT; ldlm_mode_t mode; @@ -2982,19 +3020,19 @@ static int osc_enqueue(struct obd_export *exp, struct obd_info *oinfo, no_match: if (intent) { - int size[3] = { - [MSG_PTLRPC_BODY_OFF] = sizeof(struct ptlrpc_body), - [DLM_LOCKREQ_OFF] = sizeof(struct ldlm_request), - [DLM_LOCKREQ_OFF + 1] = 0 }; - - req = ldlm_prep_enqueue_req(exp, 2, size, NULL, 0); + CFS_LIST_HEAD(cancels); + req = ptlrpc_request_alloc(class_exp2cliimp(exp), + &RQF_LDLM_ENQUEUE_LVB); if (req == NULL) RETURN(-ENOMEM); - size[DLM_LOCKREPLY_OFF] = sizeof(*rep); - size[DLM_REPLY_REC_OFF] = - sizeof(oinfo->oi_md->lsm_oinfo[0]->loi_lvb); - ptlrpc_req_set_repsize(req, 3, size); + rc = ldlm_prep_enqueue_req(exp, req, &cancels, 0); + if (rc) + RETURN(rc); + + req_capsule_set_size(&req->rq_pill, &RMF_DLM_LVB, RCL_SERVER, + sizeof(oinfo->oi_md->lsm_oinfo[0]->loi_lvb)); + ptlrpc_request_set_replen(req); } /* users of osc_enqueue() can pass this flag for ldlm_lock_match() */ @@ -3124,14 +3162,12 @@ static int osc_statfs_interpret(struct ptlrpc_request *req, if (rc != 0) GOTO(out, rc); - msfs = lustre_swab_repbuf(req, REPLY_REC_OFF, sizeof(*msfs), - lustre_swab_obd_statfs); + msfs = req_capsule_server_get(&req->rq_pill, &RMF_OBD_STATFS); if (msfs == NULL) { - CERROR("Can't unpack obd_statfs\n"); GOTO(out, rc = -EPROTO); } - memcpy(aa->aa_oi->oi_osfs, msfs, sizeof(*msfs)); + *aa->aa_oi->oi_osfs = *msfs; out: rc = aa->aa_oi->oi_cb_up(aa->aa_oi, rc); RETURN(rc); @@ -3142,7 +3178,7 @@ static int osc_statfs_async(struct obd_device *obd, struct obd_info *oinfo, { struct ptlrpc_request *req; struct osc_async_args *aa; - int size[2] = { sizeof(struct ptlrpc_body), sizeof(*oinfo->oi_osfs) }; + int rc; ENTRY; /* We could possibly pass max_age in the request (as an absolute @@ -3151,12 +3187,16 @@ static int osc_statfs_async(struct obd_device *obd, struct obd_info *oinfo, * during mount that would help a bit). Having relative timestamps * is not so great if request processing is slow, while absolute * timestamps are not ideal because they need time synchronization. */ - req = ptlrpc_prep_req(obd->u.cli.cl_import, LUSTRE_OST_VERSION, - OST_STATFS, 1, NULL, NULL); - if (!req) + req = ptlrpc_request_alloc(obd->u.cli.cl_import, &RQF_OST_STATFS); + if (req == NULL) RETURN(-ENOMEM); - ptlrpc_req_set_repsize(req, 2, size); + rc = ptlrpc_request_pack(req, LUSTRE_OST_VERSION, OST_STATFS); + if (rc) { + ptlrpc_request_free(req); + RETURN(rc); + } + ptlrpc_request_set_replen(req); req->rq_request_portal = OST_CREATE_PORTAL; //XXX FIXME bug 249 req->rq_interpret_reply = osc_statfs_interpret; @@ -3171,9 +3211,9 @@ static int osc_statfs_async(struct obd_device *obd, struct obd_info *oinfo, static int osc_statfs(struct obd_device *obd, struct obd_statfs *osfs, __u64 max_age) { - struct obd_statfs *msfs; + struct obd_statfs *msfs; struct ptlrpc_request *req; - int rc, size[2] = { sizeof(struct ptlrpc_body), sizeof(*osfs) }; + int rc; ENTRY; /* We could possibly pass max_age in the request (as an absolute @@ -3182,26 +3222,28 @@ static int osc_statfs(struct obd_device *obd, struct obd_statfs *osfs, * during mount that would help a bit). Having relative timestamps * is not so great if request processing is slow, while absolute * timestamps are not ideal because they need time synchronization. */ - req = ptlrpc_prep_req(obd->u.cli.cl_import, LUSTRE_OST_VERSION, - OST_STATFS, 1, NULL, NULL); - if (!req) + req = ptlrpc_request_alloc(obd->u.cli.cl_import, &RQF_OST_STATFS); + if (req == NULL) RETURN(-ENOMEM); - ptlrpc_req_set_repsize(req, 2, size); + rc = ptlrpc_request_pack(req, LUSTRE_OST_VERSION, OST_STATFS); + if (rc) { + ptlrpc_request_free(req); + RETURN(rc); + } + ptlrpc_request_set_replen(req); req->rq_request_portal = OST_CREATE_PORTAL; //XXX FIXME bug 249 rc = ptlrpc_queue_wait(req); if (rc) GOTO(out, rc); - msfs = lustre_swab_repbuf(req, REPLY_REC_OFF, sizeof(*msfs), - lustre_swab_obd_statfs); + msfs = req_capsule_server_get(&req->rq_pill, &RMF_OBD_STATFS); if (msfs == NULL) { - CERROR("Can't unpack obd_statfs\n"); GOTO(out, rc = -EPROTO); } - memcpy(osfs, msfs, sizeof(*osfs)); + *osfs = *msfs; EXIT; out: @@ -3355,27 +3397,38 @@ static int osc_get_info(struct obd_export *exp, obd_count keylen, RETURN(0); } else if (KEY_IS("last_id")) { struct ptlrpc_request *req; - obd_id *reply; - char *bufs[2] = { NULL, key }; - int rc, size[2] = { sizeof(struct ptlrpc_body), keylen }; + obd_id *reply; + char *tmp; + int rc; - req = ptlrpc_prep_req(class_exp2cliimp(exp), LUSTRE_OST_VERSION, - OST_GET_INFO, 2, size, bufs); + req = ptlrpc_request_alloc(class_exp2cliimp(exp), + &RQF_OST_GET_INFO); if (req == NULL) RETURN(-ENOMEM); - size[REPLY_REC_OFF] = *vallen; - ptlrpc_req_set_repsize(req, 2, size); + req_capsule_set_size(&req->rq_pill, &RMF_SETINFO_KEY, + RCL_CLIENT, keylen); + rc = ptlrpc_request_pack(req, LUSTRE_OST_VERSION, OST_GET_INFO); + if (rc) { + ptlrpc_request_free(req); + RETURN(rc); + } + + tmp = req_capsule_client_get(&req->rq_pill, &RMF_SETINFO_KEY); + LASSERT(tmp); + memcpy(tmp, key, keylen); + + req_capsule_set_size(&req->rq_pill, &RMF_OBD_ID, + RCL_SERVER, *vallen); + ptlrpc_request_set_replen(req); rc = ptlrpc_queue_wait(req); if (rc) GOTO(out, rc); - reply = lustre_swab_repbuf(req, REPLY_REC_OFF, sizeof(*reply), - lustre_swab_ost_last_id); - if (reply == NULL) { - CERROR("Can't unpack OST last ID\n"); + reply = req_capsule_server_get(&req->rq_pill, &RMF_OBD_ID); + if (reply == NULL) GOTO(out, rc = -EPROTO); - } + *((obd_id *)val) = *reply; out: ptlrpc_req_finished(req); @@ -3417,10 +3470,10 @@ static int osc_set_info_async(struct obd_export *exp, obd_count keylen, struct ptlrpc_request_set *set) { struct ptlrpc_request *req; - struct obd_device *obd = exp->exp_obd; - struct obd_import *imp = class_exp2cliimp(exp); - int size[3] = { sizeof(struct ptlrpc_body), keylen, vallen }; - char *bufs[3] = { NULL, key, val }; + struct obd_device *obd = exp->exp_obd; + struct obd_import *imp = class_exp2cliimp(exp); + char *tmp; + int rc; ENTRY; OBD_FAIL_TIMEOUT(OBD_FAIL_OSC_SHUTDOWN, 10); @@ -3478,11 +3531,26 @@ static int osc_set_info_async(struct obd_export *exp, obd_count keylen, Even if something bad goes through, we'd get a -EINVAL from OST anyway. */ - req = ptlrpc_prep_req(imp, LUSTRE_OST_VERSION, OST_SET_INFO, 3, size, - bufs); + + req = ptlrpc_request_alloc(imp, &RQF_OST_SET_INFO); if (req == NULL) RETURN(-ENOMEM); + req_capsule_set_size(&req->rq_pill, &RMF_SETINFO_KEY, + RCL_CLIENT, keylen); + req_capsule_set_size(&req->rq_pill, &RMF_SETINFO_VAL, + RCL_CLIENT, vallen); + rc = ptlrpc_request_pack(req, LUSTRE_OST_VERSION, OST_SET_INFO); + if (rc) { + ptlrpc_request_free(req); + RETURN(rc); + } + + tmp = req_capsule_client_get(&req->rq_pill, &RMF_SETINFO_KEY); + memcpy(tmp, key, keylen); + tmp = req_capsule_client_get(&req->rq_pill, &RMF_SETINFO_VAL); + memcpy(tmp, val, vallen); + if (KEY_IS(KEY_MDS_CONN)) { struct osc_creator *oscc = &obd->u.cli.cl_oscc; @@ -3492,7 +3560,7 @@ static int osc_set_info_async(struct obd_export *exp, obd_count keylen, req->rq_interpret_reply = osc_setinfo_mds_conn_interpret; } - ptlrpc_req_set_repsize(req, 1, NULL); + ptlrpc_request_set_replen(req); ptlrpc_set_add_req(set, req); ptlrpc_check_set(set); diff --git a/lustre/ost/ost_handler.c b/lustre/ost/ost_handler.c index 6ea1654..c0c84e6 100644 --- a/lustre/ost/ost_handler.c +++ b/lustre/ost/ost_handler.c @@ -1325,14 +1325,15 @@ static int ost_handle_quotacheck(struct ptlrpc_request *req) int rc; ENTRY; - oqctl = lustre_swab_reqbuf(req, REQ_REC_OFF, sizeof(*oqctl), - lustre_swab_obd_quotactl); + oqctl = req_capsule_client_get(&req->rq_pill, &RMF_OBD_QUOTACTL); if (oqctl == NULL) RETURN(-EPROTO); - rc = lustre_pack_reply(req, 1, NULL, NULL); - if (rc) - RETURN(rc); + rc = req_capsule_server_pack(&req->rq_pill); + if (rc) { + CERROR("ost: out of memory while packing quotacheck reply\n"); + RETURN(-ENOMEM); + } req->rq_status = obd_quotacheck(req->rq_export, oqctl); RETURN(0); @@ -1483,6 +1484,7 @@ int ost_msg_check_version(struct lustre_msg *msg) return rc; } +/* TODO: handle requests in a similar way as MDT: see mdt_handle_common() */ int ost_handle(struct ptlrpc_request *req) { struct obd_trans_info trans_info = { 0, }; @@ -1501,6 +1503,8 @@ int ost_handle(struct ptlrpc_request *req) GOTO(out, rc = 0); } + req_capsule_init(&req->rq_pill, req, RCL_SERVER); + /* XXX identical to MDS */ if (lustre_msg_get_opc(req->rq_reqmsg) != OST_CONNECT) { int recovering; @@ -1541,6 +1545,7 @@ int ost_handle(struct ptlrpc_request *req) switch (lustre_msg_get_opc(req->rq_reqmsg)) { case OST_CONNECT: { CDEBUG(D_INODE, "connect\n"); + req_capsule_set(&req->rq_pill, &RQF_OST_CONNECT); if (OBD_FAIL_CHECK(OBD_FAIL_OST_CONNECT_NET)) RETURN(0); rc = target_handle_connect(req); @@ -1556,6 +1561,7 @@ int ost_handle(struct ptlrpc_request *req) } case OST_DISCONNECT: CDEBUG(D_INODE, "disconnect\n"); + req_capsule_set(&req->rq_pill, &RQF_OST_DISCONNECT); if (OBD_FAIL_CHECK(OBD_FAIL_OST_DISCONNECT_NET)) RETURN(0); rc = target_handle_disconnect(req); @@ -1656,41 +1662,47 @@ int ost_handle(struct ptlrpc_request *req) break; case OST_QUOTACHECK: CDEBUG(D_INODE, "quotacheck\n"); + req_capsule_set(&req->rq_pill, &RQF_OST_QUOTACHECK); if (OBD_FAIL_CHECK(OBD_FAIL_OST_QUOTACHECK_NET)) RETURN(0); rc = ost_handle_quotacheck(req); break; case OST_QUOTACTL: CDEBUG(D_INODE, "quotactl\n"); + req_capsule_set(&req->rq_pill, &RQF_OST_QUOTACTL); if (OBD_FAIL_CHECK(OBD_FAIL_OST_QUOTACTL_NET)) RETURN(0); rc = ost_handle_quotactl(req); break; case OBD_PING: DEBUG_REQ(D_INODE, req, "ping"); + req_capsule_set(&req->rq_pill, &RQF_OBD_PING); rc = target_handle_ping(req); break; /* FIXME - just reply status */ case LLOG_ORIGIN_CONNECT: DEBUG_REQ(D_INODE, req, "log connect"); + req_capsule_set(&req->rq_pill, &RQF_LLOG_ORIGIN_CONNECT); rc = ost_llog_handle_connect(req->rq_export, req); req->rq_status = rc; - rc = lustre_pack_reply(req, 1, NULL, NULL); + rc = req_capsule_server_pack(&req->rq_pill); if (rc) RETURN(rc); RETURN(ptlrpc_reply(req)); case OBD_LOG_CANCEL: CDEBUG(D_INODE, "log cancel\n"); + req_capsule_set(&req->rq_pill, &RQF_LOG_CANCEL); if (OBD_FAIL_CHECK(OBD_FAIL_OBD_LOG_CANCEL_NET)) RETURN(0); rc = llog_origin_handle_cancel(req); req->rq_status = rc; - rc = lustre_pack_reply(req, 1, NULL, NULL); + rc = req_capsule_server_pack(&req->rq_pill); if (rc) RETURN(rc); RETURN(ptlrpc_reply(req)); case LDLM_ENQUEUE: CDEBUG(D_INODE, "enqueue\n"); + req_capsule_set(&req->rq_pill, &RQF_LDLM_ENQUEUE); if (OBD_FAIL_CHECK(OBD_FAIL_LDLM_ENQUEUE)) RETURN(0); rc = ldlm_handle_enqueue(req, ldlm_server_completion_ast, @@ -1700,12 +1712,14 @@ int ost_handle(struct ptlrpc_request *req) break; case LDLM_CONVERT: CDEBUG(D_INODE, "convert\n"); + req_capsule_set(&req->rq_pill, &RQF_LDLM_CONVERT); if (OBD_FAIL_CHECK(OBD_FAIL_LDLM_CONVERT)) RETURN(0); rc = ldlm_handle_convert(req); break; case LDLM_CANCEL: CDEBUG(D_INODE, "cancel\n"); + req_capsule_set(&req->rq_pill, &RQF_LDLM_CANCEL); if (OBD_FAIL_CHECK(OBD_FAIL_LDLM_CANCEL)) RETURN(0); rc = ldlm_handle_cancel(req); diff --git a/lustre/ptlrpc/client.c b/lustre/ptlrpc/client.c index f46f9e3..1ca4de7 100644 --- a/lustre/ptlrpc/client.c +++ b/lustre/ptlrpc/client.c @@ -35,6 +35,7 @@ #include #include #include +#include #include "ptlrpc_internal.h" @@ -132,8 +133,8 @@ struct ptlrpc_bulk_desc *ptlrpc_prep_bulk_imp (struct ptlrpc_request *req, return desc; } -struct ptlrpc_bulk_desc *ptlrpc_prep_bulk_exp (struct ptlrpc_request *req, - int npages, int type, int portal) +struct ptlrpc_bulk_desc *ptlrpc_prep_bulk_exp(struct ptlrpc_request *req, + int npages, int type, int portal) { struct obd_export *exp = req->rq_export; struct ptlrpc_bulk_desc *desc; @@ -320,37 +321,15 @@ static void __ptlrpc_free_req_to_pool(struct ptlrpc_request *request) spin_unlock(&pool->prp_lock); } -struct ptlrpc_request * -ptlrpc_prep_req_pool(struct obd_import *imp, __u32 version, int opcode, - int count, int *lengths, char **bufs, - struct ptlrpc_request_pool *pool, - struct ptlrpc_cli_ctx *ctx) +static int __ptlrpc_request_bufs_pack(struct ptlrpc_request *request, + __u32 version, int opcode, + int count, int *lengths, char **bufs, + struct ptlrpc_cli_ctx *ctx) { - struct ptlrpc_request *request = NULL; - int rc; + struct obd_import *imp = request->rq_import; + int rc; ENTRY; - /* The obd disconnected */ - if (imp == NULL) - return NULL; - - LASSERT(imp != LP_POISON); - LASSERT((unsigned long)imp->imp_client > 0x1000); - LASSERT(imp->imp_client != LP_POISON); - - if (pool) - request = ptlrpc_prep_req_from_pool(pool); - - if (!request) - OBD_ALLOC(request, sizeof(*request)); - - if (!request) { - CERROR("request allocation out of memory\n"); - RETURN(NULL); - } - - request->rq_import = class_import_get(imp); - if (unlikely(ctx)) request->rq_cli_ctx = sptlrpc_cli_ctx_get(ctx); else { @@ -361,8 +340,8 @@ ptlrpc_prep_req_pool(struct obd_import *imp, __u32 version, int opcode, sptlrpc_req_set_flavor(request, opcode); - rc = lustre_pack_request(request, imp->imp_msg_magic, count, lengths, - bufs); + rc = lustre_pack_request(request, imp->imp_msg_magic, count, + lengths, bufs); if (rc) { LASSERT(!request->rq_pool); GOTO(out_ctx, rc); @@ -403,16 +382,132 @@ ptlrpc_prep_req_pool(struct obd_import *imp, __u32 version, int opcode, lustre_msg_set_opc(request->rq_reqmsg, opcode); lustre_msg_set_flags(request->rq_reqmsg, 0); - RETURN(request); + RETURN(0); out_ctx: sptlrpc_cli_ctx_put(request->rq_cli_ctx, 1); out_free: class_import_put(imp); + return rc; +} + +int ptlrpc_request_bufs_pack(struct ptlrpc_request *request, + __u32 version, int opcode, char **bufs, + struct ptlrpc_cli_ctx *ctx) +{ + int count; + + count = req_capsule_filled_sizes(&request->rq_pill, RCL_CLIENT); + return __ptlrpc_request_bufs_pack(request, version, opcode, count, + request->rq_pill.rc_area[RCL_CLIENT], + bufs, ctx); +} + +int ptlrpc_request_pack(struct ptlrpc_request *request, + __u32 version, int opcode) +{ + return ptlrpc_request_bufs_pack(request, version, opcode, NULL, NULL); +} + +static inline +struct ptlrpc_request *__ptlrpc_request_alloc(struct obd_import *imp, + struct ptlrpc_request_pool *pool) +{ + struct ptlrpc_request *request = NULL; + + if (pool) + request = ptlrpc_prep_req_from_pool(pool); + + if (!request) + OBD_ALLOC_PTR(request); + + if (request) { + LASSERT((unsigned long)imp > 0x1000); + LASSERT(imp != LP_POISON); + LASSERT((unsigned long)imp->imp_client > 0x1000); + LASSERT(imp->imp_client != LP_POISON); + + request->rq_import = class_import_get(imp); + } else { + CERROR("request allocation out of memory\n"); + } + + return request; +} + +static struct ptlrpc_request * +ptlrpc_request_alloc_internal(struct obd_import *imp, + struct ptlrpc_request_pool * pool, + const struct req_format *format) +{ + struct ptlrpc_request *request; + + request = __ptlrpc_request_alloc(imp, pool); + if (request == NULL) + return NULL; + + req_capsule_init(&request->rq_pill, request, RCL_CLIENT); + req_capsule_set(&request->rq_pill, format); + return request; +} + +struct ptlrpc_request *ptlrpc_request_alloc(struct obd_import *imp, + const struct req_format *format) +{ + return ptlrpc_request_alloc_internal(imp, NULL, format); +} + +struct ptlrpc_request *ptlrpc_request_alloc_pool(struct obd_import *imp, + struct ptlrpc_request_pool * pool, + const struct req_format *format) +{ + return ptlrpc_request_alloc_internal(imp, pool, format); +} + +void ptlrpc_request_free(struct ptlrpc_request *request) +{ if (request->rq_pool) __ptlrpc_free_req_to_pool(request); else - OBD_FREE(request, sizeof(*request)); - return NULL; + OBD_FREE_PTR(request); +} + +struct ptlrpc_request *ptlrpc_request_alloc_pack(struct obd_import *imp, + const struct req_format *format, + __u32 version, int opcode) +{ + struct ptlrpc_request *req = ptlrpc_request_alloc(imp, format); + int rc; + + if (req) { + rc = ptlrpc_request_pack(req, version, opcode); + if (rc) { + ptlrpc_request_free(req); + req = NULL; + } + } + return req; +} + +struct ptlrpc_request * +ptlrpc_prep_req_pool(struct obd_import *imp, + __u32 version, int opcode, + int count, int *lengths, char **bufs, + struct ptlrpc_request_pool *pool) +{ + struct ptlrpc_request *request; + int rc; + + request = __ptlrpc_request_alloc(imp, pool); + if (!request) + return NULL; + + rc = __ptlrpc_request_bufs_pack(request, version, opcode, count, + lengths, bufs, NULL); + if (rc) { + ptlrpc_request_free(request); + request = NULL; + } + return request; } struct ptlrpc_request * @@ -420,7 +515,7 @@ ptlrpc_prep_req(struct obd_import *imp, __u32 version, int opcode, int count, int *lengths, char **bufs) { return ptlrpc_prep_req_pool(imp, version, opcode, count, lengths, bufs, - NULL, NULL); + NULL); } struct ptlrpc_request_set *ptlrpc_prep_set(void) @@ -1322,6 +1417,8 @@ static void __ptlrpc_free_req(struct ptlrpc_request *request, int locked) LASSERTF(list_empty(&request->rq_set_chain), "req %p\n", request); LASSERT(request->rq_cli_ctx); + req_capsule_fini(&request->rq_pill); + /* We must take it off the imp_replay_list first. Otherwise, we'll set * request->rq_reqmsg to NULL while osc_close is dereferencing it. */ if (request->rq_import != NULL) { diff --git a/lustre/ptlrpc/gss/gss_cli_upcall.c b/lustre/ptlrpc/gss/gss_cli_upcall.c index 610c108..da435a5 100644 --- a/lustre/ptlrpc/gss/gss_cli_upcall.c +++ b/lustre/ptlrpc/gss/gss_cli_upcall.c @@ -231,7 +231,6 @@ int gss_do_ctx_init_rpc(__user char *buffer, unsigned long count) struct obd_device *obd; char obdname[64]; long lsize; - int lmsg_size = sizeof(struct ptlrpc_body); int rc; if (count != sizeof(param)) { @@ -268,9 +267,9 @@ int gss_do_ctx_init_rpc(__user char *buffer, unsigned long count) /* force this import to use v2 msg */ imp->imp_msg_magic = LUSTRE_MSG_MAGIC_V2; - req = ptlrpc_prep_req(imp, LUSTRE_OBD_VERSION, SEC_CTX_INIT, - 1, &lmsg_size, NULL); - if (!req) { + req = ptlrpc_request_alloc_pack(imp, &RQF_SEC_CTX, LUSTRE_OBD_VERSION, + SEC_CTX_INIT); + if (req == NULL) { param.status = -ENOMEM; goto out_copy; } @@ -294,7 +293,7 @@ int gss_do_ctx_init_rpc(__user char *buffer, unsigned long count) goto out_copy; } - req->rq_replen = lustre_msg_size_v2(1, &lmsg_size); + ptlrpc_request_set_replen(req); rc = ptlrpc_queue_wait(req); if (rc) { @@ -339,7 +338,6 @@ int gss_do_ctx_fini_rpc(struct gss_cli_ctx *gctx) struct obd_import *imp = ctx->cc_sec->ps_import; struct ptlrpc_request *req; struct ptlrpc_user_desc *pud; - int buflens = sizeof(struct ptlrpc_body); int rc; ENTRY; @@ -362,14 +360,20 @@ int gss_do_ctx_fini_rpc(struct gss_cli_ctx *gctx) gctx->gc_proc = PTLRPC_GSS_PROC_DESTROY; - req = ptlrpc_prep_req_pool(imp, LUSTRE_OBD_VERSION, SEC_CTX_FINI, - 1, &buflens, NULL, NULL, ctx); - if (!req) { + req = ptlrpc_request_alloc(imp, &RQF_SEC_CTX); + if (req == NULL) { CWARN("ctx %p(%u): fail to prepare rpc, destroy locally\n", ctx, ctx->cc_vcred.vc_uid); GOTO(out, rc = -ENOMEM); } + rc = ptlrpc_request_bufs_pack(req, LUSTRE_OBD_VERSION, SEC_CTX_FINI, + NULL, ctx); + if (rc) { + ptlrpc_request_free(req); + GOTO(out_ref, rc); + } + /* fix the user desc */ if (req->rq_pack_udesc) { /* we rely the fact that this request is in AUTH mode, diff --git a/lustre/ptlrpc/import.c b/lustre/ptlrpc/import.c index e282302..93800ce 100644 --- a/lustre/ptlrpc/import.c +++ b/lustre/ptlrpc/import.c @@ -367,20 +367,15 @@ int ptlrpc_connect_import(struct obd_import *imp, char *new_uuid) struct obd_device *obd = imp->imp_obd; int initial_connect = 0; int set_transno = 0; - int rc; __u64 committed_before_reconnect = 0; struct ptlrpc_request *request; - int size[] = { sizeof(struct ptlrpc_body), - sizeof(imp->imp_obd->u.cli.cl_target_uuid), - sizeof(obd->obd_uuid), - sizeof(imp->imp_dlm_handle), - sizeof(imp->imp_connect_data) }; - char *tmp[] = { NULL, - obd2cli_tgt(imp->imp_obd), - obd->obd_uuid.uuid, - (char *)&imp->imp_dlm_handle, - (char *)&imp->imp_connect_data }; + char *bufs[] = { NULL, + obd2cli_tgt(imp->imp_obd), + obd->obd_uuid.uuid, + (char *)&imp->imp_dlm_handle, + (char *)&imp->imp_connect_data }; struct ptlrpc_connect_async_args *aa; + int rc; ENTRY; spin_lock(&imp->imp_lock); @@ -457,11 +452,17 @@ int ptlrpc_connect_import(struct obd_import *imp, char *new_uuid) if (rc) GOTO(out, rc); - request = ptlrpc_prep_req(imp, LUSTRE_OBD_VERSION, imp->imp_connect_op, - 5, size, tmp); - if (!request) + request = ptlrpc_request_alloc(imp, &RQF_MDS_CONNECT); + if (request == NULL) GOTO(out, rc = -ENOMEM); + rc = ptlrpc_request_bufs_pack(request, LUSTRE_OBD_VERSION, + imp->imp_connect_op, bufs, NULL); + if (rc) { + ptlrpc_request_free(request); + GOTO(out, rc); + } + #ifndef __KERNEL__ lustre_msg_add_op_flags(request->rq_reqmsg, MSG_CONNECT_LIBCLIENT); #endif @@ -469,9 +470,9 @@ int ptlrpc_connect_import(struct obd_import *imp, char *new_uuid) request->rq_send_state = LUSTRE_IMP_CONNECTING; /* Allow a slightly larger reply for future growth compatibility */ - size[REPLY_REC_OFF] = sizeof(struct obd_connect_data) + - 16 * sizeof(__u64); - ptlrpc_req_set_repsize(request, 2, size); + req_capsule_set_size(&request->rq_pill, &RMF_CONNECT_DATA, RCL_SERVER, + sizeof(struct obd_connect_data)+16*sizeof(__u64)); + ptlrpc_request_set_replen(request); request->rq_interpret_reply = ptlrpc_connect_interpret; CLASSERT(sizeof (*aa) <= sizeof (request->rq_async_args)); @@ -700,9 +701,12 @@ finish: } else { struct obd_connect_data *ocd; struct obd_export *exp; - - ocd = lustre_swab_repbuf(request, REPLY_REC_OFF, sizeof(*ocd), - lustre_swab_connect); + int ret; + ret = req_capsule_get_size(&request->rq_pill, &RMF_CONNECT_DATA, + RCL_SERVER); + /* server replied obd_connect_data is always bigger */ + ocd = req_capsule_server_sized_get(&request->rq_pill, + &RMF_CONNECT_DATA, ret); spin_lock(&imp->imp_lock); list_del(&imp->imp_conn_current->oic_item); @@ -812,9 +816,8 @@ out: if (request->rq_repmsg == NULL) RETURN(-EPROTO); - ocd = lustre_swab_repbuf(request, REPLY_REC_OFF, - sizeof *ocd, - lustre_swab_connect); + ocd = req_capsule_server_get(&request->rq_pill, + &RMF_CONNECT_DATA); if (ocd && (ocd->ocd_connect_flags & OBD_CONNECT_VERSION) && (ocd->ocd_version != LUSTRE_VERSION_CODE)) { @@ -878,13 +881,14 @@ static int signal_completed_replay(struct obd_import *imp) LASSERT(atomic_read(&imp->imp_replay_inflight) == 0); atomic_inc(&imp->imp_replay_inflight); - req = ptlrpc_prep_req(imp, LUSTRE_OBD_VERSION, OBD_PING, 1, NULL, NULL); - if (!req) { + req = ptlrpc_request_alloc_pack(imp, &RQF_OBD_PING, LUSTRE_OBD_VERSION, + OBD_PING); + if (req == NULL) { atomic_dec(&imp->imp_replay_inflight); RETURN(-ENOMEM); } - ptlrpc_req_set_repsize(req, 1, NULL); + ptlrpc_request_set_replen(req); req->rq_send_state = LUSTRE_IMP_REPLAY_WAIT; lustre_msg_add_flags(req->rq_reqmsg, MSG_LOCK_REPLAY_DONE | MSG_REQ_REPLAY_DONE); @@ -1066,7 +1070,8 @@ int ptlrpc_disconnect_import(struct obd_import *imp, int noclose) spin_unlock(&imp->imp_lock); - req = ptlrpc_prep_req(imp, LUSTRE_OBD_VERSION, rq_opc, 1, NULL, NULL); + req = ptlrpc_request_alloc_pack(imp, &RQF_MDS_DISCONNECT, + LUSTRE_OBD_VERSION, rq_opc); if (req) { /* We are disconnecting, do not retry a failed DISCONNECT rpc if * it fails. We can get through the above with a down server @@ -1079,7 +1084,7 @@ int ptlrpc_disconnect_import(struct obd_import *imp, int noclose) #endif IMPORT_SET_STATE(imp, LUSTRE_IMP_CONNECTING); req->rq_send_state = LUSTRE_IMP_CONNECTING; - ptlrpc_req_set_repsize(req, 1, NULL); + ptlrpc_request_set_replen(req); rc = ptlrpc_queue_wait(req); ptlrpc_req_finished(req); } diff --git a/lustre/ptlrpc/layout.c b/lustre/ptlrpc/layout.c index 05295b8..cfdf171 100644 --- a/lustre/ptlrpc/layout.c +++ b/lustre/ptlrpc/layout.c @@ -61,6 +61,21 @@ static const struct req_msg_field *empty[] = { &RMF_PTLRPC_BODY }; +static const struct req_msg_field *mgs_target_info_only[] = { + &RMF_PTLRPC_BODY, + &RMF_MGS_TARGET_INFO +}; + +static const struct req_msg_field *mgs_set_info[] = { + &RMF_PTLRPC_BODY, + &RMF_MGS_SEND_PARAM +}; + +static const struct req_msg_field *log_cancel_client[] = { + &RMF_PTLRPC_BODY, + &RMF_LOGCOOKIES +}; + static const struct req_msg_field *mdt_body_only[] = { &RMF_PTLRPC_BODY, &RMF_MDT_BODY @@ -72,14 +87,24 @@ static const struct req_msg_field *mdt_body_capa[] = { &RMF_CAPA1 }; +static const struct req_msg_field *quotactl_only[] = { + &RMF_PTLRPC_BODY, + &RMF_OBD_QUOTACTL +}; + +static const struct req_msg_field *qunit_data_only[] = { + &RMF_PTLRPC_BODY, + &RMF_QUNIT_DATA +}; + static const struct req_msg_field *mdt_close_client[] = { &RMF_PTLRPC_BODY, &RMF_MDT_EPOCH, - &RMF_REC_SETATTR, + &RMF_REC_REINT, &RMF_CAPA1 }; -static const struct req_msg_field *mds_statfs_server[] = { +static const struct req_msg_field *obd_statfs_server[] = { &RMF_PTLRPC_BODY, &RMF_OBD_STATFS }; @@ -115,45 +140,46 @@ static const struct req_msg_field *mds_getattr_name_client[] = { static const struct req_msg_field *mds_reint_client[] = { &RMF_PTLRPC_BODY, - &RMF_REINT_OPC + &RMF_REC_REINT }; static const struct req_msg_field *mds_reint_create_client[] = { &RMF_PTLRPC_BODY, - &RMF_REC_CREATE, + &RMF_REC_REINT, &RMF_CAPA1, - &RMF_NAME, + &RMF_NAME }; -static const struct req_msg_field *mds_reint_create_rmt_acl_client[] = { +static const struct req_msg_field *mds_reint_create_slave_client[] = { &RMF_PTLRPC_BODY, - &RMF_REC_CREATE, + &RMF_REC_REINT, &RMF_CAPA1, &RMF_NAME, &RMF_EADATA, &RMF_DLM_REQ }; -static const struct req_msg_field *mds_reint_create_sym_client[] = { +static const struct req_msg_field *mds_reint_create_rmt_acl_client[] = { &RMF_PTLRPC_BODY, - &RMF_REC_CREATE, + &RMF_REC_REINT, &RMF_CAPA1, &RMF_NAME, - &RMF_SYMTGT, + &RMF_EADATA, &RMF_DLM_REQ }; -static const struct req_msg_field *mds_reint_create_slave_client[] = { +static const struct req_msg_field *mds_reint_create_sym_client[] = { &RMF_PTLRPC_BODY, - &RMF_REC_CREATE, + &RMF_REC_REINT, &RMF_CAPA1, &RMF_NAME, - &RMF_EADATA + &RMF_SYMTGT, + &RMF_DLM_REQ }; static const struct req_msg_field *mds_reint_open_client[] = { &RMF_PTLRPC_BODY, - &RMF_REC_CREATE, + &RMF_REC_REINT, &RMF_CAPA1, &RMF_CAPA2, &RMF_NAME, @@ -171,7 +197,7 @@ static const struct req_msg_field *mds_reint_open_server[] = { static const struct req_msg_field *mds_reint_unlink_client[] = { &RMF_PTLRPC_BODY, - &RMF_REC_UNLINK, + &RMF_REC_REINT, &RMF_CAPA1, &RMF_NAME, &RMF_DLM_REQ @@ -179,7 +205,7 @@ static const struct req_msg_field *mds_reint_unlink_client[] = { static const struct req_msg_field *mds_reint_link_client[] = { &RMF_PTLRPC_BODY, - &RMF_REC_LINK, + &RMF_REC_REINT, &RMF_CAPA1, &RMF_CAPA2, &RMF_NAME, @@ -188,7 +214,7 @@ static const struct req_msg_field *mds_reint_link_client[] = { static const struct req_msg_field *mds_reint_rename_client[] = { &RMF_PTLRPC_BODY, - &RMF_REC_RENAME, + &RMF_REC_REINT, &RMF_CAPA1, &RMF_CAPA2, &RMF_NAME, @@ -205,7 +231,7 @@ static const struct req_msg_field *mds_last_unlink_server[] = { static const struct req_msg_field *mds_reint_setattr_client[] = { &RMF_PTLRPC_BODY, - &RMF_REC_SETATTR, + &RMF_REC_REINT, &RMF_CAPA1, &RMF_MDT_EPOCH, &RMF_EADATA, @@ -213,7 +239,15 @@ static const struct req_msg_field *mds_reint_setattr_client[] = { &RMF_DLM_REQ }; -static const struct req_msg_field *mds_connect_client[] = { +static const struct req_msg_field *mds_reint_setxattr_client[] = { + &RMF_PTLRPC_BODY, + &RMF_REC_REINT, + &RMF_CAPA1, + &RMF_NAME, + &RMF_EADATA +}; + +static const struct req_msg_field *obd_connect_client[] = { &RMF_PTLRPC_BODY, &RMF_TGTUUID, &RMF_CLUUID, @@ -221,7 +255,7 @@ static const struct req_msg_field *mds_connect_client[] = { &RMF_CONNECT_DATA }; -static const struct req_msg_field *mds_connect_server[] = { +static const struct req_msg_field *obd_connect_server[] = { &RMF_PTLRPC_BODY, &RMF_CONNECT_DATA }; @@ -242,11 +276,28 @@ static const struct req_msg_field *ldlm_enqueue_server[] = { &RMF_DLM_REP }; +static const struct req_msg_field *ldlm_enqueue_lvb_server[] = { + &RMF_PTLRPC_BODY, + &RMF_DLM_REP, + &RMF_DLM_LVB +}; + +static const struct req_msg_field *ldlm_cp_callback_client[] = { + &RMF_PTLRPC_BODY, + &RMF_DLM_REQ, + &RMF_DLM_LVB +}; + +static const struct req_msg_field *ldlm_gl_callback_server[] = { + &RMF_PTLRPC_BODY, + &RMF_DLM_LVB +}; + static const struct req_msg_field *ldlm_intent_client[] = { &RMF_PTLRPC_BODY, &RMF_DLM_REQ, &RMF_LDLM_INTENT, - &RMF_REINT_OPC + &RMF_REC_REINT }; static const struct req_msg_field *ldlm_intent_server[] = { @@ -254,8 +305,7 @@ static const struct req_msg_field *ldlm_intent_server[] = { &RMF_DLM_REP, &RMF_MDT_BODY, &RMF_MDT_MD, - &RMF_ACL, - &RMF_CAPA1 + &RMF_ACL }; static const struct req_msg_field *ldlm_intent_open_server[] = { @@ -277,11 +327,20 @@ static const struct req_msg_field *ldlm_intent_getattr_client[] = { &RMF_NAME }; +static const struct req_msg_field *ldlm_intent_getattr_server[] = { + &RMF_PTLRPC_BODY, + &RMF_DLM_REP, + &RMF_MDT_BODY, + &RMF_MDT_MD, + &RMF_ACL, + &RMF_CAPA1 +}; + static const struct req_msg_field *ldlm_intent_create_client[] = { &RMF_PTLRPC_BODY, &RMF_DLM_REQ, &RMF_LDLM_INTENT, - &RMF_REC_CREATE, /* coincides with mds_reint_create_client[] */ + &RMF_REC_REINT, /* coincides with mds_reint_create_client[] */ &RMF_CAPA1, &RMF_NAME, &RMF_EADATA @@ -291,18 +350,19 @@ static const struct req_msg_field *ldlm_intent_open_client[] = { &RMF_PTLRPC_BODY, &RMF_DLM_REQ, &RMF_LDLM_INTENT, - &RMF_REC_CREATE, /* coincides with mds_reint_open_client[] */ + &RMF_REC_REINT, /* coincides with mds_reint_open_client[] */ &RMF_CAPA1, &RMF_CAPA2, &RMF_NAME, - &RMF_EADATA + &RMF_EADATA, + &RMF_REC_JOINFILE }; static const struct req_msg_field *ldlm_intent_unlink_client[] = { &RMF_PTLRPC_BODY, &RMF_DLM_REQ, &RMF_LDLM_INTENT, - &RMF_REC_UNLINK, /* coincides with mds_reint_unlink_client[] */ + &RMF_REC_REINT, /* coincides with mds_reint_unlink_client[] */ &RMF_CAPA1, &RMF_NAME }; @@ -321,27 +381,116 @@ static const struct req_msg_field *mds_getxattr_server[] = { &RMF_EADATA }; -static const struct req_msg_field *mds_setxattr_client[] = { +static const struct req_msg_field *mds_getattr_server[] = { &RMF_PTLRPC_BODY, &RMF_MDT_BODY, + &RMF_MDT_MD, + &RMF_ACL, &RMF_CAPA1, + &RMF_CAPA2 +}; + +static const struct req_msg_field *mds_setattr_server[] = { + &RMF_PTLRPC_BODY, + &RMF_MDT_BODY, + &RMF_MDT_MD, + &RMF_ACL, + &RMF_CAPA1, + &RMF_CAPA2 +}; + +static const struct req_msg_field *llog_catinfo_client[] = { + &RMF_PTLRPC_BODY, &RMF_NAME, + &RMF_STRING +}; + +static const struct req_msg_field *llog_catinfo_server[] = { + &RMF_PTLRPC_BODY, + &RMF_STRING +}; + +static const struct req_msg_field *llog_origin_handle_create_client[] = { + &RMF_PTLRPC_BODY, + &RMF_LLOGD_BODY, + &RMF_NAME +}; + +static const struct req_msg_field *llogd_body_only[] = { + &RMF_PTLRPC_BODY, + &RMF_LLOGD_BODY +}; + +static const struct req_msg_field *llog_log_hdr_only[] = { + &RMF_PTLRPC_BODY, + &RMF_LLOG_LOG_HDR +}; + +static const struct req_msg_field *llogd_conn_body_only[] = { + &RMF_PTLRPC_BODY, + &RMF_LLOGD_CONN_BODY +}; + +static const struct req_msg_field *llog_origin_handle_next_block_server[] = { + &RMF_PTLRPC_BODY, + &RMF_LLOGD_BODY, &RMF_EADATA }; -static const struct req_msg_field *mds_setxattr_server[] = { - &RMF_PTLRPC_BODY +static const struct req_msg_field *ost_body_only[] = { + &RMF_PTLRPC_BODY, + &RMF_OST_BODY }; -static const struct req_msg_field *mds_getattr_server[] = { +static const struct req_msg_field *ost_body_capa[] = { &RMF_PTLRPC_BODY, - &RMF_MDT_BODY, - &RMF_MDT_MD, - &RMF_ACL, + &RMF_OST_BODY, + &RMF_CAPA1 +}; + +static const struct req_msg_field *ost_destroy_client[] = { + &RMF_PTLRPC_BODY, + &RMF_OST_BODY, + &RMF_DLM_REQ +}; + + +static const struct req_msg_field *ost_brw_client[] = { + &RMF_PTLRPC_BODY, + &RMF_OST_BODY, + &RMF_OBD_IOOBJ, + &RMF_NIOBUF_REMOTE, &RMF_CAPA1 }; +static const struct req_msg_field *ost_brw_server[] = { + &RMF_PTLRPC_BODY, + &RMF_OST_BODY, + &RMF_NIOBUF_REMOTE +}; + +static const struct req_msg_field *ost_set_info_client[] = { + &RMF_PTLRPC_BODY, + &RMF_SETINFO_KEY, + &RMF_SETINFO_VAL +}; + +static const struct req_msg_field *ost_get_info_client[] = { + &RMF_PTLRPC_BODY, + &RMF_SETINFO_KEY +}; + +static const struct req_msg_field *ost_get_info_server[] = { + &RMF_PTLRPC_BODY, + &RMF_OBD_ID +}; static const struct req_format *req_formats[] = { + &RQF_OBD_PING, + &RQF_SEC_CTX, + &RQF_SEQ_QUERY, + &RQF_FLD_QUERY, + &RQF_MGS_TARGET_REG, + &RQF_MGS_SET_INFO, &RQF_MDS_CONNECT, &RQF_MDS_DISCONNECT, &RQF_MDS_SET_INFO, @@ -349,33 +498,64 @@ static const struct req_format *req_formats[] = { &RQF_MDS_STATFS, &RQF_MDS_GETATTR, &RQF_MDS_GETATTR_NAME, + &RQF_MDS_GETXATTR, + &RQF_MDS_SYNC, + &RQF_MDS_CLOSE, + &RQF_MDS_PIN, + &RQF_MDS_UNPIN, + &RQF_MDS_READPAGE, + &RQF_MDS_WRITEPAGE, + &RQF_MDS_IS_SUBDIR, + &RQF_MDS_DONE_WRITING, &RQF_MDS_REINT, &RQF_MDS_REINT_CREATE, &RQF_MDS_REINT_CREATE_RMT_ACL, - &RQF_MDS_REINT_CREATE_SYM, &RQF_MDS_REINT_CREATE_SLAVE, + &RQF_MDS_REINT_CREATE_SYM, &RQF_MDS_REINT_OPEN, &RQF_MDS_REINT_UNLINK, &RQF_MDS_REINT_LINK, &RQF_MDS_REINT_RENAME, &RQF_MDS_REINT_SETATTR, + &RQF_MDS_REINT_SETXATTR, + &RQF_MDS_QUOTACHECK, + &RQF_MDS_QUOTACTL, + &RQF_MDS_QUOTA_DQACQ, + &RQF_OST_CONNECT, + &RQF_OST_DISCONNECT, + &RQF_OST_QUOTACHECK, + &RQF_OST_QUOTACTL, + &RQF_OST_GETATTR, + &RQF_OST_SETATTR, + &RQF_OST_CREATE, + &RQF_OST_PUNCH, + &RQF_OST_SYNC, + &RQF_OST_DESTROY, + &RQF_OST_BRW, + &RQF_OST_STATFS, + &RQF_OST_SET_INFO, + &RQF_OST_GET_INFO, &RQF_LDLM_ENQUEUE, + &RQF_LDLM_ENQUEUE_LVB, + &RQF_LDLM_CONVERT, + &RQF_LDLM_CANCEL, + &RQF_LDLM_CALLBACK, + &RQF_LDLM_CP_CALLBACK, + &RQF_LDLM_BL_CALLBACK, + &RQF_LDLM_GL_CALLBACK, &RQF_LDLM_INTENT, &RQF_LDLM_INTENT_GETATTR, &RQF_LDLM_INTENT_OPEN, &RQF_LDLM_INTENT_CREATE, &RQF_LDLM_INTENT_UNLINK, - &RQF_SEQ_QUERY, - &RQF_FLD_QUERY, - &RQF_MDS_GETXATTR, - &RQF_MDS_SETXATTR, - &RQF_MDS_SYNC, - &RQF_MDS_CLOSE, - &RQF_MDS_PIN, - &RQF_MDS_READPAGE, - &RQF_MDS_WRITEPAGE, - &RQF_MDS_IS_SUBDIR, - &RQF_MDS_DONE_WRITING + &RQF_LOG_CANCEL, + &RQF_LLOG_CATINFO, + &RQF_LLOG_ORIGIN_HANDLE_CREATE, + &RQF_LLOG_ORIGIN_HANDLE_DESTROY, + &RQF_LLOG_ORIGIN_HANDLE_NEXT_BLOCK, + &RQF_LLOG_ORIGIN_HANDLE_PREV_BLOCK, + &RQF_LLOG_ORIGIN_HANDLE_READ_HEADER, + &RQF_LLOG_ORIGIN_CONNECT }; struct req_msg_field { @@ -405,6 +585,18 @@ struct req_capsule; .rmf_swabber = (void (*)(void*))(swabber) \ } +const struct req_msg_field RMF_MGS_TARGET_INFO = + DEFINE_MSGF("mgs_target_info", 0, + sizeof(struct mgs_target_info), + lustre_swab_mgs_target_info); +EXPORT_SYMBOL(RMF_MGS_TARGET_INFO); + +const struct req_msg_field RMF_MGS_SEND_PARAM = + DEFINE_MSGF("mgs_send_param", 0, + sizeof(struct mgs_send_param), + NULL); +EXPORT_SYMBOL(RMF_MGS_SEND_PARAM); + const struct req_msg_field RMF_SETINFO_VAL = DEFINE_MSGF("setinfo_val", 0, sizeof(__u32), lustre_swab_generic_32s); @@ -435,6 +627,16 @@ const struct req_msg_field RMF_MDT_BODY = sizeof(struct mdt_body), lustre_swab_mdt_body); EXPORT_SYMBOL(RMF_MDT_BODY); +const struct req_msg_field RMF_OBD_QUOTACTL = + DEFINE_MSGF("obd_quotactl", 0, + sizeof(struct obd_quotactl), lustre_swab_obd_quotactl); +EXPORT_SYMBOL(RMF_OBD_QUOTACTL); + +const struct req_msg_field RMF_QUNIT_DATA = + DEFINE_MSGF("qunit_data", 0, + sizeof(struct qunit_data), NULL); +EXPORT_SYMBOL(RMF_QUNIT_DATA); + const struct req_msg_field RMF_MDT_EPOCH = DEFINE_MSGF("mdt_epoch", 0, sizeof(struct mdt_epoch), lustre_swab_mdt_epoch); @@ -470,6 +672,26 @@ const struct req_msg_field RMF_CLUUID = DEFINE_MSGF("cluuid", RMF_F_STRING, sizeof(struct obd_uuid) - 1, NULL); EXPORT_SYMBOL(RMF_CLUUID); +const struct req_msg_field RMF_STRING = + DEFINE_MSGF("string", RMF_F_STRING, -1, NULL); +EXPORT_SYMBOL(RMF_STRING); + +const struct req_msg_field RMF_LLOGD_BODY = + DEFINE_MSGF("llogd_body", 0, + sizeof(struct llogd_body), lustre_swab_llogd_body); +EXPORT_SYMBOL(RMF_LLOGD_BODY); + +const struct req_msg_field RMF_LLOG_LOG_HDR = + DEFINE_MSGF("llog_log_hdr", 0, + sizeof(struct llog_log_hdr), lustre_swab_llog_hdr); +EXPORT_SYMBOL(RMF_LLOG_LOG_HDR); + +const struct req_msg_field RMF_LLOGD_CONN_BODY = + DEFINE_MSGF("llogd_conn_body", 0, + sizeof(struct llogd_conn_body), + lustre_swab_llogd_conn_body); +EXPORT_SYMBOL(RMF_LLOGD_CONN_BODY); + /* * connection handle received in MDS_CONNECT request. * @@ -499,34 +721,23 @@ const struct req_msg_field RMF_LDLM_INTENT = sizeof(struct ldlm_intent), lustre_swab_ldlm_intent); EXPORT_SYMBOL(RMF_LDLM_INTENT); +const struct req_msg_field RMF_DLM_LVB = + DEFINE_MSGF("dlm_lvb", 0, sizeof(struct ost_lvb), NULL); +EXPORT_SYMBOL(RMF_DLM_LVB); + const struct req_msg_field RMF_MDT_MD = - DEFINE_MSGF("mdt_md", 0, MIN_MD_SIZE, lustre_swab_lov_mds_md); + DEFINE_MSGF("mdt_md", 0, MIN_MD_SIZE, NULL); EXPORT_SYMBOL(RMF_MDT_MD); -const struct req_msg_field RMF_REC_UNLINK = - DEFINE_MSGF("rec_unlink", 0, sizeof(struct mdt_rec_unlink), - lustre_swab_mdt_rec_unlink); -EXPORT_SYMBOL(RMF_REC_UNLINK); - -const struct req_msg_field RMF_REC_LINK = - DEFINE_MSGF("rec_link", 0, sizeof(struct mdt_rec_link), - lustre_swab_mdt_rec_link); -EXPORT_SYMBOL(RMF_REC_LINK); - -const struct req_msg_field RMF_REC_RENAME = - DEFINE_MSGF("rec_rename", 0, sizeof(struct mdt_rec_rename), - lustre_swab_mdt_rec_rename); -EXPORT_SYMBOL(RMF_REC_RENAME); +const struct req_msg_field RMF_REC_REINT = + DEFINE_MSGF("rec_reint", 0, sizeof(struct mdt_rec_reint), + lustre_swab_mdt_rec_reint); +EXPORT_SYMBOL(RMF_REC_REINT); -const struct req_msg_field RMF_REC_CREATE = - DEFINE_MSGF("rec_create", 0, - sizeof(struct mdt_rec_create), lustre_swab_mdt_rec_create); -EXPORT_SYMBOL(RMF_REC_CREATE); - -const struct req_msg_field RMF_REC_SETATTR = - DEFINE_MSGF("rec_setattr", 0, sizeof(struct mdt_rec_setattr), - lustre_swab_mdt_rec_setattr); -EXPORT_SYMBOL(RMF_REC_SETATTR); +const struct req_msg_field RMF_REC_JOINFILE = + DEFINE_MSGF("rec_joinfile", 0, sizeof(struct mdt_rec_join), + lustre_swab_mdt_rec_join); +EXPORT_SYMBOL(RMF_REC_JOINFILE); /* FIXME: this length should be defined as a macro */ const struct req_msg_field RMF_EADATA = DEFINE_MSGF("eadata", 0, -1, NULL); @@ -540,10 +751,6 @@ const struct req_msg_field RMF_LOGCOOKIES = DEFINE_MSGF("logcookies", 0, sizeof(struct llog_cookie), NULL); EXPORT_SYMBOL(RMF_LOGCOOKIES); -const struct req_msg_field RMF_REINT_OPC = - DEFINE_MSGF("reint_opc", 0, sizeof(__u32), lustre_swab_generic_32s); -EXPORT_SYMBOL(RMF_REINT_OPC); - const struct req_msg_field RMF_CAPA1 = DEFINE_MSGF("capa", 0, sizeof(struct lustre_capa), lustre_swab_lustre_capa); @@ -554,6 +761,29 @@ const struct req_msg_field RMF_CAPA2 = lustre_swab_lustre_capa); EXPORT_SYMBOL(RMF_CAPA2); +/* + * OST request field. + */ +const struct req_msg_field RMF_OST_BODY = + DEFINE_MSGF("ost_body", 0, + sizeof(struct ost_body), lustre_swab_ost_body); +EXPORT_SYMBOL(RMF_OST_BODY); + +const struct req_msg_field RMF_OBD_IOOBJ = + DEFINE_MSGF("obd_ioobj", 0, + sizeof(struct obd_ioobj), lustre_swab_obd_ioobj); +EXPORT_SYMBOL(RMF_OBD_IOOBJ); + +const struct req_msg_field RMF_NIOBUF_REMOTE = + DEFINE_MSGF("niobuf_remote", 0, -1, lustre_swab_niobuf_remote); +EXPORT_SYMBOL(RMF_NIOBUF_REMOTE); + +const struct req_msg_field RMF_OBD_ID = + DEFINE_MSGF("obd_id", 0, + sizeof(obd_id), lustre_swab_ost_last_id); +EXPORT_SYMBOL(RMF_OBD_ID); + + /* * Request formats. */ @@ -581,9 +811,55 @@ struct req_format { } \ } -#define DEFINE_REQ_FMT0(name, client, server) \ +#define DEFINE_REQ_FMT0(name, client, server) \ DEFINE_REQ_FMT(name, client, ARRAY_SIZE(client), server, ARRAY_SIZE(server)) +const struct req_format RQF_OBD_PING = + DEFINE_REQ_FMT0("OBD_PING", empty, empty); +EXPORT_SYMBOL(RQF_OBD_PING); + +const struct req_format RQF_SEC_CTX = + DEFINE_REQ_FMT0("SEC_CTX", empty, empty); +EXPORT_SYMBOL(RQF_SEC_CTX); + +const struct req_format RQF_MGS_TARGET_REG = + DEFINE_REQ_FMT0("MGS_TARGET_REG", mgs_target_info_only, + mgs_target_info_only); +EXPORT_SYMBOL(RQF_MGS_TARGET_REG); + +const struct req_format RQF_MGS_SET_INFO = + DEFINE_REQ_FMT0("MGS_SET_INTO", mgs_set_info, + mgs_set_info); +EXPORT_SYMBOL(RQF_MGS_SET_INFO); + +const struct req_format RQF_LOG_CANCEL = + DEFINE_REQ_FMT0("OBD_LOG_CANCEL", log_cancel_client, empty); +EXPORT_SYMBOL(RQF_LOG_CANCEL); + +const struct req_format RQF_MDS_QUOTACHECK = + DEFINE_REQ_FMT0("MDS_QUOTACHECK", quotactl_only, empty); +EXPORT_SYMBOL(RQF_MDS_QUOTACHECK); + +const struct req_format RQF_OST_QUOTACHECK = + DEFINE_REQ_FMT0("OST_QUOTACHECK", quotactl_only, empty); +EXPORT_SYMBOL(RQF_OST_QUOTACHECK); + +const struct req_format RQF_MDS_QUOTACTL = + DEFINE_REQ_FMT0("MDS_QUOTACTL", quotactl_only, quotactl_only); +EXPORT_SYMBOL(RQF_MDS_QUOTACTL); + +const struct req_format RQF_OST_QUOTACTL = + DEFINE_REQ_FMT0("OST_QUOTACTL", quotactl_only, quotactl_only); +EXPORT_SYMBOL(RQF_OST_QUOTACTL); + +const struct req_format RQF_QC_CALLBACK = + DEFINE_REQ_FMT0("QC_CALLBACK", quotactl_only, empty); +EXPORT_SYMBOL(RQF_QC_CALLBACK); + +const struct req_format RQF_MDS_QUOTA_DQACQ = + DEFINE_REQ_FMT0("MDS_QUOTA_DQACQ", qunit_data_only, qunit_data_only); +EXPORT_SYMBOL(RQF_MDS_QUOTA_DQACQ); + const struct req_format RQF_SEQ_QUERY = DEFINE_REQ_FMT0("SEQ_QUERY", seq_query_client, seq_query_server); EXPORT_SYMBOL(RQF_SEQ_QUERY); @@ -593,11 +869,11 @@ const struct req_format RQF_FLD_QUERY = EXPORT_SYMBOL(RQF_FLD_QUERY); const struct req_format RQF_MDS_GETSTATUS = - DEFINE_REQ_FMT0("MDS_GETSTATUS", empty, mdt_body_capa); + DEFINE_REQ_FMT0("MDS_GETSTATUS", mdt_body_only, mdt_body_capa); EXPORT_SYMBOL(RQF_MDS_GETSTATUS); const struct req_format RQF_MDS_STATFS = - DEFINE_REQ_FMT0("MDS_STATFS", empty, mds_statfs_server); + DEFINE_REQ_FMT0("MDS_STATFS", empty, obd_statfs_server); EXPORT_SYMBOL(RQF_MDS_STATFS); const struct req_format RQF_MDS_SYNC = @@ -613,11 +889,6 @@ const struct req_format RQF_MDS_GETXATTR = mds_getxattr_client, mds_getxattr_server); EXPORT_SYMBOL(RQF_MDS_GETXATTR); -const struct req_format RQF_MDS_SETXATTR = - DEFINE_REQ_FMT0("MDS_SETXATTR", - mds_setxattr_client, mds_setxattr_server); -EXPORT_SYMBOL(RQF_MDS_SETXATTR); - const struct req_format RQF_MDS_GETATTR_NAME = DEFINE_REQ_FMT0("MDS_GETATTR_NAME", mds_getattr_name_client, mds_getattr_server); @@ -638,7 +909,7 @@ const struct req_format RQF_MDS_REINT_CREATE_RMT_ACL = EXPORT_SYMBOL(RQF_MDS_REINT_CREATE_RMT_ACL); const struct req_format RQF_MDS_REINT_CREATE_SLAVE = - DEFINE_REQ_FMT0("MDS_REINT_CREATE_SLAVE", + DEFINE_REQ_FMT0("MDS_REINT_CREATE_EA", mds_reint_create_slave_client, mdt_body_capa); EXPORT_SYMBOL(RQF_MDS_REINT_CREATE_SLAVE); @@ -669,27 +940,63 @@ EXPORT_SYMBOL(RQF_MDS_REINT_RENAME); const struct req_format RQF_MDS_REINT_SETATTR = DEFINE_REQ_FMT0("MDS_REINT_SETATTR", - mds_reint_setattr_client, mdt_body_capa); + mds_reint_setattr_client, mds_setattr_server); EXPORT_SYMBOL(RQF_MDS_REINT_SETATTR); +const struct req_format RQF_MDS_REINT_SETXATTR = + DEFINE_REQ_FMT0("MDS_REINT_SETXATTR", + mds_reint_setxattr_client, mdt_body_only); +EXPORT_SYMBOL(RQF_MDS_REINT_SETXATTR); + const struct req_format RQF_MDS_CONNECT = DEFINE_REQ_FMT0("MDS_CONNECT", - mds_connect_client, mds_connect_server); + obd_connect_client, obd_connect_server); EXPORT_SYMBOL(RQF_MDS_CONNECT); const struct req_format RQF_MDS_DISCONNECT = DEFINE_REQ_FMT0("MDS_DISCONNECT", empty, empty); EXPORT_SYMBOL(RQF_MDS_DISCONNECT); - + const struct req_format RQF_MDS_SET_INFO = DEFINE_REQ_FMT0("MDS_SET_INFO", mds_set_info_client, empty); EXPORT_SYMBOL(RQF_MDS_SET_INFO); const struct req_format RQF_LDLM_ENQUEUE = DEFINE_REQ_FMT0("LDLM_ENQUEUE", - ldlm_enqueue_client, ldlm_enqueue_server); + ldlm_enqueue_client, ldlm_enqueue_lvb_server); EXPORT_SYMBOL(RQF_LDLM_ENQUEUE); +const struct req_format RQF_LDLM_ENQUEUE_LVB = + DEFINE_REQ_FMT0("LDLM_ENQUEUE_LVB", + ldlm_enqueue_client, ldlm_enqueue_lvb_server); +EXPORT_SYMBOL(RQF_LDLM_ENQUEUE_LVB); + +const struct req_format RQF_LDLM_CONVERT = + DEFINE_REQ_FMT0("LDLM_CONVERT", + ldlm_enqueue_client, ldlm_enqueue_server); +EXPORT_SYMBOL(RQF_LDLM_CONVERT); + +const struct req_format RQF_LDLM_CANCEL = + DEFINE_REQ_FMT0("LDLM_CANCEL", ldlm_enqueue_client, empty); +EXPORT_SYMBOL(RQF_LDLM_CANCEL); + +const struct req_format RQF_LDLM_CALLBACK = + DEFINE_REQ_FMT0("LDLM_CALLBACK", ldlm_enqueue_client, empty); +EXPORT_SYMBOL(RQF_LDLM_CALLBACK); + +const struct req_format RQF_LDLM_CP_CALLBACK = + DEFINE_REQ_FMT0("LDLM_CP_CALLBACK", ldlm_cp_callback_client, empty); +EXPORT_SYMBOL(RQF_LDLM_CP_CALLBACK); + +const struct req_format RQF_LDLM_BL_CALLBACK = + DEFINE_REQ_FMT0("LDLM_BL_CALLBACK", ldlm_enqueue_client, empty); +EXPORT_SYMBOL(RQF_LDLM_BL_CALLBACK); + +const struct req_format RQF_LDLM_GL_CALLBACK = + DEFINE_REQ_FMT0("LDLM_GL_CALLBACK", ldlm_enqueue_client, + ldlm_gl_callback_server); +EXPORT_SYMBOL(RQF_LDLM_GL_CALLBACK); + const struct req_format RQF_LDLM_INTENT = DEFINE_REQ_FMT0("LDLM_INTENT", ldlm_intent_client, ldlm_intent_server); @@ -697,7 +1004,7 @@ EXPORT_SYMBOL(RQF_LDLM_INTENT); const struct req_format RQF_LDLM_INTENT_GETATTR = DEFINE_REQ_FMT0("LDLM_INTENT_GETATTR", - ldlm_intent_getattr_client, ldlm_intent_server); + ldlm_intent_getattr_client, ldlm_intent_getattr_server); EXPORT_SYMBOL(RQF_LDLM_INTENT_GETATTR); const struct req_format RQF_LDLM_INTENT_OPEN = @@ -707,7 +1014,7 @@ EXPORT_SYMBOL(RQF_LDLM_INTENT_OPEN); const struct req_format RQF_LDLM_INTENT_CREATE = DEFINE_REQ_FMT0("LDLM_INTENT_CREATE", - ldlm_intent_create_client, ldlm_intent_server); + ldlm_intent_create_client, ldlm_intent_getattr_server); EXPORT_SYMBOL(RQF_LDLM_INTENT_CREATE); const struct req_format RQF_LDLM_INTENT_UNLINK = @@ -725,6 +1032,10 @@ const struct req_format RQF_MDS_PIN = mdt_body_capa, mdt_body_only); EXPORT_SYMBOL(RQF_MDS_PIN); +const struct req_format RQF_MDS_UNPIN = + DEFINE_REQ_FMT0("MDS_UNPIN", mdt_body_only, empty); +EXPORT_SYMBOL(RQF_MDS_UNPIN); + const struct req_format RQF_MDS_DONE_WRITING = DEFINE_REQ_FMT0("MDS_DONE_WRITING", mdt_close_client, mdt_body_only); @@ -746,6 +1057,91 @@ const struct req_format RQF_MDS_IS_SUBDIR = mdt_body_only, mdt_body_only); EXPORT_SYMBOL(RQF_MDS_IS_SUBDIR); +const struct req_format RQF_LLOG_CATINFO = + DEFINE_REQ_FMT0("LLOG_CATINFO", + llog_catinfo_client, llog_catinfo_server); +EXPORT_SYMBOL(RQF_LLOG_CATINFO); + +const struct req_format RQF_LLOG_ORIGIN_HANDLE_CREATE = + DEFINE_REQ_FMT0("LLOG_ORIGIN_HANDLE_CREATE", + llog_origin_handle_create_client, llogd_body_only); +EXPORT_SYMBOL(RQF_LLOG_ORIGIN_HANDLE_CREATE); + +const struct req_format RQF_LLOG_ORIGIN_HANDLE_DESTROY = + DEFINE_REQ_FMT0("LLOG_ORIGIN_HANDLE_DESTROY", + llogd_body_only, llogd_body_only); +EXPORT_SYMBOL(RQF_LLOG_ORIGIN_HANDLE_DESTROY); + +const struct req_format RQF_LLOG_ORIGIN_HANDLE_NEXT_BLOCK = + DEFINE_REQ_FMT0("LLOG_ORIGIN_HANDLE_NEXT_BLOCK", + llogd_body_only, llog_origin_handle_next_block_server); +EXPORT_SYMBOL(RQF_LLOG_ORIGIN_HANDLE_NEXT_BLOCK); + +const struct req_format RQF_LLOG_ORIGIN_HANDLE_PREV_BLOCK = + DEFINE_REQ_FMT0("LLOG_ORIGIN_HANDLE_PREV_BLOCK", + llogd_body_only, llog_origin_handle_next_block_server); +EXPORT_SYMBOL(RQF_LLOG_ORIGIN_HANDLE_PREV_BLOCK); + +const struct req_format RQF_LLOG_ORIGIN_HANDLE_READ_HEADER = + DEFINE_REQ_FMT0("LLOG_ORIGIN_HANDLE_READ_HEADER", + llogd_body_only, llog_log_hdr_only); +EXPORT_SYMBOL(RQF_LLOG_ORIGIN_HANDLE_READ_HEADER); + +const struct req_format RQF_LLOG_ORIGIN_CONNECT = + DEFINE_REQ_FMT0("LLOG_ORIGIN_CONNECT", llogd_conn_body_only, empty); +EXPORT_SYMBOL(RQF_LLOG_ORIGIN_CONNECT); + +const struct req_format RQF_OST_CONNECT = + DEFINE_REQ_FMT0("OST_CONNECT", + obd_connect_client, obd_connect_server); +EXPORT_SYMBOL(RQF_OST_CONNECT); + +const struct req_format RQF_OST_DISCONNECT = + DEFINE_REQ_FMT0("OST_DISCONNECT", empty, empty); +EXPORT_SYMBOL(RQF_OST_DISCONNECT); + +const struct req_format RQF_OST_GETATTR = + DEFINE_REQ_FMT0("OST_GETATTR", ost_body_capa, ost_body_only); +EXPORT_SYMBOL(RQF_OST_GETATTR); + +const struct req_format RQF_OST_SETATTR = + DEFINE_REQ_FMT0("OST_SETATTR", ost_body_capa, ost_body_only); +EXPORT_SYMBOL(RQF_OST_SETATTR); + +const struct req_format RQF_OST_CREATE = + DEFINE_REQ_FMT0("OST_CREATE", ost_body_only, ost_body_only); +EXPORT_SYMBOL(RQF_OST_CREATE); + +const struct req_format RQF_OST_PUNCH = + DEFINE_REQ_FMT0("OST_PUNCH", ost_body_capa, ost_body_only); +EXPORT_SYMBOL(RQF_OST_PUNCH); + +const struct req_format RQF_OST_SYNC = + DEFINE_REQ_FMT0("OST_SYNC", ost_body_capa, ost_body_only); +EXPORT_SYMBOL(RQF_OST_SYNC); + +const struct req_format RQF_OST_DESTROY = + DEFINE_REQ_FMT0("OST_DESTROY", ost_destroy_client, ost_body_only); +EXPORT_SYMBOL(RQF_OST_DESTROY); + +const struct req_format RQF_OST_BRW = + DEFINE_REQ_FMT0("OST_BRW", ost_brw_client, ost_brw_server); +EXPORT_SYMBOL(RQF_OST_BRW); + +const struct req_format RQF_OST_STATFS = + DEFINE_REQ_FMT0("OST_STATFS", empty, obd_statfs_server); +EXPORT_SYMBOL(RQF_OST_STATFS); + +const struct req_format RQF_OST_SET_INFO = + DEFINE_REQ_FMT0("OST_SET_INFO", ost_set_info_client, empty); +EXPORT_SYMBOL(RQF_OST_SET_INFO); + +const struct req_format RQF_OST_GET_INFO = + DEFINE_REQ_FMT0("OST_GET_INFO", ost_get_info_client, + ost_get_info_server); +EXPORT_SYMBOL(RQF_OST_GET_INFO); + + #if !defined(__REQ_LAYOUT_USER__) int req_layout_init(void) @@ -783,6 +1179,17 @@ void req_layout_fini(void) } EXPORT_SYMBOL(req_layout_fini); +void req_capsule_init_area(struct req_capsule *pill) +{ + int i; + + for (i = 0; i < ARRAY_SIZE(pill->rc_area[RCL_CLIENT]); i++) { + pill->rc_area[RCL_CLIENT][i] = -1; + pill->rc_area[RCL_SERVER][i] = -1; + } +} +EXPORT_SYMBOL(req_capsule_init_area); + /* * Initialize capsule. * @@ -790,15 +1197,15 @@ EXPORT_SYMBOL(req_layout_fini); * variable-sized fields. */ void req_capsule_init(struct req_capsule *pill, - struct ptlrpc_request *req, enum req_location location, - int *area) + struct ptlrpc_request *req, + enum req_location location) { LASSERT(location == RCL_SERVER || location == RCL_CLIENT); memset(pill, 0, sizeof *pill); pill->rc_req = req; pill->rc_loc = location; - pill->rc_area = area; + req_capsule_init_area(pill); } EXPORT_SYMBOL(req_capsule_init); @@ -832,39 +1239,50 @@ void req_capsule_set(struct req_capsule *pill, const struct req_format *fmt) } EXPORT_SYMBOL(req_capsule_set); -int req_capsule_pack(struct req_capsule *pill) +int req_capsule_filled_sizes(struct req_capsule *pill, + enum req_location loc) { - int i; - int nr; - int result; - int total; + const struct req_format *fmt = pill->rc_fmt; + int i; + + LASSERT(fmt != NULL); + + for (i = 0; i < fmt->rf_fields[loc].nr; ++i) { + if (pill->rc_area[loc][i] == -1) { + pill->rc_area[loc][i] = + fmt->rf_fields[loc].d[i]->rmf_size; + if (pill->rc_area[loc][i] == -1) { + /* skip the following fields */ + LASSERT(loc != RCL_SERVER); + break; + } + } + } + return i; +} +EXPORT_SYMBOL(req_capsule_filled_sizes); +int req_capsule_server_pack(struct req_capsule *pill) +{ const struct req_format *fmt; + int count; + int rc; LASSERT(pill->rc_loc == RCL_SERVER); fmt = pill->rc_fmt; LASSERT(fmt != NULL); - nr = fmt->rf_fields[RCL_SERVER].nr; - for (total = 0, i = 0; i < nr; ++i) { - int *size; - - size = &pill->rc_area[i]; - if (*size == -1) { - *size = fmt->rf_fields[RCL_SERVER].d[i]->rmf_size; - LASSERT(*size != -1); - } - total += *size; - } - result = lustre_pack_reply(pill->rc_req, nr, pill->rc_area, NULL); - if (result != 0) { + count = req_capsule_filled_sizes(pill, RCL_SERVER); + rc = lustre_pack_reply(pill->rc_req, count, + pill->rc_area[RCL_SERVER], NULL); + if (rc != 0) { DEBUG_REQ(D_ERROR, pill->rc_req, - "Cannot pack %d fields (%d bytes) in format `%s': ", - nr, total, fmt->rf_name); + "Cannot pack %d fields in format `%s': ", + count, fmt->rf_name); } - return result; + return rc; } -EXPORT_SYMBOL(req_capsule_pack); +EXPORT_SYMBOL(req_capsule_server_pack); static int __req_capsule_offset(const struct req_capsule *pill, const struct req_msg_field *field, @@ -873,7 +1291,9 @@ static int __req_capsule_offset(const struct req_capsule *pill, int offset; offset = field->rmf_offset[pill->rc_fmt->rf_idx][loc]; - LASSERT(offset > 0); + LASSERTF(offset > 0, "%s:%s, off=%d, loc=%d\n", + pill->rc_fmt->rf_name, + field->rmf_name, offset, loc); offset --; LASSERT(0 <= offset && offset < (sizeof(pill->rc_swabbed) << 3)); return offset; @@ -881,7 +1301,8 @@ static int __req_capsule_offset(const struct req_capsule *pill, static void *__req_capsule_get(struct req_capsule *pill, const struct req_msg_field *field, - enum req_location loc) + enum req_location loc, + void (*swabber)( void *)) { const struct req_format *fmt; struct lustre_msg *msg; @@ -903,26 +1324,32 @@ static void *__req_capsule_get(struct req_capsule *pill, offset = __req_capsule_offset(pill, field, loc); msg = __req_msg(pill, loc); + LASSERT(msg != NULL); getter = (field->rmf_flags & RMF_F_STRING) ? (typeof(getter))lustre_msg_string : lustre_msg_buf; - len = max(field->rmf_size, 0); + if (pill->rc_area[loc][offset] != -1) + len = pill->rc_area[loc][offset]; + else + len = max(field->rmf_size, 0); value = getter(msg, offset, len); + swabber = swabber ?: field->rmf_swabber; if (!(pill->rc_swabbed & (1 << offset)) && loc != pill->rc_loc && - field->rmf_swabber != NULL && value != NULL && + swabber != NULL && value != NULL && lustre_msg_swabbed(msg)) { - field->rmf_swabber(value); + swabber(value); pill->rc_swabbed |= (1 << offset); } - if (value == NULL) + if (value == NULL) { DEBUG_REQ(D_ERROR, pill->rc_req, "Wrong buffer for field `%s' (%d of %d) " "in format `%s': %d vs. %d (%s)\n", field->rmf_name, offset, lustre_msg_bufcount(msg), fmt->rf_name, - lustre_msg_buflen(msg, offset), field->rmf_size, + lustre_msg_buflen(msg, offset), len, rcl_names[loc]); + } return value; } @@ -930,32 +1357,73 @@ static void *__req_capsule_get(struct req_capsule *pill, void *req_capsule_client_get(struct req_capsule *pill, const struct req_msg_field *field) { - return __req_capsule_get(pill, field, RCL_CLIENT); + return __req_capsule_get(pill, field, RCL_CLIENT, NULL); } EXPORT_SYMBOL(req_capsule_client_get); +void *req_capsule_client_swab_get(struct req_capsule *pill, + const struct req_msg_field *field, + void (*swabber)(void* )) +{ + return __req_capsule_get(pill, field, RCL_CLIENT, swabber); +} +EXPORT_SYMBOL(req_capsule_client_swab_get); + +void *req_capsule_client_sized_get(struct req_capsule *pill, + const struct req_msg_field *field, + int len) +{ + req_capsule_set_size(pill, field, RCL_CLIENT, len); + return __req_capsule_get(pill, field, RCL_CLIENT, NULL); +} +EXPORT_SYMBOL(req_capsule_client_sized_get); + void *req_capsule_server_get(struct req_capsule *pill, const struct req_msg_field *field) { - return __req_capsule_get(pill, field, RCL_SERVER); + return __req_capsule_get(pill, field, RCL_SERVER, NULL); } EXPORT_SYMBOL(req_capsule_server_get); +void *req_capsule_server_swab_get(struct req_capsule *pill, + const struct req_msg_field *field, + void *swabber) +{ + return __req_capsule_get(pill, field, RCL_SERVER, swabber); +} +EXPORT_SYMBOL(req_capsule_server_swab_get); + + +void *req_capsule_server_sized_get(struct req_capsule *pill, + const struct req_msg_field *field, + int len) +{ + req_capsule_set_size(pill, field, RCL_SERVER, len); + return __req_capsule_get(pill, field, RCL_SERVER, NULL); +} +EXPORT_SYMBOL(req_capsule_server_sized_get); + const void *req_capsule_other_get(struct req_capsule *pill, const struct req_msg_field *field) { - return __req_capsule_get(pill, field, pill->rc_loc ^ 1); + return __req_capsule_get(pill, field, pill->rc_loc ^ 1, NULL); } EXPORT_SYMBOL(req_capsule_other_get); -void req_capsule_set_size(const struct req_capsule *pill, +void req_capsule_set_size(struct req_capsule *pill, const struct req_msg_field *field, enum req_location loc, int size) { - pill->rc_area[__req_capsule_offset(pill, field, loc)] = size; + LASSERT(loc == RCL_SERVER || loc == RCL_CLIENT); + + pill->rc_area[loc][__req_capsule_offset(pill, field, loc)] = size; } EXPORT_SYMBOL(req_capsule_set_size); +/* NB: this function doesn't correspond with req_capsule_set_size(), which + * actually sets the size in pill.rc_area[loc][offset], but this function + * returns the message buflen[offset], maybe we should use another name. + */ int req_capsule_get_size(const struct req_capsule *pill, const struct req_msg_field *field, enum req_location loc) @@ -1024,32 +1492,35 @@ int req_capsule_field_present(const struct req_capsule *pill, } EXPORT_SYMBOL(req_capsule_field_present); - -/* - * Shrink the specified reply message buffer @field to a specified @newlen. - * If @move_data is non-zero, then move following buffer backward - * if @newlen is zero; - * The internal offset should be adjusted by @adjust because buffer maybe has - * been moved by previous call. (@adjust >= 0) is a must. - * Return value: 1 if buffer has been moved, otherwise 0 is returned. - */ -int req_capsule_shrink(const struct req_capsule *pill, - const struct req_msg_field *field, - const unsigned int newlen, - const int adjust, - const int move_data) +void req_capsule_shrink(struct req_capsule *pill, + const struct req_msg_field *field, + unsigned int newlen, + enum req_location loc) { - int offset; + const struct req_format *fmt; + struct lustre_msg *msg; + int len; + int offset; - LASSERT(adjust >= 0); - LASSERT(req_capsule_has_field(pill, field, RCL_SERVER)); + fmt = pill->rc_fmt; + LASSERT(fmt != NULL); + LASSERT(__req_format_is_sane(fmt)); + LASSERT(req_capsule_has_field(pill, field, loc)); + LASSERT(req_capsule_field_present(pill, field, loc)); - offset = __req_capsule_offset(pill, field, RCL_SERVER); - offset -= adjust; - LASSERT(offset >= 1); + offset = __req_capsule_offset(pill, field, loc); - lustre_shrink_reply(pill->rc_req, offset, newlen, move_data); - return (newlen == 0) ? 1 : 0; + msg = __req_msg(pill, loc); + len = lustre_msg_buflen(msg, offset); + LASSERTF(newlen <= len, "%s:%s, oldlen=%d, newlen=%d\n", + fmt->rf_name, field->rmf_name, len, newlen); + + if (loc == RCL_CLIENT) + pill->rc_req->rq_reqlen = lustre_shrink_msg(msg, offset, newlen, + 1); + else + pill->rc_req->rq_replen = lustre_shrink_msg(msg, offset, newlen, + 1); } EXPORT_SYMBOL(req_capsule_shrink); diff --git a/lustre/ptlrpc/llog_client.c b/lustre/ptlrpc/llog_client.c index 27578a4..395d756 100644 --- a/lustre/ptlrpc/llog_client.c +++ b/lustre/ptlrpc/llog_client.c @@ -48,15 +48,11 @@ static int llog_client_create(struct llog_ctxt *ctxt, struct llog_handle **res, struct llog_logid *logid, char *name) { - struct obd_import *imp; - struct llogd_body req_body; - struct llogd_body *body; - struct llog_handle *handle; + struct obd_import *imp; + struct llogd_body *body; + struct llog_handle *handle; struct ptlrpc_request *req = NULL; - int size[3] = { sizeof(struct ptlrpc_body), sizeof(req_body) }; - char *bufs[3] = { NULL, (char*)&req_body }; - int bufcount = 2; - int rc; + int rc; ENTRY; if (ctxt->loc_imp == NULL) { @@ -73,42 +69,49 @@ static int llog_client_create(struct llog_ctxt *ctxt, struct llog_handle **res, RETURN(-ENOMEM); *res = handle; - memset(&req_body, 0, sizeof(req_body)); + req = ptlrpc_request_alloc(imp, &RQF_LLOG_ORIGIN_HANDLE_CREATE); + if (req == NULL) + GOTO(err_free, rc = -ENOMEM); + + if (name) + req_capsule_set_size(&req->rq_pill, &RMF_NAME, RCL_CLIENT, + strlen(name) + 1); + + rc = ptlrpc_request_pack(req, LUSTRE_LOG_VERSION, + LLOG_ORIGIN_HANDLE_CREATE); + if (rc) { + ptlrpc_request_free(req); + GOTO(err_free, rc); + } + ptlrpc_request_set_replen(req); + + body = req_capsule_client_get(&req->rq_pill, &RMF_LLOGD_BODY); if (logid) - req_body.lgd_logid = *logid; - req_body.lgd_ctxt_idx = ctxt->loc_idx - 1; + body->lgd_logid = *logid; + body->lgd_ctxt_idx = ctxt->loc_idx - 1; if (name) { - size[bufcount] = strlen(name) + 1; - bufs[bufcount] = name; - bufcount++; + char *tmp; + tmp = req_capsule_client_sized_get(&req->rq_pill, &RMF_NAME, + strlen(name) + 1); + LASSERT(tmp); + strcpy(tmp, name); } - req = ptlrpc_prep_req(imp, LUSTRE_LOG_VERSION, - LLOG_ORIGIN_HANDLE_CREATE, bufcount, size, bufs); - if (!req) - GOTO(err_free, rc = -ENOMEM); - - ptlrpc_req_set_repsize(req, 2, size); rc = ptlrpc_queue_wait(req); if (rc) GOTO(err_free, rc); - body = lustre_swab_repbuf(req, REPLY_REC_OFF, sizeof(*body), - lustre_swab_llogd_body); - if (body == NULL) { - CERROR ("Can't unpack llogd_body\n"); + body = req_capsule_server_get(&req->rq_pill, &RMF_LLOGD_BODY); + if (body == NULL) GOTO(err_free, rc =-EFAULT); - } handle->lgh_id = body->lgd_logid; handle->lgh_ctxt = ctxt; - + EXIT; out: - if (req) - ptlrpc_req_finished(req); - RETURN(rc); - + ptlrpc_req_finished(req); + return rc; err_free: llog_free_handle(handle); goto out; @@ -116,23 +119,23 @@ err_free: static int llog_client_destroy(struct llog_handle *loghandle) { - struct obd_import *imp = loghandle->lgh_ctxt->loc_imp; struct ptlrpc_request *req = NULL; - struct llogd_body *body; - int size[] = { sizeof(struct ptlrpc_body), sizeof(*body) }; - int rc; + struct llogd_body *body; + int rc; ENTRY; - req = ptlrpc_prep_req(imp, LUSTRE_LOG_VERSION, - LLOG_ORIGIN_HANDLE_DESTROY, 2, size, NULL); - if (!req) + req = ptlrpc_request_alloc_pack(loghandle->lgh_ctxt->loc_imp, + &RQF_LLOG_ORIGIN_HANDLE_DESTROY, + LUSTRE_LOG_VERSION, + LLOG_ORIGIN_HANDLE_DESTROY); + if (req == NULL) RETURN(-ENOMEM); - body = lustre_msg_buf(req->rq_reqmsg, REQ_REC_OFF, sizeof(*body)); + body = req_capsule_client_get(&req->rq_pill, &RMF_LLOGD_BODY); body->lgd_logid = loghandle->lgh_id; body->lgd_llh_flags = loghandle->lgh_hdr->llh_flags; - ptlrpc_req_set_repsize(req, 2, size); + ptlrpc_request_set_replen(req); rc = ptlrpc_queue_wait(req); ptlrpc_req_finished(req); @@ -144,20 +147,20 @@ static int llog_client_next_block(struct llog_handle *loghandle, int *cur_idx, int next_idx, __u64 *cur_offset, void *buf, int len) { - struct obd_import *imp = loghandle->lgh_ctxt->loc_imp; struct ptlrpc_request *req = NULL; - struct llogd_body *body; - void * ptr; - int size[3] = { sizeof(struct ptlrpc_body), sizeof(*body) }; - int rc; + struct llogd_body *body; + void *ptr; + int rc; ENTRY; - req = ptlrpc_prep_req(imp, LUSTRE_LOG_VERSION, - LLOG_ORIGIN_HANDLE_NEXT_BLOCK, 2, size, NULL); - if (!req) - GOTO(out, rc = -ENOMEM); + req = ptlrpc_request_alloc_pack(loghandle->lgh_ctxt->loc_imp, + &RQF_LLOG_ORIGIN_HANDLE_NEXT_BLOCK, + LUSTRE_LOG_VERSION, + LLOG_ORIGIN_HANDLE_NEXT_BLOCK); + if (req == NULL) + RETURN(-ENOMEM); - body = lustre_msg_buf(req->rq_reqmsg, REQ_REC_OFF, sizeof(*body)); + body = req_capsule_client_get(&req->rq_pill, &RMF_LLOGD_BODY); body->lgd_logid = loghandle->lgh_id; body->lgd_ctxt_idx = loghandle->lgh_ctxt->loc_idx - 1; body->lgd_llh_flags = loghandle->lgh_hdr->llh_flags; @@ -166,120 +169,105 @@ static int llog_client_next_block(struct llog_handle *loghandle, body->lgd_len = len; body->lgd_cur_offset = *cur_offset; - size[REPLY_REC_OFF + 1] = len; - ptlrpc_req_set_repsize(req, 3, size); + req_capsule_set_size(&req->rq_pill, &RMF_EADATA, RCL_SERVER, len); + ptlrpc_request_set_replen(req); rc = ptlrpc_queue_wait(req); if (rc) GOTO(out, rc); - body = lustre_swab_repbuf(req, REPLY_REC_OFF, sizeof(*body), - lustre_swab_llogd_body); - if (body == NULL) { - CERROR ("Can't unpack llogd_body\n"); + body = req_capsule_server_get(&req->rq_pill, &RMF_LLOGD_BODY); + if (body == NULL) GOTO(out, rc =-EFAULT); - } /* The log records are swabbed as they are processed */ - ptr = lustre_msg_buf(req->rq_repmsg, REPLY_REC_OFF + 1, len); - if (ptr == NULL) { - CERROR ("Can't unpack bitmap\n"); + ptr = req_capsule_server_get(&req->rq_pill, &RMF_EADATA); + if (ptr == NULL) GOTO(out, rc =-EFAULT); - } *cur_idx = body->lgd_saved_index; *cur_offset = body->lgd_cur_offset; memcpy(buf, ptr, len); - + EXIT; out: - if (req) - ptlrpc_req_finished(req); - RETURN(rc); + ptlrpc_req_finished(req); + return rc; } static int llog_client_prev_block(struct llog_handle *loghandle, int prev_idx, void *buf, int len) { - struct obd_import *imp = loghandle->lgh_ctxt->loc_imp; struct ptlrpc_request *req = NULL; - struct llogd_body *body; - void * ptr; - int size[3] = { sizeof(struct ptlrpc_body), sizeof(*body) }; - int rc; + struct llogd_body *body; + void *ptr; + int rc; ENTRY; - req = ptlrpc_prep_req(imp, LUSTRE_LOG_VERSION, - LLOG_ORIGIN_HANDLE_PREV_BLOCK, 2, size, NULL); - if (!req) - GOTO(out, rc = -ENOMEM); + req = ptlrpc_request_alloc_pack(loghandle->lgh_ctxt->loc_imp, + &RQF_LLOG_ORIGIN_HANDLE_PREV_BLOCK, + LUSTRE_LOG_VERSION, + LLOG_ORIGIN_HANDLE_PREV_BLOCK); + if (req == NULL) + RETURN(-ENOMEM); - body = lustre_msg_buf(req->rq_reqmsg, REQ_REC_OFF, sizeof(*body)); + body = req_capsule_client_get(&req->rq_pill, &RMF_LLOGD_BODY); body->lgd_logid = loghandle->lgh_id; body->lgd_ctxt_idx = loghandle->lgh_ctxt->loc_idx - 1; body->lgd_llh_flags = loghandle->lgh_hdr->llh_flags; body->lgd_index = prev_idx; body->lgd_len = len; - size[REPLY_REC_OFF + 1] = len; - ptlrpc_req_set_repsize(req, 3, size); + req_capsule_set_size(&req->rq_pill, &RMF_EADATA, RCL_SERVER, len); + ptlrpc_request_set_replen(req); + rc = ptlrpc_queue_wait(req); if (rc) GOTO(out, rc); - body = lustre_swab_repbuf(req, REPLY_REC_OFF, sizeof(*body), - lustre_swab_llogd_body); - if (body == NULL) { - CERROR ("Can't unpack llogd_body\n"); + body = req_capsule_server_get(&req->rq_pill, &RMF_LLOGD_BODY); + if (body == NULL) GOTO(out, rc =-EFAULT); - } - ptr = lustre_msg_buf(req->rq_repmsg, REPLY_REC_OFF + 1, len); - if (ptr == NULL) { - CERROR ("Can't unpack bitmap\n"); + ptr = req_capsule_server_get(&req->rq_pill, &RMF_EADATA); + if (ptr == NULL) GOTO(out, rc =-EFAULT); - } memcpy(buf, ptr, len); - + EXIT; out: - if (req) - ptlrpc_req_finished(req); - RETURN(rc); + ptlrpc_req_finished(req); + return rc; } static int llog_client_read_header(struct llog_handle *handle) { - struct obd_import *imp = handle->lgh_ctxt->loc_imp; struct ptlrpc_request *req = NULL; - struct llogd_body *body; - struct llog_log_hdr *hdr; - struct llog_rec_hdr *llh_hdr; - int size[2] = { sizeof(struct ptlrpc_body), sizeof(*body) }; - int repsize[2] = { sizeof(struct ptlrpc_body), sizeof(*hdr) }; - int rc; + struct llogd_body *body; + struct llog_log_hdr *hdr; + struct llog_rec_hdr *llh_hdr; + int rc; ENTRY; - req = ptlrpc_prep_req(imp, LUSTRE_LOG_VERSION, - LLOG_ORIGIN_HANDLE_READ_HEADER, 2, size, NULL); - if (!req) - GOTO(out, rc = -ENOMEM); + req = ptlrpc_request_alloc_pack(handle->lgh_ctxt->loc_imp, + &RQF_LLOG_ORIGIN_HANDLE_READ_HEADER, + LUSTRE_LOG_VERSION, + LLOG_ORIGIN_HANDLE_READ_HEADER); + if (req == NULL) + RETURN(-ENOMEM); - body = lustre_msg_buf(req->rq_reqmsg, REQ_REC_OFF, sizeof(*body)); + body = req_capsule_client_get(&req->rq_pill, &RMF_LLOGD_BODY); body->lgd_logid = handle->lgh_id; body->lgd_ctxt_idx = handle->lgh_ctxt->loc_idx - 1; body->lgd_llh_flags = handle->lgh_hdr->llh_flags; - ptlrpc_req_set_repsize(req, 2, repsize); + ptlrpc_request_set_replen(req); rc = ptlrpc_queue_wait(req); if (rc) GOTO(out, rc); - hdr = lustre_swab_repbuf(req, REPLY_REC_OFF, sizeof(*hdr), - lustre_swab_llog_hdr); - if (hdr == NULL) { - CERROR ("Can't unpack llog_hdr\n"); + hdr = req_capsule_server_get(&req->rq_pill, &RMF_LLOG_LOG_HDR); + if (hdr == NULL) GOTO(out, rc =-EFAULT); - } memcpy(handle->lgh_hdr, hdr, sizeof (*hdr)); handle->lgh_last_idx = handle->lgh_hdr->llh_tail.lrt_index; @@ -297,11 +285,10 @@ static int llog_client_read_header(struct llog_handle *handle) CERROR("you may need to re-run lconf --write_conf.\n"); rc = -EIO; } - + EXIT; out: - if (req) - ptlrpc_req_finished(req); - RETURN(rc); + ptlrpc_req_finished(req); + return rc; } static int llog_client_close(struct llog_handle *handle) diff --git a/lustre/ptlrpc/llog_net.c b/lustre/ptlrpc/llog_net.c index 8702071..492f390 100644 --- a/lustre/ptlrpc/llog_net.c +++ b/lustre/ptlrpc/llog_net.c @@ -51,13 +51,10 @@ int llog_origin_connect(struct llog_ctxt *ctxt, int count, struct llog_logid *logid, struct llog_gen *gen, struct obd_uuid *uuid) { - struct llog_gen_rec *lgr; - struct obd_import *imp; - struct ptlrpc_request *request; + struct llog_gen_rec *lgr; + struct ptlrpc_request *req; struct llogd_conn_body *req_body; - int size[2] = { sizeof(struct ptlrpc_body), - sizeof(struct llogd_conn_body) }; - int rc; + int rc; ENTRY; if (list_empty(&ctxt->loc_handle->u.chd.chd_head)) { @@ -69,35 +66,32 @@ int llog_origin_connect(struct llog_ctxt *ctxt, int count, LLOG_GEN_INC(ctxt->loc_gen); /* first add llog_gen_rec */ - OBD_ALLOC(lgr, sizeof(*lgr)); + OBD_ALLOC_PTR(lgr); if (!lgr) RETURN(-ENOMEM); lgr->lgr_hdr.lrh_len = lgr->lgr_tail.lrt_len = sizeof(*lgr); lgr->lgr_hdr.lrh_type = LLOG_GEN_REC; lgr->lgr_gen = ctxt->loc_gen; rc = llog_add(ctxt, &lgr->lgr_hdr, NULL, NULL, 1); - OBD_FREE(lgr, sizeof(*lgr)); + OBD_FREE_PTR(lgr); if (rc != 1) RETURN(rc); LASSERT(ctxt->loc_imp); - imp = ctxt->loc_imp; - - request = ptlrpc_prep_req(imp, LUSTRE_LOG_VERSION, - LLOG_ORIGIN_CONNECT, 2, size, NULL); - if (!request) + req = ptlrpc_request_alloc_pack(ctxt->loc_imp, &RQF_LLOG_ORIGIN_CONNECT, + LUSTRE_LOG_VERSION, + LLOG_ORIGIN_CONNECT); + if (req == NULL) RETURN(-ENOMEM); - req_body = lustre_msg_buf(request->rq_reqmsg, REQ_REC_OFF, - sizeof(*req_body)); - + req_body = req_capsule_client_get(&req->rq_pill, &RMF_LLOGD_CONN_BODY); req_body->lgdc_gen = ctxt->loc_gen; req_body->lgdc_logid = ctxt->loc_handle->lgh_id; req_body->lgdc_ctxt_idx = ctxt->loc_idx + 1; - ptlrpc_req_set_repsize(request, 1, NULL); + ptlrpc_request_set_replen(req); - rc = ptlrpc_queue_wait(request); - ptlrpc_req_finished(request); + rc = ptlrpc_queue_wait(req); + ptlrpc_req_finished(req); RETURN(rc); } @@ -111,8 +105,7 @@ int llog_handle_connect(struct ptlrpc_request *req) int rc; ENTRY; - req_body = lustre_msg_buf(req->rq_reqmsg, REQ_REC_OFF, - sizeof(*req_body)); + req_body = req_capsule_client_get(&req->rq_pill, &RMF_LLOGD_CONN_BODY); ctxt = llog_get_context(obd, req_body->lgdc_ctxt_idx); rc = llog_connect(ctxt, 1, &req_body->lgdc_logid, diff --git a/lustre/ptlrpc/llog_server.c b/lustre/ptlrpc/llog_server.c index b06c2f6..4ae01cf 100644 --- a/lustre/ptlrpc/llog_server.c +++ b/lustre/ptlrpc/llog_server.c @@ -46,35 +46,29 @@ int llog_origin_handle_create(struct ptlrpc_request *req) { - struct obd_export *exp = req->rq_export; - struct obd_device *obd = exp->exp_obd; - struct obd_device *disk_obd; - struct llog_handle *loghandle; - struct llogd_body *body; - struct lvfs_run_ctxt saved; - struct llog_logid *logid = NULL; - struct llog_ctxt *ctxt; - char * name = NULL; - int size[2] = { sizeof(struct ptlrpc_body), sizeof(*body) }; - int rc, rc2; + struct obd_export *exp = req->rq_export; + struct obd_device *obd = exp->exp_obd; + struct obd_device *disk_obd; + struct llog_handle *loghandle; + struct llogd_body *body; + struct lvfs_run_ctxt saved; + struct llog_logid *logid = NULL; + struct llog_ctxt *ctxt; + char *name = NULL; + int rc, rc2; ENTRY; - body = lustre_swab_reqbuf(req, REQ_REC_OFF, sizeof(*body), - lustre_swab_llogd_body); - if (body == NULL) { - CERROR ("Can't unpack llogd_body\n"); + body = req_capsule_client_get(&req->rq_pill, &RMF_LLOGD_BODY); + if (body == NULL) GOTO(out, rc =-EFAULT); - } if (body->lgd_logid.lgl_oid > 0) logid = &body->lgd_logid; - if (lustre_msg_bufcount(req->rq_reqmsg) > 2) { - name = lustre_msg_string(req->rq_reqmsg, REQ_REC_OFF + 1, 0); - if (name == NULL) { - CERROR("Can't unpack name\n"); + if (req_capsule_field_present(&req->rq_pill, &RMF_NAME, RCL_CLIENT)) { + name = req_capsule_client_get(&req->rq_pill, &RMF_NAME); + if (name == NULL) GOTO(out, rc = -EFAULT); - } CDEBUG(D_INFO, "opening log %s\n", name); } @@ -88,11 +82,11 @@ int llog_origin_handle_create(struct ptlrpc_request *req) if (rc) GOTO(out_pop, rc); - rc = lustre_pack_reply(req, 2, size, NULL); + rc = req_capsule_server_pack(&req->rq_pill); if (rc) GOTO(out_close, rc = -ENOMEM); - body = lustre_msg_buf(req->rq_repmsg, REPLY_REC_OFF, sizeof(*body)); + body = req_capsule_server_get(&req->rq_pill, &RMF_LLOGD_BODY); body->lgd_logid = loghandle->lgh_id; out_close: @@ -107,25 +101,21 @@ out: int llog_origin_handle_destroy(struct ptlrpc_request *req) { - struct obd_export *exp = req->rq_export; - struct obd_device *obd = exp->exp_obd; - struct obd_device *disk_obd; - struct llog_handle *loghandle; - struct llogd_body *body; - struct lvfs_run_ctxt saved; - struct llog_logid *logid = NULL; - struct llog_ctxt *ctxt; - int size[] = { sizeof(struct ptlrpc_body), sizeof(*body) }; - int rc; - __u32 flags; + struct obd_export *exp = req->rq_export; + struct obd_device *obd = exp->exp_obd; + struct obd_device *disk_obd; + struct llog_handle *loghandle; + struct llogd_body *body; + struct lvfs_run_ctxt saved; + struct llog_logid *logid = NULL; + struct llog_ctxt *ctxt; + __u32 flags; + int rc; ENTRY; - body = lustre_swab_reqbuf(req, REQ_REC_OFF, sizeof(*body), - lustre_swab_llogd_body); - if (body == NULL) { - CERROR ("Can't unpack llogd_body\n"); + body = req_capsule_client_get(&req->rq_pill, &RMF_LLOGD_BODY); + if (body == NULL) GOTO(out, rc =-EFAULT); - } if (body->lgd_logid.lgl_oid > 0) logid = &body->lgd_logid; @@ -140,11 +130,11 @@ int llog_origin_handle_destroy(struct ptlrpc_request *req) if (rc) GOTO(out_pop, rc); - rc = lustre_pack_reply(req, 2, size, NULL); + rc = req_capsule_server_pack(&req->rq_pill); if (rc) GOTO(out_close, rc = -ENOMEM); - body = lustre_msg_buf(req->rq_repmsg, REPLY_REC_OFF, sizeof (*body)); + body = req_capsule_server_get(&req->rq_pill, &RMF_LLOGD_BODY); body->lgd_logid = loghandle->lgh_id; flags = body->lgd_llh_flags; rc = llog_init_handle(loghandle, LLOG_F_IS_PLAIN, NULL); @@ -166,28 +156,23 @@ out: int llog_origin_handle_next_block(struct ptlrpc_request *req) { - struct obd_export *exp = req->rq_export; - struct obd_device *obd = exp->exp_obd; - struct obd_device *disk_obd; + struct obd_export *exp = req->rq_export; + struct obd_device *obd = exp->exp_obd; + struct obd_device *disk_obd; struct llog_handle *loghandle; - struct llogd_body *body; + struct llogd_body *body; + struct llogd_body *repbody; struct lvfs_run_ctxt saved; - struct llog_ctxt *ctxt; - __u32 flags; - __u8 *buf; - void * ptr; - int size[3] = { sizeof(struct ptlrpc_body), - sizeof(*body), - LLOG_CHUNK_SIZE }; - int rc, rc2; + struct llog_ctxt *ctxt; + __u32 flags; + __u8 *buf; + void *ptr; + int rc, rc2; ENTRY; - body = lustre_swab_reqbuf(req, REQ_REC_OFF, sizeof(*body), - lustre_swab_llogd_body); - if (body == NULL) { - CERROR ("Can't unpack llogd_body\n"); + body = req_capsule_client_get(&req->rq_pill, &RMF_LLOGD_BODY); + if (body == NULL) GOTO(out, rc =-EFAULT); - } OBD_ALLOC(buf, LLOG_CHUNK_SIZE); if (!buf) @@ -215,15 +200,16 @@ int llog_origin_handle_next_block(struct ptlrpc_request *req) if (rc) GOTO(out_close, rc); - - rc = lustre_pack_reply(req, 3, size, NULL); + req_capsule_set_size(&req->rq_pill, &RMF_EADATA, RCL_SERVER, + LLOG_CHUNK_SIZE); + rc = req_capsule_server_pack(&req->rq_pill); if (rc) GOTO(out_close, rc = -ENOMEM); - ptr = lustre_msg_buf(req->rq_repmsg, REPLY_REC_OFF, sizeof (body)); - memcpy(ptr, body, sizeof(*body)); + repbody = req_capsule_server_get(&req->rq_pill, &RMF_LLOGD_BODY); + *repbody = *body; - ptr = lustre_msg_buf(req->rq_repmsg, REPLY_REC_OFF + 1, LLOG_CHUNK_SIZE); + ptr = req_capsule_server_get(&req->rq_pill, &RMF_EADATA); memcpy(ptr, buf, LLOG_CHUNK_SIZE); out_close: @@ -241,28 +227,23 @@ out: int llog_origin_handle_prev_block(struct ptlrpc_request *req) { - struct obd_export *exp = req->rq_export; - struct obd_device *obd = exp->exp_obd; - struct llog_handle *loghandle; - struct llogd_body *body; - struct obd_device *disk_obd; - struct lvfs_run_ctxt saved; - struct llog_ctxt *ctxt; - __u32 flags; - __u8 *buf; - void * ptr; - int size[] = { sizeof(struct ptlrpc_body), - sizeof(*body), - LLOG_CHUNK_SIZE }; - int rc, rc2; + struct obd_export *exp = req->rq_export; + struct obd_device *obd = exp->exp_obd; + struct llog_handle *loghandle; + struct llogd_body *body; + struct llogd_body *repbody; + struct obd_device *disk_obd; + struct lvfs_run_ctxt saved; + struct llog_ctxt *ctxt; + __u32 flags; + __u8 *buf; + void *ptr; + int rc, rc2; ENTRY; - body = lustre_swab_reqbuf(req, REQ_REC_OFF, sizeof(*body), - lustre_swab_llogd_body); - if (body == NULL) { - CERROR ("Can't unpack llogd_body\n"); + body = req_capsule_client_get(&req->rq_pill, &RMF_LLOGD_BODY); + if (body == NULL) GOTO(out, rc =-EFAULT); - } OBD_ALLOC(buf, LLOG_CHUNK_SIZE); if (!buf) @@ -288,15 +269,16 @@ int llog_origin_handle_prev_block(struct ptlrpc_request *req) if (rc) GOTO(out_close, rc); - - rc = lustre_pack_reply(req, 3, size, NULL); + req_capsule_set_size(&req->rq_pill, &RMF_EADATA, RCL_SERVER, + LLOG_CHUNK_SIZE); + rc = req_capsule_server_pack(&req->rq_pill); if (rc) GOTO(out_close, rc = -ENOMEM); - ptr = lustre_msg_buf(req->rq_repmsg, REPLY_REC_OFF, sizeof(body)); - memcpy(ptr, body, sizeof(*body)); + repbody = req_capsule_server_get(&req->rq_pill, &RMF_LLOGD_BODY); + *repbody = *body; - ptr = lustre_msg_buf(req->rq_repmsg, REPLY_REC_OFF+1, LLOG_CHUNK_SIZE); + ptr = req_capsule_server_get(&req->rq_pill, &RMF_EADATA); memcpy(ptr, buf, LLOG_CHUNK_SIZE); out_close: @@ -313,25 +295,21 @@ out: int llog_origin_handle_read_header(struct ptlrpc_request *req) { - struct obd_export *exp = req->rq_export; - struct obd_device *obd = exp->exp_obd; - struct obd_device *disk_obd; - struct llog_handle *loghandle; - struct llogd_body *body; - struct llog_log_hdr *hdr; - struct lvfs_run_ctxt saved; - struct llog_ctxt *ctxt; - __u32 flags; - int size[2] = { sizeof(struct ptlrpc_body), sizeof(*hdr) }; - int rc, rc2; + struct obd_export *exp = req->rq_export; + struct obd_device *obd = exp->exp_obd; + struct obd_device *disk_obd; + struct llog_handle *loghandle; + struct llogd_body *body; + struct llog_log_hdr *hdr; + struct lvfs_run_ctxt saved; + struct llog_ctxt *ctxt; + __u32 flags; + int rc, rc2; ENTRY; - body = lustre_swab_reqbuf(req, REQ_REC_OFF, sizeof(*body), - lustre_swab_llogd_body); - if (body == NULL) { - CERROR ("Can't unpack llogd_body\n"); + body = req_capsule_client_get(&req->rq_pill, &RMF_LLOGD_BODY); + if (body == NULL) GOTO(out, rc =-EFAULT); - } ctxt = llog_get_context(obd, body->lgd_ctxt_idx); if (ctxt == NULL) @@ -349,12 +327,12 @@ int llog_origin_handle_read_header(struct ptlrpc_request *req) if (rc) GOTO(out_close, rc); - rc = lustre_pack_reply(req, 2, size, NULL); + rc = req_capsule_server_pack(&req->rq_pill); if (rc) GOTO(out_close, rc = -ENOMEM); - hdr = lustre_msg_buf(req->rq_repmsg, REPLY_REC_OFF, sizeof(*hdr)); - memcpy(hdr, loghandle->lgh_hdr, sizeof(*hdr)); + hdr = req_capsule_server_get(&req->rq_pill, &RMF_LLOG_LOG_HDR); + *hdr = *loghandle->lgh_hdr; out_close: rc2 = llog_close(loghandle); @@ -390,10 +368,9 @@ int llog_origin_handle_cancel(struct ptlrpc_request *req) void *handle; ENTRY; - logcookies = lustre_msg_buf(req->rq_reqmsg, REQ_REC_OFF, - sizeof(*logcookies)); - num_cookies = lustre_msg_buflen(req->rq_reqmsg, REQ_REC_OFF) / - sizeof(*logcookies); + logcookies = req_capsule_client_get(&req->rq_pill, &RMF_LOGCOOKIES); + num_cookies = req_capsule_get_size(&req->rq_pill, &RMF_LOGCOOKIES, + RCL_CLIENT) / sizeof(*logcookies); if (logcookies == NULL || num_cookies == 0) { DEBUG_REQ(D_HA, req, "no cookies sent"); RETURN(-EFAULT); @@ -443,13 +420,13 @@ EXPORT_SYMBOL(llog_origin_handle_cancel); static int llog_catinfo_config(struct obd_device *obd, char *buf, int buf_len, char *client) { - struct mds_obd *mds = &obd->u.mds; - struct llog_ctxt *ctxt = llog_get_context(obd, LLOG_CONFIG_ORIG_CTXT); - struct lvfs_run_ctxt saved; - struct llog_handle *handle = NULL; - char name[4][64]; - int rc, i, l, remains = buf_len; - char *out = buf; + struct mds_obd *mds = &obd->u.mds; + struct llog_ctxt *ctxt = llog_get_context(obd, LLOG_CONFIG_ORIG_CTXT); + struct lvfs_run_ctxt saved; + struct llog_handle *handle = NULL; + char name[4][64]; + int rc, i, l, remains = buf_len; + char *out = buf; if (ctxt == NULL || mds == NULL) RETURN(-EOPNOTSUPP); @@ -567,9 +544,9 @@ static int llog_catinfo_deletions(struct obd_device *obd, char *buf, struct llog_catid *idarray; struct llog_logid *id; char name[32] = CATLIST; - int rc; struct cb_data data; struct llog_ctxt *ctxt = llog_get_context(obd, LLOG_CONFIG_ORIG_CTXT); + int rc; if (ctxt == NULL || mds == NULL) RETURN(-EOPNOTSUPP); @@ -633,39 +610,43 @@ int llog_catinfo(struct ptlrpc_request *req) { struct obd_export *exp = req->rq_export; struct obd_device *obd = exp->exp_obd; - char *keyword; - char *buf, *reply; - int rc, buf_len = LLOG_CHUNK_SIZE; - int size[2] = { sizeof(struct ptlrpc_body), buf_len }; + char *keyword; + char *buf, *reply; + int rc; - OBD_ALLOC(buf, buf_len); + OBD_ALLOC(buf, LLOG_CHUNK_SIZE); if (buf == NULL) return -ENOMEM; - memset(buf, 0, buf_len); + memset(buf, 0, LLOG_CHUNK_SIZE); - keyword = lustre_msg_string(req->rq_reqmsg, REQ_REC_OFF, 0); + keyword = req_capsule_client_get(&req->rq_pill, &RMF_NAME); + LASSERT(keyword); if (strcmp(keyword, "config") == 0) { - char *client = lustre_msg_string(req->rq_reqmsg, - REQ_REC_OFF + 1, 0); - rc = llog_catinfo_config(obd, buf, buf_len, client); + char *client = req_capsule_client_get(&req->rq_pill, + &RMF_STRING); + + LASSERT(client); + rc = llog_catinfo_config(obd, buf, LLOG_CHUNK_SIZE, client); } else if (strcmp(keyword, "deletions") == 0) { - rc = llog_catinfo_deletions(obd, buf, buf_len); + rc = llog_catinfo_deletions(obd, buf, LLOG_CHUNK_SIZE); } else { rc = -EOPNOTSUPP; } - rc = lustre_pack_reply(req, 2, size, NULL); + req_capsule_set_size(&req->rq_pill, &RMF_STRING, RCL_SERVER, + LLOG_CHUNK_SIZE); + rc = req_capsule_server_pack(&req->rq_pill); if (rc) GOTO(out_free, rc = -ENOMEM); - reply = lustre_msg_buf(req->rq_repmsg, REPLY_REC_OFF, buf_len); + reply = req_capsule_server_get(&req->rq_pill, &RMF_STRING); if (strlen(buf) == 0) sprintf(buf, "%s", "No log informations\n"); - memcpy(reply, buf, buf_len); + memcpy(reply, buf, LLOG_CHUNK_SIZE); out_free: - OBD_FREE(buf, buf_len); + OBD_FREE(buf, LLOG_CHUNK_SIZE); return rc; } diff --git a/lustre/ptlrpc/lproc_ptlrpc.c b/lustre/ptlrpc/lproc_ptlrpc.c index ede3bc8..e4ffb22 100644 --- a/lustre/ptlrpc/lproc_ptlrpc.c +++ b/lustre/ptlrpc/lproc_ptlrpc.c @@ -548,19 +548,20 @@ EXPORT_SYMBOL(lprocfs_wr_evict_client); int lprocfs_wr_ping(struct file *file, const char *buffer, unsigned long count, void *data) { - struct obd_device *obd = data; + struct obd_device *obd = data; struct ptlrpc_request *req; - int rc; + int rc; ENTRY; LPROCFS_CLIMP_CHECK(obd); - req = ptlrpc_prep_req(obd->u.cli.cl_import, LUSTRE_OBD_VERSION, - OBD_PING, 1, NULL, NULL); + req = ptlrpc_request_alloc_pack(obd->u.cli.cl_import, &RQF_OBD_PING, + LUSTRE_OBD_VERSION, OBD_PING); + LPROCFS_CLIMP_EXIT(obd); if (req == NULL) RETURN(-ENOMEM); - ptlrpc_req_set_repsize(req, 1, NULL); + ptlrpc_request_set_replen(req); req->rq_send_state = LUSTRE_IMP_FULL; req->rq_no_resend = 1; diff --git a/lustre/ptlrpc/pack_generic.c b/lustre/ptlrpc/pack_generic.c index c59a312..e49eaa5 100644 --- a/lustre/ptlrpc/pack_generic.c +++ b/lustre/ptlrpc/pack_generic.c @@ -576,13 +576,6 @@ int lustre_shrink_msg_v2(struct lustre_msg_v2 *msg, int segment, if (newpos != tail) memcpy(newpos, tail, tail_len); } - - if (newlen == 0 && msg->lm_bufcount > segment + 1) { - memmove(&msg->lm_buflens[segment], &msg->lm_buflens[segment + 1], - (msg->lm_bufcount - segment - 1) * sizeof(__u32)); - msg->lm_buflens[msg->lm_bufcount - 1] = 0; - } - out: return lustre_msg_size_v2(msg->lm_bufcount, (int *)msg->lm_buflens); } @@ -1663,6 +1656,23 @@ void lustre_msg_set_conn_cnt(struct lustre_msg *msg, __u32 conn_cnt) } } +void ptlrpc_request_set_replen(struct ptlrpc_request *req) +{ + int count = req_capsule_filled_sizes(&req->rq_pill, RCL_SERVER); + + req->rq_replen = lustre_msg_size(req->rq_reqmsg->lm_magic, count, + req->rq_pill.rc_area[RCL_SERVER]); + if (req->rq_reqmsg->lm_magic == LUSTRE_MSG_MAGIC_V2) + req->rq_reqmsg->lm_repsize = req->rq_replen; +} + +void ptlrpc_req_set_repsize(struct ptlrpc_request *req, int count, int *lens) +{ + req->rq_replen = lustre_msg_size(req->rq_reqmsg->lm_magic, count, lens); + if (req->rq_reqmsg->lm_magic == LUSTRE_MSG_MAGIC_V2) + req->rq_reqmsg->lm_repsize = req->rq_replen; +} + /* byte flipping routines for all wire types declared in * lustre_idl.h implemented here. */ @@ -1833,6 +1843,7 @@ void lustre_swab_mdt_body (struct mdt_body *b) __swab64s (&b->ctime); __swab64s (&b->blocks); __swab64s (&b->ioepoch); + __swab64s (&b->ino); __swab32s (&b->fsuid); __swab32s (&b->fsgid); __swab32s (&b->capability); @@ -1842,11 +1853,13 @@ void lustre_swab_mdt_body (struct mdt_body *b) __swab32s (&b->flags); __swab32s (&b->rdev); __swab32s (&b->nlink); + __swab32s (&b->generation); __swab32s (&b->suppgid); __swab32s (&b->eadatasize); __swab32s (&b->aclsize); __swab32s (&b->max_mdsize); __swab32s (&b->max_cookiesize); + __swab32s (&b->padding_4); } void lustre_swab_mdt_epoch (struct mdt_epoch *b) @@ -1940,27 +1953,6 @@ void lustre_swab_mds_rec_setattr (struct mds_rec_setattr *sa) CLASSERT(offsetof(typeof(*sa), sa_padding) != 0); } -void lustre_swab_mdt_rec_setattr (struct mdt_rec_setattr *sa) -{ - __swab32s (&sa->sa_opcode); - __swab32s (&sa->sa_fsuid); - __swab32s (&sa->sa_fsgid); - __swab32s (&sa->sa_cap); - __swab32s (&sa->sa_suppgid); - __swab32s (&sa->sa_mode); - lustre_swab_lu_fid (&sa->sa_fid); - __swab64s (&sa->sa_valid); - __swab64s (&sa->sa_size); - __swab64s (&sa->sa_blocks); - __swab64s (&sa->sa_mtime); - __swab64s (&sa->sa_atime); - __swab64s (&sa->sa_ctime); - __swab32s (&sa->sa_uid); - __swab32s (&sa->sa_gid); - __swab32s (&sa->sa_attr_flags); - CLASSERT(offsetof(typeof(*sa), sa_padding) != 0); -} - void lustre_swab_mds_rec_join (struct mds_rec_join *jr) { __swab64s(&jr->jr_headsize); @@ -1993,26 +1985,6 @@ void lustre_swab_mds_rec_create (struct mds_rec_create *cr) CLASSERT(offsetof(typeof(*cr), cr_padding_5) != 0); } -void lustre_swab_mdt_rec_create (struct mdt_rec_create *cr) -{ - __swab32s (&cr->cr_opcode); - __swab32s (&cr->cr_fsuid); - __swab32s (&cr->cr_fsgid); - __swab32s (&cr->cr_cap); - __swab32s (&cr->cr_flags); /* for use with open */ - __swab32s (&cr->cr_mode); - /* handle is opaque */ - lustre_swab_lu_fid (&cr->cr_fid1); - lustre_swab_lu_fid (&cr->cr_fid2); - __swab64s (&cr->cr_time); - __swab64s (&cr->cr_rdev); - __swab64s (&cr->cr_ioepoch); - __swab32s (&cr->cr_suppgid1); - __swab32s (&cr->cr_suppgid2); - __swab32s (&cr->cr_bias); - CLASSERT(offsetof(typeof(*cr), cr_padding_1) != 0); -} - void lustre_swab_mds_rec_link (struct mds_rec_link *lk) { __swab32s (&lk->lk_opcode); @@ -2030,23 +2002,6 @@ void lustre_swab_mds_rec_link (struct mds_rec_link *lk) CLASSERT(offsetof(typeof(*lk), lk_padding_4) != 0); } -void lustre_swab_mdt_rec_link (struct mdt_rec_link *lk) -{ - __swab32s (&lk->lk_opcode); - __swab32s (&lk->lk_fsuid); - __swab32s (&lk->lk_fsgid); - __swab32s (&lk->lk_cap); - __swab32s (&lk->lk_suppgid1); - __swab32s (&lk->lk_suppgid2); - lustre_swab_lu_fid (&lk->lk_fid1); - lustre_swab_lu_fid (&lk->lk_fid2); - __swab64s (&lk->lk_time); - __swab32s (&lk->lk_bias); - CLASSERT(offsetof(typeof(*lk), lk_padding_2) != 0); - CLASSERT(offsetof(typeof(*lk), lk_padding_3) != 0); - CLASSERT(offsetof(typeof(*lk), lk_padding_4) != 0); -} - void lustre_swab_mds_rec_unlink (struct mds_rec_unlink *ul) { __swab32s (&ul->ul_opcode); @@ -2064,23 +2019,6 @@ void lustre_swab_mds_rec_unlink (struct mds_rec_unlink *ul) CLASSERT(offsetof(typeof(*ul), ul_padding_4) != 0); } -void lustre_swab_mdt_rec_unlink (struct mdt_rec_unlink *ul) -{ - __swab32s (&ul->ul_opcode); - __swab32s (&ul->ul_fsuid); - __swab32s (&ul->ul_fsgid); - __swab32s (&ul->ul_cap); - __swab32s (&ul->ul_suppgid); - __swab32s (&ul->ul_mode); - lustre_swab_lu_fid (&ul->ul_fid1); - lustre_swab_lu_fid (&ul->ul_fid2); - __swab64s (&ul->ul_time); - __swab32s (&ul->ul_bias); - CLASSERT(offsetof(typeof(*ul), ul_padding_2) != 0); - CLASSERT(offsetof(typeof(*ul), ul_padding_3) != 0); - CLASSERT(offsetof(typeof(*ul), ul_padding_4) != 0); -} - void lustre_swab_mds_rec_rename (struct mds_rec_rename *rn) { __swab32s (&rn->rn_opcode); @@ -2098,22 +2036,34 @@ void lustre_swab_mds_rec_rename (struct mds_rec_rename *rn) CLASSERT(offsetof(typeof(*rn), rn_padding_4) != 0); } -void lustre_swab_mdt_rec_rename (struct mdt_rec_rename *rn) +void lustre_swab_mdt_rec_reint (struct mdt_rec_reint *rr) { - __swab32s (&rn->rn_opcode); - __swab32s (&rn->rn_fsuid); - __swab32s (&rn->rn_fsgid); - __swab32s (&rn->rn_cap); - __swab32s (&rn->rn_suppgid1); - __swab32s (&rn->rn_suppgid2); - lustre_swab_lu_fid (&rn->rn_fid1); - lustre_swab_lu_fid (&rn->rn_fid2); - __swab64s (&rn->rn_time); - __swab32s (&rn->rn_mode); - __swab32s (&rn->rn_bias); - CLASSERT(offsetof(typeof(*rn), rn_padding_3) != 0); - CLASSERT(offsetof(typeof(*rn), rn_padding_4) != 0); -} + __swab32s (&rr->rr_opcode); + __swab32s (&rr->rr_fsuid); + __swab32s (&rr->rr_fsgid); + __swab32s (&rr->rr_cap); + __swab32s (&rr->rr_suppgid1); + __swab32s (&rr->rr_suppgid2); + /* handle is opaque */ + lustre_swab_lu_fid (&rr->rr_fid1); + lustre_swab_lu_fid (&rr->rr_fid2); + __swab64s (&rr->rr_mtime); + __swab64s (&rr->rr_atime); + __swab64s (&rr->rr_ctime); + __swab64s (&rr->rr_size); + __swab64s (&rr->rr_blocks); + __swab32s (&rr->rr_bias); + __swab32s (&rr->rr_mode); + __swab32s (&rr->rr_padding_1); + __swab32s (&rr->rr_padding_2); + __swab32s (&rr->rr_padding_3); + __swab32s (&rr->rr_padding_4); + + CLASSERT(offsetof(typeof(*rr), rr_padding_1) != 0); + CLASSERT(offsetof(typeof(*rr), rr_padding_2) != 0); + CLASSERT(offsetof(typeof(*rr), rr_padding_3) != 0); + CLASSERT(offsetof(typeof(*rr), rr_padding_4) != 0); +}; void lustre_swab_lov_desc (struct lov_desc *ld) { diff --git a/lustre/ptlrpc/pinger.c b/lustre/ptlrpc/pinger.c index d4f969a..ab5647f 100644 --- a/lustre/ptlrpc/pinger.c +++ b/lustre/ptlrpc/pinger.c @@ -42,26 +42,25 @@ static struct list_head pinger_imports = CFS_LIST_HEAD_INIT(pinger_imports); int ptlrpc_ping(struct obd_import *imp) { struct ptlrpc_request *req; - int rc = 0; ENTRY; - req = ptlrpc_prep_req(imp, LUSTRE_OBD_VERSION, OBD_PING, 1, NULL, NULL); - if (req) { - DEBUG_REQ(D_INFO, req, "pinging %s->%s", - imp->imp_obd->obd_uuid.uuid, - obd2cli_tgt(imp->imp_obd)); - req->rq_no_resend = req->rq_no_delay = 1; - ptlrpc_req_set_repsize(req, 1, NULL); - req->rq_timeout = PING_INTERVAL; - ptlrpcd_add_req(req); - } else { + req = ptlrpc_request_alloc_pack(imp, &RQF_OBD_PING, LUSTRE_OBD_VERSION, + OBD_PING); + if (req == NULL) { CERROR("OOM trying to ping %s->%s\n", imp->imp_obd->obd_uuid.uuid, obd2cli_tgt(imp->imp_obd)); - rc = -ENOMEM; + RETURN(-ENOMEM); } - RETURN(rc); + DEBUG_REQ(D_INFO, req, "pinging %s->%s", + imp->imp_obd->obd_uuid.uuid, obd2cli_tgt(imp->imp_obd)); + req->rq_no_resend = req->rq_no_delay = 1; + ptlrpc_request_set_replen(req); + req->rq_timeout = PING_INTERVAL; + ptlrpcd_add_req(req); + + RETURN(0); } void ptlrpc_update_next_ping(struct obd_import *imp) @@ -584,14 +583,18 @@ static int pinger_check_rpcs(void *arg) continue; } - req = ptlrpc_prep_req(imp, LUSTRE_OBD_VERSION, OBD_PING, - 1, NULL, NULL); - if (!req) { - CERROR("out of memory\n"); + req = ptlrpc_request_alloc_pack(imp, &RQF_OBD_PING, + LUSTRE_OBD_VERSION, + OBD_PING); + if (req == NULL) { + CERROR("OOM trying to ping %s->%s\n", + imp->imp_obd->obd_uuid.uuid, + obd2cli_tgt(imp->imp_obd)); break; } + req->rq_no_resend = 1; - ptlrpc_req_set_repsize(req, 1, NULL); + ptlrpc_request_set_replen(req); req->rq_send_state = LUSTRE_IMP_FULL; req->rq_phase = RQ_PHASE_RPC; req->rq_import_generation = generation; diff --git a/lustre/ptlrpc/ptlrpc_module.c b/lustre/ptlrpc/ptlrpc_module.c index 768e892..42fb922 100644 --- a/lustre/ptlrpc/ptlrpc_module.c +++ b/lustre/ptlrpc/ptlrpc_module.c @@ -159,6 +159,11 @@ EXPORT_SYMBOL(ptlrpc_add_rqs_to_pool); EXPORT_SYMBOL(ptlrpc_init_rq_pool); EXPORT_SYMBOL(ptlrpc_free_rq_pool); EXPORT_SYMBOL(ptlrpc_prep_req_pool); +EXPORT_SYMBOL(ptlrpc_request_alloc); +EXPORT_SYMBOL(ptlrpc_request_alloc_pool); +EXPORT_SYMBOL(ptlrpc_request_free); +EXPORT_SYMBOL(ptlrpc_request_pack); +EXPORT_SYMBOL(ptlrpc_request_alloc_pack); EXPORT_SYMBOL(ptlrpc_prep_req); EXPORT_SYMBOL(ptlrpc_free_req); EXPORT_SYMBOL(ptlrpc_unregister_reply); @@ -172,6 +177,8 @@ EXPORT_SYMBOL(ptlrpc_prep_bulk_page); EXPORT_SYMBOL(ptlrpc_abort_inflight); EXPORT_SYMBOL(ptlrpc_retain_replayable_request); EXPORT_SYMBOL(ptlrpc_next_xid); +EXPORT_SYMBOL(ptlrpc_req_set_repsize); +EXPORT_SYMBOL(ptlrpc_request_set_replen); EXPORT_SYMBOL(ptlrpc_prep_set); EXPORT_SYMBOL(ptlrpc_set_add_cb); @@ -228,17 +235,13 @@ EXPORT_SYMBOL(lustre_swab_obd_quotactl); EXPORT_SYMBOL(lustre_swab_mds_remote_perm); EXPORT_SYMBOL(lustre_swab_mdt_remote_perm); EXPORT_SYMBOL(lustre_swab_mds_rec_setattr); -EXPORT_SYMBOL(lustre_swab_mdt_rec_setattr); EXPORT_SYMBOL(lustre_swab_mds_rec_create); -EXPORT_SYMBOL(lustre_swab_mdt_rec_create); EXPORT_SYMBOL(lustre_swab_mds_rec_join); EXPORT_SYMBOL(lustre_swab_mdt_rec_join); EXPORT_SYMBOL(lustre_swab_mds_rec_link); -EXPORT_SYMBOL(lustre_swab_mdt_rec_link); EXPORT_SYMBOL(lustre_swab_mds_rec_unlink); -EXPORT_SYMBOL(lustre_swab_mdt_rec_unlink); EXPORT_SYMBOL(lustre_swab_mds_rec_rename); -EXPORT_SYMBOL(lustre_swab_mdt_rec_rename); +EXPORT_SYMBOL(lustre_swab_mdt_rec_reint); EXPORT_SYMBOL(lustre_swab_lov_desc); EXPORT_SYMBOL(lustre_swab_lov_user_md); EXPORT_SYMBOL(lustre_swab_lov_mds_md); diff --git a/lustre/ptlrpc/recov_thread.c b/lustre/ptlrpc/recov_thread.c index d3b473d..91bd48f 100644 --- a/lustre/ptlrpc/recov_thread.c +++ b/lustre/ptlrpc/recov_thread.c @@ -217,6 +217,18 @@ int llog_obd_repl_sync(struct llog_ctxt *ctxt, struct obd_export *exp) } EXPORT_SYMBOL(llog_obd_repl_sync); +static inline void stop_log_commit(struct llog_commit_master *lcm, + struct llog_commit_daemon *lcd, + int rc) +{ + CERROR("error preparing commit: rc %d\n", rc); + + spin_lock(&lcm->lcm_llcd_lock); + list_splice(&lcd->lcd_llcd_list, &lcm->lcm_llcd_resend); + CFS_INIT_LIST_HEAD(&lcd->lcd_llcd_list); + spin_unlock(&lcm->lcm_llcd_lock); +} + static int log_commit_thread(void *arg) { struct llog_commit_master *lcm = arg; @@ -329,8 +341,6 @@ static int log_commit_thread(void *arg) /* We are the only one manipulating our local list - no lock */ list_for_each_entry_safe(llcd,n, &lcd->lcd_llcd_list,llcd_list){ - int size[2] = { sizeof(struct ptlrpc_body), - llcd->llcd_cookiebytes }; char *bufs[2] = { NULL, (char *)llcd->llcd_cookies }; list_del(&llcd->llcd_list); @@ -361,17 +371,23 @@ static int log_commit_thread(void *arg) OBD_FAIL_TIMEOUT(OBD_FAIL_PTLRPC_DELAY_RECOV, 10); - request = ptlrpc_prep_req(import, LUSTRE_LOG_VERSION, - OBD_LOG_CANCEL, 2, size,bufs); + request = ptlrpc_request_alloc(import, &RQF_LOG_CANCEL); if (request == NULL) { rc = -ENOMEM; - CERROR("error preparing commit: rc %d\n", rc); + stop_log_commit(lcm, lcd, rc); + break; + } + + req_capsule_set_size(&request->rq_pill, &RMF_LOGCOOKIES, + RCL_CLIENT,llcd->llcd_cookiebytes); - spin_lock(&lcm->lcm_llcd_lock); - list_splice(&lcd->lcd_llcd_list, - &lcm->lcm_llcd_resend); - CFS_INIT_LIST_HEAD(&lcd->lcd_llcd_list); - spin_unlock(&lcm->lcm_llcd_lock); + rc = ptlrpc_request_bufs_pack(request, + LUSTRE_LOG_VERSION, + OBD_LOG_CANCEL, bufs, + NULL); + if (rc) { + ptlrpc_request_free(request); + stop_log_commit(lcm, lcd, rc); break; } @@ -379,7 +395,7 @@ static int log_commit_thread(void *arg) request->rq_request_portal = LDLM_CANCEL_REQUEST_PORTAL; request->rq_reply_portal = LDLM_CANCEL_REPLY_PORTAL; - ptlrpc_req_set_repsize(request, 1, NULL); + ptlrpc_request_set_replen(request); mutex_down(&llcd->llcd_ctxt->loc_sem); if (llcd->llcd_ctxt->loc_imp == NULL) { mutex_up(&llcd->llcd_ctxt->loc_sem); diff --git a/lustre/ptlrpc/wiretest.c b/lustre/ptlrpc/wiretest.c index fa5074b..d187035 100644 --- a/lustre/ptlrpc/wiretest.c +++ b/lustre/ptlrpc/wiretest.c @@ -125,7 +125,7 @@ void lustre_assert_wire_constants(void) (long long)REINT_RENAME); LASSERTF(REINT_OPEN == 6, " found %lld\n", (long long)REINT_OPEN); - LASSERTF(REINT_MAX == 7, " found %lld\n", + LASSERTF(REINT_MAX == 8, " found %lld\n", (long long)REINT_MAX); LASSERTF(MGS_CONNECT == 250, " found %lld\n", (long long)MGS_CONNECT); diff --git a/lustre/quota/quota_check.c b/lustre/quota/quota_check.c index 5cecee1..bdcda03 100644 --- a/lustre/quota/quota_check.c +++ b/lustre/quota/quota_check.c @@ -44,19 +44,19 @@ static int target_quotacheck_callback(struct obd_export *exp, struct obd_quotactl *oqctl) { struct ptlrpc_request *req; - struct obd_quotactl *body; - int rc, size[2] = { sizeof(struct ptlrpc_body), sizeof(*oqctl) }; + struct obd_quotactl *body; + int rc; ENTRY; - req = ptlrpc_prep_req(exp->exp_imp_reverse, LUSTRE_OBD_VERSION, - OBD_QC_CALLBACK, 2, size, NULL); - if (!req) + req = ptlrpc_request_alloc_pack(class_exp2cliimp(exp), &RQF_QC_CALLBACK, + LUSTRE_OBD_VERSION, OBD_QC_CALLBACK); + if (req == NULL) RETURN(-ENOMEM); - body = lustre_msg_buf(req->rq_reqmsg, REQ_REC_OFF, sizeof(*body)); + body = req_capsule_client_get(&req->rq_pill, &RMF_OBD_QUOTACTL); *body = *oqctl; - ptlrpc_req_set_repsize(req, 1, NULL); + ptlrpc_request_set_replen(req); rc = ptlrpc_queue_wait(req); ptlrpc_req_finished(req); @@ -146,11 +146,10 @@ out: int client_quota_check(struct obd_export *exp, struct obd_quotactl *oqctl) { - struct client_obd *cli = &exp->exp_obd->u.cli; + struct client_obd *cli = &exp->exp_obd->u.cli; struct ptlrpc_request *req; - struct obd_quotactl *body; - int size[2] = { sizeof(struct ptlrpc_body), sizeof(*body) }; - int ver, opc, rc; + struct obd_quotactl *body; + int ver, opc, rc; ENTRY; if (!strcmp(exp->exp_obd->obd_type->typ_name, LUSTRE_MDC_NAME)) { @@ -163,14 +162,15 @@ int client_quota_check(struct obd_export *exp, struct obd_quotactl *oqctl) RETURN(-EINVAL); } - req = ptlrpc_prep_req(class_exp2cliimp(exp), ver, opc, 2, size, NULL); - if (!req) - GOTO(out, rc = -ENOMEM); + req = ptlrpc_request_alloc_pack(class_exp2cliimp(exp), + &RQF_MDS_QUOTACHECK, ver, opc); + if (req == NULL) + RETURN(-ENOMEM); - body = lustre_msg_buf(req->rq_reqmsg, REQ_REC_OFF, sizeof(*body)); + body = req_capsule_client_get(&req->rq_pill, &RMF_OBD_QUOTACTL); *body = *oqctl; - ptlrpc_req_set_repsize(req, 1, NULL); + ptlrpc_request_set_replen(req); /* the next poll will find -ENODATA, that means quotacheck is * going on */ @@ -178,7 +178,6 @@ int client_quota_check(struct obd_export *exp, struct obd_quotactl *oqctl) rc = ptlrpc_queue_wait(req); if (rc) cli->cl_qchk_stat = rc; -out: ptlrpc_req_finished(req); RETURN(rc); } diff --git a/lustre/quota/quota_context.c b/lustre/quota/quota_context.c index c529bed..6c5de20 100644 --- a/lustre/quota/quota_context.c +++ b/lustre/quota/quota_context.c @@ -543,14 +543,21 @@ static int dqacq_interpret(struct ptlrpc_request *req, void *data, int rc) LASSERT(req); LASSERT(req->rq_import); - if ((req->rq_import->imp_connect_data.ocd_connect_flags & OBD_CONNECT_QUOTA64) && + + if ((req->rq_import->imp_connect_data.ocd_connect_flags & + OBD_CONNECT_QUOTA64) && !OBD_FAIL_CHECK(OBD_FAIL_QUOTA_QD_COUNT_32BIT)) { CDEBUG(D_QUOTA, "qd_count is 64bit!\n"); - qdata = lustre_swab_reqbuf(req, REPLY_REC_OFF, sizeof(*qdata), lustre_swab_qdata); + + qdata = req_capsule_server_swab_get(&req->rq_pill, + &RMF_QUNIT_DATA, + (void*)lustre_swab_qdata); } else { CDEBUG(D_QUOTA, "qd_count is 32bit!\n"); - qdata_old = lustre_swab_reqbuf(req, REPLY_REC_OFF, sizeof(struct qunit_data_old), - lustre_swab_qdata_old); + + qdata = req_capsule_server_swab_get(&req->rq_pill, + &RMF_QUNIT_DATA, + (void*)lustre_swab_qdata_old); qdata = lustre_quota_old_to_new(qdata_old); } if (qdata == NULL) { @@ -559,7 +566,8 @@ static int dqacq_interpret(struct ptlrpc_request *req, void *data, int rc) } LASSERT(qdata->qd_id == qunit->lq_data.qd_id && - (qdata->qd_flags & QUOTA_IS_GRP) == (qunit->lq_data.qd_flags & QUOTA_IS_GRP) && + (qdata->qd_flags & QUOTA_IS_GRP) == + (qunit->lq_data.qd_flags & QUOTA_IS_GRP) && (qdata->qd_count == qunit->lq_data.qd_count || qdata->qd_count == 0)); @@ -594,7 +602,6 @@ schedule_dqacq(struct obd_device *obd, struct ptlrpc_request *req; struct qunit_data *reqdata; struct dqacq_async_args *aa; - int size[2] = { sizeof(struct ptlrpc_body), sizeof(*reqdata) }; unsigned long factor; int rc = 0; ENTRY; @@ -626,7 +633,8 @@ schedule_dqacq(struct obd_device *obd, LASSERT(qunit); /* master is going to dqacq/dqrel from itself */ - if (is_master(obd, qctxt, qdata->qd_id, qdata->qd_flags & QUOTA_IS_GRP)) { + if (is_master(obd, qctxt, qdata->qd_id, qdata->qd_flags & QUOTA_IS_GRP)) + { int rc2; QDATA_DEBUG(qdata, "local %s.\n", opc == QUOTA_DQACQ ? "DQACQ" : "DQREL"); @@ -637,9 +645,10 @@ schedule_dqacq(struct obd_device *obd, /* build dqacq/dqrel request */ LASSERT(qctxt->lqc_import); - req = ptlrpc_prep_req(qctxt->lqc_import, LUSTRE_MDS_VERSION, opc, 2, - size, NULL); - if (!req) { + + req = ptlrpc_request_alloc_pack(qctxt->lqc_import, &RQF_MDS_QUOTA_DQACQ, + LUSTRE_MDS_VERSION, opc); + if (req == NULL) { dqacq_completion(obd, qctxt, qdata, -ENOMEM, opc); RETURN(-ENOMEM); } @@ -657,20 +666,24 @@ schedule_dqacq(struct obd_device *obd, { struct qunit_data_old *reqdata_old, *tmp; - reqdata_old = lustre_msg_buf(req->rq_reqmsg, REPLY_REC_OFF, - sizeof(*reqdata_old)); + reqdata_old = req_capsule_client_get(&req->rq_pill, + &RMF_QUNIT_DATA); + tmp = lustre_quota_new_to_old(qdata); *reqdata_old = *tmp; - size[1] = sizeof(*reqdata_old); + req_capsule_set_size(&req->rq_pill, &RMF_QUNIT_DATA, RCL_SERVER, + sizeof(*reqdata_old)); CDEBUG(D_QUOTA, "qd_count is 32bit!\n"); } else { - reqdata = lustre_msg_buf(req->rq_reqmsg, REPLY_REC_OFF, - sizeof(*reqdata)); + reqdata = req_capsule_client_get(&req->rq_pill, + &RMF_QUNIT_DATA); + *reqdata = *qdata; - size[1] = sizeof(*reqdata); + req_capsule_set_size(&req->rq_pill, &RMF_QUNIT_DATA, RCL_SERVER, + sizeof(*reqdata)); CDEBUG(D_QUOTA, "qd_count is 64bit!\n"); } - ptlrpc_req_set_repsize(req, 2, size); + ptlrpc_request_set_replen(req); CLASSERT(sizeof(*aa) <= sizeof(req->rq_async_args)); aa = (struct dqacq_async_args *)&req->rq_async_args; diff --git a/lustre/quota/quota_ctl.c b/lustre/quota/quota_ctl.c index c0641fc..7d3c54a 100644 --- a/lustre/quota/quota_ctl.c +++ b/lustre/quota/quota_ctl.c @@ -194,9 +194,8 @@ adjust: int client_quota_ctl(struct obd_export *exp, struct obd_quotactl *oqctl) { struct ptlrpc_request *req; - struct obd_quotactl *oqc; - int size[2] = { sizeof(struct ptlrpc_body), sizeof(*oqctl) }; - int ver, opc, rc; + struct obd_quotactl *oqc; + int ver, opc, rc; ENTRY; if (!strcmp(exp->exp_obd->obd_type->typ_name, LUSTRE_MDC_NAME)) { @@ -209,23 +208,21 @@ int client_quota_ctl(struct obd_export *exp, struct obd_quotactl *oqctl) RETURN(-EINVAL); } - req = ptlrpc_prep_req(class_exp2cliimp(exp), ver, opc, 2, size, NULL); - if (!req) - GOTO(out, rc = -ENOMEM); + req = ptlrpc_request_alloc_pack(class_exp2cliimp(exp), + &RQF_MDS_QUOTACTL, ver, opc); + if (req == NULL) + RETURN(-ENOMEM); - oqc = lustre_msg_buf(req->rq_reqmsg, REQ_REC_OFF, sizeof(*oqctl)); + oqc = req_capsule_client_get(&req->rq_pill, &RMF_OBD_QUOTACTL); *oqc = *oqctl; - ptlrpc_req_set_repsize(req, 2, size); + ptlrpc_request_set_replen(req); rc = ptlrpc_queue_wait(req); if (!rc) { - oqc = lustre_swab_repbuf(req, REPLY_REC_OFF, sizeof(*oqc), - lustre_swab_obd_quotactl); - if (oqc == NULL) { - CERROR ("Can't unpack obd_quotactl\n"); + oqc = req_capsule_server_get(&req->rq_pill, &RMF_OBD_QUOTACTL); + if (oqc == NULL) GOTO(out, rc = -EPROTO); - } *oqctl = *oqc; } diff --git a/lustre/utils/req-layout.c b/lustre/utils/req-layout.c index cd267e1..0d16b37 100644 --- a/lustre/utils/req-layout.c +++ b/lustre/utils/req-layout.c @@ -47,13 +47,19 @@ #define lustre_swab_ldlm_reply NULL #define lustre_swab_ldlm_intent NULL #define lustre_swab_lov_mds_md NULL -#define lustre_swab_mdt_rec_unlink NULL -#define lustre_swab_mdt_rec_link NULL -#define lustre_swab_mdt_rec_rename NULL -#define lustre_swab_mdt_rec_create NULL -#define lustre_swab_mdt_rec_setattr NULL +#define lustre_swab_mdt_rec_reint NULL #define lustre_swab_lustre_capa NULL #define lustre_swab_lustre_capa_key NULL +#define lustre_swab_mdt_rec_join NULL +#define lustre_swab_llogd_conn_body NULL +#define lustre_swab_llog_hdr NULL +#define lustre_swab_llogd_body NULL +#define lustre_swab_obd_quotactl NULL +#define lustre_swab_mgs_target_info NULL +#define lustre_swab_niobuf_remote NULL +#define lustre_swab_obd_ioobj NULL +#define lustre_swab_ost_body NULL +#define lustre_swab_ost_last_id NULL /* * Yes, include .c file. diff --git a/lustre/utils/wiretest.c b/lustre/utils/wiretest.c index 4360b19..628edfa 100644 --- a/lustre/utils/wiretest.c +++ b/lustre/utils/wiretest.c @@ -141,7 +141,9 @@ void lustre_assert_wire_constants(void) (long long)REINT_RENAME); LASSERTF(REINT_OPEN == 6, " found %lld\n", (long long)REINT_OPEN); - LASSERTF(REINT_MAX == 7, " found %lld\n", + LASSERTF(REINT_SETXATTR == 7, " found %lld\n", + (long long)REINT_SETXATTR); + LASSERTF(REINT_MAX == 8, " found %lld\n", (long long)REINT_MAX); LASSERTF(MGS_CONNECT == 250, " found %lld\n", (long long)MGS_CONNECT); -- 1.8.3.1