LCOV - code coverage report
Current view: top level - spdk/test/unit/lib/ftl/ftl_layout_upgrade - ftl_layout_upgrade_ut.c (source / functions) Hit Total Coverage
Test: Combined Lines: 170 192 88.5 %
Date: 2024-07-13 07:45:12 Functions: 10 47 21.3 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 28 66 42.4 %

           Branch data     Line data    Source code
       1                 :            : /*   SPDX-License-Identifier: BSD-3-Clause
       2                 :            :  *   Copyright 2023 Solidigm All Rights Reserved
       3                 :            :  *   Copyright (C) 2022 Intel Corporation.
       4                 :            :  *   All rights reserved.
       5                 :            :  */
       6                 :            : 
       7                 :            : #include <sys/queue.h>
       8                 :            : 
       9                 :            : #include "spdk/stdinc.h"
      10                 :            : 
      11                 :            : #include "CUnit/Basic.h"
      12                 :            : #include "common/lib/test_env.c"
      13                 :            : 
      14                 :            : #include "ftl/ftl_layout.c"
      15                 :            : #include "ftl/upgrade/ftl_layout_upgrade.h"
      16                 :            : #include "ftl/utils/ftl_layout_tracker_bdev.c"
      17                 :            : #include "ftl/upgrade/ftl_sb_v3.c"
      18                 :            : #include "ftl/upgrade/ftl_sb_v5.c"
      19                 :            : #include "ftl/ftl_sb.c"
      20                 :            : 
      21                 :            : extern struct ftl_region_upgrade_desc sb_upgrade_desc[];
      22                 :            : 
      23                 :            : int l2p_upgrade_v0_to_v1(struct spdk_ftl_dev *dev, struct ftl_layout_upgrade_ctx *ctx);
      24                 :            : int l2p_upgrade_v1_to_v2(struct spdk_ftl_dev *dev, struct ftl_layout_upgrade_ctx *ctx);
      25                 :            : int l2p_upgrade_v2_to_v3(struct spdk_ftl_dev *dev, struct ftl_layout_upgrade_ctx *ctx);
      26                 :            : 
      27                 :            : struct ftl_region_upgrade_desc l2p_upgrade_desc[] = {
      28                 :            :         [0] = {.verify = ftl_region_upgrade_enabled, .upgrade = l2p_upgrade_v0_to_v1, .new_version = 1},
      29                 :            :         [1] = {.verify = ftl_region_upgrade_enabled, .upgrade = l2p_upgrade_v1_to_v2, .new_version = 2},
      30                 :            :         [2] = {.verify = ftl_region_upgrade_enabled, .upgrade = l2p_upgrade_v2_to_v3, .new_version = 3},
      31                 :            : };
      32                 :            : 
      33                 :            : static struct ftl_layout_upgrade_desc_list layout_upgrade_desc[] = {
      34                 :            :         [FTL_LAYOUT_REGION_TYPE_SB] = {
      35                 :            :                 .latest_ver = FTL_SB_VERSION_CURRENT,
      36                 :            :                 .count = FTL_SB_VERSION_CURRENT,
      37                 :            :                 .desc = sb_upgrade_desc,
      38                 :            :         },
      39                 :            :         [FTL_LAYOUT_REGION_TYPE_SB_BASE] = {
      40                 :            :                 .latest_ver = FTL_SB_VERSION_CURRENT,
      41                 :            :                 .count = FTL_SB_VERSION_CURRENT,
      42                 :            :                 .desc = sb_upgrade_desc,
      43                 :            :         },
      44                 :            :         [FTL_LAYOUT_REGION_TYPE_L2P] = {
      45                 :            :                 .latest_ver = 3,
      46                 :            :                 .count = 3,
      47                 :            :                 .desc = l2p_upgrade_desc,
      48                 :            :         },
      49                 :            :         [FTL_LAYOUT_REGION_TYPE_BAND_MD] = {},
      50                 :            :         [FTL_LAYOUT_REGION_TYPE_BAND_MD_MIRROR] = {},
      51                 :            :         [FTL_LAYOUT_REGION_TYPE_VALID_MAP] = {},
      52                 :            :         [FTL_LAYOUT_REGION_TYPE_NVC_MD] = {},
      53                 :            :         [FTL_LAYOUT_REGION_TYPE_NVC_MD_MIRROR] = {},
      54                 :            :         [FTL_LAYOUT_REGION_TYPE_DATA_NVC] = {},
      55                 :            :         [FTL_LAYOUT_REGION_TYPE_DATA_BASE] = {},
      56                 :            :         [FTL_LAYOUT_REGION_TYPE_P2L_CKPT_GC] = {},
      57                 :            :         [FTL_LAYOUT_REGION_TYPE_P2L_CKPT_GC_NEXT] = {},
      58                 :            :         [FTL_LAYOUT_REGION_TYPE_P2L_CKPT_COMP] = {},
      59                 :            :         [FTL_LAYOUT_REGION_TYPE_P2L_CKPT_COMP_NEXT] = {},
      60                 :            :         [FTL_LAYOUT_REGION_TYPE_TRIM_MD] = {},
      61                 :            :         [FTL_LAYOUT_REGION_TYPE_TRIM_MD_MIRROR] = {},
      62                 :            :         [FTL_LAYOUT_REGION_TYPE_TRIM_LOG] = {},
      63                 :            :         [FTL_LAYOUT_REGION_TYPE_TRIM_LOG_MIRROR] = {},
      64                 :            : };
      65                 :            : 
      66                 :            : SPDK_STATIC_ASSERT(sizeof(layout_upgrade_desc) / sizeof(*layout_upgrade_desc) ==
      67                 :            :                    FTL_LAYOUT_REGION_TYPE_MAX,
      68                 :            :                    "Missing layout upgrade descriptors");
      69                 :            : 
      70                 :            : #include "ftl/upgrade/ftl_sb_upgrade.c"
      71                 :            : #include "ftl/upgrade/ftl_layout_upgrade.c"
      72                 :            : #include "ftl/mngt/ftl_mngt_md.c"
      73                 :            : 
      74                 :          0 : DEFINE_STUB_V(ftl_mngt_fail_step, (struct ftl_mngt_process *mngt));
      75                 :          6 : DEFINE_STUB_V(ftl_mngt_next_step, (struct ftl_mngt_process *mngt));
      76                 :          0 : DEFINE_STUB_V(ftl_md_persist, (struct ftl_md *md));
      77         [ #  # ]:          0 : DEFINE_STUB(ftl_nv_cache_load_state, int, (struct ftl_nv_cache *nv_cache), 0);
      78                 :          0 : DEFINE_STUB_V(ftl_valid_map_load_state, (struct spdk_ftl_dev *dev));
      79         [ #  # ]:          0 : DEFINE_STUB(ftl_bands_load_state, int, (struct spdk_ftl_dev *dev), 0);
      80         [ #  # ]:          0 : DEFINE_STUB(ftl_md_get_region, const struct ftl_layout_region *, (struct ftl_md *md), 0);
      81                 :          0 : DEFINE_STUB_V(ftl_md_restore, (struct ftl_md *md));
      82         [ #  # ]:          0 : DEFINE_STUB(ftl_nv_cache_save_state, int, (struct ftl_nv_cache *nv_cache), 0);
      83         [ #  # ]:          0 : DEFINE_STUB(ftl_mngt_get_step_ctx, void *, (struct ftl_mngt_process *mngt), 0);
      84                 :          0 : DEFINE_STUB_V(ftl_mngt_persist_bands_p2l, (struct ftl_mngt_process *mngt));
      85                 :          6 : DEFINE_STUB_V(ftl_band_init_gc_iter, (struct spdk_ftl_dev *dev));
      86         [ #  # ]:          0 : DEFINE_STUB(ftl_md_create_region_flags, int, (struct spdk_ftl_dev *dev, int region_type), 0);
      87         [ #  # ]:          0 : DEFINE_STUB(ftl_md_create, struct ftl_md *, (struct spdk_ftl_dev *dev, uint64_t blocks,
      88                 :            :                 uint64_t vss_blksz, const char *name, int flags, const struct ftl_layout_region *region), NULL);
      89         [ #  # ]:          0 : DEFINE_STUB(ftl_md_destroy_region_flags, int, (struct spdk_ftl_dev *dev, int region_type), 0);
      90         [ #  # ]:          0 : DEFINE_STUB(ftl_md_destroy_shm_flags, int, (struct spdk_ftl_dev *dev), 0);
      91                 :          0 : DEFINE_STUB_V(ftl_md_destroy, (struct ftl_md *md, int flags));
      92                 :          0 : DEFINE_STUB_V(ftl_mngt_call_process, (struct ftl_mngt_process *mngt,
      93                 :            :                                       const struct ftl_mngt_process_desc *process,
      94                 :            :                                       void *init_ctx));
      95         [ #  # ]:          0 : DEFINE_STUB(ftl_md_get_buffer, void *, (struct ftl_md *md), NULL);
      96         [ #  # ]:          0 : DEFINE_STUB(spdk_bdev_desc_get_bdev, struct spdk_bdev *, (struct spdk_bdev_desc *desc), NULL);
      97         [ #  # ]:          0 : DEFINE_STUB(spdk_bdev_get_write_unit_size, uint32_t, (const struct spdk_bdev *bdev), 0);
      98         [ #  # ]:          0 : DEFINE_STUB(spdk_bdev_get_num_blocks, uint64_t, (const struct spdk_bdev *bdev), 0);
      99         [ #  # ]:          0 : DEFINE_STUB(ftl_nv_cache_chunk_tail_md_num_blocks, size_t, (const struct ftl_nv_cache *nv_cache),
     100                 :            :             0);
     101         [ #  # ]:          0 : DEFINE_STUB(ftl_band_user_blocks, size_t, (const struct ftl_band *band), 0);
     102                 :            : 
     103                 :            : struct spdk_bdev_desc {
     104                 :            :         int dummy;
     105                 :            : };
     106                 :            : 
     107                 :            : struct spdk_ftl_dev g_dev;
     108                 :            : struct ftl_superblock_shm g_sb_shm = {0};
     109                 :            : struct ftl_base_device_type g_base_type = { .name = "base_dev" };
     110                 :            : struct ftl_nv_cache_device_type g_nvc_type = { .name = "nvc_dev" };
     111                 :            : struct spdk_bdev_desc g_base_bdev_desc = {0};
     112                 :            : struct spdk_bdev_desc g_nvc_bdev_desc = {0};
     113                 :            : static uint8_t g_sb_buf[FTL_SUPERBLOCK_SIZE] = {0};
     114                 :            : 
     115                 :            : #define TEST_OP 0x1984
     116                 :            : #define TEST_REG_BLKS 0x10000
     117                 :            : #define TEST_NVC_BLKS 0x1000000;
     118                 :            : #define TEST_BASE_BLKS 0x1000000000;
     119                 :            : 
     120                 :            : static int
     121                 :          6 : test_setup(void)
     122                 :            : {
     123                 :          6 :         int regno_nvc = 0, regno_base = 0, *regno_dev;
     124                 :            : 
     125                 :            :         /* setup a dummy dev: */
     126                 :          6 :         g_dev.sb = (void *)g_sb_buf;
     127                 :          6 :         g_dev.sb_shm = &g_sb_shm;
     128                 :          6 :         g_dev.conf.overprovisioning = TEST_OP;
     129         [ +  + ]:        102 :         for (uint64_t n = 0; n < sizeof(g_dev.conf.uuid); n++) {
     130                 :         96 :                 g_dev.conf.uuid.u.raw[n] = n;
     131                 :            :         }
     132                 :            : 
     133                 :          6 :         g_dev.layout.nvc.total_blocks = TEST_NVC_BLKS;
     134                 :          6 :         g_dev.layout.base.total_blocks = TEST_BASE_BLKS;
     135                 :          6 :         g_dev.base_type = &g_base_type;
     136                 :          6 :         g_dev.nv_cache.nvc_type = &g_nvc_type;
     137                 :          6 :         g_dev.base_layout_tracker = ftl_layout_tracker_bdev_init(UINT32_MAX);
     138                 :          6 :         g_dev.nvc_layout_tracker = ftl_layout_tracker_bdev_init(UINT32_MAX);
     139                 :          6 :         g_dev.base_bdev_desc = &g_base_bdev_desc;
     140                 :          6 :         g_dev.nv_cache.bdev_desc = &g_nvc_bdev_desc;
     141                 :            : 
     142         [ +  + ]:        114 :         for (int regno = 0; regno < FTL_LAYOUT_REGION_TYPE_MAX; regno++) {
     143                 :        108 :                 struct ftl_layout_region *reg = &g_dev.layout.region[regno];
     144                 :        108 :                 reg->current.blocks = TEST_REG_BLKS;
     145         [ +  + ]:        108 :                 regno_dev = sb_v3_md_region_is_nvc(regno) ? &regno_nvc : &regno_base;
     146                 :        108 :                 reg->current.offset = *regno_dev * TEST_REG_BLKS;
     147                 :        108 :                 (*regno_dev)++;
     148                 :        108 :                 reg->current.version = ftl_layout_upgrade_region_get_latest_version(regno);
     149                 :        108 :                 reg->type = regno;
     150                 :        108 :                 reg->name = "region_test";
     151         [ +  + ]:        108 :                 reg->bdev_desc = sb_v3_md_region_is_nvc(regno) ? &g_nvc_bdev_desc : &g_base_bdev_desc;
     152                 :        108 :                 reg->ioch = 0;
     153                 :            :         }
     154                 :          6 :         return 0;
     155                 :            : }
     156                 :            : 
     157                 :            : static int
     158                 :          6 : test_teardown(void)
     159                 :            : {
     160         [ +  - ]:          6 :         if (g_dev.base_layout_tracker) {
     161                 :          6 :                 ftl_layout_tracker_bdev_fini(g_dev.base_layout_tracker);
     162                 :          6 :                 g_dev.base_layout_tracker = NULL;
     163                 :            :         }
     164         [ +  - ]:          6 :         if (g_dev.nvc_layout_tracker) {
     165                 :          6 :                 ftl_layout_tracker_bdev_fini(g_dev.nvc_layout_tracker);
     166                 :          6 :                 g_dev.nvc_layout_tracker = NULL;
     167                 :            :         }
     168                 :          6 :         return 0;
     169                 :            : }
     170                 :            : 
     171                 :            : static void
     172                 :          6 : test_setup_sb_v5(uint64_t clean)
     173                 :            : {
     174                 :          6 :         union ftl_superblock_ver *sb = (void *)g_sb_buf;
     175                 :            :         uint64_t zero_offs;
     176                 :            : 
     177         [ -  + ]:          6 :         memset(&g_sb_buf, 0, sizeof(g_sb_buf));
     178                 :          6 :         ftl_mngt_init_default_sb(&g_dev, NULL);
     179                 :          6 :         sb->header.version = FTL_SB_VERSION_5;
     180                 :            : 
     181                 :          6 :         zero_offs = sizeof(struct ftl_superblock_v5);
     182         [ -  + ]:          6 :         memset(g_sb_buf + zero_offs, 0, sizeof(g_sb_buf) - zero_offs);
     183                 :          6 :         sb->v5.clean = clean;
     184                 :            : 
     185                 :          6 :         sb->header.crc = get_sb_crc(&sb->current);
     186                 :          6 : }
     187                 :            : 
     188                 :            : static void
     189                 :          6 : test_l2p_upgrade(void)
     190                 :            : {
     191                 :          6 :         union ftl_superblock_ver *sb = (void *)g_sb_buf;
     192                 :            :         struct layout_tracker_blob_entry *tbe;
     193                 :            :         struct layout_blob_entry *lbe;
     194                 :            :         struct ftl_layout_region *reg;
     195                 :          6 :         struct ftl_layout_upgrade_ctx ctx = {0};
     196                 :            :         void *blob_nvc, *blob_base, *blob_regs;
     197                 :            :         uint64_t upgrades;
     198                 :            :         int rc;
     199                 :            : 
     200                 :          6 :         test_setup_sb_v5(true);
     201                 :          6 :         CU_ASSERT_EQUAL(ftl_superblock_is_blob_area_empty(&sb->current), true);
     202                 :            : 
     203                 :            :         /* load failed: empty md list: */
     204                 :          6 :         rc = ftl_superblock_v5_load_blob_area(&g_dev);
     205                 :          6 :         CU_ASSERT_NOT_EQUAL(rc, 0);
     206                 :            : 
     207                 :            :         /* create md layout: */
     208         [ +  + ]:        114 :         for (enum ftl_layout_region_type regno = 0; regno < FTL_LAYOUT_REGION_TYPE_MAX; regno++) {
     209                 :        108 :                 struct ftl_layout_region *reg = &g_dev.layout.region[regno];
     210                 :        108 :                 CU_ASSERT_EQUAL(regno, reg->type);
     211         [ +  + ]:        108 :                 struct ftl_layout_tracker_bdev *tracker = sb_v3_md_region_is_nvc(regno) ? g_dev.nvc_layout_tracker :
     212                 :            :                                 g_dev.base_layout_tracker;
     213                 :        180 :                 const struct ftl_layout_tracker_bdev_region_props *reg_props = ftl_layout_tracker_bdev_add_region(
     214                 :        108 :                                         tracker, reg->type, reg->current.version, reg->current.blocks, TEST_REG_BLKS);
     215                 :            : 
     216                 :        108 :                 CU_ASSERT_EQUAL(reg->type, reg_props->type);
     217                 :        108 :                 CU_ASSERT_EQUAL(reg->current.version, reg_props->ver);
     218                 :        108 :                 CU_ASSERT_EQUAL(reg->current.offset, reg_props->blk_offs);
     219                 :        108 :                 CU_ASSERT_EQUAL(reg->current.blocks, reg_props->blk_sz);
     220                 :            :         }
     221                 :          6 :         ftl_superblock_v5_store_blob_area(&g_dev);
     222                 :          6 :         CU_ASSERT_EQUAL(ftl_superblock_is_blob_area_empty(&sb->current), false);
     223                 :            : 
     224                 :          6 :         blob_nvc = ftl_df_get_obj_ptr(sb->v5.blob_area, sb->v5.md_layout_nvc.df_id);
     225                 :          6 :         blob_base = ftl_df_get_obj_ptr(sb->v5.blob_area, sb->v5.md_layout_base.df_id);
     226                 :          6 :         blob_regs = ftl_df_get_obj_ptr(sb->v5.blob_area, sb->v5.layout_params.df_id);
     227                 :            : 
     228                 :            :         /* move the sb-stored blobs around: */
     229                 :          6 :         CU_ASSERT(blob_nvc < blob_base);
     230                 :          6 :         CU_ASSERT(blob_base < blob_regs);
     231   [ -  +  -  + ]:          6 :         blob_regs = memmove(blob_regs + 8192, blob_regs, sb->v5.layout_params.blob_sz);
     232                 :          6 :         sb->v5.layout_params.df_id += 8192;
     233   [ -  +  -  + ]:          6 :         blob_base = memmove(blob_base + 4096, blob_base, sb->v5.md_layout_base.blob_sz);
     234                 :          6 :         sb->v5.md_layout_base.df_id += 4096;
     235                 :            : 
     236                 :            :         /* fix l2p region version to v0 */
     237                 :          6 :         tbe = blob_nvc;
     238                 :          6 :         tbe++;
     239                 :          6 :         CU_ASSERT_EQUAL(tbe->type, FTL_LAYOUT_REGION_TYPE_L2P);
     240                 :          6 :         tbe->ver = 0;
     241                 :          6 :         reg = &g_dev.layout.region[FTL_LAYOUT_REGION_TYPE_L2P];
     242                 :          6 :         reg->current.version = 0;
     243                 :            : 
     244                 :            :         /* fix l2p num entries and size */
     245                 :          6 :         lbe = blob_regs;
     246                 :          6 :         lbe += FTL_LAYOUT_REGION_TYPE_L2P;
     247                 :          6 :         CU_ASSERT_EQUAL(lbe->type, FTL_LAYOUT_REGION_TYPE_L2P);
     248                 :          6 :         lbe->entry_size = 1;
     249                 :          6 :         lbe->num_entries = 0x1000;
     250                 :            : 
     251                 :            :         /* add l2p v2 region for a major upgrade */
     252                 :          6 :         tbe = (blob_nvc + sb->v5.md_layout_nvc.blob_sz);
     253                 :          6 :         sb->v5.md_layout_nvc.blob_sz += sizeof(*tbe);
     254                 :          6 :         tbe->type = FTL_LAYOUT_REGION_TYPE_L2P;
     255                 :          6 :         tbe->ver = 2;
     256                 :            : 
     257                 :            :         /* region overlap */
     258                 :          6 :         tbe->blk_offs = 0x1984;
     259                 :          6 :         tbe->blk_sz = 0x0514;
     260                 :          6 :         rc = ftl_superblock_v5_load_blob_area(&g_dev);
     261                 :          6 :         CU_ASSERT_NOT_EQUAL(rc, 0);
     262                 :            : 
     263                 :            :         /* correct region placement */
     264                 :          6 :         tbe->blk_offs = 0x19840514;
     265                 :          6 :         tbe->blk_sz = 0xc0ffee;
     266                 :          6 :         rc = ftl_superblock_v5_load_blob_area(&g_dev);
     267                 :          6 :         CU_ASSERT_EQUAL(rc, 0);
     268                 :            : 
     269                 :            :         /* upgrade verification */
     270                 :          6 :         ctx.reg = &g_dev.layout.region[0];
     271                 :          6 :         ctx.upgrade = &layout_upgrade_desc[0];
     272         [ +  + ]:        114 :         for (int reg_type = 0; reg_type < FTL_LAYOUT_REGION_TYPE_MAX;
     273                 :        108 :              reg_type++, ctx.reg++, ctx.upgrade++) {
     274   [ +  +  +  + ]:        108 :                 if (reg_type == FTL_LAYOUT_REGION_TYPE_SB || reg_type == FTL_LAYOUT_REGION_TYPE_SB_BASE) {
     275                 :         12 :                         ctx.reg->current.version = g_dev.sb->header.version;
     276                 :            :                 }
     277                 :        108 :                 rc = region_verify(&g_dev, &ctx);
     278                 :        108 :                 CU_ASSERT_EQUAL(rc, 0);
     279                 :            :         }
     280                 :            : 
     281                 :            :         /* region upgrade */
     282                 :          6 :         CU_ASSERT_EQUAL(reg->num_entries, 0x1000);
     283                 :          6 :         CU_ASSERT_EQUAL(reg->entry_size, 1);
     284                 :            : 
     285                 :          6 :         ctx.reg = &g_dev.layout.region[0];
     286                 :          6 :         ctx.upgrade = &layout_upgrade_desc[0];
     287                 :          6 :         upgrades = 0;
     288                 :         18 :         while (true) {
     289                 :            :                 uint64_t prev_ver;
     290                 :            : 
     291                 :         24 :                 rc = layout_upgrade_select_next_region(&g_dev, &ctx);
     292         [ +  + ]:         24 :                 if (rc == FTL_LAYOUT_UPGRADE_DONE) {
     293                 :          6 :                         break;
     294                 :            :                 }
     295                 :         18 :                 CU_ASSERT_EQUAL(rc, FTL_LAYOUT_UPGRADE_CONTINUE);
     296                 :         18 :                 CU_ASSERT_EQUAL(ctx.reg->type, FTL_LAYOUT_REGION_TYPE_L2P);
     297                 :         18 :                 upgrades++;
     298                 :            : 
     299                 :         18 :                 prev_ver = ctx.reg->current.version;
     300                 :         18 :                 rc = ftl_region_upgrade(&g_dev, &ctx);
     301                 :         18 :                 CU_ASSERT_EQUAL(rc, 0);
     302                 :         18 :                 CU_ASSERT_TRUE(prev_ver < ctx.reg->current.version);
     303                 :         18 :                 CU_ASSERT_EQUAL(upgrades, ctx.reg->current.version);
     304                 :            :         }
     305                 :          6 :         CU_ASSERT_EQUAL(upgrades, 3);
     306                 :          6 :         CU_ASSERT_EQUAL(reg->current.offset, 0x19840514);
     307                 :          6 :         CU_ASSERT_EQUAL(reg->current.blocks, 0xc0ffee);
     308                 :          6 :         CU_ASSERT_EQUAL(reg->num_entries, 0x1984);
     309                 :          6 :         CU_ASSERT_EQUAL(reg->entry_size, 0x1405);
     310                 :            : 
     311                 :            :         /* no more upgrades: */
     312                 :          6 :         ctx.reg = &g_dev.layout.region[0];
     313                 :          6 :         ctx.upgrade = &layout_upgrade_desc[0];
     314                 :          6 :         rc = layout_upgrade_select_next_region(&g_dev, &ctx);
     315                 :          6 :         CU_ASSERT_EQUAL(rc, FTL_LAYOUT_UPGRADE_DONE);
     316                 :            : 
     317                 :            :         /* restore the sb: */
     318                 :          6 :         sb->v5.md_layout_nvc.blob_sz -= sizeof(*tbe);
     319                 :          6 : }
     320                 :            : 
     321                 :            : int
     322                 :          6 : l2p_upgrade_v0_to_v1(struct spdk_ftl_dev *dev, struct ftl_layout_upgrade_ctx *ctx)
     323                 :            : {
     324                 :          6 :         struct ftl_layout_region *region = ctx->reg;
     325                 :            : 
     326                 :            :         /* minor */
     327                 :          6 :         CU_ASSERT_EQUAL(region->current.version, 0);
     328                 :          6 :         CU_ASSERT_EQUAL(ctx->next_reg_ver, 1);
     329                 :          6 :         CU_ASSERT_NOT_EQUAL(region->current.offset, 0x1984);
     330                 :          6 :         CU_ASSERT_NOT_EQUAL(region->current.blocks, 0x0514);
     331                 :            : 
     332                 :          6 :         ftl_region_upgrade_completed(dev, ctx, 0, 0, 0);
     333                 :          6 :         return 0;
     334                 :            : }
     335                 :            : 
     336                 :            : int
     337                 :          6 : l2p_upgrade_v1_to_v2(struct spdk_ftl_dev *dev, struct ftl_layout_upgrade_ctx *ctx)
     338                 :            : {
     339                 :          6 :         struct ftl_layout_region *region = ctx->reg;
     340                 :            : 
     341                 :            :         /* major */
     342                 :          6 :         CU_ASSERT_EQUAL(region->current.version, 1);
     343                 :          6 :         CU_ASSERT_EQUAL(ctx->next_reg_ver, 2);
     344                 :          6 :         CU_ASSERT_NOT_EQUAL(region->current.offset, 0x1984);
     345                 :          6 :         CU_ASSERT_NOT_EQUAL(region->current.blocks, 0x0514);
     346                 :            : 
     347                 :          6 :         ftl_region_upgrade_completed(dev, ctx, 0x1405, 0x1984, 0);
     348                 :          6 :         return 0;
     349                 :            : }
     350                 :            : 
     351                 :            : int
     352                 :          6 : l2p_upgrade_v2_to_v3(struct spdk_ftl_dev *dev, struct ftl_layout_upgrade_ctx *ctx)
     353                 :            : {
     354                 :          6 :         struct ftl_layout_region *region = ctx->reg;
     355                 :            : 
     356                 :            :         /* minor */
     357                 :          6 :         CU_ASSERT_EQUAL(region->current.version, 2);
     358                 :          6 :         CU_ASSERT_EQUAL(ctx->next_reg_ver, 3);
     359                 :          6 :         CU_ASSERT_EQUAL(region->current.offset, 0x19840514);
     360                 :          6 :         CU_ASSERT_EQUAL(region->current.blocks, 0xc0ffee);
     361                 :            : 
     362                 :          6 :         ftl_region_upgrade_completed(dev, ctx, 0, 0, 0);
     363                 :          6 :         return 0;
     364                 :            : }
     365                 :            : 
     366                 :            : int
     367                 :          6 : main(int argc, char **argv)
     368                 :            : {
     369                 :          6 :         CU_pSuite suite = NULL;
     370                 :          6 :         unsigned int num_failures = 0;
     371                 :            : 
     372                 :          6 :         CU_set_error_action(CUEA_ABORT);
     373                 :          6 :         CU_initialize_registry();
     374                 :            : 
     375                 :          6 :         suite = CU_add_suite("ftl_layout_upgrade", test_setup, test_teardown);
     376                 :            : 
     377                 :          6 :         CU_ADD_TEST(suite, test_l2p_upgrade);
     378                 :            : 
     379                 :          6 :         CU_basic_set_mode(CU_BRM_VERBOSE);
     380                 :          6 :         CU_basic_run_tests();
     381                 :          6 :         num_failures = CU_get_number_of_failures();
     382                 :          6 :         CU_cleanup_registry();
     383                 :            : 
     384                 :          6 :         return num_failures;
     385                 :            : }

Generated by: LCOV version 1.14