LCOV - code coverage report
Current view: top level - spdk/test/unit/lib/ftl/ftl_io.c - ftl_io_ut.c (source / functions) Hit Total Coverage
Test: Combined Lines: 101 156 64.7 %
Date: 2024-07-15 12:16:15 Functions: 8 89 9.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 8 82 9.8 %

           Branch data     Line data    Source code
       1                 :            : /*   SPDX-License-Identifier: BSD-3-Clause
       2                 :            :  *   Copyright (C) 2019 Intel Corporation.
       3                 :            :  *   All rights reserved.
       4                 :            :  */
       5                 :            : 
       6                 :            : #include "spdk/stdinc.h"
       7                 :            : 
       8                 :            : #include "spdk_internal/cunit.h"
       9                 :            : #include "common/lib/ut_multithread.c"
      10                 :            : 
      11                 :            : #include "ftl/ftl_io.c"
      12                 :            : #include "ftl/utils/ftl_conf.c"
      13                 :            : 
      14         [ #  # ]:          0 : DEFINE_STUB(spdk_bdev_io_get_append_location, uint64_t, (struct spdk_bdev_io *bdev_io), 0);
      15                 :          0 : DEFINE_STUB_V(spdk_bdev_close, (struct spdk_bdev_desc *desc));
      16         [ #  # ]:          0 : DEFINE_STUB(spdk_bdev_desc_get_bdev, struct spdk_bdev *, (struct spdk_bdev_desc *desc), NULL);
      17         [ #  # ]:          0 : DEFINE_STUB(spdk_bdev_get_optimal_open_zones, uint32_t, (const struct spdk_bdev *b), 1);
      18         [ #  # ]:          0 : DEFINE_STUB(spdk_bdev_get_by_name, struct spdk_bdev *, (const char *bdev_name), NULL);
      19   [ #  #  #  # ]:          0 : DEFINE_STUB(spdk_bdev_is_md_separate, bool, (const struct spdk_bdev *bdev), false);
      20   [ #  #  #  # ]:          0 : DEFINE_STUB(spdk_bdev_is_zoned, bool, (const struct spdk_bdev *bdev), false);
      21         [ #  # ]:          0 : DEFINE_STUB(spdk_bdev_zone_appendv, int, (struct spdk_bdev_desc *desc, struct spdk_io_channel *ch,
      22                 :            :                 struct iovec *iov, int iovcnt, uint64_t zone_id, uint64_t num_blocks,
      23                 :            :                 spdk_bdev_io_completion_cb cb, void *cb_arg), 0);
      24         [ #  # ]:          0 : DEFINE_STUB(spdk_bdev_get_zone_size, uint64_t, (const struct spdk_bdev *b), 1024);
      25                 :          0 : DEFINE_STUB_V(spdk_bdev_free_io, (struct spdk_bdev_io *bdev_io));
      26         [ #  # ]:          0 : DEFINE_STUB(spdk_bdev_get_buf_align, size_t, (const struct spdk_bdev *bdev), 64);
      27         [ #  # ]:          0 : DEFINE_STUB(spdk_bdev_get_dif_type, enum spdk_dif_type,
      28                 :            :             (const struct spdk_bdev *bdev), 0);
      29         [ #  # ]:          0 : DEFINE_STUB(spdk_bdev_get_name, const char *, (const struct spdk_bdev *bdev), "test");
      30         [ #  # ]:          0 : DEFINE_STUB(spdk_bdev_get_write_unit_size, uint32_t,
      31                 :            :             (const struct spdk_bdev *bdev), 0);
      32   [ #  #  #  # ]:          0 : DEFINE_STUB(spdk_bdev_io_type_supported, bool, (struct spdk_bdev *bdev,
      33                 :            :                 enum spdk_bdev_io_type io_type), true);
      34         [ #  # ]:          0 : DEFINE_STUB(spdk_bdev_open_ext, int,
      35                 :            :             (const char *bdev_name, bool write, spdk_bdev_event_cb_t event_cb,
      36                 :            :              void *event_ctx, struct spdk_bdev_desc **desc), 0);
      37         [ #  # ]:          0 : DEFINE_STUB(spdk_bdev_read_blocks, int, (struct spdk_bdev_desc *desc, struct spdk_io_channel *ch,
      38                 :            :                 void *buf, uint64_t offset_blocks, uint64_t num_blocks,
      39                 :            :                 spdk_bdev_io_completion_cb cb, void *cb_arg), 0);
      40         [ #  # ]:          0 : DEFINE_STUB(spdk_bdev_write_blocks, int, (struct spdk_bdev_desc *desc, struct spdk_io_channel *ch,
      41                 :            :                 void *buf, uint64_t offset_blocks, uint64_t num_blocks, spdk_bdev_io_completion_cb cb,
      42                 :            :                 void *cb_arg), 0);
      43         [ #  # ]:          0 : DEFINE_STUB(spdk_bdev_write_blocks_with_md, int, (struct spdk_bdev_desc *desc,
      44                 :            :                 struct spdk_io_channel *ch, void *buf, void *md, uint64_t offset_blocks,
      45                 :            :                 uint64_t num_blocks, spdk_bdev_io_completion_cb cb, void *cb_arg), 0);
      46         [ #  # ]:          0 : DEFINE_STUB(spdk_bdev_writev_blocks, int, (struct spdk_bdev_desc *desc, struct spdk_io_channel *ch,
      47                 :            :                 struct iovec *iov, int iovcnt, uint64_t offset_blocks, uint64_t num_blocks,
      48                 :            :                 spdk_bdev_io_completion_cb cb, void *cb_arg), 0);
      49         [ #  # ]:          0 : DEFINE_STUB(spdk_bdev_get_num_blocks, uint64_t, (const struct spdk_bdev *bdev), 1024);
      50         [ #  # ]:          0 : DEFINE_STUB(spdk_bdev_get_md_size, uint32_t, (const struct spdk_bdev *bdev), 0);
      51         [ #  # ]:          0 : DEFINE_STUB(spdk_bdev_get_block_size, uint32_t, (const struct spdk_bdev *bdev), 4096);
      52                 :          0 : DEFINE_STUB_V(spdk_bdev_module_release_bdev, (struct spdk_bdev *bdev));
      53         [ #  # ]:          0 : DEFINE_STUB(spdk_bdev_write_zeroes_blocks, int,
      54                 :            :             (struct spdk_bdev_desc *desc, struct spdk_io_channel *ch,
      55                 :            :              uint64_t offset_blocks, uint64_t num_blocks,
      56                 :            :              spdk_bdev_io_completion_cb cb, void *cb_arg), 0);
      57         [ #  # ]:          0 : DEFINE_STUB(spdk_mempool_create_ctor, struct spdk_mempool *,
      58                 :            :             (const char *name, size_t count, size_t ele_size, size_t cache_size,
      59                 :            :              int socket_id, spdk_mempool_obj_cb_t *obj_init, void *obj_init_arg), NULL);
      60         [ #  # ]:          0 : DEFINE_STUB(spdk_mempool_obj_iter, uint32_t,
      61                 :            :             (struct spdk_mempool *mp, spdk_mempool_obj_cb_t obj_cb, void *obj_cb_arg), 0);
      62                 :          0 : DEFINE_STUB_V(ftl_reloc, (struct ftl_reloc *reloc));
      63                 :          0 : DEFINE_STUB_V(ftl_reloc_free, (struct ftl_reloc *reloc));
      64                 :          0 : DEFINE_STUB_V(ftl_reloc_halt, (struct ftl_reloc *reloc));
      65         [ #  # ]:          0 : DEFINE_STUB(ftl_reloc_init, struct ftl_reloc *, (struct spdk_ftl_dev *dev), NULL);
      66   [ #  #  #  # ]:          0 : DEFINE_STUB(ftl_reloc_is_halted, bool, (const struct ftl_reloc *reloc), false);
      67                 :          0 : DEFINE_STUB_V(ftl_reloc_resume, (struct ftl_reloc *reloc));
      68                 :          0 : DEFINE_STUB_V(ftl_l2p_unpin, (struct spdk_ftl_dev *dev, uint64_t lba, uint64_t count));
      69         [ #  # ]:          0 : DEFINE_STUB(ftl_p2l_ckpt_acquire, struct ftl_p2l_ckpt *, (struct spdk_ftl_dev *dev), NULL);
      70                 :          0 : DEFINE_STUB_V(ftl_p2l_ckpt_release, (struct spdk_ftl_dev *dev, struct ftl_p2l_ckpt *ckpt));
      71         [ #  # ]:          0 : DEFINE_STUB(ftl_l2p_get, ftl_addr, (struct spdk_ftl_dev *dev, uint64_t lba), 0);
      72                 :          0 : DEFINE_STUB_V(ftl_mempool_put, (struct ftl_mempool *mpool, void *element));
      73                 :          0 : DEFINE_STUB_V(ftl_property_dump_bool, (struct spdk_ftl_dev *dev,
      74                 :            :                                        const struct ftl_property *property,
      75                 :            :                                        struct spdk_json_write_ctx *w));
      76         [ #  # ]:          0 : DEFINE_STUB(ftl_property_decode_bool, int, (struct spdk_ftl_dev *dev, struct ftl_property *property,
      77                 :            :                 const char *value, size_t value_size, void *output, size_t output_size), 0);
      78                 :          0 : DEFINE_STUB_V(ftl_property_set_generic, (struct spdk_ftl_dev *dev, struct ftl_mngt_process *mngt,
      79                 :            :                 const struct ftl_property *property, void *new_value, size_t new_value_size));
      80                 :          0 : DEFINE_STUB_V(ftl_property_register, (struct spdk_ftl_dev *dev,
      81                 :            :                                       const char *name, void *value, size_t size,
      82                 :            :                                       const char *unit, const char *desc,
      83                 :            :                                       ftl_property_dump_fn dump,
      84                 :            :                                       ftl_property_decode_fn decode,
      85                 :            :                                       ftl_property_set_fn set,
      86                 :            :                                       bool verbose_mode));
      87                 :            : 
      88                 :            : #if defined(DEBUG)
      89                 :          0 : DEFINE_STUB_V(ftl_trace_submission, (struct spdk_ftl_dev *dev, const struct ftl_io *io,
      90                 :            :                                      ftl_addr addr, size_t addr_cnt));
      91                 :          0 : DEFINE_STUB_V(ftl_trace_lba_io_init, (struct spdk_ftl_dev *dev, const struct ftl_io *io));
      92                 :          0 : DEFINE_STUB_V(ftl_trace_limits, (struct spdk_ftl_dev *dev, int limit, size_t num_free));
      93         [ #  # ]:          0 : DEFINE_STUB(ftl_trace_alloc_id, uint64_t, (struct spdk_ftl_dev *dev), 0);
      94                 :          0 : DEFINE_STUB_V(ftl_trace_completion, (struct spdk_ftl_dev *dev, const struct ftl_io *io,
      95                 :            :                                      enum ftl_trace_completion type));
      96                 :          0 : DEFINE_STUB_V(ftl_trace_write_band, (struct spdk_ftl_dev *dev, const struct ftl_band *band));
      97                 :            : #endif
      98                 :            : 
      99                 :            : #if defined(FTL_DUMP_STATS)
     100                 :            : DEFINE_STUB_V(ftl_dev_dump_stats, (const struct spdk_ftl_dev *dev));
     101                 :            : #endif
     102                 :            : 
     103                 :            : struct ftl_io_channel_ctx {
     104                 :            :         struct ftl_io_channel *ioch;
     105                 :            : };
     106                 :            : 
     107                 :            : struct ftl_io_channel *
     108                 :         36 : ftl_io_channel_get_ctx(struct spdk_io_channel *ioch)
     109                 :            : {
     110                 :         36 :         struct ftl_io_channel_ctx *ctx = spdk_io_channel_get_ctx(ioch);
     111                 :            : 
     112                 :         36 :         return ctx->ioch;
     113                 :            : }
     114                 :            : 
     115                 :            : struct spdk_io_channel *
     116                 :          0 : spdk_bdev_get_io_channel(struct spdk_bdev_desc *bdev_desc)
     117                 :            : {
     118                 :          0 :         return spdk_get_io_channel(bdev_desc);
     119                 :            : }
     120                 :            : 
     121                 :            : static int
     122                 :          0 : channel_create_cb(void *io_device, void *ctx)
     123                 :            : {
     124                 :          0 :         return 0;
     125                 :            : }
     126                 :            : 
     127                 :            : static void
     128                 :          0 : channel_destroy_cb(void *io_device, void *ctx)
     129                 :            : {
     130                 :          0 : }
     131                 :            : 
     132                 :            : static struct spdk_ftl_dev *
     133                 :          8 : setup_device(uint32_t num_threads, uint32_t xfer_size)
     134                 :            : {
     135                 :            :         struct spdk_ftl_dev *dev;
     136                 :            :         struct ftl_io_channel *ioch;
     137                 :            :         struct ftl_io_channel_ctx *ctx;
     138                 :            : 
     139                 :          8 :         allocate_threads(num_threads);
     140                 :          8 :         set_thread(0);
     141                 :            : 
     142                 :          8 :         dev = calloc(1, sizeof(*dev));
     143         [ -  + ]:          8 :         SPDK_CU_ASSERT_FATAL(dev != NULL);
     144                 :            : 
     145                 :          8 :         dev->core_thread = spdk_get_thread();
     146                 :          8 :         dev->ioch = calloc(1, SPDK_IO_CHANNEL_STRUCT_SIZE + sizeof(struct ftl_io_channel_ctx));
     147         [ -  + ]:          8 :         SPDK_CU_ASSERT_FATAL(dev->ioch != NULL);
     148                 :            : 
     149                 :          8 :         ctx = spdk_io_channel_get_ctx(dev->ioch);
     150                 :          8 :         ctx->ioch = calloc(1, sizeof(*ctx->ioch));
     151                 :            : 
     152                 :          8 :         ioch = ftl_io_channel_get_ctx(dev->ioch);
     153         [ -  + ]:          8 :         SPDK_CU_ASSERT_FATAL(ioch != NULL);
     154                 :            : 
     155                 :          8 :         ioch->cq = spdk_ring_create(0, 1024, 0);
     156                 :            : 
     157                 :          8 :         dev->conf = g_default_conf;
     158                 :          8 :         dev->xfer_size = xfer_size;
     159                 :          8 :         dev->base_bdev_desc = (struct spdk_bdev_desc *)0xdeadbeef;
     160                 :          8 :         dev->nv_cache.bdev_desc = (struct spdk_bdev_desc *)0xdead1234;
     161                 :          8 :         spdk_io_device_register(dev, channel_create_cb, channel_destroy_cb, 0, NULL);
     162                 :          8 :         spdk_io_device_register(dev->base_bdev_desc, channel_create_cb, channel_destroy_cb, 0, NULL);
     163                 :          8 :         spdk_io_device_register(dev->nv_cache.bdev_desc, channel_create_cb, channel_destroy_cb, 0, NULL);
     164                 :            : 
     165                 :          8 :         TAILQ_INIT(&dev->ioch_queue);
     166                 :            : 
     167                 :          8 :         return dev;
     168                 :            : }
     169                 :            : 
     170                 :            : static void
     171                 :          8 : free_device(struct spdk_ftl_dev *dev)
     172                 :            : {
     173                 :            :         struct ftl_io_channel *ioch;
     174                 :            : 
     175                 :          8 :         ioch = ftl_io_channel_get_ctx(dev->ioch);
     176                 :          8 :         spdk_ring_free(ioch->cq);
     177                 :          8 :         free(ioch);
     178                 :            : 
     179                 :          8 :         spdk_io_device_unregister(dev, NULL);
     180                 :          8 :         spdk_io_device_unregister(dev->base_bdev_desc, NULL);
     181                 :          8 :         spdk_io_device_unregister(dev->nv_cache.bdev_desc, NULL);
     182                 :            : 
     183         [ -  + ]:          8 :         while (!TAILQ_EMPTY(&dev->ioch_queue)) {
     184         [ #  # ]:          0 :                 TAILQ_REMOVE(&dev->ioch_queue, TAILQ_FIRST(&dev->ioch_queue), entry);
     185                 :            :         }
     186                 :            : 
     187                 :          8 :         free_threads();
     188                 :            : 
     189                 :          8 :         free(dev->ioch);
     190                 :          8 :         free(dev->sb);
     191                 :          8 :         free(dev);
     192                 :          8 : }
     193                 :            : 
     194                 :            : static void
     195                 :         12 : setup_io(struct ftl_io *io, struct spdk_ftl_dev *dev, spdk_ftl_fn cb, void *ctx)
     196                 :            : {
     197                 :         12 :         io->dev = dev;
     198                 :         12 :         io->user_fn = cb;
     199                 :         12 :         io->cb_ctx = ctx;
     200                 :         12 :         io->flags = 0;
     201                 :         12 :         io->ioch = dev->ioch;
     202                 :         12 : }
     203                 :            : 
     204                 :            : static void
     205                 :         12 : io_complete_cb(void *ctx, int status)
     206                 :            : {
     207                 :         12 :         *(int *)ctx = status;
     208                 :         12 : }
     209                 :            : 
     210                 :            : static void
     211                 :          4 : test_completion(void)
     212                 :            : {
     213                 :            :         struct spdk_ftl_dev *dev;
     214                 :            :         struct ftl_io_channel *ioch;
     215                 :          4 :         struct ftl_io io = { 0 }, *io_ring;
     216                 :          4 :         int req, status = 0;
     217                 :            : 
     218                 :          4 :         dev = setup_device(1, FTL_NUM_LBA_IN_BLOCK);
     219                 :          4 :         ioch = ftl_io_channel_get_ctx(dev->ioch);
     220                 :            : 
     221                 :            :         /* Setup IO and 'send' NUM_REQUESTS subrequests */
     222                 :          4 :         setup_io(&io, dev, io_complete_cb, &status);
     223                 :          4 :         io.status = -EIO;
     224                 :            : 
     225                 :            : #define NUM_REQUESTS 16
     226         [ +  + ]:         68 :         for (req = 0; req < NUM_REQUESTS; ++req) {
     227                 :         64 :                 ftl_io_inc_req(&io);
     228                 :         64 :                 CU_ASSERT_FALSE(ftl_io_done(&io));
     229                 :            :         }
     230                 :            : 
     231                 :          4 :         CU_ASSERT_EQUAL(io.req_cnt, NUM_REQUESTS);
     232                 :            : 
     233                 :            :         /* Complete all but one subrequest, make sure io still not marked as done */
     234         [ +  + ]:         64 :         for (req = 0; req < (NUM_REQUESTS - 1); ++req) {
     235                 :         60 :                 ftl_io_dec_req(&io);
     236                 :         60 :                 CU_ASSERT_FALSE(ftl_io_done(&io));
     237                 :            :         }
     238                 :            : 
     239                 :          4 :         CU_ASSERT_EQUAL(io.req_cnt, 1);
     240                 :            : 
     241                 :            :         /* Complete last subrequest, make sure it appears on the completion queue */
     242                 :          4 :         ftl_io_dec_req(&io);
     243                 :          4 :         CU_ASSERT_TRUE(ftl_io_done(&io));
     244                 :            : 
     245                 :          4 :         ftl_io_complete(&io);
     246                 :            : 
     247                 :          4 :         CU_ASSERT_EQUAL(spdk_ring_count(ioch->cq), 1);
     248                 :            : 
     249                 :            :         /* Dequeue and check if the completion callback changes the status, this is usually done via poller */
     250                 :          4 :         spdk_ring_dequeue(ioch->cq, (void **)&io_ring, 1);
     251                 :          4 :         io_ring->user_fn(io_ring->cb_ctx, io_ring->status);
     252                 :            : 
     253                 :          4 :         CU_ASSERT_EQUAL(status, -EIO);
     254                 :            : 
     255                 :          4 :         free_device(dev);
     256                 :          4 : }
     257                 :            : 
     258                 :            : static void
     259                 :          4 : test_multiple_ios(void)
     260                 :            : {
     261                 :            :         struct spdk_ftl_dev *dev;
     262                 :            :         struct ftl_io_channel *ioch;
     263                 :          4 :         struct ftl_io io[2] = { 0 }, *io_ring[2];
     264                 :          4 :         int status = -1;
     265                 :            : 
     266                 :          4 :         dev = setup_device(1, FTL_NUM_LBA_IN_BLOCK);
     267                 :          4 :         ioch = ftl_io_channel_get_ctx(dev->ioch);
     268                 :            : 
     269                 :            :         /* Send t2o IOs and check if both are in the completion queue */
     270                 :          4 :         setup_io(&io[0], dev, io_complete_cb, &status);
     271                 :          4 :         CU_ASSERT_EQUAL(spdk_ring_count(ioch->cq), 0);
     272                 :            : 
     273                 :          4 :         ftl_io_complete(io);
     274                 :          4 :         CU_ASSERT_EQUAL(spdk_ring_count(ioch->cq), 1);
     275                 :            : 
     276                 :          4 :         setup_io(&io[1], dev, io_complete_cb, &status);
     277                 :            : 
     278                 :          4 :         ftl_io_complete(&io[1]);
     279                 :          4 :         CU_ASSERT_EQUAL(spdk_ring_count(ioch->cq), 2);
     280                 :            : 
     281                 :            :         /* Dequeue and check if the completion callback changes the status, this is usually done via poller */
     282                 :          4 :         spdk_ring_dequeue(ioch->cq, (void **)io_ring, 2);
     283                 :          4 :         status = -1;
     284                 :          4 :         io_ring[0]->user_fn(io_ring[0]->cb_ctx, io_ring[0]->status);
     285                 :          4 :         CU_ASSERT_EQUAL(status, 0);
     286                 :          4 :         status = -1;
     287                 :          4 :         io_ring[1]->user_fn(io_ring[1]->cb_ctx, io_ring[1]->status);
     288                 :          4 :         CU_ASSERT_EQUAL(status, 0);
     289                 :            : 
     290                 :          4 :         free_device(dev);
     291                 :          4 : }
     292                 :            : 
     293                 :            : int
     294                 :          4 : main(int argc, char **argv)
     295                 :            : {
     296                 :            :         CU_pSuite suite;
     297                 :            :         unsigned int num_failures;
     298                 :            : 
     299                 :          4 :         CU_initialize_registry();
     300                 :            : 
     301                 :          4 :         suite = CU_add_suite("ftl_io_suite", NULL, NULL);
     302                 :            : 
     303                 :            : 
     304                 :          4 :         CU_ADD_TEST(suite, test_completion);
     305                 :          4 :         CU_ADD_TEST(suite, test_multiple_ios);
     306                 :            : 
     307                 :          4 :         num_failures = spdk_ut_run_tests(argc, argv, NULL);
     308                 :          4 :         CU_cleanup_registry();
     309                 :            : 
     310                 :          4 :         return num_failures;
     311                 :            : }

Generated by: LCOV version 1.14