LU-3373 tests: small fixes for sanity tests

[fs/lustre-release.git] / lnet / selftest / framework.c

diff --git a/lnet/selftest/framework.c b/lnet/selftest/framework.c
index 305659e..6959a5b 100644 (file)
--- a/lnet/selftest/framework.c
+++ b/lnet/selftest/framework.c
@@ -100,14 +100,14 @@ do {                                    \
         __swab64s(&(lc).route_length);  \
 } while (0)
 
-#define sfw_test_active(t)      (cfs_atomic_read(&(t)->tsi_nactive) != 0)
-#define sfw_batch_active(b)     (cfs_atomic_read(&(b)->bat_nactive) != 0)
+#define sfw_test_active(t)      (atomic_read(&(t)->tsi_nactive) != 0)
+#define sfw_batch_active(b)     (atomic_read(&(b)->bat_nactive) != 0)
 
 struct smoketest_framework {
-        cfs_list_t         fw_zombie_rpcs;     /* RPCs to be recycled */
-        cfs_list_t         fw_zombie_sessions; /* stopping sessions */
-        cfs_list_t         fw_tests;           /* registered test cases */
-        cfs_atomic_t       fw_nzombies;        /* # zombie sessions */
+       cfs_list_t         fw_zombie_rpcs;     /* RPCs to be recycled */
+       cfs_list_t         fw_zombie_sessions; /* stopping sessions */
+       cfs_list_t         fw_tests;           /* registered test cases */
+       atomic_t       fw_nzombies;        /* # zombie sessions */
        spinlock_t         fw_lock;             /* serialise */
        sfw_session_t     *fw_session;          /* _the_ session */
        int                fw_shuttingdown;     /* shutdown in progress */
@@ -214,7 +214,7 @@ sfw_deactivate_session (void)
         LASSERT (!sn->sn_timer_active);
 
         sfw_data.fw_session = NULL;
-        cfs_atomic_inc(&sfw_data.fw_nzombies);
+       atomic_inc(&sfw_data.fw_nzombies);
         cfs_list_add(&sn->sn_list, &sfw_data.fw_zombie_sessions);
 
        spin_unlock(&sfw_data.fw_lock);
@@ -284,9 +284,9 @@ sfw_init_session(sfw_session_t *sn, lst_sid_t sid,
         memset(sn, 0, sizeof(sfw_session_t));
         CFS_INIT_LIST_HEAD(&sn->sn_list);
         CFS_INIT_LIST_HEAD(&sn->sn_batches);
-        cfs_atomic_set(&sn->sn_refcount, 1);        /* +1 for caller */
-        cfs_atomic_set(&sn->sn_brw_errors, 0);
-        cfs_atomic_set(&sn->sn_ping_errors, 0);
+       atomic_set(&sn->sn_refcount, 1);        /* +1 for caller */
+       atomic_set(&sn->sn_brw_errors, 0);
+       atomic_set(&sn->sn_ping_errors, 0);
        strlcpy(&sn->sn_name[0], name, sizeof(sn->sn_name));
 
         sn->sn_timer_active = 0;
@@ -324,7 +324,7 @@ sfw_client_rpc_fini (srpc_client_rpc_t *rpc)
 {
         LASSERT (rpc->crpc_bulk.bk_niov == 0);
         LASSERT (cfs_list_empty(&rpc->crpc_list));
-        LASSERT (cfs_atomic_read(&rpc->crpc_refcount) == 0);
+       LASSERT (atomic_read(&rpc->crpc_refcount) == 0);
 #ifndef __KERNEL__
         LASSERT (rpc->crpc_bulk.bk_pages == NULL);
 #endif
@@ -381,7 +381,7 @@ sfw_bid2batch (lst_bid_t bid)
         bat->bat_error    = 0;
         bat->bat_session  = sn;
         bat->bat_id       = bid;
-        cfs_atomic_set(&bat->bat_nactive, 0);
+       atomic_set(&bat->bat_nactive, 0);
         CFS_INIT_LIST_HEAD(&bat->bat_tests);
 
         cfs_list_add_tail(&bat->bat_list, &sn->sn_batches);
@@ -417,14 +417,14 @@ sfw_get_stats (srpc_stat_reqst_t *request, srpc_stat_reply_t *reply)
                                        sn->sn_started), &tv);
 
         cnt->running_ms      = (__u32)(tv.tv_sec * 1000 + tv.tv_usec / 1000);
-        cnt->brw_errors      = cfs_atomic_read(&sn->sn_brw_errors);
-        cnt->ping_errors     = cfs_atomic_read(&sn->sn_ping_errors);
-        cnt->zombie_sessions = cfs_atomic_read(&sfw_data.fw_nzombies);
+       cnt->brw_errors      = atomic_read(&sn->sn_brw_errors);
+       cnt->ping_errors     = atomic_read(&sn->sn_ping_errors);
+       cnt->zombie_sessions = atomic_read(&sfw_data.fw_nzombies);
 
         cnt->active_batches = 0;
         cfs_list_for_each_entry_typed (bat, &sn->sn_batches,
                                        sfw_batch_t, bat_list) {
-                if (cfs_atomic_read(&bat->bat_nactive) > 0)
+               if (atomic_read(&bat->bat_nactive) > 0)
                         cnt->active_batches++;
         }
 
@@ -452,7 +452,7 @@ sfw_make_session(srpc_mksn_reqst_t *request, srpc_mksn_reply_t *reply)
                 reply->mksn_timeout = sn->sn_timeout;
 
                 if (sfw_sid_equal(request->mksn_sid, sn->sn_id)) {
-                        cfs_atomic_inc(&sn->sn_refcount);
+                       atomic_inc(&sn->sn_refcount);
                         return 0;
                 }
 
@@ -518,7 +518,7 @@ sfw_remove_session (srpc_rmsn_reqst_t *request, srpc_rmsn_reply_t *reply)
                 return 0;
         }
 
-        if (!cfs_atomic_dec_and_test(&sn->sn_refcount)) {
+       if (!atomic_dec_and_test(&sn->sn_refcount)) {
                 reply->rmsn_status = 0;
                 return 0;
         }
@@ -700,7 +700,7 @@ sfw_destroy_session (sfw_session_t *sn)
         }
 
         LIBCFS_FREE(sn, sizeof(*sn));
-        cfs_atomic_dec(&sfw_data.fw_nzombies);
+       atomic_dec(&sfw_data.fw_nzombies);
         return;
 }
 
@@ -770,7 +770,7 @@ sfw_add_test_instance (sfw_batch_t *tsb, srpc_server_rpc_t *rpc)
 
         memset(tsi, 0, sizeof(*tsi));
        spin_lock_init(&tsi->tsi_lock);
-        cfs_atomic_set(&tsi->tsi_nactive, 0);
+       atomic_set(&tsi->tsi_nactive, 0);
         CFS_INIT_LIST_HEAD(&tsi->tsi_units);
         CFS_INIT_LIST_HEAD(&tsi->tsi_free_rpcs);
         CFS_INIT_LIST_HEAD(&tsi->tsi_active_rpcs);
@@ -861,7 +861,7 @@ sfw_test_unit_done (sfw_test_unit_t *tsu)
 
         LASSERT (sfw_test_active(tsi));
 
-        if (!cfs_atomic_dec_and_test(&tsi->tsi_nactive))
+       if (!atomic_dec_and_test(&tsi->tsi_nactive))
                 return;
 
         /* the test instance is done */
@@ -873,7 +873,7 @@ sfw_test_unit_done (sfw_test_unit_t *tsu)
 
        spin_lock(&sfw_data.fw_lock);
 
-       if (!cfs_atomic_dec_and_test(&tsb->bat_nactive) ||/* tsb still active */
+       if (!atomic_dec_and_test(&tsb->bat_nactive) ||/* tsb still active */
            sn == sfw_data.fw_session) {                  /* sn also active */
                spin_unlock(&sfw_data.fw_lock);
                 return;
@@ -1005,9 +1005,8 @@ sfw_run_test (swi_workitem_t *wi)
        cfs_list_add_tail(&rpc->crpc_list, &tsi->tsi_active_rpcs);
        spin_unlock(&tsi->tsi_lock);
 
-       rpc->crpc_timeout = rpc_timeout;
-
        spin_lock(&rpc->crpc_lock);
+       rpc->crpc_timeout = rpc_timeout;
        srpc_post_rpc(rpc);
        spin_unlock(&rpc->crpc_lock);
        return 0;
@@ -1034,7 +1033,7 @@ sfw_run_batch (sfw_batch_t *tsb)
 
         if (sfw_batch_active(tsb)) {
                 CDEBUG(D_NET, "Batch already active: "LPU64" (%d)\n",
-                       tsb->bat_id.bat_id, cfs_atomic_read(&tsb->bat_nactive));
+                      tsb->bat_id.bat_id, atomic_read(&tsb->bat_nactive));
                 return 0;
         }
 
@@ -1046,11 +1045,11 @@ sfw_run_batch (sfw_batch_t *tsb)
                 LASSERT (!tsi->tsi_stopping);
                 LASSERT (!sfw_test_active(tsi));
 
-                cfs_atomic_inc(&tsb->bat_nactive);
+               atomic_inc(&tsb->bat_nactive);
 
                 cfs_list_for_each_entry_typed (tsu, &tsi->tsi_units,
                                                sfw_test_unit_t, tsu_list) {
-                        cfs_atomic_inc(&tsi->tsi_nactive);
+                       atomic_inc(&tsi->tsi_nactive);
                         tsu->tsu_loop = tsi->tsi_loop;
                         wi = &tsu->tsu_worker;
                        swi_init_workitem(wi, tsu, sfw_run_test,
@@ -1116,7 +1115,7 @@ sfw_query_batch (sfw_batch_t *tsb, int testidx, srpc_batch_reply_t *reply)
                 return -EINVAL;
 
         if (testidx == 0) {
-                reply->bar_active = cfs_atomic_read(&tsb->bat_nactive);
+               reply->bar_active = atomic_read(&tsb->bat_nactive);
                 return 0;
         }
 
@@ -1125,7 +1124,7 @@ sfw_query_batch (sfw_batch_t *tsb, int testidx, srpc_batch_reply_t *reply)
                 if (testidx-- > 1)
                         continue;
 
-                reply->bar_active = cfs_atomic_read(&tsi->tsi_nactive);
+               reply->bar_active = atomic_read(&tsi->tsi_nactive);
                 return 0;
         }
 
@@ -1612,7 +1611,7 @@ sfw_unpack_message (srpc_msg_t *msg)
 void
 sfw_abort_rpc (srpc_client_rpc_t *rpc)
 {
-       LASSERT(cfs_atomic_read(&rpc->crpc_refcount) > 0);
+       LASSERT(atomic_read(&rpc->crpc_refcount) > 0);
        LASSERT(rpc->crpc_service <= SRPC_FRAMEWORK_SERVICE_MAX_ID);
 
        spin_lock(&rpc->crpc_lock);
@@ -1732,7 +1731,7 @@ sfw_startup (void)
         sfw_data.fw_session     = NULL;
         sfw_data.fw_active_srpc = NULL;
        spin_lock_init(&sfw_data.fw_lock);
-        cfs_atomic_set(&sfw_data.fw_nzombies, 0);
+       atomic_set(&sfw_data.fw_nzombies, 0);
         CFS_INIT_LIST_HEAD(&sfw_data.fw_tests);
         CFS_INIT_LIST_HEAD(&sfw_data.fw_zombie_rpcs);
         CFS_INIT_LIST_HEAD(&sfw_data.fw_zombie_sessions);
@@ -1818,10 +1817,10 @@ sfw_shutdown (void)
                                "waiting for session timer to explode.\n");
 
         sfw_deactivate_session();
-        lst_wait_until(cfs_atomic_read(&sfw_data.fw_nzombies) == 0,
+       lst_wait_until(atomic_read(&sfw_data.fw_nzombies) == 0,
                        sfw_data.fw_lock,
                        "waiting for %d zombie sessions to die.\n",
-                       cfs_atomic_read(&sfw_data.fw_nzombies));
+                      atomic_read(&sfw_data.fw_nzombies));
 
        spin_unlock(&sfw_data.fw_lock);