Every call to ptlrpc_req_async_args() should be preceded by a
BUILD_BUG_ON() (aka LASSERT()), though a few aren't.
To improve maintainability, include the BUILD_BUG_ON into the
ptlrpc_req_async_args() macro.
Change-Id: I07481921379930b4b2d9329aefb47068fd0e07f0
Signed-off-by: NeilBrown <neilb@suse.com>
Reviewed-on: https://review.whamcloud.com/35509
Tested-by: jenkins <devops@whamcloud.com>
Tested-by: Maloo <maloo@whamcloud.com>
Reviewed-by: Neil Brown <neilb@suse.de>
Reviewed-by: Mike Pershin <mpershin@whamcloud.com>
Reviewed-by: Petros Koutoupis <pkoutoupis@cray.com>
Reviewed-by: Oleg Drokin <green@whamcloud.com>
16 files changed:
*/
#define OST_IO_BUFSIZE max_t(int, OST_IO_MAXREQSIZE + 1024, 64 * 1024)
*/
#define OST_IO_BUFSIZE max_t(int, OST_IO_MAXREQSIZE + 1024, 64 * 1024)
-
-/* Macro to hide a typecast. */
-#define ptlrpc_req_async_args(req) ((void *)&req->rq_async_args)
+/* Macro to hide a typecast and BUILD_BUG. */
+#define ptlrpc_req_async_args(_var, req) ({ \
+ BUILD_BUG_ON(sizeof(*_var) > sizeof(req->rq_async_args)); \
+ (typeof(_var))&req->rq_async_args; \
+ })
struct ptlrpc_replay_async_args {
int praa_old_state;
struct ptlrpc_replay_async_args {
int praa_old_state;
if (req == NULL)
RETURN(-ENOMEM);
if (req == NULL)
RETURN(-ENOMEM);
- CLASSERT(sizeof(*ca) <= sizeof(req->rq_async_args));
- ca = ptlrpc_req_async_args(req);
+ ca = ptlrpc_req_async_args(ca, req);
ca->ca_set_arg = arg;
ca->ca_lock = lock;
ca->ca_set_arg = arg;
ca->ca_lock = lock;
- CLASSERT(sizeof(*ca) <= sizeof(req->rq_async_args));
- ca = ptlrpc_req_async_args(req);
+ ca = ptlrpc_req_async_args(ca, req);
ca->ca_set_arg = arg;
ca->ca_lock = lock;
ca->ca_set_arg = arg;
ca->ca_lock = lock;
body->lock_handle[0] = lock->l_remote_handle;
ldlm_lock2desc(lock, &body->lock_desc);
body->lock_handle[0] = lock->l_remote_handle;
ldlm_lock2desc(lock, &body->lock_desc);
- CLASSERT(sizeof(*ca) <= sizeof(req->rq_async_args));
- ca = ptlrpc_req_async_args(req);
+ ca = ptlrpc_req_async_args(ca, req);
ca->ca_set_arg = arg;
ca->ca_lock = lock;
ca->ca_set_arg = arg;
ca->ca_lock = lock;
- ca = ptlrpc_req_async_args(req);
+ ca = ptlrpc_req_async_args(ca, req);
lock = ca->ca_lock;
if (lock == NULL)
RETURN(ERR_PTR(-EFAULT));
lock = ca->ca_lock;
if (lock == NULL)
RETURN(ERR_PTR(-EFAULT));
lprocfs_counter_incr(exp->exp_obd->obd_svc_stats,
LDLM_CONVERT - LDLM_FIRST_OPC);
lprocfs_counter_incr(exp->exp_obd->obd_svc_stats,
LDLM_CONVERT - LDLM_FIRST_OPC);
- aa = ptlrpc_req_async_args(req);
+ aa = ptlrpc_req_async_args(aa, req);
ldlm_lock2handle(lock, &aa->lock_handle);
req->rq_interpret_reply = lock_convert_interpret;
ldlm_lock2handle(lock, &aa->lock_handle);
req->rq_interpret_reply = lock_convert_interpret;
LDLM_DEBUG(lock, "replaying lock:");
atomic_inc(&req->rq_import->imp_replay_inflight);
LDLM_DEBUG(lock, "replaying lock:");
atomic_inc(&req->rq_import->imp_replay_inflight);
- CLASSERT(sizeof(*aa) <= sizeof(req->rq_async_args));
- aa = ptlrpc_req_async_args(req);
+ aa = ptlrpc_req_async_args(aa, req);
aa->lock_handle = body->lock_handle[0];
req->rq_interpret_reply = replay_lock_interpret;
ptlrpcd_add_req(req);
aa->lock_handle = body->lock_handle[0];
req->rq_interpret_reply = replay_lock_interpret;
ptlrpcd_add_req(req);
*tmp = *lr;
ptlrpc_request_set_replen(req);
*tmp = *lr;
ptlrpc_request_set_replen(req);
- llsaa = ptlrpc_req_async_args(req);
+ llsaa = ptlrpc_req_async_args(llsaa, req);
llsaa->llsaa_exp = exp;
llsaa->llsaa_com = lfsck_component_get(com);
llsaa->llsaa_llst = llst;
llsaa->llsaa_exp = exp;
llsaa->llsaa_com = lfsck_component_get(com);
llsaa->llsaa_llst = llst;
*tmp = *lr;
ptlrpc_request_set_replen(req);
*tmp = *lr;
ptlrpc_request_set_replen(req);
- laia = ptlrpc_req_async_args(req);
+ laia = ptlrpc_req_async_args(laia, req);
*laia = *(struct lfsck_async_interpret_args *)args;
if (laia->laia_com != NULL)
lfsck_component_get(laia->laia_com);
*laia = *(struct lfsck_async_interpret_args *)args;
if (laia->laia_com != NULL)
lfsck_component_get(laia->laia_com);
if (!rc) {
struct osc_enqueue_args *aa;
if (!rc) {
struct osc_enqueue_args *aa;
- CLASSERT(sizeof(*aa) <= sizeof(req->rq_async_args));
- aa = ptlrpc_req_async_args(req);
+ aa = ptlrpc_req_async_args(aa, req);
aa->oa_exp = exp;
aa->oa_mode = einfo->ei_mode;
aa->oa_type = einfo->ei_type;
aa->oa_exp = exp;
aa->oa_mode = einfo->ei_mode;
aa->oa_type = einfo->ei_type;
ptlrpc_request_set_replen(req);
req->rq_interpret_reply = mdc_data_version_interpret;
ptlrpc_request_set_replen(req);
req->rq_interpret_reply = mdc_data_version_interpret;
- CLASSERT(sizeof(*dva) <= sizeof(req->rq_async_args));
- dva = ptlrpc_req_async_args(req);
+ dva = ptlrpc_req_async_args(dva, req);
dva->dva_oio = oio;
ptlrpcd_add_req(req);
dva->dva_oio = oio;
ptlrpcd_add_req(req);
- CLASSERT(sizeof(*ga) <= sizeof(req->rq_async_args));
- ga = ptlrpc_req_async_args(req);
+ ga = ptlrpc_req_async_args(ga, req);
ga->ga_exp = exp;
ga->ga_minfo = minfo;
ga->ga_exp = exp;
ga->ga_minfo = minfo;
ptlrpc_request_set_replen(req);
req->rq_interpret_reply = mdc_statfs_interpret;
ptlrpc_request_set_replen(req);
req->rq_interpret_reply = mdc_statfs_interpret;
- CLASSERT(sizeof(*aa) <= sizeof(req->rq_async_args));
- aa = ptlrpc_req_async_args(req);
+ aa = ptlrpc_req_async_args(aa, req);
*aa = *oinfo;
ptlrpcd_add_req(req);
*aa = *oinfo;
ptlrpcd_add_req(req);
- aa = ptlrpc_req_async_args(req);
+ aa = ptlrpc_req_async_args(aa, req);
size = req_capsule_get_size(&req->rq_pill, &RMF_RCS,
RCL_SERVER);
size = req_capsule_get_size(&req->rq_pill, &RMF_RCS,
RCL_SERVER);
ptlrpc_request_set_replen(req);
LASSERT(rcs);
ptlrpc_request_set_replen(req);
LASSERT(rcs);
- aa = ptlrpc_req_async_args(req);
+ aa = ptlrpc_req_async_args(aa, req);
aa->mra_rcs = rcs;
aa->mra_nr = fa->fa_nr;
req->rq_interpret_reply = mdc_rmfid_interpret;
aa->mra_rcs = rcs;
aa->mra_nr = fa->fa_nr;
req->rq_interpret_reply = mdc_rmfid_interpret;
ptlrpc_request_set_replen(req);
req->rq_interpret_reply = osc_data_version_interpret;
ptlrpc_request_set_replen(req);
req->rq_interpret_reply = osc_data_version_interpret;
- CLASSERT(sizeof(*dva) <= sizeof(req->rq_async_args));
- dva = ptlrpc_req_async_args(req);
+ dva = ptlrpc_req_async_args(dva, req);
dva->dva_oio = oio;
ptlrpcd_add_req(req);
dva->dva_oio = oio;
ptlrpcd_add_req(req);
} else {
req->rq_interpret_reply = osc_setattr_interpret;
} else {
req->rq_interpret_reply = osc_setattr_interpret;
- CLASSERT(sizeof(*sa) <= sizeof(req->rq_async_args));
- sa = ptlrpc_req_async_args(req);
+ sa = ptlrpc_req_async_args(sa, req);
sa->sa_oa = oa;
sa->sa_upcall = upcall;
sa->sa_cookie = cookie;
sa->sa_oa = oa;
sa->sa_upcall = upcall;
sa->sa_cookie = cookie;
}
req->rq_interpret_reply = osc_ladvise_interpret;
}
req->rq_interpret_reply = osc_ladvise_interpret;
- CLASSERT(sizeof(*la) <= sizeof(req->rq_async_args));
- la = ptlrpc_req_async_args(req);
+ la = ptlrpc_req_async_args(la, req);
la->la_oa = oa;
la->la_upcall = upcall;
la->la_cookie = cookie;
la->la_oa = oa;
la->la_upcall = upcall;
la->la_cookie = cookie;
ptlrpc_request_set_replen(req);
req->rq_interpret_reply = osc_setattr_interpret;
ptlrpc_request_set_replen(req);
req->rq_interpret_reply = osc_setattr_interpret;
- CLASSERT(sizeof(*sa) <= sizeof(req->rq_async_args));
- sa = ptlrpc_req_async_args(req);
+ sa = ptlrpc_req_async_args(sa, req);
sa->sa_oa = oa;
sa->sa_upcall = upcall;
sa->sa_cookie = cookie;
sa->sa_oa = oa;
sa->sa_upcall = upcall;
sa->sa_cookie = cookie;
ptlrpc_request_set_replen(req);
req->rq_interpret_reply = osc_sync_interpret;
ptlrpc_request_set_replen(req);
req->rq_interpret_reply = osc_sync_interpret;
- CLASSERT(sizeof(*fa) <= sizeof(req->rq_async_args));
- fa = ptlrpc_req_async_args(req);
+ fa = ptlrpc_req_async_args(fa, req);
fa->fa_obj = obj;
fa->fa_oa = oa;
fa->fa_upcall = upcall;
fa->fa_obj = obj;
fa->fa_oa = oa;
fa->fa_upcall = upcall;
}
ptlrpc_request_set_replen(req);
}
ptlrpc_request_set_replen(req);
- CLASSERT(sizeof(*aa) <= sizeof(req->rq_async_args));
- aa = ptlrpc_req_async_args(req);
+ aa = ptlrpc_req_async_args(aa, req);
aa->aa_oa = oa;
aa->aa_requested_nob = requested_nob;
aa->aa_nio_count = niocount;
aa->aa_oa = oa;
aa->aa_requested_nob = requested_nob;
aa->aa_nio_count = niocount;
new_req->rq_generation_set = 1;
new_req->rq_import_generation = request->rq_import_generation;
new_req->rq_generation_set = 1;
new_req->rq_import_generation = request->rq_import_generation;
- new_aa = ptlrpc_req_async_args(new_req);
+ new_aa = ptlrpc_req_async_args(new_aa, new_req);
INIT_LIST_HEAD(&new_aa->aa_oaps);
list_splice_init(&aa->aa_oaps, &new_aa->aa_oaps);
INIT_LIST_HEAD(&new_aa->aa_oaps);
list_splice_init(&aa->aa_oaps, &new_aa->aa_oaps);
cl_req_attr_set(env, osc2cl(obj), crattr);
lustre_msg_set_jobid(req->rq_reqmsg, crattr->cra_jobid);
cl_req_attr_set(env, osc2cl(obj), crattr);
lustre_msg_set_jobid(req->rq_reqmsg, crattr->cra_jobid);
- CLASSERT(sizeof(*aa) <= sizeof(req->rq_async_args));
- aa = ptlrpc_req_async_args(req);
+ aa = ptlrpc_req_async_args(aa, req);
INIT_LIST_HEAD(&aa->aa_oaps);
list_splice_init(&rpc_list, &aa->aa_oaps);
INIT_LIST_HEAD(&aa->aa_exts);
INIT_LIST_HEAD(&aa->aa_oaps);
list_splice_init(&rpc_list, &aa->aa_oaps);
INIT_LIST_HEAD(&aa->aa_exts);
if (async) {
if (!rc) {
struct osc_enqueue_args *aa;
if (async) {
if (!rc) {
struct osc_enqueue_args *aa;
- CLASSERT(sizeof(*aa) <= sizeof(req->rq_async_args));
- aa = ptlrpc_req_async_args(req);
+ aa = ptlrpc_req_async_args(aa, req);
aa->oa_exp = exp;
aa->oa_mode = einfo->ei_mode;
aa->oa_type = einfo->ei_type;
aa->oa_exp = exp;
aa->oa_mode = einfo->ei_mode;
aa->oa_type = einfo->ei_type;
}
req->rq_interpret_reply = osc_statfs_interpret;
}
req->rq_interpret_reply = osc_statfs_interpret;
- CLASSERT(sizeof(*aa) <= sizeof(req->rq_async_args));
- aa = ptlrpc_req_async_args(req);
+ aa = ptlrpc_req_async_args(aa, req);
aa->aa_oi = oinfo;
ptlrpc_set_add_req(rqset, req);
aa->aa_oi = oinfo;
ptlrpc_set_add_req(rqset, req);
struct osc_grant_args *aa;
struct obdo *oa;
struct osc_grant_args *aa;
struct obdo *oa;
- CLASSERT(sizeof(*aa) <= sizeof(req->rq_async_args));
- aa = ptlrpc_req_async_args(req);
+ aa = ptlrpc_req_async_args(aa, req);
OBD_SLAB_ALLOC_PTR_GFP(oa, osc_obdo_kmem, GFP_NOFS);
if (!oa) {
ptlrpc_req_finished(req);
OBD_SLAB_ALLOC_PTR_GFP(oa, osc_obdo_kmem, GFP_NOFS);
if (!oa) {
ptlrpc_req_finished(req);
- aa = ptlrpc_req_async_args(req);
+ aa = ptlrpc_req_async_args(aa, req);
d = aa->pointer_arg[0];
LASSERT(d);
d = aa->pointer_arg[0];
LASSERT(d);
ptlrpc_at_set_req_timeout(req);
req->rq_interpret_reply = osp_statfs_interpret;
ptlrpc_at_set_req_timeout(req);
req->rq_interpret_reply = osp_statfs_interpret;
- aa = ptlrpc_req_async_args(req);
+ aa = ptlrpc_req_async_args(aa, req);
aa->pointer_arg[0] = d;
/*
aa->pointer_arg[0] = d;
/*
* it's done in osp_sync_interpret sooner or later */
LASSERT(d);
* it's done in osp_sync_interpret sooner or later */
LASSERT(d);
- jra = ptlrpc_req_async_args(req);
+ jra = ptlrpc_req_async_args(jra, req);
LASSERT(jra->jra_magic == OSP_JOB_MAGIC);
LASSERT(list_empty(&jra->jra_committed_link));
LASSERT(jra->jra_magic == OSP_JOB_MAGIC);
LASSERT(list_empty(&jra->jra_committed_link));
LASSERT(atomic_read(&d->opd_sync_rpcs_in_flight) <=
d->opd_sync_max_rpcs_in_flight);
LASSERT(atomic_read(&d->opd_sync_rpcs_in_flight) <=
d->opd_sync_max_rpcs_in_flight);
- jra = ptlrpc_req_async_args(req);
+ jra = ptlrpc_req_async_args(jra, req);
jra->jra_magic = OSP_JOB_MAGIC;
jra->jra_lcookie.lgc_lgl = llh->lgh_id;
jra->jra_lcookie.lgc_subsys = LLOG_MDS_OST_ORIG_CTXT;
jra->jra_magic = OSP_JOB_MAGIC;
jra->jra_lcookie.lgc_lgl = llh->lgh_id;
jra->jra_lcookie.lgc_subsys = LLOG_MDS_OST_ORIG_CTXT;
}
osp_update_request_destroy(env, our);
} else {
}
osp_update_request_destroy(env, our);
} else {
- args = ptlrpc_req_async_args(req);
+ args = ptlrpc_req_async_args(args, req);
args->oaua_update = our;
args->oaua_count = NULL;
args->oaua_waitq = NULL;
args->oaua_update = our;
args->oaua_count = NULL;
args->oaua_waitq = NULL;
- args = ptlrpc_req_async_args(req);
+ args = ptlrpc_req_async_args(args, req);
args->oaua_update = our;
/* set env to NULL, in case the interrupt cb and current function
* are in different thread */
args->oaua_update = our;
/* set env to NULL, in case the interrupt cb and current function
* are in different thread */
LASSERT(req->rq_import->imp_state == LUSTRE_IMP_REPLAY);
LASSERT(req->rq_import->imp_state == LUSTRE_IMP_REPLAY);
- CLASSERT(sizeof(*aa) <= sizeof(req->rq_async_args));
- aa = ptlrpc_req_async_args(req);
+ aa = ptlrpc_req_async_args(aa, req);
memset(aa, 0, sizeof(*aa));
/* Prepare request to be resent with ptlrpcd */
memset(aa, 0, sizeof(*aa));
/* Prepare request to be resent with ptlrpcd */
req->rq_no_delay = req->rq_no_resend = 1;
req->rq_pill.rc_fmt = (void *)&worker_format;
req->rq_no_delay = req->rq_no_resend = 1;
req->rq_pill.rc_fmt = (void *)&worker_format;
- CLASSERT(sizeof(*args) <= sizeof(req->rq_async_args));
- args = ptlrpc_req_async_args(req);
+ args = ptlrpc_req_async_args(args, req);
args->cb = cb;
args->cbdata = cbdata;
args->cb = cb;
args->cbdata = cbdata;
ptlrpc_request_set_replen(request);
request->rq_interpret_reply = ptlrpc_connect_interpret;
ptlrpc_request_set_replen(request);
request->rq_interpret_reply = ptlrpc_connect_interpret;
- CLASSERT(sizeof(*aa) <= sizeof(request->rq_async_args));
- aa = ptlrpc_req_async_args(request);
+ aa = ptlrpc_req_async_args(aa, request);
memset(aa, 0, sizeof *aa);
aa->pcaa_peer_committed = committed_before_reconnect;
memset(aa, 0, sizeof *aa);
aa->pcaa_peer_committed = committed_before_reconnect;
ptlrpc_request_set_replen(req);
ptlrpc_request_set_replen(req);
- CLASSERT(sizeof(*aa) <= sizeof(req->rq_async_args));
- aa = ptlrpc_req_async_args(req);
+ aa = ptlrpc_req_async_args(aa, req);
aa->aa_exp = exp;
aa->aa_qqi = qqi;
aa->aa_arg = (void *)lqe;
aa->aa_exp = exp;
aa->aa_qqi = qqi;
aa->aa_arg = (void *)lqe;
- CLASSERT(sizeof(*aa) <= sizeof(req->rq_async_args));
- aa = ptlrpc_req_async_args(req);
+ aa = ptlrpc_req_async_args(aa, req);
aa->aa_exp = exp;
aa->aa_qqi = qqi;
aa->aa_arg = arg;
aa->aa_exp = exp;
aa->aa_qqi = qqi;
aa->aa_arg = arg;