LU-6142 selftest: remove typedefs from lnet selftest

Change the typedefs in lnet selftest to proper structures.
Several other style changes to fix checkpatch issues with
code impacted by tyepdef change.

Test-Parameters: testlist=lnet-selftest

Change-Id: I941d460566673ccb5bccad9f3506f90ede47ed67
Signed-off-by: James Simmons <uja.ornl@yahoo.com>
Reviewed-on: https://review.whamcloud.com/27298
Reviewed-by: Doug Oucharek <doug@cadentcomputing.com>
Tested-by: Jenkins
Tested-by: Maloo <hpdd-maloo@intel.com>
Reviewed-by: Dmitry Eremin <dmitry.eremin@intel.com>
Reviewed-by: Olaf Weber <olaf.weber@hpe.com>
Reviewed-by: Oleg Drokin <oleg.drokin@intel.com>

diff --git a/lnet/selftest/brw_test.c b/lnet/selftest/brw_test.c
index 512dbb5..23a793b 100644 (file)
--- a/lnet/selftest/brw_test.c
+++ b/lnet/selftest/brw_test.c
@@ -49,10 +49,10 @@ MODULE_PARM_DESC(brw_inject_errors, "# data errors to inject randomly, zero by d
 #define BRW_MSIZE      sizeof(__u64)
 
 static void
 #define BRW_MSIZE      sizeof(__u64)
 
 static void

-brw_client_fini (sfw_test_instance_t *tsi)
+brw_client_fini(struct sfw_test_instance *tsi)

 {
 {

-       srpc_bulk_t     *bulk;
-       sfw_test_unit_t *tsu;
+       struct srpc_bulk *bulk;
+       struct sfw_test_unit *tsu;

 
        LASSERT(tsi->tsi_is_client);
 
 
        LASSERT(tsi->tsi_is_client);
 


@@ -67,22 +67,22 @@ brw_client_fini (sfw_test_instance_t *tsi)
 }
 
 static int
 }
 
 static int

-brw_client_init (sfw_test_instance_t *tsi)
+brw_client_init(struct sfw_test_instance *tsi)

 {
 {

-       sfw_session_t    *sn = tsi->tsi_batch->bat_session;
+       struct sfw_session *sn = tsi->tsi_batch->bat_session;

        int               flags;
        int               off;
        int               npg;
        int               len;
        int               opc;
        int               flags;
        int               off;
        int               npg;
        int               len;
        int               opc;

-       srpc_bulk_t      *bulk;
-       sfw_test_unit_t  *tsu;
+       struct srpc_bulk *bulk;
+       struct sfw_test_unit *tsu;

 
        LASSERT(sn != NULL);
        LASSERT(tsi->tsi_is_client);
 
        if ((sn->sn_features & LST_FEAT_BULK_LEN) == 0) {
 
        LASSERT(sn != NULL);
        LASSERT(tsi->tsi_is_client);
 
        if ((sn->sn_features & LST_FEAT_BULK_LEN) == 0) {

-               test_bulk_req_t  *breq = &tsi->tsi_u.bulk_v0;
+               struct test_bulk_req *breq = &tsi->tsi_u.bulk_v0;

 
                opc   = breq->blk_opc;
                flags = breq->blk_flags;
 
                opc   = breq->blk_opc;
                flags = breq->blk_flags;


@@ -93,7 +93,7 @@ brw_client_init (sfw_test_instance_t *tsi)
                off   = 0;
 
        } else {
                off   = 0;
 
        } else {

-               test_bulk_req_v1_t  *breq = &tsi->tsi_u.bulk_v1;
+               struct test_bulk_req_v1 *breq = &tsi->tsi_u.bulk_v1;

 
                /* I should never get this step if it's unknown feature
                 * because make_session will reject unknown feature */
 
                /* I should never get this step if it's unknown feature
                 * because make_session will reject unknown feature */


@@ -137,7 +137,7 @@ brw_client_init (sfw_test_instance_t *tsi)
 #define BRW_MAGIC       0xeeb0eeb1eeb2eeb3ULL
 #define BRW_MSIZE       sizeof(__u64)
 
 #define BRW_MAGIC       0xeeb0eeb1eeb2eeb3ULL
 #define BRW_MSIZE       sizeof(__u64)
 

-int brw_inject_one_error(void)
+static int brw_inject_one_error(void)

 {
        struct timespec64 ts;
 
 {
        struct timespec64 ts;
 


@@ -228,7 +228,7 @@ bad_data:
 }
 
 static void
 }
 
 static void

-brw_fill_bulk(srpc_bulk_t *bk, int pattern, __u64 magic)
+brw_fill_bulk(struct srpc_bulk *bk, int pattern, __u64 magic)

 {
        int          i;
        struct page *pg;
 {
        int          i;
        struct page *pg;


@@ -245,7 +245,7 @@ brw_fill_bulk(srpc_bulk_t *bk, int pattern, __u64 magic)
 }
 
 static int
 }
 
 static int

-brw_check_bulk(srpc_bulk_t *bk, int pattern, __u64 magic)
+brw_check_bulk(struct srpc_bulk *bk, int pattern, __u64 magic)

 {
        int          i;
        struct page *pg;
 {
        int          i;
        struct page *pg;


@@ -268,25 +268,25 @@ brw_check_bulk(srpc_bulk_t *bk, int pattern, __u64 magic)
 }
 
 static int
 }
 
 static int

-brw_client_prep_rpc(sfw_test_unit_t *tsu,
-                   struct lnet_process_id dest, srpc_client_rpc_t **rpcpp)
+brw_client_prep_rpc(struct sfw_test_unit *tsu, struct lnet_process_id dest,
+                   struct srpc_client_rpc **rpcpp)

 {
 {

-       srpc_bulk_t         *bulk = tsu->tsu_private;
-       sfw_test_instance_t *tsi = tsu->tsu_instance;
-       sfw_session_t       *sn = tsi->tsi_batch->bat_session;
-       srpc_client_rpc_t   *rpc;
-       srpc_brw_reqst_t    *req;
-       int                  flags;
-       int                  npg;
-       int                  len;
-       int                  opc;
-       int                  rc;
+       struct srpc_bulk *bulk = tsu->tsu_private;
+       struct sfw_test_instance *tsi = tsu->tsu_instance;
+       struct sfw_session *sn = tsi->tsi_batch->bat_session;
+       struct srpc_client_rpc *rpc;
+       struct srpc_brw_reqst *req;
+       int flags;
+       int npg;
+       int len;
+       int opc;
+       int rc;

 
        LASSERT(sn != NULL);
        LASSERT(bulk != NULL);
 
        if ((sn->sn_features & LST_FEAT_BULK_LEN) == 0) {
 
        LASSERT(sn != NULL);
        LASSERT(bulk != NULL);
 
        if ((sn->sn_features & LST_FEAT_BULK_LEN) == 0) {

-               test_bulk_req_t *breq = &tsi->tsi_u.bulk_v0;
+               struct test_bulk_req *breq = &tsi->tsi_u.bulk_v0;

 
                opc   = breq->blk_opc;
                flags = breq->blk_flags;
 
                opc   = breq->blk_opc;
                flags = breq->blk_flags;


@@ -294,8 +294,8 @@ brw_client_prep_rpc(sfw_test_unit_t *tsu,
                len   = npg * PAGE_SIZE;
 
        } else {
                len   = npg * PAGE_SIZE;
 
        } else {

-               test_bulk_req_v1_t  *breq = &tsi->tsi_u.bulk_v1;
-               int                  off;
+               struct test_bulk_req_v1 *breq = &tsi->tsi_u.bulk_v1;
+               int off;

 
                /* I should never get this step if it's unknown feature
                 * because make_session will reject unknown feature */
 
                /* I should never get this step if it's unknown feature
                 * because make_session will reject unknown feature */


@@ -312,7 +312,7 @@ brw_client_prep_rpc(sfw_test_unit_t *tsu,
        if (rc != 0)
                return rc;
 
        if (rc != 0)
                return rc;
 

-       memcpy(&rpc->crpc_bulk, bulk, offsetof(srpc_bulk_t, bk_iovs[npg]));
+       memcpy(&rpc->crpc_bulk, bulk, offsetof(struct srpc_bulk, bk_iovs[npg]));

        if (opc == LST_BRW_WRITE)
                brw_fill_bulk(&rpc->crpc_bulk, flags, BRW_MAGIC);
        else
        if (opc == LST_BRW_WRITE)
                brw_fill_bulk(&rpc->crpc_bulk, flags, BRW_MAGIC);
        else


@@ -328,14 +328,14 @@ brw_client_prep_rpc(sfw_test_unit_t *tsu,
 }
 
 static void
 }
 
 static void

-brw_client_done_rpc(sfw_test_unit_t *tsu, srpc_client_rpc_t *rpc)
+brw_client_done_rpc(struct sfw_test_unit *tsu, struct srpc_client_rpc *rpc)

 {
 {

-       __u64                magic = BRW_MAGIC;
-       sfw_test_instance_t *tsi = tsu->tsu_instance;
-       sfw_session_t       *sn = tsi->tsi_batch->bat_session;
-       srpc_msg_t          *msg = &rpc->crpc_replymsg;
-       srpc_brw_reply_t    *reply = &msg->msg_body.brw_reply;
-       srpc_brw_reqst_t    *reqst = &rpc->crpc_reqstmsg.msg_body.brw_reqst;
+       __u64 magic = BRW_MAGIC;
+       struct sfw_test_instance *tsi = tsu->tsu_instance;
+       struct sfw_session *sn = tsi->tsi_batch->bat_session;
+       struct srpc_msg *msg = &rpc->crpc_replymsg;
+       struct srpc_brw_reply *reply = &msg->msg_body.brw_reply;
+       struct srpc_brw_reqst *reqst = &rpc->crpc_reqstmsg.msg_body.brw_reqst;

 
        LASSERT(sn != NULL);
 
 
        LASSERT(sn != NULL);
 


@@ -376,9 +376,9 @@ brw_client_done_rpc(sfw_test_unit_t *tsu, srpc_client_rpc_t *rpc)
 }
 
 static void
 }
 
 static void

-brw_server_rpc_done(srpc_server_rpc_t *rpc)
+brw_server_rpc_done(struct srpc_server_rpc *rpc)

 {
 {

-       srpc_bulk_t *blk = rpc->srpc_bulk;
+       struct srpc_bulk *blk = rpc->srpc_bulk;

 
        if (blk == NULL)
                return;
 
        if (blk == NULL)
                return;


@@ -396,12 +396,12 @@ brw_server_rpc_done(srpc_server_rpc_t *rpc)
 }
 
 static int
 }
 
 static int

-brw_bulk_ready(srpc_server_rpc_t *rpc, int status)
+brw_bulk_ready(struct srpc_server_rpc *rpc, int status)

 {
 {

-        __u64             magic = BRW_MAGIC;
-        srpc_brw_reply_t *reply = &rpc->srpc_replymsg.msg_body.brw_reply;
-        srpc_brw_reqst_t *reqst;
-        srpc_msg_t       *reqstmsg;
+       __u64 magic = BRW_MAGIC;
+       struct srpc_brw_reply *reply = &rpc->srpc_replymsg.msg_body.brw_reply;
+       struct srpc_brw_reqst *reqst;
+       struct srpc_msg *reqstmsg;

 
         LASSERT (rpc->srpc_bulk != NULL);
         LASSERT (rpc->srpc_reqstbuf != NULL);
 
         LASSERT (rpc->srpc_bulk != NULL);
         LASSERT (rpc->srpc_reqstbuf != NULL);


@@ -434,13 +434,13 @@ brw_bulk_ready(srpc_server_rpc_t *rpc, int status)
 static int
 brw_server_handle(struct srpc_server_rpc *rpc)
 {
 static int
 brw_server_handle(struct srpc_server_rpc *rpc)
 {

-       struct srpc_service     *sv = rpc->srpc_scd->scd_svc;
-        srpc_msg_t       *replymsg = &rpc->srpc_replymsg;
-        srpc_msg_t       *reqstmsg = &rpc->srpc_reqstbuf->buf_msg;
-        srpc_brw_reply_t *reply = &replymsg->msg_body.brw_reply;
-        srpc_brw_reqst_t *reqst = &reqstmsg->msg_body.brw_reqst;
-       int               npg;
-        int               rc;
+       struct srpc_service *sv = rpc->srpc_scd->scd_svc;
+       struct srpc_msg *replymsg = &rpc->srpc_replymsg;
+       struct srpc_msg *reqstmsg = &rpc->srpc_reqstbuf->buf_msg;
+       struct srpc_brw_reply *reply = &replymsg->msg_body.brw_reply;
+       struct srpc_brw_reqst *reqst = &reqstmsg->msg_body.brw_reqst;
+       int npg;
+       int rc;

 
         LASSERT (sv->sv_id == SRPC_SERVICE_BRW);
 
 
         LASSERT (sv->sv_id == SRPC_SERVICE_BRW);
 


@@ -505,7 +505,8 @@ brw_server_handle(struct srpc_server_rpc *rpc)
         return 0;
 }
 
         return 0;
 }
 

-sfw_test_client_ops_t brw_test_client;
+struct sfw_test_client_ops brw_test_client;
+

 void brw_init_test_client(void)
 {
         brw_test_client.tso_init       = brw_client_init;
 void brw_init_test_client(void)
 {
         brw_test_client.tso_init       = brw_client_init;


@@ -514,10 +515,10 @@ void brw_init_test_client(void)
         brw_test_client.tso_done_rpc   = brw_client_done_rpc;
 };
 
         brw_test_client.tso_done_rpc   = brw_client_done_rpc;
 };
 

-srpc_service_t brw_test_service;
+struct srpc_service brw_test_service;
+

 void brw_init_test_service(void)
 {
 void brw_init_test_service(void)
 {

-

         brw_test_service.sv_id         = SRPC_SERVICE_BRW;
         brw_test_service.sv_name       = "brw_test";
         brw_test_service.sv_handler    = brw_server_handle;
         brw_test_service.sv_id         = SRPC_SERVICE_BRW;
         brw_test_service.sv_name       = "brw_test";
         brw_test_service.sv_handler    = brw_server_handle;

diff --git a/lnet/selftest/conctl.c b/lnet/selftest/conctl.c
index f9e4c0d..e5bba26 100644 (file)
--- a/lnet/selftest/conctl.c
+++ b/lnet/selftest/conctl.c
@@ -741,7 +741,7 @@ static int lst_test_add_ioctl(struct lstio_test_args *args)
         if (args->lstio_tes_param != NULL &&
             (args->lstio_tes_param_len <= 0 ||
             args->lstio_tes_param_len >
         if (args->lstio_tes_param != NULL &&
             (args->lstio_tes_param_len <= 0 ||
             args->lstio_tes_param_len >

-            PAGE_SIZE - sizeof(lstcon_test_t)))
+            PAGE_SIZE - sizeof(struct lstcon_test)))

                 return -EINVAL;
 
        LIBCFS_ALLOC(batch_name, args->lstio_tes_bat_nmlen + 1);
                 return -EINVAL;
 
        LIBCFS_ALLOC(batch_name, args->lstio_tes_bat_nmlen + 1);

diff --git a/lnet/selftest/conrpc.c b/lnet/selftest/conrpc.c
index 749714a..96a57f2 100644 (file)
--- a/lnet/selftest/conrpc.c
+++ b/lnet/selftest/conrpc.c
@@ -43,13 +43,13 @@
 #include "conrpc.h"
 #include "console.h"
 
 #include "conrpc.h"
 #include "console.h"
 

-void lstcon_rpc_stat_reply(lstcon_rpc_trans_t *, srpc_msg_t *,
-                          lstcon_node_t *, struct lstcon_trans_stat *);
+void lstcon_rpc_stat_reply(struct lstcon_rpc_trans *, struct srpc_msg *,
+                          struct lstcon_node *, struct lstcon_trans_stat *);

 
 static void
 
 static void

-lstcon_rpc_done(srpc_client_rpc_t *rpc)
+lstcon_rpc_done(struct srpc_client_rpc *rpc)

 {
 {

-       lstcon_rpc_t *crpc = (lstcon_rpc_t *)rpc->crpc_priv;
+       struct lstcon_rpc *crpc = rpc->crpc_priv;

 
        LASSERT(crpc != NULL && rpc == crpc->crp_rpc);
        LASSERT(crpc->crp_posted && !crpc->crp_finished);
 
        LASSERT(crpc != NULL && rpc == crpc->crp_rpc);
        LASSERT(crpc->crp_posted && !crpc->crp_finished);


@@ -85,8 +85,9 @@ lstcon_rpc_done(srpc_client_rpc_t *rpc)
 }
 
 static int
 }
 
 static int

-lstcon_rpc_init(lstcon_node_t *nd, int service, unsigned feats,
-               int bulk_npg, int bulk_len, int embedded, lstcon_rpc_t *crpc)
+lstcon_rpc_init(struct lstcon_node *nd, int service, unsigned int feats,
+               int bulk_npg, int bulk_len, int embedded,
+               struct lstcon_rpc *crpc)

 {
        crpc->crp_rpc = sfw_create_rpc(nd->nd_id, service,
                                       feats, bulk_npg, bulk_len,
 {
        crpc->crp_rpc = sfw_create_rpc(nd->nd_id, service,
                                       feats, bulk_npg, bulk_len,


@@ -110,17 +111,17 @@ lstcon_rpc_init(lstcon_node_t *nd, int service, unsigned feats,
 }
 
 static int
 }
 
 static int

-lstcon_rpc_prep(lstcon_node_t *nd, int service, unsigned feats,
-               int bulk_npg, int bulk_len, lstcon_rpc_t **crpcpp)
+lstcon_rpc_prep(struct lstcon_node *nd, int service, unsigned int feats,
+               int bulk_npg, int bulk_len, struct lstcon_rpc **crpcpp)

 {
 {

-       lstcon_rpc_t  *crpc = NULL;
-       int            rc;
+       struct lstcon_rpc *crpc = NULL;
+       int rc;

 
        spin_lock(&console_session.ses_rpc_lock);
 
        if (!list_empty(&console_session.ses_rpc_freelist)) {
                crpc = list_entry(console_session.ses_rpc_freelist.next,
 
        spin_lock(&console_session.ses_rpc_lock);
 
        if (!list_empty(&console_session.ses_rpc_freelist)) {
                crpc = list_entry(console_session.ses_rpc_freelist.next,

-                                 lstcon_rpc_t, crp_link);
+                                 struct lstcon_rpc, crp_link);

                list_del_init(&crpc->crp_link);
        }
 
                list_del_init(&crpc->crp_link);
        }
 


@@ -144,10 +145,10 @@ lstcon_rpc_prep(lstcon_node_t *nd, int service, unsigned feats,
 }
 
 void
 }
 
 void

-lstcon_rpc_put(lstcon_rpc_t *crpc)
+lstcon_rpc_put(struct lstcon_rpc *crpc)

 {
 {

-       srpc_bulk_t *bulk = &crpc->crp_rpc->crpc_bulk;
-       int          i;
+       struct srpc_bulk *bulk = &crpc->crp_rpc->crpc_bulk;
+       int i;

 
        LASSERT(list_empty(&crpc->crp_link));
 
 
        LASSERT(list_empty(&crpc->crp_link));
 


@@ -179,9 +180,9 @@ lstcon_rpc_put(lstcon_rpc_t *crpc)
 }
 
 static void
 }
 
 static void

-lstcon_rpc_post(lstcon_rpc_t *crpc)
+lstcon_rpc_post(struct lstcon_rpc *crpc)

 {
 {

-        lstcon_rpc_trans_t *trans = crpc->crp_trans;
+       struct lstcon_rpc_trans *trans = crpc->crp_trans;

 
         LASSERT (trans != NULL);
 
 
         LASSERT (trans != NULL);
 


@@ -232,9 +233,9 @@ lstcon_rpc_trans_name(int transop)
 
 int
 lstcon_rpc_trans_prep(struct list_head *translist, int transop,
 
 int
 lstcon_rpc_trans_prep(struct list_head *translist, int transop,

-                     lstcon_rpc_trans_t **transpp)
+                     struct lstcon_rpc_trans **transpp)

 {
 {

-       lstcon_rpc_trans_t *trans;
+       struct lstcon_rpc_trans *trans;

 
        if (translist != NULL) {
                list_for_each_entry(trans, translist, tas_link) {
 
        if (translist != NULL) {
                list_for_each_entry(trans, translist, tas_link) {


@@ -272,18 +273,18 @@ lstcon_rpc_trans_prep(struct list_head *translist, int transop,
 }
 
 void
 }
 
 void

-lstcon_rpc_trans_addreq(lstcon_rpc_trans_t *trans, lstcon_rpc_t *crpc)
+lstcon_rpc_trans_addreq(struct lstcon_rpc_trans *trans, struct lstcon_rpc *crpc)

 {
        list_add_tail(&crpc->crp_link, &trans->tas_rpcs_list);
        crpc->crp_trans = trans;
 }
 
 void
 {
        list_add_tail(&crpc->crp_link, &trans->tas_rpcs_list);
        crpc->crp_trans = trans;
 }
 
 void

-lstcon_rpc_trans_abort(lstcon_rpc_trans_t *trans, int error)
+lstcon_rpc_trans_abort(struct lstcon_rpc_trans *trans, int error)

 {
 {

-       srpc_client_rpc_t *rpc;
-       lstcon_rpc_t      *crpc;
-       lstcon_node_t     *nd;
+       struct srpc_client_rpc *rpc;
+       struct lstcon_rpc *crpc;
+       struct lstcon_node *nd;

 
        list_for_each_entry(crpc, &trans->tas_rpcs_list, crp_link) {
                rpc = crpc->crp_rpc;
 
        list_for_each_entry(crpc, &trans->tas_rpcs_list, crp_link) {
                rpc = crpc->crp_rpc;


@@ -320,7 +321,7 @@ lstcon_rpc_trans_abort(lstcon_rpc_trans_t *trans, int error)
 }
 
 static int
 }
 
 static int

-lstcon_rpc_trans_check(lstcon_rpc_trans_t *trans)
+lstcon_rpc_trans_check(struct lstcon_rpc_trans *trans)

 {
        if (console_session.ses_shutdown &&
            !list_empty(&trans->tas_olink)) /* Not an end session RPC */
 {
        if (console_session.ses_shutdown &&
            !list_empty(&trans->tas_olink)) /* Not an end session RPC */


@@ -330,10 +331,10 @@ lstcon_rpc_trans_check(lstcon_rpc_trans_t *trans)
 }
 
 int
 }
 
 int

-lstcon_rpc_trans_postwait(lstcon_rpc_trans_t *trans, int timeout)
+lstcon_rpc_trans_postwait(struct lstcon_rpc_trans *trans, int timeout)

 {
 {

-       lstcon_rpc_t  *crpc;
-       int            rc;
+       struct lstcon_rpc *crpc;
+       int rc;

 
        if (list_empty(&trans->tas_rpcs_list))
                 return 0;
 
        if (list_empty(&trans->tas_rpcs_list))
                 return 0;


@@ -381,11 +382,11 @@ lstcon_rpc_trans_postwait(lstcon_rpc_trans_t *trans, int timeout)
 }
 
 static int
 }
 
 static int

-lstcon_rpc_get_reply(lstcon_rpc_t *crpc, srpc_msg_t **msgpp)
+lstcon_rpc_get_reply(struct lstcon_rpc *crpc, struct srpc_msg **msgpp)

 {
 {

-        lstcon_node_t        *nd  = crpc->crp_node;
-        srpc_client_rpc_t    *rpc = crpc->crp_rpc;
-        srpc_generic_reply_t *rep;
+       struct lstcon_node *nd = crpc->crp_node;
+       struct srpc_client_rpc *rpc = crpc->crp_rpc;
+       struct srpc_generic_reply *rep;

 
         LASSERT (nd != NULL && rpc != NULL);
         LASSERT (crpc->crp_stamp != 0);
 
         LASSERT (nd != NULL && rpc != NULL);
         LASSERT (crpc->crp_stamp != 0);


@@ -418,11 +419,12 @@ lstcon_rpc_get_reply(lstcon_rpc_t *crpc, srpc_msg_t **msgpp)
 }
 
 void
 }
 
 void

-lstcon_rpc_trans_stat(lstcon_rpc_trans_t *trans, struct lstcon_trans_stat *stat)
+lstcon_rpc_trans_stat(struct lstcon_rpc_trans *trans,
+                     struct lstcon_trans_stat *stat)

 {
 {

-       lstcon_rpc_t    *crpc;
-       srpc_msg_t      *rep;
-       int              error;
+       struct lstcon_rpc *crpc;
+       struct srpc_msg *rep;
+       int error;

 
        LASSERT(stat != NULL);
 
 
        LASSERT(stat != NULL);
 


@@ -464,20 +466,20 @@ lstcon_rpc_trans_stat(lstcon_rpc_trans_t *trans, struct lstcon_trans_stat *stat)
 }
 
 int
 }
 
 int

-lstcon_rpc_trans_interpreter(lstcon_rpc_trans_t *trans,
+lstcon_rpc_trans_interpreter(struct lstcon_rpc_trans *trans,

                             struct list_head __user *head_up,
                             lstcon_rpc_readent_func_t readent)
 {
                             struct list_head __user *head_up,
                             lstcon_rpc_readent_func_t readent)
 {

-       struct list_head      tmp;
-       struct list_head     __user *next;
-       struct lstcon_rpc_ent     *ent;
-        srpc_generic_reply_t *rep;
-        lstcon_rpc_t         *crpc;
-        srpc_msg_t           *msg;
-        lstcon_node_t        *nd;
-        cfs_duration_t        dur;
-        struct timeval        tv;
-        int                   error;
+       struct list_head tmp;
+       struct list_head __user *next;
+       struct lstcon_rpc_ent *ent;
+       struct srpc_generic_reply *rep;
+       struct lstcon_rpc *crpc;
+       struct srpc_msg *msg;
+       struct lstcon_node *nd;
+       cfs_duration_t dur;
+       struct timeval tv;
+       int error;

 
        LASSERT(head_up != NULL);
 
 
        LASSERT(head_up != NULL);
 


@@ -518,7 +520,7 @@ lstcon_rpc_trans_interpreter(lstcon_rpc_trans_t *trans,
                        continue;
 
                /* RPC is done */
                        continue;
 
                /* RPC is done */

-               rep = (srpc_generic_reply_t *)&msg->msg_body.reply;
+               rep = (struct srpc_generic_reply *)&msg->msg_body.reply;

 
                if (copy_to_user(&ent->rpe_sid,
                                 &rep->sid, sizeof(rep->sid)) ||
 
                if (copy_to_user(&ent->rpe_sid,
                                 &rep->sid, sizeof(rep->sid)) ||


@@ -538,12 +540,12 @@ lstcon_rpc_trans_interpreter(lstcon_rpc_trans_t *trans,
 }
 
 void
 }
 
 void

-lstcon_rpc_trans_destroy(lstcon_rpc_trans_t *trans)
+lstcon_rpc_trans_destroy(struct lstcon_rpc_trans *trans)

 {
 {

-       srpc_client_rpc_t *rpc;
-       lstcon_rpc_t      *crpc;
-       lstcon_rpc_t      *tmp;
-       int                count = 0;
+       struct srpc_client_rpc *rpc;
+       struct lstcon_rpc *crpc;
+       struct lstcon_rpc *tmp;
+       int count = 0;

 
        list_for_each_entry_safe(crpc, tmp, &trans->tas_rpcs_list, crp_link) {
                rpc = crpc->crp_rpc;
 
        list_for_each_entry_safe(crpc, tmp, &trans->tas_rpcs_list, crp_link) {
                rpc = crpc->crp_rpc;


@@ -592,12 +594,12 @@ lstcon_rpc_trans_destroy(lstcon_rpc_trans_t *trans)
 }
 
 int
 }
 
 int

-lstcon_sesrpc_prep(lstcon_node_t *nd, int transop,
-                  unsigned feats, lstcon_rpc_t **crpc)
+lstcon_sesrpc_prep(struct lstcon_node *nd, int transop,
+                  unsigned int feats, struct lstcon_rpc **crpc)

 {
 {

-        srpc_mksn_reqst_t *msrq;
-        srpc_rmsn_reqst_t *rsrq;
-        int                rc;
+       struct srpc_mksn_reqst *msrq;
+       struct srpc_rmsn_reqst *rsrq;
+       int rc;

 
         switch (transop) {
         case LST_TRANS_SESNEW:
 
         switch (transop) {
         case LST_TRANS_SESNEW:


@@ -631,10 +633,11 @@ lstcon_sesrpc_prep(lstcon_node_t *nd, int transop,
 }
 
 int
 }
 
 int

-lstcon_dbgrpc_prep(lstcon_node_t *nd, unsigned feats, lstcon_rpc_t **crpc)
+lstcon_dbgrpc_prep(struct lstcon_node *nd, unsigned int feats,
+                  struct lstcon_rpc **crpc)

 {
 {

-       srpc_debug_reqst_t *drq;
-       int                 rc;
+       struct srpc_debug_reqst *drq;
+       int rc;

 
        rc = lstcon_rpc_prep(nd, SRPC_SERVICE_DEBUG, feats, 0, 0, crpc);
         if (rc != 0)
 
        rc = lstcon_rpc_prep(nd, SRPC_SERVICE_DEBUG, feats, 0, 0, crpc);
         if (rc != 0)


@@ -649,12 +652,12 @@ lstcon_dbgrpc_prep(lstcon_node_t *nd, unsigned feats, lstcon_rpc_t **crpc)
 }
 
 int
 }
 
 int

-lstcon_batrpc_prep(lstcon_node_t *nd, int transop, unsigned feats,
-                  lstcon_tsb_hdr_t *tsb, lstcon_rpc_t **crpc)
+lstcon_batrpc_prep(struct lstcon_node *nd, int transop, unsigned int feats,
+                  struct lstcon_tsb_hdr *tsb, struct lstcon_rpc **crpc)

 {
 {

-       lstcon_batch_t     *batch;
-       srpc_batch_reqst_t *brq;
-       int                 rc;
+       struct lstcon_batch *batch;
+       struct srpc_batch_reqst *brq;
+       int rc;

 
        rc = lstcon_rpc_prep(nd, SRPC_SERVICE_BATCH, feats, 0, 0, crpc);
         if (rc != 0)
 
        rc = lstcon_rpc_prep(nd, SRPC_SERVICE_BATCH, feats, 0, 0, crpc);
         if (rc != 0)


@@ -675,17 +678,18 @@ lstcon_batrpc_prep(lstcon_node_t *nd, int transop, unsigned feats,
 
         LASSERT (tsb->tsb_index == 0);
 
 
         LASSERT (tsb->tsb_index == 0);
 

-        batch = (lstcon_batch_t *)tsb;
+       batch = (struct lstcon_batch *)tsb;

         brq->bar_arg = batch->bat_arg;
 
         return 0;
 }
 
 int
         brq->bar_arg = batch->bat_arg;
 
         return 0;
 }
 
 int

-lstcon_statrpc_prep(lstcon_node_t *nd, unsigned feats, lstcon_rpc_t **crpc)
+lstcon_statrpc_prep(struct lstcon_node *nd, unsigned int feats,
+                   struct lstcon_rpc **crpc)

 {
 {

-       srpc_stat_reqst_t *srq;
-       int                rc;
+       struct srpc_stat_reqst *srq;
+       int rc;

 
        rc = lstcon_rpc_prep(nd, SRPC_SERVICE_QUERY_STAT, feats, 0, 0, crpc);
         if (rc != 0)
 
        rc = lstcon_rpc_prep(nd, SRPC_SERVICE_QUERY_STAT, feats, 0, 0, crpc);
         if (rc != 0)


@@ -715,15 +719,15 @@ lstcon_next_id(int idx, int nkiov, lnet_kiov_t *kiov)
 }
 
 static int
 }
 
 static int

-lstcon_dstnodes_prep(lstcon_group_t *grp, int idx,
+lstcon_dstnodes_prep(struct lstcon_group *grp, int idx,

                      int dist, int span, int nkiov, lnet_kiov_t *kiov)
 {
        struct lnet_process_id_packed *pid;
                      int dist, int span, int nkiov, lnet_kiov_t *kiov)
 {
        struct lnet_process_id_packed *pid;

-        lstcon_ndlink_t          *ndl;
-        lstcon_node_t            *nd;
-        int                       start;
-        int                       end;
-        int                       i = 0;
+       struct lstcon_ndlink *ndl;
+       struct lstcon_node *nd;
+       int start;
+       int end;
+       int i = 0;

 
         LASSERT (dist >= 1);
         LASSERT (span >= 1);
 
         LASSERT (dist >= 1);
         LASSERT (span >= 1);


@@ -769,9 +773,10 @@ lstcon_dstnodes_prep(lstcon_group_t *grp, int idx,
 }
 
 static int
 }
 
 static int

-lstcon_pingrpc_prep(struct lst_test_ping_param *param, srpc_test_reqst_t *req)
+lstcon_pingrpc_prep(struct lst_test_ping_param *param,
+                   struct srpc_test_reqst *req)

 {
 {

-        test_ping_req_t *prq = &req->tsr_u.ping;
+       struct test_ping_req *prq = &req->tsr_u.ping;

 
         prq->png_size   = param->png_size;
         prq->png_flags  = param->png_flags;
 
         prq->png_size   = param->png_size;
         prq->png_flags  = param->png_flags;


@@ -780,9 +785,10 @@ lstcon_pingrpc_prep(struct lst_test_ping_param *param, srpc_test_reqst_t *req)
 }
 
 static int
 }
 
 static int

-lstcon_bulkrpc_v0_prep(struct lst_test_bulk_param *param, srpc_test_reqst_t *req)
+lstcon_bulkrpc_v0_prep(struct lst_test_bulk_param *param,
+                      struct srpc_test_reqst *req)

 {
 {

-       test_bulk_req_t *brq = &req->tsr_u.bulk_v0;
+       struct test_bulk_req *brq = &req->tsr_u.bulk_v0;

 
        brq->blk_opc    = param->blk_opc;
        brq->blk_npg    = (param->blk_size + PAGE_SIZE - 1) /
 
        brq->blk_opc    = param->blk_opc;
        brq->blk_npg    = (param->blk_size + PAGE_SIZE - 1) /


@@ -794,9 +800,9 @@ lstcon_bulkrpc_v0_prep(struct lst_test_bulk_param *param, srpc_test_reqst_t *req
 
 static int
 lstcon_bulkrpc_v1_prep(struct lst_test_bulk_param *param, bool is_client,
 
 static int
 lstcon_bulkrpc_v1_prep(struct lst_test_bulk_param *param, bool is_client,

-                      srpc_test_reqst_t *req)
+                      struct srpc_test_reqst *req)

 {
 {

-       test_bulk_req_v1_t *brq = &req->tsr_u.bulk_v1;
+       struct test_bulk_req_v1 *brq = &req->tsr_u.bulk_v1;

 
        brq->blk_opc    = param->blk_opc;
        brq->blk_flags  = param->blk_flags;
 
        brq->blk_opc    = param->blk_opc;
        brq->blk_flags  = param->blk_flags;


@@ -807,17 +813,17 @@ lstcon_bulkrpc_v1_prep(struct lst_test_bulk_param *param, bool is_client,
 }
 
 int
 }
 
 int

-lstcon_testrpc_prep(lstcon_node_t *nd, int transop, unsigned feats,
-                    lstcon_test_t *test, lstcon_rpc_t **crpc)
+lstcon_testrpc_prep(struct lstcon_node *nd, int transop, unsigned int feats,
+                   struct lstcon_test *test, struct lstcon_rpc **crpc)

 {
 {

-        lstcon_group_t    *sgrp = test->tes_src_grp;
-        lstcon_group_t    *dgrp = test->tes_dst_grp;
-        srpc_test_reqst_t *trq;
-        srpc_bulk_t       *bulk;
-        int                i;
-       int                npg = 0;
-       int                nob = 0;
-       int                rc  = 0;
+       struct lstcon_group *sgrp = test->tes_src_grp;
+       struct lstcon_group *dgrp = test->tes_dst_grp;
+       struct srpc_test_reqst *trq;
+       struct srpc_bulk *bulk;
+       int i;
+       int npg = 0;
+       int nob = 0;
+       int rc = 0;

 
        if (transop == LST_TRANS_TSBCLIADD) {
                npg = sfw_id_pages(test->tes_span);
 
        if (transop == LST_TRANS_TSBCLIADD) {
                npg = sfw_id_pages(test->tes_span);


@@ -915,11 +921,11 @@ lstcon_testrpc_prep(lstcon_node_t *nd, int transop, unsigned feats,
 }
 
 static int
 }
 
 static int

-lstcon_sesnew_stat_reply(lstcon_rpc_trans_t *trans,
-                        lstcon_node_t *nd, srpc_msg_t *reply)
+lstcon_sesnew_stat_reply(struct lstcon_rpc_trans *trans,
+                        struct lstcon_node *nd, struct srpc_msg *reply)

 {
 {

-       srpc_mksn_reply_t *mksn_rep = &reply->msg_body.mksn_reply;
-       int                status   = mksn_rep->mksn_status;
+       struct srpc_mksn_reply *mksn_rep = &reply->msg_body.mksn_reply;
+       int status = mksn_rep->mksn_status;

 
        if (status == 0 &&
            (reply->msg_ses_feats & ~LST_FEATS_MASK) != 0) {
 
        if (status == 0 &&
            (reply->msg_ses_feats & ~LST_FEATS_MASK) != 0) {


@@ -962,15 +968,15 @@ lstcon_sesnew_stat_reply(lstcon_rpc_trans_t *trans,
 }
 
 void
 }
 
 void

-lstcon_rpc_stat_reply(lstcon_rpc_trans_t *trans, srpc_msg_t *msg,
-                     lstcon_node_t *nd, struct lstcon_trans_stat *stat)
+lstcon_rpc_stat_reply(struct lstcon_rpc_trans *trans, struct srpc_msg *msg,
+                     struct lstcon_node *nd, struct lstcon_trans_stat *stat)

 {
 {

-        srpc_rmsn_reply_t  *rmsn_rep;
-        srpc_debug_reply_t *dbg_rep;
-        srpc_batch_reply_t *bat_rep;
-        srpc_test_reply_t  *test_rep;
-        srpc_stat_reply_t  *stat_rep;
-        int                 rc = 0;
+       struct srpc_rmsn_reply *rmsn_rep;
+       struct srpc_debug_reply *dbg_rep;
+       struct srpc_batch_reply *bat_rep;
+       struct srpc_test_reply *test_rep;
+       struct srpc_stat_reply *stat_rep;
+       int rc = 0;

 
        switch (trans->tas_opc) {
        case LST_TRANS_SESNEW:
 
        switch (trans->tas_opc) {
        case LST_TRANS_SESNEW:


@@ -1085,14 +1091,14 @@ int
 lstcon_rpc_trans_ndlist(struct list_head *ndlist,
                        struct list_head *translist, int transop,
                        void *arg, lstcon_rpc_cond_func_t condition,
 lstcon_rpc_trans_ndlist(struct list_head *ndlist,
                        struct list_head *translist, int transop,
                        void *arg, lstcon_rpc_cond_func_t condition,

-                       lstcon_rpc_trans_t **transpp)
+                       struct lstcon_rpc_trans **transpp)

 {
 {

-        lstcon_rpc_trans_t *trans;
-        lstcon_ndlink_t    *ndl;
-        lstcon_node_t      *nd;
-        lstcon_rpc_t       *rpc;
-       unsigned            feats;
-        int                 rc;
+       struct lstcon_rpc_trans *trans;
+       struct lstcon_ndlink *ndl;
+       struct lstcon_node *nd;
+       struct lstcon_rpc *rpc;
+       unsigned int feats;
+       int rc;

 
         /* Creating session RPG for list of nodes */
 
 
         /* Creating session RPG for list of nodes */
 


@@ -1130,14 +1136,16 @@ lstcon_rpc_trans_ndlist(struct list_head *ndlist,
                case LST_TRANS_TSBCLIADD:
                case LST_TRANS_TSBSRVADD:
                        rc = lstcon_testrpc_prep(nd, transop, feats,
                case LST_TRANS_TSBCLIADD:
                case LST_TRANS_TSBSRVADD:
                        rc = lstcon_testrpc_prep(nd, transop, feats,

-                                                (lstcon_test_t *)arg, &rpc);
+                                                (struct lstcon_test *)arg,
+                                                &rpc);

                        break;
                case LST_TRANS_TSBRUN:
                case LST_TRANS_TSBSTOP:
                case LST_TRANS_TSBCLIQRY:
                case LST_TRANS_TSBSRVQRY:
                        rc = lstcon_batrpc_prep(nd, transop, feats,
                        break;
                case LST_TRANS_TSBRUN:
                case LST_TRANS_TSBSTOP:
                case LST_TRANS_TSBCLIQRY:
                case LST_TRANS_TSBSRVQRY:
                        rc = lstcon_batrpc_prep(nd, transop, feats,

-                                               (lstcon_tsb_hdr_t *)arg, &rpc);
+                                               (struct lstcon_tsb_hdr *)arg,
+                                               &rpc);

                        break;
                case LST_TRANS_STATQRY:
                        rc = lstcon_statrpc_prep(nd, feats, &rpc);
                        break;
                case LST_TRANS_STATQRY:
                        rc = lstcon_statrpc_prep(nd, feats, &rpc);


@@ -1169,16 +1177,16 @@ lstcon_rpc_trans_ndlist(struct list_head *ndlist,
 static void
 lstcon_rpc_pinger(void *arg)
 {
 static void
 lstcon_rpc_pinger(void *arg)
 {

-        stt_timer_t        *ptimer = (stt_timer_t *)arg;
-        lstcon_rpc_trans_t *trans;
-        lstcon_rpc_t       *crpc;
-        srpc_msg_t         *rep;
-        srpc_debug_reqst_t *drq;
-        lstcon_ndlink_t    *ndl;
-        lstcon_node_t      *nd;
+       struct stt_timer *ptimer = arg;
+       struct lstcon_rpc_trans *trans;
+       struct lstcon_rpc *crpc;
+       struct srpc_msg *rep;
+       struct srpc_debug_reqst *drq;
+       struct lstcon_ndlink *ndl;
+       struct lstcon_node *nd;

        int intv;
        int intv;

-        int                 count = 0;
-        int                 rc;
+       int count = 0;
+       int rc;

 
         /* RPC pinger is a special case of transaction,
          * it's called by timer at 8 seconds interval.
 
         /* RPC pinger is a special case of transaction,
          * it's called by timer at 8 seconds interval.


@@ -1286,8 +1294,8 @@ lstcon_rpc_pinger(void *arg)
 int
 lstcon_rpc_pinger_start(void)
 {
 int
 lstcon_rpc_pinger_start(void)
 {

-       stt_timer_t     *ptimer;
-       int              rc;
+       struct stt_timer *ptimer;
+       int rc;

 
        LASSERT(list_empty(&console_session.ses_rpc_freelist));
        LASSERT(atomic_read(&console_session.ses_rpc_counter) == 0);
 
        LASSERT(list_empty(&console_session.ses_rpc_freelist));
        LASSERT(atomic_read(&console_session.ses_rpc_counter) == 0);


@@ -1326,10 +1334,10 @@ lstcon_rpc_pinger_stop(void)
 void
 lstcon_rpc_cleanup_wait(void)
 {
 void
 lstcon_rpc_cleanup_wait(void)
 {

-       lstcon_rpc_trans_t      *trans;
-       lstcon_rpc_t            *crpc;
-       struct list_head        *pacer;
-       struct list_head         zlist;
+       struct lstcon_rpc_trans *trans;
+       struct lstcon_rpc *crpc;
+       struct list_head *pacer;
+       struct list_head zlist;

 
        /* Called with hold of global mutex */
 
 
        /* Called with hold of global mutex */
 


@@ -1337,7 +1345,7 @@ lstcon_rpc_cleanup_wait(void)
 
        while (!list_empty(&console_session.ses_trans_list)) {
                list_for_each(pacer, &console_session.ses_trans_list) {
 
        while (!list_empty(&console_session.ses_trans_list)) {
                list_for_each(pacer, &console_session.ses_trans_list) {

-                       trans = list_entry(pacer, lstcon_rpc_trans_t,
+                       trans = list_entry(pacer, struct lstcon_rpc_trans,

                                           tas_link);
 
                        CDEBUG(D_NET, "Session closed, wakeup transaction %s\n",
                                           tas_link);
 
                        CDEBUG(D_NET, "Session closed, wakeup transaction %s\n",


@@ -1370,10 +1378,10 @@ lstcon_rpc_cleanup_wait(void)
        spin_unlock(&console_session.ses_rpc_lock);
 
        while (!list_empty(&zlist)) {
        spin_unlock(&console_session.ses_rpc_lock);
 
        while (!list_empty(&zlist)) {

-               crpc = list_entry(zlist.next, lstcon_rpc_t, crp_link);
+               crpc = list_entry(zlist.next, struct lstcon_rpc, crp_link);

 
                list_del(&crpc->crp_link);
 
                list_del(&crpc->crp_link);

-               LIBCFS_FREE(crpc, sizeof(lstcon_rpc_t));
+               LIBCFS_FREE(crpc, sizeof(*crpc));

        }
 }
 
        }
 }
 

diff --git a/lnet/selftest/conrpc.h b/lnet/selftest/conrpc.h
index 3ac7005..364c33f 100644 (file)
--- a/lnet/selftest/conrpc.h
+++ b/lnet/selftest/conrpc.h
@@ -59,9 +59,9 @@ struct lstcon_tsb_hdr;
 struct lstcon_test;
 struct lstcon_node;
 
 struct lstcon_test;
 struct lstcon_node;
 

-typedef struct lstcon_rpc {
+struct lstcon_rpc {

        struct list_head         crp_link;      /* chain on rpc transaction */
        struct list_head         crp_link;      /* chain on rpc transaction */

-       srpc_client_rpc_t       *crp_rpc;       /* client rpc */
+       struct srpc_client_rpc  *crp_rpc;       /* client rpc */

        struct lstcon_node      *crp_node;      /* destination node */
        struct lstcon_rpc_trans *crp_trans;     /* conrpc transaction */
 
        struct lstcon_node      *crp_node;      /* destination node */
        struct lstcon_rpc_trans *crp_trans;     /* conrpc transaction */
 


@@ -72,9 +72,9 @@ typedef struct lstcon_rpc {
        unsigned int             crp_embedded:1;
         int                      crp_status;     /* console rpc errors */
         cfs_time_t               crp_stamp;      /* replied time stamp */
        unsigned int             crp_embedded:1;
         int                      crp_status;     /* console rpc errors */
         cfs_time_t               crp_stamp;      /* replied time stamp */

-} lstcon_rpc_t;
+};

 
 

-typedef struct lstcon_rpc_trans {
+struct lstcon_rpc_trans {

        /* link chain on owner list */
        struct list_head        tas_olink;
        /* link chain on global list */
        /* link chain on owner list */
        struct list_head        tas_olink;
        /* link chain on global list */


@@ -88,7 +88,7 @@ typedef struct lstcon_rpc_trans {
        wait_queue_head_t       tas_waitq;      /* wait queue head */
        atomic_t                tas_remaining;  /* # of un-scheduled rpcs */
        struct list_head        tas_rpcs_list;  /* queued requests */
        wait_queue_head_t       tas_waitq;      /* wait queue head */
        atomic_t                tas_remaining;  /* # of un-scheduled rpcs */
        struct list_head        tas_rpcs_list;  /* queued requests */

-} lstcon_rpc_trans_t;
+};

 
 #define LST_TRANS_PRIVATE       0x1000
 
 
 #define LST_TRANS_PRIVATE       0x1000
 


@@ -106,36 +106,37 @@ typedef struct lstcon_rpc_trans {
 
 #define LST_TRANS_STATQRY       0x21
 
 
 #define LST_TRANS_STATQRY       0x21
 

-typedef int (* lstcon_rpc_cond_func_t)(int, struct lstcon_node *, void *);
-typedef int (*lstcon_rpc_readent_func_t)(int, srpc_msg_t *,
+typedef int (*lstcon_rpc_cond_func_t)(int, struct lstcon_node *, void *);
+typedef int (*lstcon_rpc_readent_func_t)(int, struct srpc_msg *,

                                         struct lstcon_rpc_ent __user *);
 
 int  lstcon_sesrpc_prep(struct lstcon_node *nd, int transop,
                                         struct lstcon_rpc_ent __user *);
 
 int  lstcon_sesrpc_prep(struct lstcon_node *nd, int transop,

-                       unsigned version, lstcon_rpc_t **crpc);
+                       unsigned int version, struct lstcon_rpc **crpc);

 int  lstcon_dbgrpc_prep(struct lstcon_node *nd,
 int  lstcon_dbgrpc_prep(struct lstcon_node *nd,

-                       unsigned version, lstcon_rpc_t **crpc);
+                       unsigned int version, struct lstcon_rpc **crpc);

 int  lstcon_batrpc_prep(struct lstcon_node *nd, int transop, unsigned version,
 int  lstcon_batrpc_prep(struct lstcon_node *nd, int transop, unsigned version,

-                        struct lstcon_tsb_hdr *tsb, lstcon_rpc_t **crpc);
+                       struct lstcon_tsb_hdr *tsb, struct lstcon_rpc **crpc);

 int  lstcon_testrpc_prep(struct lstcon_node *nd, int transop, unsigned version,
 int  lstcon_testrpc_prep(struct lstcon_node *nd, int transop, unsigned version,

-                         struct lstcon_test *test, lstcon_rpc_t **crpc);
+                        struct lstcon_test *test, struct lstcon_rpc **crpc);

 int  lstcon_statrpc_prep(struct lstcon_node *nd, unsigned version,
 int  lstcon_statrpc_prep(struct lstcon_node *nd, unsigned version,

-                        lstcon_rpc_t **crpc);
-void lstcon_rpc_put(lstcon_rpc_t *crpc);
+                        struct lstcon_rpc **crpc);
+void lstcon_rpc_put(struct lstcon_rpc *crpc);

 int  lstcon_rpc_trans_prep(struct list_head *translist,
 int  lstcon_rpc_trans_prep(struct list_head *translist,

-                          int transop, lstcon_rpc_trans_t **transpp);
+                          int transop, struct lstcon_rpc_trans **transpp);

 int  lstcon_rpc_trans_ndlist(struct list_head *ndlist,
                             struct list_head *translist, int transop,
                             void *arg, lstcon_rpc_cond_func_t condition,
 int  lstcon_rpc_trans_ndlist(struct list_head *ndlist,
                             struct list_head *translist, int transop,
                             void *arg, lstcon_rpc_cond_func_t condition,

-                            lstcon_rpc_trans_t **transpp);
-void lstcon_rpc_trans_stat(lstcon_rpc_trans_t *trans,
+                            struct lstcon_rpc_trans **transpp);
+void lstcon_rpc_trans_stat(struct lstcon_rpc_trans *trans,

                           struct lstcon_trans_stat *stat);
                           struct lstcon_trans_stat *stat);

-int  lstcon_rpc_trans_interpreter(lstcon_rpc_trans_t *trans,
+int  lstcon_rpc_trans_interpreter(struct lstcon_rpc_trans *trans,

                                  struct list_head __user *head_up,
                                  lstcon_rpc_readent_func_t readent);
                                  struct list_head __user *head_up,
                                  lstcon_rpc_readent_func_t readent);

-void lstcon_rpc_trans_abort(lstcon_rpc_trans_t *trans, int error);
-void lstcon_rpc_trans_destroy(lstcon_rpc_trans_t *trans);
-void lstcon_rpc_trans_addreq(lstcon_rpc_trans_t *trans, lstcon_rpc_t *req);
-int  lstcon_rpc_trans_postwait(lstcon_rpc_trans_t *trans, int timeout);
+void lstcon_rpc_trans_abort(struct lstcon_rpc_trans *trans, int error);
+void lstcon_rpc_trans_destroy(struct lstcon_rpc_trans *trans);
+void lstcon_rpc_trans_addreq(struct lstcon_rpc_trans *trans,
+                            struct lstcon_rpc *req);
+int  lstcon_rpc_trans_postwait(struct lstcon_rpc_trans *trans, int timeout);

 int  lstcon_rpc_pinger_start(void);
 void lstcon_rpc_pinger_stop(void);
 void lstcon_rpc_cleanup_wait(void);
 int  lstcon_rpc_pinger_start(void);
 void lstcon_rpc_pinger_stop(void);
 void lstcon_rpc_cleanup_wait(void);

diff --git a/lnet/selftest/console.c b/lnet/selftest/console.c
index f2cf0a4..48b980d 100644 (file)
--- a/lnet/selftest/console.c
+++ b/lnet/selftest/console.c
@@ -55,10 +55,10 @@ do {                                                    \
         (p)->nle_nnode ++;                              \
 } while (0)
 
         (p)->nle_nnode ++;                              \
 } while (0)
 

-lstcon_session_t        console_session;
+struct lstcon_session console_session;

 
 static void
 
 static void

-lstcon_node_get(lstcon_node_t *nd)
+lstcon_node_get(struct lstcon_node *nd)

 {
         LASSERT (nd->nd_ref >= 1);
 
 {
         LASSERT (nd->nd_ref >= 1);
 


@@ -66,10 +66,11 @@ lstcon_node_get(lstcon_node_t *nd)
 }
 
 static int
 }
 
 static int

-lstcon_node_find(struct lnet_process_id id, lstcon_node_t **ndpp, int create)
+lstcon_node_find(struct lnet_process_id id, struct lstcon_node **ndpp,
+                int create)

 {
 {

-       lstcon_ndlink_t *ndl;
-       unsigned int     idx = LNET_NIDADDR(id.nid) % LST_GLOBAL_HASHSIZE;
+       struct lstcon_ndlink *ndl;
+       unsigned int idx = LNET_NIDADDR(id.nid) % LST_GLOBAL_HASHSIZE;

 
        LASSERT(id.nid != LNET_NID_ANY);
 
 
        LASSERT(id.nid != LNET_NID_ANY);
 


@@ -87,11 +88,11 @@ lstcon_node_find(struct lnet_process_id id, lstcon_node_t **ndpp, int create)
         if (!create)
                 return -ENOENT;
 
         if (!create)
                 return -ENOENT;
 

-        LIBCFS_ALLOC(*ndpp, sizeof(lstcon_node_t) + sizeof(lstcon_ndlink_t));
-        if (*ndpp == NULL)
-                return -ENOMEM;
+       LIBCFS_ALLOC(*ndpp, sizeof(**ndpp) + sizeof(*ndl));
+       if (*ndpp == NULL)
+               return -ENOMEM;

 
 

-        ndl = (lstcon_ndlink_t *)(*ndpp + 1);
+       ndl = (struct lstcon_ndlink *)(*ndpp + 1);

 
         ndl->ndl_node = *ndpp;
 
 
         ndl->ndl_node = *ndpp;
 


@@ -100,7 +101,7 @@ lstcon_node_find(struct lnet_process_id id, lstcon_node_t **ndpp, int create)
         ndl->ndl_node->nd_stamp = cfs_time_current();
         ndl->ndl_node->nd_state = LST_NODE_UNKNOWN;
         ndl->ndl_node->nd_timeout = 0;
         ndl->ndl_node->nd_stamp = cfs_time_current();
         ndl->ndl_node->nd_state = LST_NODE_UNKNOWN;
         ndl->ndl_node->nd_timeout = 0;

-        memset(&ndl->ndl_node->nd_ping, 0, sizeof(lstcon_rpc_t));
+       memset(&ndl->ndl_node->nd_ping, 0, sizeof(ndl->ndl_node->nd_ping));

 
        /* queued in global hash & list, no refcount is taken by
         * global hash & list, if caller release his refcount,
 
        /* queued in global hash & list, no refcount is taken by
         * global hash & list, if caller release his refcount,


@@ -112,16 +113,16 @@ lstcon_node_find(struct lnet_process_id id, lstcon_node_t **ndpp, int create)
 }
 
 static void
 }
 
 static void

-lstcon_node_put(lstcon_node_t *nd)
+lstcon_node_put(struct lstcon_node *nd)

 {
 {

-       lstcon_ndlink_t *ndl;
+       struct lstcon_ndlink *ndl;

 
        LASSERT(nd->nd_ref > 0);
 
        if (--nd->nd_ref > 0)
                return;
 
 
        LASSERT(nd->nd_ref > 0);
 
        if (--nd->nd_ref > 0)
                return;
 

-       ndl = (lstcon_ndlink_t *)(nd + 1);
+       ndl = (struct lstcon_ndlink *)(nd + 1);

 
        LASSERT(!list_empty(&ndl->ndl_link));
        LASSERT(!list_empty(&ndl->ndl_hlink));
 
        LASSERT(!list_empty(&ndl->ndl_link));
        LASSERT(!list_empty(&ndl->ndl_hlink));


@@ -130,17 +131,17 @@ lstcon_node_put(lstcon_node_t *nd)
        list_del(&ndl->ndl_link);
        list_del(&ndl->ndl_hlink);
 
        list_del(&ndl->ndl_link);
        list_del(&ndl->ndl_hlink);
 

-       LIBCFS_FREE(nd, sizeof(lstcon_node_t) + sizeof(lstcon_ndlink_t));
+       LIBCFS_FREE(nd, sizeof(*nd) + sizeof(*ndl));

 }
 
 static int
 lstcon_ndlink_find(struct list_head *hash, struct lnet_process_id id,
 }
 
 static int
 lstcon_ndlink_find(struct list_head *hash, struct lnet_process_id id,

-                  lstcon_ndlink_t **ndlpp, int create)
+                  struct lstcon_ndlink **ndlpp, int create)

 {
 {

-       unsigned int     idx = LNET_NIDADDR(id.nid) % LST_NODE_HASHSIZE;
-       lstcon_ndlink_t *ndl;
-       lstcon_node_t   *nd;
-       int              rc;
+       unsigned int idx = LNET_NIDADDR(id.nid) % LST_NODE_HASHSIZE;
+       struct lstcon_ndlink *ndl;
+       struct lstcon_node *nd;
+       int rc;

 
        if (id.nid == LNET_NID_ANY)
                return -EINVAL;
 
        if (id.nid == LNET_NID_ANY)
                return -EINVAL;


@@ -163,7 +164,7 @@ lstcon_ndlink_find(struct list_head *hash, struct lnet_process_id id,
         if (rc != 0)
                 return rc;
 
         if (rc != 0)
                 return rc;
 

-        LIBCFS_ALLOC(ndl, sizeof(lstcon_ndlink_t));
+       LIBCFS_ALLOC(ndl, sizeof(*ndl));

         if (ndl == NULL) {
                 lstcon_node_put(nd);
                 return -ENOMEM;
         if (ndl == NULL) {
                 lstcon_node_put(nd);
                 return -ENOMEM;


@@ -179,7 +180,7 @@ lstcon_ndlink_find(struct list_head *hash, struct lnet_process_id id,
 }
 
 static void
 }
 
 static void

-lstcon_ndlink_release(lstcon_ndlink_t *ndl)
+lstcon_ndlink_release(struct lstcon_ndlink *ndl)

 {
        LASSERT(list_empty(&ndl->ndl_link));
        LASSERT(!list_empty(&ndl->ndl_hlink));
 {
        LASSERT(list_empty(&ndl->ndl_link));
        LASSERT(!list_empty(&ndl->ndl_hlink));


@@ -191,12 +192,12 @@ lstcon_ndlink_release(lstcon_ndlink_t *ndl)
 }
 
 static int
 }
 
 static int

-lstcon_group_alloc(char *name, lstcon_group_t **grpp)
+lstcon_group_alloc(char *name, struct lstcon_group **grpp)

 {
 {

-       lstcon_group_t *grp;
-       int             i;
+       struct lstcon_group *grp;
+       int i;

 
 

-        LIBCFS_ALLOC(grp, offsetof(lstcon_group_t,
+       LIBCFS_ALLOC(grp, offsetof(struct lstcon_group,

                                    grp_ndl_hash[LST_NODE_HASHSIZE]));
         if (grp == NULL)
                 return -ENOMEM;
                                    grp_ndl_hash[LST_NODE_HASHSIZE]));
         if (grp == NULL)
                 return -ENOMEM;


@@ -204,7 +205,7 @@ lstcon_group_alloc(char *name, lstcon_group_t **grpp)
         grp->grp_ref = 1;
        if (name != NULL) {
                if (strlen(name) > sizeof(grp->grp_name)-1) {
         grp->grp_ref = 1;
        if (name != NULL) {
                if (strlen(name) > sizeof(grp->grp_name)-1) {

-                       LIBCFS_FREE(grp, offsetof(lstcon_group_t,
+                       LIBCFS_FREE(grp, offsetof(struct lstcon_group,

                                          grp_ndl_hash[LST_NODE_HASHSIZE]));
                        return -E2BIG;
                }
                                          grp_ndl_hash[LST_NODE_HASHSIZE]));
                        return -E2BIG;
                }


@@ -224,18 +225,19 @@ lstcon_group_alloc(char *name, lstcon_group_t **grpp)
 }
 
 static void
 }
 
 static void

-lstcon_group_addref(lstcon_group_t *grp)
+lstcon_group_addref(struct lstcon_group *grp)

 {
        grp->grp_ref++;
 }
 
 {
        grp->grp_ref++;
 }
 

-static void lstcon_group_ndlink_release(lstcon_group_t *, lstcon_ndlink_t *);
+static void lstcon_group_ndlink_release(struct lstcon_group *,
+                                       struct lstcon_ndlink *);

 
 static void
 
 static void

-lstcon_group_drain(lstcon_group_t *grp, int keep)
+lstcon_group_drain(struct lstcon_group *grp, int keep)

 {
 {

-       lstcon_ndlink_t *ndl;
-       lstcon_ndlink_t *tmp;
+       struct lstcon_ndlink *ndl;
+       struct lstcon_ndlink *tmp;

 
        list_for_each_entry_safe(ndl, tmp, &grp->grp_ndl_list, ndl_link) {
                if ((ndl->ndl_node->nd_state & keep) == 0)
 
        list_for_each_entry_safe(ndl, tmp, &grp->grp_ndl_list, ndl_link) {
                if ((ndl->ndl_node->nd_state & keep) == 0)


@@ -244,7 +246,7 @@ lstcon_group_drain(lstcon_group_t *grp, int keep)
 }
 
 static void
 }
 
 static void

-lstcon_group_decref(lstcon_group_t *grp)
+lstcon_group_decref(struct lstcon_group *grp)

 {
        int i;
 
 {
        int i;
 


@@ -259,14 +261,14 @@ lstcon_group_decref(lstcon_group_t *grp)
        for (i = 0; i < LST_NODE_HASHSIZE; i++)
                LASSERT(list_empty(&grp->grp_ndl_hash[i]));
 
        for (i = 0; i < LST_NODE_HASHSIZE; i++)
                LASSERT(list_empty(&grp->grp_ndl_hash[i]));
 

-       LIBCFS_FREE(grp, offsetof(lstcon_group_t,
+       LIBCFS_FREE(grp, offsetof(struct lstcon_group,

                                  grp_ndl_hash[LST_NODE_HASHSIZE]));
 }
 
 static int
                                  grp_ndl_hash[LST_NODE_HASHSIZE]));
 }
 
 static int

-lstcon_group_find(const char *name, lstcon_group_t **grpp)
+lstcon_group_find(const char *name, struct lstcon_group **grpp)

 {
 {

-       lstcon_group_t *grp;
+       struct lstcon_group *grp;

 
        list_for_each_entry(grp, &console_session.ses_grp_list, grp_link) {
                if (strncmp(grp->grp_name, name, LST_NAME_SIZE) != 0)
 
        list_for_each_entry(grp, &console_session.ses_grp_list, grp_link) {
                if (strncmp(grp->grp_name, name, LST_NAME_SIZE) != 0)


@@ -281,8 +283,8 @@ lstcon_group_find(const char *name, lstcon_group_t **grpp)
 }
 
 static int
 }
 
 static int

-lstcon_group_ndlink_find(lstcon_group_t *grp, struct lnet_process_id id,
-                         lstcon_ndlink_t **ndlpp, int create)
+lstcon_group_ndlink_find(struct lstcon_group *grp, struct lnet_process_id id,
+                        struct lstcon_ndlink **ndlpp, int create)

 {
        int rc;
 
 {
        int rc;
 


@@ -300,7 +302,7 @@ lstcon_group_ndlink_find(lstcon_group_t *grp, struct lnet_process_id id,
 }
 
 static void
 }
 
 static void

-lstcon_group_ndlink_release(lstcon_group_t *grp, lstcon_ndlink_t *ndl)
+lstcon_group_ndlink_release(struct lstcon_group *grp, struct lstcon_ndlink *ndl)

 {
        list_del_init(&ndl->ndl_link);
        lstcon_ndlink_release(ndl);
 {
        list_del_init(&ndl->ndl_link);
        lstcon_ndlink_release(ndl);


@@ -308,8 +310,8 @@ lstcon_group_ndlink_release(lstcon_group_t *grp, lstcon_ndlink_t *ndl)
 }
 
 static void
 }
 
 static void

-lstcon_group_ndlink_move(lstcon_group_t *old,
-                         lstcon_group_t *new, lstcon_ndlink_t *ndl)
+lstcon_group_ndlink_move(struct lstcon_group *old,
+                        struct lstcon_group *new, struct lstcon_ndlink *ndl)

 {
        unsigned int idx = LNET_NIDADDR(ndl->ndl_node->nd_id.nid) %
                                        LST_NODE_HASHSIZE;
 {
        unsigned int idx = LNET_NIDADDR(ndl->ndl_node->nd_id.nid) %
                                        LST_NODE_HASHSIZE;


@@ -326,21 +328,21 @@ lstcon_group_ndlink_move(lstcon_group_t *old,
 }
 
 static void
 }
 
 static void

-lstcon_group_move(lstcon_group_t *old, lstcon_group_t *new)
+lstcon_group_move(struct lstcon_group *old, struct lstcon_group *new)

 {
 {

-       lstcon_ndlink_t *ndl;
+       struct lstcon_ndlink *ndl;

 
        while (!list_empty(&old->grp_ndl_list)) {
                ndl = list_entry(old->grp_ndl_list.next,
 
        while (!list_empty(&old->grp_ndl_list)) {
                ndl = list_entry(old->grp_ndl_list.next,

-                                lstcon_ndlink_t, ndl_link);
+                                struct lstcon_ndlink, ndl_link);

                lstcon_group_ndlink_move(old, new, ndl);
        }
 }
 
 static int
                lstcon_group_ndlink_move(old, new, ndl);
        }
 }
 
 static int

-lstcon_sesrpc_condition(int transop, lstcon_node_t *nd, void *arg)
+lstcon_sesrpc_condition(int transop, struct lstcon_node *nd, void *arg)

 {
 {

-        lstcon_group_t *grp = (lstcon_group_t *)arg;
+       struct lstcon_group *grp = arg;

 
         switch (transop) {
         case LST_TRANS_SESNEW:
 
         switch (transop) {
         case LST_TRANS_SESNEW:


@@ -367,10 +369,10 @@ lstcon_sesrpc_condition(int transop, lstcon_node_t *nd, void *arg)
 }
 
 static int
 }
 
 static int

-lstcon_sesrpc_readent(int transop, srpc_msg_t *msg,
+lstcon_sesrpc_readent(int transop, struct srpc_msg *msg,

                      struct lstcon_rpc_ent __user *ent_up)
 {
                      struct lstcon_rpc_ent __user *ent_up)
 {

-        srpc_debug_reply_t *rep;
+       struct srpc_debug_reply *rep;

 
         switch (transop) {
         case LST_TRANS_SESNEW:
 
         switch (transop) {
         case LST_TRANS_SESNEW:


@@ -396,16 +398,17 @@ lstcon_sesrpc_readent(int transop, srpc_msg_t *msg,
 }
 
 static int
 }
 
 static int

-lstcon_group_nodes_add(lstcon_group_t *grp,
+lstcon_group_nodes_add(struct lstcon_group *grp,

                       int count, struct lnet_process_id __user *ids_up,
                       int count, struct lnet_process_id __user *ids_up,

-                      unsigned *featp, struct list_head __user *result_up)
+                      unsigned int *featp,
+                      struct list_head __user *result_up)

 {
 {

-        lstcon_rpc_trans_t      *trans;
-        lstcon_ndlink_t         *ndl;
-        lstcon_group_t          *tmp;
-       struct lnet_process_id        id;
-        int                      i;
-        int                      rc;
+       struct lstcon_rpc_trans *trans;
+       struct lstcon_ndlink *ndl;
+       struct lstcon_group *tmp;
+       struct lnet_process_id id;
+       int i;
+       int rc;

 
         rc = lstcon_group_alloc(NULL, &tmp);
         if (rc != 0) {
 
         rc = lstcon_group_alloc(NULL, &tmp);
         if (rc != 0) {


@@ -463,16 +466,16 @@ lstcon_group_nodes_add(lstcon_group_t *grp,
 }
 
 static int
 }
 
 static int

-lstcon_group_nodes_remove(lstcon_group_t *grp,
+lstcon_group_nodes_remove(struct lstcon_group *grp,

                          int count, struct lnet_process_id __user *ids_up,
                          struct list_head __user *result_up)
 {
                          int count, struct lnet_process_id __user *ids_up,
                          struct list_head __user *result_up)
 {

-        lstcon_rpc_trans_t     *trans;
-        lstcon_ndlink_t        *ndl;
-        lstcon_group_t         *tmp;
-       struct lnet_process_id       id;
-        int                     rc;
-        int                     i;
+       struct lstcon_rpc_trans *trans;
+       struct lstcon_ndlink *ndl;
+       struct lstcon_group *tmp;
+       struct lnet_process_id id;
+       int rc;
+       int i;

 
         /* End session and remove node from the group */
 
 
         /* End session and remove node from the group */
 


@@ -520,8 +523,8 @@ error:
 int
 lstcon_group_add(char *name)
 {
 int
 lstcon_group_add(char *name)
 {

-        lstcon_group_t *grp;
-        int             rc;
+       struct lstcon_group *grp;
+       int rc;

 
         rc = (lstcon_group_find(name, &grp) == 0)? -EEXIST: 0;
         if (rc != 0) {
 
         rc = (lstcon_group_find(name, &grp) == 0)? -EEXIST: 0;
         if (rc != 0) {


@@ -545,7 +548,7 @@ int
 lstcon_nodes_add(char *name, int count, struct lnet_process_id __user *ids_up,
                 unsigned *featp, struct list_head __user *result_up)
 {
 lstcon_nodes_add(char *name, int count, struct lnet_process_id __user *ids_up,
                 unsigned *featp, struct list_head __user *result_up)
 {

-        lstcon_group_t         *grp;
+       struct lstcon_group         *grp;

         int                     rc;
 
         LASSERT (count > 0);
         int                     rc;
 
         LASSERT (count > 0);


@@ -575,9 +578,9 @@ lstcon_nodes_add(char *name, int count, struct lnet_process_id __user *ids_up,
 int
 lstcon_group_del(char *name)
 {
 int
 lstcon_group_del(char *name)
 {

-        lstcon_rpc_trans_t *trans;
-        lstcon_group_t     *grp;
-        int                 rc;
+       struct lstcon_rpc_trans *trans;
+       struct lstcon_group *grp;
+       int rc;

 
         rc = lstcon_group_find(name, &grp);
         if (rc != 0) {
 
         rc = lstcon_group_find(name, &grp);
         if (rc != 0) {


@@ -616,8 +619,8 @@ lstcon_group_del(char *name)
 int
 lstcon_group_clean(char *name, int args)
 {
 int
 lstcon_group_clean(char *name, int args)
 {

-        lstcon_group_t *grp = NULL;
-        int             rc;
+       struct lstcon_group *grp = NULL;
+       int rc;

 
         rc = lstcon_group_find(name, &grp);
         if (rc != 0) {
 
         rc = lstcon_group_find(name, &grp);
         if (rc != 0) {


@@ -650,8 +653,8 @@ lstcon_nodes_remove(char *name, int count,
                    struct lnet_process_id __user *ids_up,
                    struct list_head __user *result_up)
 {
                    struct lnet_process_id __user *ids_up,
                    struct list_head __user *result_up)
 {

-        lstcon_group_t *grp = NULL;
-        int             rc;
+       struct lstcon_group *grp = NULL;
+       int rc;

 
         rc = lstcon_group_find(name, &grp);
         if (rc != 0) {
 
         rc = lstcon_group_find(name, &grp);
         if (rc != 0) {


@@ -679,9 +682,9 @@ lstcon_nodes_remove(char *name, int count,
 int
 lstcon_group_refresh(char *name, struct list_head __user *result_up)
 {
 int
 lstcon_group_refresh(char *name, struct list_head __user *result_up)
 {

-        lstcon_rpc_trans_t      *trans;
-        lstcon_group_t          *grp;
-        int                      rc;
+       struct lstcon_rpc_trans *trans;
+       struct lstcon_group *grp;
+       int rc;

 
         rc = lstcon_group_find(name, &grp);
         if (rc != 0) {
 
         rc = lstcon_group_find(name, &grp);
         if (rc != 0) {


@@ -721,7 +724,7 @@ lstcon_group_refresh(char *name, struct list_head __user *result_up)
 int
 lstcon_group_list(int index, int len, char __user *name_up)
 {
 int
 lstcon_group_list(int index, int len, char __user *name_up)
 {

-       lstcon_group_t *grp;
+       struct lstcon_group *grp;

 
        LASSERT(index >= 0);
        LASSERT(name_up != NULL);
 
        LASSERT(index >= 0);
        LASSERT(name_up != NULL);


@@ -740,10 +743,10 @@ static int
 lstcon_nodes_getent(struct list_head *head, int *index_p,
                    int *count_p, struct lstcon_node_ent __user *dents_up)
 {
 lstcon_nodes_getent(struct list_head *head, int *index_p,
                    int *count_p, struct lstcon_node_ent __user *dents_up)
 {

-        lstcon_ndlink_t  *ndl;
-        lstcon_node_t    *nd;
-        int               count = 0;
-        int               index = 0;
+       struct lstcon_ndlink *ndl;
+       struct lstcon_node *nd;
+       int count = 0;
+       int index = 0;

 
        LASSERT(index_p != NULL && count_p != NULL);
        LASSERT(dents_up != NULL);
 
        LASSERT(index_p != NULL && count_p != NULL);
        LASSERT(dents_up != NULL);


@@ -782,9 +785,9 @@ lstcon_group_info(char *name, struct lstcon_ndlist_ent __user *gents_p,
                  struct lstcon_node_ent __user *dents_up)
 {
        struct lstcon_ndlist_ent *gentp;
                  struct lstcon_node_ent __user *dents_up)
 {
        struct lstcon_ndlist_ent *gentp;

-        lstcon_group_t      *grp;
-        lstcon_ndlink_t     *ndl;
-        int                  rc;
+       struct lstcon_group *grp;
+       struct lstcon_ndlink *ndl;
+       int rc;

 
         rc = lstcon_group_find(name, &grp);
         if (rc != 0) {
 
         rc = lstcon_group_find(name, &grp);
         if (rc != 0) {


@@ -824,9 +827,9 @@ lstcon_group_info(char *name, struct lstcon_ndlist_ent __user *gents_p,
 }
 
 static int
 }
 
 static int

-lstcon_batch_find(const char *name, lstcon_batch_t **batpp)
+lstcon_batch_find(const char *name, struct lstcon_batch **batpp)

 {
 {

-       lstcon_batch_t *bat;
+       struct lstcon_batch *bat;

 
        list_for_each_entry(bat, &console_session.ses_bat_list, bat_link) {
                if (strncmp(bat->bat_name, name, LST_NAME_SIZE) == 0) {
 
        list_for_each_entry(bat, &console_session.ses_bat_list, bat_link) {
                if (strncmp(bat->bat_name, name, LST_NAME_SIZE) == 0) {


@@ -841,9 +844,9 @@ lstcon_batch_find(const char *name, lstcon_batch_t **batpp)
 int
 lstcon_batch_add(char *name)
 {
 int
 lstcon_batch_add(char *name)
 {

-        lstcon_batch_t   *bat;
-        int               i;
-        int               rc;
+       struct lstcon_batch *bat;
+       int i;
+       int rc;

 
         rc = (lstcon_batch_find(name, &bat) == 0)? -EEXIST: 0;
         if (rc != 0) {
 
         rc = (lstcon_batch_find(name, &bat) == 0)? -EEXIST: 0;
         if (rc != 0) {


@@ -851,17 +854,17 @@ lstcon_batch_add(char *name)
                 return rc;
         }
 
                 return rc;
         }
 

-        LIBCFS_ALLOC(bat, sizeof(lstcon_batch_t));
+       LIBCFS_ALLOC(bat, sizeof(*bat));

         if (bat == NULL) {
                 CERROR("Can't allocate descriptor for batch %s\n", name);
                 return -ENOMEM;
         }
 
         if (bat == NULL) {
                 CERROR("Can't allocate descriptor for batch %s\n", name);
                 return -ENOMEM;
         }
 

-        LIBCFS_ALLOC(bat->bat_cli_hash,
+       LIBCFS_ALLOC(bat->bat_cli_hash,

                     sizeof(struct list_head) * LST_NODE_HASHSIZE);
                     sizeof(struct list_head) * LST_NODE_HASHSIZE);

-        if (bat->bat_cli_hash == NULL) {
-                CERROR("Can't allocate hash for batch %s\n", name);
-                LIBCFS_FREE(bat, sizeof(lstcon_batch_t));
+       if (bat->bat_cli_hash == NULL) {
+               CERROR("Can't allocate hash for batch %s\n", name);
+               LIBCFS_FREE(bat, sizeof(*bat));

 
                 return -ENOMEM;
         }
 
                 return -ENOMEM;
         }


@@ -871,7 +874,7 @@ lstcon_batch_add(char *name)
         if (bat->bat_srv_hash == NULL) {
                 CERROR("Can't allocate hash for batch %s\n", name);
                 LIBCFS_FREE(bat->bat_cli_hash, LST_NODE_HASHSIZE);
         if (bat->bat_srv_hash == NULL) {
                 CERROR("Can't allocate hash for batch %s\n", name);
                 LIBCFS_FREE(bat->bat_cli_hash, LST_NODE_HASHSIZE);

-                LIBCFS_FREE(bat, sizeof(lstcon_batch_t));
+               LIBCFS_FREE(bat, sizeof(*bat));

 
                 return -ENOMEM;
         }
 
                 return -ENOMEM;
         }


@@ -879,7 +882,7 @@ lstcon_batch_add(char *name)
        if (strlen(name) > sizeof(bat->bat_name)-1) {
                LIBCFS_FREE(bat->bat_srv_hash, LST_NODE_HASHSIZE);
                LIBCFS_FREE(bat->bat_cli_hash, LST_NODE_HASHSIZE);
        if (strlen(name) > sizeof(bat->bat_name)-1) {
                LIBCFS_FREE(bat->bat_srv_hash, LST_NODE_HASHSIZE);
                LIBCFS_FREE(bat->bat_cli_hash, LST_NODE_HASHSIZE);

-               LIBCFS_FREE(bat, sizeof(lstcon_batch_t));
+               LIBCFS_FREE(bat, sizeof(*bat));

                return -E2BIG;
        }
        strncpy(bat->bat_name, name, sizeof(bat->bat_name));
                return -E2BIG;
        }
        strncpy(bat->bat_name, name, sizeof(bat->bat_name));


@@ -907,7 +910,7 @@ lstcon_batch_add(char *name)
 int
 lstcon_batch_list(int index, int len, char __user *name_up)
 {
 int
 lstcon_batch_list(int index, int len, char __user *name_up)
 {

-       lstcon_batch_t *bat;
+       struct lstcon_batch *bat;

 
        LASSERT(name_up != NULL);
        LASSERT(index >= 0);
 
        LASSERT(name_up != NULL);
        LASSERT(index >= 0);


@@ -928,12 +931,12 @@ lstcon_batch_info(char *name, struct lstcon_test_batch_ent __user *ent_up,
                  struct lstcon_node_ent __user *dents_up)
 {
        struct lstcon_test_batch_ent *entp;
                  struct lstcon_node_ent __user *dents_up)
 {
        struct lstcon_test_batch_ent *entp;

-       struct list_head        *clilst;
-       struct list_head        *srvlst;
-        lstcon_test_t           *test = NULL;
-        lstcon_batch_t          *bat;
-        lstcon_ndlink_t         *ndl;
-        int                      rc;
+       struct list_head *clilst;
+       struct list_head *srvlst;
+       struct lstcon_test *test = NULL;
+       struct lstcon_batch *bat;
+       struct lstcon_ndlink *ndl;
+       int rc;

 
         rc = lstcon_batch_find(name, &bat);
         if (rc != 0) {
 
         rc = lstcon_batch_find(name, &bat);
         if (rc != 0) {


@@ -996,7 +999,7 @@ lstcon_batch_info(char *name, struct lstcon_test_batch_ent __user *ent_up,
 }
 
 static int
 }
 
 static int

-lstcon_batrpc_condition(int transop, lstcon_node_t *nd, void *arg)
+lstcon_batrpc_condition(int transop, struct lstcon_node *nd, void *arg)

 {
         switch (transop) {
         case LST_TRANS_TSBRUN:
 {
         switch (transop) {
         case LST_TRANS_TSBRUN:


@@ -1018,10 +1021,10 @@ lstcon_batrpc_condition(int transop, lstcon_node_t *nd, void *arg)
 }
 
 static int
 }
 
 static int

-lstcon_batch_op(lstcon_batch_t *bat, int transop,
+lstcon_batch_op(struct lstcon_batch *bat, int transop,

                struct list_head __user *result_up)
 {
                struct list_head __user *result_up)
 {

-        lstcon_rpc_trans_t *trans;
+       struct lstcon_rpc_trans *trans;

         int                 rc;
 
         rc = lstcon_rpc_trans_ndlist(&bat->bat_cli_list,
         int                 rc;
 
         rc = lstcon_rpc_trans_ndlist(&bat->bat_cli_list,


@@ -1044,8 +1047,8 @@ lstcon_batch_op(lstcon_batch_t *bat, int transop,
 int
 lstcon_batch_run(char *name, int timeout, struct list_head __user *result_up)
 {
 int
 lstcon_batch_run(char *name, int timeout, struct list_head __user *result_up)
 {

-        lstcon_batch_t *bat;
-        int             rc;
+       struct lstcon_batch *bat;
+       int rc;

 
         if (lstcon_batch_find(name, &bat) != 0) {
                 CDEBUG(D_NET, "Can't find batch %s\n", name);
 
         if (lstcon_batch_find(name, &bat) != 0) {
                 CDEBUG(D_NET, "Can't find batch %s\n", name);


@@ -1066,8 +1069,8 @@ lstcon_batch_run(char *name, int timeout, struct list_head __user *result_up)
 int
 lstcon_batch_stop(char *name, int force, struct list_head __user *result_up)
 {
 int
 lstcon_batch_stop(char *name, int force, struct list_head __user *result_up)
 {

-        lstcon_batch_t *bat;
-        int             rc;
+       struct lstcon_batch *bat;
+       int rc;

 
         if (lstcon_batch_find(name, &bat) != 0) {
                 CDEBUG(D_NET, "Can't find batch %s\n", name);
 
         if (lstcon_batch_find(name, &bat) != 0) {
                 CDEBUG(D_NET, "Can't find batch %s\n", name);


@@ -1086,17 +1089,17 @@ lstcon_batch_stop(char *name, int force, struct list_head __user *result_up)
 }
 
 static void
 }
 
 static void

-lstcon_batch_destroy(lstcon_batch_t *bat)
+lstcon_batch_destroy(struct lstcon_batch *bat)

 {
 {

-        lstcon_ndlink_t    *ndl;
-        lstcon_test_t      *test;
-        int                 i;
+       struct lstcon_ndlink *ndl;
+       struct lstcon_test *test;
+       int i;

 
        list_del(&bat->bat_link);
 
        while (!list_empty(&bat->bat_test_list)) {
                test = list_entry(bat->bat_test_list.next,
 
        list_del(&bat->bat_link);
 
        while (!list_empty(&bat->bat_test_list)) {
                test = list_entry(bat->bat_test_list.next,

-                                 lstcon_test_t, tes_link);
+                                 struct lstcon_test, tes_link);

                LASSERT(list_empty(&test->tes_trans_list));
 
                list_del(&test->tes_link);
                LASSERT(list_empty(&test->tes_trans_list));
 
                list_del(&test->tes_link);


@@ -1104,7 +1107,7 @@ lstcon_batch_destroy(lstcon_batch_t *bat)
                lstcon_group_decref(test->tes_src_grp);
                lstcon_group_decref(test->tes_dst_grp);
 
                lstcon_group_decref(test->tes_src_grp);
                lstcon_group_decref(test->tes_dst_grp);
 

-               LIBCFS_FREE(test, offsetof(lstcon_test_t,
+               LIBCFS_FREE(test, offsetof(struct lstcon_test,

                                           tes_param[test->tes_paramlen]));
        }
 
                                           tes_param[test->tes_paramlen]));
        }
 


@@ -1112,7 +1115,7 @@ lstcon_batch_destroy(lstcon_batch_t *bat)
 
        while (!list_empty(&bat->bat_cli_list)) {
                ndl = list_entry(bat->bat_cli_list.next,
 
        while (!list_empty(&bat->bat_cli_list)) {
                ndl = list_entry(bat->bat_cli_list.next,

-                                lstcon_ndlink_t, ndl_link);
+                                struct lstcon_ndlink, ndl_link);

                list_del_init(&ndl->ndl_link);
 
                lstcon_ndlink_release(ndl);
                list_del_init(&ndl->ndl_link);
 
                lstcon_ndlink_release(ndl);


@@ -1120,7 +1123,7 @@ lstcon_batch_destroy(lstcon_batch_t *bat)
 
        while (!list_empty(&bat->bat_srv_list)) {
                ndl = list_entry(bat->bat_srv_list.next,
 
        while (!list_empty(&bat->bat_srv_list)) {
                ndl = list_entry(bat->bat_srv_list.next,

-                                lstcon_ndlink_t, ndl_link);
+                                struct lstcon_ndlink, ndl_link);

                list_del_init(&ndl->ndl_link);
 
                lstcon_ndlink_release(ndl);
                list_del_init(&ndl->ndl_link);
 
                lstcon_ndlink_release(ndl);


@@ -1135,19 +1138,18 @@ lstcon_batch_destroy(lstcon_batch_t *bat)
                    sizeof(struct list_head) * LST_NODE_HASHSIZE);
        LIBCFS_FREE(bat->bat_srv_hash,
                    sizeof(struct list_head) * LST_NODE_HASHSIZE);
                    sizeof(struct list_head) * LST_NODE_HASHSIZE);
        LIBCFS_FREE(bat->bat_srv_hash,
                    sizeof(struct list_head) * LST_NODE_HASHSIZE);

-       LIBCFS_FREE(bat, sizeof(lstcon_batch_t));
+       LIBCFS_FREE(bat, sizeof(*bat));

 }
 
 static int
 }
 
 static int

-lstcon_testrpc_condition(int transop, lstcon_node_t *nd, void *arg)
+lstcon_testrpc_condition(int transop, struct lstcon_node *nd, void *arg)

 {
 {

-       lstcon_test_t    *test;
-       lstcon_batch_t   *batch;
-       lstcon_ndlink_t  *ndl;
+       struct lstcon_test *test = arg;
+       struct lstcon_batch *batch;
+       struct lstcon_ndlink *ndl;

        struct list_head *hash;
        struct list_head *head;
 
        struct list_head *hash;
        struct list_head *head;
 

-       test = (lstcon_test_t *)arg;

        LASSERT(test != NULL);
 
        batch = test->tes_batch;
        LASSERT(test != NULL);
 
        batch = test->tes_batch;


@@ -1183,12 +1185,13 @@ lstcon_testrpc_condition(int transop, lstcon_node_t *nd, void *arg)
 }
 
 static int
 }
 
 static int

-lstcon_test_nodes_add(lstcon_test_t *test, struct list_head __user *result_up)
+lstcon_test_nodes_add(struct lstcon_test *test,
+                     struct list_head __user *result_up)

 {
 {

-        lstcon_rpc_trans_t     *trans;
-        lstcon_group_t         *grp;
-        int                     transop;
-        int                     rc;
+       struct lstcon_rpc_trans *trans;
+       struct lstcon_group *grp;
+       int transop;
+       int rc;

 
         LASSERT (test->tes_src_grp != NULL);
         LASSERT (test->tes_dst_grp != NULL);
 
         LASSERT (test->tes_src_grp != NULL);
         LASSERT (test->tes_dst_grp != NULL);


@@ -1235,7 +1238,7 @@ again:
 }
 
 static int
 }
 
 static int

-lstcon_verify_batch(const char *name, lstcon_batch_t **batch)
+lstcon_verify_batch(const char *name, struct lstcon_batch **batch)

 {
        int rc;
 
 {
        int rc;
 


@@ -1254,10 +1257,10 @@ lstcon_verify_batch(const char *name, lstcon_batch_t **batch)
 }
 
 static int
 }
 
 static int

-lstcon_verify_group(const char *name, lstcon_group_t **grp)
+lstcon_verify_group(const char *name, struct lstcon_group **grp)

 {
 {

-       int                     rc;
-       lstcon_ndlink_t         *ndl;
+       int rc;
+       struct lstcon_ndlink *ndl;

 
        rc = lstcon_group_find(name, grp);
        if (rc != 0) {
 
        rc = lstcon_group_find(name, grp);
        if (rc != 0) {


@@ -1283,11 +1286,11 @@ lstcon_test_add(char *batch_name, int type, int loop,
                void *param, int paramlen, int *retp,
                struct list_head __user *result_up)
 {
                void *param, int paramlen, int *retp,
                struct list_head __user *result_up)
 {

-       lstcon_test_t    *test   = NULL;
-       int              rc;
-       lstcon_group_t   *src_grp = NULL;
-       lstcon_group_t   *dst_grp = NULL;
-       lstcon_batch_t   *batch = NULL;
+       struct lstcon_test *test = NULL;
+       int rc;
+       struct lstcon_group *src_grp = NULL;
+       struct lstcon_group *dst_grp = NULL;
+       struct lstcon_batch *batch = NULL;

 
        /*
         * verify that a batch of the given name exists, and the groups
 
        /*
         * verify that a batch of the given name exists, and the groups


@@ -1309,7 +1312,7 @@ lstcon_test_add(char *batch_name, int type, int loop,
        if (dst_grp->grp_userland)
                *retp = 1;
 
        if (dst_grp->grp_userland)
                *retp = 1;
 

-       LIBCFS_ALLOC(test, offsetof(lstcon_test_t, tes_param[paramlen]));
+       LIBCFS_ALLOC(test, offsetof(struct lstcon_test, tes_param[paramlen]));

        if (!test) {
                CERROR("Can't allocate test descriptor\n");
                rc = -ENOMEM;
        if (!test) {
                CERROR("Can't allocate test descriptor\n");
                rc = -ENOMEM;


@@ -1356,7 +1359,8 @@ lstcon_test_add(char *batch_name, int type, int loop,
        return rc;
 out:
        if (test != NULL)
        return rc;
 out:
        if (test != NULL)

-               LIBCFS_FREE(test, offsetof(lstcon_test_t, tes_param[paramlen]));
+               LIBCFS_FREE(test, offsetof(struct lstcon_test,
+                                          tes_param[paramlen]));

 
        if (dst_grp != NULL)
                lstcon_group_decref(dst_grp);
 
        if (dst_grp != NULL)
                lstcon_group_decref(dst_grp);


@@ -1368,9 +1372,10 @@ out:
 }
 
 static int
 }
 
 static int

-lstcon_test_find(lstcon_batch_t *batch, int idx, lstcon_test_t **testpp)
+lstcon_test_find(struct lstcon_batch *batch, int idx,
+                struct lstcon_test **testpp)

 {
 {

-       lstcon_test_t *test;
+       struct lstcon_test *test;

 
        list_for_each_entry(test, &batch->bat_test_list, tes_link) {
                if (idx == test->tes_hdr.tsb_index) {
 
        list_for_each_entry(test, &batch->bat_test_list, tes_link) {
                if (idx == test->tes_hdr.tsb_index) {


@@ -1383,10 +1388,10 @@ lstcon_test_find(lstcon_batch_t *batch, int idx, lstcon_test_t **testpp)
 }
 
 static int
 }
 
 static int

-lstcon_tsbrpc_readent(int transop, srpc_msg_t *msg,
+lstcon_tsbrpc_readent(int transop, struct srpc_msg *msg,

                      struct lstcon_rpc_ent __user *ent_up)
 {
                      struct lstcon_rpc_ent __user *ent_up)
 {

-        srpc_batch_reply_t *rep = &msg->msg_body.bat_reply;
+       struct srpc_batch_reply *rep = &msg->msg_body.bat_reply;

 
         LASSERT (transop == LST_TRANS_TSBCLIQRY ||
                  transop == LST_TRANS_TSBSRVQRY);
 
         LASSERT (transop == LST_TRANS_TSBCLIQRY ||
                  transop == LST_TRANS_TSBSRVQRY);


@@ -1403,14 +1408,14 @@ int
 lstcon_test_batch_query(char *name, int testidx, int client,
                        int timeout, struct list_head __user *result_up)
 {
 lstcon_test_batch_query(char *name, int testidx, int client,
                        int timeout, struct list_head __user *result_up)
 {

-        lstcon_rpc_trans_t *trans;
-       struct list_head   *translist;
-       struct list_head   *ndlist;
-        lstcon_tsb_hdr_t   *hdr;
-        lstcon_batch_t     *batch;
-        lstcon_test_t      *test = NULL;
-        int                 transop;
-        int                 rc;
+       struct lstcon_rpc_trans *trans;
+       struct list_head *translist;
+       struct list_head *ndlist;
+       struct lstcon_tsb_hdr *hdr;
+       struct lstcon_batch *batch;
+       struct lstcon_test *test = NULL;
+       int transop;
+       int rc;

 
         rc = lstcon_batch_find(name, &batch);
         if (rc != 0) {
 
         rc = lstcon_batch_find(name, &batch);
         if (rc != 0) {


@@ -1462,11 +1467,11 @@ lstcon_test_batch_query(char *name, int testidx, int client,
 }
 
 static int
 }
 
 static int

-lstcon_statrpc_readent(int transop, srpc_msg_t *msg,
+lstcon_statrpc_readent(int transop, struct srpc_msg *msg,

                       struct lstcon_rpc_ent __user *ent_up)
 {
                       struct lstcon_rpc_ent __user *ent_up)
 {

-       srpc_stat_reply_t *rep = &msg->msg_body.stat_reply;
-       struct sfw_counters __user  *sfwk_stat;
+       struct srpc_stat_reply *rep = &msg->msg_body.stat_reply;
+       struct sfw_counters __user *sfwk_stat;

        struct srpc_counters __user *srpc_stat;
        struct lnet_counters __user *lnet_stat;
 
        struct srpc_counters __user *srpc_stat;
        struct lnet_counters __user *lnet_stat;
 


@@ -1492,7 +1497,7 @@ lstcon_ndlist_stat(struct list_head *ndlist,
                   int timeout, struct list_head __user *result_up)
 {
        struct list_head    head;
                   int timeout, struct list_head __user *result_up)
 {
        struct list_head    head;

-       lstcon_rpc_trans_t *trans;
+       struct lstcon_rpc_trans *trans;

        int                 rc;
 
        INIT_LIST_HEAD(&head);
        int                 rc;
 
        INIT_LIST_HEAD(&head);


@@ -1517,8 +1522,8 @@ int
 lstcon_group_stat(char *grp_name, int timeout,
                  struct list_head __user *result_up)
 {
 lstcon_group_stat(char *grp_name, int timeout,
                  struct list_head __user *result_up)
 {

-        lstcon_group_t     *grp;
-        int                 rc;
+       struct lstcon_group *grp;
+       int rc;

 
         rc = lstcon_group_find(grp_name, &grp);
         if (rc != 0) {
 
         rc = lstcon_group_find(grp_name, &grp);
         if (rc != 0) {


@@ -1537,11 +1542,11 @@ int
 lstcon_nodes_stat(int count, struct lnet_process_id __user *ids_up,
                  int timeout, struct list_head __user *result_up)
 {
 lstcon_nodes_stat(int count, struct lnet_process_id __user *ids_up,
                  int timeout, struct list_head __user *result_up)
 {

-        lstcon_ndlink_t         *ndl;
-        lstcon_group_t          *tmp;
-       struct lnet_process_id        id;
-        int                      i;
-        int                      rc;
+       struct lstcon_ndlink *ndl;
+       struct lstcon_group *tmp;
+       struct lnet_process_id id;
+       int i;
+       int rc;

 
         rc = lstcon_group_alloc(NULL, &tmp);
         if (rc != 0) {
 
         rc = lstcon_group_alloc(NULL, &tmp);
         if (rc != 0) {


@@ -1582,8 +1587,8 @@ lstcon_debug_ndlist(struct list_head *ndlist,
                    struct list_head *translist,
                    int timeout, struct list_head __user *result_up)
 {
                    struct list_head *translist,
                    int timeout, struct list_head __user *result_up)
 {

-        lstcon_rpc_trans_t *trans;
-        int                 rc;
+       struct lstcon_rpc_trans *trans;
+       int rc;

 
         rc = lstcon_rpc_trans_ndlist(ndlist, translist, LST_TRANS_SESQRY,
                                      NULL, lstcon_sesrpc_condition, &trans);
 
         rc = lstcon_rpc_trans_ndlist(ndlist, translist, LST_TRANS_SESQRY,
                                      NULL, lstcon_sesrpc_condition, &trans);


@@ -1612,8 +1617,8 @@ int
 lstcon_batch_debug(int timeout, char *name,
                   int client, struct list_head __user *result_up)
 {
 lstcon_batch_debug(int timeout, char *name,
                   int client, struct list_head __user *result_up)
 {

-        lstcon_batch_t *bat;
-        int             rc;
+       struct lstcon_batch *bat;
+       int rc;

 
         rc = lstcon_batch_find(name, &bat);
         if (rc != 0)
 
         rc = lstcon_batch_find(name, &bat);
         if (rc != 0)


@@ -1630,8 +1635,8 @@ int
 lstcon_group_debug(int timeout, char *name,
                   struct list_head __user *result_up)
 {
 lstcon_group_debug(int timeout, char *name,
                   struct list_head __user *result_up)
 {

-        lstcon_group_t *grp;
-        int             rc;
+       struct lstcon_group *grp;
+       int rc;

 
         rc = lstcon_group_find(name, &grp);
         if (rc != 0)
 
         rc = lstcon_group_find(name, &grp);
         if (rc != 0)


@@ -1645,15 +1650,15 @@ lstcon_group_debug(int timeout, char *name,
 }
 
 int
 }
 
 int

-lstcon_nodes_debug(int timeout,
-                  int count, struct lnet_process_id __user *ids_up,
+lstcon_nodes_debug(int timeout, int count,
+                  struct lnet_process_id __user *ids_up,

                   struct list_head __user *result_up)
 {
                   struct list_head __user *result_up)
 {

-       struct lnet_process_id  id;
-        lstcon_ndlink_t   *ndl;
-        lstcon_group_t    *grp;
-        int                i;
-        int                rc;
+       struct lnet_process_id id;
+       struct lstcon_ndlink *ndl;
+       struct lstcon_group *grp;
+       int i;
+       int rc;

 
         rc = lstcon_group_alloc(NULL, &grp);
         if (rc != 0) {
 
         rc = lstcon_group_alloc(NULL, &grp);
         if (rc != 0) {


@@ -1759,7 +1764,7 @@ lstcon_session_new(char *name, int key, unsigned feats,
 
         rc = lstcon_rpc_pinger_start();
         if (rc != 0) {
 
         rc = lstcon_rpc_pinger_start();
         if (rc != 0) {

-                lstcon_batch_t *bat = NULL;
+               struct lstcon_batch *bat = NULL;

 
                 lstcon_batch_find(LST_DEFAULT_BATCH, &bat);
                 lstcon_batch_destroy(bat);
 
                 lstcon_batch_find(LST_DEFAULT_BATCH, &bat);
                 lstcon_batch_destroy(bat);


@@ -1783,8 +1788,8 @@ lstcon_session_info(struct lst_sid __user *sid_up, int __user *key_up,
                    char __user *name_up, int len)
 {
        struct lstcon_ndlist_ent *entp;
                    char __user *name_up, int len)
 {
        struct lstcon_ndlist_ent *entp;

-        lstcon_ndlink_t     *ndl;
-        int                  rc = 0;
+       struct lstcon_ndlink *ndl;
+       int rc = 0;

 
         if (console_session.ses_state != LST_SESSION_ACTIVE)
                 return -ESRCH;
 
         if (console_session.ses_state != LST_SESSION_ACTIVE)
                 return -ESRCH;


@@ -1814,10 +1819,10 @@ lstcon_session_info(struct lst_sid __user *sid_up, int __user *key_up,
 int
 lstcon_session_end()
 {
 int
 lstcon_session_end()
 {

-        lstcon_rpc_trans_t *trans;
-        lstcon_group_t     *grp;
-        lstcon_batch_t     *bat;
-        int                 rc = 0;
+       struct lstcon_rpc_trans *trans;
+       struct lstcon_group *grp;
+       struct lstcon_batch *bat;
+       int rc = 0;

 
         LASSERT (console_session.ses_state == LST_SESSION_ACTIVE);
 
 
         LASSERT (console_session.ses_state == LST_SESSION_ACTIVE);
 


@@ -1850,7 +1855,7 @@ lstcon_session_end()
        /* destroy all batches */
        while (!list_empty(&console_session.ses_bat_list)) {
                bat = list_entry(console_session.ses_bat_list.next,
        /* destroy all batches */
        while (!list_empty(&console_session.ses_bat_list)) {
                bat = list_entry(console_session.ses_bat_list.next,

-                                lstcon_batch_t, bat_link);
+                                struct lstcon_batch, bat_link);

 
                lstcon_batch_destroy(bat);
        }
 
                lstcon_batch_destroy(bat);
        }


@@ -1858,7 +1863,7 @@ lstcon_session_end()
        /* destroy all groups */
        while (!list_empty(&console_session.ses_grp_list)) {
                grp = list_entry(console_session.ses_grp_list.next,
        /* destroy all groups */
        while (!list_empty(&console_session.ses_grp_list)) {
                grp = list_entry(console_session.ses_grp_list.next,

-                                lstcon_group_t, grp_link);
+                                struct lstcon_group, grp_link);

                LASSERT(grp->grp_ref == 1);
 
                lstcon_group_decref(grp);
                LASSERT(grp->grp_ref == 1);
 
                lstcon_group_decref(grp);


@@ -1906,15 +1911,15 @@ lstcon_session_feats_check(unsigned feats)
 }
 
 static int
 }
 
 static int

-lstcon_acceptor_handle (srpc_server_rpc_t *rpc)
+lstcon_acceptor_handle(struct srpc_server_rpc *rpc)

 {
 {

-        srpc_msg_t        *rep  = &rpc->srpc_replymsg;
-        srpc_msg_t        *req  = &rpc->srpc_reqstbuf->buf_msg;
-        srpc_join_reqst_t *jreq = &req->msg_body.join_reqst;
-        srpc_join_reply_t *jrep = &rep->msg_body.join_reply;
-        lstcon_group_t    *grp  = NULL;
-        lstcon_ndlink_t   *ndl;
-        int                rc   = 0;
+       struct srpc_msg *rep = &rpc->srpc_replymsg;
+       struct srpc_msg *req = &rpc->srpc_reqstbuf->buf_msg;
+       struct srpc_join_reqst *jreq = &req->msg_body.join_reqst;
+       struct srpc_join_reply *jrep = &rep->msg_body.join_reply;
+       struct lstcon_group *grp = NULL;
+       struct lstcon_ndlink *ndl;
+       int rc = 0;

 
         sfw_unpack_message(req);
 
 
         sfw_unpack_message(req);
 


@@ -1989,7 +1994,8 @@ out:
         return rc;
 }
 
         return rc;
 }
 

-static srpc_service_t lstcon_acceptor_service;
+static struct srpc_service lstcon_acceptor_service;
+

 static void lstcon_init_acceptor_service(void)
 {
         /* initialize selftest console acceptor service table */
 static void lstcon_init_acceptor_service(void)
 {
         /* initialize selftest console acceptor service table */


@@ -2010,8 +2016,6 @@ lstcon_console_init(void)
         int     i;
         int     rc;
 
         int     i;
         int     rc;
 

-        memset(&console_session, 0, sizeof(lstcon_session_t));
-

        console_session.ses_id              = LST_INVALID_SID;
        console_session.ses_state           = LST_SESSION_NONE;
        console_session.ses_timeout         = 0;
        console_session.ses_id              = LST_INVALID_SID;
        console_session.ses_state           = LST_SESSION_NONE;
        console_session.ses_timeout         = 0;

diff --git a/lnet/selftest/console.h b/lnet/selftest/console.h
index 3145346..08f199c 100644 (file)
--- a/lnet/selftest/console.h
+++ b/lnet/selftest/console.h
@@ -47,22 +47,25 @@
 #include "selftest.h"
 #include "conrpc.h"
 
 #include "selftest.h"
 #include "conrpc.h"
 

-typedef struct lstcon_node {
-       struct lnet_process_id    nd_id;          /* id of the node */
+/* node descriptor */
+struct lstcon_node {
+       struct lnet_process_id    nd_id;        /* id of the node */

         int                  nd_ref;         /* reference count */
         int                  nd_state;       /* state of the node */
         int                  nd_timeout;     /* session timeout */
         cfs_time_t           nd_stamp;       /* timestamp of last replied RPC */
         int                  nd_ref;         /* reference count */
         int                  nd_state;       /* state of the node */
         int                  nd_timeout;     /* session timeout */
         cfs_time_t           nd_stamp;       /* timestamp of last replied RPC */

-        struct lstcon_rpc    nd_ping;        /* ping rpc */
-} lstcon_node_t;                                /*** node descriptor */
+       struct lstcon_rpc       nd_ping;        /* ping rpc */
+};

 
 

-typedef struct {
+/* node link descriptor */
+struct lstcon_ndlink {

        struct list_head        ndl_link;       /* chain on list */
        struct list_head        ndl_hlink;      /* chain on hash */
        struct list_head        ndl_link;       /* chain on list */
        struct list_head        ndl_hlink;      /* chain on hash */

-       lstcon_node_t           *ndl_node;      /* pointer to node */
-} lstcon_ndlink_t;                             /*** node link descriptor */
+       struct lstcon_node      *ndl_node;      /* pointer to node */
+};

 
 

-typedef struct {
+/* (alias of nodes) group descriptor */
+struct lstcon_group {

        struct list_head        grp_link;       /* chain on global group list */
        int                     grp_ref;        /* reference count */
        int                     grp_userland;   /* has userland nodes */
        struct list_head        grp_link;       /* chain on global group list */
        int                     grp_ref;        /* reference count */
        int                     grp_userland;   /* has userland nodes */


@@ -72,19 +75,20 @@ typedef struct {
        struct list_head        grp_trans_list; /* transaction list */
        struct list_head        grp_ndl_list;   /* nodes list */
        struct list_head        grp_ndl_hash[0];/* hash table for nodes */
        struct list_head        grp_trans_list; /* transaction list */
        struct list_head        grp_ndl_list;   /* nodes list */
        struct list_head        grp_ndl_hash[0];/* hash table for nodes */

-} lstcon_group_t;              /*** (alias of nodes) group descriptor */
+};

 
 #define LST_BATCH_IDLE          0xB0            /* idle batch */
 #define LST_BATCH_RUNNING       0xB1            /* running batch */
 
 
 #define LST_BATCH_IDLE          0xB0            /* idle batch */
 #define LST_BATCH_RUNNING       0xB1            /* running batch */
 

-typedef struct lstcon_tsb_hdr {
+struct lstcon_tsb_hdr {

        struct lst_bid          tsb_id;         /* batch ID */
         int                     tsb_index;      /* test index */
        struct lst_bid          tsb_id;         /* batch ID */
         int                     tsb_index;      /* test index */

-} lstcon_tsb_hdr_t;
+};

 
 

-typedef struct {
+/* (tests ) batch descriptor */
+struct lstcon_batch {

        /* test_batch header */
        /* test_batch header */

-       lstcon_tsb_hdr_t        bat_hdr;
+       struct lstcon_tsb_hdr   bat_hdr;

        /* chain on session's batches list */
        struct list_head        bat_link;
        /* # of test */
        /* chain on session's batches list */
        struct list_head        bat_link;
        /* # of test */


@@ -100,7 +104,7 @@ typedef struct {
        struct list_head        bat_test_list;
        /* list head of transaction */
        struct list_head        bat_trans_list;
        struct list_head        bat_test_list;
        /* list head of transaction */
        struct list_head        bat_trans_list;

-       /* list head of client nodes (lstcon_node_t) */
+       /* list head of client nodes (struct lstcon_node) */

        struct list_head        bat_cli_list;
        /* hash table of client nodes */
        struct list_head        *bat_cli_hash;
        struct list_head        bat_cli_list;
        /* hash table of client nodes */
        struct list_head        *bat_cli_hash;


@@ -108,15 +112,16 @@ typedef struct {
        struct list_head        bat_srv_list;
        /* hash table of server nodes */
        struct list_head        *bat_srv_hash;
        struct list_head        bat_srv_list;
        /* hash table of server nodes */
        struct list_head        *bat_srv_hash;

-} lstcon_batch_t;              /*** (tests ) batch descritptor */
+};

 
 

-typedef struct lstcon_test {
+/* a single test descriptor */
+struct lstcon_test {

        /* test batch header */
        /* test batch header */

-       lstcon_tsb_hdr_t        tes_hdr;
+       struct lstcon_tsb_hdr   tes_hdr;

        /* chain on batch's tests list */
        struct list_head        tes_link;
        /* pointer to batch */
        /* chain on batch's tests list */
        struct list_head        tes_link;
        /* pointer to batch */

-       lstcon_batch_t         *tes_batch;
+       struct lstcon_batch     *tes_batch;

 
         int                   tes_type;       /* type of the test, i.e: bulk, ping */
         int                   tes_stop_onerr; /* stop on error */
 
         int                   tes_type;       /* type of the test, i.e: bulk, ping */
         int                   tes_stop_onerr; /* stop on error */


@@ -128,12 +133,12 @@ typedef struct lstcon_test {
         int                   tes_cliidx;     /* client index, used for RPC creating */
 
        struct list_head        tes_trans_list; /* transaction list */
         int                   tes_cliidx;     /* client index, used for RPC creating */
 
        struct list_head        tes_trans_list; /* transaction list */

-       lstcon_group_t          *tes_src_grp;   /* group run the test */
-       lstcon_group_t          *tes_dst_grp;   /* target group */
+       struct lstcon_group     *tes_src_grp;   /* group run the test */
+       struct lstcon_group     *tes_dst_grp;   /* target group */

 
         int                   tes_paramlen;   /* test parameter length */
         char                  tes_param[0];   /* test parameter */
 
         int                   tes_paramlen;   /* test parameter length */
         char                  tes_param[0];   /* test parameter */

-} lstcon_test_t;                                /*** a single test descriptor */
+};

 
 #define LST_GLOBAL_HASHSIZE     503             /* global nodes hash table size */
 #define LST_NODE_HASHSIZE       239             /* node hash table (for batch or group) */
 
 #define LST_GLOBAL_HASHSIZE     503             /* global nodes hash table size */
 #define LST_NODE_HASHSIZE       239             /* node hash table (for batch or group) */


@@ -143,9 +148,9 @@ typedef struct lstcon_test {
 
 #define LST_CONSOLE_TIMEOUT     300             /* default console timeout */
 
 
 #define LST_CONSOLE_TIMEOUT     300             /* default console timeout */
 

-typedef struct {
+struct lstcon_session {

        struct mutex            ses_mutex;      /* only 1 thread in session */
        struct mutex            ses_mutex;      /* only 1 thread in session */

-       struct lst_sid               ses_id;         /* global session id */
+       struct lst_sid          ses_id;         /* global session id */

         int                     ses_key;        /* local session key */
         int                     ses_state;      /* state of session */
         int                     ses_timeout;    /* timeout in seconds */
         int                     ses_key;        /* local session key */
         int                     ses_state;      /* state of session */
         int                     ses_timeout;    /* timeout in seconds */


@@ -162,9 +167,9 @@ typedef struct {
        unsigned                ses_expired:1;
         __u64                   ses_id_cookie;  /* batch id cookie */
         char                    ses_name[LST_NAME_SIZE];  /* session name */
        unsigned                ses_expired:1;
         __u64                   ses_id_cookie;  /* batch id cookie */
         char                    ses_name[LST_NAME_SIZE];  /* session name */

-        lstcon_rpc_trans_t     *ses_ping;       /* session pinger */
-        stt_timer_t             ses_ping_timer; /* timer for pinger */
-       struct lstcon_trans_stat     ses_trans_stat; /* transaction stats */
+       struct lstcon_rpc_trans *ses_ping;      /* session pinger */
+       struct stt_timer        ses_ping_timer; /* timer for pinger */
+       struct lstcon_trans_stat ses_trans_stat;/* transaction stats */

 
        struct list_head        ses_trans_list; /* global list of transaction */
        struct list_head        ses_grp_list;   /* global list of groups */
 
        struct list_head        ses_trans_list; /* global list of transaction */
        struct list_head        ses_grp_list;   /* global list of groups */


@@ -175,9 +180,9 @@ typedef struct {
        spinlock_t              ses_rpc_lock;   /* serialize */
        atomic_t                ses_rpc_counter;/* # of initialized RPCs */
        struct list_head        ses_rpc_freelist;/* idle console rpc */
        spinlock_t              ses_rpc_lock;   /* serialize */
        atomic_t                ses_rpc_counter;/* # of initialized RPCs */
        struct list_head        ses_rpc_freelist;/* idle console rpc */

-} lstcon_session_t;            /*** session descriptor */
+}; /* session descriptor */

 
 

-extern lstcon_session_t         console_session;
+extern struct lstcon_session console_session;

 
 static inline struct lstcon_trans_stat *
 lstcon_trans_stat(void)
 
 static inline struct lstcon_trans_stat *
 lstcon_trans_stat(void)

diff --git a/lnet/selftest/framework.c b/lnet/selftest/framework.c
index 032d95e..b85dbb5 100644 (file)
--- a/lnet/selftest/framework.c
+++ b/lnet/selftest/framework.c
@@ -111,21 +111,21 @@ static struct smoketest_framework {
        /* serialise */
        spinlock_t              fw_lock;
        /* _the_ session */
        /* serialise */
        spinlock_t              fw_lock;
        /* _the_ session */

-       sfw_session_t           *fw_session;
+       struct sfw_session      *fw_session;

        /* shutdown in progress */
        int                     fw_shuttingdown;
        /* running RPC */
        /* shutdown in progress */
        int                     fw_shuttingdown;
        /* running RPC */

-       srpc_server_rpc_t       *fw_active_srpc;
+       struct srpc_server_rpc  *fw_active_srpc;

 } sfw_data;
 
 /* forward ref's */
 } sfw_data;
 
 /* forward ref's */

-int sfw_stop_batch (sfw_batch_t *tsb, int force);
-void sfw_destroy_session (sfw_session_t *sn);
+static int sfw_stop_batch(struct sfw_batch *tsb, int force);
+static void sfw_destroy_session(struct sfw_session *sn);

 
 

-static inline sfw_test_case_t *
+static inline struct sfw_test_case *

 sfw_find_test_case(int id)
 {
 sfw_find_test_case(int id)
 {

-       sfw_test_case_t *tsc;
+       struct sfw_test_case *tsc;

 
        LASSERT(id <= SRPC_SERVICE_MAX_ID);
        LASSERT(id > SRPC_FRAMEWORK_SERVICE_MAX_ID);
 
        LASSERT(id <= SRPC_SERVICE_MAX_ID);
        LASSERT(id > SRPC_FRAMEWORK_SERVICE_MAX_ID);


@@ -139,9 +139,10 @@ sfw_find_test_case(int id)
 }
 
 static int
 }
 
 static int

-sfw_register_test (srpc_service_t *service, sfw_test_client_ops_t *cliops)
+sfw_register_test(struct srpc_service *service,
+                 struct sfw_test_client_ops *cliops)

 {
 {

-        sfw_test_case_t *tsc;
+       struct sfw_test_case *tsc;

 
         if (sfw_find_test_case(service->sv_id) != NULL) {
                 CERROR ("Failed to register test %s (%d)\n",
 
         if (sfw_find_test_case(service->sv_id) != NULL) {
                 CERROR ("Failed to register test %s (%d)\n",


@@ -149,7 +150,7 @@ sfw_register_test (srpc_service_t *service, sfw_test_client_ops_t *cliops)
                 return -EEXIST;
         }
 
                 return -EEXIST;
         }
 

-        LIBCFS_ALLOC(tsc, sizeof(sfw_test_case_t));
+       LIBCFS_ALLOC(tsc, sizeof(*tsc));

         if (tsc == NULL)
                 return -ENOMEM;
 
         if (tsc == NULL)
                 return -ENOMEM;
 


@@ -163,8 +164,8 @@ sfw_register_test (srpc_service_t *service, sfw_test_client_ops_t *cliops)
 static void
 sfw_add_session_timer (void)
 {
 static void
 sfw_add_session_timer (void)
 {

-        sfw_session_t *sn = sfw_data.fw_session;
-        stt_timer_t   *timer = &sn->sn_timer;
+       struct sfw_session *sn = sfw_data.fw_session;
+       struct stt_timer *timer = &sn->sn_timer;

 
         LASSERT (!sfw_data.fw_shuttingdown);
 
 
         LASSERT (!sfw_data.fw_shuttingdown);
 


@@ -182,7 +183,7 @@ sfw_add_session_timer (void)
 static int
 sfw_del_session_timer (void)
 {
 static int
 sfw_del_session_timer (void)
 {

-        sfw_session_t *sn = sfw_data.fw_session;
+       struct sfw_session *sn = sfw_data.fw_session;

 
         if (sn == NULL || !sn->sn_timer_active)
                 return 0;
 
         if (sn == NULL || !sn->sn_timer_active)
                 return 0;


@@ -202,10 +203,10 @@ static void
 sfw_deactivate_session (void)
 __must_hold(&sfw_data.fw_lock)
 {
 sfw_deactivate_session (void)
 __must_hold(&sfw_data.fw_lock)
 {

-        sfw_session_t *sn = sfw_data.fw_session;
+       struct sfw_session *sn = sfw_data.fw_session;

         int            nactive = 0;
         int            nactive = 0;

-        sfw_batch_t   *tsb;
-        sfw_test_case_t *tsc;
+       struct sfw_batch *tsb;
+       struct sfw_test_case *tsc;

 
         if (sn == NULL) return;
 
 
         if (sn == NULL) return;
 


@@ -245,7 +246,7 @@ __must_hold(&sfw_data.fw_lock)
 static void
 sfw_session_expired (void *data)
 {
 static void
 sfw_session_expired (void *data)
 {

-       sfw_session_t *sn = data;
+       struct sfw_session *sn = data;

 
        spin_lock(&sfw_data.fw_lock);
 
 
        spin_lock(&sfw_data.fw_lock);
 


@@ -263,12 +264,12 @@ sfw_session_expired (void *data)
 }
 
 static inline void
 }
 
 static inline void

-sfw_init_session(sfw_session_t *sn, struct lst_sid sid,
+sfw_init_session(struct sfw_session *sn, struct lst_sid sid,

                 unsigned features, const char *name)
 {
                 unsigned features, const char *name)
 {

-        stt_timer_t *timer = &sn->sn_timer;
+       struct stt_timer *timer = &sn->sn_timer;

 
 

-        memset(sn, 0, sizeof(sfw_session_t));
+       memset(sn, 0, sizeof(struct sfw_session));

        INIT_LIST_HEAD(&sn->sn_list);
        INIT_LIST_HEAD(&sn->sn_batches);
        atomic_set(&sn->sn_refcount, 1);        /* +1 for caller */
        INIT_LIST_HEAD(&sn->sn_list);
        INIT_LIST_HEAD(&sn->sn_batches);
        atomic_set(&sn->sn_refcount, 1);        /* +1 for caller */


@@ -307,7 +308,7 @@ sfw_server_rpc_done(struct srpc_server_rpc *rpc)
 }
 
 static void
 }
 
 static void

-sfw_client_rpc_fini (srpc_client_rpc_t *rpc)
+sfw_client_rpc_fini(struct srpc_client_rpc *rpc)

 {
        LASSERT(rpc->crpc_bulk.bk_niov == 0);
        LASSERT(list_empty(&rpc->crpc_list));
 {
        LASSERT(rpc->crpc_bulk.bk_niov == 0);
        LASSERT(list_empty(&rpc->crpc_list));


@@ -328,11 +329,11 @@ sfw_client_rpc_fini (srpc_client_rpc_t *rpc)
        spin_unlock(&sfw_data.fw_lock);
 }
 
        spin_unlock(&sfw_data.fw_lock);
 }
 

-static sfw_batch_t *
+static struct sfw_batch *

 sfw_find_batch(struct lst_bid bid)
 {
 sfw_find_batch(struct lst_bid bid)
 {

-       sfw_session_t *sn = sfw_data.fw_session;
-       sfw_batch_t   *bat;
+       struct sfw_session *sn = sfw_data.fw_session;
+       struct sfw_batch *bat;

 
        LASSERT(sn != NULL);
 
 
        LASSERT(sn != NULL);
 


@@ -344,11 +345,11 @@ sfw_find_batch(struct lst_bid bid)
        return NULL;
 }
 
        return NULL;
 }
 

-static sfw_batch_t *
+static struct sfw_batch *

 sfw_bid2batch(struct lst_bid bid)
 {
 sfw_bid2batch(struct lst_bid bid)
 {

-        sfw_session_t *sn = sfw_data.fw_session;
-        sfw_batch_t   *bat;
+       struct sfw_session *sn = sfw_data.fw_session;
+       struct sfw_batch *bat;

 
         LASSERT (sn != NULL);
 
 
         LASSERT (sn != NULL);
 


@@ -356,7 +357,7 @@ sfw_bid2batch(struct lst_bid bid)
         if (bat != NULL)
                 return bat;
 
         if (bat != NULL)
                 return bat;
 

-        LIBCFS_ALLOC(bat, sizeof(sfw_batch_t));
+       LIBCFS_ALLOC(bat, sizeof(*bat));

        if (bat == NULL)
                 return NULL;
 
        if (bat == NULL)
                 return NULL;
 


@@ -371,11 +372,11 @@ sfw_bid2batch(struct lst_bid bid)
 }
 
 static int
 }
 
 static int

-sfw_get_stats (srpc_stat_reqst_t *request, srpc_stat_reply_t *reply)
+sfw_get_stats(struct srpc_stat_reqst *request, struct srpc_stat_reply *reply)

 {
 {

-        sfw_session_t  *sn = sfw_data.fw_session;
+       struct sfw_session *sn = sfw_data.fw_session;

        struct sfw_counters *cnt = &reply->str_fw;
        struct sfw_counters *cnt = &reply->str_fw;

-        sfw_batch_t    *bat;
+       struct sfw_batch *bat;

 
         reply->str_sid = (sn == NULL) ? LST_INVALID_SID : sn->sn_id;
 
 
         reply->str_sid = (sn == NULL) ? LST_INVALID_SID : sn->sn_id;
 


@@ -410,12 +411,12 @@ sfw_get_stats (srpc_stat_reqst_t *request, srpc_stat_reply_t *reply)
 }
 
 int
 }
 
 int

-sfw_make_session(srpc_mksn_reqst_t *request, srpc_mksn_reply_t *reply)
+sfw_make_session(struct srpc_mksn_reqst *request, struct srpc_mksn_reply *reply)

 {
 {

-       sfw_session_t *sn = sfw_data.fw_session;
-       srpc_msg_t    *msg = container_of(request, srpc_msg_t,
-                                         msg_body.mksn_reqst);
-       int            cplen = 0;
+       struct sfw_session *sn = sfw_data.fw_session;
+       struct srpc_msg *msg = container_of(request, struct srpc_msg,
+                                           msg_body.mksn_reqst);
+       int cplen = 0;

 
         if (request->mksn_sid.ses_nid == LNET_NID_ANY) {
                 reply->mksn_sid = (sn == NULL) ? LST_INVALID_SID : sn->sn_id;
 
         if (request->mksn_sid.ses_nid == LNET_NID_ANY) {
                 reply->mksn_sid = (sn == NULL) ? LST_INVALID_SID : sn->sn_id;


@@ -445,7 +446,7 @@ sfw_make_session(srpc_mksn_reqst_t *request, srpc_mksn_reply_t *reply)
 
        /* reject the request if it requires unknown features
         * NB: old version will always accept all features because it's not
 
        /* reject the request if it requires unknown features
         * NB: old version will always accept all features because it's not

-        * aware of srpc_msg_t::msg_ses_feats, it's a defect but it's also
+        * aware of struct srpc_msg::msg_ses_feats, it's a defect but it's also

         * harmless because it will return zero feature to console, and it's
         * console's responsibility to make sure all nodes in a session have
         * same feature mask. */
         * harmless because it will return zero feature to console, and it's
         * console's responsibility to make sure all nodes in a session have
         * same feature mask. */


@@ -455,7 +456,7 @@ sfw_make_session(srpc_mksn_reqst_t *request, srpc_mksn_reply_t *reply)
        }
 
        /* brand new or create by force */
        }
 
        /* brand new or create by force */

-       LIBCFS_ALLOC(sn, sizeof(sfw_session_t));
+       LIBCFS_ALLOC(sn, sizeof(*sn));

        if (sn == NULL) {
                CERROR("dropping RPC mksn under memory pressure\n");
                return -ENOMEM;
        if (sn == NULL) {
                CERROR("dropping RPC mksn under memory pressure\n");
                return -ENOMEM;


@@ -479,9 +480,10 @@ sfw_make_session(srpc_mksn_reqst_t *request, srpc_mksn_reply_t *reply)
 }
 
 static int
 }
 
 static int

-sfw_remove_session (srpc_rmsn_reqst_t *request, srpc_rmsn_reply_t *reply)
+sfw_remove_session(struct srpc_rmsn_reqst *request,
+                  struct srpc_rmsn_reply *reply)

 {
 {

-        sfw_session_t *sn = sfw_data.fw_session;
+       struct sfw_session *sn = sfw_data.fw_session;

 
         reply->rmsn_sid = (sn == NULL) ? LST_INVALID_SID : sn->sn_id;
 
 
         reply->rmsn_sid = (sn == NULL) ? LST_INVALID_SID : sn->sn_id;
 


@@ -511,9 +513,10 @@ sfw_remove_session (srpc_rmsn_reqst_t *request, srpc_rmsn_reply_t *reply)
 }
 
 static int
 }
 
 static int

-sfw_debug_session (srpc_debug_reqst_t *request, srpc_debug_reply_t *reply)
+sfw_debug_session(struct srpc_debug_reqst *request,
+                 struct srpc_debug_reply *reply)

 {
 {

-        sfw_session_t *sn = sfw_data.fw_session;
+       struct sfw_session *sn = sfw_data.fw_session;

 
         if (sn == NULL) {
                 reply->dbg_status = ESRCH;
 
         if (sn == NULL) {
                 reply->dbg_status = ESRCH;


@@ -532,10 +535,10 @@ sfw_debug_session (srpc_debug_reqst_t *request, srpc_debug_reply_t *reply)
 }
 
 static void
 }
 
 static void

-sfw_test_rpc_fini (srpc_client_rpc_t *rpc)
+sfw_test_rpc_fini(struct srpc_client_rpc *rpc)

 {
 {

-       sfw_test_unit_t     *tsu = rpc->crpc_priv;
-       sfw_test_instance_t *tsi = tsu->tsu_instance;
+       struct sfw_test_unit *tsu = rpc->crpc_priv;
+       struct sfw_test_instance *tsi = tsu->tsu_instance;

 
        /* Called with hold of tsi->tsi_lock */
        LASSERT(list_empty(&rpc->crpc_list));
 
        /* Called with hold of tsi->tsi_lock */
        LASSERT(list_empty(&rpc->crpc_list));


@@ -543,7 +546,7 @@ sfw_test_rpc_fini (srpc_client_rpc_t *rpc)
 }
 
 static inline int
 }
 
 static inline int

-sfw_test_buffers(sfw_test_instance_t *tsi)
+sfw_test_buffers(struct sfw_test_instance *tsi)

 {
        struct sfw_test_case    *tsc;
        struct srpc_service     *svc;
 {
        struct sfw_test_case    *tsc;
        struct srpc_service     *svc;


@@ -617,10 +620,10 @@ sfw_unload_test(struct sfw_test_instance *tsi)
 }
 
 static void
 }
 
 static void

-sfw_destroy_test_instance (sfw_test_instance_t *tsi)
+sfw_destroy_test_instance(struct sfw_test_instance *tsi)

 {
 {

-        srpc_client_rpc_t *rpc;
-        sfw_test_unit_t   *tsu;
+       struct srpc_client_rpc *rpc;
+       struct sfw_test_unit *tsu;

 
         if (!tsi->tsi_is_client) goto clean;
 
 
         if (!tsi->tsi_is_client) goto clean;
 


@@ -632,14 +635,14 @@ sfw_destroy_test_instance (sfw_test_instance_t *tsi)
 
        while (!list_empty(&tsi->tsi_units)) {
                tsu = list_entry(tsi->tsi_units.next,
 
        while (!list_empty(&tsi->tsi_units)) {
                tsu = list_entry(tsi->tsi_units.next,

-                                sfw_test_unit_t, tsu_list);
+                                struct sfw_test_unit, tsu_list);

                list_del(&tsu->tsu_list);
                LIBCFS_FREE(tsu, sizeof(*tsu));
        }
 
        while (!list_empty(&tsi->tsi_free_rpcs)) {
                rpc = list_entry(tsi->tsi_free_rpcs.next,
                list_del(&tsu->tsu_list);
                LIBCFS_FREE(tsu, sizeof(*tsu));
        }
 
        while (!list_empty(&tsi->tsi_free_rpcs)) {
                rpc = list_entry(tsi->tsi_free_rpcs.next,

-                                srpc_client_rpc_t, crpc_list);
+                                struct srpc_client_rpc, crpc_list);

                list_del(&rpc->crpc_list);
                LIBCFS_FREE(rpc, srpc_client_rpc_size(rpc));
        }
                list_del(&rpc->crpc_list);
                LIBCFS_FREE(rpc, srpc_client_rpc_size(rpc));
        }


@@ -651,35 +654,35 @@ clean:
 }
 
 static void
 }
 
 static void

-sfw_destroy_batch (sfw_batch_t *tsb)
+sfw_destroy_batch(struct sfw_batch *tsb)

 {
 {

-       sfw_test_instance_t *tsi;
+       struct sfw_test_instance *tsi;

 
        LASSERT(!sfw_batch_active(tsb));
        LASSERT(list_empty(&tsb->bat_list));
 
        while (!list_empty(&tsb->bat_tests)) {
                tsi = list_entry(tsb->bat_tests.next,
 
        LASSERT(!sfw_batch_active(tsb));
        LASSERT(list_empty(&tsb->bat_list));
 
        while (!list_empty(&tsb->bat_tests)) {
                tsi = list_entry(tsb->bat_tests.next,

-                                sfw_test_instance_t, tsi_list);
+                                struct sfw_test_instance, tsi_list);

                list_del_init(&tsi->tsi_list);
                sfw_destroy_test_instance(tsi);
        }
 
                list_del_init(&tsi->tsi_list);
                sfw_destroy_test_instance(tsi);
        }
 

-       LIBCFS_FREE(tsb, sizeof(sfw_batch_t));
+       LIBCFS_FREE(tsb, sizeof(*tsb));

        return;
 }
 
        return;
 }
 

-void
-sfw_destroy_session (sfw_session_t *sn)
+static void
+sfw_destroy_session(struct sfw_session *sn)

 {
 {

-       sfw_batch_t *batch;
+       struct sfw_batch *batch;

 
        LASSERT(list_empty(&sn->sn_list));
        LASSERT(sn != sfw_data.fw_session);
 
        while (!list_empty(&sn->sn_batches)) {
                batch = list_entry(sn->sn_batches.next,
 
        LASSERT(list_empty(&sn->sn_list));
        LASSERT(sn != sfw_data.fw_session);
 
        while (!list_empty(&sn->sn_batches)) {
                batch = list_entry(sn->sn_batches.next,

-                                  sfw_batch_t, bat_list);
+                                  struct sfw_batch, bat_list);

                list_del_init(&batch->bat_list);
                sfw_destroy_batch(batch);
        }
                list_del_init(&batch->bat_list);
                sfw_destroy_batch(batch);
        }


@@ -690,9 +693,9 @@ sfw_destroy_session (sfw_session_t *sn)
 }
 
 static void
 }
 
 static void

-sfw_unpack_addtest_req(srpc_msg_t *msg)
+sfw_unpack_addtest_req(struct srpc_msg *msg)

 {
 {

-        srpc_test_reqst_t *req = &msg->msg_body.tes_reqst;
+       struct srpc_test_reqst *req = &msg->msg_body.tes_reqst;

 
         LASSERT (msg->msg_type == SRPC_MSG_TEST_REQST);
         LASSERT (req->tsr_is_client);
 
         LASSERT (msg->msg_type == SRPC_MSG_TEST_REQST);
         LASSERT (req->tsr_is_client);


@@ -704,14 +707,14 @@ sfw_unpack_addtest_req(srpc_msg_t *msg)
 
        if (req->tsr_service == SRPC_SERVICE_BRW) {
                if ((msg->msg_ses_feats & LST_FEAT_BULK_LEN) == 0) {
 
        if (req->tsr_service == SRPC_SERVICE_BRW) {
                if ((msg->msg_ses_feats & LST_FEAT_BULK_LEN) == 0) {

-                       test_bulk_req_t *bulk = &req->tsr_u.bulk_v0;
+                       struct test_bulk_req *bulk = &req->tsr_u.bulk_v0;

 
                        __swab32s(&bulk->blk_opc);
                        __swab32s(&bulk->blk_npg);
                        __swab32s(&bulk->blk_flags);
 
                } else {
 
                        __swab32s(&bulk->blk_opc);
                        __swab32s(&bulk->blk_npg);
                        __swab32s(&bulk->blk_flags);
 
                } else {

-                       test_bulk_req_v1_t *bulk = &req->tsr_u.bulk_v1;
+                       struct test_bulk_req_v1 *bulk = &req->tsr_u.bulk_v1;

 
                        __swab16s(&bulk->blk_opc);
                        __swab16s(&bulk->blk_flags);
 
                        __swab16s(&bulk->blk_opc);
                        __swab16s(&bulk->blk_flags);


@@ -723,7 +726,7 @@ sfw_unpack_addtest_req(srpc_msg_t *msg)
        }
 
         if (req->tsr_service == SRPC_SERVICE_PING) {
        }
 
         if (req->tsr_service == SRPC_SERVICE_PING) {

-                test_ping_req_t *ping = &req->tsr_u.ping;
+               struct test_ping_req *ping = &req->tsr_u.ping;

 
                 __swab32s(&ping->png_size);
                 __swab32s(&ping->png_flags);
 
                 __swab32s(&ping->png_size);
                 __swab32s(&ping->png_flags);


@@ -735,16 +738,16 @@ sfw_unpack_addtest_req(srpc_msg_t *msg)
 }
 
 static int
 }
 
 static int

-sfw_add_test_instance (sfw_batch_t *tsb, srpc_server_rpc_t *rpc)
+sfw_add_test_instance(struct sfw_batch *tsb, struct srpc_server_rpc *rpc)

 {
 {

-        srpc_msg_t          *msg = &rpc->srpc_reqstbuf->buf_msg;
-        srpc_test_reqst_t   *req = &msg->msg_body.tes_reqst;
-        srpc_bulk_t         *bk = rpc->srpc_bulk;
-        int                  ndest = req->tsr_ndest;
-        sfw_test_unit_t     *tsu;
-        sfw_test_instance_t *tsi;
-        int                  i;
-        int                  rc;
+       struct srpc_msg *msg = &rpc->srpc_reqstbuf->buf_msg;
+       struct srpc_test_reqst *req = &msg->msg_body.tes_reqst;
+       struct srpc_bulk *bk = rpc->srpc_bulk;
+       int ndest = req->tsr_ndest;
+       struct sfw_test_unit *tsu;
+       struct sfw_test_instance *tsi;
+       int i;
+       int rc;

 
         LIBCFS_ALLOC(tsi, sizeof(*tsi));
         if (tsi == NULL) {
 
         LIBCFS_ALLOC(tsi, sizeof(*tsi));
         if (tsi == NULL) {


@@ -801,7 +804,7 @@ sfw_add_test_instance (sfw_batch_t *tsb, srpc_server_rpc_t *rpc)
                         sfw_unpack_id(id);
 
                 for (j = 0; j < tsi->tsi_concur; j++) {
                         sfw_unpack_id(id);
 
                 for (j = 0; j < tsi->tsi_concur; j++) {

-                        LIBCFS_ALLOC(tsu, sizeof(sfw_test_unit_t));
+                       LIBCFS_ALLOC(tsu, sizeof(*tsu));

                         if (tsu == NULL) {
                                 rc = -ENOMEM;
                                 CERROR ("Can't allocate tsu for %d\n",
                         if (tsu == NULL) {
                                 rc = -ENOMEM;
                                 CERROR ("Can't allocate tsu for %d\n",


@@ -830,11 +833,11 @@ error:
 }
 
 static void
 }
 
 static void

-sfw_test_unit_done (sfw_test_unit_t *tsu)
+sfw_test_unit_done(struct sfw_test_unit *tsu)

 {
 {

-        sfw_test_instance_t *tsi = tsu->tsu_instance;
-        sfw_batch_t         *tsb = tsi->tsi_batch;
-        sfw_session_t       *sn = tsb->bat_session;
+       struct sfw_test_instance *tsi = tsu->tsu_instance;
+       struct sfw_batch *tsb = tsi->tsi_batch;
+       struct sfw_session *sn = tsb->bat_session;

 
         LASSERT (sfw_test_active(tsi));
 
 
         LASSERT (sfw_test_active(tsi));
 


@@ -873,10 +876,10 @@ sfw_test_unit_done (sfw_test_unit_t *tsu)
 }
 
 static void
 }
 
 static void

-sfw_test_rpc_done (srpc_client_rpc_t *rpc)
+sfw_test_rpc_done(struct srpc_client_rpc *rpc)

 {
 {

-        sfw_test_unit_t     *tsu = rpc->crpc_priv;
-        sfw_test_instance_t *tsi = tsu->tsu_instance;
+       struct sfw_test_unit *tsu = rpc->crpc_priv;
+       struct sfw_test_instance *tsi = tsu->tsu_instance;

         int                  done = 0;
 
         tsi->tsi_ops->tso_done_rpc(tsu, rpc);
         int                  done = 0;
 
         tsi->tsi_ops->tso_done_rpc(tsu, rpc);


@@ -909,12 +912,12 @@ sfw_test_rpc_done (srpc_client_rpc_t *rpc)
 }
 
 int
 }
 
 int

-sfw_create_test_rpc(sfw_test_unit_t *tsu, struct lnet_process_id peer,
+sfw_create_test_rpc(struct sfw_test_unit *tsu, struct lnet_process_id peer,

                    unsigned features, int nblk, int blklen,
                    unsigned features, int nblk, int blklen,

-                   srpc_client_rpc_t **rpcpp)
+                   struct srpc_client_rpc **rpcpp)

 {
 {

-       srpc_client_rpc_t   *rpc = NULL;
-       sfw_test_instance_t *tsi = tsu->tsu_instance;
+       struct srpc_client_rpc *rpc = NULL;
+       struct sfw_test_instance *tsi = tsu->tsu_instance;

 
        spin_lock(&tsi->tsi_lock);
 
 
        spin_lock(&tsi->tsi_lock);
 


@@ -923,7 +926,7 @@ sfw_create_test_rpc(sfw_test_unit_t *tsu, struct lnet_process_id peer,
        if (!list_empty(&tsi->tsi_free_rpcs)) {
                /* pick request from buffer */
                rpc = list_entry(tsi->tsi_free_rpcs.next,
        if (!list_empty(&tsi->tsi_free_rpcs)) {
                /* pick request from buffer */
                rpc = list_entry(tsi->tsi_free_rpcs.next,

-                                srpc_client_rpc_t, crpc_list);
+                                struct srpc_client_rpc, crpc_list);

                LASSERT(nblk == rpc->crpc_bulk.bk_niov);
                list_del_init(&rpc->crpc_list);
        }
                LASSERT(nblk == rpc->crpc_bulk.bk_niov);
                list_del_init(&rpc->crpc_list);
        }


@@ -952,11 +955,11 @@ sfw_create_test_rpc(sfw_test_unit_t *tsu, struct lnet_process_id peer,
 }
 
 static int
 }
 
 static int

-sfw_run_test (swi_workitem_t *wi)
+sfw_run_test(struct swi_workitem *wi)

 {
 {

-        sfw_test_unit_t     *tsu = wi->swi_workitem.wi_data;
-        sfw_test_instance_t *tsi = tsu->tsu_instance;
-        srpc_client_rpc_t   *rpc = NULL;
+       struct sfw_test_unit *tsu = wi->swi_workitem.wi_data;
+       struct sfw_test_instance *tsi = tsu->tsu_instance;
+       struct srpc_client_rpc *rpc = NULL;

 
         LASSERT (wi == &tsu->tsu_worker);
 
 
         LASSERT (wi == &tsu->tsu_worker);
 


@@ -1001,11 +1004,11 @@ test_done:
 }
 
 static int
 }
 
 static int

-sfw_run_batch (sfw_batch_t *tsb)
+sfw_run_batch(struct sfw_batch *tsb)

 {
 {

-        swi_workitem_t      *wi;
-        sfw_test_unit_t     *tsu;
-        sfw_test_instance_t *tsi;
+       struct swi_workitem *wi;
+       struct sfw_test_unit *tsu;
+       struct sfw_test_instance *tsi;

 
         if (sfw_batch_active(tsb)) {
                CDEBUG(D_NET, "Batch already active: %llu (%d)\n",
 
         if (sfw_batch_active(tsb)) {
                CDEBUG(D_NET, "Batch already active: %llu (%d)\n",


@@ -1037,11 +1040,11 @@ sfw_run_batch (sfw_batch_t *tsb)
        return 0;
 }
 
        return 0;
 }
 

-int
-sfw_stop_batch (sfw_batch_t *tsb, int force)
+static int
+sfw_stop_batch(struct sfw_batch *tsb, int force)

 {
 {

-        sfw_test_instance_t *tsi;
-        srpc_client_rpc_t   *rpc;
+       struct sfw_test_instance *tsi;
+       struct srpc_client_rpc *rpc;

 
         if (!sfw_batch_active(tsb)) {
                CDEBUG(D_NET, "Batch %llu inactive\n", tsb->bat_id.bat_id);
 
         if (!sfw_batch_active(tsb)) {
                CDEBUG(D_NET, "Batch %llu inactive\n", tsb->bat_id.bat_id);


@@ -1080,9 +1083,10 @@ sfw_stop_batch (sfw_batch_t *tsb, int force)
 }
 
 static int
 }
 
 static int

-sfw_query_batch (sfw_batch_t *tsb, int testidx, srpc_batch_reply_t *reply)
+sfw_query_batch(struct sfw_batch *tsb, int testidx,
+               struct srpc_batch_reply *reply)

 {
 {

-        sfw_test_instance_t *tsi;
+       struct sfw_test_instance *tsi;

 
         if (testidx < 0)
                 return -EINVAL;
 
         if (testidx < 0)
                 return -EINVAL;


@@ -1104,7 +1108,7 @@ sfw_query_batch (sfw_batch_t *tsb, int testidx, srpc_batch_reply_t *reply)
 }
 
 void
 }
 
 void

-sfw_free_pages (srpc_server_rpc_t *rpc)
+sfw_free_pages(struct srpc_server_rpc *rpc)

 {
         srpc_free_bulk(rpc->srpc_bulk);
         rpc->srpc_bulk = NULL;
 {
         srpc_free_bulk(rpc->srpc_bulk);
         rpc->srpc_bulk = NULL;


@@ -1125,13 +1129,13 @@ sfw_alloc_pages(struct srpc_server_rpc *rpc, int cpt, int npages, int len,
 }
 
 static int
 }
 
 static int

-sfw_add_test (srpc_server_rpc_t *rpc)
+sfw_add_test(struct srpc_server_rpc *rpc)

 {
 {

-        sfw_session_t     *sn = sfw_data.fw_session;
-        srpc_test_reply_t *reply = &rpc->srpc_replymsg.msg_body.tes_reply;
-        srpc_test_reqst_t *request;
-        int                rc;
-        sfw_batch_t       *bat;
+       struct sfw_session *sn = sfw_data.fw_session;
+       struct srpc_test_reply *reply = &rpc->srpc_replymsg.msg_body.tes_reply;
+       struct srpc_test_reqst *request;
+       int rc;
+       struct sfw_batch *bat;

 
         request = &rpc->srpc_reqstbuf->buf_msg.msg_body.tes_reqst;
         reply->tsr_sid = (sn == NULL) ? LST_INVALID_SID : sn->sn_id;
 
         request = &rpc->srpc_reqstbuf->buf_msg.msg_body.tes_reqst;
         reply->tsr_sid = (sn == NULL) ? LST_INVALID_SID : sn->sn_id;


@@ -1195,11 +1199,12 @@ sfw_add_test (srpc_server_rpc_t *rpc)
 }
 
 static int
 }
 
 static int

-sfw_control_batch (srpc_batch_reqst_t *request, srpc_batch_reply_t *reply)
+sfw_control_batch(struct srpc_batch_reqst *request,
+                 struct srpc_batch_reply *reply)

 {
 {

-        sfw_session_t *sn = sfw_data.fw_session;
+       struct sfw_session *sn = sfw_data.fw_session;

         int            rc = 0;
         int            rc = 0;

-        sfw_batch_t   *bat;
+       struct sfw_batch *bat;

 
         reply->bar_sid = (sn == NULL) ? LST_INVALID_SID : sn->sn_id;
 
 
         reply->bar_sid = (sn == NULL) ? LST_INVALID_SID : sn->sn_id;
 


@@ -1239,8 +1244,8 @@ static int
 sfw_handle_server_rpc(struct srpc_server_rpc *rpc)
 {
        struct srpc_service     *sv = rpc->srpc_scd->scd_svc;
 sfw_handle_server_rpc(struct srpc_server_rpc *rpc)
 {
        struct srpc_service     *sv = rpc->srpc_scd->scd_svc;

-       srpc_msg_t     *reply   = &rpc->srpc_replymsg;
-       srpc_msg_t     *request = &rpc->srpc_reqstbuf->buf_msg;
+       struct srpc_msg     *reply      = &rpc->srpc_replymsg;
+       struct srpc_msg     *request    = &rpc->srpc_reqstbuf->buf_msg;

        unsigned        features = LST_FEATS_MASK;
        int             rc = 0;
 
        unsigned        features = LST_FEATS_MASK;
        int             rc = 0;
 


@@ -1273,7 +1278,7 @@ sfw_handle_server_rpc(struct srpc_server_rpc *rpc)
 
        if (sv->sv_id != SRPC_SERVICE_MAKE_SESSION &&
            sv->sv_id != SRPC_SERVICE_DEBUG) {
 
        if (sv->sv_id != SRPC_SERVICE_MAKE_SESSION &&
            sv->sv_id != SRPC_SERVICE_DEBUG) {

-               sfw_session_t *sn = sfw_data.fw_session;
+               struct sfw_session *sn = sfw_data.fw_session;

 
                if (sn != NULL &&
                    sn->sn_features != request->msg_ses_feats) {
 
                if (sn != NULL &&
                    sn->sn_features != request->msg_ses_feats) {


@@ -1389,12 +1394,12 @@ sfw_bulk_ready(struct srpc_server_rpc *rpc, int status)
        return rc;
 }
 
        return rc;
 }
 

-srpc_client_rpc_t *
+struct srpc_client_rpc *

 sfw_create_rpc(struct lnet_process_id peer, int service,
               unsigned features, int nbulkiov, int bulklen,
 sfw_create_rpc(struct lnet_process_id peer, int service,
               unsigned features, int nbulkiov, int bulklen,

-              void (*done)(srpc_client_rpc_t *), void *priv)
+              void (*done)(struct srpc_client_rpc *), void *priv)

 {
 {

-       srpc_client_rpc_t *rpc = NULL;
+       struct srpc_client_rpc *rpc = NULL;

 
        spin_lock(&sfw_data.fw_lock);
 
 
        spin_lock(&sfw_data.fw_lock);
 


@@ -1403,7 +1408,7 @@ sfw_create_rpc(struct lnet_process_id peer, int service,
 
        if (nbulkiov == 0 && !list_empty(&sfw_data.fw_zombie_rpcs)) {
                rpc = list_entry(sfw_data.fw_zombie_rpcs.next,
 
        if (nbulkiov == 0 && !list_empty(&sfw_data.fw_zombie_rpcs)) {
                rpc = list_entry(sfw_data.fw_zombie_rpcs.next,

-                                     srpc_client_rpc_t, crpc_list);
+                                    struct srpc_client_rpc, crpc_list);

                list_del(&rpc->crpc_list);
 
                 srpc_init_client_rpc(rpc, peer, service, 0, 0,
                list_del(&rpc->crpc_list);
 
                 srpc_init_client_rpc(rpc, peer, service, 0, 0,


@@ -1427,7 +1432,7 @@ sfw_create_rpc(struct lnet_process_id peer, int service,
 }
 
 void
 }
 
 void

-sfw_unpack_message (srpc_msg_t *msg)
+sfw_unpack_message(struct srpc_msg *msg)

 {
         if (msg->msg_magic == SRPC_MSG_MAGIC)
                 return; /* no flipping needed */
 {
         if (msg->msg_magic == SRPC_MSG_MAGIC)
                 return; /* no flipping needed */


@@ -1436,7 +1441,7 @@ sfw_unpack_message (srpc_msg_t *msg)
         LASSERT (msg->msg_magic == __swab32(SRPC_MSG_MAGIC));
 
         if (msg->msg_type == SRPC_MSG_STAT_REQST) {
         LASSERT (msg->msg_magic == __swab32(SRPC_MSG_MAGIC));
 
         if (msg->msg_type == SRPC_MSG_STAT_REQST) {

-                srpc_stat_reqst_t *req = &msg->msg_body.stat_reqst;
+               struct srpc_stat_reqst *req = &msg->msg_body.stat_reqst;

 
                 __swab32s(&req->str_type);
                 __swab64s(&req->str_rpyid);
 
                 __swab32s(&req->str_type);
                 __swab64s(&req->str_rpyid);


@@ -1445,7 +1450,7 @@ sfw_unpack_message (srpc_msg_t *msg)
         }
 
         if (msg->msg_type == SRPC_MSG_STAT_REPLY) {
         }
 
         if (msg->msg_type == SRPC_MSG_STAT_REPLY) {

-                srpc_stat_reply_t *rep = &msg->msg_body.stat_reply;
+               struct srpc_stat_reply *rep = &msg->msg_body.stat_reply;

 
                 __swab32s(&rep->str_status);
                 sfw_unpack_sid(rep->str_sid);
 
                 __swab32s(&rep->str_status);
                 sfw_unpack_sid(rep->str_sid);


@@ -1456,7 +1461,7 @@ sfw_unpack_message (srpc_msg_t *msg)
         }
 
         if (msg->msg_type == SRPC_MSG_MKSN_REQST) {
         }
 
         if (msg->msg_type == SRPC_MSG_MKSN_REQST) {

-                srpc_mksn_reqst_t *req = &msg->msg_body.mksn_reqst;
+               struct srpc_mksn_reqst *req = &msg->msg_body.mksn_reqst;

 
                 __swab64s(&req->mksn_rpyid);
                 __swab32s(&req->mksn_force);
 
                 __swab64s(&req->mksn_rpyid);
                 __swab32s(&req->mksn_force);


@@ -1465,7 +1470,7 @@ sfw_unpack_message (srpc_msg_t *msg)
         }
 
         if (msg->msg_type == SRPC_MSG_MKSN_REPLY) {
         }
 
         if (msg->msg_type == SRPC_MSG_MKSN_REPLY) {

-                srpc_mksn_reply_t *rep = &msg->msg_body.mksn_reply;
+               struct srpc_mksn_reply *rep = &msg->msg_body.mksn_reply;

 
                 __swab32s(&rep->mksn_status);
                 __swab32s(&rep->mksn_timeout);
 
                 __swab32s(&rep->mksn_status);
                 __swab32s(&rep->mksn_timeout);


@@ -1474,7 +1479,7 @@ sfw_unpack_message (srpc_msg_t *msg)
         }
 
         if (msg->msg_type == SRPC_MSG_RMSN_REQST) {
         }
 
         if (msg->msg_type == SRPC_MSG_RMSN_REQST) {

-                srpc_rmsn_reqst_t *req = &msg->msg_body.rmsn_reqst;
+               struct srpc_rmsn_reqst *req = &msg->msg_body.rmsn_reqst;

 
                 __swab64s(&req->rmsn_rpyid);
                 sfw_unpack_sid(req->rmsn_sid);
 
                 __swab64s(&req->rmsn_rpyid);
                 sfw_unpack_sid(req->rmsn_sid);


@@ -1482,7 +1487,7 @@ sfw_unpack_message (srpc_msg_t *msg)
         }
 
         if (msg->msg_type == SRPC_MSG_RMSN_REPLY) {
         }
 
         if (msg->msg_type == SRPC_MSG_RMSN_REPLY) {

-                srpc_rmsn_reply_t *rep = &msg->msg_body.rmsn_reply;
+               struct srpc_rmsn_reply *rep = &msg->msg_body.rmsn_reply;

 
                 __swab32s(&rep->rmsn_status);
                 sfw_unpack_sid(rep->rmsn_sid);
 
                 __swab32s(&rep->rmsn_status);
                 sfw_unpack_sid(rep->rmsn_sid);


@@ -1490,7 +1495,7 @@ sfw_unpack_message (srpc_msg_t *msg)
         }
 
         if (msg->msg_type == SRPC_MSG_DEBUG_REQST) {
         }
 
         if (msg->msg_type == SRPC_MSG_DEBUG_REQST) {

-                srpc_debug_reqst_t *req = &msg->msg_body.dbg_reqst;
+               struct srpc_debug_reqst *req = &msg->msg_body.dbg_reqst;

 
                 __swab64s(&req->dbg_rpyid);
                 __swab32s(&req->dbg_flags);
 
                 __swab64s(&req->dbg_rpyid);
                 __swab32s(&req->dbg_flags);


@@ -1499,7 +1504,7 @@ sfw_unpack_message (srpc_msg_t *msg)
         }
 
         if (msg->msg_type == SRPC_MSG_DEBUG_REPLY) {
         }
 
         if (msg->msg_type == SRPC_MSG_DEBUG_REPLY) {

-                srpc_debug_reply_t *rep = &msg->msg_body.dbg_reply;
+               struct srpc_debug_reply *rep = &msg->msg_body.dbg_reply;

 
                 __swab32s(&rep->dbg_nbatch);
                 __swab32s(&rep->dbg_timeout);
 
                 __swab32s(&rep->dbg_nbatch);
                 __swab32s(&rep->dbg_timeout);


@@ -1508,7 +1513,7 @@ sfw_unpack_message (srpc_msg_t *msg)
         }
 
         if (msg->msg_type == SRPC_MSG_BATCH_REQST) {
         }
 
         if (msg->msg_type == SRPC_MSG_BATCH_REQST) {

-                srpc_batch_reqst_t *req = &msg->msg_body.bat_reqst;
+               struct srpc_batch_reqst *req = &msg->msg_body.bat_reqst;

 
                 __swab32s(&req->bar_opc);
                 __swab64s(&req->bar_rpyid);
 
                 __swab32s(&req->bar_opc);
                 __swab64s(&req->bar_rpyid);


@@ -1520,7 +1525,7 @@ sfw_unpack_message (srpc_msg_t *msg)
         }
 
         if (msg->msg_type == SRPC_MSG_BATCH_REPLY) {
         }
 
         if (msg->msg_type == SRPC_MSG_BATCH_REPLY) {

-                srpc_batch_reply_t *rep = &msg->msg_body.bat_reply;
+               struct srpc_batch_reply *rep = &msg->msg_body.bat_reply;

 
                 __swab32s(&rep->bar_status);
                 sfw_unpack_sid(rep->bar_sid);
 
                 __swab32s(&rep->bar_status);
                 sfw_unpack_sid(rep->bar_sid);


@@ -1528,7 +1533,7 @@ sfw_unpack_message (srpc_msg_t *msg)
         }
 
         if (msg->msg_type == SRPC_MSG_TEST_REQST) {
         }
 
         if (msg->msg_type == SRPC_MSG_TEST_REQST) {

-                srpc_test_reqst_t *req = &msg->msg_body.tes_reqst;
+               struct srpc_test_reqst *req = &msg->msg_body.tes_reqst;

 
                 __swab64s(&req->tsr_rpyid);
                 __swab64s(&req->tsr_bulkid);
 
                 __swab64s(&req->tsr_rpyid);
                 __swab64s(&req->tsr_bulkid);


@@ -1542,7 +1547,7 @@ sfw_unpack_message (srpc_msg_t *msg)
         }
 
         if (msg->msg_type == SRPC_MSG_TEST_REPLY) {
         }
 
         if (msg->msg_type == SRPC_MSG_TEST_REPLY) {

-                srpc_test_reply_t *rep = &msg->msg_body.tes_reply;
+               struct srpc_test_reply *rep = &msg->msg_body.tes_reply;

 
                 __swab32s(&rep->tsr_status);
                 sfw_unpack_sid(rep->tsr_sid);
 
                 __swab32s(&rep->tsr_status);
                 sfw_unpack_sid(rep->tsr_sid);


@@ -1550,7 +1555,7 @@ sfw_unpack_message (srpc_msg_t *msg)
         }
 
         if (msg->msg_type == SRPC_MSG_JOIN_REQST) {
         }
 
         if (msg->msg_type == SRPC_MSG_JOIN_REQST) {

-                srpc_join_reqst_t *req = &msg->msg_body.join_reqst;
+               struct srpc_join_reqst *req = &msg->msg_body.join_reqst;

 
                 __swab64s(&req->join_rpyid);
                 sfw_unpack_sid(req->join_sid);
 
                 __swab64s(&req->join_rpyid);
                 sfw_unpack_sid(req->join_sid);


@@ -1558,7 +1563,7 @@ sfw_unpack_message (srpc_msg_t *msg)
         }
 
         if (msg->msg_type == SRPC_MSG_JOIN_REPLY) {
         }
 
         if (msg->msg_type == SRPC_MSG_JOIN_REPLY) {

-                srpc_join_reply_t *rep = &msg->msg_body.join_reply;
+               struct srpc_join_reply *rep = &msg->msg_body.join_reply;

 
                 __swab32s(&rep->join_status);
                 __swab32s(&rep->join_timeout);
 
                 __swab32s(&rep->join_status);
                 __swab32s(&rep->join_timeout);


@@ -1571,7 +1576,7 @@ sfw_unpack_message (srpc_msg_t *msg)
 }
 
 void
 }
 
 void

-sfw_abort_rpc (srpc_client_rpc_t *rpc)
+sfw_abort_rpc(struct srpc_client_rpc *rpc)

 {
        LASSERT(atomic_read(&rpc->crpc_refcount) > 0);
        LASSERT(rpc->crpc_service <= SRPC_FRAMEWORK_SERVICE_MAX_ID);
 {
        LASSERT(atomic_read(&rpc->crpc_refcount) > 0);
        LASSERT(rpc->crpc_service <= SRPC_FRAMEWORK_SERVICE_MAX_ID);


@@ -1583,7 +1588,7 @@ sfw_abort_rpc (srpc_client_rpc_t *rpc)
 }
 
 void
 }
 
 void

-sfw_post_rpc (srpc_client_rpc_t *rpc)
+sfw_post_rpc(struct srpc_client_rpc *rpc)

 {
        spin_lock(&rpc->crpc_lock);
 
 {
        spin_lock(&rpc->crpc_lock);
 


@@ -1599,8 +1604,7 @@ sfw_post_rpc (srpc_client_rpc_t *rpc)
        return;
 }
 
        return;
 }
 

-static srpc_service_t sfw_services[] =
-{
+static struct srpc_service sfw_services[] = {

         {
                 /* sv_id */    SRPC_SERVICE_DEBUG,
                 /* sv_name */  "debug",
         {
                 /* sv_id */    SRPC_SERVICE_DEBUG,
                 /* sv_name */  "debug",


@@ -1644,8 +1648,8 @@ sfw_startup (void)
         int              i;
         int              rc;
         int              error;
         int              i;
         int              rc;
         int              error;

-        srpc_service_t  *sv;
-        sfw_test_case_t *tsc;
+       struct srpc_service *sv;
+       struct sfw_test_case *tsc;

 
 
         if (session_timeout < 0) {
 
 
         if (session_timeout < 0) {


@@ -1739,8 +1743,8 @@ sfw_startup (void)
 void
 sfw_shutdown (void)
 {
 void
 sfw_shutdown (void)
 {

-       srpc_service_t  *sv;
-       sfw_test_case_t *tsc;
+       struct srpc_service *sv;
+       struct sfw_test_case *tsc;

        int              i;
 
        spin_lock(&sfw_data.fw_lock);
        int              i;
 
        spin_lock(&sfw_data.fw_lock);


@@ -1777,10 +1781,10 @@ sfw_shutdown (void)
         }
 
        while (!list_empty(&sfw_data.fw_zombie_rpcs)) {
         }
 
        while (!list_empty(&sfw_data.fw_zombie_rpcs)) {

-               srpc_client_rpc_t *rpc;
+               struct srpc_client_rpc *rpc;

 
                rpc = list_entry(sfw_data.fw_zombie_rpcs.next,
 
                rpc = list_entry(sfw_data.fw_zombie_rpcs.next,

-                                srpc_client_rpc_t, crpc_list);
+                                struct srpc_client_rpc, crpc_list);

                list_del(&rpc->crpc_list);
 
                LIBCFS_FREE(rpc, srpc_client_rpc_size(rpc));
                list_del(&rpc->crpc_list);
 
                LIBCFS_FREE(rpc, srpc_client_rpc_size(rpc));


@@ -1796,7 +1800,7 @@ sfw_shutdown (void)
 
        while (!list_empty(&sfw_data.fw_tests)) {
                tsc = list_entry(sfw_data.fw_tests.next,
 
        while (!list_empty(&sfw_data.fw_tests)) {
                tsc = list_entry(sfw_data.fw_tests.next,

-                                sfw_test_case_t, tsc_list);
+                                struct sfw_test_case, tsc_list);

 
                srpc_wait_service_shutdown(tsc->tsc_srv_service);
 
 
                srpc_wait_service_shutdown(tsc->tsc_srv_service);
 

diff --git a/lnet/selftest/module.c b/lnet/selftest/module.c
index 2f87742..be5e37c 100644 (file)
--- a/lnet/selftest/module.c
+++ b/lnet/selftest/module.c
@@ -87,12 +87,12 @@ lnet_selftest_exit(void)
 void
 lnet_selftest_structure_assertion(void)
 {
 void
 lnet_selftest_structure_assertion(void)
 {

-        CLASSERT(sizeof(srpc_msg_t) == 160);
-        CLASSERT(sizeof(srpc_test_reqst_t) == 70);
-        CLASSERT(offsetof(srpc_msg_t, msg_body.tes_reqst.tsr_concur) == 72);
-        CLASSERT(offsetof(srpc_msg_t, msg_body.tes_reqst.tsr_ndest) == 78);
-        CLASSERT(sizeof(srpc_stat_reply_t) == 136);
-        CLASSERT(sizeof(srpc_stat_reqst_t) == 28);
+       CLASSERT(sizeof(struct srpc_msg) == 160);
+       CLASSERT(sizeof(struct srpc_test_reqst) == 70);
+       CLASSERT(offsetof(struct srpc_msg, msg_body.tes_reqst.tsr_concur) == 72);
+       CLASSERT(offsetof(struct srpc_msg, msg_body.tes_reqst.tsr_ndest) == 78);
+       CLASSERT(sizeof(struct srpc_stat_reply) == 136);
+       CLASSERT(sizeof(struct srpc_stat_reqst) == 28);

 }
 
 static int __init
 }
 
 static int __init

diff --git a/lnet/selftest/ping_test.c b/lnet/selftest/ping_test.c
index ea20761..2d1403b 100644 (file)
--- a/lnet/selftest/ping_test.c
+++ b/lnet/selftest/ping_test.c
@@ -44,17 +44,17 @@ static int ping_srv_workitems = SFW_TEST_WI_MAX;
 module_param(ping_srv_workitems, int, 0644);
 MODULE_PARM_DESC(ping_srv_workitems, "# PING server workitems");
 
 module_param(ping_srv_workitems, int, 0644);
 MODULE_PARM_DESC(ping_srv_workitems, "# PING server workitems");
 

-typedef struct {
+struct lst_ping_data {

        spinlock_t      pnd_lock;       /* serialize */
        int             pnd_counter;    /* sequence counter */
        spinlock_t      pnd_lock;       /* serialize */
        int             pnd_counter;    /* sequence counter */

-} lst_ping_data_t;
+};

 
 

-static lst_ping_data_t  lst_ping_data;
+static struct lst_ping_data lst_ping_data;

 
 static int
 
 static int

-ping_client_init(sfw_test_instance_t *tsi)
+ping_client_init(struct sfw_test_instance *tsi)

 {
 {

-       sfw_session_t *sn = tsi->tsi_batch->bat_session;
+       struct sfw_session *sn = tsi->tsi_batch->bat_session;

 
        LASSERT(tsi->tsi_is_client);
        LASSERT(sn != NULL && (sn->sn_features & ~LST_FEATS_MASK) == 0);
 
        LASSERT(tsi->tsi_is_client);
        LASSERT(sn != NULL && (sn->sn_features & ~LST_FEATS_MASK) == 0);


@@ -66,9 +66,9 @@ ping_client_init(sfw_test_instance_t *tsi)
 }
 
 static void
 }
 
 static void

-ping_client_fini (sfw_test_instance_t *tsi)
+ping_client_fini(struct sfw_test_instance *tsi)

 {
 {

-        sfw_session_t *sn = tsi->tsi_batch->bat_session;
+       struct sfw_session *sn = tsi->tsi_batch->bat_session;

         int            errors;
 
         LASSERT (sn != NULL);
         int            errors;
 
         LASSERT (sn != NULL);


@@ -82,14 +82,14 @@ ping_client_fini (sfw_test_instance_t *tsi)
 }
 
 static int
 }
 
 static int

-ping_client_prep_rpc(sfw_test_unit_t *tsu,
-                    struct lnet_process_id dest, srpc_client_rpc_t **rpc)
+ping_client_prep_rpc(struct sfw_test_unit *tsu, struct lnet_process_id dest,
+                    struct srpc_client_rpc **rpc)

 {
 {

-       srpc_ping_reqst_t   *req;
-       sfw_test_instance_t *tsi = tsu->tsu_instance;
-       sfw_session_t       *sn  = tsi->tsi_batch->bat_session;
+       struct srpc_ping_reqst *req;
+       struct sfw_test_instance *tsi = tsu->tsu_instance;
+       struct sfw_session *sn = tsi->tsi_batch->bat_session;

        struct timespec64 ts;
        struct timespec64 ts;

-       int                  rc;
+       int rc;

 
        LASSERT(sn != NULL);
        LASSERT((sn->sn_features & ~LST_FEATS_MASK) == 0);
 
        LASSERT(sn != NULL);
        LASSERT((sn->sn_features & ~LST_FEATS_MASK) == 0);


@@ -114,12 +114,12 @@ ping_client_prep_rpc(sfw_test_unit_t *tsu,
 }
 
 static void
 }
 
 static void

-ping_client_done_rpc (sfw_test_unit_t *tsu, srpc_client_rpc_t *rpc)
+ping_client_done_rpc(struct sfw_test_unit *tsu, struct srpc_client_rpc *rpc)

 {
 {

-        sfw_test_instance_t *tsi = tsu->tsu_instance;
-       sfw_session_t *sn = tsi->tsi_batch->bat_session;
-       srpc_ping_reqst_t *reqst = &rpc->crpc_reqstmsg.msg_body.ping_reqst;
-       srpc_ping_reply_t *reply = &rpc->crpc_replymsg.msg_body.ping_reply;
+       struct sfw_test_instance *tsi = tsu->tsu_instance;
+       struct sfw_session *sn = tsi->tsi_batch->bat_session;
+       struct srpc_ping_reqst *reqst = &rpc->crpc_reqstmsg.msg_body.ping_reqst;
+       struct srpc_ping_reply *reply = &rpc->crpc_replymsg.msg_body.ping_reply;

        struct timespec64 ts;
 
        LASSERT(sn != NULL);
        struct timespec64 ts;
 
        LASSERT(sn != NULL);


@@ -167,11 +167,11 @@ ping_client_done_rpc (sfw_test_unit_t *tsu, srpc_client_rpc_t *rpc)
 static int
 ping_server_handle(struct srpc_server_rpc *rpc)
 {
 static int
 ping_server_handle(struct srpc_server_rpc *rpc)
 {

-       struct srpc_service     *sv  = rpc->srpc_scd->scd_svc;
-        srpc_msg_t        *reqstmsg = &rpc->srpc_reqstbuf->buf_msg;
-       srpc_msg_t        *replymsg = &rpc->srpc_replymsg;
-        srpc_ping_reqst_t *req = &reqstmsg->msg_body.ping_reqst;
-        srpc_ping_reply_t *rep = &rpc->srpc_replymsg.msg_body.ping_reply;
+       struct srpc_service *sv  = rpc->srpc_scd->scd_svc;
+       struct srpc_msg *reqstmsg = &rpc->srpc_reqstbuf->buf_msg;
+       struct srpc_msg *replymsg = &rpc->srpc_replymsg;
+       struct srpc_ping_reqst *req = &reqstmsg->msg_body.ping_reqst;
+       struct srpc_ping_reply *rep = &rpc->srpc_replymsg.msg_body.ping_reply;

 
         LASSERT (sv->sv_id == SRPC_SERVICE_PING);
 
 
         LASSERT (sv->sv_id == SRPC_SERVICE_PING);
 


@@ -207,7 +207,8 @@ ping_server_handle(struct srpc_server_rpc *rpc)
        return 0;
 }
 
        return 0;
 }
 

-sfw_test_client_ops_t ping_test_client;
+struct sfw_test_client_ops ping_test_client;
+

 void ping_init_test_client(void)
 {
         ping_test_client.tso_init     = ping_client_init;
 void ping_init_test_client(void)
 {
         ping_test_client.tso_init     = ping_client_init;


@@ -216,7 +217,8 @@ void ping_init_test_client(void)
         ping_test_client.tso_done_rpc = ping_client_done_rpc;
 }
 
         ping_test_client.tso_done_rpc = ping_client_done_rpc;
 }
 

-srpc_service_t ping_test_service;
+struct srpc_service ping_test_service;
+

 void ping_init_test_service(void)
 {
        ping_test_service.sv_id       = SRPC_SERVICE_PING;
 void ping_init_test_service(void)
 {
        ping_test_service.sv_id       = SRPC_SERVICE_PING;

diff --git a/lnet/selftest/rpc.c b/lnet/selftest/rpc.c
index f5ea3e2..8593fcb 100644 (file)
--- a/lnet/selftest/rpc.c
+++ b/lnet/selftest/rpc.c
@@ -42,21 +42,21 @@
 
 #include "selftest.h"
 
 
 #include "selftest.h"
 

-typedef enum {
+enum srpc_state {

         SRPC_STATE_NONE,
         SRPC_STATE_NI_INIT,
         SRPC_STATE_EQ_INIT,
         SRPC_STATE_RUNNING,
         SRPC_STATE_STOPPING,
         SRPC_STATE_NONE,
         SRPC_STATE_NI_INIT,
         SRPC_STATE_EQ_INIT,
         SRPC_STATE_RUNNING,
         SRPC_STATE_STOPPING,

-} srpc_state_t;
+};

 
 static struct smoketest_rpc {
        spinlock_t       rpc_glock;     /* global lock */
 
 static struct smoketest_rpc {
        spinlock_t       rpc_glock;     /* global lock */

-       srpc_service_t  *rpc_services[SRPC_SERVICE_MAX_ID + 1];
-       struct lnet_handle_eq   rpc_lnet_eq;    /* _the_ LNet event queue */
-       srpc_state_t     rpc_state;
+       struct srpc_service     *rpc_services[SRPC_SERVICE_MAX_ID + 1];
+       struct lnet_handle_eq    rpc_lnet_eq;   /* _the_ LNet event queue */
+       enum srpc_state          rpc_state;

        struct srpc_counters     rpc_counters;
        struct srpc_counters     rpc_counters;

-       __u64            rpc_matchbits; /* matchbits counter */
+       __u64                    rpc_matchbits; /* matchbits counter */

 } srpc_data;
 
 static inline int
 } srpc_data;
 
 static inline int


@@ -67,7 +67,7 @@ srpc_serv_portal(int svc_id)
 }
 
 /* forward ref's */
 }
 
 /* forward ref's */

-int srpc_handle_rpc(swi_workitem_t *wi);
+static int srpc_handle_rpc(struct swi_workitem *wi);

 
 void srpc_get_counters(struct srpc_counters *cnt)
 {
 
 void srpc_get_counters(struct srpc_counters *cnt)
 {


@@ -84,7 +84,8 @@ void srpc_set_counters(const struct srpc_counters *cnt)
 }
 
 static int
 }
 
 static int

-srpc_add_bulk_page(srpc_bulk_t *bk, struct page *pg, int i, int off, int nob)
+srpc_add_bulk_page(struct srpc_bulk *bk, struct page *pg, int i, int off,
+                  int nob)

 {
        LASSERT(off < PAGE_SIZE);
        LASSERT(nob > 0 && nob <= PAGE_SIZE);
 {
        LASSERT(off < PAGE_SIZE);
        LASSERT(nob > 0 && nob <= PAGE_SIZE);


@@ -96,7 +97,7 @@ srpc_add_bulk_page(srpc_bulk_t *bk, struct page *pg, int i, int off, int nob)
 }
 
 void
 }
 
 void

-srpc_free_bulk (srpc_bulk_t *bk)
+srpc_free_bulk(struct srpc_bulk *bk)

 {
         int         i;
        struct page *pg;
 {
         int         i;
        struct page *pg;


@@ -110,27 +111,27 @@ srpc_free_bulk (srpc_bulk_t *bk)
                __free_page(pg);
         }
 
                __free_page(pg);
         }
 

-        LIBCFS_FREE(bk, offsetof(srpc_bulk_t, bk_iovs[bk->bk_niov]));
+       LIBCFS_FREE(bk, offsetof(struct srpc_bulk, bk_iovs[bk->bk_niov]));

         return;
 }
 
         return;
 }
 

-srpc_bulk_t *
+struct srpc_bulk *

 srpc_alloc_bulk(int cpt, unsigned bulk_off, unsigned bulk_npg,
                unsigned bulk_len, int sink)
 {
 srpc_alloc_bulk(int cpt, unsigned bulk_off, unsigned bulk_npg,
                unsigned bulk_len, int sink)
 {

-       srpc_bulk_t  *bk;
+       struct srpc_bulk *bk;

        int           i;
 
        LASSERT(bulk_npg > 0 && bulk_npg <= LNET_MAX_IOV);
 
        LIBCFS_CPT_ALLOC(bk, lnet_cpt_table(), cpt,
        int           i;
 
        LASSERT(bulk_npg > 0 && bulk_npg <= LNET_MAX_IOV);
 
        LIBCFS_CPT_ALLOC(bk, lnet_cpt_table(), cpt,

-                        offsetof(srpc_bulk_t, bk_iovs[bulk_npg]));
+                        offsetof(struct srpc_bulk, bk_iovs[bulk_npg]));

        if (bk == NULL) {
                CERROR("Can't allocate descriptor for %d pages\n", bulk_npg);
                return NULL;
        }
 
        if (bk == NULL) {
                CERROR("Can't allocate descriptor for %d pages\n", bulk_npg);
                return NULL;
        }
 

-       memset(bk, 0, offsetof(srpc_bulk_t, bk_iovs[bulk_npg]));
+       memset(bk, 0, offsetof(struct srpc_bulk, bk_iovs[bulk_npg]));

        bk->bk_sink   = sink;
        bk->bk_len    = bulk_len;
        bk->bk_niov   = bulk_npg;
        bk->bk_sink   = sink;
        bk->bk_len    = bulk_len;
        bk->bk_niov   = bulk_npg;


@@ -333,7 +334,7 @@ srpc_add_service(struct srpc_service *sv)
 }
 
 int
 }
 
 int

-srpc_remove_service (srpc_service_t *sv)
+srpc_remove_service(struct srpc_service *sv)

 {
        int id = sv->sv_id;
 
 {
        int id = sv->sv_id;
 


@@ -352,7 +353,7 @@ srpc_remove_service (srpc_service_t *sv)
 static int
 srpc_post_passive_rdma(int portal, int local, __u64 matchbits, void *buf,
                       int len, int options, struct lnet_process_id peer,
 static int
 srpc_post_passive_rdma(int portal, int local, __u64 matchbits, void *buf,
                       int len, int options, struct lnet_process_id peer,

-                      struct lnet_handle_md *mdh, srpc_event_t *ev)
+                      struct lnet_handle_md *mdh, struct srpc_event *ev)

 {
        int              rc;
        struct lnet_md   md;
 {
        int              rc;
        struct lnet_md   md;


@@ -391,8 +392,9 @@ srpc_post_passive_rdma(int portal, int local, __u64 matchbits, void *buf,
 
 static int
 srpc_post_active_rdma(int portal, __u64 matchbits, void *buf, int len,
 
 static int
 srpc_post_active_rdma(int portal, __u64 matchbits, void *buf, int len,

-                     int options, struct lnet_process_id peer, lnet_nid_t self,
-                     struct lnet_handle_md *mdh, srpc_event_t *ev)
+                     int options, struct lnet_process_id peer,
+                     lnet_nid_t self, struct lnet_handle_md *mdh,
+                     struct srpc_event *ev)

 {
        int rc;
        struct lnet_md md;
 {
        int rc;
        struct lnet_md md;


@@ -443,7 +445,7 @@ srpc_post_active_rdma(int portal, __u64 matchbits, void *buf, int len,
 
 static int
 srpc_post_passive_rqtbuf(int service, int local, void *buf, int len,
 
 static int
 srpc_post_passive_rqtbuf(int service, int local, void *buf, int len,

-                        struct lnet_handle_md *mdh, srpc_event_t *ev)
+                        struct lnet_handle_md *mdh, struct srpc_event *ev)

 {
        struct lnet_process_id any = {0};
 
 {
        struct lnet_process_id any = {0};
 


@@ -688,7 +690,8 @@ srpc_finish_service(struct srpc_service *sv)
 
 /* called with sv->sv_lock held */
 static void
 
 /* called with sv->sv_lock held */
 static void

-srpc_service_recycle_buffer(struct srpc_service_cd *scd, srpc_buffer_t *buf)
+srpc_service_recycle_buffer(struct srpc_service_cd *scd,
+                           struct srpc_buffer *buf)

 __must_hold(&scd->scd_lock)
 {
        if (!scd->scd_svc->sv_shuttingdown && scd->scd_buf_adjust >= 0) {
 __must_hold(&scd->scd_lock)
 {
        if (!scd->scd_svc->sv_shuttingdown && scd->scd_buf_adjust >= 0) {


@@ -744,11 +747,11 @@ srpc_abort_service(struct srpc_service *sv)
 }
 
 void
 }
 
 void

-srpc_shutdown_service(srpc_service_t *sv)
+srpc_shutdown_service(struct srpc_service *sv)

 {
        struct srpc_service_cd  *scd;
        struct srpc_server_rpc  *rpc;
 {
        struct srpc_service_cd  *scd;
        struct srpc_server_rpc  *rpc;

-       srpc_buffer_t           *buf;
+       struct srpc_buffer *buf;

        int                     i;
 
        CDEBUG(D_NET, "Shutting down service: id %d, name %s\n",
        int                     i;
 
        CDEBUG(D_NET, "Shutting down service: id %d, name %s\n",


@@ -779,9 +782,9 @@ srpc_shutdown_service(srpc_service_t *sv)
 }
 
 static int
 }
 
 static int

-srpc_send_request (srpc_client_rpc_t *rpc)
+srpc_send_request(struct srpc_client_rpc *rpc)

 {
 {

-        srpc_event_t *ev = &rpc->crpc_reqstev;
+       struct srpc_event *ev = &rpc->crpc_reqstev;

         int           rc;
 
         ev->ev_fired = 0;
         int           rc;
 
         ev->ev_fired = 0;


@@ -790,7 +793,7 @@ srpc_send_request (srpc_client_rpc_t *rpc)
 
        rc = srpc_post_active_rdma(srpc_serv_portal(rpc->crpc_service),
                                   rpc->crpc_service, &rpc->crpc_reqstmsg,
 
        rc = srpc_post_active_rdma(srpc_serv_portal(rpc->crpc_service),
                                   rpc->crpc_service, &rpc->crpc_reqstmsg,

-                                  sizeof(srpc_msg_t), LNET_MD_OP_PUT,
+                                  sizeof(struct srpc_msg), LNET_MD_OP_PUT,

                                   rpc->crpc_dest, LNET_NID_ANY,
                                   &rpc->crpc_reqstmdh, ev);
         if (rc != 0) {
                                   rpc->crpc_dest, LNET_NID_ANY,
                                   &rpc->crpc_reqstmdh, ev);
         if (rc != 0) {


@@ -801,11 +804,11 @@ srpc_send_request (srpc_client_rpc_t *rpc)
 }
 
 static int
 }
 
 static int

-srpc_prepare_reply (srpc_client_rpc_t *rpc)
+srpc_prepare_reply(struct srpc_client_rpc *rpc)

 {
 {

-        srpc_event_t *ev = &rpc->crpc_replyev;
-        __u64        *id = &rpc->crpc_reqstmsg.msg_body.reqst.rpyid;
-        int           rc;
+       struct srpc_event *ev = &rpc->crpc_replyev;
+       u64 *id = &rpc->crpc_reqstmsg.msg_body.reqst.rpyid;
+       int rc;

 
         ev->ev_fired = 0;
         ev->ev_data  = rpc;
 
         ev->ev_fired = 0;
         ev->ev_data  = rpc;


@@ -814,7 +817,8 @@ srpc_prepare_reply (srpc_client_rpc_t *rpc)
         *id = srpc_next_id();
 
        rc = srpc_post_passive_rdma(SRPC_RDMA_PORTAL, 0, *id,
         *id = srpc_next_id();
 
        rc = srpc_post_passive_rdma(SRPC_RDMA_PORTAL, 0, *id,

-                                    &rpc->crpc_replymsg, sizeof(srpc_msg_t),
+                                   &rpc->crpc_replymsg,
+                                   sizeof(struct srpc_msg),

                                     LNET_MD_OP_PUT, rpc->crpc_dest,
                                     &rpc->crpc_replymdh, ev);
         if (rc != 0) {
                                     LNET_MD_OP_PUT, rpc->crpc_dest,
                                     &rpc->crpc_replymdh, ev);
         if (rc != 0) {


@@ -825,10 +829,10 @@ srpc_prepare_reply (srpc_client_rpc_t *rpc)
 }
 
 static int
 }
 
 static int

-srpc_prepare_bulk (srpc_client_rpc_t *rpc)
+srpc_prepare_bulk(struct srpc_client_rpc *rpc)

 {
 {

-        srpc_bulk_t  *bk = &rpc->crpc_bulk;
-        srpc_event_t *ev = &rpc->crpc_bulkev;
+       struct srpc_bulk *bk = &rpc->crpc_bulk;
+       struct srpc_event *ev = &rpc->crpc_bulkev;

         __u64        *id = &rpc->crpc_reqstmsg.msg_body.reqst.bulkid;
         int           rc;
         int           opt;
         __u64        *id = &rpc->crpc_reqstmsg.msg_body.reqst.bulkid;
         int           rc;
         int           opt;


@@ -857,10 +861,10 @@ srpc_prepare_bulk (srpc_client_rpc_t *rpc)
 }
 
 static int
 }
 
 static int

-srpc_do_bulk (srpc_server_rpc_t *rpc)
+srpc_do_bulk(struct srpc_server_rpc *rpc)

 {
 {

-        srpc_event_t  *ev = &rpc->srpc_ev;
-        srpc_bulk_t   *bk = rpc->srpc_bulk;
+       struct srpc_event *ev = &rpc->srpc_ev;
+       struct srpc_bulk *bk = rpc->srpc_bulk;

         __u64          id = rpc->srpc_reqstbuf->buf_msg.msg_body.reqst.bulkid;
         int            rc;
         int            opt;
         __u64          id = rpc->srpc_reqstbuf->buf_msg.msg_body.reqst.bulkid;
         int            rc;
         int            opt;


@@ -885,11 +889,11 @@ srpc_do_bulk (srpc_server_rpc_t *rpc)
 
 /* only called from srpc_handle_rpc */
 static void
 
 /* only called from srpc_handle_rpc */
 static void

-srpc_server_rpc_done(srpc_server_rpc_t *rpc, int status)
+srpc_server_rpc_done(struct srpc_server_rpc *rpc, int status)

 {
        struct srpc_service_cd  *scd = rpc->srpc_scd;
        struct srpc_service     *sv  = scd->scd_svc;
 {
        struct srpc_service_cd  *scd = rpc->srpc_scd;
        struct srpc_service     *sv  = scd->scd_svc;

-       srpc_buffer_t           *buffer;
+       struct srpc_buffer *buffer;

 
         LASSERT (status != 0 || rpc->srpc_wi.swi_state == SWI_STATE_DONE);
 
 
         LASSERT (status != 0 || rpc->srpc_wi.swi_state == SWI_STATE_DONE);
 


@@ -932,7 +936,7 @@ srpc_server_rpc_done(srpc_server_rpc_t *rpc, int status)
 
        if (!sv->sv_shuttingdown && !list_empty(&scd->scd_buf_blocked)) {
                buffer = list_entry(scd->scd_buf_blocked.next,
 
        if (!sv->sv_shuttingdown && !list_empty(&scd->scd_buf_blocked)) {
                buffer = list_entry(scd->scd_buf_blocked.next,

-                                       srpc_buffer_t, buf_list);
+                                       struct srpc_buffer, buf_list);

                list_del(&buffer->buf_list);
 
                srpc_init_server_rpc(rpc, scd, buffer);
                list_del(&buffer->buf_list);
 
                srpc_init_server_rpc(rpc, scd, buffer);


@@ -947,13 +951,12 @@ srpc_server_rpc_done(srpc_server_rpc_t *rpc, int status)
 }
 
 /* handles an incoming RPC */
 }
 
 /* handles an incoming RPC */

-int
-srpc_handle_rpc(swi_workitem_t *wi)
+static int srpc_handle_rpc(struct swi_workitem *wi)

 {
        struct srpc_server_rpc  *rpc = wi->swi_workitem.wi_data;
        struct srpc_service_cd  *scd = rpc->srpc_scd;
        struct srpc_service     *sv = scd->scd_svc;
 {
        struct srpc_server_rpc  *rpc = wi->swi_workitem.wi_data;
        struct srpc_service_cd  *scd = rpc->srpc_scd;
        struct srpc_service     *sv = scd->scd_svc;

-       srpc_event_t            *ev = &rpc->srpc_ev;
+       struct srpc_event *ev = &rpc->srpc_ev;

        int                     rc = 0;
 
        LASSERT(wi == &rpc->srpc_wi);
        int                     rc = 0;
 
        LASSERT(wi == &rpc->srpc_wi);


@@ -980,8 +983,8 @@ srpc_handle_rpc(swi_workitem_t *wi)
         default:
                 LBUG ();
         case SWI_STATE_NEWBORN: {
         default:
                 LBUG ();
         case SWI_STATE_NEWBORN: {

-                srpc_msg_t           *msg;
-                srpc_generic_reply_t *reply;
+               struct srpc_msg *msg;
+               struct srpc_generic_reply *reply;

 
                 msg = &rpc->srpc_reqstbuf->buf_msg;
                 reply = &rpc->srpc_replymsg.msg_body.reply;
 
                 msg = &rpc->srpc_reqstbuf->buf_msg;
                 reply = &rpc->srpc_replymsg.msg_body.reply;


@@ -1062,7 +1065,7 @@ srpc_handle_rpc(swi_workitem_t *wi)
 static void
 srpc_client_rpc_expired (void *data)
 {
 static void
 srpc_client_rpc_expired (void *data)
 {

-        srpc_client_rpc_t *rpc = data;
+       struct srpc_client_rpc *rpc = data;

 
         CWARN ("Client RPC expired: service %d, peer %s, timeout %d.\n",
                rpc->crpc_service, libcfs_id2str(rpc->crpc_dest),
 
         CWARN ("Client RPC expired: service %d, peer %s, timeout %d.\n",
                rpc->crpc_service, libcfs_id2str(rpc->crpc_dest),


@@ -1081,9 +1084,9 @@ srpc_client_rpc_expired (void *data)
 }
 
 static void
 }
 
 static void

-srpc_add_client_rpc_timer(srpc_client_rpc_t *rpc)
+srpc_add_client_rpc_timer(struct srpc_client_rpc *rpc)

 {
 {

-       stt_timer_t *timer = &rpc->crpc_timer;
+       struct stt_timer *timer = &rpc->crpc_timer;

 
        if (rpc->crpc_timeout == 0)
                return;
 
        if (rpc->crpc_timeout == 0)
                return;


@@ -1102,7 +1105,7 @@ srpc_add_client_rpc_timer(srpc_client_rpc_t *rpc)
  * Upon exit the RPC expiry timer is not queued and the handler is not
  * running on any CPU. */
 static void
  * Upon exit the RPC expiry timer is not queued and the handler is not
  * running on any CPU. */
 static void

-srpc_del_client_rpc_timer (srpc_client_rpc_t *rpc)
+srpc_del_client_rpc_timer(struct srpc_client_rpc *rpc)

 {
        /* timer not planted or already exploded */
        if (rpc->crpc_timeout == 0)
 {
        /* timer not planted or already exploded */
        if (rpc->crpc_timeout == 0)


@@ -1123,9 +1126,9 @@ srpc_del_client_rpc_timer (srpc_client_rpc_t *rpc)
 }
 
 static void
 }
 
 static void

-srpc_client_rpc_done (srpc_client_rpc_t *rpc, int status)
+srpc_client_rpc_done(struct srpc_client_rpc *rpc, int status)

 {
 {

-       swi_workitem_t *wi = &rpc->crpc_wi;
+       struct swi_workitem *wi = &rpc->crpc_wi;

 
        LASSERT(status != 0 || wi->swi_state == SWI_STATE_DONE);
 
 
        LASSERT(status != 0 || wi->swi_state == SWI_STATE_DONE);
 


@@ -1161,11 +1164,11 @@ srpc_client_rpc_done (srpc_client_rpc_t *rpc, int status)
 
 /* sends an outgoing RPC */
 int
 
 /* sends an outgoing RPC */
 int

-srpc_send_rpc (swi_workitem_t *wi)
+srpc_send_rpc(struct swi_workitem *wi)

 {
         int                rc = 0;
 {
         int                rc = 0;

-       srpc_client_rpc_t *rpc;
-       srpc_msg_t        *reply;
+       struct srpc_client_rpc *rpc;
+       struct srpc_msg *reply;

        int                do_bulk;
 
        LASSERT(wi != NULL);
        int                do_bulk;
 
        LASSERT(wi != NULL);


@@ -1218,7 +1221,9 @@ srpc_send_rpc (swi_workitem_t *wi)
                 wi->swi_state = SWI_STATE_REQUEST_SENT;
                 /* perhaps more events, fall thru */
         case SWI_STATE_REQUEST_SENT: {
                 wi->swi_state = SWI_STATE_REQUEST_SENT;
                 /* perhaps more events, fall thru */
         case SWI_STATE_REQUEST_SENT: {

-                srpc_msg_type_t type = srpc_service2reply(rpc->crpc_service);
+               enum srpc_msg_type type;
+
+               type = srpc_service2reply(rpc->crpc_service);

 
                 if (!rpc->crpc_replyev.ev_fired) break;
 
 
                 if (!rpc->crpc_replyev.ev_fired) break;
 


@@ -1286,15 +1291,15 @@ abort:
         return 0;
 }
 
         return 0;
 }
 

-srpc_client_rpc_t *
+struct srpc_client_rpc *

 srpc_create_client_rpc(struct lnet_process_id peer, int service,
                       int nbulkiov, int bulklen,
 srpc_create_client_rpc(struct lnet_process_id peer, int service,
                       int nbulkiov, int bulklen,

-                      void (*rpc_done)(srpc_client_rpc_t *),
-                      void (*rpc_fini)(srpc_client_rpc_t *), void *priv)
+                      void (*rpc_done)(struct srpc_client_rpc *),
+                      void (*rpc_fini)(struct srpc_client_rpc *), void *priv)

 {
 {

-        srpc_client_rpc_t *rpc;
+       struct srpc_client_rpc *rpc;

 
 

-        LIBCFS_ALLOC(rpc, offsetof(srpc_client_rpc_t,
+       LIBCFS_ALLOC(rpc, offsetof(struct srpc_client_rpc,

                                    crpc_bulk.bk_iovs[nbulkiov]));
         if (rpc == NULL)
                 return NULL;
                                    crpc_bulk.bk_iovs[nbulkiov]));
         if (rpc == NULL)
                 return NULL;


@@ -1306,7 +1311,7 @@ srpc_create_client_rpc(struct lnet_process_id peer, int service,
 
 /* called with rpc->crpc_lock held */
 void
 
 /* called with rpc->crpc_lock held */
 void

-srpc_abort_rpc (srpc_client_rpc_t *rpc, int why)
+srpc_abort_rpc(struct srpc_client_rpc *rpc, int why)

 {
         LASSERT (why != 0);
 
 {
         LASSERT (why != 0);
 


@@ -1327,7 +1332,7 @@ srpc_abort_rpc (srpc_client_rpc_t *rpc, int why)
 
 /* called with rpc->crpc_lock held */
 void
 
 /* called with rpc->crpc_lock held */
 void

-srpc_post_rpc (srpc_client_rpc_t *rpc)
+srpc_post_rpc(struct srpc_client_rpc *rpc)

 {
         LASSERT (!rpc->crpc_aborted);
         LASSERT (srpc_data.rpc_state == SRPC_STATE_RUNNING);
 {
         LASSERT (!rpc->crpc_aborted);
         LASSERT (srpc_data.rpc_state == SRPC_STATE_RUNNING);


@@ -1345,7 +1350,7 @@ srpc_post_rpc (srpc_client_rpc_t *rpc)
 int
 srpc_send_reply(struct srpc_server_rpc *rpc)
 {
 int
 srpc_send_reply(struct srpc_server_rpc *rpc)
 {

-       srpc_event_t            *ev = &rpc->srpc_ev;
+       struct srpc_event *ev = &rpc->srpc_ev;

        struct srpc_msg         *msg = &rpc->srpc_replymsg;
        struct srpc_buffer      *buffer = rpc->srpc_reqstbuf;
        struct srpc_service_cd  *scd = rpc->srpc_scd;
        struct srpc_msg         *msg = &rpc->srpc_replymsg;
        struct srpc_buffer      *buffer = rpc->srpc_reqstbuf;
        struct srpc_service_cd  *scd = rpc->srpc_scd;


@@ -1390,13 +1395,13 @@ static void
 srpc_lnet_ev_handler(struct lnet_event *ev)
 {
        struct srpc_service_cd  *scd;
 srpc_lnet_ev_handler(struct lnet_event *ev)
 {
        struct srpc_service_cd  *scd;

-       srpc_event_t      *rpcev = ev->md.user_ptr;
-       srpc_client_rpc_t *crpc;
-       srpc_server_rpc_t *srpc;
-       srpc_buffer_t     *buffer;
-       srpc_service_t    *sv;
-       srpc_msg_t        *msg;
-       srpc_msg_type_t    type;
+       struct srpc_event *rpcev = ev->md.user_ptr;
+       struct srpc_client_rpc *crpc;
+       struct srpc_server_rpc *srpc;
+       struct srpc_buffer *buffer;
+       struct srpc_service *sv;
+       struct srpc_msg *msg;
+       enum srpc_msg_type type;

 
        LASSERT (!in_interrupt());
 
 
        LASSERT (!in_interrupt());
 


@@ -1466,7 +1471,8 @@ srpc_lnet_ev_handler(struct lnet_event *ev)
                 LASSERT (ev->type != LNET_EVENT_UNLINK ||
                          sv->sv_shuttingdown);
 
                 LASSERT (ev->type != LNET_EVENT_UNLINK ||
                          sv->sv_shuttingdown);
 

-                buffer = container_of(ev->md.start, srpc_buffer_t, buf_msg);
+               buffer = container_of(ev->md.start, struct srpc_buffer,
+                                     buf_msg);

                buffer->buf_peer = ev->source;
                 buffer->buf_self = ev->target.nid;
 
                buffer->buf_peer = ev->source;
                 buffer->buf_self = ev->target.nid;
 


@@ -1641,7 +1647,7 @@ srpc_shutdown (void)
                spin_lock(&srpc_data.rpc_glock);
 
                 for (i = 0; i <= SRPC_SERVICE_MAX_ID; i++) {
                spin_lock(&srpc_data.rpc_glock);
 
                 for (i = 0; i <= SRPC_SERVICE_MAX_ID; i++) {

-                        srpc_service_t *sv = srpc_data.rpc_services[i];
+                       struct srpc_service *sv = srpc_data.rpc_services[i];

 
                         LASSERTF (sv == NULL,
                                   "service not empty: id %d, name %s\n",
 
                         LASSERTF (sv == NULL,
                                   "service not empty: id %d, name %s\n",

diff --git a/lnet/selftest/rpc.h b/lnet/selftest/rpc.h
index aab2629..de30dc8 100644 (file)
--- a/lnet/selftest/rpc.h
+++ b/lnet/selftest/rpc.h
@@ -37,10 +37,10 @@
 
 /*
  * LST wired structures
 
 /*
  * LST wired structures

- * 
+ *

  * XXX: *REPLY == *REQST + 1
  */
  * XXX: *REPLY == *REQST + 1
  */

-typedef enum {
+enum srpc_msg_type {

         SRPC_MSG_MKSN_REQST     = 0,
         SRPC_MSG_MKSN_REPLY     = 1,
         SRPC_MSG_RMSN_REQST     = 2,
         SRPC_MSG_MKSN_REQST     = 0,
         SRPC_MSG_MKSN_REPLY     = 1,
         SRPC_MSG_RMSN_REQST     = 2,


@@ -59,118 +59,118 @@ typedef enum {
         SRPC_MSG_PING_REPLY     = 15,
         SRPC_MSG_JOIN_REQST     = 16,
         SRPC_MSG_JOIN_REPLY     = 17,
         SRPC_MSG_PING_REPLY     = 15,
         SRPC_MSG_JOIN_REQST     = 16,
         SRPC_MSG_JOIN_REPLY     = 17,

-} srpc_msg_type_t;
+};

 
 /* CAVEAT EMPTOR:
 
 /* CAVEAT EMPTOR:

- * All srpc_*_reqst_t's 1st field must be matchbits of reply buffer,
+ * All struct srpc_*_reqst's 1st field must be matchbits of reply buffer,

  * and 2nd field matchbits of bulk buffer if any.
  *
  * and 2nd field matchbits of bulk buffer if any.
  *

- * All srpc_*_reply_t's 1st field must be a __u32 status, and 2nd field
+ * All struct srpc_*_reply's 1st field must be a __u32 status, and 2nd field

  * session id if needed.
  */
  * session id if needed.
  */

-typedef struct {
+struct srpc_generic_reqst {

         __u64                  rpyid;          /* reply buffer matchbits */
         __u64                  bulkid;         /* bulk buffer matchbits */
         __u64                  rpyid;          /* reply buffer matchbits */
         __u64                  bulkid;         /* bulk buffer matchbits */

-} WIRE_ATTR srpc_generic_reqst_t;
+} WIRE_ATTR;

 
 

-typedef struct {
+struct srpc_generic_reply {

         __u32                   status;
        struct lst_sid               sid;
         __u32                   status;
        struct lst_sid               sid;

-} WIRE_ATTR srpc_generic_reply_t;
+} WIRE_ATTR;

 
 /* FRAMEWORK RPCs */
 
 /* FRAMEWORK RPCs */

-typedef struct {
+struct srpc_mksn_reqst {

         __u64                  mksn_rpyid;      /* reply buffer matchbits */
        struct lst_sid               mksn_sid;        /* session id */
         __u32                  mksn_force;      /* use brute force */
         char                   mksn_name[LST_NAME_SIZE];
         __u64                  mksn_rpyid;      /* reply buffer matchbits */
        struct lst_sid               mksn_sid;        /* session id */
         __u32                  mksn_force;      /* use brute force */
         char                   mksn_name[LST_NAME_SIZE];

-} WIRE_ATTR srpc_mksn_reqst_t;                         /* make session request */
+} WIRE_ATTR;                                   /* make session request */

 
 

-typedef struct {
+struct srpc_mksn_reply {

         __u32                   mksn_status;      /* session status */
        struct lst_sid               mksn_sid;         /* session id */
         __u32                   mksn_timeout;     /* session timeout */
         char                   mksn_name[LST_NAME_SIZE];
         __u32                   mksn_status;      /* session status */
        struct lst_sid               mksn_sid;         /* session id */
         __u32                   mksn_timeout;     /* session timeout */
         char                   mksn_name[LST_NAME_SIZE];

-} WIRE_ATTR srpc_mksn_reply_t; /* make session reply */
+} WIRE_ATTR;                                   /* make session reply */

 
 

-typedef struct {
-        __u64                  rmsn_rpyid;      /* reply buffer matchbits */
-       struct lst_sid          rmsn_sid;        /* session id */
-} WIRE_ATTR srpc_rmsn_reqst_t; /* remove session request */
+struct srpc_rmsn_reqst {
+       __u64                   rmsn_rpyid;     /* reply buffer matchbits */
+       struct lst_sid          rmsn_sid;       /* session id */
+} WIRE_ATTR;                                   /* remove session request */

 
 

-typedef struct {
+struct srpc_rmsn_reply {

         __u32                  rmsn_status;
         __u32                  rmsn_status;

-       struct lst_sid          rmsn_sid;        /* session id */
-} WIRE_ATTR srpc_rmsn_reply_t; /* remove session reply */
+       struct lst_sid          rmsn_sid;       /* session id */
+} WIRE_ATTR;                                   /* remove session reply */

 
 

-typedef struct {
+struct srpc_join_reqst {

         __u64                  join_rpyid;     /* reply buffer matchbits */
        struct lst_sid               join_sid;       /* session id to join */
         char                    join_group[LST_NAME_SIZE]; /* group name */
         __u64                  join_rpyid;     /* reply buffer matchbits */
        struct lst_sid               join_sid;       /* session id to join */
         char                    join_group[LST_NAME_SIZE]; /* group name */

-} WIRE_ATTR srpc_join_reqst_t;
+} WIRE_ATTR;

 
 

-typedef struct {
+struct srpc_join_reply {

         __u32                   join_status;    /* returned status */
        struct lst_sid               join_sid;       /* session id */
         __u32                  join_timeout;   /* # seconds' inactivity to expire */
         char                    join_session[LST_NAME_SIZE]; /* session name */
         __u32                   join_status;    /* returned status */
        struct lst_sid               join_sid;       /* session id */
         __u32                  join_timeout;   /* # seconds' inactivity to expire */
         char                    join_session[LST_NAME_SIZE]; /* session name */

-} WIRE_ATTR srpc_join_reply_t;
+} WIRE_ATTR;

 
 

-typedef struct {
+struct srpc_debug_reqst {

         __u64                   dbg_rpyid;      /* reply buffer matchbits */ 
        struct lst_sid               dbg_sid;        /* session id */
         __u32                   dbg_flags;      /* bitmap of debug */
         __u64                   dbg_rpyid;      /* reply buffer matchbits */ 
        struct lst_sid               dbg_sid;        /* session id */
         __u32                   dbg_flags;      /* bitmap of debug */

-} WIRE_ATTR srpc_debug_reqst_t;
+} WIRE_ATTR;

 
 

-typedef struct {
+struct srpc_debug_reply {

         __u32                   dbg_status;     /* returned code */
        struct lst_sid               dbg_sid;        /* session id */
         __u32                   dbg_timeout;    /* session timeout */
         __u32                   dbg_nbatch;     /* # of batches in the node */
         char                    dbg_name[LST_NAME_SIZE]; /* session name */
         __u32                   dbg_status;     /* returned code */
        struct lst_sid               dbg_sid;        /* session id */
         __u32                   dbg_timeout;    /* session timeout */
         __u32                   dbg_nbatch;     /* # of batches in the node */
         char                    dbg_name[LST_NAME_SIZE]; /* session name */

-} WIRE_ATTR srpc_debug_reply_t;
+} WIRE_ATTR;

 
 #define SRPC_BATCH_OPC_RUN      1
 #define SRPC_BATCH_OPC_STOP     2
 #define SRPC_BATCH_OPC_QUERY    3
 
 
 #define SRPC_BATCH_OPC_RUN      1
 #define SRPC_BATCH_OPC_STOP     2
 #define SRPC_BATCH_OPC_QUERY    3
 

-typedef struct {
+struct srpc_batch_reqst {

         __u64                   bar_rpyid;      /* reply buffer matchbits */ 
        struct lst_sid               bar_sid;        /* session id */
        struct lst_bid               bar_bid;        /* batch id */
         __u32                   bar_opc;        /* create/start/stop batch */
         __u32                   bar_testidx;    /* index of test */
         __u32                   bar_arg;        /* parameters */
         __u64                   bar_rpyid;      /* reply buffer matchbits */ 
        struct lst_sid               bar_sid;        /* session id */
        struct lst_bid               bar_bid;        /* batch id */
         __u32                   bar_opc;        /* create/start/stop batch */
         __u32                   bar_testidx;    /* index of test */
         __u32                   bar_arg;        /* parameters */

-} WIRE_ATTR srpc_batch_reqst_t;
+} WIRE_ATTR;

 
 

-typedef struct {
+struct srpc_batch_reply {

         __u32                   bar_status;     /* status of request */
        struct lst_sid          bar_sid;        /* session id */
         __u32                   bar_active;     /* # of active tests in batch/test */
         __u32                   bar_time;       /* remained time */
         __u32                   bar_status;     /* status of request */
        struct lst_sid          bar_sid;        /* session id */
         __u32                   bar_active;     /* # of active tests in batch/test */
         __u32                   bar_time;       /* remained time */

-} WIRE_ATTR srpc_batch_reply_t;
+} WIRE_ATTR;

 
 

-typedef struct {
+struct srpc_stat_reqst {

         __u64                   str_rpyid;      /* reply buffer matchbits */
        struct lst_sid          str_sid;        /* session id */
         __u32                   str_type;       /* type of stat */
         __u64                   str_rpyid;      /* reply buffer matchbits */
        struct lst_sid          str_sid;        /* session id */
         __u32                   str_type;       /* type of stat */

-} WIRE_ATTR srpc_stat_reqst_t;
+} WIRE_ATTR;

 
 

-typedef struct {
+struct srpc_stat_reply {

         __u32                   str_status;
        struct lst_sid          str_sid;
        struct sfw_counters     str_fw;
        struct srpc_counters    str_rpc;
        struct lnet_counters    str_lnet;
         __u32                   str_status;
        struct lst_sid          str_sid;
        struct sfw_counters     str_fw;
        struct srpc_counters    str_rpc;
        struct lnet_counters    str_lnet;

-} WIRE_ATTR srpc_stat_reply_t;
+} WIRE_ATTR;

 
 

-typedef struct {
+struct test_bulk_req {

         __u32                   blk_opc;        /* bulk operation code */
         __u32                   blk_npg;        /* # of pages */
         __u32                   blk_flags;      /* reserved flags */
         __u32                   blk_opc;        /* bulk operation code */
         __u32                   blk_npg;        /* # of pages */
         __u32                   blk_flags;      /* reserved flags */

-} WIRE_ATTR test_bulk_req_t;
+} WIRE_ATTR;

 
 

-typedef struct {
+struct test_bulk_req_v1 {

        /** bulk operation code */
        __u16                   blk_opc;
        /** data check flags */
        /** bulk operation code */
        __u16                   blk_opc;
        /** data check flags */


@@ -179,14 +179,14 @@ typedef struct {
        __u32                   blk_len;
        /** bulk offset */
        __u32                   blk_offset;
        __u32                   blk_len;
        /** bulk offset */
        __u32                   blk_offset;

-} WIRE_ATTR test_bulk_req_v1_t;
+} WIRE_ATTR;

 
 

-typedef struct {
+struct test_ping_req {

        __u32                   png_size;       /* size of ping message */
        __u32                   png_flags;      /* reserved flags */
        __u32                   png_size;       /* size of ping message */
        __u32                   png_flags;      /* reserved flags */

-} WIRE_ATTR test_ping_req_t;
+} WIRE_ATTR;

 
 

-typedef struct {
+struct srpc_test_reqst {

        __u64                   tsr_rpyid;      /* reply buffer matchbits */
        __u64                   tsr_bulkid;     /* bulk buffer matchbits */
        struct lst_sid          tsr_sid;        /* session id */
        __u64                   tsr_rpyid;      /* reply buffer matchbits */
        __u64                   tsr_bulkid;     /* bulk buffer matchbits */
        struct lst_sid          tsr_sid;        /* session id */


@@ -200,86 +200,86 @@ typedef struct {
        __u32                   tsr_ndest;      /* # of dest nodes */
 
        union {
        __u32                   tsr_ndest;      /* # of dest nodes */
 
        union {

-               test_ping_req_t         ping;
-               test_bulk_req_t         bulk_v0;
-               test_bulk_req_v1_t      bulk_v1;
-       }               tsr_u;
-} WIRE_ATTR srpc_test_reqst_t;
+               struct test_ping_req    ping;
+               struct test_bulk_req    bulk_v0;
+               struct test_bulk_req_v1 bulk_v1;
+       } tsr_u;
+} WIRE_ATTR;

 
 

-typedef struct {
+struct srpc_test_reply {

        __u32                   tsr_status;     /* returned code */
        struct lst_sid          tsr_sid;
        __u32                   tsr_status;     /* returned code */
        struct lst_sid          tsr_sid;

-} WIRE_ATTR srpc_test_reply_t;
+} WIRE_ATTR;

 
 /* TEST RPCs */
 
 /* TEST RPCs */

-typedef struct {
+struct srpc_ping_reqst {

         __u64                   pnr_rpyid;
         __u32                   pnr_magic;
         __u32                   pnr_seq;
         __u64                   pnr_time_sec;
        __u64                   pnr_time_nsec;
         __u64                   pnr_rpyid;
         __u32                   pnr_magic;
         __u32                   pnr_seq;
         __u64                   pnr_time_sec;
        __u64                   pnr_time_nsec;

-} WIRE_ATTR srpc_ping_reqst_t;
+} WIRE_ATTR;

 
 

-typedef struct {
+struct srpc_ping_reply {

         __u32                   pnr_status;
         __u32                   pnr_magic;
         __u32                   pnr_seq;
         __u32                   pnr_status;
         __u32                   pnr_magic;
         __u32                   pnr_seq;

-} WIRE_ATTR srpc_ping_reply_t;
+} WIRE_ATTR;

 
 

-typedef struct {
+struct srpc_brw_reqst {

         __u64                   brw_rpyid;      /* reply buffer matchbits */
         __u64                   brw_bulkid;     /* bulk buffer matchbits */
         __u32                   brw_rw;         /* read or write */
         __u32                   brw_len;        /* bulk data len */
         __u32                   brw_flags;      /* bulk data patterns */
         __u64                   brw_rpyid;      /* reply buffer matchbits */
         __u64                   brw_bulkid;     /* bulk buffer matchbits */
         __u32                   brw_rw;         /* read or write */
         __u32                   brw_len;        /* bulk data len */
         __u32                   brw_flags;      /* bulk data patterns */

-} WIRE_ATTR srpc_brw_reqst_t; /* bulk r/w request */
+} WIRE_ATTR;                                   /* bulk r/w request */

 
 

-typedef struct {
+struct srpc_brw_reply {

         __u32                   brw_status;
         __u32                   brw_status;

-} WIRE_ATTR srpc_brw_reply_t; /* bulk r/w reply */
+} WIRE_ATTR; /* bulk r/w reply */

 
 #define SRPC_MSG_MAGIC                  0xeeb0f00d
 #define SRPC_MSG_VERSION                1
 
 
 #define SRPC_MSG_MAGIC                  0xeeb0f00d
 #define SRPC_MSG_VERSION                1
 

-typedef struct srpc_msg {
+struct srpc_msg {

        /** magic number */
        __u32   msg_magic;
        /** message version number */
        __u32   msg_version;
        /** magic number */
        __u32   msg_magic;
        /** message version number */
        __u32   msg_version;

-       /** type of message body: srpc_msg_type_t */
+       /** type of message body: enum srpc_msg_type */

        __u32   msg_type;
        __u32   msg_reserved0;
        __u32   msg_reserved1;
        /** test session features */
        __u32   msg_ses_feats;
         union {
        __u32   msg_type;
        __u32   msg_reserved0;
        __u32   msg_reserved1;
        /** test session features */
        __u32   msg_ses_feats;
         union {

-                srpc_generic_reqst_t reqst;
-                srpc_generic_reply_t reply;
-
-                srpc_mksn_reqst_t    mksn_reqst;
-                srpc_mksn_reply_t    mksn_reply;
-                srpc_rmsn_reqst_t    rmsn_reqst;
-                srpc_rmsn_reply_t    rmsn_reply;
-                srpc_debug_reqst_t   dbg_reqst;
-                srpc_debug_reply_t   dbg_reply;
-                srpc_batch_reqst_t   bat_reqst;
-                srpc_batch_reply_t   bat_reply;
-                srpc_stat_reqst_t    stat_reqst;
-                srpc_stat_reply_t    stat_reply;
-                srpc_test_reqst_t    tes_reqst;
-                srpc_test_reply_t    tes_reply;
-                srpc_join_reqst_t    join_reqst;
-                srpc_join_reply_t    join_reply;
-
-                srpc_ping_reqst_t    ping_reqst;
-                srpc_ping_reply_t    ping_reply;
-                srpc_brw_reqst_t     brw_reqst;
-                srpc_brw_reply_t     brw_reply;
-        }     msg_body;
-} WIRE_ATTR srpc_msg_t;
+               struct srpc_generic_reqst       reqst;
+               struct srpc_generic_reply       reply;
+
+               struct srpc_mksn_reqst          mksn_reqst;
+               struct srpc_mksn_reply          mksn_reply;
+               struct srpc_rmsn_reqst          rmsn_reqst;
+               struct srpc_rmsn_reply          rmsn_reply;
+               struct srpc_debug_reqst         dbg_reqst;
+               struct srpc_debug_reply         dbg_reply;
+               struct srpc_batch_reqst         bat_reqst;
+               struct srpc_batch_reply         bat_reply;
+               struct srpc_stat_reqst          stat_reqst;
+               struct srpc_stat_reply          stat_reply;
+               struct srpc_test_reqst          tes_reqst;
+               struct srpc_test_reply          tes_reply;
+               struct srpc_join_reqst          join_reqst;
+               struct srpc_join_reply          join_reply;
+
+               struct srpc_ping_reqst          ping_reqst;
+               struct srpc_ping_reply          ping_reply;
+               struct srpc_brw_reqst           brw_reqst;
+               struct srpc_brw_reply           brw_reply;
+       } msg_body;
+} WIRE_ATTR;

 
 static inline void
 
 static inline void

-srpc_unpack_msg_hdr(srpc_msg_t *msg)
+srpc_unpack_msg_hdr(struct srpc_msg *msg)

 {
        if (msg->msg_magic == SRPC_MSG_MAGIC)
                return; /* no flipping needed */
 {
        if (msg->msg_magic == SRPC_MSG_MAGIC)
                return; /* no flipping needed */

diff --git a/lnet/selftest/selftest.h b/lnet/selftest/selftest.h
index 44bb2f8..c6514b5 100644 (file)
--- a/lnet/selftest/selftest.h
+++ b/lnet/selftest/selftest.h
@@ -89,7 +89,7 @@ struct sfw_test_instance;
 /* all reply/bulk RDMAs go to this portal */
 #define SRPC_RDMA_PORTAL                52
 
 /* all reply/bulk RDMAs go to this portal */
 #define SRPC_RDMA_PORTAL                52
 

-static inline srpc_msg_type_t
+static inline enum srpc_msg_type

 srpc_service2request (int service)
 {
         switch (service) {
 srpc_service2request (int service)
 {
         switch (service) {


@@ -124,13 +124,13 @@ srpc_service2request (int service)
         }
 }
 
         }
 }
 

-static inline srpc_msg_type_t
+static inline enum srpc_msg_type

 srpc_service2reply (int service)
 {
         return srpc_service2request(service) + 1;
 }
 
 srpc_service2reply (int service)
 {
         return srpc_service2request(service) + 1;
 }
 

-typedef enum {
+enum srpc_event_type {

         SRPC_BULK_REQ_RCVD   = 1, /* passive bulk request(PUT sink/GET source) received */
         SRPC_BULK_PUT_SENT   = 2, /* active bulk PUT sent (source) */
         SRPC_BULK_GET_RPLD   = 3, /* active bulk GET replied (sink) */
         SRPC_BULK_REQ_RCVD   = 1, /* passive bulk request(PUT sink/GET source) received */
         SRPC_BULK_PUT_SENT   = 2, /* active bulk PUT sent (source) */
         SRPC_BULK_GET_RPLD   = 3, /* active bulk GET replied (sink) */


@@ -138,73 +138,74 @@ typedef enum {
         SRPC_REPLY_SENT      = 5, /* outgoing reply sent */
         SRPC_REQUEST_RCVD    = 6, /* incoming request received */
         SRPC_REQUEST_SENT    = 7, /* outgoing request sent */
         SRPC_REPLY_SENT      = 5, /* outgoing reply sent */
         SRPC_REQUEST_RCVD    = 6, /* incoming request received */
         SRPC_REQUEST_SENT    = 7, /* outgoing request sent */

-} srpc_event_type_t;
+};

 
 /* RPC event */
 
 /* RPC event */

-typedef struct {
-        srpc_event_type_t ev_type;   /* what's up */
-       enum lnet_event_kind ev_lnet;   /* LNet event type */
+struct srpc_event {
+       enum srpc_event_type    ev_type;   /* what's up */
+       enum lnet_event_kind    ev_lnet;   /* LNet event type */

         int               ev_fired;  /* LNet event fired? */
         int               ev_status; /* LNet event status */
         void             *ev_data;   /* owning server/client RPC */
         int               ev_fired;  /* LNet event fired? */
         int               ev_status; /* LNet event status */
         void             *ev_data;   /* owning server/client RPC */

-} srpc_event_t;
+};

 
 

-typedef struct {
+/* bulk descriptor */
+struct srpc_bulk {

         int              bk_len;  /* len of bulk data */
        struct lnet_handle_md bk_mdh;
         int              bk_sink; /* sink/source */
         int              bk_niov; /* # iov in bk_iovs */
         lnet_kiov_t      bk_iovs[0];
         int              bk_len;  /* len of bulk data */
        struct lnet_handle_md bk_mdh;
         int              bk_sink; /* sink/source */
         int              bk_niov; /* # iov in bk_iovs */
         lnet_kiov_t      bk_iovs[0];

-} srpc_bulk_t; /* bulk descriptor */
+};

 
 /* message buffer descriptor */
 
 /* message buffer descriptor */

-typedef struct srpc_buffer {
+struct srpc_buffer {

        struct list_head        buf_list; /* chain on srpc_service::*_msgq */
        struct list_head        buf_list; /* chain on srpc_service::*_msgq */

-       srpc_msg_t              buf_msg;
+       struct srpc_msg         buf_msg;

        struct lnet_handle_md   buf_mdh;
        lnet_nid_t              buf_self;
        struct lnet_process_id  buf_peer;
        struct lnet_handle_md   buf_mdh;
        lnet_nid_t              buf_self;
        struct lnet_process_id  buf_peer;

-} srpc_buffer_t;
+};

 
 struct swi_workitem;
 
 struct swi_workitem;

-typedef int (*swi_action_t) (struct swi_workitem *);
+typedef int (*swi_action_t)(struct swi_workitem *);

 
 

-typedef struct swi_workitem {
+struct swi_workitem {

        struct cfs_wi_sched     *swi_sched;
        struct cfs_wi_sched     *swi_sched;

-       struct cfs_workitem       swi_workitem;
+       struct cfs_workitem     swi_workitem;

         swi_action_t         swi_action;
         int                  swi_state;
         swi_action_t         swi_action;
         int                  swi_state;

-} swi_workitem_t;
+};

 
 /* server-side state of a RPC */
 
 /* server-side state of a RPC */

-typedef struct srpc_server_rpc {
+struct srpc_server_rpc {

        /* chain on srpc_service::*_rpcq */
        struct list_head        srpc_list;
        struct srpc_service_cd *srpc_scd;
        /* chain on srpc_service::*_rpcq */
        struct list_head        srpc_list;
        struct srpc_service_cd *srpc_scd;

-       swi_workitem_t          srpc_wi;
-       srpc_event_t            srpc_ev;        /* bulk/reply event */
+       struct swi_workitem     srpc_wi;
+       struct srpc_event       srpc_ev;        /* bulk/reply event */

        lnet_nid_t              srpc_self;
        struct lnet_process_id  srpc_peer;
        lnet_nid_t              srpc_self;
        struct lnet_process_id  srpc_peer;

-       srpc_msg_t              srpc_replymsg;
+       struct srpc_msg         srpc_replymsg;

        struct lnet_handle_md   srpc_replymdh;
        struct lnet_handle_md   srpc_replymdh;

-       srpc_buffer_t           *srpc_reqstbuf;
-       srpc_bulk_t             *srpc_bulk;
+       struct srpc_buffer     *srpc_reqstbuf;
+       struct srpc_bulk       *srpc_bulk;

 
        unsigned int    srpc_aborted; /* being given up */
        int             srpc_status;
        void            (*srpc_done)(struct srpc_server_rpc *);
 
        unsigned int    srpc_aborted; /* being given up */
        int             srpc_status;
        void            (*srpc_done)(struct srpc_server_rpc *);

-} srpc_server_rpc_t;
+};

 
 /* client-side state of a RPC */
 
 /* client-side state of a RPC */

-typedef struct srpc_client_rpc {
+struct srpc_client_rpc {

        struct list_head        crpc_list;      /* chain on user's lists */
        spinlock_t              crpc_lock;      /* serialize */
        int                     crpc_service;
        atomic_t                crpc_refcount;
        /* # seconds to wait for reply */
        int                     crpc_timeout;
        struct list_head        crpc_list;      /* chain on user's lists */
        spinlock_t              crpc_lock;      /* serialize */
        int                     crpc_service;
        atomic_t                crpc_refcount;
        /* # seconds to wait for reply */
        int                     crpc_timeout;

-       stt_timer_t             crpc_timer;
-       swi_workitem_t          crpc_wi;
+       struct stt_timer        crpc_timer;
+       struct swi_workitem     crpc_wi;

        struct lnet_process_id  crpc_dest;
 
         void               (*crpc_done)(struct srpc_client_rpc *);
        struct lnet_process_id  crpc_dest;
 
         void               (*crpc_done)(struct srpc_client_rpc *);


@@ -216,21 +217,21 @@ typedef struct srpc_client_rpc {
         unsigned int         crpc_aborted:1; /* being given up */
         unsigned int         crpc_closed:1;  /* completed */
 
         unsigned int         crpc_aborted:1; /* being given up */
         unsigned int         crpc_closed:1;  /* completed */
 

-        /* RPC events */
-        srpc_event_t         crpc_bulkev;    /* bulk event */
-        srpc_event_t         crpc_reqstev;   /* request event */
-        srpc_event_t         crpc_replyev;   /* reply event */
+       /* RPC events */
+       struct srpc_event       crpc_bulkev;    /* bulk event */
+       struct srpc_event       crpc_reqstev;   /* request event */
+       struct srpc_event       crpc_replyev;   /* reply event */

 
 

-        /* bulk, request(reqst), and reply exchanged on wire */
-        srpc_msg_t           crpc_reqstmsg;
-        srpc_msg_t           crpc_replymsg;
+       /* bulk, request(reqst), and reply exchanged on wire */
+       struct srpc_msg         crpc_reqstmsg;
+       struct srpc_msg         crpc_replymsg;

        struct lnet_handle_md   crpc_reqstmdh;
        struct lnet_handle_md   crpc_replymdh;
        struct lnet_handle_md   crpc_reqstmdh;
        struct lnet_handle_md   crpc_replymdh;

-        srpc_bulk_t          crpc_bulk;
-} srpc_client_rpc_t;
+       struct srpc_bulk        crpc_bulk;
+};

 
 #define srpc_client_rpc_size(rpc)                                       \
 
 #define srpc_client_rpc_size(rpc)                                       \

-offsetof(srpc_client_rpc_t, crpc_bulk.bk_iovs[(rpc)->crpc_bulk.bk_niov])
+offsetof(struct srpc_client_rpc, crpc_bulk.bk_iovs[(rpc)->crpc_bulk.bk_niov])

 
 #define srpc_client_rpc_addref(rpc)                                     \
 do {                                                                    \
 
 #define srpc_client_rpc_addref(rpc)                                     \
 do {                                                                    \


@@ -262,13 +263,13 @@ struct srpc_service_cd {
        /** backref to service */
        struct srpc_service     *scd_svc;
        /** event buffer */
        /** backref to service */
        struct srpc_service     *scd_svc;
        /** event buffer */

-       srpc_event_t            scd_ev;
+       struct srpc_event       scd_ev;

        /** free RPC descriptors */
        struct list_head        scd_rpc_free;
        /** in-flight RPCs */
        struct list_head        scd_rpc_active;
        /** workitem for posting buffer */
        /** free RPC descriptors */
        struct list_head        scd_rpc_free;
        /** in-flight RPCs */
        struct list_head        scd_rpc_active;
        /** workitem for posting buffer */

-       swi_workitem_t          scd_buf_wi;
+       struct swi_workitem     scd_buf_wi;

        /** CPT id */
        int                     scd_cpt;
        /** error code for scd_buf_wi */
        /** CPT id */
        int                     scd_cpt;
        /** error code for scd_buf_wi */


@@ -302,7 +303,7 @@ struct srpc_service_cd {
 #define SFW_FRWK_WI_MIN                16
 #define SFW_FRWK_WI_MAX                256
 
 #define SFW_FRWK_WI_MIN                16
 #define SFW_FRWK_WI_MAX                256
 

-typedef struct srpc_service {
+struct srpc_service {

        int                     sv_id;          /* service id */
        const char              *sv_name;       /* human readable name */
        int                     sv_wi_total;    /* total server workitems */
        int                     sv_id;          /* service id */
        const char              *sv_name;       /* human readable name */
        int                     sv_wi_total;    /* total server workitems */


@@ -314,11 +315,11 @@ typedef struct srpc_service {
          * - sv_handler: process incoming RPC request
          * - sv_bulk_ready: notify bulk data
          */
          * - sv_handler: process incoming RPC request
          * - sv_bulk_ready: notify bulk data
          */

-        int              (*sv_handler) (srpc_server_rpc_t *);
-        int              (*sv_bulk_ready) (srpc_server_rpc_t *, int);
-} srpc_service_t;
+       int              (*sv_handler)(struct srpc_server_rpc *);
+       int              (*sv_bulk_ready)(struct srpc_server_rpc *, int);
+};

 
 

-typedef struct {
+struct sfw_session {

        /* chain on fw_zombie_sessions */
        struct list_head        sn_list;
        struct lst_sid          sn_id;          /* unique identifier */
        /* chain on fw_zombie_sessions */
        struct list_head        sn_list;
        struct lst_sid          sn_id;          /* unique identifier */


@@ -326,42 +327,42 @@ typedef struct {
        unsigned int            sn_timeout;
        int                     sn_timer_active;
        unsigned int            sn_features;
        unsigned int            sn_timeout;
        int                     sn_timer_active;
        unsigned int            sn_features;

-       stt_timer_t             sn_timer;
+       struct stt_timer        sn_timer;

        struct list_head        sn_batches;     /* list of batches */
        char                    sn_name[LST_NAME_SIZE];
        atomic_t                sn_refcount;
        atomic_t                sn_brw_errors;
        atomic_t                sn_ping_errors;
        cfs_time_t              sn_started;
        struct list_head        sn_batches;     /* list of batches */
        char                    sn_name[LST_NAME_SIZE];
        atomic_t                sn_refcount;
        atomic_t                sn_brw_errors;
        atomic_t                sn_ping_errors;
        cfs_time_t              sn_started;

-} sfw_session_t;
+};

 
 #define sfw_sid_equal(sid0, sid1)     ((sid0).ses_nid == (sid1).ses_nid && \
                                        (sid0).ses_stamp == (sid1).ses_stamp)
 
 
 #define sfw_sid_equal(sid0, sid1)     ((sid0).ses_nid == (sid1).ses_nid && \
                                        (sid0).ses_stamp == (sid1).ses_stamp)
 

-typedef struct {
+struct sfw_batch {

        struct list_head        bat_list;       /* chain on sn_batches */
        struct lst_bid          bat_id;         /* batch id */
        int                     bat_error;      /* error code of batch */
        struct list_head        bat_list;       /* chain on sn_batches */
        struct lst_bid          bat_id;         /* batch id */
        int                     bat_error;      /* error code of batch */

-       sfw_session_t           *bat_session;   /* batch's session */
+       struct sfw_session      *bat_session;   /* batch's session */

        atomic_t                bat_nactive;    /* # of active tests */
        struct list_head        bat_tests;      /* test instances */
        atomic_t                bat_nactive;    /* # of active tests */
        struct list_head        bat_tests;      /* test instances */

-} sfw_batch_t;
+};

 
 

-typedef struct {
-        int  (*tso_init)(struct sfw_test_instance *tsi); /* intialize test client */
-        void (*tso_fini)(struct sfw_test_instance *tsi); /* finalize test client */
-        int  (*tso_prep_rpc)(struct sfw_test_unit *tsu,
+struct sfw_test_client_ops {
+       int  (*tso_init)(struct sfw_test_instance *tsi); /* intailize test client */
+       void (*tso_fini)(struct sfw_test_instance *tsi); /* finalize test client */
+       int  (*tso_prep_rpc)(struct sfw_test_unit *tsu,

                             struct lnet_process_id dest,
                             struct lnet_process_id dest,

-                             srpc_client_rpc_t **rpc);   /* prep a tests rpc */
+                            struct srpc_client_rpc **rpc); /* prep a tests rpc */

         void (*tso_done_rpc)(struct sfw_test_unit *tsu,
         void (*tso_done_rpc)(struct sfw_test_unit *tsu,

-                             srpc_client_rpc_t *rpc);    /* done a test rpc */
-} sfw_test_client_ops_t;
+                            struct srpc_client_rpc *rpc);  /* done a test rpc */
+};

 
 

-typedef struct sfw_test_instance {
+struct sfw_test_instance {

        struct list_head        tsi_list;       /* chain on batch */
        int                     tsi_service;    /* test type */
        struct list_head        tsi_list;       /* chain on batch */
        int                     tsi_service;    /* test type */

-       sfw_batch_t             *tsi_batch;     /* batch */
-       sfw_test_client_ops_t   *tsi_ops;       /* test client operations */
+       struct sfw_batch        *tsi_batch;     /* batch */
+       struct sfw_test_client_ops      *tsi_ops;       /* test client operations */

 
        /* public parameter for all test units */
        unsigned int            tsi_is_client:1;     /* is test client */
 
        /* public parameter for all test units */
        unsigned int            tsi_is_client:1;     /* is test client */


@@ -378,11 +379,11 @@ typedef struct sfw_test_instance {
        struct list_head        tsi_active_rpcs;/* active rpcs */
 
        union {
        struct list_head        tsi_active_rpcs;/* active rpcs */
 
        union {

-               test_ping_req_t         ping;     /* ping parameter */
-               test_bulk_req_t         bulk_v0;  /* bulk parameter */
-               test_bulk_req_v1_t      bulk_v1;  /* bulk v1 parameter */
+               struct test_ping_req    ping;     /* ping parameter */
+               struct test_bulk_req    bulk_v0;  /* bulk parameter */
+               struct test_bulk_req_v1 bulk_v1;  /* bulk v1 parameter */

        } tsi_u;
        } tsi_u;

-} sfw_test_instance_t;
+};

 
 /* XXX: trailing (PAGE_SIZE % sizeof(struct lnet_process_id)) bytes at
  * the end of pages are not used */
 
 /* XXX: trailing (PAGE_SIZE % sizeof(struct lnet_process_id)) bytes at
  * the end of pages are not used */


@@ -391,57 +392,59 @@ typedef struct sfw_test_instance {
 #define SFW_MAX_NDESTS     (LNET_MAX_IOV * SFW_ID_PER_PAGE)
 #define sfw_id_pages(n)    (((n) + SFW_ID_PER_PAGE - 1) / SFW_ID_PER_PAGE)
 
 #define SFW_MAX_NDESTS     (LNET_MAX_IOV * SFW_ID_PER_PAGE)
 #define sfw_id_pages(n)    (((n) + SFW_ID_PER_PAGE - 1) / SFW_ID_PER_PAGE)
 

-typedef struct sfw_test_unit {
+struct sfw_test_unit {

        struct list_head        tsu_list;       /* chain on lst_test_instance */
        struct lnet_process_id  tsu_dest;       /* id of dest node */
        int                     tsu_loop;       /* loop count of the test */
        struct list_head        tsu_list;       /* chain on lst_test_instance */
        struct lnet_process_id  tsu_dest;       /* id of dest node */
        int                     tsu_loop;       /* loop count of the test */

-       sfw_test_instance_t     *tsu_instance;  /* pointer to test instance */
+       struct sfw_test_instance *tsu_instance; /* pointer to test instance */

        void                    *tsu_private;   /* private data */
        void                    *tsu_private;   /* private data */

-       swi_workitem_t          tsu_worker;     /* workitem of the test unit */
-} sfw_test_unit_t;
+       struct swi_workitem      tsu_worker;    /* workitem of the test unit */
+};

 
 

-typedef struct sfw_test_case {
-       struct list_head        tsc_list;               /* chain on fw_tests */
-       srpc_service_t          *tsc_srv_service;       /* test service */
-       sfw_test_client_ops_t   *tsc_cli_ops;           /* ops of test client */
-} sfw_test_case_t;
+struct sfw_test_case {
+       struct list_head                tsc_list;               /* chain on fw_tests */
+       struct srpc_service             *tsc_srv_service;       /* test service */
+       struct sfw_test_client_ops      *tsc_cli_ops;           /* ops of test client */
+};

 
 

-srpc_client_rpc_t *
+struct srpc_client_rpc *

 sfw_create_rpc(struct lnet_process_id peer, int service,
               unsigned features, int nbulkiov, int bulklen,
 sfw_create_rpc(struct lnet_process_id peer, int service,
               unsigned features, int nbulkiov, int bulklen,

-              void (*done) (srpc_client_rpc_t *), void *priv);
-int sfw_create_test_rpc(sfw_test_unit_t *tsu,
+              void (*done)(struct srpc_client_rpc *), void *priv);
+int sfw_create_test_rpc(struct sfw_test_unit *tsu,

                        struct lnet_process_id peer, unsigned int features,
                        struct lnet_process_id peer, unsigned int features,

-                       int nblk, int blklen, srpc_client_rpc_t **rpc);
-void sfw_abort_rpc(srpc_client_rpc_t *rpc);
-void sfw_post_rpc(srpc_client_rpc_t *rpc);
-void sfw_client_rpc_done(srpc_client_rpc_t *rpc);
-void sfw_unpack_message(srpc_msg_t *msg);
-void sfw_free_pages(srpc_server_rpc_t *rpc);
-void sfw_add_bulk_page(srpc_bulk_t *bk, struct page *pg, int i);
-int sfw_alloc_pages(srpc_server_rpc_t *rpc, int cpt, int npages, int len,
+                       int nblk, int blklen, struct srpc_client_rpc **rpc);
+void sfw_abort_rpc(struct srpc_client_rpc *rpc);
+void sfw_post_rpc(struct srpc_client_rpc *rpc);
+void sfw_client_rpc_done(struct srpc_client_rpc *rpc);
+void sfw_unpack_message(struct srpc_msg *msg);
+void sfw_free_pages(struct srpc_server_rpc *rpc);
+void sfw_add_bulk_page(struct srpc_bulk *bk, struct page *pg, int i);
+int sfw_alloc_pages(struct srpc_server_rpc *rpc, int cpt, int npages, int len,

                    int sink);
                    int sink);

-int sfw_make_session (srpc_mksn_reqst_t *request, srpc_mksn_reply_t *reply);
+int sfw_make_session(struct srpc_mksn_reqst *request,
+                    struct srpc_mksn_reply *reply);

 
 

-srpc_client_rpc_t *
+struct srpc_client_rpc *

 srpc_create_client_rpc(struct lnet_process_id peer, int service,
                        int nbulkiov, int bulklen,
 srpc_create_client_rpc(struct lnet_process_id peer, int service,
                        int nbulkiov, int bulklen,

-                       void (*rpc_done)(srpc_client_rpc_t *),
-                       void (*rpc_fini)(srpc_client_rpc_t *), void *priv);
-void srpc_post_rpc(srpc_client_rpc_t *rpc);
-void srpc_abort_rpc(srpc_client_rpc_t *rpc, int why);
-void srpc_free_bulk(srpc_bulk_t *bk);
-srpc_bulk_t *srpc_alloc_bulk(int cpt, unsigned off, unsigned bulk_npg,
-                            unsigned bulk_len, int sink);
-int srpc_send_rpc(swi_workitem_t *wi);
-int srpc_send_reply(srpc_server_rpc_t *rpc);
-int srpc_add_service(srpc_service_t *sv);
-int srpc_remove_service(srpc_service_t *sv);
-void srpc_shutdown_service(srpc_service_t *sv);
-void srpc_abort_service(srpc_service_t *sv);
-int srpc_finish_service(srpc_service_t *sv);
-int srpc_service_add_buffers(srpc_service_t *sv, int nbuffer);
-void srpc_service_remove_buffers(srpc_service_t *sv, int nbuffer);
+                      void (*rpc_done)(struct srpc_client_rpc *),
+                      void (*rpc_fini)(struct srpc_client_rpc *), void *priv);
+void srpc_post_rpc(struct srpc_client_rpc *rpc);
+void srpc_abort_rpc(struct srpc_client_rpc *rpc, int why);
+void srpc_free_bulk(struct srpc_bulk *bk);
+struct srpc_bulk *srpc_alloc_bulk(int cpt, unsigned int off,
+                                 unsigned int bulk_npg, unsigned int bulk_len,
+                                 int sink);
+int srpc_send_rpc(struct swi_workitem *wi);
+int srpc_send_reply(struct srpc_server_rpc *rpc);
+int srpc_add_service(struct srpc_service *sv);
+int srpc_remove_service(struct srpc_service *sv);
+void srpc_shutdown_service(struct srpc_service *sv);
+void srpc_abort_service(struct srpc_service *sv);
+int srpc_finish_service(struct srpc_service *sv);
+int srpc_service_add_buffers(struct srpc_service *sv, int nbuffer);
+void srpc_service_remove_buffers(struct srpc_service *sv, int nbuffer);

 void srpc_get_counters(struct srpc_counters *cnt);
 void srpc_set_counters(const struct srpc_counters *cnt);
 
 void srpc_get_counters(struct srpc_counters *cnt);
 void srpc_set_counters(const struct srpc_counters *cnt);
 


@@ -457,13 +460,14 @@ srpc_serv_is_framework(struct srpc_service *svc)
 static inline int
 swi_wi_action(struct cfs_workitem *wi)
 {
 static inline int
 swi_wi_action(struct cfs_workitem *wi)
 {

-        swi_workitem_t *swi = container_of(wi, swi_workitem_t, swi_workitem);
+       struct swi_workitem *swi;

 
 

-        return swi->swi_action(swi);
+       swi = container_of(wi, struct swi_workitem, swi_workitem);
+       return swi->swi_action(swi);

 }
 
 static inline void
 }
 
 static inline void

-swi_init_workitem(swi_workitem_t *swi, void *data,
+swi_init_workitem(struct swi_workitem *swi, void *data,

                  swi_action_t action, struct cfs_wi_sched *sched)
 {
        swi->swi_sched  = sched;
                  swi_action_t action, struct cfs_wi_sched *sched)
 {
        swi->swi_sched  = sched;


@@ -473,19 +477,19 @@ swi_init_workitem(swi_workitem_t *swi, void *data,
 }
 
 static inline void
 }
 
 static inline void

-swi_schedule_workitem(swi_workitem_t *wi)
+swi_schedule_workitem(struct swi_workitem *wi)

 {
        cfs_wi_schedule(wi->swi_sched, &wi->swi_workitem);
 }
 
 static inline void
 {
        cfs_wi_schedule(wi->swi_sched, &wi->swi_workitem);
 }
 
 static inline void

-swi_exit_workitem(swi_workitem_t *swi)
+swi_exit_workitem(struct swi_workitem *swi)

 {
        cfs_wi_exit(swi->swi_sched, &swi->swi_workitem);
 }
 
 static inline int
 {
        cfs_wi_exit(swi->swi_sched, &swi->swi_workitem);
 }
 
 static inline int

-swi_deschedule_workitem(swi_workitem_t *swi)
+swi_deschedule_workitem(struct swi_workitem *swi)

 {
        return cfs_wi_deschedule(swi->swi_sched, &swi->swi_workitem);
 }
 {
        return cfs_wi_deschedule(swi->swi_sched, &swi->swi_workitem);
 }


@@ -496,7 +500,7 @@ void sfw_shutdown(void);
 void srpc_shutdown(void);
 
 static inline void
 void srpc_shutdown(void);
 
 static inline void

-srpc_destroy_client_rpc (srpc_client_rpc_t *rpc)
+srpc_destroy_client_rpc(struct srpc_client_rpc *rpc)

 {
        LASSERT (rpc != NULL);
        LASSERT (!srpc_event_pending(rpc));
 {
        LASSERT (rpc != NULL);
        LASSERT (!srpc_event_pending(rpc));


@@ -512,14 +516,14 @@ srpc_destroy_client_rpc (srpc_client_rpc_t *rpc)
 }
 
 static inline void
 }
 
 static inline void

-srpc_init_client_rpc(srpc_client_rpc_t *rpc, struct lnet_process_id peer,
+srpc_init_client_rpc(struct srpc_client_rpc *rpc, struct lnet_process_id peer,

                     int service, int nbulkiov, int bulklen,
                     int service, int nbulkiov, int bulklen,

-                    void (*rpc_done)(srpc_client_rpc_t *),
-                    void (*rpc_fini)(srpc_client_rpc_t *), void *priv)
+                    void (*rpc_done)(struct srpc_client_rpc *),
+                    void (*rpc_fini)(struct srpc_client_rpc *), void *priv)

 {
        LASSERT(nbulkiov <= LNET_MAX_IOV);
 
 {
        LASSERT(nbulkiov <= LNET_MAX_IOV);
 

-       memset(rpc, 0, offsetof(srpc_client_rpc_t,
+       memset(rpc, 0, offsetof(struct srpc_client_rpc,

                                crpc_bulk.bk_iovs[nbulkiov]));
 
        INIT_LIST_HEAD(&rpc->crpc_list);
                                crpc_bulk.bk_iovs[nbulkiov]));
 
        INIT_LIST_HEAD(&rpc->crpc_list);


@@ -585,7 +589,7 @@ do {                                                                        \
 } while (0)
 
 static inline void
 } while (0)
 
 static inline void

-srpc_wait_service_shutdown(srpc_service_t *sv)
+srpc_wait_service_shutdown(struct srpc_service *sv)

 {
        int i = 2;
 
 {
        int i = 2;
 


@@ -601,13 +605,13 @@ srpc_wait_service_shutdown(srpc_service_t *sv)
        }
 }
 
        }
 }
 

-extern sfw_test_client_ops_t ping_test_client;
-extern srpc_service_t        ping_test_service;
+extern struct sfw_test_client_ops ping_test_client;
+extern struct srpc_service ping_test_service;

 void ping_init_test_client(void);
 void ping_init_test_service(void);
 
 void ping_init_test_client(void);
 void ping_init_test_service(void);
 

-extern sfw_test_client_ops_t brw_test_client;
-extern srpc_service_t        brw_test_service;
+extern struct sfw_test_client_ops brw_test_client;
+extern struct srpc_service brw_test_service;

 void brw_init_test_client(void);
 void brw_init_test_service(void);
 
 void brw_init_test_client(void);
 void brw_init_test_service(void);
 

diff --git a/lnet/selftest/timer.c b/lnet/selftest/timer.c
index ff016e9..f4e70bd 100644 (file)
--- a/lnet/selftest/timer.c
+++ b/lnet/selftest/timer.c
@@ -64,7 +64,7 @@ static struct st_timer_data {
 } stt_data;
 
 void
 } stt_data;
 
 void

-stt_add_timer(stt_timer_t *timer)
+stt_add_timer(struct stt_timer *timer)

 {
        struct list_head *pos;
 
 {
        struct list_head *pos;
 


@@ -78,7 +78,8 @@ stt_add_timer(stt_timer_t *timer)
 
        /* a simple insertion sort */
        list_for_each_prev(pos, STTIMER_SLOT(timer->stt_expires)) {
 
        /* a simple insertion sort */
        list_for_each_prev(pos, STTIMER_SLOT(timer->stt_expires)) {

-               stt_timer_t *old = list_entry(pos, stt_timer_t, stt_list);
+               struct stt_timer *old = list_entry(pos, struct stt_timer,
+                                                  stt_list);

 
                if (timer->stt_expires >= old->stt_expires)
                        break;
 
                if (timer->stt_expires >= old->stt_expires)
                        break;


@@ -98,7 +99,7 @@ stt_add_timer(stt_timer_t *timer)
  * another CPU.
  */
 int
  * another CPU.
  */
 int

-stt_del_timer(stt_timer_t *timer)
+stt_del_timer(struct stt_timer *timer)

 {
        int ret = 0;
 
 {
        int ret = 0;
 


@@ -121,10 +122,10 @@ static int
 stt_expire_list(struct list_head *slot, time64_t now)
 {
        int          expired = 0;
 stt_expire_list(struct list_head *slot, time64_t now)
 {
        int          expired = 0;

-       stt_timer_t *timer;
+       struct stt_timer *timer;

 
        while (!list_empty(slot)) {
 
        while (!list_empty(slot)) {

-               timer = list_entry(slot->next, stt_timer_t, stt_list);
+               timer = list_entry(slot->next, struct stt_timer, stt_list);

 
                if (timer->stt_expires > now)
                        break;
 
                if (timer->stt_expires > now)
                        break;

diff --git a/lnet/selftest/timer.h b/lnet/selftest/timer.h
index 476eee7..e769c4c 100644 (file)
--- a/lnet/selftest/timer.h
+++ b/lnet/selftest/timer.h
@@ -34,15 +34,15 @@
 #ifndef __SELFTEST_TIMER_H__
 #define __SELFTEST_TIMER_H__
 
 #ifndef __SELFTEST_TIMER_H__
 #define __SELFTEST_TIMER_H__
 

-typedef struct {
+struct stt_timer {

        struct list_head        stt_list;
        time64_t                stt_expires;
        void                    (*stt_func)(void *);
        void                    *stt_data;
        struct list_head        stt_list;
        time64_t                stt_expires;
        void                    (*stt_func)(void *);
        void                    *stt_data;

-} stt_timer_t;
+};

 
 

-void stt_add_timer(stt_timer_t *timer);
-int stt_del_timer(stt_timer_t *timer);
+void stt_add_timer(struct stt_timer *timer);
+int stt_del_timer(struct stt_timer *timer);

 int stt_startup(void);
 void stt_shutdown(void);
 
 int stt_startup(void);
 void stt_shutdown(void);