LCOV - code coverage report
Current view: top level - spdk/test/unit/lib/ftl/ftl_band.c - ftl_band_ut.c (source / functions) Hit Total Coverage
Test: Combined Lines: 152 233 65.2 %
Date: 2024-07-11 15:05:21 Functions: 15 96 15.6 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 7 28 25.0 %

           Branch data     Line data    Source code
       1                 :            : /*   SPDX-License-Identifier: BSD-3-Clause
       2                 :            :  *   Copyright (C) 2018 Intel Corporation.
       3                 :            :  *   All rights reserved.
       4                 :            :  */
       5                 :            : 
       6                 :            : #include "spdk/stdinc.h"
       7                 :            : 
       8                 :            : #include "spdk_internal/cunit.h"
       9                 :            : #include "common/lib/test_env.c"
      10                 :            : 
      11                 :            : #include "ftl/ftl_core.c"
      12                 :            : #include "ftl/ftl_band.c"
      13                 :            : #include "ftl/ftl_layout.c"
      14                 :            : #include "../common/utils.c"
      15                 :            : 
      16                 :            : #define TEST_BAND_IDX           42
      17                 :            : #define TEST_LBA                0x68676564
      18                 :            : #define TEST_SEQ                0xDEADBEEF
      19                 :            : #define G_GEO_ZONE_SIZE 10000
      20                 :            : #define G_GEO_OPTIMAL_OPEN_ZONES 1
      21                 :            : 
      22                 :            : struct base_bdev_geometry g_geo = {
      23                 :            :         .write_unit_size    = FTL_NUM_LBA_IN_BLOCK,
      24                 :            :         .optimal_open_zones = G_GEO_OPTIMAL_OPEN_ZONES,
      25                 :            :         .zone_size          = G_GEO_ZONE_SIZE,
      26                 :            :         .blockcnt           = (TEST_BAND_IDX + 1) * G_GEO_ZONE_SIZE * G_GEO_OPTIMAL_OPEN_ZONES,
      27                 :            : };
      28                 :            : 
      29                 :            : static struct spdk_ftl_dev *g_dev;
      30                 :            : static struct ftl_band  *g_band;
      31                 :            : 
      32                 :            : #if defined(DEBUG)
      33                 :          0 : DEFINE_STUB_V(ftl_band_validate_md, (struct ftl_band *band, ftl_band_validate_md_cb cb));
      34                 :          0 : DEFINE_STUB_V(ftl_p2l_validate_ckpt, (struct ftl_band *band));
      35                 :          0 : DEFINE_STUB_V(ftl_trace_limits, (struct spdk_ftl_dev *dev, int limit, size_t num_free));
      36                 :          0 : DEFINE_STUB_V(ftl_trace_completion, (struct spdk_ftl_dev *dev, const struct ftl_io *io,
      37                 :            :                                      enum ftl_trace_completion completion));
      38                 :          0 : DEFINE_STUB_V(ftl_trace_write_band, (struct spdk_ftl_dev *dev, const struct ftl_band *band));
      39                 :          0 : DEFINE_STUB_V(ftl_trace_submission, (struct spdk_ftl_dev *dev, const struct ftl_io *io,
      40                 :            :                                      ftl_addr addr, size_t addr_cnt));
      41                 :            : #endif
      42                 :          0 : DEFINE_STUB_V(spdk_bdev_free_io, (struct spdk_bdev_io *bdev_io));
      43                 :          0 : DEFINE_STUB(spdk_bdev_get_block_size, uint32_t, (const struct spdk_bdev *bdev), 512);
      44                 :          0 : DEFINE_STUB(spdk_bdev_get_name, const char *, (const struct spdk_bdev *bdev), "test");
      45                 :          0 : DEFINE_STUB(spdk_bdev_get_num_blocks, uint64_t, (const struct spdk_bdev *bdev), 0);
      46                 :          0 : DEFINE_STUB(spdk_bdev_get_md_size, uint32_t, (const struct spdk_bdev *bdev), 8);
      47                 :          0 : DEFINE_STUB(spdk_bdev_write_blocks, int, (struct spdk_bdev_desc *desc, struct spdk_io_channel *ch,
      48                 :            :                 void *buf, uint64_t offset_blocks, uint64_t num_blocks, spdk_bdev_io_completion_cb cb,
      49                 :            :                 void *cb_arg), 0);
      50                 :          0 : DEFINE_STUB(spdk_bdev_write_blocks_with_md, int, (struct spdk_bdev_desc *desc,
      51                 :            :                 struct spdk_io_channel *ch, void *buf, void *md, uint64_t offset_blocks,
      52                 :            :                 uint64_t num_blocks, spdk_bdev_io_completion_cb cb, void *cb_arg), 0);
      53                 :          0 : DEFINE_STUB(spdk_bdev_read_blocks, int, (struct spdk_bdev_desc *desc, struct spdk_io_channel *ch,
      54                 :            :                 void *buf, uint64_t offset_blocks, uint64_t num_blocks,
      55                 :            :                 spdk_bdev_io_completion_cb cb, void *cb_arg), 0);
      56                 :          0 : DEFINE_STUB(spdk_bdev_write_zeroes_blocks, int,
      57                 :            :             (struct spdk_bdev_desc *desc, struct spdk_io_channel *ch,
      58                 :            :              uint64_t offset_blocks, uint64_t num_blocks,
      59                 :            :              spdk_bdev_io_completion_cb cb, void *cb_arg), 0);
      60                 :          0 : DEFINE_STUB(spdk_bdev_writev_blocks, int, (struct spdk_bdev_desc *desc, struct spdk_io_channel *ch,
      61                 :            :                 struct iovec *iov, int iovcnt, uint64_t offset_blocks, uint64_t num_blocks,
      62                 :            :                 spdk_bdev_io_completion_cb cb, void *cb_arg), 0);
      63                 :          0 : DEFINE_STUB_V(ftl_io_advance, (struct ftl_io *io, size_t num_blocks));
      64                 :          0 : DEFINE_STUB(ftl_io_channel_get_ctx, struct ftl_io_channel *,
      65                 :            :             (struct spdk_io_channel *ioch), NULL);
      66                 :          0 : DEFINE_STUB_V(ftl_io_complete, (struct ftl_io *io));
      67                 :          0 : DEFINE_STUB(ftl_io_current_lba, uint64_t, (const struct ftl_io *io), 0);
      68                 :          0 : DEFINE_STUB_V(ftl_io_dec_req, (struct ftl_io *io));
      69                 :          0 : DEFINE_STUB_V(ftl_io_fail, (struct ftl_io *io, int status));
      70                 :          0 : DEFINE_STUB(ftl_io_get_lba, uint64_t,
      71                 :            :             (const struct ftl_io *io, size_t offset), 0);
      72                 :          0 : DEFINE_STUB_V(ftl_io_inc_req, (struct ftl_io *io));
      73                 :          0 : DEFINE_STUB(ftl_io_iovec_addr, void *, (struct ftl_io *io), NULL);
      74                 :          0 : DEFINE_STUB(ftl_io_iovec_len_left, size_t, (struct ftl_io *io), 0);
      75                 :            : 
      76                 :          0 : DEFINE_STUB(ftl_iovec_num_blocks, size_t,
      77                 :            :             (struct iovec *iov, size_t iov_cnt), 0);
      78                 :          0 : DEFINE_STUB_V(ftl_reloc, (struct ftl_reloc *reloc));
      79                 :            : 
      80         [ #  # ]:          0 : DEFINE_STUB(ftl_reloc_is_halted, bool, (const struct ftl_reloc *reloc), false);
      81                 :          0 : DEFINE_STUB_V(ftl_reloc_halt, (struct ftl_reloc *reloc));
      82         [ -  + ]:         24 : DEFINE_STUB(spdk_bdev_is_zoned, bool, (const struct spdk_bdev *bdev), true);
      83                 :          0 : DEFINE_STUB(ftl_p2l_ckpt_acquire, struct ftl_p2l_ckpt *, (struct spdk_ftl_dev *dev), NULL);
      84                 :          0 : DEFINE_STUB(ftl_mngt_unmap, int, (struct spdk_ftl_dev *dev, uint64_t lba, uint64_t num_blocks,
      85                 :            :                                   spdk_ftl_fn cb, void *cb_cntx), 0);
      86                 :          0 : DEFINE_STUB_V(ftl_p2l_ckpt_release, (struct spdk_ftl_dev *dev, struct ftl_p2l_ckpt *ckpt));
      87                 :            : 
      88                 :          0 : DEFINE_STUB_V(ftl_l2p_process, (struct spdk_ftl_dev *dev));
      89                 :          0 : DEFINE_STUB_V(ftl_nv_cache_process, (struct spdk_ftl_dev *dev));
      90         [ #  # ]:          0 : DEFINE_STUB(ftl_nv_cache_is_halted, bool, (struct ftl_nv_cache *nvc), true);
      91                 :          0 : DEFINE_STUB(ftl_nv_cache_chunks_busy, int, (struct ftl_nv_cache *nvc), true);
      92         [ #  # ]:          0 : DEFINE_STUB(ftl_nv_cache_full, bool, (struct ftl_nv_cache *nvc), true);
      93         [ #  # ]:          0 : DEFINE_STUB(ftl_l2p_is_halted, bool, (struct spdk_ftl_dev *dev), true);
      94         [ #  # ]:          0 : DEFINE_STUB(ftl_nv_cache_write, bool, (struct ftl_io *io), true);
      95                 :          0 : DEFINE_STUB_V(ftl_nv_cache_halt, (struct ftl_nv_cache *nvc));
      96                 :          0 : DEFINE_STUB_V(ftl_l2p_halt, (struct spdk_ftl_dev *dev));
      97                 :          0 : DEFINE_STUB(ftl_io_init, int, (struct spdk_io_channel *_ioch, struct ftl_io *io, uint64_t lba,
      98                 :            :                                size_t num_blocks,
      99                 :            :                                struct iovec *iov, size_t iov_cnt, spdk_ftl_fn cb_fn, void *cb_ctx, int type), 0);
     100                 :          0 : DEFINE_STUB_V(ftl_mngt_next_step, (struct ftl_mngt_process *mngt));
     101                 :          0 : DEFINE_STUB_V(ftl_mngt_fail_step, (struct ftl_mngt_process *mngt));
     102                 :          0 : DEFINE_STUB_V(spdk_bdev_close, (struct spdk_bdev_desc *desc));
     103                 :          0 : DEFINE_STUB(spdk_bdev_get_io_channel, struct spdk_io_channel *, (struct spdk_bdev_desc *bdev_desc),
     104                 :            :             NULL);
     105         [ #  # ]:          0 : DEFINE_STUB(spdk_bdev_io_type_supported, bool, (struct spdk_bdev *bdev,
     106                 :            :                 enum spdk_bdev_io_type io_type), true);
     107                 :          0 : DEFINE_STUB_V(spdk_bdev_module_release_bdev, (struct spdk_bdev *bdev));
     108                 :          0 : DEFINE_STUB(spdk_bdev_module_claim_bdev, int, (struct spdk_bdev *bdev, struct spdk_bdev_desc *desc,
     109                 :            :                 struct spdk_bdev_module *module), 0);
     110                 :          0 : DEFINE_STUB(spdk_bdev_open_ext, int, (const char *bdev_name, bool write,
     111                 :            :                                       spdk_bdev_event_cb_t event_cb,
     112                 :            :                                       void *event_ctx, struct spdk_bdev_desc **desc), 0);
     113                 :          0 : DEFINE_STUB(spdk_bdev_get_write_unit_size, uint32_t, (const struct spdk_bdev *bdev), 1);
     114         [ #  # ]:          0 : DEFINE_STUB(spdk_bdev_is_md_separate, bool, (const struct spdk_bdev *bdev), true);
     115                 :          0 : DEFINE_STUB(spdk_bdev_get_dif_type, enum spdk_dif_type, (const struct spdk_bdev *bdev),
     116                 :            :             SPDK_DIF_DISABLE);
     117                 :          0 : DEFINE_STUB(ftl_md_xfer_blocks, uint64_t, (struct spdk_ftl_dev *dev), 4);
     118                 :          0 : DEFINE_STUB_V(ftl_l2p_pin, (struct spdk_ftl_dev *dev, uint64_t lba, uint64_t count,
     119                 :            :                             ftl_l2p_pin_cb cb, void *cb_ctx,
     120                 :            :                             struct ftl_l2p_pin_ctx *pin_ctx));
     121                 :          0 : DEFINE_STUB_V(ftl_l2p_pin_skip, (struct spdk_ftl_dev *dev, ftl_l2p_pin_cb cb, void *cb_ctx,
     122                 :            :                                  struct ftl_l2p_pin_ctx *pin_ctx));
     123                 :          0 : DEFINE_STUB(ftl_nv_cache_read, int, (struct ftl_io *io, ftl_addr addr, uint32_t num_blocks,
     124                 :            :                                      spdk_bdev_io_completion_cb cb, void *cb_arg), 0);
     125                 :          0 : DEFINE_STUB(spdk_bdev_queue_io_wait, int, (struct spdk_bdev *bdev, struct spdk_io_channel *ch,
     126                 :            :                 struct spdk_bdev_io_wait_entry *entry), 0);
     127                 :          0 : DEFINE_STUB(ftl_l2p_get, ftl_addr, (struct spdk_ftl_dev *dev, uint64_t lba), 0);
     128                 :          0 : DEFINE_STUB_V(ftl_writer_run, (struct ftl_writer *writer));
     129         [ #  # ]:          0 : DEFINE_STUB(ftl_writer_is_halted, bool, (struct ftl_writer *writer), true);
     130                 :          0 : DEFINE_STUB(ftl_mempool_claim_df, void *, (struct ftl_mempool *mpool, ftl_df_obj_id df_obj_id),
     131                 :            :             NULL);
     132                 :          0 : DEFINE_STUB(ftl_bitmap_count_set, uint64_t, (struct ftl_bitmap *bitmap), 0);
     133                 :          0 : DEFINE_STUB(ftl_p2l_ckpt_region_type, enum ftl_layout_region_type,
     134                 :            :             (const struct ftl_p2l_ckpt *ckpt), 0);
     135                 :          0 : DEFINE_STUB(ftl_md_get_buffer, void *, (struct ftl_md *md), NULL);
     136                 :          0 : DEFINE_STUB(ftl_md_get_vss_buffer, union ftl_md_vss *, (struct ftl_md *md), NULL);
     137                 :          0 : DEFINE_STUB(ftl_nv_cache_acquire_trim_seq_id, uint64_t, (struct ftl_nv_cache *nv_cache), 0);
     138                 :          0 : DEFINE_STUB_V(ftl_md_persist, (struct ftl_md *md));
     139                 :          0 : DEFINE_STUB_V(spdk_bdev_io_get_nvme_status, (const struct spdk_bdev_io *bdev_io, uint32_t *cdw0,
     140                 :            :                 int *sct, int *sc));
     141         [ #  # ]:          0 : DEFINE_STUB(ftl_nv_cache_throttle, bool, (struct spdk_ftl_dev *dev), true);
     142                 :          0 : DEFINE_STUB(ftl_base_device_get_type_by_bdev, const struct ftl_base_device_type *,
     143                 :            :             (struct spdk_ftl_dev *dev, struct spdk_bdev *bdev), NULL);
     144                 :          0 : DEFINE_STUB(ftl_layout_tracker_bdev_init, struct ftl_layout_tracker_bdev *,
     145                 :            :             (uint64_t bdev_blks), NULL);
     146                 :          0 : DEFINE_STUB_V(ftl_layout_tracker_bdev_fini, (struct ftl_layout_tracker_bdev *tracker));
     147                 :          0 : DEFINE_STUB(ftl_nv_cache_chunk_tail_md_num_blocks, size_t, (const struct ftl_nv_cache *nv_cache),
     148                 :            :             0);
     149                 :          0 : DEFINE_STUB_V(ftl_layout_tracker_bdev_find_next_region, (struct ftl_layout_tracker_bdev *tracker,
     150                 :            :                 enum ftl_layout_region_type reg_type,
     151                 :            :                 const struct ftl_layout_tracker_bdev_region_props **search_ctx));
     152         [ #  # ]:          0 : DEFINE_STUB(ftl_superblock_is_blob_area_empty, bool, (struct ftl_superblock *sb), true);
     153                 :          0 : DEFINE_STUB(ftl_superblock_store_blob_area, int, (struct spdk_ftl_dev *dev), 0);
     154                 :          0 : DEFINE_STUB(ftl_superblock_load_blob_area, int, (struct spdk_ftl_dev *dev), 0);
     155                 :          0 : DEFINE_STUB(ftl_superblock_md_layout_apply, int, (struct spdk_ftl_dev *dev), 0);
     156                 :          0 : DEFINE_STUB(ftl_layout_tracker_bdev_rm_region, int, (struct ftl_layout_tracker_bdev *tracker,
     157                 :            :                 enum ftl_layout_region_type reg_type, uint32_t reg_ver), 0);
     158                 :            : 
     159                 :            : static void
     160                 :         72 : adjust_bitmap(struct ftl_bitmap **bitmap, uint64_t *bit)
     161                 :            : {
     162         [ +  + ]:         72 :         if (*bitmap == g_dev->valid_map) {
     163                 :         36 :                 *bitmap = g_band->p2l_map.valid;
     164                 :         36 :                 *bit = test_offset_from_addr(*bit, g_band);
     165                 :            :         }
     166                 :         72 : }
     167                 :            : 
     168                 :            : bool
     169                 :         44 : ftl_bitmap_get(const struct ftl_bitmap *bitmap, uint64_t bit)
     170                 :            : {
     171                 :         44 :         adjust_bitmap((struct ftl_bitmap **)&bitmap, &bit);
     172                 :         44 :         return spdk_bit_array_get((struct spdk_bit_array *)bitmap, bit);
     173                 :            : }
     174                 :            : 
     175                 :            : void
     176                 :         20 : ftl_bitmap_set(struct ftl_bitmap *bitmap, uint64_t bit)
     177                 :            : {
     178                 :            :         int ret;
     179                 :            : 
     180                 :         20 :         adjust_bitmap(&bitmap, &bit);
     181                 :         20 :         ret = spdk_bit_array_set((struct spdk_bit_array *)bitmap, bit);
     182                 :         20 :         CU_ASSERT_EQUAL(ret, 0);
     183                 :         20 : }
     184                 :            : 
     185                 :            : void
     186                 :          8 : ftl_bitmap_clear(struct ftl_bitmap *bitmap, uint64_t bit)
     187                 :            : {
     188                 :          8 :         adjust_bitmap(&bitmap, &bit);
     189                 :          8 :         spdk_bit_array_clear((struct spdk_bit_array *)bitmap, bit);
     190                 :          8 : }
     191                 :            : 
     192                 :            : static void
     193                 :         24 : setup_band(void)
     194                 :            : {
     195                 :            :         int rc;
     196                 :            : 
     197                 :         24 :         g_dev = test_init_ftl_dev(&g_geo);
     198                 :         24 :         g_band = test_init_ftl_band(g_dev, TEST_BAND_IDX, ftl_get_num_blocks_in_band(g_dev));
     199                 :         24 :         rc = ftl_band_alloc_p2l_map(g_band);
     200                 :         24 :         CU_ASSERT_EQUAL_FATAL(rc, 0);
     201                 :         24 : }
     202                 :            : 
     203                 :            : static void
     204                 :         24 : cleanup_band(void)
     205                 :            : {
     206                 :         24 :         ftl_band_release_p2l_map(g_band);
     207                 :         24 :         test_free_ftl_band(g_band);
     208                 :         24 :         test_free_ftl_dev(g_dev);
     209                 :         24 : }
     210                 :            : 
     211                 :            : static ftl_addr
     212                 :      80032 : addr_from_zone_id(uint64_t zone_id)
     213                 :            : {
     214                 :            :         ftl_addr addr;
     215                 :            : 
     216                 :      80032 :         addr = zone_id * g_geo.zone_size;
     217                 :      80032 :         return addr;
     218                 :            : }
     219                 :            : 
     220                 :            : static void
     221                 :          4 : test_band_block_offset_from_addr_base(void)
     222                 :            : {
     223                 :            :         ftl_addr addr;
     224                 :            :         uint64_t offset;
     225                 :            : 
     226                 :          4 :         setup_band();
     227                 :          4 :         addr = addr_from_zone_id(0);
     228                 :          4 :         addr += TEST_BAND_IDX * ftl_get_num_blocks_in_band(g_dev);
     229                 :            : 
     230                 :          4 :         offset = ftl_band_block_offset_from_addr(g_band, addr);
     231                 :          4 :         CU_ASSERT_EQUAL(offset, 0);
     232                 :          4 :         cleanup_band();
     233                 :          4 : }
     234                 :            : 
     235                 :            : static void
     236                 :          4 : test_band_block_offset_from_addr_offset(void)
     237                 :            : {
     238                 :            :         ftl_addr addr;
     239                 :            :         uint64_t offset, expect, j;
     240                 :            : 
     241                 :          4 :         setup_band();
     242         [ +  + ]:      40004 :         for (j = 0; j < g_geo.zone_size; ++j) {
     243                 :      40000 :                 addr = addr_from_zone_id(0);
     244                 :      40000 :                 addr += TEST_BAND_IDX * ftl_get_num_blocks_in_band(g_dev) + j;
     245                 :            : 
     246                 :      40000 :                 offset = ftl_band_block_offset_from_addr(g_band, addr);
     247                 :            : 
     248                 :      40000 :                 expect = test_offset_from_addr(addr, g_band);
     249                 :      40000 :                 CU_ASSERT_EQUAL(offset, expect);
     250                 :            :         }
     251                 :          4 :         cleanup_band();
     252                 :          4 : }
     253                 :            : 
     254                 :            : static void
     255                 :          4 : test_band_addr_from_block_offset(void)
     256                 :            : {
     257                 :            :         ftl_addr addr, expect;
     258                 :            :         uint64_t offset, j;
     259                 :            : 
     260                 :          4 :         setup_band();
     261         [ +  + ]:      40004 :         for (j = 0; j < g_geo.zone_size; ++j) {
     262                 :      40000 :                 expect = addr_from_zone_id(0);
     263                 :      40000 :                 expect += TEST_BAND_IDX * ftl_get_num_blocks_in_band(g_dev) + j;
     264                 :            : 
     265                 :      40000 :                 offset = ftl_band_block_offset_from_addr(g_band, expect);
     266                 :      40000 :                 addr = ftl_band_addr_from_block_offset(g_band, offset);
     267                 :            : 
     268                 :      40000 :                 CU_ASSERT_EQUAL(addr, expect);
     269                 :            :         }
     270                 :          4 :         cleanup_band();
     271                 :          4 : }
     272                 :            : 
     273                 :            : static void
     274                 :          4 : test_band_set_addr(void)
     275                 :            : {
     276                 :            :         struct ftl_p2l_map *p2l_map;
     277                 :            :         ftl_addr addr;
     278                 :          4 :         uint64_t offset = 0;
     279                 :            : 
     280                 :          4 :         setup_band();
     281                 :          4 :         p2l_map = &g_band->p2l_map;
     282                 :          4 :         addr = addr_from_zone_id(0);
     283                 :          4 :         addr += TEST_BAND_IDX * ftl_get_num_blocks_in_band(g_dev);
     284                 :            : 
     285                 :          4 :         CU_ASSERT_EQUAL(p2l_map->num_valid, 0);
     286                 :            : 
     287                 :          4 :         offset = test_offset_from_addr(addr, g_band);
     288                 :            : 
     289                 :          4 :         ftl_band_set_addr(g_band, TEST_LBA, addr);
     290                 :          4 :         ftl_band_set_p2l(g_band, TEST_LBA, addr, TEST_SEQ);
     291                 :          4 :         CU_ASSERT_EQUAL(p2l_map->num_valid, 1);
     292                 :          4 :         CU_ASSERT_EQUAL(p2l_map->band_map[offset].lba, TEST_LBA);
     293                 :          4 :         CU_ASSERT_EQUAL(p2l_map->band_map[offset].seq_id, TEST_SEQ);
     294                 :          4 :         CU_ASSERT_TRUE(ftl_bitmap_get(p2l_map->valid, offset));
     295                 :            : 
     296                 :          4 :         addr += g_geo.zone_size / 2;
     297                 :          4 :         offset = test_offset_from_addr(addr, g_band);
     298                 :          4 :         ftl_band_set_addr(g_band, TEST_LBA + 1, addr);
     299                 :          4 :         ftl_band_set_p2l(g_band, TEST_LBA + 1, addr, TEST_SEQ + 1);
     300                 :          4 :         CU_ASSERT_EQUAL(p2l_map->num_valid, 2);
     301                 :          4 :         CU_ASSERT_EQUAL(p2l_map->band_map[offset].lba, TEST_LBA + 1);
     302                 :          4 :         CU_ASSERT_EQUAL(p2l_map->band_map[offset].seq_id, TEST_SEQ + 1);
     303                 :          4 :         CU_ASSERT_TRUE(ftl_bitmap_get(p2l_map->valid, offset));
     304                 :          4 :         addr -= g_geo.zone_size / 2;
     305                 :          4 :         offset = test_offset_from_addr(addr, g_band);
     306                 :          4 :         CU_ASSERT_TRUE(ftl_bitmap_get(p2l_map->valid, offset));
     307                 :          4 :         cleanup_band();
     308                 :          4 : }
     309                 :            : 
     310                 :            : static void
     311                 :          4 : test_invalidate_addr(void)
     312                 :            : {
     313                 :            :         struct ftl_p2l_map *p2l_map;
     314                 :            :         ftl_addr addr;
     315                 :            :         uint64_t offset[2];
     316                 :            : 
     317                 :          4 :         setup_band();
     318                 :          4 :         p2l_map = &g_band->p2l_map;
     319                 :          4 :         addr = addr_from_zone_id(0);
     320                 :          4 :         addr += TEST_BAND_IDX * ftl_get_num_blocks_in_band(g_dev);
     321                 :          4 :         offset[0] = test_offset_from_addr(addr, g_band);
     322                 :            : 
     323                 :          4 :         ftl_band_set_addr(g_band, TEST_LBA, addr);
     324                 :          4 :         ftl_band_set_p2l(g_band, TEST_LBA, addr, TEST_SEQ);
     325                 :          4 :         CU_ASSERT_EQUAL(p2l_map->num_valid, 1);
     326                 :          4 :         CU_ASSERT_TRUE(ftl_bitmap_get(p2l_map->valid, offset[0]));
     327                 :          4 :         ftl_invalidate_addr(g_band->dev, addr);
     328                 :          4 :         CU_ASSERT_EQUAL(p2l_map->num_valid, 0);
     329                 :          4 :         CU_ASSERT_FALSE(ftl_bitmap_get(p2l_map->valid, offset[0]));
     330                 :            : 
     331                 :          4 :         offset[0] = test_offset_from_addr(addr, g_band);
     332                 :          4 :         ftl_band_set_addr(g_band, TEST_LBA, addr);
     333                 :          4 :         ftl_band_set_p2l(g_band, TEST_LBA, addr, TEST_SEQ);
     334                 :          4 :         addr += g_geo.zone_size / 2;
     335                 :          4 :         offset[1] = test_offset_from_addr(addr, g_band);
     336                 :          4 :         ftl_band_set_addr(g_band, TEST_LBA + 1, addr);
     337                 :          4 :         ftl_band_set_p2l(g_band, TEST_LBA + 1, addr, TEST_SEQ);
     338                 :          4 :         CU_ASSERT_EQUAL(p2l_map->num_valid, 2);
     339                 :          4 :         CU_ASSERT_TRUE(ftl_bitmap_get(p2l_map->valid, offset[0]));
     340                 :          4 :         CU_ASSERT_TRUE(ftl_bitmap_get(p2l_map->valid, offset[1]));
     341                 :          4 :         ftl_invalidate_addr(g_band->dev, addr);
     342                 :          4 :         CU_ASSERT_EQUAL(p2l_map->num_valid, 1);
     343                 :          4 :         CU_ASSERT_TRUE(ftl_bitmap_get(p2l_map->valid, offset[0]));
     344                 :          4 :         CU_ASSERT_FALSE(ftl_bitmap_get(p2l_map->valid, offset[1]));
     345                 :          4 :         cleanup_band();
     346                 :          4 : }
     347                 :            : 
     348                 :            : static void
     349                 :          4 : test_next_xfer_addr(void)
     350                 :            : {
     351                 :            :         ftl_addr addr, result, expect;
     352                 :            : 
     353                 :          4 :         setup_band();
     354                 :            :         /* Verify simple one block incremention */
     355                 :          4 :         addr = addr_from_zone_id(0);
     356                 :          4 :         addr += TEST_BAND_IDX * ftl_get_num_blocks_in_band(g_dev);
     357                 :          4 :         expect = addr;
     358                 :          4 :         expect += 1;
     359                 :            : 
     360                 :          4 :         result = ftl_band_next_xfer_addr(g_band, addr, 1);
     361                 :          4 :         CU_ASSERT_EQUAL(result, expect);
     362                 :            : 
     363                 :            :         /* Verify jumping from last zone to the first one */
     364                 :          4 :         expect = addr_from_zone_id(0);
     365                 :          4 :         expect += TEST_BAND_IDX * ftl_get_num_blocks_in_band(g_dev) + g_dev->xfer_size;
     366                 :          4 :         addr = addr_from_zone_id(0);
     367                 :          4 :         addr += TEST_BAND_IDX * ftl_get_num_blocks_in_band(g_dev);
     368                 :          4 :         result = ftl_band_next_xfer_addr(g_band, addr, g_dev->xfer_size);
     369                 :          4 :         CU_ASSERT_EQUAL(result, expect);
     370                 :            : 
     371                 :            :         /* Verify jumping from last zone to the first one with unaligned offset */
     372                 :          4 :         expect = addr_from_zone_id(0);
     373                 :          4 :         expect += TEST_BAND_IDX * ftl_get_num_blocks_in_band(g_dev);
     374                 :          4 :         expect += g_dev->xfer_size + 2;
     375                 :          4 :         addr = addr_from_zone_id(0);
     376                 :          4 :         addr += TEST_BAND_IDX * ftl_get_num_blocks_in_band(g_dev);
     377                 :          4 :         result = ftl_band_next_xfer_addr(g_band, addr, g_dev->xfer_size + 2);
     378                 :          4 :         CU_ASSERT_EQUAL(result, expect);
     379                 :            : 
     380                 :          4 :         cleanup_band();
     381                 :          4 : }
     382                 :            : 
     383                 :            : int
     384                 :          4 : main(int argc, char **argv)
     385                 :            : {
     386                 :          4 :         CU_pSuite suite = NULL;
     387                 :            :         unsigned int num_failures;
     388                 :            : 
     389                 :          4 :         CU_initialize_registry();
     390                 :            : 
     391                 :          4 :         suite = CU_add_suite("ftl_band_suite", NULL, NULL);
     392                 :            : 
     393                 :            : 
     394                 :          4 :         CU_ADD_TEST(suite, test_band_block_offset_from_addr_base);
     395                 :          4 :         CU_ADD_TEST(suite, test_band_block_offset_from_addr_offset);
     396                 :          4 :         CU_ADD_TEST(suite, test_band_addr_from_block_offset);
     397                 :          4 :         CU_ADD_TEST(suite, test_band_set_addr);
     398                 :          4 :         CU_ADD_TEST(suite, test_invalidate_addr);
     399                 :          4 :         CU_ADD_TEST(suite, test_next_xfer_addr);
     400                 :            : 
     401                 :          4 :         num_failures = spdk_ut_run_tests(argc, argv, NULL);
     402                 :          4 :         CU_cleanup_registry();
     403                 :            : 
     404                 :          4 :         return num_failures;
     405                 :            : }

Generated by: LCOV version 1.14