LCOV - code coverage report
Current view: top level - spdk/test/unit/lib/bdev/raid - common.c (source / functions) Hit Total Coverage
Test: Combined Lines: 123 125 98.4 %
Date: 2024-07-12 17:44:46 Functions: 15 15 100.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 42 60 70.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_internal/cunit.h"
       7                 :            : #include "spdk/stdinc.h"
       8                 :            : #include "bdev/raid/bdev_raid.h"
       9                 :            : 
      10                 :            : struct spdk_bdev_desc {
      11                 :            :         struct spdk_bdev *bdev;
      12                 :            : };
      13                 :            : 
      14                 :            : typedef enum spdk_dif_type spdk_dif_type_t;
      15                 :            : 
      16                 :            : spdk_dif_type_t
      17                 :      69254 : spdk_bdev_get_dif_type(const struct spdk_bdev *bdev)
      18                 :            : {
      19         [ +  + ]:      69254 :         if (bdev->md_len != 0) {
      20                 :      45068 :                 return bdev->dif_type;
      21                 :            :         } else {
      22                 :      24186 :                 return SPDK_DIF_DISABLE;
      23                 :            :         }
      24                 :            : }
      25                 :            : 
      26                 :            : enum raid_params_md_type {
      27                 :            :         RAID_PARAMS_MD_NONE,
      28                 :            :         RAID_PARAMS_MD_SEPARATE,
      29                 :            :         RAID_PARAMS_MD_INTERLEAVED,
      30                 :            : };
      31                 :            : 
      32                 :            : struct raid_params {
      33                 :            :         uint8_t num_base_bdevs;
      34                 :            :         uint64_t base_bdev_blockcnt;
      35                 :            :         uint32_t base_bdev_blocklen;
      36                 :            :         uint32_t strip_size;
      37                 :            :         enum raid_params_md_type md_type;
      38                 :            : };
      39                 :            : 
      40                 :            : int raid_test_params_alloc(size_t count);
      41                 :            : void raid_test_params_free(void);
      42                 :            : void raid_test_params_add(struct raid_params *params);
      43                 :            : struct raid_bdev *raid_test_create_raid_bdev(struct raid_params *params,
      44                 :            :                 struct raid_bdev_module *module);
      45                 :            : void raid_test_delete_raid_bdev(struct raid_bdev *raid_bdev);
      46                 :            : struct raid_bdev_io_channel *raid_test_create_io_channel(struct raid_bdev *raid_bdev);
      47                 :            : void raid_test_destroy_io_channel(struct raid_bdev_io_channel *raid_ch);
      48                 :            : void raid_test_bdev_io_init(struct raid_bdev_io *raid_io, struct raid_bdev *raid_bdev,
      49                 :            :                             struct raid_bdev_io_channel *raid_ch,
      50                 :            :                             enum spdk_bdev_io_type type, uint64_t offset_blocks,
      51                 :            :                             uint64_t num_blocks, struct iovec *iovs, int iovcnt, void *md_buf);
      52                 :            : 
      53                 :            : /* needs to be implemented in module unit test files */
      54                 :            : void raid_test_bdev_io_complete(struct raid_bdev_io *raid_io, enum spdk_bdev_io_status status);
      55                 :            : 
      56                 :            : struct raid_params *g_params;
      57                 :            : size_t g_params_count;
      58                 :            : size_t g_params_size;
      59                 :            : 
      60                 :            : #define ARRAY_FOR_EACH(a, e) \
      61                 :            :         for (e = a; e < a + SPDK_COUNTOF(a); e++)
      62                 :            : 
      63                 :            : #define RAID_PARAMS_FOR_EACH(p) \
      64                 :            :         for (p = g_params; p < g_params + g_params_count; p++)
      65                 :            : 
      66                 :            : struct spdk_bdev *
      67                 :     157534 : spdk_bdev_desc_get_bdev(struct spdk_bdev_desc *desc)
      68                 :            : {
      69                 :     157534 :         return desc->bdev;
      70                 :            : }
      71                 :            : 
      72                 :            : int
      73                 :         10 : raid_test_params_alloc(size_t count)
      74                 :            : {
      75         [ -  + ]:         10 :         assert(g_params == NULL);
      76                 :            : 
      77                 :         10 :         g_params_size = count;
      78                 :         10 :         g_params_count = 0;
      79                 :         10 :         g_params = calloc(count, sizeof(*g_params));
      80                 :            : 
      81         [ +  - ]:         10 :         return g_params ? 0 : -ENOMEM;
      82                 :            : }
      83                 :            : 
      84                 :            : void
      85                 :         10 : raid_test_params_free(void)
      86                 :            : {
      87                 :         10 :         g_params_count = 0;
      88                 :         10 :         g_params_size = 0;
      89                 :         10 :         free(g_params);
      90                 :         10 : }
      91                 :            : 
      92                 :            : void
      93                 :        378 : raid_test_params_add(struct raid_params *params)
      94                 :            : {
      95         [ -  + ]:        378 :         assert(g_params_count < g_params_size);
      96                 :            : 
      97   [ -  +  -  + ]:        378 :         memcpy(g_params + g_params_count, params, sizeof(*params));
      98                 :        378 :         g_params_count++;
      99                 :        378 : }
     100                 :            : 
     101                 :            : struct raid_bdev *
     102                 :       3260 : raid_test_create_raid_bdev(struct raid_params *params, struct raid_bdev_module *module)
     103                 :            : {
     104                 :            :         struct raid_bdev *raid_bdev;
     105                 :            :         struct raid_base_bdev_info *base_info;
     106                 :            : 
     107         [ -  + ]:       3260 :         SPDK_CU_ASSERT_FATAL(spdk_u32_is_pow2(params->base_bdev_blocklen));
     108                 :            : 
     109                 :       3260 :         raid_bdev = calloc(1, sizeof(*raid_bdev));
     110         [ -  + ]:       3260 :         SPDK_CU_ASSERT_FATAL(raid_bdev != NULL);
     111                 :            : 
     112                 :       3260 :         raid_bdev->module = module;
     113                 :       3260 :         raid_bdev->level = module->level;
     114                 :       3260 :         raid_bdev->num_base_bdevs = params->num_base_bdevs;
     115                 :            : 
     116   [ +  +  +  - ]:       3260 :         switch (raid_bdev->module->base_bdevs_constraint.type) {
     117                 :       1584 :         case CONSTRAINT_MAX_BASE_BDEVS_REMOVED:
     118                 :       3168 :                 raid_bdev->min_base_bdevs_operational = raid_bdev->num_base_bdevs -
     119                 :       1584 :                                                         raid_bdev->module->base_bdevs_constraint.value;
     120                 :       1584 :                 break;
     121                 :        192 :         case CONSTRAINT_MIN_BASE_BDEVS_OPERATIONAL:
     122                 :        192 :                 raid_bdev->min_base_bdevs_operational = raid_bdev->module->base_bdevs_constraint.value;
     123                 :        192 :                 break;
     124                 :       1484 :         case CONSTRAINT_UNSET:
     125                 :       1484 :                 raid_bdev->min_base_bdevs_operational = raid_bdev->num_base_bdevs;
     126                 :       1484 :                 break;
     127                 :          0 :         default:
     128                 :          0 :                 CU_FAIL_FATAL("unsupported raid constraint type");
     129                 :            :         };
     130                 :            : 
     131                 :       3260 :         raid_bdev->bdev.blocklen = params->base_bdev_blocklen;
     132         [ +  + ]:       3260 :         raid_bdev->bdev.md_len = (params->md_type == RAID_PARAMS_MD_NONE ? 0 : 16);
     133                 :       3260 :         raid_bdev->bdev.md_interleave = (params->md_type == RAID_PARAMS_MD_INTERLEAVED);
     134   [ -  +  +  + ]:       3260 :         if (raid_bdev->bdev.md_interleave) {
     135                 :        528 :                 raid_bdev->bdev.blocklen += raid_bdev->bdev.md_len;
     136                 :            :         }
     137                 :            : 
     138                 :       3260 :         raid_bdev->strip_size = params->strip_size;
     139                 :       3260 :         raid_bdev->strip_size_kb = params->strip_size * params->base_bdev_blocklen / 1024;
     140                 :       3260 :         raid_bdev->strip_size_shift = spdk_u32log2(raid_bdev->strip_size);
     141                 :            : 
     142                 :       3260 :         raid_bdev->base_bdev_info = calloc(raid_bdev->num_base_bdevs,
     143                 :            :                                            sizeof(struct raid_base_bdev_info));
     144         [ -  + ]:       3260 :         SPDK_CU_ASSERT_FATAL(raid_bdev->base_bdev_info != NULL);
     145                 :            : 
     146         [ +  + ]:      17084 :         RAID_FOR_EACH_BASE_BDEV(raid_bdev, base_info) {
     147                 :            :                 struct spdk_bdev *bdev;
     148                 :            :                 struct spdk_bdev_desc *desc;
     149                 :            : 
     150                 :      13824 :                 bdev = calloc(1, sizeof(*bdev));
     151         [ -  + ]:      13824 :                 SPDK_CU_ASSERT_FATAL(bdev != NULL);
     152                 :      13824 :                 bdev->ctxt = base_info;
     153                 :      13824 :                 bdev->blockcnt = params->base_bdev_blockcnt;
     154                 :      13824 :                 bdev->blocklen = raid_bdev->bdev.blocklen;
     155                 :      13824 :                 bdev->md_len = raid_bdev->bdev.md_len;
     156         [ -  + ]:      13824 :                 bdev->md_interleave = raid_bdev->bdev.md_interleave;
     157                 :            : 
     158                 :      13824 :                 desc = calloc(1, sizeof(*desc));
     159         [ -  + ]:      13824 :                 SPDK_CU_ASSERT_FATAL(desc != NULL);
     160                 :      13824 :                 desc->bdev = bdev;
     161                 :            : 
     162                 :      13824 :                 base_info->raid_bdev = raid_bdev;
     163                 :      13824 :                 base_info->desc = desc;
     164                 :      13824 :                 base_info->data_offset = 0;
     165                 :      13824 :                 base_info->data_size = bdev->blockcnt;
     166                 :            :         }
     167                 :            : 
     168                 :       3260 :         return raid_bdev;
     169                 :            : }
     170                 :            : 
     171                 :            : void
     172                 :       3260 : raid_test_delete_raid_bdev(struct raid_bdev *raid_bdev)
     173                 :            : {
     174                 :            :         struct raid_base_bdev_info *base_info;
     175                 :            : 
     176         [ +  + ]:      17084 :         RAID_FOR_EACH_BASE_BDEV(raid_bdev, base_info) {
     177                 :      13824 :                 free(base_info->desc->bdev);
     178                 :      13824 :                 free(base_info->desc);
     179                 :            :         }
     180                 :       3260 :         free(raid_bdev->base_bdev_info);
     181                 :       3260 :         free(raid_bdev);
     182                 :       3260 : }
     183                 :            : 
     184                 :            : struct raid_bdev_io_channel {
     185                 :            :         struct spdk_io_channel **_base_channels;
     186                 :            :         struct spdk_io_channel *_module_channel;
     187                 :            : };
     188                 :            : 
     189                 :            : struct spdk_io_channel *
     190                 :     416028 : raid_bdev_channel_get_base_channel(struct raid_bdev_io_channel *raid_ch, uint8_t idx)
     191                 :            : {
     192                 :     416028 :         return raid_ch->_base_channels[idx];
     193                 :            : }
     194                 :            : 
     195                 :            : void *
     196                 :      28494 : raid_bdev_channel_get_module_ctx(struct raid_bdev_io_channel *raid_ch)
     197                 :            : {
     198                 :      28494 :         return spdk_io_channel_get_ctx(raid_ch->_module_channel);
     199                 :            : }
     200                 :            : 
     201                 :            : struct raid_bdev_io_channel *
     202                 :       2882 : raid_test_create_io_channel(struct raid_bdev *raid_bdev)
     203                 :            : {
     204                 :            :         struct raid_bdev_io_channel *raid_ch;
     205                 :            :         uint8_t i;
     206                 :            : 
     207                 :       2882 :         raid_ch = calloc(1, sizeof(*raid_ch));
     208         [ -  + ]:       2882 :         SPDK_CU_ASSERT_FATAL(raid_ch != NULL);
     209                 :            : 
     210                 :       2882 :         raid_ch->_base_channels = calloc(raid_bdev->num_base_bdevs, sizeof(struct spdk_io_channel *));
     211         [ -  + ]:       2882 :         SPDK_CU_ASSERT_FATAL(raid_ch->_base_channels != NULL);
     212                 :            : 
     213         [ +  + ]:      15266 :         for (i = 0; i < raid_bdev->num_base_bdevs; i++) {
     214                 :      12384 :                 raid_ch->_base_channels[i] = (void *)1;
     215                 :            :         }
     216                 :            : 
     217         [ +  + ]:       2882 :         if (raid_bdev->module->get_io_channel) {
     218                 :       1530 :                 raid_ch->_module_channel = raid_bdev->module->get_io_channel(raid_bdev);
     219         [ -  + ]:       1530 :                 SPDK_CU_ASSERT_FATAL(raid_ch->_module_channel != NULL);
     220                 :            :         }
     221                 :            : 
     222                 :       2882 :         return raid_ch;
     223                 :            : }
     224                 :            : 
     225                 :            : void
     226                 :       2882 : raid_test_destroy_io_channel(struct raid_bdev_io_channel *raid_ch)
     227                 :            : {
     228                 :       2882 :         free(raid_ch->_base_channels);
     229                 :            : 
     230         [ +  + ]:       2882 :         if (raid_ch->_module_channel) {
     231                 :       1530 :                 spdk_put_io_channel(raid_ch->_module_channel);
     232                 :       1530 :                 poll_threads();
     233                 :            :         }
     234                 :            : 
     235                 :       2882 :         free(raid_ch);
     236                 :       2882 : }
     237                 :            : 
     238                 :            : void
     239                 :      46318 : raid_test_bdev_io_init(struct raid_bdev_io *raid_io, struct raid_bdev *raid_bdev,
     240                 :            :                        struct raid_bdev_io_channel *raid_ch,
     241                 :            :                        enum spdk_bdev_io_type type, uint64_t offset_blocks,
     242                 :            :                        uint64_t num_blocks, struct iovec *iovs, int iovcnt, void *md_buf)
     243                 :            : {
     244         [ -  + ]:      46318 :         memset(raid_io, 0, sizeof(*raid_io));
     245                 :            : 
     246                 :      46318 :         raid_io->raid_bdev = raid_bdev;
     247                 :      46318 :         raid_io->raid_ch = raid_ch;
     248                 :            : 
     249                 :      46318 :         raid_io->type = type;
     250                 :      46318 :         raid_io->offset_blocks = offset_blocks;
     251                 :      46318 :         raid_io->num_blocks = num_blocks;
     252                 :      46318 :         raid_io->iovs = iovs;
     253                 :      46318 :         raid_io->iovcnt = iovcnt;
     254                 :      46318 :         raid_io->md_buf = md_buf;
     255                 :            : 
     256                 :      46318 :         raid_bdev_io_set_default_status(raid_io, SPDK_BDEV_IO_STATUS_SUCCESS);
     257                 :      46318 : }
     258                 :            : 
     259                 :            : void
     260                 :      43252 : raid_bdev_io_complete(struct raid_bdev_io *raid_io, enum spdk_bdev_io_status status)
     261                 :            : {
     262         [ +  + ]:      43252 :         if (raid_io->completion_cb != NULL) {
     263                 :       1998 :                 raid_io->completion_cb(raid_io, status);
     264                 :            :         } else {
     265                 :      41254 :                 raid_test_bdev_io_complete(raid_io, status);
     266                 :            :         }
     267                 :      43252 : }
     268                 :            : 
     269                 :            : bool
     270                 :     211444 : raid_bdev_io_complete_part(struct raid_bdev_io *raid_io, uint64_t completed,
     271                 :            :                            enum spdk_bdev_io_status status)
     272                 :            : {
     273         [ -  + ]:     211444 :         SPDK_CU_ASSERT_FATAL(raid_io->base_bdev_io_remaining >= completed);
     274                 :     211444 :         raid_io->base_bdev_io_remaining -= completed;
     275                 :            : 
     276         [ +  + ]:     211444 :         if (status != raid_io->base_bdev_io_status_default) {
     277                 :      10824 :                 raid_io->base_bdev_io_status = status;
     278                 :            :         }
     279                 :            : 
     280         [ +  + ]:     211444 :         if (raid_io->base_bdev_io_remaining == 0) {
     281                 :      25320 :                 raid_bdev_io_complete(raid_io, raid_io->base_bdev_io_status);
     282                 :      25320 :                 return true;
     283                 :            :         } else {
     284                 :     186124 :                 return false;
     285                 :            :         }
     286                 :            : }
     287                 :            : 
     288                 :            : struct raid_base_bdev_info *
     289                 :        240 : raid_bdev_channel_get_base_info(struct raid_bdev_io_channel *raid_ch, struct spdk_bdev *base_bdev)
     290                 :            : {
     291                 :        240 :         return base_bdev->ctxt;
     292                 :            : }

Generated by: LCOV version 1.14