LU-4423 ptlrpc: incorporate BUILD_BUG_ON into ptlrpc_req_async_args()

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>

diff --git a/lustre/include/lustre_net.h b/lustre/include/lustre_net.h
index cf9b7e3..aac45f2 100644 (file)
--- a/lustre/include/lustre_net.h
+++ b/lustre/include/lustre_net.h
@@ -511,9 +511,11 @@
  */
 #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;

diff --git a/lustre/ldlm/ldlm_lockd.c b/lustre/ldlm/ldlm_lockd.c
index 980d225..65509be 100644 (file)
--- a/lustre/ldlm/ldlm_lockd.c
+++ b/lustre/ldlm/ldlm_lockd.c
@@ -899,8 +899,7 @@ int ldlm_server_blocking_ast(struct ldlm_lock *lock,
        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;
 


@@ -1020,8 +1019,7 @@ int ldlm_server_completion_ast(struct ldlm_lock *lock, __u64 flags, void *data)
                RETURN(rc);
        }
 
                RETURN(rc);
        }
 

-       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;
 


@@ -1149,8 +1147,7 @@ int ldlm_server_glimpse_ast(struct ldlm_lock *lock, void *data)
        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;
 


@@ -1203,7 +1200,7 @@ struct ldlm_lock *ldlm_request_lock(struct ptlrpc_request *req)
 
        ENTRY;
 
 
        ENTRY;
 

-       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));

diff --git a/lustre/ldlm/ldlm_request.c b/lustre/ldlm/ldlm_request.c
index 54100d7..c0f4f2f 100644 (file)
--- a/lustre/ldlm/ldlm_request.c
+++ b/lustre/ldlm/ldlm_request.c
@@ -1301,7 +1301,7 @@ int ldlm_cli_convert(struct ldlm_lock *lock, __u32 *flags)
                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;
 


@@ -2617,8 +2617,7 @@ static int replay_one_lock(struct obd_import *imp, struct ldlm_lock *lock)
        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);

diff --git a/lustre/lfsck/lfsck_layout.c b/lustre/lfsck/lfsck_layout.c
index aad367c..33563da 100644 (file)
--- a/lustre/lfsck/lfsck_layout.c
+++ b/lustre/lfsck/lfsck_layout.c
@@ -4682,7 +4682,7 @@ static int lfsck_layout_async_query(const struct lu_env *env,
        *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;

diff --git a/lustre/lfsck/lfsck_lib.c b/lustre/lfsck/lfsck_lib.c
index 7e67555..7abf85d 100644 (file)
--- a/lustre/lfsck/lfsck_lib.c
+++ b/lustre/lfsck/lfsck_lib.c
@@ -2448,7 +2448,7 @@ int lfsck_async_request(const struct lu_env *env, struct obd_export *exp,
        *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);

diff --git a/lustre/mdc/mdc_dev.c b/lustre/mdc/mdc_dev.c
index 394bb3e..08c868e 100644 (file)
--- a/lustre/mdc/mdc_dev.c
+++ b/lustre/mdc/mdc_dev.c
@@ -779,8 +779,7 @@ no_match:
                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;


@@ -1249,8 +1248,7 @@ static int mdc_io_data_version_start(const struct lu_env *env,
        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);

diff --git a/lustre/mdc/mdc_locks.c b/lustre/mdc/mdc_locks.c
index 661cb7f..5b11d5d 100644 (file)
--- a/lustre/mdc/mdc_locks.c
+++ b/lustre/mdc/mdc_locks.c
@@ -1425,8 +1425,7 @@ int mdc_intent_getattr_async(struct obd_export *exp,
                RETURN(rc);
        }
 
                RETURN(rc);
        }
 

-       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;
 

diff --git a/lustre/mdc/mdc_request.c b/lustre/mdc/mdc_request.c
index 04cef2a..646db73 100644 (file)
--- a/lustre/mdc/mdc_request.c
+++ b/lustre/mdc/mdc_request.c
@@ -1602,8 +1602,7 @@ static int mdc_statfs_async(struct obd_export *exp,
        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);


@@ -2579,7 +2578,7 @@ int mdc_rmfid_interpret(const struct lu_env *env, struct ptlrpc_request *req,
        ENTRY;
 
        if (!rc) {
        ENTRY;
 
        if (!rc) {

-               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);


@@ -2630,7 +2629,7 @@ static int mdc_rmfid(struct obd_export *exp, struct fid_array *fa,
        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;

diff --git a/lustre/osc/osc_io.c b/lustre/osc/osc_io.c
index 68cc041..4a1ac52 100644 (file)
--- a/lustre/osc/osc_io.c
+++ b/lustre/osc/osc_io.c
@@ -732,8 +732,7 @@ static int osc_io_data_version_start(const struct lu_env *env,
 
        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);

diff --git a/lustre/osc/osc_request.c b/lustre/osc/osc_request.c
index b0ff640..b4ed99b 100644 (file)
--- a/lustre/osc/osc_request.c
+++ b/lustre/osc/osc_request.c
@@ -231,8 +231,7 @@ int osc_setattr_async(struct obd_export *exp, struct obdo *oa,
        } 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;


@@ -320,8 +319,7 @@ int osc_ladvise_base(struct obd_export *exp, struct obdo *oa,
        }
 
        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;


@@ -417,8 +415,7 @@ int osc_punch_send(struct obd_export *exp, struct obdo *oa,
        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;


@@ -496,8 +493,7 @@ int osc_sync_base(struct osc_object *obj, struct obdo *oa,
        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;


@@ -1549,8 +1545,7 @@ no_bulk:
        }
        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;


@@ -1968,7 +1963,7 @@ static int osc_brw_redo_request(struct ptlrpc_request *request,
         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);


@@ -2313,8 +2308,7 @@ int osc_build_rpc(const struct lu_env *env, struct client_obd *cli,
        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);


@@ -2609,8 +2603,7 @@ no_match:
        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;


@@ -2776,8 +2769,7 @@ static int osc_statfs_async(struct obd_export *exp,
        }
 
        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);


@@ -2961,8 +2953,7 @@ int osc_set_info_async(const struct lu_env *env, struct obd_export *exp,
                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);

diff --git a/lustre/osp/osp_precreate.c b/lustre/osp/osp_precreate.c
index b806159..f489037 100644 (file)
--- a/lustre/osp/osp_precreate.c
+++ b/lustre/osp/osp_precreate.c
@@ -124,7 +124,7 @@ static int osp_statfs_interpret(const struct lu_env *env,
 
        ENTRY;
 
 
        ENTRY;
 

-       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);
 


@@ -206,7 +206,7 @@ static int osp_statfs_update(const struct lu_env *env, struct osp_device *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;
 
        /*

diff --git a/lustre/osp/osp_sync.c b/lustre/osp/osp_sync.c
index 4547325..074864f 100644 (file)
--- a/lustre/osp/osp_sync.c
+++ b/lustre/osp/osp_sync.c
@@ -516,7 +516,7 @@ static void osp_sync_request_commit_cb(struct ptlrpc_request *req)
         * 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));
 


@@ -644,7 +644,7 @@ static void osp_sync_send_new_rpc(struct osp_device *d,
        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;

diff --git a/lustre/osp/osp_trans.c b/lustre/osp/osp_trans.c
index a69a9cb..90b9e47 100644 (file)
--- a/lustre/osp/osp_trans.c
+++ b/lustre/osp/osp_trans.c
@@ -735,7 +735,7 @@ int osp_unplug_async_request(const struct lu_env *env,
                }
                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;


@@ -1118,7 +1118,7 @@ static int osp_send_update_req(const struct lu_env *env,
                RETURN(rc);
        }
 
                RETURN(rc);
        }
 

-       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 */

diff --git a/lustre/ptlrpc/client.c b/lustre/ptlrpc/client.c
index e482e56..e43cd01 100644 (file)
--- a/lustre/ptlrpc/client.c
+++ b/lustre/ptlrpc/client.c
@@ -3213,8 +3213,7 @@ int ptlrpc_replay_req(struct ptlrpc_request *req)
 
        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 */


@@ -3569,8 +3568,7 @@ void *ptlrpcd_alloc_work(struct obd_import *imp,
        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;
 

diff --git a/lustre/ptlrpc/import.c b/lustre/ptlrpc/import.c
index 3aa6f39..2334fac 100644 (file)
--- a/lustre/ptlrpc/import.c
+++ b/lustre/ptlrpc/import.c
@@ -779,8 +779,7 @@ int ptlrpc_connect_import(struct obd_import *imp)
        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;

diff --git a/lustre/quota/qsd_request.c b/lustre/quota/qsd_request.c
index 152ba90..cf5d273 100644 (file)
--- a/lustre/quota/qsd_request.c
+++ b/lustre/quota/qsd_request.c
@@ -119,8 +119,7 @@ int qsd_send_dqacq(const struct lu_env *env, struct obd_export *exp,
 
        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;


@@ -322,8 +321,7 @@ int qsd_intent_lock(const struct lu_env *env, struct obd_export *exp,
                break;
        }
 
                break;
        }
 

-       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;