1 /* 2 * BSD LICENSE 3 * 4 * Copyright (c) 2018-2019 Broadcom. All Rights Reserved. 5 * The term "Broadcom" refers to Broadcom Inc. and/or its subsidiaries. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 11 * * Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * * Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in 15 * the documentation and/or other materials provided with the 16 * distribution. 17 * * Neither the name of Intel Corporation nor the names of its 18 * contributors may be used to endorse or promote products derived 19 * from this software without specific prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 22 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 24 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 25 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 26 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 27 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 28 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 29 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 30 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 31 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 32 */ 33 34 /* NVMF FC Transport Unit Test */ 35 36 #include "spdk/env.h" 37 #include "spdk_cunit.h" 38 #include "spdk/nvmf.h" 39 #include "spdk/endian.h" 40 #include "spdk/trace.h" 41 #include "spdk/log.h" 42 43 #include "ut_multithread.c" 44 45 #include "transport.h" 46 #include "nvmf_internal.h" 47 48 #include "nvmf_fc.h" 49 50 #include "json/json_util.c" 51 #include "json/json_write.c" 52 #include "nvmf/nvmf.c" 53 #include "nvmf/transport.c" 54 #include "spdk/bdev_module.h" 55 #include "nvmf/subsystem.c" 56 #include "nvmf/fc.c" 57 #include "nvmf/fc_ls.c" 58 59 /* 60 * SPDK Stuff 61 */ 62 63 #ifdef SPDK_CONFIG_RDMA 64 const struct spdk_nvmf_transport_ops spdk_nvmf_transport_rdma = { 65 .type = SPDK_NVME_TRANSPORT_RDMA, 66 .opts_init = NULL, 67 .create = NULL, 68 .destroy = NULL, 69 70 .listen = NULL, 71 .stop_listen = NULL, 72 .accept = NULL, 73 74 .listener_discover = NULL, 75 76 .poll_group_create = NULL, 77 .poll_group_destroy = NULL, 78 .poll_group_add = NULL, 79 .poll_group_poll = NULL, 80 81 .req_free = NULL, 82 .req_complete = NULL, 83 84 .qpair_fini = NULL, 85 .qpair_get_peer_trid = NULL, 86 .qpair_get_local_trid = NULL, 87 .qpair_get_listen_trid = NULL, 88 }; 89 #endif 90 91 const struct spdk_nvmf_transport_ops spdk_nvmf_transport_tcp = { 92 .type = SPDK_NVME_TRANSPORT_TCP, 93 }; 94 95 struct spdk_trace_histories *g_trace_histories; 96 97 DEFINE_STUB_V(_spdk_trace_record, (uint64_t tsc, uint16_t tpoint_id, uint16_t poller_id, 98 uint32_t size, uint64_t object_id, uint64_t arg1)); 99 DEFINE_STUB(spdk_nvme_transport_id_compare, int, 100 (const struct spdk_nvme_transport_id *trid1, 101 const struct spdk_nvme_transport_id *trid2), 0); 102 DEFINE_STUB_V(spdk_trace_register_object, (uint8_t type, char id_prefix)); 103 DEFINE_STUB_V(spdk_trace_register_description, 104 (const char *name, uint16_t tpoint_id, uint8_t owner_type, 105 uint8_t object_type, uint8_t new_object, uint8_t arg1_type, 106 const char *arg1_name)); 107 DEFINE_STUB_V(spdk_trace_add_register_fn, (struct spdk_trace_register_fn *reg_fn)); 108 DEFINE_STUB(spdk_bdev_get_name, const char *, (const struct spdk_bdev *bdev), "fc_ut_test"); 109 DEFINE_STUB_V(nvmf_ctrlr_destruct, (struct spdk_nvmf_ctrlr *ctrlr)); 110 DEFINE_STUB_V(nvmf_qpair_free_aer, (struct spdk_nvmf_qpair *qpair)); 111 DEFINE_STUB(spdk_bdev_get_io_channel, struct spdk_io_channel *, (struct spdk_bdev_desc *desc), 112 NULL); 113 DEFINE_STUB_V(spdk_nvmf_request_exec, (struct spdk_nvmf_request *req)); 114 DEFINE_STUB_V(nvmf_ctrlr_ns_changed, (struct spdk_nvmf_ctrlr *ctrlr, uint32_t nsid)); 115 DEFINE_STUB(spdk_bdev_open, int, (struct spdk_bdev *bdev, bool write, 116 spdk_bdev_remove_cb_t remove_cb, 117 void *remove_ctx, struct spdk_bdev_desc **desc), 0); 118 DEFINE_STUB_V(spdk_bdev_close, (struct spdk_bdev_desc *desc)); 119 DEFINE_STUB(spdk_bdev_module_claim_bdev, int, 120 (struct spdk_bdev *bdev, struct spdk_bdev_desc *desc, 121 struct spdk_bdev_module *module), 0); 122 DEFINE_STUB_V(spdk_bdev_module_release_bdev, (struct spdk_bdev *bdev)); 123 DEFINE_STUB(spdk_bdev_get_block_size, uint32_t, (const struct spdk_bdev *bdev), 512); 124 DEFINE_STUB(spdk_bdev_get_num_blocks, uint64_t, (const struct spdk_bdev *bdev), 1024); 125 126 DEFINE_STUB(nvmf_ctrlr_async_event_ns_notice, int, (struct spdk_nvmf_ctrlr *ctrlr), 0); 127 DEFINE_STUB(nvmf_ctrlr_async_event_ana_change_notice, int, 128 (struct spdk_nvmf_ctrlr *ctrlr), 0); 129 DEFINE_STUB_V(spdk_nvme_trid_populate_transport, (struct spdk_nvme_transport_id *trid, 130 enum spdk_nvme_transport_type trtype)); 131 DEFINE_STUB_V(spdk_nvmf_ctrlr_data_init, (struct spdk_nvmf_transport_opts *opts, 132 struct spdk_nvmf_ctrlr_data *cdata)); 133 DEFINE_STUB(spdk_nvmf_request_complete, int, (struct spdk_nvmf_request *req), 134 -ENOSPC); 135 136 DEFINE_STUB_V(nvmf_update_discovery_log, 137 (struct spdk_nvmf_tgt *tgt, const char *hostnqn)); 138 139 DEFINE_STUB(rte_hash_create, struct rte_hash *, (const struct rte_hash_parameters *params), 140 (void *)1); 141 DEFINE_STUB(rte_hash_del_key, int32_t, (const struct rte_hash *h, const void *key), 0); 142 DEFINE_STUB(rte_hash_lookup_data, int, (const struct rte_hash *h, const void *key, void **data), 143 -ENOENT); 144 DEFINE_STUB(rte_hash_add_key_data, int, (const struct rte_hash *h, const void *key, void *data), 0); 145 DEFINE_STUB_V(rte_hash_free, (struct rte_hash *h)); 146 DEFINE_STUB(nvmf_fc_lld_port_add, int, (struct spdk_nvmf_fc_port *fc_port), 0); 147 DEFINE_STUB(nvmf_fc_lld_port_remove, int, (struct spdk_nvmf_fc_port *fc_port), 0); 148 149 const char * 150 spdk_nvme_transport_id_trtype_str(enum spdk_nvme_transport_type trtype) 151 { 152 switch (trtype) { 153 case SPDK_NVME_TRANSPORT_PCIE: 154 return "PCIe"; 155 case SPDK_NVME_TRANSPORT_RDMA: 156 return "RDMA"; 157 case SPDK_NVME_TRANSPORT_FC: 158 return "FC"; 159 default: 160 return NULL; 161 } 162 } 163 164 const char * 165 spdk_nvme_transport_id_adrfam_str(enum spdk_nvmf_adrfam adrfam) 166 { 167 switch (adrfam) { 168 case SPDK_NVMF_ADRFAM_IPV4: 169 return "IPv4"; 170 case SPDK_NVMF_ADRFAM_IPV6: 171 return "IPv6"; 172 case SPDK_NVMF_ADRFAM_IB: 173 return "IB"; 174 case SPDK_NVMF_ADRFAM_FC: 175 return "FC"; 176 default: 177 return NULL; 178 } 179 } 180 181 const struct spdk_uuid * 182 spdk_bdev_get_uuid(const struct spdk_bdev *bdev) 183 { 184 return &bdev->uuid; 185 } 186 187 static bool g_lld_init_called = false; 188 189 int 190 nvmf_fc_lld_init(void) 191 { 192 g_lld_init_called = true; 193 return 0; 194 } 195 196 static bool g_lld_fini_called = false; 197 198 void 199 nvmf_fc_lld_fini(spdk_nvmf_transport_destroy_done_cb cb_fn, void *ctx) 200 { 201 g_lld_fini_called = true; 202 } 203 204 DEFINE_STUB_V(nvmf_fc_lld_start, (void)); 205 DEFINE_STUB(nvmf_fc_init_q, int, (struct spdk_nvmf_fc_hwqp *hwqp), 0); 206 DEFINE_STUB_V(nvmf_fc_reinit_q, (void *queues_prev, void *queues_curr)); 207 DEFINE_STUB(nvmf_fc_init_rqpair_buffers, int, (struct spdk_nvmf_fc_hwqp *hwqp), 0); 208 DEFINE_STUB(nvmf_fc_set_q_online_state, int, (struct spdk_nvmf_fc_hwqp *hwqp, bool online), 0); 209 DEFINE_STUB(nvmf_fc_put_xchg, int, (struct spdk_nvmf_fc_hwqp *hwqp, struct spdk_nvmf_fc_xchg *xri), 210 0); 211 DEFINE_STUB(nvmf_fc_recv_data, int, (struct spdk_nvmf_fc_request *fc_req), 0); 212 DEFINE_STUB(nvmf_fc_send_data, int, (struct spdk_nvmf_fc_request *fc_req), 0); 213 DEFINE_STUB_V(nvmf_fc_rqpair_buffer_release, (struct spdk_nvmf_fc_hwqp *hwqp, uint16_t buff_idx)); 214 DEFINE_STUB(nvmf_fc_xmt_rsp, int, (struct spdk_nvmf_fc_request *fc_req, uint8_t *ersp_buf, 215 uint32_t ersp_len), 0); 216 DEFINE_STUB(nvmf_fc_xmt_ls_rsp, int, (struct spdk_nvmf_fc_nport *tgtport, 217 struct spdk_nvmf_fc_ls_rqst *ls_rqst), 0); 218 DEFINE_STUB(nvmf_fc_issue_abort, int, (struct spdk_nvmf_fc_hwqp *hwqp, 219 struct spdk_nvmf_fc_xchg *xri, 220 spdk_nvmf_fc_caller_cb cb, void *cb_args), 0); 221 DEFINE_STUB(nvmf_fc_xmt_bls_rsp, int, (struct spdk_nvmf_fc_hwqp *hwqp, 222 uint16_t ox_id, uint16_t rx_id, 223 uint16_t rpi, bool rjt, uint8_t rjt_exp, 224 spdk_nvmf_fc_caller_cb cb, void *cb_args), 0); 225 DEFINE_STUB(nvmf_fc_alloc_srsr_bufs, struct spdk_nvmf_fc_srsr_bufs *, (size_t rqst_len, 226 size_t rsp_len), NULL); 227 DEFINE_STUB_V(nvmf_fc_free_srsr_bufs, (struct spdk_nvmf_fc_srsr_bufs *srsr_bufs)); 228 DEFINE_STUB(nvmf_fc_xmt_srsr_req, int, (struct spdk_nvmf_fc_hwqp *hwqp, 229 struct spdk_nvmf_fc_srsr_bufs *xmt_srsr_bufs, 230 spdk_nvmf_fc_caller_cb cb, void *cb_args), 0); 231 DEFINE_STUB(nvmf_fc_q_sync_available, bool, (void), true); 232 DEFINE_STUB(nvmf_fc_issue_q_sync, int, (struct spdk_nvmf_fc_hwqp *hwqp, uint64_t u_id, 233 uint16_t skip_rq), 0); 234 DEFINE_STUB(nvmf_fc_assign_conn_to_hwqp, bool, (struct spdk_nvmf_fc_hwqp *hwqp, 235 uint64_t *conn_id, uint32_t sq_size), true); 236 DEFINE_STUB(nvmf_fc_get_hwqp_from_conn_id, struct spdk_nvmf_fc_hwqp *, 237 (struct spdk_nvmf_fc_hwqp *queues, 238 uint32_t num_queues, uint64_t conn_id), NULL); 239 DEFINE_STUB_V(nvmf_fc_dump_all_queues, (struct spdk_nvmf_fc_hwqp *ls_queue, 240 struct spdk_nvmf_fc_hwqp *io_queues, 241 uint32_t num_io_queues, 242 struct spdk_nvmf_fc_queue_dump_info *dump_info)); 243 DEFINE_STUB_V(nvmf_fc_get_xri_info, (struct spdk_nvmf_fc_hwqp *hwqp, 244 struct spdk_nvmf_fc_xchg_info *info)); 245 DEFINE_STUB(nvmf_fc_get_rsvd_thread, struct spdk_thread *, (void), NULL); 246 247 uint32_t 248 nvmf_fc_process_queue(struct spdk_nvmf_fc_hwqp *hwqp) 249 { 250 hwqp->lcore_id++; 251 return 0; /* always return 0 or else it will poll forever */ 252 } 253 254 struct spdk_nvmf_fc_xchg * 255 nvmf_fc_get_xri(struct spdk_nvmf_fc_hwqp *hwqp) 256 { 257 static struct spdk_nvmf_fc_xchg xchg; 258 259 xchg.xchg_id = 1; 260 return &xchg; 261 } 262 263 #define MAX_FC_UT_POLL_THREADS 8 264 static struct spdk_nvmf_poll_group *g_poll_groups[MAX_FC_UT_POLL_THREADS] = {0}; 265 #define MAX_FC_UT_HWQPS MAX_FC_UT_POLL_THREADS 266 static struct spdk_nvmf_tgt *g_nvmf_tgt = NULL; 267 static struct spdk_nvmf_transport *g_nvmf_tprt = NULL; 268 uint8_t g_fc_port_handle = 0xff; 269 struct spdk_nvmf_fc_hwqp lld_q[MAX_FC_UT_HWQPS]; 270 271 static void 272 _add_transport_done(void *arg, int status) 273 { 274 CU_ASSERT(status == 0); 275 } 276 277 static void 278 _add_transport_done_dup_err(void *arg, int status) 279 { 280 CU_ASSERT(status == -EEXIST); 281 } 282 283 static void 284 create_transport_test(void) 285 { 286 const struct spdk_nvmf_transport_ops *ops = NULL; 287 struct spdk_nvmf_transport_opts opts = { 0 }; 288 struct spdk_nvmf_target_opts tgt_opts = { 289 .name = "nvmf_test_tgt", 290 .max_subsystems = 0 291 }; 292 293 allocate_threads(8); 294 set_thread(0); 295 296 g_nvmf_tgt = spdk_nvmf_tgt_create(&tgt_opts); 297 SPDK_CU_ASSERT_FATAL(g_nvmf_tgt != NULL); 298 299 ops = nvmf_get_transport_ops(SPDK_NVME_TRANSPORT_NAME_FC); 300 SPDK_CU_ASSERT_FATAL(ops != NULL); 301 302 ops->opts_init(&opts); 303 304 g_lld_init_called = false; 305 opts.opts_size = sizeof(opts); 306 g_nvmf_tprt = spdk_nvmf_transport_create("FC", &opts); 307 SPDK_CU_ASSERT_FATAL(g_nvmf_tprt != NULL); 308 309 CU_ASSERT(g_lld_init_called == true); 310 CU_ASSERT(opts.max_queue_depth == g_nvmf_tprt->opts.max_queue_depth); 311 CU_ASSERT(opts.max_qpairs_per_ctrlr == g_nvmf_tprt->opts.max_qpairs_per_ctrlr); 312 CU_ASSERT(opts.in_capsule_data_size == g_nvmf_tprt->opts.in_capsule_data_size); 313 CU_ASSERT(opts.max_io_size == g_nvmf_tprt->opts.max_io_size); 314 CU_ASSERT(opts.io_unit_size == g_nvmf_tprt->opts.io_unit_size); 315 CU_ASSERT(opts.max_aq_depth == g_nvmf_tprt->opts.max_aq_depth); 316 317 set_thread(0); 318 319 spdk_nvmf_tgt_add_transport(g_nvmf_tgt, g_nvmf_tprt, 320 _add_transport_done, 0); 321 poll_thread(0); 322 323 /* Add transport again - should get error */ 324 spdk_nvmf_tgt_add_transport(g_nvmf_tgt, g_nvmf_tprt, 325 _add_transport_done_dup_err, 0); 326 poll_thread(0); 327 328 /* create transport with bad args/options */ 329 #ifndef SPDK_CONFIG_RDMA 330 CU_ASSERT(spdk_nvmf_transport_create("RDMA", &opts) == NULL); 331 #endif 332 CU_ASSERT(spdk_nvmf_transport_create("Bogus Transport", &opts) == NULL); 333 opts.max_io_size = 1024 ^ 3; 334 CU_ASSERT(spdk_nvmf_transport_create("FC", &opts) == NULL); 335 opts.max_io_size = 999; 336 opts.io_unit_size = 1024; 337 CU_ASSERT(spdk_nvmf_transport_create("FC", &opts) == NULL); 338 } 339 340 static void 341 port_init_cb(uint8_t port_handle, enum spdk_fc_event event_type, void *arg, int err) 342 { 343 CU_ASSERT(err == 0); 344 CU_ASSERT(port_handle == 2); 345 g_fc_port_handle = port_handle; 346 } 347 348 static void 349 create_fc_port_test(void) 350 { 351 struct spdk_nvmf_fc_hw_port_init_args init_args = { 0 }; 352 struct spdk_nvmf_fc_port *fc_port = NULL; 353 int err; 354 355 SPDK_CU_ASSERT_FATAL(g_nvmf_tprt != NULL); 356 357 init_args.port_handle = 2; 358 init_args.io_queue_cnt = spdk_min(MAX_FC_UT_HWQPS, spdk_env_get_core_count()); 359 init_args.ls_queue_size = 100; 360 init_args.io_queue_size = 100; 361 init_args.io_queues = (void *)lld_q; 362 363 set_thread(0); 364 err = nvmf_fc_main_enqueue_event(SPDK_FC_HW_PORT_INIT, (void *)&init_args, port_init_cb); 365 CU_ASSERT(err == 0); 366 poll_thread(0); 367 368 fc_port = nvmf_fc_port_lookup(g_fc_port_handle); 369 CU_ASSERT(fc_port != NULL); 370 } 371 372 static void 373 online_fc_port_test(void) 374 { 375 struct spdk_nvmf_fc_port *fc_port; 376 struct spdk_nvmf_fc_hw_port_online_args args; 377 int err; 378 379 SPDK_CU_ASSERT_FATAL(g_nvmf_tprt != NULL); 380 381 fc_port = nvmf_fc_port_lookup(g_fc_port_handle); 382 SPDK_CU_ASSERT_FATAL(fc_port != NULL); 383 384 set_thread(0); 385 args.port_handle = g_fc_port_handle; 386 err = nvmf_fc_main_enqueue_event(SPDK_FC_HW_PORT_ONLINE, (void *)&args, port_init_cb); 387 CU_ASSERT(err == 0); 388 poll_threads(); 389 set_thread(0); 390 if (err == 0) { 391 uint32_t i; 392 for (i = 0; i < fc_port->num_io_queues; i++) { 393 CU_ASSERT(fc_port->io_queues[i].fgroup != 0); 394 CU_ASSERT(fc_port->io_queues[i].fgroup != 0); 395 CU_ASSERT(fc_port->io_queues[i].fgroup->hwqp_count != 0); 396 } 397 } 398 } 399 400 static void 401 create_poll_groups_test(void) 402 { 403 unsigned i; 404 405 SPDK_CU_ASSERT_FATAL(g_nvmf_tprt != NULL); 406 407 for (i = 0; i < MAX_FC_UT_POLL_THREADS; i++) { 408 set_thread(i); 409 g_poll_groups[i] = spdk_nvmf_poll_group_create(g_nvmf_tgt); 410 poll_thread(i); 411 CU_ASSERT(g_poll_groups[i] != NULL); 412 } 413 set_thread(0); 414 } 415 416 static void 417 poll_group_poll_test(void) 418 { 419 unsigned i; 420 unsigned poll_cnt = 10; 421 struct spdk_nvmf_fc_port *fc_port = NULL; 422 423 SPDK_CU_ASSERT_FATAL(g_nvmf_tprt != NULL); 424 425 set_thread(0); 426 fc_port = nvmf_fc_port_lookup(g_fc_port_handle); 427 SPDK_CU_ASSERT_FATAL(fc_port != NULL); 428 429 for (i = 0; i < fc_port->num_io_queues; i++) { 430 fc_port->io_queues[i].lcore_id = 0; 431 } 432 433 for (i = 0; i < poll_cnt; i++) { 434 /* this should cause spdk_nvmf_fc_poll_group_poll to be called() */ 435 poll_threads(); 436 } 437 438 /* check if hwqp's lcore_id has been updated */ 439 for (i = 0; i < fc_port->num_io_queues; i++) { 440 CU_ASSERT(fc_port->io_queues[i].lcore_id == poll_cnt); 441 } 442 } 443 444 static void 445 remove_hwqps_from_poll_groups_test(void) 446 { 447 unsigned i; 448 struct spdk_nvmf_fc_port *fc_port = NULL; 449 450 SPDK_CU_ASSERT_FATAL(g_nvmf_tprt != NULL); 451 452 fc_port = nvmf_fc_port_lookup(g_fc_port_handle); 453 SPDK_CU_ASSERT_FATAL(fc_port != NULL); 454 455 for (i = 0; i < fc_port->num_io_queues; i++) { 456 nvmf_fc_poll_group_remove_hwqp(&fc_port->io_queues[i], NULL, NULL); 457 poll_threads(); 458 CU_ASSERT(fc_port->io_queues[i].fgroup == 0); 459 } 460 } 461 462 static void 463 destroy_transport_test(void) 464 { 465 unsigned i; 466 467 SPDK_CU_ASSERT_FATAL(g_nvmf_tprt != NULL); 468 469 for (i = 0; i < MAX_FC_UT_POLL_THREADS; i++) { 470 set_thread(i); 471 spdk_nvmf_poll_group_destroy(g_poll_groups[i], NULL, NULL); 472 poll_thread(0); 473 } 474 475 set_thread(0); 476 SPDK_CU_ASSERT_FATAL(g_nvmf_tgt != NULL); 477 g_lld_fini_called = false; 478 spdk_nvmf_tgt_destroy(g_nvmf_tgt, NULL, NULL); 479 poll_threads(); 480 CU_ASSERT(g_lld_fini_called == true); 481 } 482 483 static int 484 nvmf_fc_tests_init(void) 485 { 486 return 0; 487 } 488 489 static int 490 nvmf_fc_tests_fini(void) 491 { 492 free_threads(); 493 return 0; 494 } 495 496 int main(int argc, char **argv) 497 { 498 unsigned int num_failures = 0; 499 CU_pSuite suite = NULL; 500 501 CU_set_error_action(CUEA_ABORT); 502 CU_initialize_registry(); 503 504 suite = CU_add_suite("NVMf-FC", nvmf_fc_tests_init, nvmf_fc_tests_fini); 505 506 CU_ADD_TEST(suite, create_transport_test); 507 CU_ADD_TEST(suite, create_poll_groups_test); 508 CU_ADD_TEST(suite, create_fc_port_test); 509 CU_ADD_TEST(suite, online_fc_port_test); 510 CU_ADD_TEST(suite, poll_group_poll_test); 511 CU_ADD_TEST(suite, remove_hwqps_from_poll_groups_test); 512 CU_ADD_TEST(suite, destroy_transport_test); 513 514 CU_basic_set_mode(CU_BRM_VERBOSE); 515 CU_basic_run_tests(); 516 num_failures = CU_get_number_of_failures(); 517 CU_cleanup_registry(); 518 519 return num_failures; 520 } 521