LCOV - code coverage report
Current view: top level - spdk/test/unit/lib/ftl/ftl_l2p - ftl_l2p_ut.c (source / functions) Hit Total Coverage
Test: Combined Lines: 46 48 95.8 %
Date: 2024-07-11 07:44:42 Functions: 8 8 100.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 9 12 75.0 %

           Branch data     Line data    Source code
       1                 :            : /*   SPDX-License-Identifier: BSD-3-Clause
       2                 :            :  *   Copyright (C) 2022 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.h"
      12                 :            : 
      13                 :            : #define L2P_TABLE_SIZE 1024
      14                 :            : 
      15                 :            : static struct spdk_ftl_dev *g_dev;
      16                 :            : 
      17                 :            : static struct spdk_ftl_dev *
      18                 :          6 : test_alloc_dev(size_t size)
      19                 :            : {
      20                 :            :         struct spdk_ftl_dev *dev;
      21                 :            : 
      22                 :          6 :         dev = calloc(1, sizeof(*dev));
      23                 :            : 
      24                 :          6 :         dev->num_lbas = L2P_TABLE_SIZE;
      25                 :          6 :         dev->l2p = calloc(L2P_TABLE_SIZE, size);
      26                 :          6 :         dev->layout.l2p.addr_size = size;
      27                 :            : 
      28         [ +  - ]:          6 :         if (size > sizeof(uint32_t)) {
      29                 :          6 :                 dev->layout.base.total_blocks = ~(~0ULL << 33);
      30                 :            :         } else {
      31                 :          0 :                 dev->layout.base.total_blocks = 1024;
      32                 :            :         }
      33                 :            : 
      34                 :          6 :         return dev;
      35                 :            : }
      36                 :            : 
      37                 :            : static int
      38                 :          6 : setup_l2p_64bit(void)
      39                 :            : {
      40                 :          6 :         g_dev = test_alloc_dev(sizeof(uint64_t));
      41                 :          6 :         return 0;
      42                 :            : }
      43                 :            : 
      44                 :            : static void
      45                 :          6 : clean_l2p(void)
      46                 :            : {
      47                 :            :         size_t l2p_elem_size;
      48                 :            : 
      49         [ -  + ]:          6 :         if (ftl_addr_packed(g_dev)) {
      50                 :          0 :                 l2p_elem_size = sizeof(uint32_t);
      51                 :            :         } else {
      52                 :          6 :                 l2p_elem_size = sizeof(uint64_t);
      53                 :            :         }
      54         [ -  + ]:          6 :         memset(g_dev->l2p, 0, g_dev->num_lbas * l2p_elem_size);
      55                 :          6 : }
      56                 :            : 
      57                 :            : static int
      58                 :          6 : cleanup(void)
      59                 :            : {
      60                 :          6 :         free(g_dev->l2p);
      61                 :          6 :         free(g_dev);
      62                 :          6 :         g_dev = NULL;
      63                 :          6 :         return 0;
      64                 :            : }
      65                 :            : 
      66                 :            : void
      67                 :       3072 : ftl_l2p_set(struct spdk_ftl_dev *dev, uint64_t lba, ftl_addr addr)
      68                 :            : {
      69                 :       3072 :         ((uint64_t *)dev->l2p)[lba] = addr;
      70                 :       3072 : }
      71                 :            : 
      72                 :            : ftl_addr
      73                 :       6144 : ftl_l2p_get(struct spdk_ftl_dev *dev, uint64_t lba)
      74                 :            : {
      75                 :       6144 :         return ((uint64_t *)dev->l2p)[lba];
      76                 :            : }
      77                 :            : 
      78                 :            : static void
      79                 :          6 : test_addr_cached(void)
      80                 :            : {
      81                 :            :         ftl_addr addr;
      82                 :            :         size_t i;
      83                 :            : 
      84                 :            :         /* Set every other LBA is cached */
      85         [ +  + ]:       3078 :         for (i = 0; i < L2P_TABLE_SIZE; i += 2) {
      86                 :       3072 :                 addr = ftl_addr_from_nvc_offset(g_dev, i);
      87                 :       3072 :                 ftl_l2p_set(g_dev, i, addr);
      88                 :            :         }
      89                 :            : 
      90                 :            :         /* Check every even LBA is cached while others are not */
      91         [ +  + ]:       6150 :         for (i = 0; i < L2P_TABLE_SIZE; ++i) {
      92                 :       6144 :                 addr = ftl_l2p_get(g_dev, i);
      93                 :            : 
      94         [ +  + ]:       6144 :                 if (i % 2 == 0) {
      95                 :       3072 :                         CU_ASSERT_TRUE(ftl_addr_in_nvc(g_dev, addr));
      96                 :       3072 :                         CU_ASSERT_EQUAL(ftl_addr_to_nvc_offset(g_dev, addr), i);
      97                 :            :                 } else {
      98                 :       3072 :                         CU_ASSERT_FALSE(ftl_addr_in_nvc(g_dev, addr));
      99                 :            :                 }
     100                 :            :         }
     101                 :          6 :         clean_l2p();
     102                 :          6 : }
     103                 :            : 
     104                 :            : int
     105                 :          6 : main(int argc, char **argv)
     106                 :            : {
     107                 :          6 :         CU_pSuite suite64 = NULL;
     108                 :            :         unsigned int num_failures;
     109                 :            : 
     110                 :          6 :         CU_initialize_registry();
     111                 :            : 
     112                 :          6 :         suite64 = CU_add_suite("ftl_addr64_suite", setup_l2p_64bit, cleanup);
     113                 :            : 
     114                 :          6 :         CU_ADD_TEST(suite64, test_addr_cached);
     115                 :            : 
     116                 :          6 :         num_failures = spdk_ut_run_tests(argc, argv, NULL);
     117                 :          6 :         CU_cleanup_registry();
     118                 :            : 
     119                 :          6 :         return num_failures;
     120                 :            : }

Generated by: LCOV version 1.14