selftest.h revision a649ad1d7b44d2b5da62eec804539bb221396570
1/* 2 * GPL HEADER START 3 * 4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License version 2 only, 8 * as published by the Free Software Foundation. 9 * 10 * This program is distributed in the hope that it will be useful, but 11 * WITHOUT ANY WARRANTY; without even the implied warranty of 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 13 * General Public License version 2 for more details (a copy is included 14 * in the LICENSE file that accompanied this code). 15 * 16 * You should have received a copy of the GNU General Public License 17 * version 2 along with this program; If not, see 18 * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf 19 * copy of GPLv2]. 20 * 21 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, 22 * CA 95054 USA or visit www.sun.com if you need additional information or 23 * have any questions. 24 * 25 * GPL HEADER END 26 */ 27/* 28 * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved. 29 * Use is subject to license terms. 30 * 31 * Copyright (c) 2012, Intel Corporation. 32 */ 33/* 34 * This file is part of Lustre, http://www.lustre.org/ 35 * Lustre is a trademark of Sun Microsystems, Inc. 36 * 37 * lnet/selftest/selftest.h 38 * 39 * Author: Isaac Huang <isaac@clusterfs.com> 40 */ 41#ifndef __SELFTEST_SELFTEST_H__ 42#define __SELFTEST_SELFTEST_H__ 43 44#define LNET_ONLY 45 46#include "../../include/linux/libcfs/libcfs.h" 47#include "../../include/linux/lnet/lnet.h" 48#include "../../include/linux/lnet/lib-lnet.h" 49#include "../../include/linux/lnet/lib-types.h" 50#include "../../include/linux/lnet/lnetst.h" 51 52#include "rpc.h" 53#include "timer.h" 54 55#ifndef MADE_WITHOUT_COMPROMISE 56#define MADE_WITHOUT_COMPROMISE 57#endif 58 59 60#define SWI_STATE_NEWBORN 0 61#define SWI_STATE_REPLY_SUBMITTED 1 62#define SWI_STATE_REPLY_SENT 2 63#define SWI_STATE_REQUEST_SUBMITTED 3 64#define SWI_STATE_REQUEST_SENT 4 65#define SWI_STATE_REPLY_RECEIVED 5 66#define SWI_STATE_BULK_STARTED 6 67#define SWI_STATE_DONE 10 68 69/* forward refs */ 70struct srpc_service; 71struct srpc_service_cd; 72struct sfw_test_unit; 73struct sfw_test_instance; 74 75/* services below SRPC_FRAMEWORK_SERVICE_MAX_ID are framework 76 * services, e.g. create/modify session. 77 */ 78#define SRPC_SERVICE_DEBUG 0 79#define SRPC_SERVICE_MAKE_SESSION 1 80#define SRPC_SERVICE_REMOVE_SESSION 2 81#define SRPC_SERVICE_BATCH 3 82#define SRPC_SERVICE_TEST 4 83#define SRPC_SERVICE_QUERY_STAT 5 84#define SRPC_SERVICE_JOIN 6 85#define SRPC_FRAMEWORK_SERVICE_MAX_ID 10 86/* other services start from SRPC_FRAMEWORK_SERVICE_MAX_ID+1 */ 87#define SRPC_SERVICE_BRW 11 88#define SRPC_SERVICE_PING 12 89#define SRPC_SERVICE_MAX_ID 12 90 91#define SRPC_REQUEST_PORTAL 50 92/* a lazy portal for framework RPC requests */ 93#define SRPC_FRAMEWORK_REQUEST_PORTAL 51 94/* all reply/bulk RDMAs go to this portal */ 95#define SRPC_RDMA_PORTAL 52 96 97static inline srpc_msg_type_t 98srpc_service2request (int service) 99{ 100 switch (service) { 101 default: 102 LBUG (); 103 case SRPC_SERVICE_DEBUG: 104 return SRPC_MSG_DEBUG_REQST; 105 106 case SRPC_SERVICE_MAKE_SESSION: 107 return SRPC_MSG_MKSN_REQST; 108 109 case SRPC_SERVICE_REMOVE_SESSION: 110 return SRPC_MSG_RMSN_REQST; 111 112 case SRPC_SERVICE_BATCH: 113 return SRPC_MSG_BATCH_REQST; 114 115 case SRPC_SERVICE_TEST: 116 return SRPC_MSG_TEST_REQST; 117 118 case SRPC_SERVICE_QUERY_STAT: 119 return SRPC_MSG_STAT_REQST; 120 121 case SRPC_SERVICE_BRW: 122 return SRPC_MSG_BRW_REQST; 123 124 case SRPC_SERVICE_PING: 125 return SRPC_MSG_PING_REQST; 126 127 case SRPC_SERVICE_JOIN: 128 return SRPC_MSG_JOIN_REQST; 129 } 130} 131 132static inline srpc_msg_type_t 133srpc_service2reply (int service) 134{ 135 return srpc_service2request(service) + 1; 136} 137 138typedef enum { 139 SRPC_BULK_REQ_RCVD = 1, /* passive bulk request(PUT sink/GET source) received */ 140 SRPC_BULK_PUT_SENT = 2, /* active bulk PUT sent (source) */ 141 SRPC_BULK_GET_RPLD = 3, /* active bulk GET replied (sink) */ 142 SRPC_REPLY_RCVD = 4, /* incoming reply received */ 143 SRPC_REPLY_SENT = 5, /* outgoing reply sent */ 144 SRPC_REQUEST_RCVD = 6, /* incoming request received */ 145 SRPC_REQUEST_SENT = 7, /* outgoing request sent */ 146} srpc_event_type_t; 147 148/* RPC event */ 149typedef struct { 150 srpc_event_type_t ev_type; /* what's up */ 151 lnet_event_kind_t ev_lnet; /* LNet event type */ 152 int ev_fired; /* LNet event fired? */ 153 int ev_status; /* LNet event status */ 154 void *ev_data; /* owning server/client RPC */ 155} srpc_event_t; 156 157typedef struct { 158 int bk_len; /* len of bulk data */ 159 lnet_handle_md_t bk_mdh; 160 int bk_sink; /* sink/source */ 161 int bk_niov; /* # iov in bk_iovs */ 162 lnet_kiov_t bk_iovs[0]; 163} srpc_bulk_t; /* bulk descriptor */ 164 165/* message buffer descriptor */ 166typedef struct srpc_buffer { 167 struct list_head buf_list; /* chain on srpc_service::*_msgq */ 168 srpc_msg_t buf_msg; 169 lnet_handle_md_t buf_mdh; 170 lnet_nid_t buf_self; 171 lnet_process_id_t buf_peer; 172} srpc_buffer_t; 173 174struct swi_workitem; 175typedef int (*swi_action_t) (struct swi_workitem *); 176 177typedef struct swi_workitem { 178 struct cfs_wi_sched *swi_sched; 179 cfs_workitem_t swi_workitem; 180 swi_action_t swi_action; 181 int swi_state; 182} swi_workitem_t; 183 184/* server-side state of a RPC */ 185typedef struct srpc_server_rpc { 186 /* chain on srpc_service::*_rpcq */ 187 struct list_head srpc_list; 188 struct srpc_service_cd *srpc_scd; 189 swi_workitem_t srpc_wi; 190 srpc_event_t srpc_ev; /* bulk/reply event */ 191 lnet_nid_t srpc_self; 192 lnet_process_id_t srpc_peer; 193 srpc_msg_t srpc_replymsg; 194 lnet_handle_md_t srpc_replymdh; 195 srpc_buffer_t *srpc_reqstbuf; 196 srpc_bulk_t *srpc_bulk; 197 198 unsigned int srpc_aborted; /* being given up */ 199 int srpc_status; 200 void (*srpc_done)(struct srpc_server_rpc *); 201} srpc_server_rpc_t; 202 203/* client-side state of a RPC */ 204typedef struct srpc_client_rpc { 205 struct list_head crpc_list; /* chain on user's lists */ 206 spinlock_t crpc_lock; /* serialize */ 207 int crpc_service; 208 atomic_t crpc_refcount; 209 int crpc_timeout; /* # seconds to wait for reply */ 210 stt_timer_t crpc_timer; 211 swi_workitem_t crpc_wi; 212 lnet_process_id_t crpc_dest; 213 214 void (*crpc_done)(struct srpc_client_rpc *); 215 void (*crpc_fini)(struct srpc_client_rpc *); 216 int crpc_status; /* completion status */ 217 void *crpc_priv; /* caller data */ 218 219 /* state flags */ 220 unsigned int crpc_aborted:1; /* being given up */ 221 unsigned int crpc_closed:1; /* completed */ 222 223 /* RPC events */ 224 srpc_event_t crpc_bulkev; /* bulk event */ 225 srpc_event_t crpc_reqstev; /* request event */ 226 srpc_event_t crpc_replyev; /* reply event */ 227 228 /* bulk, request(reqst), and reply exchanged on wire */ 229 srpc_msg_t crpc_reqstmsg; 230 srpc_msg_t crpc_replymsg; 231 lnet_handle_md_t crpc_reqstmdh; 232 lnet_handle_md_t crpc_replymdh; 233 srpc_bulk_t crpc_bulk; 234} srpc_client_rpc_t; 235 236#define srpc_client_rpc_size(rpc) \ 237offsetof(srpc_client_rpc_t, crpc_bulk.bk_iovs[(rpc)->crpc_bulk.bk_niov]) 238 239#define srpc_client_rpc_addref(rpc) \ 240do { \ 241 CDEBUG(D_NET, "RPC[%p] -> %s (%d)++\n", \ 242 (rpc), libcfs_id2str((rpc)->crpc_dest), \ 243 atomic_read(&(rpc)->crpc_refcount)); \ 244 LASSERT(atomic_read(&(rpc)->crpc_refcount) > 0); \ 245 atomic_inc(&(rpc)->crpc_refcount); \ 246} while (0) 247 248#define srpc_client_rpc_decref(rpc) \ 249do { \ 250 CDEBUG(D_NET, "RPC[%p] -> %s (%d)--\n", \ 251 (rpc), libcfs_id2str((rpc)->crpc_dest), \ 252 atomic_read(&(rpc)->crpc_refcount)); \ 253 LASSERT(atomic_read(&(rpc)->crpc_refcount) > 0); \ 254 if (atomic_dec_and_test(&(rpc)->crpc_refcount)) \ 255 srpc_destroy_client_rpc(rpc); \ 256} while (0) 257 258#define srpc_event_pending(rpc) ((rpc)->crpc_bulkev.ev_fired == 0 || \ 259 (rpc)->crpc_reqstev.ev_fired == 0 || \ 260 (rpc)->crpc_replyev.ev_fired == 0) 261 262/* CPU partition data of srpc service */ 263struct srpc_service_cd { 264 /** serialize */ 265 spinlock_t scd_lock; 266 /** backref to service */ 267 struct srpc_service *scd_svc; 268 /** event buffer */ 269 srpc_event_t scd_ev; 270 /** free RPC descriptors */ 271 struct list_head scd_rpc_free; 272 /** in-flight RPCs */ 273 struct list_head scd_rpc_active; 274 /** workitem for posting buffer */ 275 swi_workitem_t scd_buf_wi; 276 /** CPT id */ 277 int scd_cpt; 278 /** error code for scd_buf_wi */ 279 int scd_buf_err; 280 /** timestamp for scd_buf_err */ 281 unsigned long scd_buf_err_stamp; 282 /** total # request buffers */ 283 int scd_buf_total; 284 /** # posted request buffers */ 285 int scd_buf_nposted; 286 /** in progress of buffer posting */ 287 int scd_buf_posting; 288 /** allocate more buffers if scd_buf_nposted < scd_buf_low */ 289 int scd_buf_low; 290 /** increase/decrease some buffers */ 291 int scd_buf_adjust; 292 /** posted message buffers */ 293 struct list_head scd_buf_posted; 294 /** blocked for RPC descriptor */ 295 struct list_head scd_buf_blocked; 296}; 297 298/* number of server workitems (mini-thread) for testing service */ 299#define SFW_TEST_WI_MIN 256 300#define SFW_TEST_WI_MAX 2048 301/* extra buffers for tolerating buggy peers, or unbalanced number 302 * of peers between partitions */ 303#define SFW_TEST_WI_EXTRA 64 304 305/* number of server workitems (mini-thread) for framework service */ 306#define SFW_FRWK_WI_MIN 16 307#define SFW_FRWK_WI_MAX 256 308 309typedef struct srpc_service { 310 int sv_id; /* service id */ 311 const char *sv_name; /* human readable name */ 312 int sv_wi_total; /* total server workitems */ 313 int sv_shuttingdown; 314 int sv_ncpts; 315 /* percpt data for srpc_service */ 316 struct srpc_service_cd **sv_cpt_data; 317 /* Service callbacks: 318 * - sv_handler: process incoming RPC request 319 * - sv_bulk_ready: notify bulk data 320 */ 321 int (*sv_handler) (srpc_server_rpc_t *); 322 int (*sv_bulk_ready) (srpc_server_rpc_t *, int); 323} srpc_service_t; 324 325typedef struct { 326 struct list_head sn_list; /* chain on fw_zombie_sessions */ 327 lst_sid_t sn_id; /* unique identifier */ 328 unsigned int sn_timeout; /* # seconds' inactivity to expire */ 329 int sn_timer_active; 330 unsigned int sn_features; 331 stt_timer_t sn_timer; 332 struct list_head sn_batches; /* list of batches */ 333 char sn_name[LST_NAME_SIZE]; 334 atomic_t sn_refcount; 335 atomic_t sn_brw_errors; 336 atomic_t sn_ping_errors; 337 unsigned long sn_started; 338} sfw_session_t; 339 340#define sfw_sid_equal(sid0, sid1) ((sid0).ses_nid == (sid1).ses_nid && \ 341 (sid0).ses_stamp == (sid1).ses_stamp) 342 343typedef struct { 344 struct list_head bat_list; /* chain on sn_batches */ 345 lst_bid_t bat_id; /* batch id */ 346 int bat_error; /* error code of batch */ 347 sfw_session_t *bat_session; /* batch's session */ 348 atomic_t bat_nactive; /* # of active tests */ 349 struct list_head bat_tests; /* test instances */ 350} sfw_batch_t; 351 352typedef struct { 353 int (*tso_init)(struct sfw_test_instance *tsi); /* initialize test client */ 354 void (*tso_fini)(struct sfw_test_instance *tsi); /* finalize test client */ 355 int (*tso_prep_rpc)(struct sfw_test_unit *tsu, 356 lnet_process_id_t dest, 357 srpc_client_rpc_t **rpc); /* prep a tests rpc */ 358 void (*tso_done_rpc)(struct sfw_test_unit *tsu, 359 srpc_client_rpc_t *rpc); /* done a test rpc */ 360} sfw_test_client_ops_t; 361 362typedef struct sfw_test_instance { 363 struct list_head tsi_list; /* chain on batch */ 364 int tsi_service; /* test type */ 365 sfw_batch_t *tsi_batch; /* batch */ 366 sfw_test_client_ops_t *tsi_ops; /* test client operations */ 367 368 /* public parameter for all test units */ 369 unsigned int tsi_is_client:1; /* is test client */ 370 unsigned int tsi_stoptsu_onerr:1; /* stop tsu on error */ 371 int tsi_concur; /* concurrency */ 372 int tsi_loop; /* loop count */ 373 374 /* status of test instance */ 375 spinlock_t tsi_lock; /* serialize */ 376 unsigned int tsi_stopping:1; /* test is stopping */ 377 atomic_t tsi_nactive; /* # of active test unit */ 378 struct list_head tsi_units; /* test units */ 379 struct list_head tsi_free_rpcs; /* free rpcs */ 380 struct list_head tsi_active_rpcs; /* active rpcs */ 381 382 union { 383 test_ping_req_t ping; /* ping parameter */ 384 test_bulk_req_t bulk_v0; /* bulk parameter */ 385 test_bulk_req_v1_t bulk_v1; /* bulk v1 parameter */ 386 } tsi_u; 387} sfw_test_instance_t; 388 389/* XXX: trailing (PAGE_CACHE_SIZE % sizeof(lnet_process_id_t)) bytes at 390 * the end of pages are not used */ 391#define SFW_MAX_CONCUR LST_MAX_CONCUR 392#define SFW_ID_PER_PAGE (PAGE_CACHE_SIZE / sizeof(lnet_process_id_packed_t)) 393#define SFW_MAX_NDESTS (LNET_MAX_IOV * SFW_ID_PER_PAGE) 394#define sfw_id_pages(n) (((n) + SFW_ID_PER_PAGE - 1) / SFW_ID_PER_PAGE) 395 396typedef struct sfw_test_unit { 397 struct list_head tsu_list; /* chain on lst_test_instance */ 398 lnet_process_id_t tsu_dest; /* id of dest node */ 399 int tsu_loop; /* loop count of the test */ 400 sfw_test_instance_t *tsu_instance; /* pointer to test instance */ 401 void *tsu_private; /* private data */ 402 swi_workitem_t tsu_worker; /* workitem of the test unit */ 403} sfw_test_unit_t; 404 405typedef struct sfw_test_case { 406 struct list_head tsc_list; /* chain on fw_tests */ 407 srpc_service_t *tsc_srv_service; /* test service */ 408 sfw_test_client_ops_t *tsc_cli_ops; /* ops of test client */ 409} sfw_test_case_t; 410 411srpc_client_rpc_t * 412sfw_create_rpc(lnet_process_id_t peer, int service, 413 unsigned features, int nbulkiov, int bulklen, 414 void (*done) (srpc_client_rpc_t *), void *priv); 415int sfw_create_test_rpc(sfw_test_unit_t *tsu, 416 lnet_process_id_t peer, unsigned features, 417 int nblk, int blklen, srpc_client_rpc_t **rpc); 418void sfw_abort_rpc(srpc_client_rpc_t *rpc); 419void sfw_post_rpc(srpc_client_rpc_t *rpc); 420void sfw_client_rpc_done(srpc_client_rpc_t *rpc); 421void sfw_unpack_message(srpc_msg_t *msg); 422void sfw_free_pages(srpc_server_rpc_t *rpc); 423void sfw_add_bulk_page(srpc_bulk_t *bk, struct page *pg, int i); 424int sfw_alloc_pages(srpc_server_rpc_t *rpc, int cpt, int npages, int len, 425 int sink); 426int sfw_make_session (srpc_mksn_reqst_t *request, srpc_mksn_reply_t *reply); 427 428srpc_client_rpc_t * 429srpc_create_client_rpc(lnet_process_id_t peer, int service, 430 int nbulkiov, int bulklen, 431 void (*rpc_done)(srpc_client_rpc_t *), 432 void (*rpc_fini)(srpc_client_rpc_t *), void *priv); 433void srpc_post_rpc(srpc_client_rpc_t *rpc); 434void srpc_abort_rpc(srpc_client_rpc_t *rpc, int why); 435void srpc_free_bulk(srpc_bulk_t *bk); 436srpc_bulk_t *srpc_alloc_bulk(int cpt, unsigned bulk_npg, unsigned bulk_len, 437 int sink); 438int srpc_send_rpc(swi_workitem_t *wi); 439int srpc_send_reply(srpc_server_rpc_t *rpc); 440int srpc_add_service(srpc_service_t *sv); 441int srpc_remove_service(srpc_service_t *sv); 442void srpc_shutdown_service(srpc_service_t *sv); 443void srpc_abort_service(srpc_service_t *sv); 444int srpc_finish_service(srpc_service_t *sv); 445int srpc_service_add_buffers(srpc_service_t *sv, int nbuffer); 446void srpc_service_remove_buffers(srpc_service_t *sv, int nbuffer); 447void srpc_get_counters(srpc_counters_t *cnt); 448void srpc_set_counters(const srpc_counters_t *cnt); 449 450extern struct cfs_wi_sched *lst_sched_serial; 451extern struct cfs_wi_sched **lst_sched_test; 452 453static inline int 454srpc_serv_is_framework(struct srpc_service *svc) 455{ 456 return svc->sv_id < SRPC_FRAMEWORK_SERVICE_MAX_ID; 457} 458 459static inline int 460swi_wi_action(cfs_workitem_t *wi) 461{ 462 swi_workitem_t *swi = container_of(wi, swi_workitem_t, swi_workitem); 463 464 return swi->swi_action(swi); 465} 466 467static inline void 468swi_init_workitem(swi_workitem_t *swi, void *data, 469 swi_action_t action, struct cfs_wi_sched *sched) 470{ 471 swi->swi_sched = sched; 472 swi->swi_action = action; 473 swi->swi_state = SWI_STATE_NEWBORN; 474 cfs_wi_init(&swi->swi_workitem, data, swi_wi_action); 475} 476 477static inline void 478swi_schedule_workitem(swi_workitem_t *wi) 479{ 480 cfs_wi_schedule(wi->swi_sched, &wi->swi_workitem); 481} 482 483static inline void 484swi_exit_workitem(swi_workitem_t *swi) 485{ 486 cfs_wi_exit(swi->swi_sched, &swi->swi_workitem); 487} 488 489static inline int 490swi_deschedule_workitem(swi_workitem_t *swi) 491{ 492 return cfs_wi_deschedule(swi->swi_sched, &swi->swi_workitem); 493} 494 495 496int sfw_startup(void); 497int srpc_startup(void); 498void sfw_shutdown(void); 499void srpc_shutdown(void); 500 501static inline void 502srpc_destroy_client_rpc (srpc_client_rpc_t *rpc) 503{ 504 LASSERT (rpc != NULL); 505 LASSERT (!srpc_event_pending(rpc)); 506 LASSERT (atomic_read(&rpc->crpc_refcount) == 0); 507 508 if (rpc->crpc_fini == NULL) { 509 LIBCFS_FREE(rpc, srpc_client_rpc_size(rpc)); 510 } else { 511 (*rpc->crpc_fini) (rpc); 512 } 513 514 return; 515} 516 517static inline void 518srpc_init_client_rpc (srpc_client_rpc_t *rpc, lnet_process_id_t peer, 519 int service, int nbulkiov, int bulklen, 520 void (*rpc_done)(srpc_client_rpc_t *), 521 void (*rpc_fini)(srpc_client_rpc_t *), void *priv) 522{ 523 LASSERT (nbulkiov <= LNET_MAX_IOV); 524 525 memset(rpc, 0, offsetof(srpc_client_rpc_t, 526 crpc_bulk.bk_iovs[nbulkiov])); 527 528 INIT_LIST_HEAD(&rpc->crpc_list); 529 swi_init_workitem(&rpc->crpc_wi, rpc, srpc_send_rpc, 530 lst_sched_test[lnet_cpt_of_nid(peer.nid)]); 531 spin_lock_init(&rpc->crpc_lock); 532 atomic_set(&rpc->crpc_refcount, 1); /* 1 ref for caller */ 533 534 rpc->crpc_dest = peer; 535 rpc->crpc_priv = priv; 536 rpc->crpc_service = service; 537 rpc->crpc_bulk.bk_len = bulklen; 538 rpc->crpc_bulk.bk_niov = nbulkiov; 539 rpc->crpc_done = rpc_done; 540 rpc->crpc_fini = rpc_fini; 541 LNetInvalidateHandle(&rpc->crpc_reqstmdh); 542 LNetInvalidateHandle(&rpc->crpc_replymdh); 543 LNetInvalidateHandle(&rpc->crpc_bulk.bk_mdh); 544 545 /* no event is expected at this point */ 546 rpc->crpc_bulkev.ev_fired = 547 rpc->crpc_reqstev.ev_fired = 548 rpc->crpc_replyev.ev_fired = 1; 549 550 rpc->crpc_reqstmsg.msg_magic = SRPC_MSG_MAGIC; 551 rpc->crpc_reqstmsg.msg_version = SRPC_MSG_VERSION; 552 rpc->crpc_reqstmsg.msg_type = srpc_service2request(service); 553 return; 554} 555 556static inline const char * 557swi_state2str (int state) 558{ 559#define STATE2STR(x) case x: return #x 560 switch(state) { 561 default: 562 LBUG(); 563 STATE2STR(SWI_STATE_NEWBORN); 564 STATE2STR(SWI_STATE_REPLY_SUBMITTED); 565 STATE2STR(SWI_STATE_REPLY_SENT); 566 STATE2STR(SWI_STATE_REQUEST_SUBMITTED); 567 STATE2STR(SWI_STATE_REQUEST_SENT); 568 STATE2STR(SWI_STATE_REPLY_RECEIVED); 569 STATE2STR(SWI_STATE_BULK_STARTED); 570 STATE2STR(SWI_STATE_DONE); 571 } 572#undef STATE2STR 573} 574 575#define selftest_wait_events() \ 576 do { \ 577 set_current_state(TASK_UNINTERRUPTIBLE); \ 578 schedule_timeout(cfs_time_seconds(1) / 10); \ 579 } while (0) 580 581 582#define lst_wait_until(cond, lock, fmt, ...) \ 583do { \ 584 int __I = 2; \ 585 while (!(cond)) { \ 586 CDEBUG(IS_PO2(++__I) ? D_WARNING : D_NET, \ 587 fmt, ## __VA_ARGS__); \ 588 spin_unlock(&(lock)); \ 589 \ 590 selftest_wait_events(); \ 591 \ 592 spin_lock(&(lock)); \ 593 } \ 594} while (0) 595 596static inline void 597srpc_wait_service_shutdown(srpc_service_t *sv) 598{ 599 int i = 2; 600 601 LASSERT(sv->sv_shuttingdown); 602 603 while (srpc_finish_service(sv) == 0) { 604 i++; 605 CDEBUG (((i & -i) == i) ? D_WARNING : D_NET, 606 "Waiting for %s service to shutdown...\n", 607 sv->sv_name); 608 selftest_wait_events(); 609 } 610} 611 612#endif /* __SELFTEST_SELFTEST_H__ */ 613