__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 */
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);
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;
{
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
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);
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++;
}
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;
}
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;
}
}
LIBCFS_FREE(sn, sizeof(*sn));
- cfs_atomic_dec(&sfw_data.fw_nzombies);
+ atomic_dec(&sfw_data.fw_nzombies);
return;
}
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);
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 */
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;
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;
}
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,
return -EINVAL;
if (testidx == 0) {
- reply->bar_active = cfs_atomic_read(&tsb->bat_nactive);
+ reply->bar_active = atomic_read(&tsb->bat_nactive);
return 0;
}
if (testidx-- > 1)
continue;
- reply->bar_active = cfs_atomic_read(&tsi->tsi_nactive);
+ reply->bar_active = atomic_read(&tsi->tsi_nactive);
return 0;
}
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);
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);
"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);