LCOV - code coverage report
Current view: top level - spdk/test/unit/lib/bdev/raid/concat.c - concat_ut.c (source / functions) Hit Total Coverage
Test: Combined Lines: 220 236 93.2 %
Date: 2024-07-13 04:47:26 Functions: 21 27 77.8 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 68 84 81.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                 :            : #include "spdk_internal/cunit.h"
       8                 :            : #include "spdk/env.h"
       9                 :            : 
      10                 :            : #include "common/lib/ut_multithread.c"
      11                 :            : 
      12                 :            : #include "bdev/raid/concat.c"
      13                 :            : #include "../common.c"
      14                 :            : 
      15         [ #  # ]:          0 : DEFINE_STUB(spdk_bdev_readv_blocks_with_md, int, (struct spdk_bdev_desc *desc,
      16                 :            :                 struct spdk_io_channel *ch,
      17                 :            :                 struct iovec *iov, int iovcnt, void *md,
      18                 :            :                 uint64_t offset_blocks, uint64_t num_blocks,
      19                 :            :                 spdk_bdev_io_completion_cb cb, void *cb_arg), 0);
      20         [ #  # ]:          0 : DEFINE_STUB(spdk_bdev_writev_blocks_with_md, int, (struct spdk_bdev_desc *desc,
      21                 :            :                 struct spdk_io_channel *ch,
      22                 :            :                 struct iovec *iov, int iovcnt, void *md,
      23                 :            :                 uint64_t offset_blocks, uint64_t num_blocks,
      24                 :            :                 spdk_bdev_io_completion_cb cb, void *cb_arg), 0);
      25         [ #  # ]:          0 : DEFINE_STUB(raid_bdev_remap_dix_reftag, int, (void *md_buf, uint64_t num_blocks,
      26                 :            :                 struct spdk_bdev *bdev, uint32_t remapped_offset), -1);
      27                 :            : 
      28                 :            : #define BLOCK_LEN (4096)
      29                 :            : 
      30                 :            : enum CONCAT_IO_TYPE {
      31                 :            :         CONCAT_NONE = 0,
      32                 :            :         CONCAT_WRITEV,
      33                 :            :         CONCAT_READV,
      34                 :            :         CONCAT_FLUSH,
      35                 :            :         CONCAT_UNMAP,
      36                 :            : };
      37                 :            : 
      38                 :            : #define MAX_RECORDS (10)
      39                 :            : /*
      40                 :            :  * Store the information of io requests sent to the underlying bdevs.
      41                 :            :  * For a single null payload request to the concat bdev,
      42                 :            :  * we may send multiple requests to the underling bdevs,
      43                 :            :  * so we store the io request information to arrays.
      44                 :            :  */
      45                 :            : struct req_records {
      46                 :            :         uint64_t offset_blocks[MAX_RECORDS];
      47                 :            :         uint64_t num_blocks[MAX_RECORDS];
      48                 :            :         enum CONCAT_IO_TYPE io_type[MAX_RECORDS];
      49                 :            :         int count;
      50                 :            :         void *md;
      51                 :            : } g_req_records;
      52                 :            : 
      53                 :            : /*
      54                 :            :  * g_succeed is true means the spdk_bdev_readv/writev/unmap/flush_blocks
      55                 :            :  * functions will return 0.
      56                 :            :  * g_succeed is false means the spdk_bdev_readv/writev/unmap/flush_blocks
      57                 :            :  * functions will return -ENOMEM.
      58                 :            :  * We always set it to false before an IO request, then the raid_bdev_queue_io_wait
      59                 :            :  * function will re-submit the request, and the raid_bdev_queue_io_wait function will
      60                 :            :  * set g_succeed to true, then the IO will succeed next time.
      61                 :            :  */
      62                 :            : bool g_succeed;
      63                 :            : 
      64                 :          6 : DEFINE_STUB_V(raid_bdev_module_list_add, (struct raid_bdev_module *raid_module));
      65                 :       2364 : DEFINE_STUB_V(spdk_bdev_free_io, (struct spdk_bdev_io *bdev_io));
      66                 :            : 
      67                 :            : int
      68                 :       1584 : spdk_bdev_readv_blocks_ext(struct spdk_bdev_desc *desc, struct spdk_io_channel *ch,
      69                 :            :                            struct iovec *iov, int iovcnt, uint64_t offset_blocks, uint64_t num_blocks,
      70                 :            :                            spdk_bdev_io_completion_cb cb, void *cb_arg, struct spdk_bdev_ext_io_opts *opts)
      71                 :            : {
      72   [ +  +  +  + ]:       1584 :         if (g_succeed) {
      73                 :        792 :                 int i = g_req_records.count;
      74                 :            : 
      75                 :        792 :                 g_req_records.offset_blocks[i] = offset_blocks;
      76                 :        792 :                 g_req_records.num_blocks[i] = num_blocks;
      77                 :        792 :                 g_req_records.io_type[i] = CONCAT_READV;
      78                 :        792 :                 g_req_records.count++;
      79                 :        792 :                 cb(NULL, true, cb_arg);
      80                 :        792 :                 g_req_records.md = opts->metadata;
      81                 :        792 :                 return 0;
      82                 :            :         } else {
      83                 :        792 :                 return -ENOMEM;
      84                 :            :         }
      85                 :            : }
      86                 :            : 
      87                 :            : int
      88                 :       1584 : spdk_bdev_writev_blocks_ext(struct spdk_bdev_desc *desc, struct spdk_io_channel *ch,
      89                 :            :                             struct iovec *iov, int iovcnt, uint64_t offset_blocks, uint64_t num_blocks,
      90                 :            :                             spdk_bdev_io_completion_cb cb, void *cb_arg, struct spdk_bdev_ext_io_opts *opts)
      91                 :            : {
      92   [ +  +  +  + ]:       1584 :         if (g_succeed) {
      93                 :        792 :                 int i = g_req_records.count;
      94                 :            : 
      95                 :        792 :                 g_req_records.offset_blocks[i] = offset_blocks;
      96                 :        792 :                 g_req_records.num_blocks[i] = num_blocks;
      97                 :        792 :                 g_req_records.io_type[i] = CONCAT_WRITEV;
      98                 :        792 :                 g_req_records.count++;
      99                 :        792 :                 cb(NULL, true, cb_arg);
     100                 :        792 :                 g_req_records.md = opts->metadata;
     101                 :        792 :                 return 0;
     102                 :            :         } else {
     103                 :        792 :                 return -ENOMEM;
     104                 :            :         }
     105                 :            : }
     106                 :            : 
     107                 :            : int
     108                 :        588 : spdk_bdev_unmap_blocks(struct spdk_bdev_desc *desc, struct spdk_io_channel *ch,
     109                 :            :                        uint64_t offset_blocks, uint64_t num_blocks,
     110                 :            :                        spdk_bdev_io_completion_cb cb, void *cb_arg)
     111                 :            : {
     112   [ +  +  +  + ]:        588 :         if (g_succeed) {
     113                 :        390 :                 int i = g_req_records.count;
     114                 :            : 
     115                 :        390 :                 g_req_records.offset_blocks[i] = offset_blocks;
     116                 :        390 :                 g_req_records.num_blocks[i] = num_blocks;
     117                 :        390 :                 g_req_records.io_type[i] = CONCAT_UNMAP;
     118                 :        390 :                 g_req_records.count++;
     119                 :        390 :                 cb(NULL, true, cb_arg);
     120                 :        390 :                 return 0;
     121                 :            :         } else {
     122                 :        198 :                 return -ENOMEM;
     123                 :            :         }
     124                 :            : }
     125                 :            : 
     126                 :            : int
     127                 :        588 : spdk_bdev_flush_blocks(struct spdk_bdev_desc *desc, struct spdk_io_channel *ch,
     128                 :            :                        uint64_t offset_blocks, uint64_t num_blocks,
     129                 :            :                        spdk_bdev_io_completion_cb cb, void *cb_arg)
     130                 :            : {
     131   [ +  +  +  + ]:        588 :         if (g_succeed) {
     132                 :        390 :                 int i = g_req_records.count;
     133                 :            : 
     134                 :        390 :                 g_req_records.offset_blocks[i] = offset_blocks;
     135                 :        390 :                 g_req_records.num_blocks[i] = num_blocks;
     136                 :        390 :                 g_req_records.io_type[i] = CONCAT_FLUSH;
     137                 :        390 :                 g_req_records.count++;
     138                 :        390 :                 cb(NULL, true, cb_arg);
     139                 :        390 :                 return 0;
     140                 :            :         } else {
     141                 :        198 :                 return -ENOMEM;
     142                 :            :         }
     143                 :            : }
     144                 :            : 
     145                 :            : void
     146                 :       1980 : raid_bdev_queue_io_wait(struct raid_bdev_io *raid_io, struct spdk_bdev *bdev,
     147                 :            :                         struct spdk_io_channel *ch, spdk_bdev_io_wait_cb cb_fn)
     148                 :            : {
     149                 :       1980 :         g_succeed = true;
     150                 :       1980 :         cb_fn(raid_io);
     151                 :       1980 : }
     152                 :            : 
     153                 :            : void
     154                 :       1980 : raid_test_bdev_io_complete(struct raid_bdev_io *raid_io, enum spdk_bdev_io_status status)
     155                 :            : {
     156                 :       1980 :         CU_ASSERT(status == SPDK_BDEV_IO_STATUS_SUCCESS);
     157                 :       1980 : }
     158                 :            : 
     159                 :            : static void
     160                 :       1980 : init_globals(void)
     161                 :            : {
     162                 :            :         int i;
     163                 :            : 
     164         [ +  + ]:      21780 :         for (i = 0; i < MAX_RECORDS; i++) {
     165                 :      19800 :                 g_req_records.offset_blocks[i] = 0;
     166                 :      19800 :                 g_req_records.num_blocks[i] = 0;
     167                 :      19800 :                 g_req_records.io_type[i] = CONCAT_NONE;
     168                 :            :         }
     169                 :       1980 :         g_req_records.count = 0;
     170                 :       1980 :         g_succeed = false;
     171                 :       1980 : }
     172                 :            : 
     173                 :            : static int
     174                 :          6 : test_setup(void)
     175                 :            : {
     176                 :          6 :         uint8_t num_base_bdevs_values[] = { 3, 4, 5 };
     177                 :          6 :         uint64_t base_bdev_blockcnt_values[] = { 1, 1024, 1024 * 1024 };
     178                 :          6 :         uint32_t base_bdev_blocklen_values[] = { 512, 4096 };
     179                 :          6 :         uint32_t strip_size_kb_values[] = { 1, 4, 128 };
     180                 :            :         uint8_t *num_base_bdevs;
     181                 :            :         uint64_t *base_bdev_blockcnt;
     182                 :            :         uint32_t *base_bdev_blocklen;
     183                 :            :         uint32_t *strip_size_kb;
     184                 :            :         uint64_t params_count;
     185                 :            :         int rc;
     186                 :            : 
     187                 :          6 :         params_count = SPDK_COUNTOF(num_base_bdevs_values) *
     188                 :            :                        SPDK_COUNTOF(base_bdev_blockcnt_values) *
     189                 :            :                        SPDK_COUNTOF(base_bdev_blocklen_values) *
     190                 :            :                        SPDK_COUNTOF(strip_size_kb_values);
     191                 :          6 :         rc = raid_test_params_alloc(params_count);
     192         [ -  + ]:          6 :         if (rc) {
     193                 :          0 :                 return rc;
     194                 :            :         }
     195                 :            : 
     196         [ +  + ]:         24 :         ARRAY_FOR_EACH(num_base_bdevs_values, num_base_bdevs) {
     197         [ +  + ]:         72 :                 ARRAY_FOR_EACH(base_bdev_blockcnt_values, base_bdev_blockcnt) {
     198         [ +  + ]:        162 :                         ARRAY_FOR_EACH(base_bdev_blocklen_values, base_bdev_blocklen) {
     199         [ +  + ]:        432 :                                 ARRAY_FOR_EACH(strip_size_kb_values, strip_size_kb) {
     200                 :        594 :                                         struct raid_params params = {
     201                 :        324 :                                                 .num_base_bdevs = *num_base_bdevs,
     202                 :        324 :                                                 .base_bdev_blockcnt = *base_bdev_blockcnt,
     203                 :        324 :                                                 .base_bdev_blocklen = *base_bdev_blocklen,
     204         [ -  + ]:        324 :                                                 .strip_size = *strip_size_kb * 1024 / *base_bdev_blocklen,
     205                 :            :                                         };
     206         [ +  + ]:        324 :                                         if (params.strip_size == 0 ||
     207         [ +  + ]:        270 :                                             params.strip_size > params.base_bdev_blockcnt) {
     208                 :        126 :                                                 continue;
     209                 :            :                                         }
     210                 :        198 :                                         raid_test_params_add(&params);
     211                 :            :                                 }
     212                 :            :                         }
     213                 :            :                 }
     214                 :            :         }
     215                 :            : 
     216                 :          6 :         return 0;
     217                 :            : }
     218                 :            : 
     219                 :            : static int
     220                 :          6 : test_cleanup(void)
     221                 :            : {
     222                 :          6 :         raid_test_params_free();
     223                 :          6 :         return 0;
     224                 :            : }
     225                 :            : 
     226                 :            : static struct raid_bdev *
     227                 :       2178 : create_concat(struct raid_params *params)
     228                 :            : {
     229                 :       2178 :         struct raid_bdev *raid_bdev = raid_test_create_raid_bdev(params, &g_concat_module);
     230                 :            : 
     231                 :       2178 :         CU_ASSERT(concat_start(raid_bdev) == 0);
     232                 :       2178 :         return raid_bdev;
     233                 :            : }
     234                 :            : 
     235                 :            : static void
     236                 :       2178 : delete_concat(struct raid_bdev *raid_bdev)
     237                 :            : {
     238                 :       2178 :         concat_stop(raid_bdev);
     239                 :       2178 :         raid_test_delete_raid_bdev(raid_bdev);
     240                 :       2178 : }
     241                 :            : 
     242                 :            : static void
     243                 :          6 : test_concat_start(void)
     244                 :            : {
     245                 :            :         struct raid_bdev *raid_bdev;
     246                 :            :         struct raid_params *params;
     247                 :            :         struct concat_block_range *block_range;
     248                 :            :         uint64_t total_blockcnt;
     249                 :            :         int i;
     250                 :            : 
     251         [ +  + ]:        204 :         RAID_PARAMS_FOR_EACH(params) {
     252                 :        198 :                 raid_bdev = create_concat(params);
     253                 :        198 :                 block_range = raid_bdev->module_private;
     254                 :        198 :                 total_blockcnt = 0;
     255         [ +  + ]:        990 :                 for (i = 0; i < params->num_base_bdevs; i++) {
     256                 :        792 :                         CU_ASSERT(block_range[i].start == total_blockcnt);
     257                 :        792 :                         CU_ASSERT(block_range[i].length == params->base_bdev_blockcnt);
     258                 :        792 :                         total_blockcnt += params->base_bdev_blockcnt;
     259                 :            :                 }
     260                 :        198 :                 delete_concat(raid_bdev);
     261                 :            :         }
     262                 :          6 : }
     263                 :            : 
     264                 :            : static void
     265                 :       1980 : raid_io_cleanup(struct raid_bdev_io *raid_io)
     266                 :            : {
     267         [ +  + ]:       1980 :         if (raid_io->iovs) {
     268                 :       1584 :                 free(raid_io->iovs->iov_base);
     269                 :       1584 :                 free(raid_io->iovs);
     270                 :            :         }
     271                 :            : 
     272                 :       1980 :         free(raid_io);
     273                 :       1980 : }
     274                 :            : 
     275                 :            : static void
     276                 :       1980 : raid_io_initialize(struct raid_bdev_io *raid_io, struct raid_bdev_io_channel *raid_ch,
     277                 :            :                    struct raid_bdev *raid_bdev, uint64_t lba, uint64_t blocks, int16_t iotype)
     278                 :            : {
     279                 :            :         struct iovec *iovs;
     280                 :            :         int iovcnt;
     281                 :            :         void *md_buf;
     282                 :            : 
     283   [ +  +  +  + ]:       1980 :         if (iotype == SPDK_BDEV_IO_TYPE_UNMAP || iotype == SPDK_BDEV_IO_TYPE_FLUSH) {
     284                 :        396 :                 iovs = NULL;
     285                 :        396 :                 iovcnt = 0;
     286                 :        396 :                 md_buf = NULL;
     287                 :            :         } else {
     288                 :       1584 :                 iovcnt = 1;
     289                 :       1584 :                 iovs = calloc(iovcnt, sizeof(struct iovec));
     290         [ -  + ]:       1584 :                 SPDK_CU_ASSERT_FATAL(iovs != NULL);
     291                 :       1584 :                 iovs->iov_len = raid_io->num_blocks * BLOCK_LEN;
     292                 :       1584 :                 iovs->iov_base = calloc(1, iovs->iov_len);
     293         [ -  + ]:       1584 :                 SPDK_CU_ASSERT_FATAL(iovs->iov_base != NULL);
     294                 :       1584 :                 md_buf = (void *)0xAEDFEBAC;
     295                 :            :         }
     296                 :            : 
     297                 :       1980 :         raid_test_bdev_io_init(raid_io, raid_bdev, raid_ch, iotype, lba, blocks, iovs, iovcnt, md_buf);
     298                 :       1980 : }
     299                 :            : 
     300                 :            : static void
     301                 :        396 : submit_and_verify_rw(enum CONCAT_IO_TYPE io_type, struct raid_params *params)
     302                 :            : {
     303                 :            :         struct raid_bdev *raid_bdev;
     304                 :            :         struct raid_bdev_io *raid_io;
     305                 :            :         struct raid_bdev_io_channel *raid_ch;
     306                 :            :         uint64_t lba, blocks;
     307                 :            :         int i;
     308                 :            : 
     309                 :        396 :         lba = 0;
     310                 :        396 :         blocks = 1;
     311         [ +  + ]:       1980 :         for (i = 0; i < params->num_base_bdevs; i++) {
     312                 :       1584 :                 init_globals();
     313                 :       1584 :                 raid_bdev = create_concat(params);
     314                 :       1584 :                 raid_io = calloc(1, sizeof(*raid_io));
     315         [ -  + ]:       1584 :                 SPDK_CU_ASSERT_FATAL(raid_io != NULL);
     316                 :       1584 :                 raid_ch = raid_test_create_io_channel(raid_bdev);
     317                 :            : 
     318   [ +  +  -  -  :       1584 :                 switch (io_type) {
                      - ]
     319                 :        792 :                 case CONCAT_WRITEV:
     320                 :        792 :                         raid_io_initialize(raid_io, raid_ch, raid_bdev, lba, blocks, SPDK_BDEV_IO_TYPE_WRITE);
     321                 :        792 :                         concat_submit_rw_request(raid_io);
     322                 :        792 :                         break;
     323                 :        792 :                 case CONCAT_READV:
     324                 :        792 :                         raid_io_initialize(raid_io, raid_ch, raid_bdev, lba, blocks, SPDK_BDEV_IO_TYPE_READ);
     325                 :        792 :                         concat_submit_rw_request(raid_io);
     326                 :        792 :                         break;
     327                 :          0 :                 case CONCAT_UNMAP:
     328                 :          0 :                         raid_io_initialize(raid_io, raid_ch, raid_bdev, lba, blocks, SPDK_BDEV_IO_TYPE_UNMAP);
     329                 :          0 :                         concat_submit_null_payload_request(raid_io);
     330                 :          0 :                         break;
     331                 :          0 :                 case CONCAT_FLUSH:
     332                 :          0 :                         raid_io_initialize(raid_io, raid_ch, raid_bdev, lba, blocks, SPDK_BDEV_IO_TYPE_FLUSH);
     333                 :          0 :                         concat_submit_null_payload_request(raid_io);
     334                 :          0 :                         break;
     335                 :          0 :                 default:
     336                 :          0 :                         CU_ASSERT(false);
     337                 :            :                 }
     338                 :            : 
     339                 :            :                 /*
     340                 :            :                  * We submit request to the first lba of each underlying device,
     341                 :            :                  * so the offset of the underling device should always be 0.
     342                 :            :                  */
     343                 :       1584 :                 CU_ASSERT(g_req_records.offset_blocks[0] == 0);
     344                 :       1584 :                 CU_ASSERT(g_req_records.num_blocks[0] == blocks);
     345                 :       1584 :                 CU_ASSERT(g_req_records.io_type[0] == io_type);
     346                 :       1584 :                 CU_ASSERT(g_req_records.count == 1);
     347                 :       1584 :                 CU_ASSERT(g_req_records.md == (void *)0xAEDFEBAC);
     348                 :       1584 :                 raid_io_cleanup(raid_io);
     349                 :       1584 :                 raid_test_destroy_io_channel(raid_ch);
     350                 :       1584 :                 delete_concat(raid_bdev);
     351                 :       1584 :                 lba += params->base_bdev_blockcnt;
     352                 :            :         }
     353                 :        396 : }
     354                 :            : 
     355                 :            : static void
     356                 :          6 : test_concat_rw(void)
     357                 :            : {
     358                 :            :         struct raid_params *params;
     359                 :          6 :         enum CONCAT_IO_TYPE io_type_list[] = {CONCAT_WRITEV, CONCAT_READV};
     360                 :            :         enum CONCAT_IO_TYPE io_type;
     361                 :            :         int i;
     362                 :            : 
     363         [ +  + ]:        204 :         RAID_PARAMS_FOR_EACH(params) {
     364         [ +  + ]:        594 :                 for (i = 0; i < 2; i ++) {
     365                 :        396 :                         io_type = io_type_list[i];
     366                 :        396 :                         submit_and_verify_rw(io_type, params);
     367                 :            :                 }
     368                 :            :         }
     369                 :          6 : }
     370                 :            : 
     371                 :            : static void
     372                 :        396 : submit_and_verify_null_payload(enum CONCAT_IO_TYPE io_type, struct raid_params *params)
     373                 :            : {
     374                 :            :         struct raid_bdev *raid_bdev;
     375                 :            :         struct raid_bdev_io *raid_io;
     376                 :            :         struct raid_bdev_io_channel *raid_ch;
     377                 :            :         uint64_t lba, blocks;
     378                 :            : 
     379                 :            :         /*
     380                 :            :          * In this unittest, all base bdevs have the same blockcnt.
     381                 :            :          * If the base_bdev_blockcnt > 1, the request will start from
     382                 :            :          * the second bdev, and across two bdevs.
     383                 :            :          * If the base_bdev_blockcnt == 1, the request will start from
     384                 :            :          * the third bdev. In this case, if there are only 3 bdevs,
     385                 :            :          * we can not set blocks to base_bdev_blockcnt + 1 because the request
     386                 :            :          * will be beyond the end of the last bdev, so we set the blocks to 1
     387                 :            :          */
     388                 :        396 :         lba = params->base_bdev_blockcnt + 1;
     389   [ +  +  +  + ]:        396 :         if (params->base_bdev_blockcnt == 1 && params->num_base_bdevs == 3) {
     390                 :         12 :                 blocks = 1;
     391                 :            :         } else {
     392                 :        384 :                 blocks = params->base_bdev_blockcnt + 1;
     393                 :            :         }
     394                 :        396 :         init_globals();
     395                 :        396 :         raid_bdev = create_concat(params);
     396                 :        396 :         raid_io = calloc(1, sizeof(*raid_io));
     397         [ -  + ]:        396 :         SPDK_CU_ASSERT_FATAL(raid_io != NULL);
     398                 :        396 :         raid_ch = raid_test_create_io_channel(raid_bdev);
     399                 :            : 
     400      [ +  +  - ]:        396 :         switch (io_type) {
     401                 :        198 :         case CONCAT_UNMAP:
     402                 :        198 :                 raid_io_initialize(raid_io, raid_ch, raid_bdev, lba, blocks, SPDK_BDEV_IO_TYPE_UNMAP);
     403                 :        198 :                 concat_submit_null_payload_request(raid_io);
     404                 :        198 :                 break;
     405                 :        198 :         case CONCAT_FLUSH:
     406                 :        198 :                 raid_io_initialize(raid_io, raid_ch, raid_bdev, lba, blocks, SPDK_BDEV_IO_TYPE_FLUSH);
     407                 :        198 :                 concat_submit_null_payload_request(raid_io);
     408                 :        198 :                 break;
     409                 :          0 :         default:
     410                 :          0 :                 CU_ASSERT(false);
     411                 :            :         }
     412                 :            : 
     413         [ +  + ]:        396 :         if (params->base_bdev_blockcnt == 1) {
     414         [ +  + ]:         36 :                 if (params->num_base_bdevs == 3) {
     415                 :         12 :                         CU_ASSERT(g_req_records.count == 1);
     416                 :         12 :                         CU_ASSERT(g_req_records.offset_blocks[0] == 0);
     417                 :         12 :                         CU_ASSERT(g_req_records.num_blocks[0] == 1);
     418                 :            :                 } else {
     419                 :         24 :                         CU_ASSERT(g_req_records.count == 2);
     420                 :         24 :                         CU_ASSERT(g_req_records.offset_blocks[0] == 0);
     421                 :         24 :                         CU_ASSERT(g_req_records.num_blocks[0] == 1);
     422                 :         24 :                         CU_ASSERT(g_req_records.io_type[0] == io_type);
     423                 :         24 :                         CU_ASSERT(g_req_records.offset_blocks[1] == 0);
     424                 :         24 :                         CU_ASSERT(g_req_records.num_blocks[1] == 1);
     425                 :         24 :                         CU_ASSERT(g_req_records.io_type[1] == io_type);
     426                 :            :                 }
     427                 :            :         } else {
     428                 :        360 :                 CU_ASSERT(g_req_records.count == 2);
     429                 :        360 :                 CU_ASSERT(g_req_records.offset_blocks[0] == 1);
     430                 :        360 :                 CU_ASSERT(g_req_records.num_blocks[0] == params->base_bdev_blockcnt - 1);
     431                 :        360 :                 CU_ASSERT(g_req_records.io_type[0] == io_type);
     432                 :        360 :                 CU_ASSERT(g_req_records.offset_blocks[1] == 0);
     433                 :        360 :                 CU_ASSERT(g_req_records.num_blocks[1] == 2);
     434                 :        360 :                 CU_ASSERT(g_req_records.io_type[1] == io_type);
     435                 :            :         }
     436                 :        396 :         raid_io_cleanup(raid_io);
     437                 :        396 :         raid_test_destroy_io_channel(raid_ch);
     438                 :        396 :         delete_concat(raid_bdev);
     439                 :        396 : }
     440                 :            : 
     441                 :            : static void
     442                 :          6 : test_concat_null_payload(void)
     443                 :            : {
     444                 :            :         struct raid_params *params;
     445                 :          6 :         enum CONCAT_IO_TYPE io_type_list[] = {CONCAT_FLUSH, CONCAT_UNMAP};
     446                 :            :         enum CONCAT_IO_TYPE io_type;
     447                 :            :         int i;
     448                 :            : 
     449         [ +  + ]:        204 :         RAID_PARAMS_FOR_EACH(params) {
     450         [ +  + ]:        594 :                 for (i = 0; i < 2; i ++) {
     451                 :        396 :                         io_type = io_type_list[i];
     452                 :        396 :                         submit_and_verify_null_payload(io_type, params);
     453                 :            :                 }
     454                 :            :         }
     455                 :          6 : }
     456                 :            : 
     457                 :            : int
     458                 :          6 : main(int argc, char **argv)
     459                 :            : {
     460                 :          6 :         CU_pSuite suite = NULL;
     461                 :            :         unsigned int num_failures;
     462                 :            : 
     463                 :          6 :         CU_initialize_registry();
     464                 :            : 
     465                 :          6 :         suite = CU_add_suite("concat", test_setup, test_cleanup);
     466                 :          6 :         CU_ADD_TEST(suite, test_concat_start);
     467                 :          6 :         CU_ADD_TEST(suite, test_concat_rw);
     468                 :          6 :         CU_ADD_TEST(suite, test_concat_null_payload);
     469                 :            : 
     470                 :          6 :         allocate_threads(1);
     471                 :          6 :         set_thread(0);
     472                 :            : 
     473                 :          6 :         num_failures = spdk_ut_run_tests(argc, argv, NULL);
     474                 :          6 :         CU_cleanup_registry();
     475                 :            : 
     476                 :          6 :         free_threads();
     477                 :            : 
     478                 :          6 :         return num_failures;
     479                 :            : }

Generated by: LCOV version 1.14