*
* You should have received a copy of the GNU General Public License
* version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
*
* GPL HEADER END
*/
* Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
* Use is subject to license terms.
*
- * Copyright (c) 2012, Intel Corporation.
+ * Copyright (c) 2012, 2016, Intel Corporation.
*/
/*
* This file is part of Lustre, http://www.lustre.org/
#include "selftest.h"
-lst_sid_t LST_INVALID_SID = {LNET_NID_ANY, -1};
+struct lst_sid LST_INVALID_SID = {LNET_NID_ANY, -1};
static int session_timeout = 100;
-CFS_MODULE_PARM(session_timeout, "i", int, 0444,
- "test session timeout in seconds (100 by default, 0 == never)");
+module_param(session_timeout, int, 0444);
+MODULE_PARM_DESC(session_timeout, "test session timeout in seconds (100 by default, 0 == never)");
static int rpc_timeout = 64;
-CFS_MODULE_PARM(rpc_timeout, "i", int, 0644,
- "rpc timeout in seconds (64 by default, 0 == never)");
+module_param(rpc_timeout, int, 0644);
+MODULE_PARM_DESC(rpc_timeout, "rpc timeout in seconds (64 by default, 0 == never)");
#define sfw_unpack_id(id) \
do { \
#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 {
+static struct smoketest_framework {
/* RPCs to be recycled */
struct list_head fw_zombie_rpcs;
/* stopping sessions */
if (tsc == NULL)
return -ENOMEM;
- memset(tsc, 0, sizeof(sfw_test_case_t));
tsc->tsc_cli_ops = cliops;
tsc->tsc_srv_service = service;
return 0;
}
-void
+static void
sfw_add_session_timer (void)
{
sfw_session_t *sn = sfw_data.fw_session;
LASSERT (!sn->sn_timer_active);
sn->sn_timer_active = 1;
- timer->stt_expires = cfs_time_add(sn->sn_timeout,
- cfs_time_current_sec());
+ timer->stt_expires = ktime_get_real_seconds()+ sn->sn_timeout;
stt_add_timer(timer);
return;
}
-int
+static int
sfw_del_session_timer (void)
{
sfw_session_t *sn = sfw_data.fw_session;
return 0;
}
-#ifndef __KERNEL__
- /* Racing is impossible in single-threaded userland selftest */
- LBUG();
-#endif
return EBUSY; /* racing with sfw_session_expired() */
}
/* called with sfw_data.fw_lock held */
static void
sfw_deactivate_session (void)
+__must_hold(&sfw_data.fw_lock)
{
sfw_session_t *sn = sfw_data.fw_session;
int nactive = 0;
spin_lock(&sfw_data.fw_lock);
}
-#ifndef __KERNEL__
-int
-sfw_session_removed (void)
-{
- return (sfw_data.fw_session == NULL) ? 1 : 0;
-}
-
-#endif
-
-void
+static void
sfw_session_expired (void *data)
{
sfw_session_t *sn = data;
LASSERT (sn->sn_timer_active);
LASSERT (sn == sfw_data.fw_session);
- CWARN ("Session expired! sid: %s-"LPU64", name: %s\n",
+ CWARN ("Session expired! sid: %s-%llu, name: %s\n",
libcfs_nid2str(sn->sn_id.ses_nid),
sn->sn_id.ses_stamp, &sn->sn_name[0]);
}
static inline void
-sfw_init_session(sfw_session_t *sn, lst_sid_t sid,
+sfw_init_session(sfw_session_t *sn, struct lst_sid sid,
unsigned features, const char *name)
{
stt_timer_t *timer = &sn->sn_timer;
}
/* completion handler for incoming framework RPCs */
-void
+static void
sfw_server_rpc_done(struct srpc_server_rpc *rpc)
{
struct srpc_service *sv = rpc->srpc_scd->scd_svc;
return;
}
-void
+static void
sfw_client_rpc_fini (srpc_client_rpc_t *rpc)
{
LASSERT(rpc->crpc_bulk.bk_niov == 0);
LASSERT(list_empty(&rpc->crpc_list));
LASSERT(atomic_read(&rpc->crpc_refcount) == 0);
-#ifndef __KERNEL__
- LASSERT(rpc->crpc_bulk.bk_pages == NULL);
-#endif
CDEBUG(D_NET, "Outgoing framework RPC done: "
"service %d, peer %s, status %s:%d:%d\n",
spin_unlock(&sfw_data.fw_lock);
}
-sfw_batch_t *
-sfw_find_batch (lst_bid_t bid)
+static sfw_batch_t *
+sfw_find_batch(struct lst_bid bid)
{
sfw_session_t *sn = sfw_data.fw_session;
sfw_batch_t *bat;
return NULL;
}
-sfw_batch_t *
-sfw_bid2batch (lst_bid_t bid)
+static sfw_batch_t *
+sfw_bid2batch(struct lst_bid bid)
{
sfw_session_t *sn = sfw_data.fw_session;
sfw_batch_t *bat;
return bat;
LIBCFS_ALLOC(bat, sizeof(sfw_batch_t));
- if (bat == NULL)
+ if (bat == NULL)
return NULL;
bat->bat_error = 0;
return bat;
}
-int
+static int
sfw_get_stats (srpc_stat_reqst_t *request, srpc_stat_reply_t *reply)
{
sfw_session_t *sn = sfw_data.fw_session;
- sfw_counters_t *cnt = &reply->str_fw;
+ struct sfw_counters *cnt = &reply->str_fw;
sfw_batch_t *bat;
struct timeval tv;
return 0;
}
-int
+static int
sfw_remove_session (srpc_rmsn_reqst_t *request, srpc_rmsn_reply_t *reply)
{
sfw_session_t *sn = sfw_data.fw_session;
return 0;
}
-int
+static int
sfw_debug_session (srpc_debug_reqst_t *request, srpc_debug_reply_t *reply)
{
sfw_session_t *sn = sfw_data.fw_session;
reply->dbg_status = ESRCH;
reply->dbg_sid = LST_INVALID_SID;
return 0;
- }
+ }
reply->dbg_status = 0;
reply->dbg_sid = sn->sn_id;
return 0;
}
-void
+static void
sfw_test_rpc_fini (srpc_client_rpc_t *rpc)
{
sfw_test_unit_t *tsu = rpc->crpc_priv;
return max(SFW_TEST_WI_MIN, nbuf + SFW_TEST_WI_EXTRA);
}
-int
+static int
sfw_load_test(struct sfw_test_instance *tsi)
{
struct sfw_test_case *tsc;
return 0;
}
-void
+static void
sfw_unload_test(struct sfw_test_instance *tsi)
{
struct sfw_test_case *tsc;
return;
}
-void
+static void
sfw_destroy_test_instance (sfw_test_instance_t *tsi)
{
srpc_client_rpc_t *rpc;
return;
}
-void
+static void
sfw_destroy_batch (sfw_batch_t *tsb)
{
sfw_test_instance_t *tsi;
return;
}
-void
+static void
sfw_unpack_addtest_req(srpc_msg_t *msg)
{
srpc_test_reqst_t *req = &msg->msg_body.tes_reqst;
return;
}
-int
+static int
sfw_add_test_instance (sfw_batch_t *tsb, srpc_server_rpc_t *rpc)
{
srpc_msg_t *msg = &rpc->srpc_reqstbuf->buf_msg;
LIBCFS_ALLOC(tsi, sizeof(*tsi));
if (tsi == NULL) {
- CERROR ("Can't allocate test instance for batch: "LPU64"\n",
+ CERROR ("Can't allocate test instance for batch: %llu\n",
tsb->bat_id.bat_id);
return -ENOMEM;
}
- memset(tsi, 0, sizeof(*tsi));
spin_lock_init(&tsi->tsi_lock);
atomic_set(&tsi->tsi_nactive, 0);
INIT_LIST_HEAD(&tsi->tsi_units);
}
LASSERT (bk != NULL);
-#ifndef __KERNEL__
- LASSERT (bk->bk_pages != NULL);
-#endif
LASSERT (bk->bk_niov * SFW_ID_PER_PAGE >= (unsigned int)ndest);
LASSERT((unsigned int)bk->bk_len >=
sizeof(lnet_process_id_packed_t) * ndest);
lnet_process_id_packed_t id;
int j;
-#ifdef __KERNEL__
dests = page_address(bk->bk_iovs[i / SFW_ID_PER_PAGE].kiov_page);
LASSERT (dests != NULL); /* my pages are within KVM always */
-#else
- 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)
sfw_unpack_id(id);
return;
}
-void
+static void
sfw_test_rpc_done (srpc_client_rpc_t *rpc)
{
sfw_test_unit_t *tsu = rpc->crpc_priv;
return 0;
}
-int
+static int
sfw_run_test (swi_workitem_t *wi)
{
sfw_test_unit_t *tsu = wi->swi_workitem.wi_data;
return 1;
}
-int
+static int
sfw_run_batch (sfw_batch_t *tsb)
{
swi_workitem_t *wi;
sfw_test_instance_t *tsi;
if (sfw_batch_active(tsb)) {
- CDEBUG(D_NET, "Batch already active: "LPU64" (%d)\n",
+ CDEBUG(D_NET, "Batch already active: %llu (%d)\n",
tsb->bat_id.bat_id, atomic_read(&tsb->bat_nactive));
return 0;
}
srpc_client_rpc_t *rpc;
if (!sfw_batch_active(tsb)) {
- CDEBUG(D_NET, "Batch "LPU64" inactive\n", tsb->bat_id.bat_id);
+ CDEBUG(D_NET, "Batch %llu inactive\n", tsb->bat_id.bat_id);
return 0;
}
return 0;
}
-int
+static int
sfw_query_batch (sfw_batch_t *tsb, int testidx, srpc_batch_reply_t *reply)
{
sfw_test_instance_t *tsi;
LASSERT(rpc->srpc_bulk == NULL);
LASSERT(npages > 0 && npages <= LNET_MAX_IOV);
- rpc->srpc_bulk = srpc_alloc_bulk(cpt, npages, len, sink);
+ rpc->srpc_bulk = srpc_alloc_bulk(cpt, 0, npages, len, sink);
if (rpc->srpc_bulk == NULL)
return -ENOMEM;
return 0;
}
-int
+static int
sfw_add_test (srpc_server_rpc_t *rpc)
{
sfw_session_t *sn = sfw_data.fw_session;
int len;
if ((sn->sn_features & LST_FEAT_BULK_LEN) == 0) {
- len = npg * PAGE_CACHE_SIZE;
+ len = npg * PAGE_SIZE;
} else {
len = sizeof(lnet_process_id_packed_t) *
return 0;
}
-int
+static int
sfw_control_batch (srpc_batch_reqst_t *request, srpc_batch_reply_t *reply)
{
sfw_session_t *sn = sfw_data.fw_session;
return 0;
}
-int
+static int
sfw_handle_server_rpc(struct srpc_server_rpc *rpc)
{
struct srpc_service *sv = rpc->srpc_scd->scd_svc;
rpc->srpc_done = sfw_server_rpc_done;
spin_lock(&sfw_data.fw_lock);
-#ifdef __KERNEL__
if (!sfw_data.fw_shuttingdown)
sfw_add_session_timer();
-#else
- LASSERT(!sfw_data.fw_shuttingdown);
- sfw_add_session_timer();
-#endif
sfw_data.fw_active_srpc = NULL;
spin_unlock(&sfw_data.fw_lock);
return rc;
}
-int
+static int
sfw_bulk_ready(struct srpc_server_rpc *rpc, int status)
{
struct srpc_service *sv = rpc->srpc_scd->scd_svc;
spin_lock(&sfw_data.fw_lock);
-#ifdef __KERNEL__
if (!sfw_data.fw_shuttingdown)
sfw_add_session_timer();
-#else
- LASSERT(!sfw_data.fw_shuttingdown);
- sfw_add_session_timer();
-#endif
sfw_data.fw_active_srpc = NULL;
spin_unlock(&sfw_data.fw_lock);
return;
}
-static srpc_service_t sfw_services[] =
+static srpc_service_t sfw_services[] =
{
{
/* sv_id */ SRPC_SERVICE_DEBUG,
}
};
-extern sfw_test_client_ops_t ping_test_client;
-extern srpc_service_t ping_test_service;
-extern void ping_init_test_client(void);
-extern void ping_init_test_service(void);
-
-extern sfw_test_client_ops_t brw_test_client;
-extern srpc_service_t brw_test_service;
-extern void brw_init_test_client(void);
-extern void brw_init_test_service(void);
-
-
int
sfw_startup (void)
{
srpc_service_t *sv;
sfw_test_case_t *tsc;
-#ifndef __KERNEL__
- char *s;
-
- s = getenv("SESSION_TIMEOUT");
- session_timeout = s != NULL ? atoi(s) : session_timeout;
-
- s = getenv("RPC_TIMEOUT");
- rpc_timeout = s != NULL ? atoi(s) : rpc_timeout;
-#endif
if (session_timeout < 0) {
CERROR ("Session timeout must be non-negative: %d\n",
spin_lock(&sfw_data.fw_lock);
sfw_data.fw_shuttingdown = 1;
-#ifdef __KERNEL__
lst_wait_until(sfw_data.fw_active_srpc == NULL, sfw_data.fw_lock,
"waiting for active RPC to finish.\n");
-#else
- LASSERT (sfw_data.fw_active_srpc == NULL);
-#endif
if (sfw_del_session_timer() != 0)
lst_wait_until(sfw_data.fw_session == NULL, sfw_data.fw_lock,