ceph/src/spdk/test/unit/lib/nvmf/fc.c/fc_ut.c

   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_internal/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 "nvmf/subsystem.c"
  55 #include "nvmf/fc.c"
  56 #include "nvmf/fc_ls.c"
  57
  58 /*
  59  * SPDK Stuff
  60  */
  61
  62 #ifdef SPDK_CONFIG_RDMA
  63 const struct spdk_nvmf_transport_ops spdk_nvmf_transport_rdma = {
  64         .type = SPDK_NVME_TRANSPORT_RDMA,
  65         .opts_init = NULL,
  66         .create = NULL,
  67         .destroy = NULL,
  68
  69         .listen = NULL,
  70         .stop_listen = NULL,
  71         .accept = NULL,
  72
  73         .listener_discover = NULL,
  74
  75         .poll_group_create = NULL,
  76         .poll_group_destroy = NULL,
  77         .poll_group_add = NULL,
  78         .poll_group_poll = NULL,
  79
  80         .req_free = NULL,
  81         .req_complete = NULL,
  82
  83         .qpair_fini = NULL,
  84         .qpair_get_peer_trid = NULL,
  85         .qpair_get_local_trid = NULL,
  86         .qpair_get_listen_trid = NULL,
  87 };
  88 #endif
  89
  90 const struct spdk_nvmf_transport_ops spdk_nvmf_transport_tcp = {
  91         .type = SPDK_NVME_TRANSPORT_TCP,
  92 };
  93
  94 struct spdk_trace_histories *g_trace_histories;
  95
  96 DEFINE_STUB_V(_spdk_trace_record, (uint64_t tsc, uint16_t tpoint_id, uint16_t poller_id,
  97                                    uint32_t size, uint64_t object_id, uint64_t arg1));
  98 DEFINE_STUB(spdk_nvme_transport_id_compare, int,
  99             (const struct spdk_nvme_transport_id *trid1,
 100              const struct spdk_nvme_transport_id *trid2), 0);
 101 DEFINE_STUB_V(spdk_trace_register_object, (uint8_t type, char id_prefix));
 102 DEFINE_STUB_V(spdk_trace_register_description,
 103               (const char *name, uint16_t tpoint_id, uint8_t owner_type,
 104                uint8_t object_type, uint8_t new_object, uint8_t arg1_type,
 105                const char *arg1_name));
 106 DEFINE_STUB_V(spdk_trace_add_register_fn, (struct spdk_trace_register_fn *reg_fn));
 107 DEFINE_STUB(spdk_bdev_get_name, const char *, (const struct spdk_bdev *bdev), "fc_ut_test");
 108 DEFINE_STUB_V(nvmf_ctrlr_destruct, (struct spdk_nvmf_ctrlr *ctrlr));
 109 DEFINE_STUB_V(nvmf_qpair_free_aer, (struct spdk_nvmf_qpair *qpair));
 110 DEFINE_STUB(spdk_bdev_get_io_channel, struct spdk_io_channel *, (struct spdk_bdev_desc *desc),
 111             NULL);
 112 DEFINE_STUB_V(spdk_nvmf_request_exec, (struct spdk_nvmf_request *req));
 113 DEFINE_STUB_V(nvmf_ctrlr_ns_changed, (struct spdk_nvmf_ctrlr *ctrlr, uint32_t nsid));
 114 DEFINE_STUB(spdk_bdev_open, int, (struct spdk_bdev *bdev, bool write,
 115                                   spdk_bdev_remove_cb_t remove_cb,
 116                                   void *remove_ctx, struct spdk_bdev_desc **desc), 0);
 117 DEFINE_STUB_V(spdk_bdev_close, (struct spdk_bdev_desc *desc));
 118 DEFINE_STUB(spdk_bdev_module_claim_bdev, int,
 119             (struct spdk_bdev *bdev, struct spdk_bdev_desc *desc,
 120              struct spdk_bdev_module *module), 0);
 121 DEFINE_STUB_V(spdk_bdev_module_release_bdev, (struct spdk_bdev *bdev));
 122 DEFINE_STUB(spdk_bdev_get_block_size, uint32_t, (const struct spdk_bdev *bdev), 512);
 123 DEFINE_STUB(spdk_bdev_get_num_blocks, uint64_t, (const struct spdk_bdev *bdev), 1024);
 124
 125 DEFINE_STUB(nvmf_ctrlr_async_event_ns_notice, int, (struct spdk_nvmf_ctrlr *ctrlr), 0);
 126 DEFINE_STUB_V(spdk_nvme_trid_populate_transport, (struct spdk_nvme_transport_id *trid,
 127                 enum spdk_nvme_transport_type trtype));
 128 DEFINE_STUB_V(spdk_nvmf_ctrlr_data_init, (struct spdk_nvmf_transport_opts *opts,
 129                 struct spdk_nvmf_ctrlr_data *cdata));
 130 DEFINE_STUB(spdk_nvmf_request_complete, int, (struct spdk_nvmf_request *req),
 131             -ENOSPC);
 132
 133 const char *
 134 spdk_nvme_transport_id_trtype_str(enum spdk_nvme_transport_type trtype)
 135 {
 136         switch (trtype) {
 137         case SPDK_NVME_TRANSPORT_PCIE:
 138                 return "PCIe";
 139         case SPDK_NVME_TRANSPORT_RDMA:
 140                 return "RDMA";
 141         case SPDK_NVME_TRANSPORT_FC:
 142                 return "FC";
 143         default:
 144                 return NULL;
 145         }
 146 }
 147
 148 const char *
 149 spdk_nvme_transport_id_adrfam_str(enum spdk_nvmf_adrfam adrfam)
 150 {
 151         switch (adrfam) {
 152         case SPDK_NVMF_ADRFAM_IPV4:
 153                 return "IPv4";
 154         case SPDK_NVMF_ADRFAM_IPV6:
 155                 return "IPv6";
 156         case SPDK_NVMF_ADRFAM_IB:
 157                 return "IB";
 158         case SPDK_NVMF_ADRFAM_FC:
 159                 return "FC";
 160         default:
 161                 return NULL;
 162         }
 163 }
 164
 165 const struct spdk_uuid *
 166 spdk_bdev_get_uuid(const struct spdk_bdev *bdev)
 167 {
 168         return &bdev->uuid;
 169 }
 170
 171 static bool g_lld_init_called = false;
 172
 173 int
 174 nvmf_fc_lld_init(void)
 175 {
 176         g_lld_init_called = true;
 177         return 0;
 178 }
 179
 180 static bool g_lld_fini_called = false;
 181
 182 void
 183 nvmf_fc_lld_fini(void)
 184 {
 185         g_lld_fini_called = true;
 186 }
 187
 188 DEFINE_STUB_V(nvmf_fc_lld_start, (void));
 189 DEFINE_STUB(nvmf_fc_init_q, int, (struct spdk_nvmf_fc_hwqp *hwqp), 0);
 190 DEFINE_STUB_V(nvmf_fc_reinit_q, (void *queues_prev, void *queues_curr));
 191 DEFINE_STUB(nvmf_fc_init_rqpair_buffers, int, (struct spdk_nvmf_fc_hwqp *hwqp), 0);
 192 DEFINE_STUB(nvmf_fc_set_q_online_state, int, (struct spdk_nvmf_fc_hwqp *hwqp, bool online), 0);
 193 DEFINE_STUB(nvmf_fc_put_xchg, int, (struct spdk_nvmf_fc_hwqp *hwqp, struct spdk_nvmf_fc_xchg *xri),
 194             0);
 195 DEFINE_STUB(nvmf_fc_recv_data, int, (struct spdk_nvmf_fc_request *fc_req), 0);
 196 DEFINE_STUB(nvmf_fc_send_data, int, (struct spdk_nvmf_fc_request *fc_req), 0);
 197 DEFINE_STUB_V(nvmf_fc_rqpair_buffer_release, (struct spdk_nvmf_fc_hwqp *hwqp, uint16_t buff_idx));
 198 DEFINE_STUB(nvmf_fc_xmt_rsp, int, (struct spdk_nvmf_fc_request *fc_req, uint8_t *ersp_buf,
 199                                    uint32_t ersp_len), 0);
 200 DEFINE_STUB(nvmf_fc_xmt_ls_rsp, int, (struct spdk_nvmf_fc_nport *tgtport,
 201                                       struct spdk_nvmf_fc_ls_rqst *ls_rqst), 0);
 202 DEFINE_STUB(nvmf_fc_issue_abort, int, (struct spdk_nvmf_fc_hwqp *hwqp,
 203                                        struct spdk_nvmf_fc_xchg *xri,
 204                                        spdk_nvmf_fc_caller_cb cb, void *cb_args), 0);
 205 DEFINE_STUB(nvmf_fc_xmt_bls_rsp, int, (struct spdk_nvmf_fc_hwqp *hwqp,
 206                                        uint16_t ox_id, uint16_t rx_id,
 207                                        uint16_t rpi, bool rjt, uint8_t rjt_exp,
 208                                        spdk_nvmf_fc_caller_cb cb, void *cb_args), 0);
 209 DEFINE_STUB(nvmf_fc_alloc_srsr_bufs, struct spdk_nvmf_fc_srsr_bufs *, (size_t rqst_len,
 210                 size_t rsp_len), NULL);
 211 DEFINE_STUB_V(nvmf_fc_free_srsr_bufs, (struct spdk_nvmf_fc_srsr_bufs *srsr_bufs));
 212 DEFINE_STUB(nvmf_fc_xmt_srsr_req, int, (struct spdk_nvmf_fc_hwqp *hwqp,
 213                                         struct spdk_nvmf_fc_srsr_bufs *xmt_srsr_bufs,
 214                                         spdk_nvmf_fc_caller_cb cb, void *cb_args), 0);
 215 DEFINE_STUB(nvmf_fc_q_sync_available, bool, (void), true);
 216 DEFINE_STUB(nvmf_fc_issue_q_sync, int, (struct spdk_nvmf_fc_hwqp *hwqp, uint64_t u_id,
 217                                         uint16_t skip_rq), 0);
 218 DEFINE_STUB(nvmf_fc_assign_conn_to_hwqp, bool, (struct spdk_nvmf_fc_hwqp *hwqp,
 219                 uint64_t *conn_id, uint32_t sq_size), true);
 220 DEFINE_STUB(nvmf_fc_get_hwqp_from_conn_id, struct spdk_nvmf_fc_hwqp *,
 221             (struct spdk_nvmf_fc_hwqp *queues,
 222              uint32_t num_queues, uint64_t conn_id), NULL);
 223 DEFINE_STUB_V(nvmf_fc_release_conn, (struct spdk_nvmf_fc_hwqp *hwqp, uint64_t conn_id,
 224                                      uint32_t sq_size));
 225 DEFINE_STUB_V(nvmf_fc_dump_all_queues, (struct spdk_nvmf_fc_hwqp *ls_queue,
 226                                         struct spdk_nvmf_fc_hwqp *io_queues,
 227                                         uint32_t num_io_queues,
 228                                         struct spdk_nvmf_fc_queue_dump_info *dump_info));
 229 DEFINE_STUB_V(nvmf_fc_get_xri_info, (struct spdk_nvmf_fc_hwqp *hwqp,
 230                                      struct spdk_nvmf_fc_xchg_info *info));
 231 DEFINE_STUB(nvmf_fc_get_rsvd_thread, struct spdk_thread *, (void), NULL);
 232
 233 uint32_t
 234 nvmf_fc_process_queue(struct spdk_nvmf_fc_hwqp *hwqp)
 235 {
 236         hwqp->lcore_id++;
 237         return 0; /* always return 0 or else it will poll forever */
 238 }
 239
 240 struct spdk_nvmf_fc_xchg *
 241 nvmf_fc_get_xri(struct spdk_nvmf_fc_hwqp *hwqp)
 242 {
 243         static struct spdk_nvmf_fc_xchg xchg;
 244
 245         xchg.xchg_id = 1;
 246         return &xchg;
 247 }
 248
 249 #define MAX_FC_UT_POLL_THREADS 8
 250 static struct spdk_nvmf_poll_group *g_poll_groups[MAX_FC_UT_POLL_THREADS] = {0};
 251 #define MAX_FC_UT_HWQPS MAX_FC_UT_POLL_THREADS
 252 static struct spdk_nvmf_tgt *g_nvmf_tgt = NULL;
 253 static struct spdk_nvmf_transport *g_nvmf_tprt = NULL;
 254 uint8_t g_fc_port_handle = 0xff;
 255 struct spdk_nvmf_fc_hwqp lld_q[MAX_FC_UT_HWQPS];
 256
 257 static void
 258 _add_transport_done(void *arg, int status)
 259 {
 260         CU_ASSERT(status == 0);
 261 }
 262
 263 static void
 264 _add_transport_done_dup_err(void *arg, int status)
 265 {
 266         CU_ASSERT(status == -EEXIST);
 267 }
 268
 269 static void
 270 create_transport_test(void)
 271 {
 272         const struct spdk_nvmf_transport_ops *ops = NULL;
 273         struct spdk_nvmf_transport_opts opts = { 0 };
 274         struct spdk_nvmf_target_opts tgt_opts = {
 275                 .name = "nvmf_test_tgt",
 276                 .max_subsystems = 0
 277         };
 278
 279         allocate_threads(8);
 280         set_thread(0);
 281
 282         g_nvmf_tgt = spdk_nvmf_tgt_create(&tgt_opts);
 283         SPDK_CU_ASSERT_FATAL(g_nvmf_tgt != NULL);
 284
 285         ops = nvmf_get_transport_ops(SPDK_NVME_TRANSPORT_NAME_FC);
 286         SPDK_CU_ASSERT_FATAL(ops != NULL);
 287
 288         ops->opts_init(&opts);
 289
 290         g_lld_init_called = false;
 291         g_nvmf_tprt = spdk_nvmf_transport_create("FC", &opts);
 292         SPDK_CU_ASSERT_FATAL(g_nvmf_tprt != NULL);
 293
 294         CU_ASSERT(g_lld_init_called == true);
 295         CU_ASSERT(opts.max_queue_depth == g_nvmf_tprt->opts.max_queue_depth);
 296         CU_ASSERT(opts.max_qpairs_per_ctrlr == g_nvmf_tprt->opts.max_qpairs_per_ctrlr);
 297         CU_ASSERT(opts.in_capsule_data_size == g_nvmf_tprt->opts.in_capsule_data_size);
 298         CU_ASSERT(opts.max_io_size == g_nvmf_tprt->opts.max_io_size);
 299         CU_ASSERT(opts.io_unit_size == g_nvmf_tprt->opts.io_unit_size);
 300         CU_ASSERT(opts.max_aq_depth == g_nvmf_tprt->opts.max_aq_depth);
 301
 302         set_thread(0);
 303
 304         spdk_nvmf_tgt_add_transport(g_nvmf_tgt, g_nvmf_tprt,
 305                                     _add_transport_done, 0);
 306         poll_thread(0);
 307
 308         /* Add transport again - should get error */
 309         spdk_nvmf_tgt_add_transport(g_nvmf_tgt, g_nvmf_tprt,
 310                                     _add_transport_done_dup_err, 0);
 311         poll_thread(0);
 312
 313         /* create transport with bad args/options */
 314 #ifndef SPDK_CONFIG_RDMA
 315         CU_ASSERT(spdk_nvmf_transport_create("RDMA", &opts) == NULL);
 316 #endif
 317         CU_ASSERT(spdk_nvmf_transport_create("Bogus Transport", &opts) == NULL);
 318         opts.max_io_size = 1024 ^ 3;
 319         CU_ASSERT(spdk_nvmf_transport_create("FC", &opts) == NULL);
 320         opts.max_io_size = 999;
 321         opts.io_unit_size = 1024;
 322         CU_ASSERT(spdk_nvmf_transport_create("FC", &opts) == NULL);
 323 }
 324
 325 static void
 326 port_init_cb(uint8_t port_handle, enum spdk_fc_event event_type, void *arg, int err)
 327 {
 328         CU_ASSERT(err == 0);
 329         CU_ASSERT(port_handle == 2);
 330         g_fc_port_handle = port_handle;
 331 }
 332
 333 static void
 334 create_fc_port_test(void)
 335 {
 336         struct spdk_nvmf_fc_hw_port_init_args init_args = { 0 };
 337         struct spdk_nvmf_fc_port *fc_port = NULL;
 338         int err;
 339
 340         SPDK_CU_ASSERT_FATAL(g_nvmf_tprt != NULL);
 341
 342         init_args.port_handle = 2;
 343         init_args.io_queue_cnt = spdk_min(MAX_FC_UT_HWQPS, spdk_env_get_core_count());
 344         init_args.ls_queue_size = 100;
 345         init_args.io_queue_size = 100;
 346         init_args.io_queues = (void *)lld_q;
 347
 348         set_thread(0);
 349         err = nvmf_fc_master_enqueue_event(SPDK_FC_HW_PORT_INIT, (void *)&init_args, port_init_cb);
 350         CU_ASSERT(err == 0);
 351         poll_thread(0);
 352
 353         fc_port = nvmf_fc_port_lookup(g_fc_port_handle);
 354         CU_ASSERT(fc_port != NULL);
 355 }
 356
 357 static void
 358 online_fc_port_test(void)
 359 {
 360         struct spdk_nvmf_fc_port *fc_port;
 361         struct spdk_nvmf_fc_hw_port_online_args args;
 362         int err;
 363
 364         SPDK_CU_ASSERT_FATAL(g_nvmf_tprt != NULL);
 365
 366         fc_port = nvmf_fc_port_lookup(g_fc_port_handle);
 367         SPDK_CU_ASSERT_FATAL(fc_port != NULL);
 368
 369         set_thread(0);
 370         args.port_handle = g_fc_port_handle;
 371         err = nvmf_fc_master_enqueue_event(SPDK_FC_HW_PORT_ONLINE, (void *)&args, port_init_cb);
 372         CU_ASSERT(err == 0);
 373         poll_threads();
 374         set_thread(0);
 375         if (err == 0) {
 376                 uint32_t i;
 377                 for (i = 0; i < fc_port->num_io_queues; i++) {
 378                         CU_ASSERT(fc_port->io_queues[i].fgroup != 0);
 379                         CU_ASSERT(fc_port->io_queues[i].fgroup != 0);
 380                         CU_ASSERT(fc_port->io_queues[i].fgroup->hwqp_count != 0);
 381                 }
 382         }
 383 }
 384
 385 static void
 386 create_poll_groups_test(void)
 387 {
 388         unsigned i;
 389
 390         SPDK_CU_ASSERT_FATAL(g_nvmf_tprt != NULL);
 391
 392         for (i = 0; i < MAX_FC_UT_POLL_THREADS; i++) {
 393                 set_thread(i);
 394                 g_poll_groups[i] = spdk_nvmf_poll_group_create(g_nvmf_tgt);
 395                 poll_thread(i);
 396                 CU_ASSERT(g_poll_groups[i] != NULL);
 397         }
 398         set_thread(0);
 399 }
 400
 401 static void
 402 poll_group_poll_test(void)
 403 {
 404         unsigned i;
 405         unsigned poll_cnt =  10;
 406         struct spdk_nvmf_fc_port *fc_port = NULL;
 407
 408         SPDK_CU_ASSERT_FATAL(g_nvmf_tprt != NULL);
 409
 410         set_thread(0);
 411         fc_port = nvmf_fc_port_lookup(g_fc_port_handle);
 412         SPDK_CU_ASSERT_FATAL(fc_port != NULL);
 413
 414         for (i = 0; i < fc_port->num_io_queues; i++) {
 415                 fc_port->io_queues[i].lcore_id = 0;
 416         }
 417
 418         for (i = 0; i < poll_cnt; i++) {
 419                 /* this should cause spdk_nvmf_fc_poll_group_poll to be called() */
 420                 poll_threads();
 421         }
 422
 423         /* check if hwqp's lcore_id has been updated */
 424         for (i = 0; i < fc_port->num_io_queues; i++) {
 425                 CU_ASSERT(fc_port->io_queues[i].lcore_id == poll_cnt);
 426         }
 427 }
 428
 429 static void
 430 remove_hwqps_from_poll_groups_test(void)
 431 {
 432         unsigned i;
 433         struct spdk_nvmf_fc_port *fc_port = NULL;
 434
 435         SPDK_CU_ASSERT_FATAL(g_nvmf_tprt != NULL);
 436
 437         fc_port = nvmf_fc_port_lookup(g_fc_port_handle);
 438         SPDK_CU_ASSERT_FATAL(fc_port != NULL);
 439
 440         for (i = 0; i < fc_port->num_io_queues; i++) {
 441                 nvmf_fc_poll_group_remove_hwqp(&fc_port->io_queues[i]);
 442                 poll_threads();
 443                 CU_ASSERT(fc_port->io_queues[i].fgroup == 0);
 444         }
 445 }
 446
 447 static void
 448 destroy_transport_test(void)
 449 {
 450         unsigned i;
 451
 452         set_thread(0);
 453         SPDK_CU_ASSERT_FATAL(g_nvmf_tprt != NULL);
 454
 455         for (i = 0; i < MAX_FC_UT_POLL_THREADS; i++) {
 456                 set_thread(i);
 457                 spdk_nvmf_poll_group_destroy(g_poll_groups[i], NULL, NULL);
 458                 poll_thread(0);
 459         }
 460
 461         SPDK_CU_ASSERT_FATAL(g_nvmf_tgt != NULL);
 462         g_lld_fini_called = false;
 463         spdk_nvmf_tgt_destroy(g_nvmf_tgt, NULL, NULL);
 464         poll_threads();
 465         CU_ASSERT(g_lld_fini_called == true);
 466 }
 467
 468 static int
 469 nvmf_fc_tests_init(void)
 470 {
 471         return 0;
 472 }
 473
 474 static int
 475 nvmf_fc_tests_fini(void)
 476 {
 477         free_threads();
 478         return 0;
 479 }
 480
 481 int main(int argc, char **argv)
 482 {
 483         unsigned int num_failures = 0;
 484         CU_pSuite suite = NULL;
 485
 486         CU_set_error_action(CUEA_ABORT);
 487         CU_initialize_registry();
 488
 489         suite = CU_add_suite("NVMf-FC", nvmf_fc_tests_init, nvmf_fc_tests_fini);
 490
 491         CU_ADD_TEST(suite, create_transport_test);
 492         CU_ADD_TEST(suite, create_poll_groups_test);
 493         CU_ADD_TEST(suite, create_fc_port_test);
 494         CU_ADD_TEST(suite, online_fc_port_test);
 495         CU_ADD_TEST(suite, poll_group_poll_test);
 496         CU_ADD_TEST(suite, remove_hwqps_from_poll_groups_test);
 497         CU_ADD_TEST(suite, destroy_transport_test);
 498
 499         CU_basic_set_mode(CU_BRM_VERBOSE);
 500         CU_basic_run_tests();
 501         num_failures = CU_get_number_of_failures();
 502         CU_cleanup_registry();
 503
 504         return num_failures;
 505 }