LCOV - code coverage report
Current view: top level - spdk/test/unit/lib/bdev/mt/bdev.c - bdev_ut.c (source / functions) Hit Total Coverage
Test: Combined Lines: 1547 1572 98.4 %
Date: 2024-07-13 06:45:54 Functions: 73 83 88.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 158 263 60.1 %

           Branch data     Line data    Source code
       1                 :            : /*   SPDX-License-Identifier: BSD-3-Clause
       2                 :            :  *   Copyright (C) 2017 Intel Corporation.
       3                 :            :  *   Copyright (c) 2022-2023 NVIDIA CORPORATION & AFFILIATES.
       4                 :            :  *   All rights reserved.
       5                 :            :  */
       6                 :            : 
       7                 :            : #include "spdk_internal/cunit.h"
       8                 :            : 
       9                 :            : #include "common/lib/ut_multithread.c"
      10                 :            : #include "unit/lib/json_mock.c"
      11                 :            : 
      12                 :            : #include "spdk/config.h"
      13                 :            : /* HACK: disable VTune integration so the unit test doesn't need VTune headers and libs to build */
      14                 :            : #undef SPDK_CONFIG_VTUNE
      15                 :            : 
      16                 :            : #include "bdev/bdev.c"
      17                 :            : 
      18                 :            : #define BDEV_UT_NUM_THREADS 3
      19                 :            : 
      20                 :        272 : DEFINE_STUB(spdk_notify_send, uint64_t, (const char *type, const char *ctx), 0);
      21                 :        184 : DEFINE_STUB(spdk_notify_type_register, struct spdk_notify_type *, (const char *type), NULL);
      22                 :          0 : DEFINE_STUB_V(spdk_scsi_nvme_translate, (const struct spdk_bdev_io *bdev_io, int *sc, int *sk,
      23                 :            :                 int *asc, int *ascq));
      24                 :          0 : DEFINE_STUB(spdk_memory_domain_get_dma_device_id, const char *, (struct spdk_memory_domain *domain),
      25                 :            :             "test_domain");
      26                 :          0 : DEFINE_STUB(spdk_memory_domain_get_dma_device_type, enum spdk_dma_device_type,
      27                 :            :             (struct spdk_memory_domain *domain), 0);
      28                 :          0 : DEFINE_STUB_V(spdk_accel_sequence_finish,
      29                 :            :               (struct spdk_accel_sequence *seq, spdk_accel_completion_cb cb_fn, void *cb_arg));
      30                 :          0 : DEFINE_STUB_V(spdk_accel_sequence_abort, (struct spdk_accel_sequence *seq));
      31                 :          0 : DEFINE_STUB_V(spdk_accel_sequence_reverse, (struct spdk_accel_sequence *seq));
      32                 :          0 : DEFINE_STUB(spdk_accel_append_copy, int,
      33                 :            :             (struct spdk_accel_sequence **seq, struct spdk_io_channel *ch, struct iovec *dst_iovs,
      34                 :            :              uint32_t dst_iovcnt, struct spdk_memory_domain *dst_domain, void *dst_domain_ctx,
      35                 :            :              struct iovec *src_iovs, uint32_t src_iovcnt, struct spdk_memory_domain *src_domain,
      36                 :            :              void *src_domain_ctx, int flags, spdk_accel_step_cb cb_fn, void *cb_arg), 0);
      37                 :          0 : DEFINE_STUB(spdk_accel_get_memory_domain, struct spdk_memory_domain *, (void), NULL);
      38                 :            : 
      39                 :            : DEFINE_RETURN_MOCK(spdk_memory_domain_pull_data, int);
      40                 :            : int
      41                 :          0 : spdk_memory_domain_pull_data(struct spdk_memory_domain *src_domain, void *src_domain_ctx,
      42                 :            :                              struct iovec *src_iov, uint32_t src_iov_cnt, struct iovec *dst_iov, uint32_t dst_iov_cnt,
      43                 :            :                              spdk_memory_domain_data_cpl_cb cpl_cb, void *cpl_cb_arg)
      44                 :            : {
      45   [ #  #  #  # ]:          0 :         HANDLE_RETURN_MOCK(spdk_memory_domain_pull_data);
      46                 :            : 
      47                 :          0 :         cpl_cb(cpl_cb_arg, 0);
      48                 :          0 :         return 0;
      49                 :            : }
      50                 :            : 
      51                 :            : DEFINE_RETURN_MOCK(spdk_memory_domain_push_data, int);
      52                 :            : int
      53                 :          0 : spdk_memory_domain_push_data(struct spdk_memory_domain *dst_domain, void *dst_domain_ctx,
      54                 :            :                              struct iovec *dst_iov, uint32_t dst_iovcnt, struct iovec *src_iov, uint32_t src_iovcnt,
      55                 :            :                              spdk_memory_domain_data_cpl_cb cpl_cb, void *cpl_cb_arg)
      56                 :            : {
      57   [ #  #  #  # ]:          0 :         HANDLE_RETURN_MOCK(spdk_memory_domain_push_data);
      58                 :            : 
      59                 :          0 :         cpl_cb(cpl_cb_arg, 0);
      60                 :          0 :         return 0;
      61                 :            : }
      62                 :            : 
      63                 :            : static int g_accel_io_device;
      64                 :            : 
      65                 :            : struct spdk_io_channel *
      66                 :        144 : spdk_accel_get_io_channel(void)
      67                 :            : {
      68                 :        144 :         return spdk_get_io_channel(&g_accel_io_device);
      69                 :            : }
      70                 :            : 
      71                 :            : struct ut_bdev {
      72                 :            :         struct spdk_bdev        bdev;
      73                 :            :         void                    *io_target;
      74                 :            : };
      75                 :            : 
      76                 :            : struct ut_bdev_channel {
      77                 :            :         TAILQ_HEAD(, spdk_bdev_io)      outstanding_io;
      78                 :            :         uint32_t                        outstanding_cnt;
      79                 :            :         uint32_t                        avail_cnt;
      80                 :            :         struct spdk_thread              *thread;
      81                 :            :         TAILQ_ENTRY(ut_bdev_channel)    link;
      82                 :            : };
      83                 :            : 
      84                 :            : int g_io_device;
      85                 :            : struct ut_bdev g_bdev;
      86                 :            : struct spdk_bdev_desc *g_desc;
      87                 :            : bool g_teardown_done = false;
      88                 :            : bool g_get_io_channel = true;
      89                 :            : bool g_create_ch = true;
      90                 :            : bool g_init_complete_called = false;
      91                 :            : bool g_fini_start_called = true;
      92                 :            : int g_status = 0;
      93                 :            : int g_count = 0;
      94                 :            : struct spdk_histogram_data *g_histogram = NULL;
      95                 :            : TAILQ_HEAD(, ut_bdev_channel) g_ut_channels;
      96                 :            : 
      97                 :            : static int
      98                 :        136 : ut_accel_ch_create_cb(void *io_device, void *ctx)
      99                 :            : {
     100                 :        136 :         return 0;
     101                 :            : }
     102                 :            : 
     103                 :            : static void
     104                 :        136 : ut_accel_ch_destroy_cb(void *io_device, void *ctx)
     105                 :            : {
     106                 :        136 : }
     107                 :            : 
     108                 :            : static int
     109                 :        144 : stub_create_ch(void *io_device, void *ctx_buf)
     110                 :            : {
     111                 :        144 :         struct ut_bdev_channel *ch = ctx_buf;
     112                 :            : 
     113   [ +  +  +  + ]:        144 :         if (g_create_ch == false) {
     114                 :          4 :                 return -1;
     115                 :            :         }
     116                 :            : 
     117                 :        140 :         TAILQ_INIT(&ch->outstanding_io);
     118                 :        140 :         ch->outstanding_cnt = 0;
     119                 :            :         /*
     120                 :            :          * When avail gets to 0, the submit_request function will return ENOMEM.
     121                 :            :          *  Most tests to not want ENOMEM to occur, so by default set this to a
     122                 :            :          *  big value that won't get hit.  The ENOMEM tests can then override this
     123                 :            :          *  value to something much smaller to induce ENOMEM conditions.
     124                 :            :          */
     125                 :        140 :         ch->avail_cnt = 2048;
     126                 :        140 :         ch->thread = spdk_get_thread();
     127                 :            : 
     128                 :        140 :         TAILQ_INSERT_TAIL(&g_ut_channels, ch, link);
     129                 :            : 
     130                 :        140 :         return 0;
     131                 :            : }
     132                 :            : 
     133                 :            : static void
     134                 :        140 : stub_destroy_ch(void *io_device, void *ctx_buf)
     135                 :            : {
     136                 :        140 :         struct ut_bdev_channel *ch = ctx_buf;
     137                 :            : 
     138         [ +  + ]:        140 :         TAILQ_REMOVE(&g_ut_channels, ch, link);
     139                 :        140 : }
     140                 :            : 
     141                 :            : static struct spdk_io_channel *
     142                 :        152 : stub_get_io_channel(void *ctx)
     143                 :            : {
     144                 :        152 :         struct ut_bdev *ut_bdev = ctx;
     145                 :            : 
     146   [ +  +  +  + ]:        152 :         if (g_get_io_channel == true) {
     147                 :        148 :                 return spdk_get_io_channel(ut_bdev->io_target);
     148                 :            :         } else {
     149                 :          4 :                 return NULL;
     150                 :            :         }
     151                 :            : }
     152                 :            : 
     153                 :            : static int
     154                 :        136 : stub_destruct(void *ctx)
     155                 :            : {
     156                 :        136 :         return 0;
     157                 :            : }
     158                 :            : 
     159                 :            : static void
     160                 :         44 : stub_reset_channel(void *ctx)
     161                 :            : {
     162                 :         44 :         struct ut_bdev_channel *ch = ctx;
     163                 :            :         struct spdk_bdev_io *io;
     164                 :            : 
     165         [ +  + ]:        124 :         while (!TAILQ_EMPTY(&ch->outstanding_io)) {
     166                 :         80 :                 io = TAILQ_FIRST(&ch->outstanding_io);
     167         [ +  + ]:         80 :                 TAILQ_REMOVE(&ch->outstanding_io, io, module_link);
     168                 :         80 :                 ch->outstanding_cnt--;
     169                 :         80 :                 spdk_bdev_io_complete(io, SPDK_BDEV_IO_STATUS_ABORTED);
     170                 :         80 :                 ch->avail_cnt++;
     171                 :            :         }
     172                 :         44 : }
     173                 :            : 
     174                 :            : static void
     175                 :        568 : stub_submit_request(struct spdk_io_channel *_ch, struct spdk_bdev_io *bdev_io)
     176                 :            : {
     177                 :        568 :         struct ut_bdev_channel *ch = spdk_io_channel_get_ctx(_ch), *tmp_ch;
     178                 :            :         struct spdk_bdev_io *io;
     179                 :            : 
     180         [ +  + ]:        568 :         if (bdev_io->type == SPDK_BDEV_IO_TYPE_RESET) {
     181         [ +  + ]:         76 :                 TAILQ_FOREACH(tmp_ch, &g_ut_channels, link) {
     182         [ +  + ]:         44 :                         if (spdk_get_thread() == tmp_ch->thread) {
     183                 :         32 :                                 stub_reset_channel(tmp_ch);
     184                 :            :                         } else {
     185                 :         12 :                                 spdk_thread_send_msg(tmp_ch->thread, stub_reset_channel, tmp_ch);
     186                 :            :                         }
     187                 :            :                 }
     188         [ +  + ]:        536 :         } else if (bdev_io->type == SPDK_BDEV_IO_TYPE_ABORT) {
     189         [ +  - ]:          8 :                 TAILQ_FOREACH(io, &ch->outstanding_io, module_link) {
     190         [ +  - ]:          8 :                         if (io == bdev_io->u.abort.bio_to_abort) {
     191         [ -  + ]:          8 :                                 TAILQ_REMOVE(&ch->outstanding_io, io, module_link);
     192                 :          8 :                                 ch->outstanding_cnt--;
     193                 :          8 :                                 spdk_bdev_io_complete(io, SPDK_BDEV_IO_STATUS_ABORTED);
     194                 :          8 :                                 ch->avail_cnt++;
     195                 :            : 
     196                 :          8 :                                 spdk_bdev_io_complete(bdev_io, SPDK_BDEV_IO_STATUS_SUCCESS);
     197                 :          8 :                                 return;
     198                 :            :                         }
     199                 :            :                 }
     200                 :            : 
     201                 :          0 :                 spdk_bdev_io_complete(bdev_io, SPDK_BDEV_IO_STATUS_FAILED);
     202                 :          0 :                 return;
     203                 :            :         }
     204                 :            : 
     205         [ +  + ]:        560 :         if (ch->avail_cnt > 0) {
     206                 :        540 :                 TAILQ_INSERT_TAIL(&ch->outstanding_io, bdev_io, module_link);
     207                 :        540 :                 ch->outstanding_cnt++;
     208                 :        540 :                 ch->avail_cnt--;
     209                 :            :         } else {
     210                 :         20 :                 spdk_bdev_io_complete(bdev_io, SPDK_BDEV_IO_STATUS_NOMEM);
     211                 :            :         }
     212                 :            : }
     213                 :            : 
     214                 :            : static uint32_t
     215                 :        216 : stub_complete_io(void *io_target, uint32_t num_to_complete)
     216                 :            : {
     217                 :        216 :         struct spdk_io_channel *_ch = spdk_get_io_channel(io_target);
     218                 :        216 :         struct ut_bdev_channel *ch = spdk_io_channel_get_ctx(_ch);
     219                 :            :         struct spdk_bdev_io *io;
     220                 :        216 :         bool complete_all = (num_to_complete == 0);
     221                 :        216 :         uint32_t num_completed = 0;
     222                 :            : 
     223   [ +  +  +  + ]:        668 :         while (complete_all || num_completed < num_to_complete) {
     224         [ +  + ]:        580 :                 if (TAILQ_EMPTY(&ch->outstanding_io)) {
     225                 :        128 :                         break;
     226                 :            :                 }
     227                 :        452 :                 io = TAILQ_FIRST(&ch->outstanding_io);
     228         [ +  + ]:        452 :                 TAILQ_REMOVE(&ch->outstanding_io, io, module_link);
     229                 :        452 :                 ch->outstanding_cnt--;
     230                 :        452 :                 spdk_bdev_io_complete(io, SPDK_BDEV_IO_STATUS_SUCCESS);
     231                 :        452 :                 ch->avail_cnt++;
     232                 :        452 :                 num_completed++;
     233                 :            :         }
     234                 :        216 :         spdk_put_io_channel(_ch);
     235                 :        216 :         return num_completed;
     236                 :            : }
     237                 :            : 
     238                 :            : static bool
     239                 :        280 : stub_io_type_supported(void *ctx, enum spdk_bdev_io_type type)
     240                 :            : {
     241                 :        280 :         return true;
     242                 :            : }
     243                 :            : 
     244                 :            : static struct spdk_bdev_fn_table fn_table = {
     245                 :            :         .get_io_channel =       stub_get_io_channel,
     246                 :            :         .destruct =             stub_destruct,
     247                 :            :         .submit_request =       stub_submit_request,
     248                 :            :         .io_type_supported =    stub_io_type_supported,
     249                 :            : };
     250                 :            : 
     251                 :            : struct spdk_bdev_module bdev_ut_if;
     252                 :            : 
     253                 :            : static int
     254                 :         92 : module_init(void)
     255                 :            : {
     256                 :         92 :         spdk_bdev_module_init_done(&bdev_ut_if);
     257                 :         92 :         return 0;
     258                 :            : }
     259                 :            : 
     260                 :            : static void
     261                 :         92 : module_fini(void)
     262                 :            : {
     263                 :         92 : }
     264                 :            : 
     265                 :            : static void
     266                 :         92 : init_complete(void)
     267                 :            : {
     268                 :         92 :         g_init_complete_called = true;
     269                 :         92 : }
     270                 :            : 
     271                 :            : static void
     272                 :         92 : fini_start(void)
     273                 :            : {
     274                 :         92 :         g_fini_start_called = true;
     275                 :         92 : }
     276                 :            : 
     277                 :            : struct spdk_bdev_module bdev_ut_if = {
     278                 :            :         .name = "bdev_ut",
     279                 :            :         .module_init = module_init,
     280                 :            :         .module_fini = module_fini,
     281                 :            :         .async_init = true,
     282                 :            :         .init_complete = init_complete,
     283                 :            :         .fini_start = fini_start,
     284                 :            : };
     285                 :            : 
     286                 :          4 : SPDK_BDEV_MODULE_REGISTER(bdev_ut, &bdev_ut_if)
     287                 :            : 
     288                 :            : static void
     289                 :        128 : register_bdev(struct ut_bdev *ut_bdev, char *name, void *io_target)
     290                 :            : {
     291         [ -  + ]:        128 :         memset(ut_bdev, 0, sizeof(*ut_bdev));
     292                 :            : 
     293                 :        128 :         ut_bdev->io_target = io_target;
     294                 :        128 :         ut_bdev->bdev.ctxt = ut_bdev;
     295                 :        128 :         ut_bdev->bdev.name = name;
     296                 :        128 :         ut_bdev->bdev.fn_table = &fn_table;
     297                 :        128 :         ut_bdev->bdev.module = &bdev_ut_if;
     298                 :        128 :         ut_bdev->bdev.blocklen = 4096;
     299                 :        128 :         ut_bdev->bdev.blockcnt = 1024;
     300                 :            : 
     301                 :        128 :         spdk_bdev_register(&ut_bdev->bdev);
     302                 :        128 : }
     303                 :            : 
     304                 :            : static void
     305                 :        116 : unregister_bdev(struct ut_bdev *ut_bdev)
     306                 :            : {
     307                 :            :         /* Handle any deferred messages. */
     308                 :        116 :         poll_threads();
     309                 :        116 :         spdk_bdev_unregister(&ut_bdev->bdev, NULL, NULL);
     310                 :            :         /* Handle the async bdev unregister. */
     311                 :        116 :         poll_threads();
     312                 :        116 : }
     313                 :            : 
     314                 :            : static void
     315                 :         88 : bdev_init_cb(void *done, int rc)
     316                 :            : {
     317                 :         88 :         CU_ASSERT(rc == 0);
     318                 :         88 :         *(bool *)done = true;
     319                 :         88 : }
     320                 :            : 
     321                 :            : static void
     322                 :         20 : _bdev_event_cb(enum spdk_bdev_event_type type, struct spdk_bdev *bdev,
     323                 :            :                void *event_ctx)
     324                 :            : {
     325      [ +  +  - ]:         20 :         switch (type) {
     326                 :         16 :         case SPDK_BDEV_EVENT_REMOVE:
     327         [ +  + ]:         16 :                 if (event_ctx != NULL) {
     328                 :          4 :                         *(bool *)event_ctx = true;
     329                 :            :                 }
     330                 :         16 :                 break;
     331                 :          4 :         case SPDK_BDEV_EVENT_RESIZE:
     332         [ +  - ]:          4 :                 if (event_ctx != NULL) {
     333                 :          4 :                         *(int *)event_ctx += 1;
     334                 :            :                 }
     335                 :          4 :                 break;
     336                 :          0 :         default:
     337                 :          0 :                 CU_ASSERT(false);
     338                 :          0 :                 break;
     339                 :            :         }
     340                 :         20 : }
     341                 :            : 
     342                 :            : static void
     343                 :         88 : setup_test(void)
     344                 :            : {
     345                 :         88 :         bool done = false;
     346                 :            :         int rc;
     347                 :            : 
     348                 :         88 :         TAILQ_INIT(&g_ut_channels);
     349                 :            : 
     350                 :         88 :         allocate_cores(BDEV_UT_NUM_THREADS);
     351                 :         88 :         allocate_threads(BDEV_UT_NUM_THREADS);
     352                 :         88 :         set_thread(0);
     353                 :            : 
     354                 :         88 :         rc = spdk_iobuf_initialize();
     355                 :         88 :         CU_ASSERT(rc == 0);
     356                 :         88 :         spdk_bdev_initialize(bdev_init_cb, &done);
     357                 :         88 :         spdk_io_device_register(&g_io_device, stub_create_ch, stub_destroy_ch,
     358                 :            :                                 sizeof(struct ut_bdev_channel), NULL);
     359                 :         88 :         spdk_io_device_register(&g_accel_io_device, ut_accel_ch_create_cb,
     360                 :            :                                 ut_accel_ch_destroy_cb, 0, NULL);
     361                 :         88 :         register_bdev(&g_bdev, "ut_bdev", &g_io_device);
     362                 :         88 :         spdk_bdev_open_ext("ut_bdev", true, _bdev_event_cb, NULL, &g_desc);
     363                 :         88 : }
     364                 :            : 
     365                 :            : static void
     366                 :        180 : finish_cb(void *cb_arg)
     367                 :            : {
     368                 :        180 :         g_teardown_done = true;
     369                 :        180 : }
     370                 :            : 
     371                 :            : static void
     372                 :         84 : teardown_test(void)
     373                 :            : {
     374                 :         84 :         set_thread(0);
     375                 :         84 :         g_teardown_done = false;
     376                 :         84 :         spdk_bdev_close(g_desc);
     377                 :         84 :         g_desc = NULL;
     378                 :         84 :         unregister_bdev(&g_bdev);
     379                 :         84 :         spdk_io_device_unregister(&g_io_device, NULL);
     380                 :         84 :         spdk_bdev_finish(finish_cb, NULL);
     381                 :         84 :         spdk_io_device_unregister(&g_accel_io_device, NULL);
     382                 :         84 :         spdk_iobuf_finish(finish_cb, NULL);
     383                 :         84 :         poll_threads();
     384         [ -  + ]:         84 :         memset(&g_bdev, 0, sizeof(g_bdev));
     385         [ -  + ]:         84 :         CU_ASSERT(g_teardown_done == true);
     386                 :         84 :         g_teardown_done = false;
     387                 :         84 :         free_threads();
     388                 :         84 :         free_cores();
     389                 :         84 :         CU_ASSERT(TAILQ_EMPTY(&g_ut_channels))
     390                 :         84 : }
     391                 :            : 
     392                 :            : static uint32_t
     393                 :         28 : bdev_io_tailq_cnt(bdev_io_tailq_t *tailq)
     394                 :            : {
     395                 :            :         struct spdk_bdev_io *io;
     396                 :         28 :         uint32_t cnt = 0;
     397                 :            : 
     398         [ +  + ]:       1000 :         TAILQ_FOREACH(io, tailq, internal.link) {
     399                 :        972 :                 cnt++;
     400                 :            :         }
     401                 :            : 
     402                 :         28 :         return cnt;
     403                 :            : }
     404                 :            : 
     405                 :            : static void
     406                 :          4 : basic(void)
     407                 :            : {
     408                 :          4 :         g_init_complete_called = false;
     409                 :          4 :         setup_test();
     410         [ -  + ]:          4 :         CU_ASSERT(g_init_complete_called == true);
     411                 :            : 
     412                 :          4 :         set_thread(0);
     413                 :            : 
     414                 :          4 :         g_get_io_channel = false;
     415                 :          4 :         g_ut_threads[0].ch = spdk_bdev_get_io_channel(g_desc);
     416                 :          4 :         CU_ASSERT(g_ut_threads[0].ch == NULL);
     417                 :            : 
     418                 :          4 :         g_get_io_channel = true;
     419                 :          4 :         g_create_ch = false;
     420                 :          4 :         g_ut_threads[0].ch = spdk_bdev_get_io_channel(g_desc);
     421                 :          4 :         CU_ASSERT(g_ut_threads[0].ch == NULL);
     422                 :            : 
     423                 :          4 :         g_get_io_channel = true;
     424                 :          4 :         g_create_ch = true;
     425                 :          4 :         g_ut_threads[0].ch = spdk_bdev_get_io_channel(g_desc);
     426                 :          4 :         CU_ASSERT(g_ut_threads[0].ch != NULL);
     427                 :          4 :         spdk_put_io_channel(g_ut_threads[0].ch);
     428                 :            : 
     429                 :          4 :         g_fini_start_called = false;
     430                 :          4 :         teardown_test();
     431         [ -  + ]:          4 :         CU_ASSERT(g_fini_start_called == true);
     432                 :          4 : }
     433                 :            : 
     434                 :            : static void
     435                 :         20 : _bdev_unregistered(void *done, int rc)
     436                 :            : {
     437                 :         20 :         CU_ASSERT(rc == 0);
     438                 :         20 :         *(bool *)done = true;
     439                 :         20 : }
     440                 :            : 
     441                 :            : static void
     442                 :          4 : unregister_and_close(void)
     443                 :            : {
     444                 :          4 :         bool done, remove_notify;
     445                 :          4 :         struct spdk_bdev_desc *desc = NULL;
     446                 :            : 
     447                 :          4 :         setup_test();
     448                 :          4 :         set_thread(0);
     449                 :            : 
     450                 :            :         /* setup_test() automatically opens the bdev,
     451                 :            :          * but this test needs to do that in a different
     452                 :            :          * way. */
     453                 :          4 :         spdk_bdev_close(g_desc);
     454                 :          4 :         poll_threads();
     455                 :            : 
     456                 :            :         /* Try hotremoving a bdev with descriptors which don't provide
     457                 :            :          * any context to the notification callback */
     458                 :          4 :         spdk_bdev_open_ext("ut_bdev", true, _bdev_event_cb, NULL, &desc);
     459         [ -  + ]:          4 :         SPDK_CU_ASSERT_FATAL(desc != NULL);
     460                 :            : 
     461                 :            :         /* There is an open descriptor on the device. Unregister it,
     462                 :            :          * which can't proceed until the descriptor is closed. */
     463                 :          4 :         done = false;
     464                 :          4 :         spdk_bdev_unregister(&g_bdev.bdev, _bdev_unregistered, &done);
     465                 :            : 
     466                 :            :         /* Poll the threads to allow all events to be processed */
     467                 :          4 :         poll_threads();
     468                 :            : 
     469                 :            :         /* Make sure the bdev was not unregistered. We still have a
     470                 :            :          * descriptor open */
     471         [ -  + ]:          4 :         CU_ASSERT(done == false);
     472                 :            : 
     473                 :          4 :         spdk_bdev_close(desc);
     474                 :          4 :         poll_threads();
     475                 :          4 :         desc = NULL;
     476                 :            : 
     477                 :            :         /* The unregister should have completed */
     478         [ -  + ]:          4 :         CU_ASSERT(done == true);
     479                 :            : 
     480                 :            : 
     481                 :            :         /* Register the bdev again */
     482                 :          4 :         register_bdev(&g_bdev, "ut_bdev", &g_io_device);
     483                 :            : 
     484                 :          4 :         remove_notify = false;
     485                 :          4 :         spdk_bdev_open_ext("ut_bdev", true, _bdev_event_cb, &remove_notify, &desc);
     486         [ -  + ]:          4 :         SPDK_CU_ASSERT_FATAL(desc != NULL);
     487         [ -  + ]:          4 :         CU_ASSERT(remove_notify == false);
     488                 :            : 
     489                 :            :         /* There is an open descriptor on the device. Unregister it,
     490                 :            :          * which can't proceed until the descriptor is closed. */
     491                 :          4 :         done = false;
     492                 :          4 :         spdk_bdev_unregister(&g_bdev.bdev, _bdev_unregistered, &done);
     493                 :            :         /* No polling has occurred, so neither of these should execute */
     494         [ -  + ]:          4 :         CU_ASSERT(remove_notify == false);
     495         [ -  + ]:          4 :         CU_ASSERT(done == false);
     496                 :            : 
     497                 :            :         /* Prior to the unregister completing, close the descriptor */
     498                 :          4 :         spdk_bdev_close(desc);
     499                 :            : 
     500                 :            :         /* Poll the threads to allow all events to be processed */
     501                 :          4 :         poll_threads();
     502                 :            : 
     503                 :            :         /* Remove notify should not have been called because the
     504                 :            :          * descriptor is already closed. */
     505         [ -  + ]:          4 :         CU_ASSERT(remove_notify == false);
     506                 :            : 
     507                 :            :         /* The unregister should have completed */
     508         [ -  + ]:          4 :         CU_ASSERT(done == true);
     509                 :            : 
     510                 :            :         /* Restore the original g_bdev so that we can use teardown_test(). */
     511                 :          4 :         register_bdev(&g_bdev, "ut_bdev", &g_io_device);
     512                 :          4 :         spdk_bdev_open_ext("ut_bdev", true, _bdev_event_cb, NULL, &g_desc);
     513                 :          4 :         teardown_test();
     514                 :          4 : }
     515                 :            : 
     516                 :            : static void
     517                 :          4 : unregister_and_close_different_threads(void)
     518                 :            : {
     519                 :          4 :         bool done;
     520                 :          4 :         struct spdk_bdev_desc *desc = NULL;
     521                 :            : 
     522                 :          4 :         setup_test();
     523                 :          4 :         set_thread(0);
     524                 :            : 
     525                 :            :         /* setup_test() automatically opens the bdev,
     526                 :            :          * but this test needs to do that in a different
     527                 :            :          * way. */
     528                 :          4 :         spdk_bdev_close(g_desc);
     529                 :          4 :         poll_threads();
     530                 :            : 
     531                 :          4 :         set_thread(1);
     532                 :          4 :         spdk_bdev_open_ext("ut_bdev", true, _bdev_event_cb, NULL, &desc);
     533         [ -  + ]:          4 :         SPDK_CU_ASSERT_FATAL(desc != NULL);
     534                 :          4 :         done = false;
     535                 :            : 
     536                 :          4 :         set_thread(0);
     537                 :          4 :         spdk_bdev_unregister(&g_bdev.bdev, _bdev_unregistered, &done);
     538                 :            : 
     539                 :            :         /* Poll the threads to allow all events to be processed */
     540                 :          4 :         poll_threads();
     541                 :            : 
     542                 :            :         /* Make sure the bdev was not unregistered. We still have a
     543                 :            :          * descriptor open */
     544         [ -  + ]:          4 :         CU_ASSERT(done == false);
     545                 :            : 
     546                 :            :         /* Close the descriptor on thread 1.  Poll the thread and confirm the
     547                 :            :          * unregister did not complete, since it was unregistered on thread 0.
     548                 :            :          */
     549                 :          4 :         set_thread(1);
     550                 :          4 :         spdk_bdev_close(desc);
     551                 :          4 :         poll_thread(1);
     552         [ -  + ]:          4 :         CU_ASSERT(done == false);
     553                 :            : 
     554                 :            :         /* Now poll thread 0 and confirm the unregister completed. */
     555                 :          4 :         set_thread(0);
     556                 :          4 :         poll_thread(0);
     557         [ -  + ]:          4 :         CU_ASSERT(done == true);
     558                 :            : 
     559                 :            :         /* Restore the original g_bdev so that we can use teardown_test(). */
     560                 :          4 :         register_bdev(&g_bdev, "ut_bdev", &g_io_device);
     561                 :          4 :         spdk_bdev_open_ext("ut_bdev", true, _bdev_event_cb, NULL, &g_desc);
     562                 :          4 :         teardown_test();
     563                 :          4 : }
     564                 :            : 
     565                 :            : static void
     566                 :          8 : reset_done(struct spdk_bdev_io *bdev_io, bool success, void *cb_arg)
     567                 :            : {
     568                 :          8 :         bool *done = cb_arg;
     569                 :            : 
     570                 :          8 :         CU_ASSERT(success == true);
     571                 :          8 :         *done = true;
     572                 :          8 :         spdk_bdev_free_io(bdev_io);
     573                 :          8 : }
     574                 :            : 
     575                 :            : static void
     576                 :          4 : put_channel_during_reset(void)
     577                 :            : {
     578                 :            :         struct spdk_io_channel *io_ch;
     579                 :          4 :         bool done = false;
     580                 :            : 
     581                 :          4 :         setup_test();
     582                 :            : 
     583                 :          4 :         set_thread(0);
     584                 :          4 :         io_ch = spdk_bdev_get_io_channel(g_desc);
     585                 :          4 :         CU_ASSERT(io_ch != NULL);
     586                 :            : 
     587                 :            :         /*
     588                 :            :          * Start a reset, but then put the I/O channel before
     589                 :            :          *  the deferred messages for the reset get a chance to
     590                 :            :          *  execute.
     591                 :            :          */
     592                 :          4 :         spdk_bdev_reset(g_desc, io_ch, reset_done, &done);
     593                 :          4 :         spdk_put_io_channel(io_ch);
     594                 :          4 :         poll_threads();
     595                 :          4 :         stub_complete_io(g_bdev.io_target, 0);
     596                 :            : 
     597                 :          4 :         teardown_test();
     598                 :          4 : }
     599                 :            : 
     600                 :            : static void
     601                 :         16 : aborted_reset_done(struct spdk_bdev_io *bdev_io, bool success, void *cb_arg)
     602                 :            : {
     603                 :         16 :         enum spdk_bdev_io_status *status = cb_arg;
     604                 :            : 
     605         [ +  + ]:         16 :         *status = success ? SPDK_BDEV_IO_STATUS_SUCCESS : SPDK_BDEV_IO_STATUS_FAILED;
     606                 :         16 :         spdk_bdev_free_io(bdev_io);
     607                 :         16 : }
     608                 :            : 
     609                 :            : static void io_done(struct spdk_bdev_io *bdev_io, bool success, void *cb_arg);
     610                 :            : 
     611                 :            : static void
     612                 :          4 : aborted_reset(void)
     613                 :            : {
     614                 :            :         struct spdk_io_channel *io_ch[2];
     615                 :          4 :         enum spdk_bdev_io_status status1 = SPDK_BDEV_IO_STATUS_PENDING,
     616                 :          4 :                                  status2 = SPDK_BDEV_IO_STATUS_PENDING;
     617                 :            : 
     618                 :          4 :         setup_test();
     619                 :            : 
     620                 :          4 :         set_thread(0);
     621                 :          4 :         io_ch[0] = spdk_bdev_get_io_channel(g_desc);
     622                 :          4 :         CU_ASSERT(io_ch[0] != NULL);
     623                 :          4 :         spdk_bdev_reset(g_desc, io_ch[0], aborted_reset_done, &status1);
     624                 :          4 :         poll_threads();
     625                 :          4 :         CU_ASSERT(g_bdev.bdev.internal.reset_in_progress != NULL);
     626                 :            : 
     627                 :            :         /*
     628                 :            :          * First reset has been submitted on ch0.  Now submit a second
     629                 :            :          *  reset on ch1 which will get queued since there is already a
     630                 :            :          *  reset in progress.
     631                 :            :          */
     632                 :          4 :         set_thread(1);
     633                 :          4 :         io_ch[1] = spdk_bdev_get_io_channel(g_desc);
     634                 :          4 :         CU_ASSERT(io_ch[1] != NULL);
     635                 :          4 :         spdk_bdev_reset(g_desc, io_ch[1], aborted_reset_done, &status2);
     636                 :          4 :         poll_threads();
     637                 :          4 :         CU_ASSERT(g_bdev.bdev.internal.reset_in_progress != NULL);
     638                 :            : 
     639                 :            :         /*
     640                 :            :          * Now destroy ch1.  This will abort the queued reset.  Check that
     641                 :            :          *  the second reset was completed with failed status.  Also check
     642                 :            :          *  that bdev->internal.reset_in_progress != NULL, since the
     643                 :            :          *  original reset has not been completed yet.  This ensures that
     644                 :            :          *  the bdev code is correctly noticing that the failed reset is
     645                 :            :          *  *not* the one that had been submitted to the bdev module.
     646                 :            :          */
     647                 :          4 :         set_thread(1);
     648                 :          4 :         spdk_put_io_channel(io_ch[1]);
     649                 :          4 :         poll_threads();
     650                 :          4 :         CU_ASSERT(status2 == SPDK_BDEV_IO_STATUS_FAILED);
     651                 :          4 :         CU_ASSERT(g_bdev.bdev.internal.reset_in_progress != NULL);
     652                 :            : 
     653                 :            :         /*
     654                 :            :          * Now complete the first reset, verify that it completed with SUCCESS
     655                 :            :          *  status and that bdev->internal.reset_in_progress is also set back to NULL.
     656                 :            :          */
     657                 :          4 :         set_thread(0);
     658                 :          4 :         spdk_put_io_channel(io_ch[0]);
     659                 :          4 :         stub_complete_io(g_bdev.io_target, 0);
     660                 :          4 :         poll_threads();
     661                 :          4 :         CU_ASSERT(status1 == SPDK_BDEV_IO_STATUS_SUCCESS);
     662                 :          4 :         CU_ASSERT(g_bdev.bdev.internal.reset_in_progress == NULL);
     663                 :            : 
     664                 :          4 :         teardown_test();
     665                 :          4 : }
     666                 :            : 
     667                 :            : static void
     668                 :          4 : aborted_reset_no_outstanding_io(void)
     669                 :            : {
     670                 :            :         struct spdk_io_channel *io_ch[2];
     671                 :            :         struct spdk_bdev_channel *bdev_ch[2];
     672                 :            :         struct spdk_bdev *bdev[2];
     673                 :          4 :         enum spdk_bdev_io_status status1 = SPDK_BDEV_IO_STATUS_PENDING,
     674                 :          4 :                                  status2 = SPDK_BDEV_IO_STATUS_PENDING;
     675                 :            : 
     676                 :          4 :         setup_test();
     677                 :            : 
     678                 :            :         /*
     679                 :            :          * This time we test the reset without any outstanding IO
     680                 :            :          * present on the bdev channel, so both resets should finish
     681                 :            :          * immediately.
     682                 :            :          */
     683                 :            : 
     684                 :          4 :         set_thread(0);
     685                 :            :         /* Set reset_io_drain_timeout to allow bdev
     686                 :            :          * reset to stay pending until we call abort. */
     687                 :          4 :         io_ch[0] = spdk_bdev_get_io_channel(g_desc);
     688                 :          4 :         bdev_ch[0] = spdk_io_channel_get_ctx(io_ch[0]);
     689                 :          4 :         bdev[0] = bdev_ch[0]->bdev;
     690                 :          4 :         bdev[0]->reset_io_drain_timeout = SPDK_BDEV_RESET_IO_DRAIN_RECOMMENDED_VALUE;
     691                 :          4 :         CU_ASSERT(io_ch[0] != NULL);
     692                 :          4 :         spdk_bdev_reset(g_desc, io_ch[0], aborted_reset_done, &status1);
     693                 :          4 :         poll_threads();
     694                 :          4 :         CU_ASSERT(g_bdev.bdev.internal.reset_in_progress == NULL);
     695                 :          4 :         CU_ASSERT(status1 == SPDK_BDEV_IO_STATUS_SUCCESS);
     696                 :          4 :         spdk_put_io_channel(io_ch[0]);
     697                 :            : 
     698                 :          4 :         set_thread(1);
     699                 :            :         /* Set reset_io_drain_timeout to allow bdev
     700                 :            :          * reset to stay pending until we call abort. */
     701                 :          4 :         io_ch[1] = spdk_bdev_get_io_channel(g_desc);
     702                 :          4 :         bdev_ch[1] = spdk_io_channel_get_ctx(io_ch[1]);
     703                 :          4 :         bdev[1] = bdev_ch[1]->bdev;
     704                 :          4 :         bdev[1]->reset_io_drain_timeout = SPDK_BDEV_RESET_IO_DRAIN_RECOMMENDED_VALUE;
     705                 :          4 :         CU_ASSERT(io_ch[1] != NULL);
     706                 :          4 :         spdk_bdev_reset(g_desc, io_ch[1], aborted_reset_done, &status2);
     707                 :          4 :         poll_threads();
     708                 :          4 :         CU_ASSERT(g_bdev.bdev.internal.reset_in_progress == NULL);
     709                 :          4 :         CU_ASSERT(status2 == SPDK_BDEV_IO_STATUS_SUCCESS);
     710                 :          4 :         spdk_put_io_channel(io_ch[1]);
     711                 :            : 
     712                 :          4 :         stub_complete_io(g_bdev.io_target, 0);
     713                 :          4 :         poll_threads();
     714                 :            : 
     715                 :          4 :         teardown_test();
     716                 :          4 : }
     717                 :            : 
     718                 :            : 
     719                 :            : static void
     720                 :        148 : io_during_io_done(struct spdk_bdev_io *bdev_io, bool success, void *cb_arg)
     721                 :            : {
     722                 :        148 :         enum spdk_bdev_io_status *status = cb_arg;
     723                 :            : 
     724                 :        148 :         *status = bdev_io->internal.status;
     725                 :        148 :         spdk_bdev_free_io(bdev_io);
     726                 :        148 : }
     727                 :            : 
     728                 :            : static void
     729                 :          4 : io_during_reset(void)
     730                 :            : {
     731                 :            :         struct spdk_io_channel *io_ch[2];
     732                 :            :         struct spdk_bdev_channel *bdev_ch[2];
     733                 :          4 :         enum spdk_bdev_io_status status0, status1, status_reset;
     734                 :            :         int rc;
     735                 :            : 
     736                 :          4 :         setup_test();
     737                 :            : 
     738                 :            :         /*
     739                 :            :          * First test normal case - submit an I/O on each of two channels (with no resets)
     740                 :            :          *  and verify they complete successfully.
     741                 :            :          */
     742                 :          4 :         set_thread(0);
     743                 :          4 :         io_ch[0] = spdk_bdev_get_io_channel(g_desc);
     744                 :          4 :         bdev_ch[0] = spdk_io_channel_get_ctx(io_ch[0]);
     745                 :          4 :         CU_ASSERT(bdev_ch[0]->flags == 0);
     746                 :          4 :         status0 = SPDK_BDEV_IO_STATUS_PENDING;
     747                 :          4 :         rc = spdk_bdev_read_blocks(g_desc, io_ch[0], NULL, 0, 1, io_during_io_done, &status0);
     748                 :          4 :         CU_ASSERT(rc == 0);
     749                 :            : 
     750                 :          4 :         set_thread(1);
     751                 :          4 :         io_ch[1] = spdk_bdev_get_io_channel(g_desc);
     752                 :          4 :         bdev_ch[1] = spdk_io_channel_get_ctx(io_ch[1]);
     753                 :          4 :         CU_ASSERT(bdev_ch[1]->flags == 0);
     754                 :          4 :         status1 = SPDK_BDEV_IO_STATUS_PENDING;
     755                 :          4 :         rc = spdk_bdev_read_blocks(g_desc, io_ch[1], NULL, 0, 1, io_during_io_done, &status1);
     756                 :          4 :         CU_ASSERT(rc == 0);
     757                 :            : 
     758                 :          4 :         poll_threads();
     759                 :          4 :         CU_ASSERT(status0 == SPDK_BDEV_IO_STATUS_PENDING);
     760                 :          4 :         CU_ASSERT(status1 == SPDK_BDEV_IO_STATUS_PENDING);
     761                 :            : 
     762                 :          4 :         set_thread(0);
     763                 :          4 :         stub_complete_io(g_bdev.io_target, 0);
     764                 :          4 :         CU_ASSERT(status0 == SPDK_BDEV_IO_STATUS_SUCCESS);
     765                 :            : 
     766                 :          4 :         set_thread(1);
     767                 :          4 :         stub_complete_io(g_bdev.io_target, 0);
     768                 :          4 :         CU_ASSERT(status1 == SPDK_BDEV_IO_STATUS_SUCCESS);
     769                 :            : 
     770                 :            :         /*
     771                 :            :          * Now submit a reset, and leave it pending while we submit I/O on two different
     772                 :            :          *  channels.  These I/O should be failed by the bdev layer since the reset is in
     773                 :            :          *  progress.
     774                 :            :          */
     775                 :          4 :         set_thread(0);
     776                 :          4 :         status_reset = SPDK_BDEV_IO_STATUS_PENDING;
     777                 :          4 :         rc = spdk_bdev_reset(g_desc, io_ch[0], io_during_io_done, &status_reset);
     778                 :          4 :         CU_ASSERT(rc == 0);
     779                 :            : 
     780                 :          4 :         CU_ASSERT(bdev_ch[0]->flags == 0);
     781                 :          4 :         CU_ASSERT(bdev_ch[1]->flags == 0);
     782                 :          4 :         poll_threads();
     783                 :          4 :         CU_ASSERT(bdev_ch[0]->flags == BDEV_CH_RESET_IN_PROGRESS);
     784                 :          4 :         CU_ASSERT(bdev_ch[1]->flags == BDEV_CH_RESET_IN_PROGRESS);
     785                 :            : 
     786                 :          4 :         set_thread(0);
     787                 :          4 :         status0 = SPDK_BDEV_IO_STATUS_PENDING;
     788                 :          4 :         rc = spdk_bdev_read_blocks(g_desc, io_ch[0], NULL, 0, 1, io_during_io_done, &status0);
     789                 :          4 :         CU_ASSERT(rc == 0);
     790                 :            : 
     791                 :          4 :         set_thread(1);
     792                 :          4 :         status1 = SPDK_BDEV_IO_STATUS_PENDING;
     793                 :          4 :         rc = spdk_bdev_read_blocks(g_desc, io_ch[1], NULL, 0, 1, io_during_io_done, &status1);
     794                 :          4 :         CU_ASSERT(rc == 0);
     795                 :            : 
     796                 :            :         /*
     797                 :            :          * A reset is in progress so these read I/O should complete with aborted.  Note that we
     798                 :            :          *  need to poll_threads() since I/O completed inline have their completion deferred.
     799                 :            :          */
     800                 :          4 :         poll_threads();
     801                 :          4 :         CU_ASSERT(status_reset == SPDK_BDEV_IO_STATUS_PENDING);
     802                 :          4 :         CU_ASSERT(status0 == SPDK_BDEV_IO_STATUS_ABORTED);
     803                 :          4 :         CU_ASSERT(status1 == SPDK_BDEV_IO_STATUS_ABORTED);
     804                 :            : 
     805                 :            :         /*
     806                 :            :          * Complete the reset
     807                 :            :          */
     808                 :          4 :         set_thread(0);
     809                 :          4 :         stub_complete_io(g_bdev.io_target, 0);
     810                 :            : 
     811                 :            :         /*
     812                 :            :          * Only poll thread 0. We should not get a completion.
     813                 :            :          */
     814                 :          4 :         poll_thread(0);
     815                 :          4 :         CU_ASSERT(status_reset == SPDK_BDEV_IO_STATUS_PENDING);
     816                 :            : 
     817                 :            :         /*
     818                 :            :          * Poll both thread 0 and 1 so the messages can propagate and we
     819                 :            :          * get a completion.
     820                 :            :          */
     821                 :          4 :         poll_threads();
     822                 :          4 :         CU_ASSERT(status_reset == SPDK_BDEV_IO_STATUS_SUCCESS);
     823                 :            : 
     824                 :          4 :         spdk_put_io_channel(io_ch[0]);
     825                 :          4 :         set_thread(1);
     826                 :          4 :         spdk_put_io_channel(io_ch[1]);
     827                 :          4 :         poll_threads();
     828                 :            : 
     829                 :          4 :         teardown_test();
     830                 :          4 : }
     831                 :            : 
     832                 :            : static uint32_t
     833                 :         56 : count_queued_resets(void *io_target)
     834                 :            : {
     835                 :         56 :         struct spdk_io_channel *_ch = spdk_get_io_channel(io_target);
     836                 :         56 :         struct ut_bdev_channel *ch = spdk_io_channel_get_ctx(_ch);
     837                 :            :         struct spdk_bdev_io *io;
     838                 :         56 :         uint32_t submitted_resets = 0;
     839                 :            : 
     840         [ +  + ]:        100 :         TAILQ_FOREACH(io, &ch->outstanding_io, module_link) {
     841         [ +  + ]:         44 :                 if (io->type == SPDK_BDEV_IO_TYPE_RESET) {
     842                 :          8 :                         submitted_resets++;
     843                 :            :                 }
     844                 :            :         }
     845                 :            : 
     846                 :         56 :         spdk_put_io_channel(_ch);
     847                 :            : 
     848                 :         56 :         return submitted_resets;
     849                 :            : }
     850                 :            : 
     851                 :            : static void
     852                 :          4 : reset_completions(void)
     853                 :            : {
     854                 :            :         struct spdk_io_channel *io_ch;
     855                 :            :         struct spdk_bdev_channel *bdev_ch;
     856                 :            :         struct spdk_bdev *bdev;
     857                 :          4 :         enum spdk_bdev_io_status status0, status_reset;
     858                 :            :         int rc, iter;
     859                 :            : 
     860                 :          4 :         setup_test();
     861                 :            : 
     862                 :            :         /* This test covers four test cases:
     863                 :            :          * 1) reset_io_drain_timeout of a bdev is greater than 0
     864                 :            :          * 2) No outstandind IO are present on any bdev channel
     865                 :            :          * 3) Outstanding IO finish during bdev reset
     866                 :            :          * 4) Outstanding IO do not finish before reset is done waiting
     867                 :            :          *    for them.
     868                 :            :          *
     869                 :            :          * Above conditions mainly affect the timing of bdev reset completion
     870                 :            :          * and whether a reset should be skipped via spdk_bdev_io_complete()
     871                 :            :          * or sent down to the underlying bdev module via bdev_io_submit_reset(). */
     872                 :            : 
     873                 :            :         /* Test preparation */
     874                 :          4 :         set_thread(0);
     875                 :          4 :         io_ch = spdk_bdev_get_io_channel(g_desc);
     876                 :          4 :         bdev_ch = spdk_io_channel_get_ctx(io_ch);
     877                 :          4 :         CU_ASSERT(bdev_ch->flags == 0);
     878                 :            : 
     879                 :            : 
     880                 :            :         /* Test case 1) reset_io_drain_timeout set to 0. Reset should be sent down immediately. */
     881                 :          4 :         bdev = &g_bdev.bdev;
     882                 :          4 :         bdev->reset_io_drain_timeout = 0;
     883                 :            : 
     884                 :          4 :         status_reset = SPDK_BDEV_IO_STATUS_PENDING;
     885                 :          4 :         rc = spdk_bdev_reset(g_desc, io_ch, io_during_io_done, &status_reset);
     886                 :          4 :         CU_ASSERT(rc == 0);
     887                 :          4 :         poll_threads();
     888                 :          4 :         CU_ASSERT(count_queued_resets(g_bdev.io_target) == 1);
     889                 :            : 
     890                 :            :         /* Call reset completion inside bdev module. */
     891                 :          4 :         stub_complete_io(g_bdev.io_target, 0);
     892                 :          4 :         poll_threads();
     893                 :          4 :         CU_ASSERT(count_queued_resets(g_bdev.io_target) == 0);
     894                 :          4 :         CU_ASSERT(status_reset == SPDK_BDEV_IO_STATUS_SUCCESS);
     895                 :          4 :         CU_ASSERT(g_bdev.bdev.internal.reset_in_progress == NULL);
     896                 :            : 
     897                 :            : 
     898                 :            :         /* Test case 2) no outstanding IO are present. Reset should perform one iteration over
     899                 :            :         * channels and then be skipped. */
     900                 :          4 :         bdev->reset_io_drain_timeout = SPDK_BDEV_RESET_IO_DRAIN_RECOMMENDED_VALUE;
     901                 :          4 :         status_reset = SPDK_BDEV_IO_STATUS_PENDING;
     902                 :            : 
     903                 :          4 :         rc = spdk_bdev_reset(g_desc, io_ch, io_during_io_done, &status_reset);
     904                 :          4 :         CU_ASSERT(rc == 0);
     905                 :          4 :         poll_threads();
     906                 :            :         /* Reset was never submitted to the bdev module. */
     907                 :          4 :         CU_ASSERT(count_queued_resets(g_bdev.io_target) == 0);
     908                 :          4 :         CU_ASSERT(status_reset == SPDK_BDEV_IO_STATUS_SUCCESS);
     909                 :          4 :         CU_ASSERT(g_bdev.bdev.internal.reset_in_progress == NULL);
     910                 :            : 
     911                 :            : 
     912                 :            :         /* Test case 3) outstanding IO finish during bdev reset procedure. Reset should initiate
     913                 :            :         * wait poller to check for IO completions every second, until reset_io_drain_timeout is
     914                 :            :         * reached, but finish earlier than this threshold. */
     915                 :          4 :         status0 = SPDK_BDEV_IO_STATUS_PENDING;
     916                 :          4 :         status_reset = SPDK_BDEV_IO_STATUS_PENDING;
     917                 :          4 :         rc = spdk_bdev_read_blocks(g_desc, io_ch, NULL, 0, 1, io_during_io_done, &status0);
     918                 :          4 :         CU_ASSERT(rc == 0);
     919                 :            : 
     920                 :          4 :         rc = spdk_bdev_reset(g_desc, io_ch, io_during_io_done, &status_reset);
     921                 :          4 :         CU_ASSERT(rc == 0);
     922                 :          4 :         poll_threads();
     923                 :            :         /* The reset just started and should not have been submitted yet. */
     924                 :          4 :         CU_ASSERT(count_queued_resets(g_bdev.io_target) == 0);
     925                 :            : 
     926                 :          4 :         poll_threads();
     927                 :          4 :         CU_ASSERT(status_reset == SPDK_BDEV_IO_STATUS_PENDING);
     928                 :            :         /* Let the poller wait for about half the time then complete outstanding IO. */
     929         [ +  + ]:         12 :         for (iter = 0; iter < 2; iter++) {
     930                 :            :                 /* Reset is still processing and not submitted at this point. */
     931                 :          8 :                 CU_ASSERT(count_queued_resets(g_bdev.io_target) == 0);
     932                 :          8 :                 spdk_delay_us(1000 * 1000);
     933                 :          8 :                 poll_threads();
     934                 :          8 :                 poll_threads();
     935                 :            :         }
     936                 :          4 :         CU_ASSERT(status_reset == SPDK_BDEV_IO_STATUS_PENDING);
     937                 :          4 :         stub_complete_io(g_bdev.io_target, 0);
     938                 :          4 :         poll_threads();
     939                 :          4 :         spdk_delay_us(BDEV_RESET_CHECK_OUTSTANDING_IO_PERIOD);
     940                 :          4 :         poll_threads();
     941                 :          4 :         poll_threads();
     942                 :          4 :         CU_ASSERT(status_reset == SPDK_BDEV_IO_STATUS_SUCCESS);
     943                 :            :         /* Sending reset to the bdev module has been skipped. */
     944                 :          4 :         CU_ASSERT(count_queued_resets(g_bdev.io_target) == 0);
     945                 :          4 :         CU_ASSERT(g_bdev.bdev.internal.reset_in_progress == NULL);
     946                 :            : 
     947                 :            : 
     948                 :            :         /* Test case 4) outstanding IO are still present after reset_io_drain_timeout
     949                 :            :         * seconds have passed. */
     950                 :          4 :         status0 = SPDK_BDEV_IO_STATUS_PENDING;
     951                 :          4 :         status_reset = SPDK_BDEV_IO_STATUS_PENDING;
     952                 :          4 :         rc = spdk_bdev_read_blocks(g_desc, io_ch, NULL, 0, 1, io_during_io_done, &status0);
     953                 :          4 :         CU_ASSERT(rc == 0);
     954                 :            : 
     955                 :          4 :         rc = spdk_bdev_reset(g_desc, io_ch, io_during_io_done, &status_reset);
     956                 :          4 :         CU_ASSERT(rc == 0);
     957                 :          4 :         poll_threads();
     958                 :            :         /* The reset just started and should not have been submitted yet. */
     959                 :          4 :         CU_ASSERT(count_queued_resets(g_bdev.io_target) == 0);
     960                 :            : 
     961                 :          4 :         poll_threads();
     962                 :          4 :         CU_ASSERT(status_reset == SPDK_BDEV_IO_STATUS_PENDING);
     963                 :            :         /* Let the poller wait for reset_io_drain_timeout seconds. */
     964         [ +  + ]:         24 :         for (iter = 0; iter < bdev->reset_io_drain_timeout; iter++) {
     965                 :         20 :                 CU_ASSERT(count_queued_resets(g_bdev.io_target) == 0);
     966                 :         20 :                 spdk_delay_us(BDEV_RESET_CHECK_OUTSTANDING_IO_PERIOD);
     967                 :         20 :                 poll_threads();
     968                 :         20 :                 poll_threads();
     969                 :            :         }
     970                 :            : 
     971                 :            :         /* After timing out, the reset should have been sent to the module. */
     972                 :          4 :         CU_ASSERT(count_queued_resets(g_bdev.io_target) == 1);
     973                 :            :         /* Complete reset submitted to the module and the read IO. */
     974                 :          4 :         stub_complete_io(g_bdev.io_target, 0);
     975                 :          4 :         poll_threads();
     976                 :          4 :         CU_ASSERT(status_reset == SPDK_BDEV_IO_STATUS_SUCCESS);
     977                 :          4 :         CU_ASSERT(g_bdev.bdev.internal.reset_in_progress == NULL);
     978                 :            : 
     979                 :            : 
     980                 :            :         /* Destroy the channel and end the test. */
     981                 :          4 :         spdk_put_io_channel(io_ch);
     982                 :          4 :         poll_threads();
     983                 :            : 
     984                 :          4 :         teardown_test();
     985                 :          4 : }
     986                 :            : 
     987                 :            : 
     988                 :            : static void
     989                 :          4 : basic_qos(void)
     990                 :            : {
     991                 :            :         struct spdk_io_channel *io_ch[2];
     992                 :            :         struct spdk_bdev_channel *bdev_ch[2];
     993                 :            :         struct spdk_bdev *bdev;
     994                 :          4 :         enum spdk_bdev_io_status status, abort_status;
     995                 :            :         int rc;
     996                 :            : 
     997                 :          4 :         setup_test();
     998                 :            : 
     999                 :            :         /* Enable QoS */
    1000                 :          4 :         bdev = &g_bdev.bdev;
    1001                 :          4 :         bdev->internal.qos = calloc(1, sizeof(*bdev->internal.qos));
    1002         [ -  + ]:          4 :         SPDK_CU_ASSERT_FATAL(bdev->internal.qos != NULL);
    1003                 :            :         /*
    1004                 :            :          * Enable read/write IOPS, read only byte per second and
    1005                 :            :          * read/write byte per second rate limits.
    1006                 :            :          * In this case, all rate limits will take equal effect.
    1007                 :            :          */
    1008                 :            :         /* 2000 read/write I/O per second, or 2 per millisecond */
    1009                 :          4 :         bdev->internal.qos->rate_limits[SPDK_BDEV_QOS_RW_IOPS_RATE_LIMIT].limit = 2000;
    1010                 :            :         /* 8K read/write byte per millisecond with 4K block size */
    1011                 :          4 :         bdev->internal.qos->rate_limits[SPDK_BDEV_QOS_RW_BPS_RATE_LIMIT].limit = 8192000;
    1012                 :            :         /* 8K read only byte per millisecond with 4K block size */
    1013                 :          4 :         bdev->internal.qos->rate_limits[SPDK_BDEV_QOS_R_BPS_RATE_LIMIT].limit = 8192000;
    1014                 :            : 
    1015                 :          4 :         g_get_io_channel = true;
    1016                 :            : 
    1017                 :          4 :         set_thread(0);
    1018                 :          4 :         io_ch[0] = spdk_bdev_get_io_channel(g_desc);
    1019                 :          4 :         bdev_ch[0] = spdk_io_channel_get_ctx(io_ch[0]);
    1020                 :          4 :         CU_ASSERT(bdev_ch[0]->flags == BDEV_CH_QOS_ENABLED);
    1021                 :            : 
    1022                 :          4 :         set_thread(1);
    1023                 :          4 :         io_ch[1] = spdk_bdev_get_io_channel(g_desc);
    1024                 :          4 :         bdev_ch[1] = spdk_io_channel_get_ctx(io_ch[1]);
    1025                 :          4 :         CU_ASSERT(bdev_ch[1]->flags == BDEV_CH_QOS_ENABLED);
    1026                 :            : 
    1027                 :            :         /*
    1028                 :            :          * Send an I/O on thread 0, which is where the QoS thread is running.
    1029                 :            :          */
    1030                 :          4 :         set_thread(0);
    1031                 :          4 :         status = SPDK_BDEV_IO_STATUS_PENDING;
    1032                 :          4 :         rc = spdk_bdev_read_blocks(g_desc, io_ch[0], NULL, 0, 1, io_during_io_done, &status);
    1033                 :          4 :         CU_ASSERT(rc == 0);
    1034                 :          4 :         CU_ASSERT(status == SPDK_BDEV_IO_STATUS_PENDING);
    1035                 :          4 :         poll_threads();
    1036                 :          4 :         stub_complete_io(g_bdev.io_target, 0);
    1037                 :          4 :         poll_threads();
    1038                 :          4 :         CU_ASSERT(status == SPDK_BDEV_IO_STATUS_SUCCESS);
    1039                 :            : 
    1040                 :            :         /* Send an I/O on thread 1. The QoS thread is not running here. */
    1041                 :          4 :         status = SPDK_BDEV_IO_STATUS_PENDING;
    1042                 :          4 :         set_thread(1);
    1043                 :          4 :         rc = spdk_bdev_read_blocks(g_desc, io_ch[1], NULL, 0, 1, io_during_io_done, &status);
    1044                 :          4 :         CU_ASSERT(rc == 0);
    1045                 :          4 :         CU_ASSERT(status == SPDK_BDEV_IO_STATUS_PENDING);
    1046                 :          4 :         poll_threads();
    1047                 :            :         /* Complete I/O on thread 0. This should not complete the I/O we submitted. */
    1048                 :          4 :         set_thread(0);
    1049                 :          4 :         stub_complete_io(g_bdev.io_target, 0);
    1050                 :          4 :         poll_threads();
    1051                 :          4 :         CU_ASSERT(status == SPDK_BDEV_IO_STATUS_PENDING);
    1052                 :            :         /* Now complete I/O on original thread 1. */
    1053                 :          4 :         set_thread(1);
    1054                 :          4 :         poll_threads();
    1055                 :          4 :         stub_complete_io(g_bdev.io_target, 0);
    1056                 :          4 :         poll_threads();
    1057                 :          4 :         CU_ASSERT(status == SPDK_BDEV_IO_STATUS_SUCCESS);
    1058                 :            : 
    1059                 :            :         /* Reset rate limit for the next test cases. */
    1060                 :          4 :         spdk_delay_us(SPDK_BDEV_QOS_TIMESLICE_IN_USEC);
    1061                 :          4 :         poll_threads();
    1062                 :            : 
    1063                 :            :         /*
    1064                 :            :          * Test abort request when QoS is enabled.
    1065                 :            :          */
    1066                 :            : 
    1067                 :            :         /* Send an I/O on thread 0, which is where the QoS thread is running. */
    1068                 :          4 :         set_thread(0);
    1069                 :          4 :         status = SPDK_BDEV_IO_STATUS_PENDING;
    1070                 :          4 :         rc = spdk_bdev_read_blocks(g_desc, io_ch[0], NULL, 0, 1, io_during_io_done, &status);
    1071                 :          4 :         CU_ASSERT(rc == 0);
    1072                 :          4 :         CU_ASSERT(status == SPDK_BDEV_IO_STATUS_PENDING);
    1073                 :            :         /* Send an abort to the I/O on the same thread. */
    1074                 :          4 :         abort_status = SPDK_BDEV_IO_STATUS_PENDING;
    1075                 :          4 :         rc = spdk_bdev_abort(g_desc, io_ch[0], &status, io_during_io_done, &abort_status);
    1076                 :          4 :         CU_ASSERT(rc == 0);
    1077                 :          4 :         CU_ASSERT(abort_status == SPDK_BDEV_IO_STATUS_PENDING);
    1078                 :          4 :         poll_threads();
    1079                 :          4 :         CU_ASSERT(abort_status == SPDK_BDEV_IO_STATUS_SUCCESS);
    1080                 :          4 :         CU_ASSERT(status == SPDK_BDEV_IO_STATUS_ABORTED);
    1081                 :            : 
    1082                 :            :         /* Send an I/O on thread 1. The QoS thread is not running here. */
    1083                 :          4 :         status = SPDK_BDEV_IO_STATUS_PENDING;
    1084                 :          4 :         set_thread(1);
    1085                 :          4 :         rc = spdk_bdev_read_blocks(g_desc, io_ch[1], NULL, 0, 1, io_during_io_done, &status);
    1086                 :          4 :         CU_ASSERT(rc == 0);
    1087                 :          4 :         CU_ASSERT(status == SPDK_BDEV_IO_STATUS_PENDING);
    1088                 :          4 :         poll_threads();
    1089                 :            :         /* Send an abort to the I/O on the same thread. */
    1090                 :          4 :         abort_status = SPDK_BDEV_IO_STATUS_PENDING;
    1091                 :          4 :         rc = spdk_bdev_abort(g_desc, io_ch[1], &status, io_during_io_done, &abort_status);
    1092                 :          4 :         CU_ASSERT(rc == 0);
    1093                 :          4 :         CU_ASSERT(abort_status == SPDK_BDEV_IO_STATUS_PENDING);
    1094                 :          4 :         poll_threads();
    1095                 :            :         /* Complete the I/O with failure and the abort with success on thread 1. */
    1096                 :          4 :         CU_ASSERT(abort_status == SPDK_BDEV_IO_STATUS_SUCCESS);
    1097                 :          4 :         CU_ASSERT(status == SPDK_BDEV_IO_STATUS_ABORTED);
    1098                 :            : 
    1099                 :          4 :         set_thread(0);
    1100                 :            : 
    1101                 :            :         /*
    1102                 :            :          * Close the descriptor only, which should stop the qos channel as
    1103                 :            :          * the last descriptor removed.
    1104                 :            :          */
    1105                 :          4 :         spdk_bdev_close(g_desc);
    1106                 :          4 :         poll_threads();
    1107                 :          4 :         CU_ASSERT(bdev->internal.qos->ch == NULL);
    1108                 :            : 
    1109                 :            :         /*
    1110                 :            :          * Open the bdev again which shall setup the qos channel as the
    1111                 :            :          * channels are valid.
    1112                 :            :          */
    1113                 :          4 :         spdk_bdev_open_ext("ut_bdev", true, _bdev_event_cb, NULL, &g_desc);
    1114                 :          4 :         poll_threads();
    1115                 :          4 :         CU_ASSERT(bdev->internal.qos->ch != NULL);
    1116                 :            : 
    1117                 :            :         /* Tear down the channels */
    1118                 :          4 :         set_thread(0);
    1119                 :          4 :         spdk_put_io_channel(io_ch[0]);
    1120                 :          4 :         set_thread(1);
    1121                 :          4 :         spdk_put_io_channel(io_ch[1]);
    1122                 :          4 :         poll_threads();
    1123                 :          4 :         set_thread(0);
    1124                 :            : 
    1125                 :            :         /* Close the descriptor, which should stop the qos channel */
    1126                 :          4 :         spdk_bdev_close(g_desc);
    1127                 :          4 :         poll_threads();
    1128                 :          4 :         CU_ASSERT(bdev->internal.qos->ch == NULL);
    1129                 :            : 
    1130                 :            :         /* Open the bdev again, no qos channel setup without valid channels. */
    1131                 :          4 :         spdk_bdev_open_ext("ut_bdev", true, _bdev_event_cb, NULL, &g_desc);
    1132                 :          4 :         poll_threads();
    1133                 :          4 :         CU_ASSERT(bdev->internal.qos->ch == NULL);
    1134                 :            : 
    1135                 :            :         /* Create the channels in reverse order. */
    1136                 :          4 :         set_thread(1);
    1137                 :          4 :         io_ch[1] = spdk_bdev_get_io_channel(g_desc);
    1138                 :          4 :         bdev_ch[1] = spdk_io_channel_get_ctx(io_ch[1]);
    1139                 :          4 :         CU_ASSERT(bdev_ch[1]->flags == BDEV_CH_QOS_ENABLED);
    1140                 :            : 
    1141                 :          4 :         set_thread(0);
    1142                 :          4 :         io_ch[0] = spdk_bdev_get_io_channel(g_desc);
    1143                 :          4 :         bdev_ch[0] = spdk_io_channel_get_ctx(io_ch[0]);
    1144                 :          4 :         CU_ASSERT(bdev_ch[0]->flags == BDEV_CH_QOS_ENABLED);
    1145                 :            : 
    1146                 :            :         /* Confirm that the qos thread is now thread 1 */
    1147                 :          4 :         CU_ASSERT(bdev->internal.qos->ch == bdev_ch[1]);
    1148                 :            : 
    1149                 :            :         /* Tear down the channels */
    1150                 :          4 :         set_thread(0);
    1151                 :          4 :         spdk_put_io_channel(io_ch[0]);
    1152                 :          4 :         set_thread(1);
    1153                 :          4 :         spdk_put_io_channel(io_ch[1]);
    1154                 :          4 :         poll_threads();
    1155                 :            : 
    1156                 :          4 :         set_thread(0);
    1157                 :            : 
    1158                 :          4 :         teardown_test();
    1159                 :          4 : }
    1160                 :            : 
    1161                 :            : static void
    1162                 :          4 : io_during_qos_queue(void)
    1163                 :            : {
    1164                 :            :         struct spdk_io_channel *io_ch[2];
    1165                 :            :         struct spdk_bdev_channel *bdev_ch[2];
    1166                 :            :         struct spdk_bdev *bdev;
    1167                 :          4 :         enum spdk_bdev_io_status status0, status1, status2;
    1168                 :            :         int rc;
    1169                 :            : 
    1170                 :          4 :         setup_test();
    1171                 :          4 :         MOCK_SET(spdk_get_ticks, 0);
    1172                 :            : 
    1173                 :            :         /* Enable QoS */
    1174                 :          4 :         bdev = &g_bdev.bdev;
    1175                 :          4 :         bdev->internal.qos = calloc(1, sizeof(*bdev->internal.qos));
    1176         [ -  + ]:          4 :         SPDK_CU_ASSERT_FATAL(bdev->internal.qos != NULL);
    1177                 :            : 
    1178                 :            :         /*
    1179                 :            :          * Enable read/write IOPS, read only byte per sec, write only
    1180                 :            :          * byte per sec and read/write byte per sec rate limits.
    1181                 :            :          * In this case, both read only and write only byte per sec
    1182                 :            :          * rate limit will take effect.
    1183                 :            :          */
    1184                 :            :         /* 4000 read/write I/O per second, or 4 per millisecond */
    1185                 :          4 :         bdev->internal.qos->rate_limits[SPDK_BDEV_QOS_RW_IOPS_RATE_LIMIT].limit = 4000;
    1186                 :            :         /* 8K byte per millisecond with 4K block size */
    1187                 :          4 :         bdev->internal.qos->rate_limits[SPDK_BDEV_QOS_RW_BPS_RATE_LIMIT].limit = 8192000;
    1188                 :            :         /* 4K byte per millisecond with 4K block size */
    1189                 :          4 :         bdev->internal.qos->rate_limits[SPDK_BDEV_QOS_R_BPS_RATE_LIMIT].limit = 4096000;
    1190                 :            :         /* 4K byte per millisecond with 4K block size */
    1191                 :          4 :         bdev->internal.qos->rate_limits[SPDK_BDEV_QOS_W_BPS_RATE_LIMIT].limit = 4096000;
    1192                 :            : 
    1193                 :          4 :         g_get_io_channel = true;
    1194                 :            : 
    1195                 :            :         /* Create channels */
    1196                 :          4 :         set_thread(0);
    1197                 :          4 :         io_ch[0] = spdk_bdev_get_io_channel(g_desc);
    1198                 :          4 :         bdev_ch[0] = spdk_io_channel_get_ctx(io_ch[0]);
    1199                 :          4 :         CU_ASSERT(bdev_ch[0]->flags == BDEV_CH_QOS_ENABLED);
    1200                 :            : 
    1201                 :          4 :         set_thread(1);
    1202                 :          4 :         io_ch[1] = spdk_bdev_get_io_channel(g_desc);
    1203                 :          4 :         bdev_ch[1] = spdk_io_channel_get_ctx(io_ch[1]);
    1204                 :          4 :         CU_ASSERT(bdev_ch[1]->flags == BDEV_CH_QOS_ENABLED);
    1205                 :            : 
    1206                 :            :         /* Send two read I/Os */
    1207                 :          4 :         status1 = SPDK_BDEV_IO_STATUS_PENDING;
    1208                 :          4 :         rc = spdk_bdev_read_blocks(g_desc, io_ch[1], NULL, 0, 1, io_during_io_done, &status1);
    1209                 :          4 :         CU_ASSERT(rc == 0);
    1210                 :          4 :         CU_ASSERT(status1 == SPDK_BDEV_IO_STATUS_PENDING);
    1211                 :          4 :         set_thread(0);
    1212                 :          4 :         status0 = SPDK_BDEV_IO_STATUS_PENDING;
    1213                 :          4 :         rc = spdk_bdev_read_blocks(g_desc, io_ch[0], NULL, 0, 1, io_during_io_done, &status0);
    1214                 :          4 :         CU_ASSERT(rc == 0);
    1215                 :          4 :         CU_ASSERT(status0 == SPDK_BDEV_IO_STATUS_PENDING);
    1216                 :            :         /* Send one write I/O */
    1217                 :          4 :         status2 = SPDK_BDEV_IO_STATUS_PENDING;
    1218                 :          4 :         rc = spdk_bdev_write_blocks(g_desc, io_ch[0], NULL, 0, 1, io_during_io_done, &status2);
    1219                 :          4 :         CU_ASSERT(rc == 0);
    1220                 :          4 :         CU_ASSERT(status2 == SPDK_BDEV_IO_STATUS_PENDING);
    1221                 :            : 
    1222                 :            :         /* Complete any I/O that arrived at the disk */
    1223                 :          4 :         poll_threads();
    1224                 :          4 :         set_thread(1);
    1225                 :          4 :         stub_complete_io(g_bdev.io_target, 0);
    1226                 :          4 :         set_thread(0);
    1227                 :          4 :         stub_complete_io(g_bdev.io_target, 0);
    1228                 :          4 :         poll_threads();
    1229                 :            : 
    1230                 :            :         /* Only one of the two read I/Os should complete. (logical XOR) */
    1231         [ -  + ]:          4 :         if (status0 == SPDK_BDEV_IO_STATUS_SUCCESS) {
    1232                 :          0 :                 CU_ASSERT(status1 == SPDK_BDEV_IO_STATUS_PENDING);
    1233                 :            :         } else {
    1234                 :          4 :                 CU_ASSERT(status1 == SPDK_BDEV_IO_STATUS_SUCCESS);
    1235                 :            :         }
    1236                 :            :         /* The write I/O should complete. */
    1237                 :          4 :         CU_ASSERT(status2 == SPDK_BDEV_IO_STATUS_SUCCESS);
    1238                 :            : 
    1239                 :            :         /* Advance in time by a millisecond */
    1240                 :          4 :         spdk_delay_us(1000);
    1241                 :            : 
    1242                 :            :         /* Complete more I/O */
    1243                 :          4 :         poll_threads();
    1244                 :          4 :         set_thread(1);
    1245                 :          4 :         stub_complete_io(g_bdev.io_target, 0);
    1246                 :          4 :         set_thread(0);
    1247                 :          4 :         stub_complete_io(g_bdev.io_target, 0);
    1248                 :          4 :         poll_threads();
    1249                 :            : 
    1250                 :            :         /* Now the second read I/O should be done */
    1251                 :          4 :         CU_ASSERT(status0 == SPDK_BDEV_IO_STATUS_SUCCESS);
    1252                 :          4 :         CU_ASSERT(status1 == SPDK_BDEV_IO_STATUS_SUCCESS);
    1253                 :            : 
    1254                 :            :         /* Tear down the channels */
    1255                 :          4 :         set_thread(1);
    1256                 :          4 :         spdk_put_io_channel(io_ch[1]);
    1257                 :          4 :         set_thread(0);
    1258                 :          4 :         spdk_put_io_channel(io_ch[0]);
    1259                 :          4 :         poll_threads();
    1260                 :            : 
    1261                 :          4 :         teardown_test();
    1262                 :          4 : }
    1263                 :            : 
    1264                 :            : static void
    1265                 :          4 : io_during_qos_reset(void)
    1266                 :            : {
    1267                 :            :         struct spdk_io_channel *io_ch[2];
    1268                 :            :         struct spdk_bdev_channel *bdev_ch[2];
    1269                 :            :         struct spdk_bdev *bdev;
    1270                 :          4 :         enum spdk_bdev_io_status status0, status1, reset_status;
    1271                 :            :         int rc;
    1272                 :            : 
    1273                 :          4 :         setup_test();
    1274                 :          4 :         MOCK_SET(spdk_get_ticks, 0);
    1275                 :            : 
    1276                 :            :         /* Enable QoS */
    1277                 :          4 :         bdev = &g_bdev.bdev;
    1278                 :          4 :         bdev->internal.qos = calloc(1, sizeof(*bdev->internal.qos));
    1279         [ -  + ]:          4 :         SPDK_CU_ASSERT_FATAL(bdev->internal.qos != NULL);
    1280                 :            : 
    1281                 :            :         /*
    1282                 :            :          * Enable read/write IOPS, write only byte per sec and
    1283                 :            :          * read/write byte per second rate limits.
    1284                 :            :          * In this case, read/write byte per second rate limit will
    1285                 :            :          * take effect first.
    1286                 :            :          */
    1287                 :            :         /* 2000 read/write I/O per second, or 2 per millisecond */
    1288                 :          4 :         bdev->internal.qos->rate_limits[SPDK_BDEV_QOS_RW_IOPS_RATE_LIMIT].limit = 2000;
    1289                 :            :         /* 4K byte per millisecond with 4K block size */
    1290                 :          4 :         bdev->internal.qos->rate_limits[SPDK_BDEV_QOS_RW_BPS_RATE_LIMIT].limit = 4096000;
    1291                 :            :         /* 8K byte per millisecond with 4K block size */
    1292                 :          4 :         bdev->internal.qos->rate_limits[SPDK_BDEV_QOS_W_BPS_RATE_LIMIT].limit = 8192000;
    1293                 :            : 
    1294                 :          4 :         g_get_io_channel = true;
    1295                 :            : 
    1296                 :            :         /* Create channels */
    1297                 :          4 :         set_thread(0);
    1298                 :          4 :         io_ch[0] = spdk_bdev_get_io_channel(g_desc);
    1299                 :          4 :         bdev_ch[0] = spdk_io_channel_get_ctx(io_ch[0]);
    1300                 :          4 :         CU_ASSERT(bdev_ch[0]->flags == BDEV_CH_QOS_ENABLED);
    1301                 :            : 
    1302                 :          4 :         set_thread(1);
    1303                 :          4 :         io_ch[1] = spdk_bdev_get_io_channel(g_desc);
    1304                 :          4 :         bdev_ch[1] = spdk_io_channel_get_ctx(io_ch[1]);
    1305                 :          4 :         CU_ASSERT(bdev_ch[1]->flags == BDEV_CH_QOS_ENABLED);
    1306                 :            : 
    1307                 :            :         /* Send two I/O. One of these gets queued by QoS. The other is sitting at the disk. */
    1308                 :          4 :         status1 = SPDK_BDEV_IO_STATUS_PENDING;
    1309                 :          4 :         rc = spdk_bdev_write_blocks(g_desc, io_ch[1], NULL, 0, 1, io_during_io_done, &status1);
    1310                 :          4 :         CU_ASSERT(rc == 0);
    1311                 :          4 :         set_thread(0);
    1312                 :          4 :         status0 = SPDK_BDEV_IO_STATUS_PENDING;
    1313                 :          4 :         rc = spdk_bdev_write_blocks(g_desc, io_ch[0], NULL, 0, 1, io_during_io_done, &status0);
    1314                 :          4 :         CU_ASSERT(rc == 0);
    1315                 :            : 
    1316                 :          4 :         poll_threads();
    1317                 :          4 :         CU_ASSERT(status1 == SPDK_BDEV_IO_STATUS_PENDING);
    1318                 :          4 :         CU_ASSERT(status0 == SPDK_BDEV_IO_STATUS_PENDING);
    1319                 :            : 
    1320                 :            :         /* Reset the bdev. */
    1321                 :          4 :         reset_status = SPDK_BDEV_IO_STATUS_PENDING;
    1322                 :          4 :         rc = spdk_bdev_reset(g_desc, io_ch[0], io_during_io_done, &reset_status);
    1323                 :          4 :         CU_ASSERT(rc == 0);
    1324                 :            : 
    1325                 :            :         /* Complete any I/O that arrived at the disk */
    1326                 :          4 :         poll_threads();
    1327                 :          4 :         set_thread(1);
    1328                 :          4 :         stub_complete_io(g_bdev.io_target, 0);
    1329                 :          4 :         set_thread(0);
    1330                 :          4 :         stub_complete_io(g_bdev.io_target, 0);
    1331                 :          4 :         poll_threads();
    1332                 :            : 
    1333                 :          4 :         CU_ASSERT(reset_status == SPDK_BDEV_IO_STATUS_SUCCESS);
    1334                 :          4 :         CU_ASSERT(status0 == SPDK_BDEV_IO_STATUS_ABORTED);
    1335                 :          4 :         CU_ASSERT(status1 == SPDK_BDEV_IO_STATUS_ABORTED);
    1336                 :            : 
    1337                 :            :         /* Tear down the channels */
    1338                 :          4 :         set_thread(1);
    1339                 :          4 :         spdk_put_io_channel(io_ch[1]);
    1340                 :          4 :         set_thread(0);
    1341                 :          4 :         spdk_put_io_channel(io_ch[0]);
    1342                 :          4 :         poll_threads();
    1343                 :            : 
    1344                 :          4 :         teardown_test();
    1345                 :          4 : }
    1346                 :            : 
    1347                 :            : static void
    1348                 :        516 : enomem_done(struct spdk_bdev_io *bdev_io, bool success, void *cb_arg)
    1349                 :            : {
    1350                 :        516 :         enum spdk_bdev_io_status *status = cb_arg;
    1351                 :            : 
    1352         [ +  + ]:        516 :         *status = success ? SPDK_BDEV_IO_STATUS_SUCCESS : SPDK_BDEV_IO_STATUS_FAILED;
    1353                 :        516 :         spdk_bdev_free_io(bdev_io);
    1354                 :        516 : }
    1355                 :            : 
    1356                 :            : static void
    1357                 :          4 : enomem(void)
    1358                 :          4 : {
    1359                 :            :         struct spdk_io_channel *io_ch;
    1360                 :            :         struct spdk_bdev_channel *bdev_ch;
    1361                 :            :         struct spdk_bdev_shared_resource *shared_resource;
    1362                 :            :         struct ut_bdev_channel *ut_ch;
    1363                 :          4 :         const uint32_t IO_ARRAY_SIZE = 64;
    1364                 :          4 :         const uint32_t AVAIL = 20;
    1365         [ -  + ]:          4 :         enum spdk_bdev_io_status status[IO_ARRAY_SIZE], status_reset;
    1366                 :            :         uint32_t nomem_cnt, i;
    1367                 :            :         struct spdk_bdev_io *first_io;
    1368                 :            :         int rc;
    1369                 :            : 
    1370                 :          4 :         setup_test();
    1371                 :            : 
    1372                 :          4 :         set_thread(0);
    1373                 :          4 :         io_ch = spdk_bdev_get_io_channel(g_desc);
    1374                 :          4 :         bdev_ch = spdk_io_channel_get_ctx(io_ch);
    1375                 :          4 :         shared_resource = bdev_ch->shared_resource;
    1376                 :          4 :         ut_ch = spdk_io_channel_get_ctx(bdev_ch->channel);
    1377                 :          4 :         ut_ch->avail_cnt = AVAIL;
    1378                 :            : 
    1379                 :            :         /* First submit a number of IOs equal to what the channel can support. */
    1380         [ +  + ]:         84 :         for (i = 0; i < AVAIL; i++) {
    1381                 :         80 :                 status[i] = SPDK_BDEV_IO_STATUS_PENDING;
    1382                 :         80 :                 rc = spdk_bdev_read_blocks(g_desc, io_ch, NULL, 0, 1, enomem_done, &status[i]);
    1383                 :         80 :                 CU_ASSERT(rc == 0);
    1384                 :            :         }
    1385                 :          4 :         CU_ASSERT(TAILQ_EMPTY(&shared_resource->nomem_io));
    1386                 :            : 
    1387                 :            :         /*
    1388                 :            :          * Next, submit one additional I/O.  This one should fail with ENOMEM and then go onto
    1389                 :            :          *  the enomem_io list.
    1390                 :            :          */
    1391                 :          4 :         status[AVAIL] = SPDK_BDEV_IO_STATUS_PENDING;
    1392                 :          4 :         rc = spdk_bdev_read_blocks(g_desc, io_ch, NULL, 0, 1, enomem_done, &status[AVAIL]);
    1393                 :          4 :         CU_ASSERT(rc == 0);
    1394         [ -  + ]:          4 :         SPDK_CU_ASSERT_FATAL(!TAILQ_EMPTY(&shared_resource->nomem_io));
    1395                 :          4 :         first_io = TAILQ_FIRST(&shared_resource->nomem_io);
    1396                 :            : 
    1397                 :            :         /*
    1398                 :            :          * Now submit a bunch more I/O.  These should all fail with ENOMEM and get queued behind
    1399                 :            :          *  the first_io above.
    1400                 :            :          */
    1401         [ +  + ]:        176 :         for (i = AVAIL + 1; i < IO_ARRAY_SIZE; i++) {
    1402                 :        172 :                 status[i] = SPDK_BDEV_IO_STATUS_PENDING;
    1403                 :        172 :                 rc = spdk_bdev_read_blocks(g_desc, io_ch, NULL, 0, 1, enomem_done, &status[i]);
    1404                 :        172 :                 CU_ASSERT(rc == 0);
    1405                 :            :         }
    1406                 :            : 
    1407                 :            :         /* Assert that first_io is still at the head of the list. */
    1408                 :          4 :         CU_ASSERT(TAILQ_FIRST(&shared_resource->nomem_io) == first_io);
    1409                 :          4 :         CU_ASSERT(bdev_io_tailq_cnt(&shared_resource->nomem_io) == (IO_ARRAY_SIZE - AVAIL));
    1410                 :          4 :         nomem_cnt = bdev_io_tailq_cnt(&shared_resource->nomem_io);
    1411                 :          4 :         CU_ASSERT(shared_resource->nomem_threshold == (AVAIL - NOMEM_THRESHOLD_COUNT));
    1412                 :            : 
    1413                 :            :         /*
    1414                 :            :          * Complete 1 I/O only.  The key check here is bdev_io_tailq_cnt - this should not have
    1415                 :            :          *  changed since completing just 1 I/O should not trigger retrying the queued nomem_io
    1416                 :            :          *  list.
    1417                 :            :          */
    1418                 :          4 :         stub_complete_io(g_bdev.io_target, 1);
    1419                 :          4 :         CU_ASSERT(bdev_io_tailq_cnt(&shared_resource->nomem_io) == nomem_cnt);
    1420                 :            : 
    1421                 :            :         /*
    1422                 :            :          * Complete enough I/O to hit the nomem_threshold.  This should trigger retrying nomem_io,
    1423                 :            :          *  and we should see I/O get resubmitted to the test bdev module.
    1424                 :            :          */
    1425                 :          4 :         stub_complete_io(g_bdev.io_target, NOMEM_THRESHOLD_COUNT - 1);
    1426                 :          4 :         CU_ASSERT(bdev_io_tailq_cnt(&shared_resource->nomem_io) < nomem_cnt);
    1427                 :          4 :         nomem_cnt = bdev_io_tailq_cnt(&shared_resource->nomem_io);
    1428                 :            : 
    1429                 :            :         /* Complete 1 I/O only.  This should not trigger retrying the queued nomem_io. */
    1430                 :          4 :         stub_complete_io(g_bdev.io_target, 1);
    1431                 :          4 :         CU_ASSERT(bdev_io_tailq_cnt(&shared_resource->nomem_io) == nomem_cnt);
    1432                 :            : 
    1433                 :            :         /*
    1434                 :            :          * Send a reset and confirm that all I/O are completed, including the ones that
    1435                 :            :          *  were queued on the nomem_io list.
    1436                 :            :          */
    1437                 :          4 :         status_reset = SPDK_BDEV_IO_STATUS_PENDING;
    1438                 :          4 :         rc = spdk_bdev_reset(g_desc, io_ch, enomem_done, &status_reset);
    1439                 :          4 :         poll_threads();
    1440                 :          4 :         CU_ASSERT(rc == 0);
    1441                 :            :         /* This will complete the reset. */
    1442                 :          4 :         stub_complete_io(g_bdev.io_target, 0);
    1443                 :            : 
    1444                 :          4 :         CU_ASSERT(bdev_io_tailq_cnt(&shared_resource->nomem_io) == 0);
    1445                 :          4 :         CU_ASSERT(shared_resource->io_outstanding == 0);
    1446                 :            : 
    1447                 :          4 :         spdk_put_io_channel(io_ch);
    1448                 :          4 :         poll_threads();
    1449                 :          4 :         teardown_test();
    1450                 :          4 : }
    1451                 :            : 
    1452                 :            : static void
    1453                 :          4 : enomem_multi_bdev(void)
    1454                 :          4 : {
    1455                 :            :         struct spdk_io_channel *io_ch;
    1456                 :            :         struct spdk_bdev_channel *bdev_ch;
    1457                 :            :         struct spdk_bdev_shared_resource *shared_resource;
    1458                 :            :         struct ut_bdev_channel *ut_ch;
    1459                 :          4 :         const uint32_t IO_ARRAY_SIZE = 64;
    1460                 :          4 :         const uint32_t AVAIL = 20;
    1461         [ -  + ]:          4 :         enum spdk_bdev_io_status status[IO_ARRAY_SIZE];
    1462                 :            :         uint32_t i;
    1463                 :            :         struct ut_bdev *second_bdev;
    1464                 :          4 :         struct spdk_bdev_desc *second_desc = NULL;
    1465                 :            :         struct spdk_bdev_channel *second_bdev_ch;
    1466                 :            :         struct spdk_io_channel *second_ch;
    1467                 :            :         int rc;
    1468                 :            : 
    1469                 :          4 :         setup_test();
    1470                 :            : 
    1471                 :            :         /* Register second bdev with the same io_target  */
    1472                 :          4 :         second_bdev = calloc(1, sizeof(*second_bdev));
    1473         [ -  + ]:          4 :         SPDK_CU_ASSERT_FATAL(second_bdev != NULL);
    1474                 :          4 :         register_bdev(second_bdev, "ut_bdev2", g_bdev.io_target);
    1475                 :          4 :         spdk_bdev_open_ext("ut_bdev2", true, _bdev_event_cb, NULL, &second_desc);
    1476         [ -  + ]:          4 :         SPDK_CU_ASSERT_FATAL(second_desc != NULL);
    1477                 :            : 
    1478                 :          4 :         set_thread(0);
    1479                 :          4 :         io_ch = spdk_bdev_get_io_channel(g_desc);
    1480                 :          4 :         bdev_ch = spdk_io_channel_get_ctx(io_ch);
    1481                 :          4 :         shared_resource = bdev_ch->shared_resource;
    1482                 :          4 :         ut_ch = spdk_io_channel_get_ctx(bdev_ch->channel);
    1483                 :          4 :         ut_ch->avail_cnt = AVAIL;
    1484                 :            : 
    1485                 :          4 :         second_ch = spdk_bdev_get_io_channel(second_desc);
    1486                 :          4 :         second_bdev_ch = spdk_io_channel_get_ctx(second_ch);
    1487         [ -  + ]:          4 :         SPDK_CU_ASSERT_FATAL(shared_resource == second_bdev_ch->shared_resource);
    1488                 :            : 
    1489                 :            :         /* Saturate io_target through bdev A. */
    1490         [ +  + ]:         84 :         for (i = 0; i < AVAIL; i++) {
    1491                 :         80 :                 status[i] = SPDK_BDEV_IO_STATUS_PENDING;
    1492                 :         80 :                 rc = spdk_bdev_read_blocks(g_desc, io_ch, NULL, 0, 1, enomem_done, &status[i]);
    1493                 :         80 :                 CU_ASSERT(rc == 0);
    1494                 :            :         }
    1495                 :          4 :         CU_ASSERT(TAILQ_EMPTY(&shared_resource->nomem_io));
    1496                 :            : 
    1497                 :            :         /*
    1498                 :            :          * Now submit I/O through the second bdev. This should fail with ENOMEM
    1499                 :            :          * and then go onto the nomem_io list.
    1500                 :            :          */
    1501                 :          4 :         status[AVAIL] = SPDK_BDEV_IO_STATUS_PENDING;
    1502                 :          4 :         rc = spdk_bdev_read_blocks(second_desc, second_ch, NULL, 0, 1, enomem_done, &status[AVAIL]);
    1503                 :          4 :         CU_ASSERT(rc == 0);
    1504         [ -  + ]:          4 :         SPDK_CU_ASSERT_FATAL(!TAILQ_EMPTY(&shared_resource->nomem_io));
    1505                 :            : 
    1506                 :            :         /* Complete first bdev's I/O. This should retry sending second bdev's nomem_io */
    1507                 :          4 :         stub_complete_io(g_bdev.io_target, AVAIL);
    1508                 :            : 
    1509         [ -  + ]:          4 :         SPDK_CU_ASSERT_FATAL(TAILQ_EMPTY(&shared_resource->nomem_io));
    1510                 :          4 :         CU_ASSERT(shared_resource->io_outstanding == 1);
    1511                 :            : 
    1512                 :            :         /* Now complete our retried I/O  */
    1513                 :          4 :         stub_complete_io(g_bdev.io_target, 1);
    1514         [ -  + ]:          4 :         SPDK_CU_ASSERT_FATAL(shared_resource->io_outstanding == 0);
    1515                 :            : 
    1516                 :          4 :         spdk_put_io_channel(io_ch);
    1517                 :          4 :         spdk_put_io_channel(second_ch);
    1518                 :          4 :         spdk_bdev_close(second_desc);
    1519                 :          4 :         unregister_bdev(second_bdev);
    1520                 :          4 :         poll_threads();
    1521                 :          4 :         free(second_bdev);
    1522                 :          4 :         teardown_test();
    1523                 :          4 : }
    1524                 :            : 
    1525                 :            : static void
    1526                 :          4 : enomem_multi_bdev_unregister(void)
    1527                 :          4 : {
    1528                 :            :         struct spdk_io_channel *io_ch;
    1529                 :            :         struct spdk_bdev_channel *bdev_ch;
    1530                 :            :         struct spdk_bdev_shared_resource *shared_resource;
    1531                 :            :         struct ut_bdev_channel *ut_ch;
    1532                 :          4 :         const uint32_t IO_ARRAY_SIZE = 64;
    1533                 :          4 :         const uint32_t AVAIL = 20;
    1534         [ -  + ]:          4 :         enum spdk_bdev_io_status status[IO_ARRAY_SIZE];
    1535                 :            :         uint32_t i;
    1536                 :            :         int rc;
    1537                 :            : 
    1538                 :          4 :         setup_test();
    1539                 :            : 
    1540                 :          4 :         set_thread(0);
    1541                 :          4 :         io_ch = spdk_bdev_get_io_channel(g_desc);
    1542                 :          4 :         bdev_ch = spdk_io_channel_get_ctx(io_ch);
    1543                 :          4 :         shared_resource = bdev_ch->shared_resource;
    1544                 :          4 :         ut_ch = spdk_io_channel_get_ctx(bdev_ch->channel);
    1545                 :          4 :         ut_ch->avail_cnt = AVAIL;
    1546                 :            : 
    1547                 :            :         /* Saturate io_target through the bdev. */
    1548         [ +  + ]:         84 :         for (i = 0; i < AVAIL; i++) {
    1549                 :         80 :                 status[i] = SPDK_BDEV_IO_STATUS_PENDING;
    1550                 :         80 :                 rc = spdk_bdev_read_blocks(g_desc, io_ch, NULL, 0, 1, enomem_done, &status[i]);
    1551                 :         80 :                 CU_ASSERT(rc == 0);
    1552                 :            :         }
    1553                 :          4 :         CU_ASSERT(TAILQ_EMPTY(&shared_resource->nomem_io));
    1554                 :            : 
    1555                 :            :         /*
    1556                 :            :          * Now submit I/O through the bdev. This should fail with ENOMEM
    1557                 :            :          * and then go onto the nomem_io list.
    1558                 :            :          */
    1559                 :          4 :         status[AVAIL] = SPDK_BDEV_IO_STATUS_PENDING;
    1560                 :          4 :         rc = spdk_bdev_read_blocks(g_desc, io_ch, NULL, 0, 1, enomem_done, &status[AVAIL]);
    1561                 :          4 :         CU_ASSERT(rc == 0);
    1562         [ -  + ]:          4 :         SPDK_CU_ASSERT_FATAL(!TAILQ_EMPTY(&shared_resource->nomem_io));
    1563                 :            : 
    1564                 :            :         /* Unregister the bdev to abort the IOs from nomem_io queue. */
    1565                 :          4 :         unregister_bdev(&g_bdev);
    1566                 :          4 :         CU_ASSERT(status[AVAIL] == SPDK_BDEV_IO_STATUS_FAILED);
    1567         [ -  + ]:          4 :         SPDK_CU_ASSERT_FATAL(TAILQ_EMPTY(&shared_resource->nomem_io));
    1568         [ -  + ]:          4 :         SPDK_CU_ASSERT_FATAL(shared_resource->io_outstanding == AVAIL);
    1569                 :            : 
    1570                 :            :         /* Complete the bdev's I/O. */
    1571                 :          4 :         stub_complete_io(g_bdev.io_target, AVAIL);
    1572         [ -  + ]:          4 :         SPDK_CU_ASSERT_FATAL(shared_resource->io_outstanding == 0);
    1573                 :            : 
    1574                 :          4 :         spdk_put_io_channel(io_ch);
    1575                 :          4 :         poll_threads();
    1576                 :          4 :         teardown_test();
    1577                 :          4 : }
    1578                 :            : 
    1579                 :            : static void
    1580                 :          4 : enomem_multi_io_target(void)
    1581                 :          4 : {
    1582                 :            :         struct spdk_io_channel *io_ch;
    1583                 :            :         struct spdk_bdev_channel *bdev_ch;
    1584                 :            :         struct ut_bdev_channel *ut_ch;
    1585                 :          4 :         const uint32_t IO_ARRAY_SIZE = 64;
    1586                 :          4 :         const uint32_t AVAIL = 20;
    1587         [ -  + ]:          4 :         enum spdk_bdev_io_status status[IO_ARRAY_SIZE];
    1588                 :            :         uint32_t i;
    1589                 :          4 :         int new_io_device;
    1590                 :            :         struct ut_bdev *second_bdev;
    1591                 :          4 :         struct spdk_bdev_desc *second_desc = NULL;
    1592                 :            :         struct spdk_bdev_channel *second_bdev_ch;
    1593                 :            :         struct spdk_io_channel *second_ch;
    1594                 :            :         int rc;
    1595                 :            : 
    1596                 :          4 :         setup_test();
    1597                 :            : 
    1598                 :            :         /* Create new io_target and a second bdev using it */
    1599                 :          4 :         spdk_io_device_register(&new_io_device, stub_create_ch, stub_destroy_ch,
    1600                 :            :                                 sizeof(struct ut_bdev_channel), NULL);
    1601                 :          4 :         second_bdev = calloc(1, sizeof(*second_bdev));
    1602         [ -  + ]:          4 :         SPDK_CU_ASSERT_FATAL(second_bdev != NULL);
    1603                 :          4 :         register_bdev(second_bdev, "ut_bdev2", &new_io_device);
    1604                 :          4 :         spdk_bdev_open_ext("ut_bdev2", true, _bdev_event_cb, NULL, &second_desc);
    1605         [ -  + ]:          4 :         SPDK_CU_ASSERT_FATAL(second_desc != NULL);
    1606                 :            : 
    1607                 :          4 :         set_thread(0);
    1608                 :          4 :         io_ch = spdk_bdev_get_io_channel(g_desc);
    1609                 :          4 :         bdev_ch = spdk_io_channel_get_ctx(io_ch);
    1610                 :          4 :         ut_ch = spdk_io_channel_get_ctx(bdev_ch->channel);
    1611                 :          4 :         ut_ch->avail_cnt = AVAIL;
    1612                 :            : 
    1613                 :            :         /* Different io_target should imply a different shared_resource */
    1614                 :          4 :         second_ch = spdk_bdev_get_io_channel(second_desc);
    1615                 :          4 :         second_bdev_ch = spdk_io_channel_get_ctx(second_ch);
    1616         [ -  + ]:          4 :         SPDK_CU_ASSERT_FATAL(bdev_ch->shared_resource != second_bdev_ch->shared_resource);
    1617                 :            : 
    1618                 :            :         /* Saturate io_target through bdev A. */
    1619         [ +  + ]:         84 :         for (i = 0; i < AVAIL; i++) {
    1620                 :         80 :                 status[i] = SPDK_BDEV_IO_STATUS_PENDING;
    1621                 :         80 :                 rc = spdk_bdev_read_blocks(g_desc, io_ch, NULL, 0, 1, enomem_done, &status[i]);
    1622                 :         80 :                 CU_ASSERT(rc == 0);
    1623                 :            :         }
    1624                 :          4 :         CU_ASSERT(TAILQ_EMPTY(&bdev_ch->shared_resource->nomem_io));
    1625                 :            : 
    1626                 :            :         /* Issue one more I/O to fill ENOMEM list. */
    1627                 :          4 :         status[AVAIL] = SPDK_BDEV_IO_STATUS_PENDING;
    1628                 :          4 :         rc = spdk_bdev_read_blocks(g_desc, io_ch, NULL, 0, 1, enomem_done, &status[AVAIL]);
    1629                 :          4 :         CU_ASSERT(rc == 0);
    1630         [ -  + ]:          4 :         SPDK_CU_ASSERT_FATAL(!TAILQ_EMPTY(&bdev_ch->shared_resource->nomem_io));
    1631                 :            : 
    1632                 :            :         /*
    1633                 :            :          * Now submit I/O through the second bdev. This should go through and complete
    1634                 :            :          * successfully because we're using a different io_device underneath.
    1635                 :            :          */
    1636                 :          4 :         status[AVAIL] = SPDK_BDEV_IO_STATUS_PENDING;
    1637                 :          4 :         rc = spdk_bdev_read_blocks(second_desc, second_ch, NULL, 0, 1, enomem_done, &status[AVAIL]);
    1638                 :          4 :         CU_ASSERT(rc == 0);
    1639         [ -  + ]:          4 :         SPDK_CU_ASSERT_FATAL(TAILQ_EMPTY(&second_bdev_ch->shared_resource->nomem_io));
    1640                 :          4 :         stub_complete_io(second_bdev->io_target, 1);
    1641                 :            : 
    1642                 :            :         /* Cleanup; Complete outstanding I/O. */
    1643                 :          4 :         stub_complete_io(g_bdev.io_target, AVAIL);
    1644         [ -  + ]:          4 :         SPDK_CU_ASSERT_FATAL(TAILQ_EMPTY(&bdev_ch->shared_resource->nomem_io));
    1645                 :            :         /* Complete the ENOMEM I/O */
    1646                 :          4 :         stub_complete_io(g_bdev.io_target, 1);
    1647                 :          4 :         CU_ASSERT(bdev_ch->shared_resource->io_outstanding == 0);
    1648                 :            : 
    1649         [ -  + ]:          4 :         SPDK_CU_ASSERT_FATAL(TAILQ_EMPTY(&bdev_ch->shared_resource->nomem_io));
    1650                 :          4 :         CU_ASSERT(bdev_ch->shared_resource->io_outstanding == 0);
    1651                 :          4 :         spdk_put_io_channel(io_ch);
    1652                 :          4 :         spdk_put_io_channel(second_ch);
    1653                 :          4 :         spdk_bdev_close(second_desc);
    1654                 :          4 :         unregister_bdev(second_bdev);
    1655                 :          4 :         spdk_io_device_unregister(&new_io_device, NULL);
    1656                 :          4 :         poll_threads();
    1657                 :          4 :         free(second_bdev);
    1658                 :          4 :         teardown_test();
    1659                 :          4 : }
    1660                 :            : 
    1661                 :            : static void
    1662                 :         36 : qos_dynamic_enable_done(void *cb_arg, int status)
    1663                 :            : {
    1664                 :         36 :         int *rc = cb_arg;
    1665                 :         36 :         *rc = status;
    1666                 :         36 : }
    1667                 :            : 
    1668                 :            : static void
    1669                 :          4 : qos_dynamic_enable(void)
    1670                 :            : {
    1671                 :            :         struct spdk_io_channel *io_ch[2];
    1672                 :            :         struct spdk_bdev_channel *bdev_ch[2];
    1673                 :            :         struct spdk_bdev *bdev;
    1674                 :          4 :         enum spdk_bdev_io_status bdev_io_status[2];
    1675                 :          4 :         uint64_t limits[SPDK_BDEV_QOS_NUM_RATE_LIMIT_TYPES] = {};
    1676                 :          4 :         int status, second_status, rc, i;
    1677                 :            : 
    1678                 :          4 :         setup_test();
    1679                 :          4 :         MOCK_SET(spdk_get_ticks, 0);
    1680                 :            : 
    1681         [ +  + ]:         20 :         for (i = 0; i < SPDK_BDEV_QOS_NUM_RATE_LIMIT_TYPES; i++) {
    1682                 :         16 :                 limits[i] = UINT64_MAX;
    1683                 :            :         }
    1684                 :            : 
    1685                 :          4 :         bdev = &g_bdev.bdev;
    1686                 :            : 
    1687                 :          4 :         g_get_io_channel = true;
    1688                 :            : 
    1689                 :            :         /* Create channels */
    1690                 :          4 :         set_thread(0);
    1691                 :          4 :         io_ch[0] = spdk_bdev_get_io_channel(g_desc);
    1692                 :          4 :         bdev_ch[0] = spdk_io_channel_get_ctx(io_ch[0]);
    1693                 :          4 :         CU_ASSERT(bdev_ch[0]->flags == 0);
    1694                 :            : 
    1695                 :          4 :         set_thread(1);
    1696                 :          4 :         io_ch[1] = spdk_bdev_get_io_channel(g_desc);
    1697                 :          4 :         bdev_ch[1] = spdk_io_channel_get_ctx(io_ch[1]);
    1698                 :          4 :         CU_ASSERT(bdev_ch[1]->flags == 0);
    1699                 :            : 
    1700                 :          4 :         set_thread(0);
    1701                 :            : 
    1702                 :            :         /*
    1703                 :            :          * Enable QoS: Read/Write IOPS, Read/Write byte,
    1704                 :            :          * Read only byte and Write only byte per second
    1705                 :            :          * rate limits.
    1706                 :            :          * More than 10 I/Os allowed per timeslice.
    1707                 :            :          */
    1708                 :          4 :         status = -1;
    1709                 :          4 :         limits[SPDK_BDEV_QOS_RW_IOPS_RATE_LIMIT] = 10000;
    1710                 :          4 :         limits[SPDK_BDEV_QOS_RW_BPS_RATE_LIMIT] = 100;
    1711                 :          4 :         limits[SPDK_BDEV_QOS_R_BPS_RATE_LIMIT] = 100;
    1712                 :          4 :         limits[SPDK_BDEV_QOS_W_BPS_RATE_LIMIT] = 10;
    1713                 :          4 :         spdk_bdev_set_qos_rate_limits(bdev, limits, qos_dynamic_enable_done, &status);
    1714                 :          4 :         poll_threads();
    1715                 :          4 :         CU_ASSERT(status == 0);
    1716                 :          4 :         CU_ASSERT((bdev_ch[0]->flags & BDEV_CH_QOS_ENABLED) != 0);
    1717                 :          4 :         CU_ASSERT((bdev_ch[1]->flags & BDEV_CH_QOS_ENABLED) != 0);
    1718                 :            : 
    1719                 :            :         /*
    1720                 :            :          * Submit and complete 10 I/O to fill the QoS allotment for this timeslice.
    1721                 :            :          * Additional I/O will then be queued.
    1722                 :            :          */
    1723                 :          4 :         set_thread(0);
    1724         [ +  + ]:         44 :         for (i = 0; i < 10; i++) {
    1725                 :         40 :                 bdev_io_status[0] = SPDK_BDEV_IO_STATUS_PENDING;
    1726                 :         40 :                 rc = spdk_bdev_read_blocks(g_desc, io_ch[0], NULL, 0, 1, io_during_io_done, &bdev_io_status[0]);
    1727                 :         40 :                 CU_ASSERT(rc == 0);
    1728                 :         40 :                 CU_ASSERT(bdev_io_status[0] == SPDK_BDEV_IO_STATUS_PENDING);
    1729                 :         40 :                 poll_thread(0);
    1730                 :         40 :                 stub_complete_io(g_bdev.io_target, 0);
    1731                 :         40 :                 CU_ASSERT(bdev_io_status[0] == SPDK_BDEV_IO_STATUS_SUCCESS);
    1732                 :            :         }
    1733                 :            : 
    1734                 :            :         /*
    1735                 :            :          * Send two more I/O.  These I/O will be queued since the current timeslice allotment has been
    1736                 :            :          * filled already.  We want to test that when QoS is disabled that these two I/O:
    1737                 :            :          *  1) are not aborted
    1738                 :            :          *  2) are sent back to their original thread for resubmission
    1739                 :            :          */
    1740                 :          4 :         bdev_io_status[0] = SPDK_BDEV_IO_STATUS_PENDING;
    1741                 :          4 :         rc = spdk_bdev_read_blocks(g_desc, io_ch[0], NULL, 0, 1, io_during_io_done, &bdev_io_status[0]);
    1742                 :          4 :         CU_ASSERT(rc == 0);
    1743                 :          4 :         CU_ASSERT(bdev_io_status[0] == SPDK_BDEV_IO_STATUS_PENDING);
    1744                 :          4 :         set_thread(1);
    1745                 :          4 :         bdev_io_status[1] = SPDK_BDEV_IO_STATUS_PENDING;
    1746                 :          4 :         rc = spdk_bdev_read_blocks(g_desc, io_ch[1], NULL, 0, 1, io_during_io_done, &bdev_io_status[1]);
    1747                 :          4 :         CU_ASSERT(rc == 0);
    1748                 :          4 :         CU_ASSERT(bdev_io_status[1] == SPDK_BDEV_IO_STATUS_PENDING);
    1749                 :          4 :         poll_threads();
    1750                 :            : 
    1751                 :            :         /*
    1752                 :            :          * Disable QoS: Read/Write IOPS, Read/Write byte,
    1753                 :            :          * Read only byte rate limits
    1754                 :            :          */
    1755                 :          4 :         status = -1;
    1756                 :          4 :         limits[SPDK_BDEV_QOS_RW_IOPS_RATE_LIMIT] = 0;
    1757                 :          4 :         limits[SPDK_BDEV_QOS_RW_BPS_RATE_LIMIT] = 0;
    1758                 :          4 :         limits[SPDK_BDEV_QOS_R_BPS_RATE_LIMIT] = 0;
    1759                 :          4 :         spdk_bdev_set_qos_rate_limits(bdev, limits, qos_dynamic_enable_done, &status);
    1760                 :          4 :         poll_threads();
    1761                 :          4 :         CU_ASSERT(status == 0);
    1762                 :          4 :         CU_ASSERT((bdev_ch[0]->flags & BDEV_CH_QOS_ENABLED) != 0);
    1763                 :          4 :         CU_ASSERT((bdev_ch[1]->flags & BDEV_CH_QOS_ENABLED) != 0);
    1764                 :            : 
    1765                 :            :         /* Disable QoS: Write only Byte per second rate limit */
    1766                 :          4 :         status = -1;
    1767                 :          4 :         limits[SPDK_BDEV_QOS_W_BPS_RATE_LIMIT] = 0;
    1768                 :          4 :         spdk_bdev_set_qos_rate_limits(bdev, limits, qos_dynamic_enable_done, &status);
    1769                 :          4 :         poll_threads();
    1770                 :          4 :         CU_ASSERT(status == 0);
    1771                 :          4 :         CU_ASSERT((bdev_ch[0]->flags & BDEV_CH_QOS_ENABLED) == 0);
    1772                 :          4 :         CU_ASSERT((bdev_ch[1]->flags & BDEV_CH_QOS_ENABLED) == 0);
    1773                 :            : 
    1774                 :            :         /*
    1775                 :            :          * All I/O should have been resubmitted back on their original thread.  Complete
    1776                 :            :          *  all I/O on thread 0, and ensure that only the thread 0 I/O was completed.
    1777                 :            :          */
    1778                 :          4 :         set_thread(0);
    1779                 :          4 :         stub_complete_io(g_bdev.io_target, 0);
    1780                 :          4 :         poll_threads();
    1781                 :          4 :         CU_ASSERT(bdev_io_status[0] == SPDK_BDEV_IO_STATUS_SUCCESS);
    1782                 :          4 :         CU_ASSERT(bdev_io_status[1] == SPDK_BDEV_IO_STATUS_PENDING);
    1783                 :            : 
    1784                 :            :         /* Now complete all I/O on thread 1 and ensure the thread 1 I/O was completed. */
    1785                 :          4 :         set_thread(1);
    1786                 :          4 :         stub_complete_io(g_bdev.io_target, 0);
    1787                 :          4 :         poll_threads();
    1788                 :          4 :         CU_ASSERT(bdev_io_status[1] == SPDK_BDEV_IO_STATUS_SUCCESS);
    1789                 :            : 
    1790                 :            :         /* Disable QoS again */
    1791                 :          4 :         status = -1;
    1792                 :          4 :         limits[SPDK_BDEV_QOS_RW_IOPS_RATE_LIMIT] = 0;
    1793                 :          4 :         spdk_bdev_set_qos_rate_limits(bdev, limits, qos_dynamic_enable_done, &status);
    1794                 :          4 :         poll_threads();
    1795                 :          4 :         CU_ASSERT(status == 0); /* This should succeed */
    1796                 :          4 :         CU_ASSERT((bdev_ch[0]->flags & BDEV_CH_QOS_ENABLED) == 0);
    1797                 :          4 :         CU_ASSERT((bdev_ch[1]->flags & BDEV_CH_QOS_ENABLED) == 0);
    1798                 :            : 
    1799                 :            :         /* Enable QoS on thread 0 */
    1800                 :          4 :         status = -1;
    1801                 :          4 :         limits[SPDK_BDEV_QOS_RW_IOPS_RATE_LIMIT] = 10000;
    1802                 :          4 :         spdk_bdev_set_qos_rate_limits(bdev, limits, qos_dynamic_enable_done, &status);
    1803                 :          4 :         poll_threads();
    1804                 :          4 :         CU_ASSERT(status == 0);
    1805                 :          4 :         CU_ASSERT((bdev_ch[0]->flags & BDEV_CH_QOS_ENABLED) != 0);
    1806                 :          4 :         CU_ASSERT((bdev_ch[1]->flags & BDEV_CH_QOS_ENABLED) != 0);
    1807                 :            : 
    1808                 :            :         /* Disable QoS on thread 1 */
    1809                 :          4 :         set_thread(1);
    1810                 :          4 :         status = -1;
    1811                 :          4 :         limits[SPDK_BDEV_QOS_RW_IOPS_RATE_LIMIT] = 0;
    1812                 :          4 :         spdk_bdev_set_qos_rate_limits(bdev, limits, qos_dynamic_enable_done, &status);
    1813                 :            :         /* Don't poll yet. This should leave the channels with QoS enabled */
    1814                 :          4 :         CU_ASSERT(status == -1);
    1815                 :          4 :         CU_ASSERT((bdev_ch[0]->flags & BDEV_CH_QOS_ENABLED) != 0);
    1816                 :          4 :         CU_ASSERT((bdev_ch[1]->flags & BDEV_CH_QOS_ENABLED) != 0);
    1817                 :            : 
    1818                 :            :         /* Enable QoS. This should immediately fail because the previous disable QoS hasn't completed. */
    1819                 :          4 :         second_status = 0;
    1820                 :          4 :         limits[SPDK_BDEV_QOS_RW_BPS_RATE_LIMIT] = 10;
    1821                 :          4 :         spdk_bdev_set_qos_rate_limits(bdev, limits, qos_dynamic_enable_done, &second_status);
    1822                 :          4 :         poll_threads();
    1823                 :          4 :         CU_ASSERT(status == 0); /* The disable should succeed */
    1824                 :          4 :         CU_ASSERT(second_status < 0); /* The enable should fail */
    1825                 :          4 :         CU_ASSERT((bdev_ch[0]->flags & BDEV_CH_QOS_ENABLED) == 0);
    1826                 :          4 :         CU_ASSERT((bdev_ch[1]->flags & BDEV_CH_QOS_ENABLED) == 0);
    1827                 :            : 
    1828                 :            :         /* Enable QoS on thread 1. This should succeed now that the disable has completed. */
    1829                 :          4 :         status = -1;
    1830                 :          4 :         limits[SPDK_BDEV_QOS_RW_IOPS_RATE_LIMIT] = 10000;
    1831                 :          4 :         spdk_bdev_set_qos_rate_limits(bdev, limits, qos_dynamic_enable_done, &status);
    1832                 :          4 :         poll_threads();
    1833                 :          4 :         CU_ASSERT(status == 0);
    1834                 :          4 :         CU_ASSERT((bdev_ch[0]->flags & BDEV_CH_QOS_ENABLED) != 0);
    1835                 :          4 :         CU_ASSERT((bdev_ch[1]->flags & BDEV_CH_QOS_ENABLED) != 0);
    1836                 :            : 
    1837                 :            :         /* Tear down the channels */
    1838                 :          4 :         set_thread(0);
    1839                 :          4 :         spdk_put_io_channel(io_ch[0]);
    1840                 :          4 :         set_thread(1);
    1841                 :          4 :         spdk_put_io_channel(io_ch[1]);
    1842                 :          4 :         poll_threads();
    1843                 :            : 
    1844                 :          4 :         set_thread(0);
    1845                 :          4 :         teardown_test();
    1846                 :          4 : }
    1847                 :            : 
    1848                 :            : static void
    1849                 :          8 : histogram_status_cb(void *cb_arg, int status)
    1850                 :            : {
    1851                 :          8 :         g_status = status;
    1852                 :          8 : }
    1853                 :            : 
    1854                 :            : static void
    1855                 :          8 : histogram_data_cb(void *cb_arg, int status, struct spdk_histogram_data *histogram)
    1856                 :            : {
    1857                 :          8 :         g_status = status;
    1858                 :          8 :         g_histogram = histogram;
    1859                 :          8 : }
    1860                 :            : 
    1861                 :            : static void
    1862                 :      59392 : histogram_io_count(void *ctx, uint64_t start, uint64_t end, uint64_t count,
    1863                 :            :                    uint64_t total, uint64_t so_far)
    1864                 :            : {
    1865                 :      59392 :         g_count += count;
    1866                 :      59392 : }
    1867                 :            : 
    1868                 :            : static void
    1869                 :          4 : bdev_histograms_mt(void)
    1870                 :            : {
    1871                 :            :         struct spdk_io_channel *ch[2];
    1872                 :            :         struct spdk_histogram_data *histogram;
    1873                 :          4 :         uint8_t buf[4096];
    1874                 :          4 :         int status = false;
    1875                 :            :         int rc;
    1876                 :            : 
    1877                 :            : 
    1878                 :          4 :         setup_test();
    1879                 :            : 
    1880                 :          4 :         set_thread(0);
    1881                 :          4 :         ch[0] = spdk_bdev_get_io_channel(g_desc);
    1882                 :          4 :         CU_ASSERT(ch[0] != NULL);
    1883                 :            : 
    1884                 :          4 :         set_thread(1);
    1885                 :          4 :         ch[1] = spdk_bdev_get_io_channel(g_desc);
    1886                 :          4 :         CU_ASSERT(ch[1] != NULL);
    1887                 :            : 
    1888                 :            : 
    1889                 :            :         /* Enable histogram */
    1890                 :          4 :         spdk_bdev_histogram_enable(&g_bdev.bdev, histogram_status_cb, NULL, true);
    1891                 :          4 :         poll_threads();
    1892                 :          4 :         CU_ASSERT(g_status == 0);
    1893         [ -  + ]:          4 :         CU_ASSERT(g_bdev.bdev.internal.histogram_enabled == true);
    1894                 :            : 
    1895                 :            :         /* Allocate histogram */
    1896                 :          4 :         histogram = spdk_histogram_data_alloc();
    1897                 :            : 
    1898                 :            :         /* Check if histogram is zeroed */
    1899                 :          4 :         spdk_bdev_histogram_get(&g_bdev.bdev, histogram, histogram_data_cb, NULL);
    1900                 :          4 :         poll_threads();
    1901                 :          4 :         CU_ASSERT(g_status == 0);
    1902         [ -  + ]:          4 :         SPDK_CU_ASSERT_FATAL(g_histogram != NULL);
    1903                 :            : 
    1904                 :          4 :         g_count = 0;
    1905                 :          4 :         spdk_histogram_data_iterate(g_histogram, histogram_io_count, NULL);
    1906                 :            : 
    1907                 :          4 :         CU_ASSERT(g_count == 0);
    1908                 :            : 
    1909                 :          4 :         set_thread(0);
    1910                 :          4 :         rc = spdk_bdev_write_blocks(g_desc, ch[0], &buf, 0, 1, io_during_io_done, &status);
    1911                 :          4 :         CU_ASSERT(rc == 0);
    1912                 :            : 
    1913                 :          4 :         spdk_delay_us(10);
    1914                 :          4 :         stub_complete_io(g_bdev.io_target, 1);
    1915                 :          4 :         poll_threads();
    1916                 :          4 :         CU_ASSERT(status == true);
    1917                 :            : 
    1918                 :            : 
    1919                 :          4 :         set_thread(1);
    1920                 :          4 :         rc = spdk_bdev_read_blocks(g_desc, ch[1], &buf, 0, 1, io_during_io_done, &status);
    1921                 :          4 :         CU_ASSERT(rc == 0);
    1922                 :            : 
    1923                 :          4 :         spdk_delay_us(10);
    1924                 :          4 :         stub_complete_io(g_bdev.io_target, 1);
    1925                 :          4 :         poll_threads();
    1926                 :          4 :         CU_ASSERT(status == true);
    1927                 :            : 
    1928                 :          4 :         set_thread(0);
    1929                 :            : 
    1930                 :            :         /* Check if histogram gathered data from all I/O channels */
    1931                 :          4 :         spdk_bdev_histogram_get(&g_bdev.bdev, histogram, histogram_data_cb, NULL);
    1932                 :          4 :         poll_threads();
    1933                 :          4 :         CU_ASSERT(g_status == 0);
    1934         [ -  + ]:          4 :         CU_ASSERT(g_bdev.bdev.internal.histogram_enabled == true);
    1935         [ -  + ]:          4 :         SPDK_CU_ASSERT_FATAL(g_histogram != NULL);
    1936                 :            : 
    1937                 :          4 :         g_count = 0;
    1938                 :          4 :         spdk_histogram_data_iterate(g_histogram, histogram_io_count, NULL);
    1939                 :          4 :         CU_ASSERT(g_count == 2);
    1940                 :            : 
    1941                 :            :         /* Disable histogram */
    1942                 :          4 :         spdk_bdev_histogram_enable(&g_bdev.bdev, histogram_status_cb, NULL, false);
    1943                 :          4 :         poll_threads();
    1944                 :          4 :         CU_ASSERT(g_status == 0);
    1945         [ -  + ]:          4 :         CU_ASSERT(g_bdev.bdev.internal.histogram_enabled == false);
    1946                 :            : 
    1947                 :          4 :         spdk_histogram_data_free(histogram);
    1948                 :            : 
    1949                 :            :         /* Tear down the channels */
    1950                 :          4 :         set_thread(0);
    1951                 :          4 :         spdk_put_io_channel(ch[0]);
    1952                 :          4 :         set_thread(1);
    1953                 :          4 :         spdk_put_io_channel(ch[1]);
    1954                 :          4 :         poll_threads();
    1955                 :          4 :         set_thread(0);
    1956                 :          4 :         teardown_test();
    1957                 :            : 
    1958                 :          4 : }
    1959                 :            : 
    1960                 :            : struct timeout_io_cb_arg {
    1961                 :            :         struct iovec iov;
    1962                 :            :         uint8_t type;
    1963                 :            : };
    1964                 :            : 
    1965                 :            : static int
    1966                 :         28 : bdev_channel_count_submitted_io(struct spdk_bdev_channel *ch)
    1967                 :            : {
    1968                 :            :         struct spdk_bdev_io *bdev_io;
    1969                 :         28 :         int n = 0;
    1970                 :            : 
    1971         [ -  + ]:         28 :         if (!ch) {
    1972                 :          0 :                 return -1;
    1973                 :            :         }
    1974                 :            : 
    1975         [ +  + ]:         56 :         TAILQ_FOREACH(bdev_io, &ch->io_submitted, internal.ch_link) {
    1976                 :         28 :                 n++;
    1977                 :            :         }
    1978                 :            : 
    1979                 :         28 :         return n;
    1980                 :            : }
    1981                 :            : 
    1982                 :            : static void
    1983                 :         16 : bdev_channel_io_timeout_cb(void *cb_arg, struct spdk_bdev_io *bdev_io)
    1984                 :            : {
    1985                 :         16 :         struct timeout_io_cb_arg *ctx = cb_arg;
    1986                 :            : 
    1987                 :         16 :         ctx->type = bdev_io->type;
    1988                 :         16 :         ctx->iov.iov_base = bdev_io->iov.iov_base;
    1989                 :         16 :         ctx->iov.iov_len = bdev_io->iov.iov_len;
    1990                 :         16 : }
    1991                 :            : 
    1992                 :            : static bool g_io_done;
    1993                 :            : 
    1994                 :            : static void
    1995                 :         36 : io_done(struct spdk_bdev_io *bdev_io, bool success, void *cb_arg)
    1996                 :            : {
    1997                 :         36 :         g_io_done = true;
    1998                 :         36 :         spdk_bdev_free_io(bdev_io);
    1999                 :         36 : }
    2000                 :            : 
    2001                 :            : static void
    2002                 :          4 : bdev_set_io_timeout_mt(void)
    2003                 :            : {
    2004                 :            :         struct spdk_io_channel *ch[3];
    2005                 :            :         struct spdk_bdev_channel *bdev_ch[3];
    2006                 :          4 :         struct timeout_io_cb_arg cb_arg;
    2007                 :            : 
    2008                 :          4 :         setup_test();
    2009                 :            : 
    2010                 :          4 :         g_bdev.bdev.optimal_io_boundary = 16;
    2011                 :          4 :         g_bdev.bdev.split_on_optimal_io_boundary = true;
    2012                 :            : 
    2013                 :          4 :         set_thread(0);
    2014                 :          4 :         ch[0] = spdk_bdev_get_io_channel(g_desc);
    2015                 :          4 :         CU_ASSERT(ch[0] != NULL);
    2016                 :            : 
    2017                 :          4 :         set_thread(1);
    2018                 :          4 :         ch[1] = spdk_bdev_get_io_channel(g_desc);
    2019                 :          4 :         CU_ASSERT(ch[1] != NULL);
    2020                 :            : 
    2021                 :          4 :         set_thread(2);
    2022                 :          4 :         ch[2] = spdk_bdev_get_io_channel(g_desc);
    2023                 :          4 :         CU_ASSERT(ch[2] != NULL);
    2024                 :            : 
    2025                 :            :         /* Multi-thread mode
    2026                 :            :          * 1, Check the poller was registered successfully
    2027                 :            :          * 2, Check the timeout IO and ensure the IO was the submitted by user
    2028                 :            :          * 3, Check the link int the bdev_ch works right.
    2029                 :            :          * 4, Close desc and put io channel during the timeout poller is polling
    2030                 :            :          */
    2031                 :            : 
    2032                 :            :         /* In desc thread set the timeout */
    2033                 :          4 :         set_thread(0);
    2034                 :          4 :         CU_ASSERT(spdk_bdev_set_timeout(g_desc, 5, bdev_channel_io_timeout_cb, &cb_arg) == 0);
    2035                 :          4 :         CU_ASSERT(g_desc->io_timeout_poller != NULL);
    2036                 :          4 :         CU_ASSERT(g_desc->cb_fn == bdev_channel_io_timeout_cb);
    2037                 :          4 :         CU_ASSERT(g_desc->cb_arg == &cb_arg);
    2038                 :            : 
    2039                 :            :         /* check the IO submitted list and timeout handler */
    2040                 :          4 :         CU_ASSERT(spdk_bdev_read_blocks(g_desc, ch[0], (void *)0x2000, 0, 1, io_done, NULL) == 0);
    2041                 :          4 :         bdev_ch[0] = spdk_io_channel_get_ctx(ch[0]);
    2042                 :          4 :         CU_ASSERT(bdev_channel_count_submitted_io(bdev_ch[0]) == 1);
    2043                 :            : 
    2044                 :          4 :         set_thread(1);
    2045                 :          4 :         CU_ASSERT(spdk_bdev_write_blocks(g_desc, ch[1], (void *)0x1000, 0, 1, io_done, NULL) == 0);
    2046                 :          4 :         bdev_ch[1] = spdk_io_channel_get_ctx(ch[1]);
    2047                 :          4 :         CU_ASSERT(bdev_channel_count_submitted_io(bdev_ch[1]) == 1);
    2048                 :            : 
    2049                 :            :         /* Now test that a single-vector command is split correctly.
    2050                 :            :          * Offset 14, length 8, payload 0xF000
    2051                 :            :          *  Child - Offset 14, length 2, payload 0xF000
    2052                 :            :          *  Child - Offset 16, length 6, payload 0xF000 + 2 * 512
    2053                 :            :          *
    2054                 :            :          * Set up the expected values before calling spdk_bdev_read_blocks
    2055                 :            :          */
    2056                 :          4 :         set_thread(2);
    2057                 :          4 :         CU_ASSERT(spdk_bdev_read_blocks(g_desc, ch[2], (void *)0xF000, 14, 8, io_done, NULL) == 0);
    2058                 :          4 :         bdev_ch[2] = spdk_io_channel_get_ctx(ch[2]);
    2059                 :          4 :         CU_ASSERT(bdev_channel_count_submitted_io(bdev_ch[2]) == 3);
    2060                 :            : 
    2061                 :          4 :         set_thread(0);
    2062         [ -  + ]:          4 :         memset(&cb_arg, 0, sizeof(cb_arg));
    2063                 :          4 :         spdk_delay_us(3 * spdk_get_ticks_hz());
    2064                 :          4 :         poll_threads();
    2065                 :          4 :         CU_ASSERT(cb_arg.type == 0);
    2066                 :          4 :         CU_ASSERT(cb_arg.iov.iov_base == (void *)0x0);
    2067                 :          4 :         CU_ASSERT(cb_arg.iov.iov_len == 0);
    2068                 :            : 
    2069                 :            :         /* Now the time reach the limit */
    2070                 :          4 :         spdk_delay_us(3 * spdk_get_ticks_hz());
    2071                 :          4 :         poll_thread(0);
    2072                 :          4 :         CU_ASSERT(cb_arg.type == SPDK_BDEV_IO_TYPE_READ);
    2073                 :          4 :         CU_ASSERT(cb_arg.iov.iov_base == (void *)0x2000);
    2074                 :          4 :         CU_ASSERT(cb_arg.iov.iov_len == 1 * g_bdev.bdev.blocklen);
    2075                 :          4 :         stub_complete_io(g_bdev.io_target, 1);
    2076                 :          4 :         CU_ASSERT(bdev_channel_count_submitted_io(bdev_ch[0]) == 0);
    2077                 :            : 
    2078         [ -  + ]:          4 :         memset(&cb_arg, 0, sizeof(cb_arg));
    2079                 :          4 :         set_thread(1);
    2080                 :          4 :         poll_thread(1);
    2081                 :          4 :         CU_ASSERT(cb_arg.type == SPDK_BDEV_IO_TYPE_WRITE);
    2082                 :          4 :         CU_ASSERT(cb_arg.iov.iov_base == (void *)0x1000);
    2083                 :          4 :         CU_ASSERT(cb_arg.iov.iov_len == 1 * g_bdev.bdev.blocklen);
    2084                 :          4 :         stub_complete_io(g_bdev.io_target, 1);
    2085                 :          4 :         CU_ASSERT(bdev_channel_count_submitted_io(bdev_ch[1]) == 0);
    2086                 :            : 
    2087         [ -  + ]:          4 :         memset(&cb_arg, 0, sizeof(cb_arg));
    2088                 :          4 :         set_thread(2);
    2089                 :          4 :         poll_thread(2);
    2090                 :          4 :         CU_ASSERT(cb_arg.type == SPDK_BDEV_IO_TYPE_READ);
    2091                 :          4 :         CU_ASSERT(cb_arg.iov.iov_base == (void *)0xF000);
    2092                 :          4 :         CU_ASSERT(cb_arg.iov.iov_len == 8 * g_bdev.bdev.blocklen);
    2093                 :          4 :         stub_complete_io(g_bdev.io_target, 1);
    2094                 :          4 :         CU_ASSERT(bdev_channel_count_submitted_io(bdev_ch[2]) == 2);
    2095                 :          4 :         stub_complete_io(g_bdev.io_target, 1);
    2096                 :          4 :         CU_ASSERT(bdev_channel_count_submitted_io(bdev_ch[2]) == 0);
    2097                 :            : 
    2098                 :            :         /* Run poll_timeout_done() it means complete the timeout poller */
    2099                 :          4 :         set_thread(0);
    2100                 :          4 :         poll_thread(0);
    2101                 :          4 :         CU_ASSERT(g_desc->refs == 0);
    2102                 :          4 :         CU_ASSERT(spdk_bdev_read_blocks(g_desc, ch[0], (void *)0x1000, 0, 1, io_done, NULL) == 0);
    2103                 :          4 :         set_thread(1);
    2104                 :          4 :         CU_ASSERT(spdk_bdev_write_blocks(g_desc, ch[1], (void *)0x2000, 0, 2, io_done, NULL) == 0);
    2105                 :          4 :         set_thread(2);
    2106                 :          4 :         CU_ASSERT(spdk_bdev_read_blocks(g_desc, ch[2], (void *)0x3000, 0, 3, io_done, NULL) == 0);
    2107                 :            : 
    2108                 :            :         /* Trigger timeout poller to run again, desc->refs is incremented.
    2109                 :            :          * In thread 0 we destroy the io channel before timeout poller runs.
    2110                 :            :          * Timeout callback is not called on thread 0.
    2111                 :            :          */
    2112                 :          4 :         spdk_delay_us(6 * spdk_get_ticks_hz());
    2113         [ -  + ]:          4 :         memset(&cb_arg, 0, sizeof(cb_arg));
    2114                 :          4 :         set_thread(0);
    2115                 :          4 :         stub_complete_io(g_bdev.io_target, 1);
    2116                 :          4 :         spdk_put_io_channel(ch[0]);
    2117                 :          4 :         poll_thread(0);
    2118                 :          4 :         CU_ASSERT(g_desc->refs == 1)
    2119                 :          4 :         CU_ASSERT(cb_arg.type == 0);
    2120                 :          4 :         CU_ASSERT(cb_arg.iov.iov_base == (void *)0x0);
    2121                 :          4 :         CU_ASSERT(cb_arg.iov.iov_len == 0);
    2122                 :            : 
    2123                 :            :         /* In thread 1 timeout poller runs then we destroy the io channel
    2124                 :            :          * Timeout callback is called on thread 1.
    2125                 :            :          */
    2126         [ -  + ]:          4 :         memset(&cb_arg, 0, sizeof(cb_arg));
    2127                 :          4 :         set_thread(1);
    2128                 :          4 :         poll_thread(1);
    2129                 :          4 :         stub_complete_io(g_bdev.io_target, 1);
    2130                 :          4 :         spdk_put_io_channel(ch[1]);
    2131                 :          4 :         poll_thread(1);
    2132                 :          4 :         CU_ASSERT(cb_arg.type == SPDK_BDEV_IO_TYPE_WRITE);
    2133                 :          4 :         CU_ASSERT(cb_arg.iov.iov_base == (void *)0x2000);
    2134                 :          4 :         CU_ASSERT(cb_arg.iov.iov_len == 2 * g_bdev.bdev.blocklen);
    2135                 :            : 
    2136                 :            :         /* Close the desc.
    2137                 :            :          * Unregister the timeout poller first.
    2138                 :            :          * Then decrement desc->refs but it's not zero yet so desc is not freed.
    2139                 :            :          */
    2140                 :          4 :         set_thread(0);
    2141                 :          4 :         spdk_bdev_close(g_desc);
    2142                 :          4 :         CU_ASSERT(g_desc->refs == 1);
    2143                 :          4 :         CU_ASSERT(g_desc->io_timeout_poller == NULL);
    2144                 :            : 
    2145                 :            :         /* Timeout poller runs on thread 2 then we destroy the io channel.
    2146                 :            :          * Desc is closed so we would exit the timeout poller directly.
    2147                 :            :          * timeout callback is not called on thread 2.
    2148                 :            :          */
    2149         [ -  + ]:          4 :         memset(&cb_arg, 0, sizeof(cb_arg));
    2150                 :          4 :         set_thread(2);
    2151                 :          4 :         poll_thread(2);
    2152                 :          4 :         stub_complete_io(g_bdev.io_target, 1);
    2153                 :          4 :         spdk_put_io_channel(ch[2]);
    2154                 :          4 :         poll_thread(2);
    2155                 :          4 :         CU_ASSERT(cb_arg.type == 0);
    2156                 :          4 :         CU_ASSERT(cb_arg.iov.iov_base == (void *)0x0);
    2157                 :          4 :         CU_ASSERT(cb_arg.iov.iov_len == 0);
    2158                 :            : 
    2159                 :          4 :         set_thread(0);
    2160                 :          4 :         poll_thread(0);
    2161                 :          4 :         g_teardown_done = false;
    2162                 :          4 :         unregister_bdev(&g_bdev);
    2163                 :          4 :         spdk_io_device_unregister(&g_io_device, NULL);
    2164                 :          4 :         spdk_bdev_finish(finish_cb, NULL);
    2165                 :          4 :         spdk_iobuf_finish(finish_cb, NULL);
    2166                 :          4 :         poll_threads();
    2167         [ -  + ]:          4 :         memset(&g_bdev, 0, sizeof(g_bdev));
    2168         [ -  + ]:          4 :         CU_ASSERT(g_teardown_done == true);
    2169                 :          4 :         g_teardown_done = false;
    2170                 :          4 :         free_threads();
    2171                 :          4 :         free_cores();
    2172                 :          4 : }
    2173                 :            : 
    2174                 :            : static bool g_io_done2;
    2175                 :            : static bool g_lock_lba_range_done;
    2176                 :            : static bool g_unlock_lba_range_done;
    2177                 :            : 
    2178                 :            : static void
    2179                 :          4 : io_done2(struct spdk_bdev_io *bdev_io, bool success, void *cb_arg)
    2180                 :            : {
    2181                 :          4 :         g_io_done2 = true;
    2182                 :          4 :         spdk_bdev_free_io(bdev_io);
    2183                 :          4 : }
    2184                 :            : 
    2185                 :            : static void
    2186                 :          4 : lock_lba_range_done(struct lba_range *range, void *ctx, int status)
    2187                 :            : {
    2188                 :          4 :         g_lock_lba_range_done = true;
    2189                 :          4 : }
    2190                 :            : 
    2191                 :            : static void
    2192                 :          4 : unlock_lba_range_done(struct lba_range *range, void *ctx, int status)
    2193                 :            : {
    2194                 :          4 :         g_unlock_lba_range_done = true;
    2195                 :          4 : }
    2196                 :            : 
    2197                 :            : static uint32_t
    2198                 :         24 : stub_channel_outstanding_cnt(void *io_target)
    2199                 :            : {
    2200                 :         24 :         struct spdk_io_channel *_ch = spdk_get_io_channel(io_target);
    2201                 :         24 :         struct ut_bdev_channel *ch = spdk_io_channel_get_ctx(_ch);
    2202                 :            :         uint32_t outstanding_cnt;
    2203                 :            : 
    2204                 :         24 :         outstanding_cnt = ch->outstanding_cnt;
    2205                 :            : 
    2206                 :         24 :         spdk_put_io_channel(_ch);
    2207                 :         24 :         return outstanding_cnt;
    2208                 :            : }
    2209                 :            : 
    2210                 :            : static void
    2211                 :          4 : lock_lba_range_then_submit_io(void)
    2212                 :            : {
    2213                 :          4 :         struct spdk_bdev_desc *desc = NULL;
    2214                 :            :         void *io_target;
    2215                 :            :         struct spdk_io_channel *io_ch[3];
    2216                 :            :         struct spdk_bdev_channel *bdev_ch[3];
    2217                 :            :         struct lba_range *range;
    2218                 :          4 :         char buf[4096];
    2219                 :          4 :         int ctx0, ctx1, ctx2;
    2220                 :            :         int rc;
    2221                 :            : 
    2222                 :          4 :         setup_test();
    2223                 :            : 
    2224                 :          4 :         io_target = g_bdev.io_target;
    2225                 :          4 :         desc = g_desc;
    2226                 :            : 
    2227                 :          4 :         set_thread(0);
    2228                 :          4 :         io_ch[0] = spdk_bdev_get_io_channel(desc);
    2229                 :          4 :         bdev_ch[0] = spdk_io_channel_get_ctx(io_ch[0]);
    2230                 :          4 :         CU_ASSERT(io_ch[0] != NULL);
    2231                 :            : 
    2232                 :          4 :         set_thread(1);
    2233                 :          4 :         io_ch[1] = spdk_bdev_get_io_channel(desc);
    2234                 :          4 :         bdev_ch[1] = spdk_io_channel_get_ctx(io_ch[1]);
    2235                 :          4 :         CU_ASSERT(io_ch[1] != NULL);
    2236                 :            : 
    2237                 :          4 :         set_thread(0);
    2238                 :          4 :         g_lock_lba_range_done = false;
    2239                 :          4 :         rc = bdev_lock_lba_range(desc, io_ch[0], 20, 10, lock_lba_range_done, &ctx0);
    2240                 :          4 :         CU_ASSERT(rc == 0);
    2241                 :          4 :         poll_threads();
    2242                 :            : 
    2243                 :            :         /* The lock should immediately become valid, since there are no outstanding
    2244                 :            :          * write I/O.
    2245                 :            :          */
    2246         [ -  + ]:          4 :         CU_ASSERT(g_lock_lba_range_done == true);
    2247                 :          4 :         range = TAILQ_FIRST(&bdev_ch[0]->locked_ranges);
    2248         [ -  + ]:          4 :         SPDK_CU_ASSERT_FATAL(range != NULL);
    2249                 :          4 :         CU_ASSERT(range->offset == 20);
    2250                 :          4 :         CU_ASSERT(range->length == 10);
    2251                 :          4 :         CU_ASSERT(range->owner_ch == bdev_ch[0]);
    2252                 :            : 
    2253                 :          4 :         g_io_done = false;
    2254                 :          4 :         CU_ASSERT(TAILQ_EMPTY(&bdev_ch[0]->io_locked));
    2255                 :          4 :         rc = spdk_bdev_read_blocks(desc, io_ch[0], buf, 20, 1, io_done, &ctx0);
    2256                 :          4 :         CU_ASSERT(rc == 0);
    2257                 :          4 :         CU_ASSERT(stub_channel_outstanding_cnt(io_target) == 1);
    2258                 :            : 
    2259                 :          4 :         stub_complete_io(io_target, 1);
    2260                 :          4 :         poll_threads();
    2261         [ -  + ]:          4 :         CU_ASSERT(g_io_done == true);
    2262                 :          4 :         CU_ASSERT(TAILQ_EMPTY(&bdev_ch[0]->io_locked));
    2263                 :            : 
    2264                 :            :         /* Try a write I/O.  This should actually be allowed to execute, since the channel
    2265                 :            :          * holding the lock is submitting the write I/O.
    2266                 :            :          */
    2267                 :          4 :         g_io_done = false;
    2268                 :          4 :         CU_ASSERT(TAILQ_EMPTY(&bdev_ch[0]->io_locked));
    2269                 :          4 :         rc = spdk_bdev_write_blocks(desc, io_ch[0], buf, 20, 1, io_done, &ctx0);
    2270                 :          4 :         CU_ASSERT(rc == 0);
    2271                 :          4 :         CU_ASSERT(stub_channel_outstanding_cnt(io_target) == 1);
    2272                 :            : 
    2273                 :          4 :         stub_complete_io(io_target, 1);
    2274                 :          4 :         poll_threads();
    2275         [ -  + ]:          4 :         CU_ASSERT(g_io_done == true);
    2276                 :          4 :         CU_ASSERT(TAILQ_EMPTY(&bdev_ch[0]->io_locked));
    2277                 :            : 
    2278                 :            :         /* Try a write I/O.  This should get queued in the io_locked tailq. */
    2279                 :          4 :         set_thread(1);
    2280                 :          4 :         g_io_done = false;
    2281                 :          4 :         CU_ASSERT(TAILQ_EMPTY(&bdev_ch[1]->io_locked));
    2282                 :          4 :         rc = spdk_bdev_write_blocks(desc, io_ch[1], buf, 20, 1, io_done, &ctx1);
    2283                 :          4 :         CU_ASSERT(rc == 0);
    2284                 :          4 :         poll_threads();
    2285                 :          4 :         CU_ASSERT(stub_channel_outstanding_cnt(io_target) == 0);
    2286                 :          4 :         CU_ASSERT(!TAILQ_EMPTY(&bdev_ch[1]->io_locked));
    2287         [ -  + ]:          4 :         CU_ASSERT(g_io_done == false);
    2288                 :            : 
    2289                 :            :         /* Try to unlock the lba range using thread 1's io_ch.  This should fail. */
    2290                 :          4 :         rc = bdev_unlock_lba_range(desc, io_ch[1], 20, 10, unlock_lba_range_done, &ctx1);
    2291                 :          4 :         CU_ASSERT(rc == -EINVAL);
    2292                 :            : 
    2293                 :            :         /* Now create a new channel and submit a write I/O with it.  This should also be queued.
    2294                 :            :          * The new channel should inherit the active locks from the bdev's internal list.
    2295                 :            :          */
    2296                 :          4 :         set_thread(2);
    2297                 :          4 :         io_ch[2] = spdk_bdev_get_io_channel(desc);
    2298                 :          4 :         bdev_ch[2] = spdk_io_channel_get_ctx(io_ch[2]);
    2299                 :          4 :         CU_ASSERT(io_ch[2] != NULL);
    2300                 :            : 
    2301                 :          4 :         g_io_done2 = false;
    2302                 :          4 :         CU_ASSERT(TAILQ_EMPTY(&bdev_ch[2]->io_locked));
    2303                 :          4 :         rc = spdk_bdev_write_blocks(desc, io_ch[2], buf, 22, 2, io_done2, &ctx2);
    2304                 :          4 :         CU_ASSERT(rc == 0);
    2305                 :          4 :         poll_threads();
    2306                 :          4 :         CU_ASSERT(stub_channel_outstanding_cnt(io_target) == 0);
    2307                 :          4 :         CU_ASSERT(!TAILQ_EMPTY(&bdev_ch[2]->io_locked));
    2308         [ -  + ]:          4 :         CU_ASSERT(g_io_done2 == false);
    2309                 :            : 
    2310                 :          4 :         set_thread(0);
    2311                 :          4 :         rc = bdev_unlock_lba_range(desc, io_ch[0], 20, 10, unlock_lba_range_done, &ctx0);
    2312                 :          4 :         CU_ASSERT(rc == 0);
    2313                 :          4 :         poll_threads();
    2314                 :          4 :         CU_ASSERT(TAILQ_EMPTY(&bdev_ch[0]->locked_ranges));
    2315                 :            : 
    2316                 :            :         /* The LBA range is unlocked, so the write IOs should now have started execution. */
    2317                 :          4 :         CU_ASSERT(TAILQ_EMPTY(&bdev_ch[1]->io_locked));
    2318                 :          4 :         CU_ASSERT(TAILQ_EMPTY(&bdev_ch[2]->io_locked));
    2319                 :            : 
    2320                 :          4 :         set_thread(1);
    2321                 :          4 :         CU_ASSERT(stub_channel_outstanding_cnt(io_target) == 1);
    2322                 :          4 :         stub_complete_io(io_target, 1);
    2323                 :          4 :         set_thread(2);
    2324                 :          4 :         CU_ASSERT(stub_channel_outstanding_cnt(io_target) == 1);
    2325                 :          4 :         stub_complete_io(io_target, 1);
    2326                 :            : 
    2327                 :          4 :         poll_threads();
    2328         [ -  + ]:          4 :         CU_ASSERT(g_io_done == true);
    2329         [ -  + ]:          4 :         CU_ASSERT(g_io_done2 == true);
    2330                 :            : 
    2331                 :            :         /* Tear down the channels */
    2332                 :          4 :         set_thread(0);
    2333                 :          4 :         spdk_put_io_channel(io_ch[0]);
    2334                 :          4 :         set_thread(1);
    2335                 :          4 :         spdk_put_io_channel(io_ch[1]);
    2336                 :          4 :         set_thread(2);
    2337                 :          4 :         spdk_put_io_channel(io_ch[2]);
    2338                 :          4 :         poll_threads();
    2339                 :          4 :         set_thread(0);
    2340                 :          4 :         teardown_test();
    2341                 :          4 : }
    2342                 :            : 
    2343                 :            : /* spdk_bdev_reset() freezes and unfreezes I/O channels by using spdk_for_each_channel().
    2344                 :            :  * spdk_bdev_unregister() calls spdk_io_device_unregister() in the end. However
    2345                 :            :  * spdk_io_device_unregister() fails if it is called while executing spdk_for_each_channel().
    2346                 :            :  * Hence, in this case, spdk_io_device_unregister() is deferred until spdk_bdev_reset()
    2347                 :            :  * completes. Test this behavior.
    2348                 :            :  */
    2349                 :            : static void
    2350                 :          4 : unregister_during_reset(void)
    2351                 :            : {
    2352                 :            :         struct spdk_io_channel *io_ch[2];
    2353                 :          4 :         bool done_reset = false, done_unregister = false;
    2354                 :            :         int rc;
    2355                 :            : 
    2356                 :          4 :         setup_test();
    2357                 :          4 :         set_thread(0);
    2358                 :            : 
    2359                 :          4 :         io_ch[0] = spdk_bdev_get_io_channel(g_desc);
    2360         [ -  + ]:          4 :         SPDK_CU_ASSERT_FATAL(io_ch[0] != NULL);
    2361                 :            : 
    2362                 :          4 :         set_thread(1);
    2363                 :            : 
    2364                 :          4 :         io_ch[1] = spdk_bdev_get_io_channel(g_desc);
    2365         [ -  + ]:          4 :         SPDK_CU_ASSERT_FATAL(io_ch[1] != NULL);
    2366                 :            : 
    2367                 :          4 :         set_thread(0);
    2368                 :            : 
    2369                 :          4 :         CU_ASSERT(g_bdev.bdev.internal.reset_in_progress == NULL);
    2370                 :            : 
    2371                 :          4 :         rc = spdk_bdev_reset(g_desc, io_ch[0], reset_done, &done_reset);
    2372                 :          4 :         CU_ASSERT(rc == 0);
    2373                 :            : 
    2374                 :          4 :         set_thread(0);
    2375                 :            : 
    2376                 :          4 :         poll_thread_times(0, 1);
    2377                 :            : 
    2378                 :          4 :         spdk_bdev_close(g_desc);
    2379                 :          4 :         spdk_bdev_unregister(&g_bdev.bdev, _bdev_unregistered, &done_unregister);
    2380                 :            : 
    2381         [ -  + ]:          4 :         CU_ASSERT(done_reset == false);
    2382         [ -  + ]:          4 :         CU_ASSERT(done_unregister == false);
    2383                 :            : 
    2384                 :          4 :         poll_threads();
    2385                 :            : 
    2386                 :          4 :         stub_complete_io(g_bdev.io_target, 0);
    2387                 :            : 
    2388                 :          4 :         poll_threads();
    2389                 :            : 
    2390         [ -  + ]:          4 :         CU_ASSERT(done_reset == true);
    2391         [ -  + ]:          4 :         CU_ASSERT(done_unregister == false);
    2392                 :            : 
    2393                 :          4 :         spdk_put_io_channel(io_ch[0]);
    2394                 :            : 
    2395                 :          4 :         set_thread(1);
    2396                 :            : 
    2397                 :          4 :         spdk_put_io_channel(io_ch[1]);
    2398                 :            : 
    2399                 :          4 :         poll_threads();
    2400                 :            : 
    2401         [ -  + ]:          4 :         CU_ASSERT(done_unregister == true);
    2402                 :            : 
    2403                 :            :         /* Restore the original g_bdev so that we can use teardown_test(). */
    2404                 :          4 :         set_thread(0);
    2405                 :          4 :         register_bdev(&g_bdev, "ut_bdev", &g_io_device);
    2406                 :          4 :         spdk_bdev_open_ext("ut_bdev", true, _bdev_event_cb, NULL, &g_desc);
    2407                 :          4 :         teardown_test();
    2408                 :          4 : }
    2409                 :            : 
    2410                 :            : static void
    2411                 :          4 : bdev_init_wt_cb(void *done, int rc)
    2412                 :            : {
    2413                 :          4 : }
    2414                 :            : 
    2415                 :            : static int
    2416                 :          4 : wrong_thread_setup(void)
    2417                 :            : {
    2418                 :          4 :         allocate_cores(1);
    2419                 :          4 :         allocate_threads(2);
    2420                 :          4 :         set_thread(0);
    2421                 :            : 
    2422                 :          4 :         spdk_io_device_register(&g_accel_io_device, ut_accel_ch_create_cb,
    2423                 :            :                                 ut_accel_ch_destroy_cb, 0, NULL);
    2424                 :          4 :         spdk_bdev_initialize(bdev_init_wt_cb, NULL);
    2425                 :          4 :         spdk_io_device_register(&g_io_device, stub_create_ch, stub_destroy_ch,
    2426                 :            :                                 sizeof(struct ut_bdev_channel), NULL);
    2427                 :            : 
    2428                 :          4 :         set_thread(1);
    2429                 :            : 
    2430                 :          4 :         return 0;
    2431                 :            : }
    2432                 :            : 
    2433                 :            : static int
    2434                 :          4 : wrong_thread_teardown(void)
    2435                 :            : {
    2436                 :          4 :         int rc = 0;
    2437                 :            : 
    2438                 :          4 :         set_thread(0);
    2439                 :            : 
    2440                 :          4 :         g_teardown_done = false;
    2441                 :          4 :         spdk_io_device_unregister(&g_io_device, NULL);
    2442                 :          4 :         spdk_bdev_finish(finish_cb, NULL);
    2443                 :          4 :         poll_threads();
    2444         [ -  + ]:          4 :         memset(&g_bdev, 0, sizeof(g_bdev));
    2445   [ -  +  -  + ]:          4 :         if (!g_teardown_done) {
    2446   [ #  #  #  # ]:          0 :                 fprintf(stderr, "%s:%d %s: teardown not done\n", __FILE__, __LINE__, __func__);
    2447                 :          0 :                 rc = -1;
    2448                 :            :         }
    2449                 :          4 :         g_teardown_done = false;
    2450                 :            : 
    2451                 :          4 :         spdk_io_device_unregister(&g_accel_io_device, NULL);
    2452                 :          4 :         free_threads();
    2453                 :          4 :         free_cores();
    2454                 :            : 
    2455                 :          4 :         return rc;
    2456                 :            : }
    2457                 :            : 
    2458                 :            : static void
    2459                 :          8 : _bdev_unregistered_wt(void *ctx, int rc)
    2460                 :            : {
    2461                 :          8 :         struct spdk_thread **threadp = ctx;
    2462                 :            : 
    2463                 :          8 :         *threadp = spdk_get_thread();
    2464                 :          8 : }
    2465                 :            : 
    2466                 :            : static void
    2467                 :          4 : spdk_bdev_register_wt(void)
    2468                 :            : {
    2469                 :          4 :         struct spdk_bdev bdev = { 0 };
    2470                 :            :         int rc;
    2471                 :          4 :         struct spdk_thread *unreg_thread;
    2472                 :            : 
    2473                 :          4 :         bdev.name = "wt_bdev";
    2474                 :          4 :         bdev.fn_table = &fn_table;
    2475                 :          4 :         bdev.module = &bdev_ut_if;
    2476                 :          4 :         bdev.blocklen = 4096;
    2477                 :          4 :         bdev.blockcnt = 1024;
    2478                 :            : 
    2479                 :            :         /* Can register only on app thread */
    2480                 :          4 :         rc = spdk_bdev_register(&bdev);
    2481                 :          4 :         CU_ASSERT(rc == -EINVAL);
    2482                 :            : 
    2483                 :            :         /* Can unregister on any thread */
    2484                 :          4 :         set_thread(0);
    2485                 :          4 :         rc = spdk_bdev_register(&bdev);
    2486                 :          4 :         CU_ASSERT(rc == 0);
    2487                 :          4 :         set_thread(1);
    2488                 :          4 :         unreg_thread = NULL;
    2489                 :          4 :         spdk_bdev_unregister(&bdev, _bdev_unregistered_wt, &unreg_thread);
    2490                 :          4 :         poll_threads();
    2491                 :          4 :         CU_ASSERT(unreg_thread == spdk_get_thread());
    2492                 :            : 
    2493                 :            :         /* Can unregister by name on any thread */
    2494                 :          4 :         set_thread(0);
    2495                 :          4 :         rc = spdk_bdev_register(&bdev);
    2496                 :          4 :         CU_ASSERT(rc == 0);
    2497                 :          4 :         set_thread(1);
    2498                 :          4 :         unreg_thread = NULL;
    2499                 :          4 :         rc = spdk_bdev_unregister_by_name(bdev.name, bdev.module, _bdev_unregistered_wt,
    2500                 :            :                                           &unreg_thread);
    2501                 :          4 :         CU_ASSERT(rc == 0);
    2502                 :          4 :         poll_threads();
    2503                 :          4 :         CU_ASSERT(unreg_thread == spdk_get_thread());
    2504                 :          4 : }
    2505                 :            : 
    2506                 :            : static void
    2507                 :          8 : wait_for_examine_cb(void *arg)
    2508                 :            : {
    2509                 :          8 :         struct spdk_thread **thread = arg;
    2510                 :            : 
    2511                 :          8 :         *thread = spdk_get_thread();
    2512                 :          8 : }
    2513                 :            : 
    2514                 :            : static void
    2515                 :          4 : spdk_bdev_examine_wt(void)
    2516                 :            : {
    2517                 :            :         int rc;
    2518         [ -  + ]:          4 :         bool save_auto_examine = g_bdev_opts.bdev_auto_examine;
    2519                 :          4 :         struct spdk_thread *thread;
    2520                 :            : 
    2521                 :          4 :         g_bdev_opts.bdev_auto_examine = false;
    2522                 :            : 
    2523                 :          4 :         set_thread(0);
    2524                 :          4 :         register_bdev(&g_bdev, "ut_bdev_wt", &g_io_device);
    2525                 :          4 :         CU_ASSERT(spdk_bdev_get_by_name("ut_bdev_wt") != NULL);
    2526                 :          4 :         set_thread(1);
    2527                 :            : 
    2528                 :            :         /* Can examine only on the app thread */
    2529                 :          4 :         rc = spdk_bdev_examine("ut_bdev_wt");
    2530                 :          4 :         CU_ASSERT(rc == -EINVAL);
    2531                 :          4 :         unregister_bdev(&g_bdev);
    2532                 :          4 :         CU_ASSERT(spdk_bdev_get_by_name("ut_bdev_wt") == NULL);
    2533                 :            : 
    2534                 :            :         /* Can wait for examine on app thread, callback called on app thread. */
    2535                 :          4 :         set_thread(0);
    2536                 :          4 :         register_bdev(&g_bdev, "ut_bdev_wt", &g_io_device);
    2537                 :          4 :         CU_ASSERT(spdk_bdev_get_by_name("ut_bdev_wt") != NULL);
    2538                 :          4 :         thread = NULL;
    2539                 :          4 :         rc = spdk_bdev_wait_for_examine(wait_for_examine_cb, &thread);
    2540                 :          4 :         CU_ASSERT(rc == 0);
    2541                 :          4 :         poll_threads();
    2542                 :          4 :         CU_ASSERT(thread == spdk_get_thread());
    2543                 :          4 :         unregister_bdev(&g_bdev);
    2544                 :          4 :         CU_ASSERT(spdk_bdev_get_by_name("ut_bdev_wt") == NULL);
    2545                 :            : 
    2546                 :            :         /* Can wait for examine on non-app thread, callback called on same thread. */
    2547                 :          4 :         set_thread(0);
    2548                 :          4 :         register_bdev(&g_bdev, "ut_bdev_wt", &g_io_device);
    2549                 :          4 :         CU_ASSERT(spdk_bdev_get_by_name("ut_bdev_wt") != NULL);
    2550                 :          4 :         thread = NULL;
    2551                 :          4 :         rc = spdk_bdev_wait_for_examine(wait_for_examine_cb, &thread);
    2552                 :          4 :         CU_ASSERT(rc == 0);
    2553                 :          4 :         poll_threads();
    2554                 :          4 :         CU_ASSERT(thread == spdk_get_thread());
    2555                 :          4 :         unregister_bdev(&g_bdev);
    2556                 :          4 :         CU_ASSERT(spdk_bdev_get_by_name("ut_bdev_wt") == NULL);
    2557                 :            : 
    2558                 :          4 :         unregister_bdev(&g_bdev);
    2559                 :          4 :         g_bdev_opts.bdev_auto_examine = save_auto_examine;
    2560                 :          4 : }
    2561                 :            : 
    2562                 :            : static void
    2563                 :          4 : event_notify_and_close(void)
    2564                 :            : {
    2565                 :          4 :         int resize_notify_count = 0;
    2566                 :          4 :         struct spdk_bdev_desc *desc = NULL;
    2567                 :            :         struct spdk_bdev *bdev;
    2568                 :            :         int rc;
    2569                 :            : 
    2570                 :          4 :         setup_test();
    2571                 :          4 :         set_thread(0);
    2572                 :            : 
    2573                 :            :         /* setup_test() automatically opens the bdev, but this test needs to do
    2574                 :            :          * that in a different way. */
    2575                 :          4 :         spdk_bdev_close(g_desc);
    2576                 :          4 :         poll_threads();
    2577                 :            : 
    2578                 :          4 :         set_thread(1);
    2579                 :            : 
    2580                 :          4 :         rc = spdk_bdev_open_ext("ut_bdev", true, _bdev_event_cb, &resize_notify_count, &desc);
    2581                 :          4 :         CU_ASSERT(rc == 0);
    2582         [ -  + ]:          4 :         SPDK_CU_ASSERT_FATAL(desc != NULL);
    2583                 :            : 
    2584                 :          4 :         bdev = spdk_bdev_desc_get_bdev(desc);
    2585         [ -  + ]:          4 :         SPDK_CU_ASSERT_FATAL(bdev != NULL);
    2586                 :            : 
    2587                 :            :         /* Test a normal case that a resize event is notified. */
    2588                 :          4 :         set_thread(0);
    2589                 :            : 
    2590                 :          4 :         rc = spdk_bdev_notify_blockcnt_change(bdev, 1024 * 2);
    2591                 :          4 :         CU_ASSERT(rc == 0);
    2592                 :          4 :         CU_ASSERT(bdev->blockcnt == 1024 * 2);
    2593                 :          4 :         CU_ASSERT(desc->refs == 1);
    2594                 :          4 :         CU_ASSERT(resize_notify_count == 0);
    2595                 :            : 
    2596                 :          4 :         poll_threads();
    2597                 :            : 
    2598                 :          4 :         CU_ASSERT(desc->refs == 0);
    2599                 :          4 :         CU_ASSERT(resize_notify_count == 1);
    2600                 :            : 
    2601                 :            :         /* Test a complex case if the bdev is closed after two event_notify messages are sent,
    2602                 :            :          * then both event_notify messages are discarded and the desc is freed.
    2603                 :            :          */
    2604                 :          4 :         rc = spdk_bdev_notify_blockcnt_change(bdev, 1024 * 3);
    2605                 :          4 :         CU_ASSERT(rc == 0);
    2606                 :          4 :         CU_ASSERT(bdev->blockcnt == 1024 * 3);
    2607                 :          4 :         CU_ASSERT(desc->refs == 1);
    2608                 :          4 :         CU_ASSERT(resize_notify_count == 1);
    2609                 :            : 
    2610                 :          4 :         rc = spdk_bdev_notify_blockcnt_change(bdev, 1024 * 4);
    2611                 :          4 :         CU_ASSERT(rc == 0);
    2612                 :          4 :         CU_ASSERT(bdev->blockcnt == 1024 * 4);
    2613                 :          4 :         CU_ASSERT(desc->refs == 2);
    2614                 :          4 :         CU_ASSERT(resize_notify_count == 1);
    2615                 :            : 
    2616                 :          4 :         set_thread(1);
    2617                 :            : 
    2618                 :          4 :         spdk_bdev_close(desc);
    2619         [ -  + ]:          4 :         CU_ASSERT(desc->closed == true);
    2620                 :          4 :         CU_ASSERT(desc->refs == 2);
    2621                 :          4 :         CU_ASSERT(resize_notify_count == 1);
    2622                 :            : 
    2623                 :          4 :         poll_threads();
    2624                 :            : 
    2625                 :          4 :         CU_ASSERT(resize_notify_count == 1);
    2626                 :            : 
    2627                 :          4 :         set_thread(0);
    2628                 :            : 
    2629                 :            :         /* Restore g_desc. Then, we can execute teardown_test(). */
    2630                 :          4 :         spdk_bdev_open_ext("ut_bdev", true, _bdev_event_cb, NULL, &g_desc);
    2631                 :          4 :         teardown_test();
    2632                 :          4 : }
    2633                 :            : 
    2634                 :            : /* There was a bug that bdev_channel_poll_qos() called spdk_for_each_channel()
    2635                 :            :  * after spdk_io_device_unregister() is called for a bdev.
    2636                 :            :  *
    2637                 :            :  * This occurred in the following sequence.
    2638                 :            :  * - There was a bdev and a channel for it.
    2639                 :            :  * - QoS was enabled and started.
    2640                 :            :  * - spdk_bdev_unregister() was called. However, there was a open descriptor.
    2641                 :            :  *   Hence, remove notification was sent and unregistration was pending.
    2642                 :            :  * - Receiving a event notification, spdk_put_io_channel() and spdk_bdev_close() were
    2643                 :            :  *   called. In spdk_bdev_close(), the existing QoS was unbound and a message was sent
    2644                 :            :  *   to it, and then the pending spdk_io_device_unregister() was finally executed.
    2645                 :            :  * - If bdev_channel_poll_qos() was executed before the message was processed,
    2646                 :            :  *   bdev_channel_poll_qos() called spdk_bdev_for_each_channel() and hit assert().
    2647                 :            :  *
    2648                 :            :  * The fix was in this case bdev_channel_poll_qos() returned immediately because QoS
    2649                 :            :  * was not enabled. bdev_qos_destroy() created a new disabled QoS and swapped it with
    2650                 :            :  * the existing QoS.
    2651                 :            :  *
    2652                 :            :  * This test case was added to avoid degradation in future.
    2653                 :            :  */
    2654                 :            : static void
    2655                 :          4 : unregister_and_qos_poller(void)
    2656                 :            : {
    2657                 :            :         struct spdk_io_channel *io_ch;
    2658                 :            :         struct spdk_bdev_channel *bdev_ch;
    2659                 :          4 :         struct spdk_bdev_desc *desc = NULL;
    2660                 :            :         struct spdk_bdev_qos *old_qos;
    2661                 :          4 :         uint64_t limits[SPDK_BDEV_QOS_NUM_RATE_LIMIT_TYPES] = {};
    2662                 :          4 :         bool remove_notify = false, done_unregister = false;
    2663                 :          4 :         int status = -1, rc;
    2664                 :            : 
    2665                 :          4 :         setup_test();
    2666                 :          4 :         set_thread(0);
    2667                 :            : 
    2668                 :          4 :         MOCK_SET(spdk_get_ticks, 10);
    2669                 :            : 
    2670                 :            :         /* setup_test() automatically opens the bdev, but this test needs to do
    2671                 :            :          * that in a different way.
    2672                 :            :          */
    2673                 :          4 :         spdk_bdev_close(g_desc);
    2674                 :          4 :         poll_threads();
    2675                 :            : 
    2676                 :            :         /* We want to get remove event notification to check if unregistration
    2677                 :            :          * is deferred.
    2678                 :            :          */
    2679                 :          4 :         spdk_bdev_open_ext("ut_bdev", true, _bdev_event_cb, &remove_notify, &desc);
    2680         [ -  + ]:          4 :         SPDK_CU_ASSERT_FATAL(desc != NULL);
    2681         [ -  + ]:          4 :         CU_ASSERT(remove_notify == false);
    2682                 :            : 
    2683                 :          4 :         io_ch = spdk_bdev_get_io_channel(desc);
    2684         [ -  + ]:          4 :         SPDK_CU_ASSERT_FATAL(io_ch != NULL);
    2685                 :          4 :         bdev_ch = spdk_io_channel_get_ctx(io_ch);
    2686                 :            : 
    2687                 :          4 :         limits[SPDK_BDEV_QOS_RW_IOPS_RATE_LIMIT] = 10000;
    2688                 :          4 :         limits[SPDK_BDEV_QOS_RW_BPS_RATE_LIMIT] = 0;
    2689                 :          4 :         limits[SPDK_BDEV_QOS_R_BPS_RATE_LIMIT] = 0;
    2690                 :          4 :         limits[SPDK_BDEV_QOS_W_BPS_RATE_LIMIT] = 0;
    2691                 :          4 :         spdk_bdev_set_qos_rate_limits(&g_bdev.bdev, limits, qos_dynamic_enable_done, &status);
    2692                 :          4 :         poll_threads();
    2693                 :          4 :         CU_ASSERT(status == 0);
    2694                 :          4 :         CU_ASSERT((bdev_ch->flags & BDEV_CH_QOS_ENABLED) != 0);
    2695                 :            : 
    2696                 :          4 :         old_qos = g_bdev.bdev.internal.qos;
    2697                 :          4 :         CU_ASSERT(old_qos != NULL);
    2698                 :            : 
    2699                 :          4 :         spdk_bdev_unregister(&g_bdev.bdev, _bdev_unregistered, &done_unregister);
    2700         [ -  + ]:          4 :         CU_ASSERT(done_unregister == false);
    2701         [ -  + ]:          4 :         CU_ASSERT(remove_notify == false);
    2702                 :            : 
    2703                 :          4 :         poll_threads();
    2704         [ -  + ]:          4 :         CU_ASSERT(done_unregister == false);
    2705         [ -  + ]:          4 :         CU_ASSERT(remove_notify == true);
    2706                 :            : 
    2707                 :          4 :         spdk_put_io_channel(io_ch);
    2708                 :          4 :         spdk_bdev_close(desc);
    2709                 :            : 
    2710                 :          4 :         CU_ASSERT(g_bdev.bdev.internal.qos != NULL);
    2711                 :          4 :         CU_ASSERT(g_bdev.bdev.internal.qos->thread == NULL);
    2712                 :          4 :         CU_ASSERT(old_qos != g_bdev.bdev.internal.qos);
    2713                 :            : 
    2714                 :            :         /* bdev_channel_poll_qos() has a chance to be executed in this small window. */
    2715                 :          4 :         spdk_delay_us(SPDK_BDEV_QOS_TIMESLICE_IN_USEC);
    2716                 :            : 
    2717                 :          4 :         rc = bdev_channel_poll_qos(&g_bdev.bdev);
    2718                 :          4 :         CU_ASSERT(rc == SPDK_POLLER_IDLE);
    2719                 :            : 
    2720                 :          4 :         poll_threads();
    2721                 :            : 
    2722         [ -  + ]:          4 :         CU_ASSERT(done_unregister == true);
    2723                 :            : 
    2724                 :            :         /* Restore the original g_bdev so that we can use teardown_test(). */
    2725                 :          4 :         set_thread(0);
    2726                 :          4 :         register_bdev(&g_bdev, "ut_bdev", &g_io_device);
    2727                 :          4 :         spdk_bdev_open_ext("ut_bdev", true, _bdev_event_cb, NULL, &g_desc);
    2728                 :          4 :         teardown_test();
    2729                 :          4 : }
    2730                 :            : 
    2731                 :            : int
    2732                 :          4 : main(int argc, char **argv)
    2733                 :            : {
    2734                 :          4 :         CU_pSuite       suite = NULL;
    2735                 :          4 :         CU_pSuite       suite_wt = NULL;
    2736                 :            :         unsigned int    num_failures;
    2737                 :            : 
    2738                 :          4 :         CU_initialize_registry();
    2739                 :            : 
    2740                 :          4 :         suite = CU_add_suite("bdev", NULL, NULL);
    2741                 :          4 :         suite_wt = CU_add_suite("bdev_wrong_thread", wrong_thread_setup, wrong_thread_teardown);
    2742                 :            : 
    2743                 :          4 :         CU_ADD_TEST(suite, basic);
    2744                 :          4 :         CU_ADD_TEST(suite, unregister_and_close);
    2745                 :          4 :         CU_ADD_TEST(suite, unregister_and_close_different_threads);
    2746                 :          4 :         CU_ADD_TEST(suite, basic_qos);
    2747                 :          4 :         CU_ADD_TEST(suite, put_channel_during_reset);
    2748                 :          4 :         CU_ADD_TEST(suite, aborted_reset);
    2749                 :          4 :         CU_ADD_TEST(suite, aborted_reset_no_outstanding_io);
    2750                 :          4 :         CU_ADD_TEST(suite, io_during_reset);
    2751                 :          4 :         CU_ADD_TEST(suite, reset_completions);
    2752                 :          4 :         CU_ADD_TEST(suite, io_during_qos_queue);
    2753                 :          4 :         CU_ADD_TEST(suite, io_during_qos_reset);
    2754                 :          4 :         CU_ADD_TEST(suite, enomem);
    2755                 :          4 :         CU_ADD_TEST(suite, enomem_multi_bdev);
    2756                 :          4 :         CU_ADD_TEST(suite, enomem_multi_bdev_unregister);
    2757                 :          4 :         CU_ADD_TEST(suite, enomem_multi_io_target);
    2758                 :          4 :         CU_ADD_TEST(suite, qos_dynamic_enable);
    2759                 :          4 :         CU_ADD_TEST(suite, bdev_histograms_mt);
    2760                 :          4 :         CU_ADD_TEST(suite, bdev_set_io_timeout_mt);
    2761                 :          4 :         CU_ADD_TEST(suite, lock_lba_range_then_submit_io);
    2762                 :          4 :         CU_ADD_TEST(suite, unregister_during_reset);
    2763                 :          4 :         CU_ADD_TEST(suite_wt, spdk_bdev_register_wt);
    2764                 :          4 :         CU_ADD_TEST(suite_wt, spdk_bdev_examine_wt);
    2765                 :          4 :         CU_ADD_TEST(suite, event_notify_and_close);
    2766                 :          4 :         CU_ADD_TEST(suite, unregister_and_qos_poller);
    2767                 :            : 
    2768                 :          4 :         num_failures = spdk_ut_run_tests(argc, argv, NULL);
    2769                 :          4 :         CU_cleanup_registry();
    2770                 :          4 :         return num_failures;
    2771                 :            : }

Generated by: LCOV version 1.14