__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);
- strncpy(&sn->sn_name[0], name, LST_NAME_SIZE);
+ 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;
sn->sn_id = sid;
{
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++;
}
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;
if (request->mksn_sid.ses_nid == LNET_NID_ANY) {
reply->mksn_sid = (sn == NULL) ? LST_INVALID_SID : sn->sn_id;
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;
}
if (!request->mksn_force) {
reply->mksn_status = EBUSY;
- strncpy(&reply->mksn_name[0], &sn->sn_name[0], LST_NAME_SIZE);
+ cplen = strlcpy(&reply->mksn_name[0], &sn->sn_name[0],
+ sizeof(reply->mksn_name));
+ if (cplen >= sizeof(reply->mksn_name))
+ return -E2BIG;
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;
}
reply->dbg_status = 0;
reply->dbg_sid = sn->sn_id;
reply->dbg_timeout = sn->sn_timeout;
- strncpy(reply->dbg_name, &sn->sn_name[0], LST_NAME_SIZE);
+ if (strlcpy(reply->dbg_name, &sn->sn_name[0], sizeof(reply->dbg_name))
+ >= sizeof(reply->dbg_name))
+ return -E2BIG;
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);
int j;
#ifdef __KERNEL__
- dests = cfs_page_address(bk->bk_iovs[i / SFW_ID_PER_PAGE].kiov_page);
- LASSERT (dests != NULL); /* my pages are within KVM always */
+ dests = page_address(bk->bk_iovs[i / SFW_ID_PER_PAGE].kiov_page);
+ LASSERT (dests != NULL); /* my pages are within KVM always */
#else
- dests = cfs_page_address(bk->bk_pages[i / SFW_ID_PER_PAGE]);
+ dests = page_address(bk->bk_pages[i / SFW_ID_PER_PAGE]);
#endif
id = dests[i % SFW_ID_PER_PAGE];
if (msg->msg_magic != SRPC_MSG_MAGIC)
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;
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;
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;
}
int len;
if ((sn->sn_features & LST_FEAT_BULK_LEN) == 0) {
- len = npg * CFS_PAGE_SIZE;
+ len = npg * PAGE_CACHE_SIZE;
} else {
len = sizeof(lnet_process_id_packed_t) *
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);