LCOV - code coverage report
Current view: top level - spdk/test/unit/lib/scsi/scsi_bdev.c - scsi_bdev_ut.c (source / functions) Hit Total Coverage
Test: Combined Lines: 710 738 96.2 %
Date: 2024-07-15 13:34:03 Functions: 43 79 54.4 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 76 146 52.1 %

           Branch data     Line data    Source code
       1                 :            : /*   SPDX-License-Identifier: BSD-3-Clause
       2                 :            :  *   Copyright (C) 2016 Intel Corporation.
       3                 :            :  *   All rights reserved.
       4                 :            :  */
       5                 :            : 
       6                 :            : #include "spdk/stdinc.h"
       7                 :            : 
       8                 :            : #include "scsi/task.c"
       9                 :            : #include "scsi/scsi_bdev.c"
      10                 :            : #include "common/lib/test_env.c"
      11                 :            : 
      12                 :            : #include "spdk_internal/cunit.h"
      13                 :            : 
      14                 :            : #include "spdk_internal/mock.h"
      15                 :            : #include "spdk/bdev_module.h"
      16                 :            : 
      17                 :          4 : SPDK_LOG_REGISTER_COMPONENT(scsi)
      18                 :            : 
      19                 :            : static uint64_t g_test_bdev_num_blocks;
      20                 :            : 
      21                 :            : TAILQ_HEAD(, spdk_bdev_io) g_bdev_io_queue;
      22                 :            : int g_outstanding_bdev_io_count = 0;
      23                 :            : int g_scsi_cb_called = 0;
      24                 :            : 
      25                 :            : TAILQ_HEAD(, spdk_bdev_io_wait_entry) g_io_wait_queue;
      26                 :            : int g_pending_bdev_io_count  = 0;
      27                 :            : bool g_bdev_io_pool_full = false;
      28                 :            : int g_bdev_io_pool_count = -1;
      29                 :            : 
      30                 :            : bool
      31                 :          0 : spdk_bdev_io_type_supported(struct spdk_bdev *bdev, enum spdk_bdev_io_type io_type)
      32                 :            : {
      33                 :          0 :         abort();
      34                 :            :         return false;
      35                 :            : }
      36                 :            : 
      37                 :         68 : DEFINE_STUB_V(spdk_bdev_free_io, (struct spdk_bdev_io *bdev_io));
      38                 :            : 
      39         [ #  # ]:          0 : DEFINE_STUB(spdk_bdev_get_name, const char *,
      40                 :            :             (const struct spdk_bdev *bdev), "test");
      41                 :            : 
      42         [ -  + ]:         12 : DEFINE_STUB(spdk_bdev_get_block_size, uint32_t,
      43                 :            :             (const struct spdk_bdev *bdev), 512);
      44                 :            : 
      45         [ #  # ]:          0 : DEFINE_STUB(spdk_bdev_get_acwu, uint16_t,
      46                 :            :             (const struct spdk_bdev *bdev), 1);
      47                 :            : 
      48         [ -  + ]:         24 : DEFINE_STUB(spdk_bdev_get_md_size, uint32_t,
      49                 :            :             (const struct spdk_bdev *bdev), 8);
      50                 :            : 
      51   [ -  +  -  + ]:         12 : DEFINE_STUB(spdk_bdev_is_md_interleaved, bool,
      52                 :            :             (const struct spdk_bdev *bdev), false);
      53                 :            : 
      54         [ -  + ]:         60 : DEFINE_STUB(spdk_bdev_get_data_block_size, uint32_t,
      55                 :            :             (const struct spdk_bdev *bdev), 512);
      56                 :            : 
      57         [ #  # ]:          0 : DEFINE_STUB(spdk_bdev_get_physical_block_size, uint32_t,
      58                 :            :             (const struct spdk_bdev *bdev), 4096);
      59                 :            : 
      60                 :            : uint64_t
      61                 :         88 : spdk_bdev_get_num_blocks(const struct spdk_bdev *bdev)
      62                 :            : {
      63                 :         88 :         return g_test_bdev_num_blocks;
      64                 :            : }
      65                 :            : 
      66         [ -  + ]:       1028 : DEFINE_STUB(spdk_bdev_get_product_name, const char *,
      67                 :            :             (const struct spdk_bdev *bdev), "test product");
      68                 :            : 
      69   [ -  +  -  + ]:          8 : DEFINE_STUB(spdk_bdev_has_write_cache, bool,
      70                 :            :             (const struct spdk_bdev *bdev), false);
      71                 :            : 
      72         [ -  + ]:         12 : DEFINE_STUB(spdk_bdev_get_dif_type, enum spdk_dif_type,
      73                 :            :             (const struct spdk_bdev *bdev), SPDK_DIF_DISABLE);
      74                 :            : 
      75   [ -  +  -  + ]:         12 : DEFINE_STUB(spdk_bdev_is_dif_head_of_md, bool,
      76                 :            :             (const struct spdk_bdev *bdev), false);
      77                 :            : 
      78   [ -  +  -  + ]:         24 : DEFINE_STUB(spdk_bdev_is_dif_check_enabled, bool,
      79                 :            :             (const struct spdk_bdev *bdev, enum spdk_dif_check_type check_type), false);
      80                 :            : 
      81         [ #  # ]:          0 : DEFINE_STUB(scsi_pr_out, int, (struct spdk_scsi_task *task,
      82                 :            :                                uint8_t *cdb, uint8_t *data, uint16_t data_len), 0);
      83                 :            : 
      84         [ #  # ]:          0 : DEFINE_STUB(scsi_pr_in, int, (struct spdk_scsi_task *task, uint8_t *cdb,
      85                 :            :                               uint8_t *data, uint16_t data_len), 0);
      86                 :            : 
      87         [ #  # ]:          0 : DEFINE_STUB(scsi2_reserve, int, (struct spdk_scsi_task *task, uint8_t *cdb), 0);
      88         [ #  # ]:          0 : DEFINE_STUB(scsi2_release, int, (struct spdk_scsi_task *task), 0);
      89                 :            : 
      90                 :            : void
      91                 :         64 : scsi_lun_complete_task(struct spdk_scsi_lun *lun, struct spdk_scsi_task *task)
      92                 :            : {
      93                 :         64 :         g_scsi_cb_called++;
      94                 :         64 : }
      95                 :            : 
      96                 :          0 : DEFINE_STUB_V(scsi_lun_complete_reset_task,
      97                 :            :               (struct spdk_scsi_lun *lun, struct spdk_scsi_task *task));
      98                 :            : 
      99         [ #  # ]:          0 : DEFINE_STUB(spdk_scsi_lun_id_int_to_fmt, uint64_t, (int lun_id), 0);
     100                 :            : 
     101         [ #  # ]:          0 : DEFINE_STUB(spdk_scsi_dev_get_first_lun, struct spdk_scsi_lun *,
     102                 :            :             (struct spdk_scsi_dev *dev), NULL);
     103                 :            : 
     104         [ #  # ]:          0 : DEFINE_STUB(spdk_scsi_dev_get_next_lun, struct spdk_scsi_lun *,
     105                 :            :             (struct spdk_scsi_lun *prev_lun), NULL);
     106                 :            : 
     107         [ #  # ]:          0 : DEFINE_STUB(spdk_scsi_sbc_opcode_string, const char *,
     108                 :            :             (uint8_t opcode, uint16_t sa), "UNKNOWN");
     109                 :            : 
     110                 :            : static void
     111                 :       1096 : ut_put_task(struct spdk_scsi_task *task)
     112                 :            : {
     113         [ +  + ]:       1096 :         if (task->alloc_len) {
     114                 :         12 :                 free(task->iov.iov_base);
     115                 :            :         }
     116                 :            : 
     117                 :       1096 :         task->iov.iov_base = NULL;
     118                 :       1096 :         task->iov.iov_len = 0;
     119                 :       1096 :         task->alloc_len = 0;
     120         [ -  + ]:       1096 :         SPDK_CU_ASSERT_FATAL(TAILQ_EMPTY(&g_bdev_io_queue));
     121                 :       1096 : }
     122                 :            : 
     123                 :            : static void
     124                 :       1096 : ut_init_task(struct spdk_scsi_task *task)
     125                 :            : {
     126         [ -  + ]:       1096 :         memset(task, 0xFF, sizeof(*task));
     127                 :       1096 :         task->iov.iov_base = NULL;
     128                 :       1096 :         task->iovs = &task->iov;
     129                 :       1096 :         task->iovcnt = 1;
     130                 :       1096 :         task->alloc_len = 0;
     131                 :       1096 :         task->dxfer_dir = SPDK_SCSI_DIR_NONE;
     132                 :       1096 : }
     133                 :            : 
     134                 :            : void
     135                 :         52 : spdk_bdev_io_get_scsi_status(const struct spdk_bdev_io *bdev_io,
     136                 :            :                              int *sc, int *sk, int *asc, int *ascq)
     137                 :            : {
     138   [ +  -  +  + ]:         52 :         switch (bdev_io->internal.status) {
     139                 :         44 :         case SPDK_BDEV_IO_STATUS_SUCCESS:
     140                 :         44 :                 *sc = SPDK_SCSI_STATUS_GOOD;
     141                 :         44 :                 *sk = SPDK_SCSI_SENSE_NO_SENSE;
     142                 :         44 :                 *asc = SPDK_SCSI_ASC_NO_ADDITIONAL_SENSE;
     143                 :         44 :                 *ascq = SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE;
     144                 :         44 :                 break;
     145                 :          0 :         case SPDK_BDEV_IO_STATUS_MISCOMPARE:
     146                 :          0 :                 *sc = SPDK_SCSI_STATUS_CHECK_CONDITION;
     147                 :          0 :                 *sk = SPDK_SCSI_SENSE_MISCOMPARE;
     148                 :          0 :                 *asc = SPDK_SCSI_ASC_MISCOMPARE_DURING_VERIFY_OPERATION;
     149                 :          0 :                 *ascq = bdev_io->internal.error.scsi.ascq;
     150                 :          0 :                 break;
     151                 :          4 :         case SPDK_BDEV_IO_STATUS_SCSI_ERROR:
     152                 :          4 :                 *sc = bdev_io->internal.error.scsi.sc;
     153                 :          4 :                 *sk = bdev_io->internal.error.scsi.sk;
     154                 :          4 :                 *asc = bdev_io->internal.error.scsi.asc;
     155                 :          4 :                 *ascq = bdev_io->internal.error.scsi.ascq;
     156                 :          4 :                 break;
     157                 :          4 :         default:
     158                 :          4 :                 *sc = SPDK_SCSI_STATUS_CHECK_CONDITION;
     159                 :          4 :                 *sk = SPDK_SCSI_SENSE_ABORTED_COMMAND;
     160                 :          4 :                 *asc = SPDK_SCSI_ASC_NO_ADDITIONAL_SENSE;
     161                 :          4 :                 *ascq = SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE;
     162                 :          4 :                 break;
     163                 :            :         }
     164                 :         52 : }
     165                 :            : 
     166                 :            : void
     167                 :          0 : spdk_bdev_io_get_iovec(struct spdk_bdev_io *bdev_io, struct iovec **iovp, int *iovcntp)
     168                 :            : {
     169                 :          0 :         *iovp = NULL;
     170                 :          0 :         *iovcntp = 0;
     171                 :          0 : }
     172                 :            : 
     173                 :            : static void
     174                 :         76 : ut_bdev_io_complete(void)
     175                 :            : {
     176                 :            :         struct spdk_bdev_io *bdev_io;
     177                 :            : 
     178         [ +  + ]:        156 :         while (!TAILQ_EMPTY(&g_bdev_io_queue)) {
     179                 :         80 :                 bdev_io = TAILQ_FIRST(&g_bdev_io_queue);
     180         [ +  + ]:         80 :                 TAILQ_REMOVE(&g_bdev_io_queue, bdev_io, internal.link);
     181                 :         80 :                 bdev_io->internal.cb(bdev_io, true, bdev_io->internal.caller_ctx);
     182                 :         80 :                 free(bdev_io);
     183                 :         80 :                 g_outstanding_bdev_io_count--;
     184         [ +  + ]:         80 :                 if (g_bdev_io_pool_count != -1) {
     185                 :         24 :                         g_bdev_io_pool_count++;
     186                 :            :                 }
     187                 :            :         }
     188                 :         76 : }
     189                 :            : 
     190                 :            : static void
     191                 :         76 : ut_bdev_io_retry(void)
     192                 :            : {
     193                 :            :         struct spdk_bdev_io_wait_entry *entry;
     194                 :            : 
     195         [ +  + ]:        104 :         while (!TAILQ_EMPTY(&g_io_wait_queue)) {
     196                 :         28 :                 entry = TAILQ_FIRST(&g_io_wait_queue);
     197         [ -  + ]:         28 :                 TAILQ_REMOVE(&g_io_wait_queue, entry, link);
     198                 :         28 :                 g_pending_bdev_io_count--;
     199                 :         28 :                 entry->cb_fn(entry->cb_arg);
     200                 :            :         }
     201                 :         76 : }
     202                 :            : 
     203                 :            : static void
     204                 :         48 : ut_bdev_io_flush(void)
     205                 :            : {
     206   [ +  +  +  + ]:        112 :         while (!TAILQ_EMPTY(&g_bdev_io_queue) || !TAILQ_EMPTY(&g_io_wait_queue)) {
     207                 :         64 :                 ut_bdev_io_complete();
     208                 :         64 :                 ut_bdev_io_retry();
     209                 :            :         }
     210                 :         48 : }
     211                 :            : 
     212                 :            : static int
     213                 :        116 : _spdk_bdev_io_op(spdk_bdev_io_completion_cb cb, void *cb_arg)
     214                 :            : {
     215                 :            :         struct spdk_bdev_io *bdev_io;
     216                 :            : 
     217   [ +  +  +  + ]:        116 :         if (g_bdev_io_pool_full) {
     218                 :         28 :                 g_bdev_io_pool_full = false;
     219                 :         28 :                 return -ENOMEM;
     220         [ +  + ]:         88 :         } else if (g_bdev_io_pool_count == 0) {
     221                 :          8 :                 return -ENOMEM;
     222         [ +  + ]:         80 :         } else if (g_bdev_io_pool_count != -1) {
     223                 :         24 :                 g_bdev_io_pool_count--;
     224                 :            :         }
     225                 :            : 
     226                 :         80 :         bdev_io = calloc(1, sizeof(*bdev_io));
     227         [ -  + ]:         80 :         SPDK_CU_ASSERT_FATAL(bdev_io != NULL);
     228                 :         80 :         bdev_io->internal.status = SPDK_BDEV_IO_STATUS_SUCCESS;
     229                 :         80 :         bdev_io->internal.cb = cb;
     230                 :         80 :         bdev_io->internal.caller_ctx = cb_arg;
     231                 :            : 
     232                 :         80 :         TAILQ_INSERT_TAIL(&g_bdev_io_queue, bdev_io, internal.link);
     233                 :         80 :         g_outstanding_bdev_io_count++;
     234                 :            : 
     235                 :         80 :         return 0;
     236                 :            : }
     237                 :            : 
     238                 :            : int
     239                 :         28 : spdk_bdev_readv_blocks(struct spdk_bdev_desc *desc, struct spdk_io_channel *ch,
     240                 :            :                        struct iovec *iov, int iovcnt,
     241                 :            :                        uint64_t offset_blocks, uint64_t num_blocks,
     242                 :            :                        spdk_bdev_io_completion_cb cb, void *cb_arg)
     243                 :            : {
     244                 :         28 :         return _spdk_bdev_io_op(cb, cb_arg);
     245                 :            : }
     246                 :            : 
     247                 :            : int
     248                 :         12 : spdk_bdev_writev_blocks(struct spdk_bdev_desc *desc, struct spdk_io_channel *ch,
     249                 :            :                         struct iovec *iov, int iovcnt,
     250                 :            :                         uint64_t offset_blocks, uint64_t num_blocks,
     251                 :            :                         spdk_bdev_io_completion_cb cb, void *cb_arg)
     252                 :            : {
     253                 :         12 :         return _spdk_bdev_io_op(cb, cb_arg);
     254                 :            : }
     255                 :            : 
     256                 :            : int
     257                 :          0 : spdk_bdev_comparev_and_writev_blocks(struct spdk_bdev_desc *desc, struct spdk_io_channel *ch,
     258                 :            :                                      struct iovec *compare_iov, int compare_iovcnt,
     259                 :            :                                      struct iovec *write_iov, int write_iovcnt,
     260                 :            :                                      uint64_t offset_blocks, uint64_t num_blocks,
     261                 :            :                                      spdk_bdev_io_completion_cb cb, void *cb_arg)
     262                 :            : {
     263                 :          0 :         return _spdk_bdev_io_op(cb, cb_arg);
     264                 :            : }
     265                 :            : 
     266                 :            : int
     267                 :         64 : spdk_bdev_unmap_blocks(struct spdk_bdev_desc *desc, struct spdk_io_channel *ch,
     268                 :            :                        uint64_t offset_blocks, uint64_t num_blocks,
     269                 :            :                        spdk_bdev_io_completion_cb cb, void *cb_arg)
     270                 :            : {
     271                 :         64 :         return _spdk_bdev_io_op(cb, cb_arg);
     272                 :            : }
     273                 :            : 
     274                 :            : int
     275                 :          0 : spdk_bdev_reset(struct spdk_bdev_desc *desc, struct spdk_io_channel *ch,
     276                 :            :                 spdk_bdev_io_completion_cb cb, void *cb_arg)
     277                 :            : {
     278                 :          0 :         return _spdk_bdev_io_op(cb, cb_arg);
     279                 :            : }
     280                 :            : 
     281                 :            : int
     282                 :         12 : spdk_bdev_flush_blocks(struct spdk_bdev_desc *desc, struct spdk_io_channel *ch,
     283                 :            :                        uint64_t offset_blocks, uint64_t num_blocks,
     284                 :            :                        spdk_bdev_io_completion_cb cb, void *cb_arg)
     285                 :            : {
     286                 :         12 :         return _spdk_bdev_io_op(cb, cb_arg);
     287                 :            : }
     288                 :            : 
     289                 :            : int
     290                 :         28 : spdk_bdev_queue_io_wait(struct spdk_bdev *bdev, struct spdk_io_channel *ch,
     291                 :            :                         struct spdk_bdev_io_wait_entry *entry)
     292                 :            : {
     293                 :         28 :         TAILQ_INSERT_TAIL(&g_io_wait_queue, entry, link);
     294                 :         28 :         g_pending_bdev_io_count++;
     295                 :         28 :         return 0;
     296                 :            : }
     297                 :            : 
     298                 :            : int
     299                 :         12 : spdk_dif_ctx_init(struct spdk_dif_ctx *ctx, uint32_t block_size, uint32_t md_size,
     300                 :            :                   bool md_interleave, bool dif_loc, enum spdk_dif_type dif_type, uint32_t dif_flags,
     301                 :            :                   uint32_t init_ref_tag, uint16_t apptag_mask, uint16_t app_tag,
     302                 :            :                   uint32_t data_offset, uint64_t guard_seed, struct spdk_dif_ctx_init_ext_opts *opts)
     303                 :            : {
     304                 :         12 :         ctx->dif_pi_format = opts->dif_pi_format;
     305                 :         12 :         ctx->init_ref_tag = init_ref_tag;
     306                 :         12 :         ctx->ref_tag_offset = data_offset / 512;
     307                 :         12 :         return 0;
     308                 :            : }
     309                 :            : 
     310                 :            : /*
     311                 :            :  * This test specifically tests a mode select 6 command from the
     312                 :            :  *  Windows SCSI compliance test that caused SPDK to crash.
     313                 :            :  */
     314                 :            : static void
     315                 :          4 : mode_select_6_test(void)
     316                 :            : {
     317                 :          4 :         struct spdk_bdev bdev;
     318                 :          4 :         struct spdk_scsi_task task;
     319                 :          4 :         struct spdk_scsi_lun lun;
     320                 :          4 :         struct spdk_scsi_dev dev;
     321                 :          4 :         char cdb[16];
     322                 :          4 :         char data[24];
     323                 :            :         int rc;
     324                 :            : 
     325                 :          4 :         ut_init_task(&task);
     326                 :            : 
     327                 :          4 :         cdb[0] = 0x15;
     328                 :          4 :         cdb[1] = 0x11;
     329                 :          4 :         cdb[2] = 0x00;
     330                 :          4 :         cdb[3] = 0x00;
     331                 :          4 :         cdb[4] = 0x18;
     332                 :          4 :         cdb[5] = 0x00;
     333                 :          4 :         task.cdb = cdb;
     334                 :            : 
     335         [ -  + ]:          4 :         snprintf(&dev.name[0], sizeof(dev.name), "spdk_iscsi_translation_test");
     336                 :          4 :         lun.bdev = &bdev;
     337                 :          4 :         lun.dev = &dev;
     338                 :          4 :         task.lun = &lun;
     339                 :            : 
     340         [ -  + ]:          4 :         memset(data, 0, sizeof(data));
     341                 :          4 :         data[4] = 0x08;
     342                 :          4 :         data[5] = 0x02;
     343                 :          4 :         spdk_scsi_task_set_data(&task, data, sizeof(data));
     344                 :            : 
     345                 :          4 :         rc = bdev_scsi_execute(&task);
     346                 :            : 
     347                 :          4 :         CU_ASSERT_EQUAL(rc, 0);
     348                 :            : 
     349                 :          4 :         ut_put_task(&task);
     350                 :          4 : }
     351                 :            : 
     352                 :            : /*
     353                 :            :  * This test specifically tests a mode select 6 command which
     354                 :            :  *  contains no mode pages.
     355                 :            :  */
     356                 :            : static void
     357                 :          4 : mode_select_6_test2(void)
     358                 :            : {
     359                 :          4 :         struct spdk_bdev bdev;
     360                 :          4 :         struct spdk_scsi_task task;
     361                 :          4 :         struct spdk_scsi_lun lun;
     362                 :          4 :         struct spdk_scsi_dev dev;
     363                 :          4 :         char cdb[16];
     364                 :            :         int rc;
     365                 :            : 
     366                 :          4 :         ut_init_task(&task);
     367                 :            : 
     368                 :          4 :         cdb[0] = 0x15;
     369                 :          4 :         cdb[1] = 0x00;
     370                 :          4 :         cdb[2] = 0x00;
     371                 :          4 :         cdb[3] = 0x00;
     372                 :          4 :         cdb[4] = 0x00;
     373                 :          4 :         cdb[5] = 0x00;
     374                 :          4 :         task.cdb = cdb;
     375                 :            : 
     376         [ -  + ]:          4 :         snprintf(&dev.name[0], sizeof(dev.name), "spdk_iscsi_translation_test");
     377                 :          4 :         lun.bdev = &bdev;
     378                 :          4 :         lun.dev = &dev;
     379                 :          4 :         task.lun = &lun;
     380                 :            : 
     381                 :          4 :         rc = bdev_scsi_execute(&task);
     382                 :            : 
     383                 :          4 :         CU_ASSERT_EQUAL(rc, 0);
     384                 :            : 
     385                 :          4 :         ut_put_task(&task);
     386                 :          4 : }
     387                 :            : 
     388                 :            : /*
     389                 :            :  * This test specifically tests a mode sense 6 command which
     390                 :            :  *  return all subpage 00h mode pages.
     391                 :            :  */
     392                 :            : static void
     393                 :          4 : mode_sense_6_test(void)
     394                 :            : {
     395                 :          4 :         struct spdk_bdev bdev;
     396                 :          4 :         struct spdk_scsi_task task;
     397                 :          4 :         struct spdk_scsi_lun lun;
     398                 :          4 :         struct spdk_scsi_dev dev;
     399                 :          4 :         char cdb[12];
     400                 :            :         unsigned char *data;
     401                 :            :         int rc;
     402                 :          4 :         unsigned char mode_data_len = 0;
     403                 :          4 :         unsigned char medium_type = 0;
     404                 :          4 :         unsigned char dev_specific_param = 0;
     405                 :          4 :         unsigned char blk_descriptor_len = 0;
     406                 :            : 
     407                 :          4 :         memset(&bdev, 0, sizeof(struct spdk_bdev));
     408                 :          4 :         ut_init_task(&task);
     409                 :          4 :         memset(cdb, 0, sizeof(cdb));
     410                 :            : 
     411                 :          4 :         cdb[0] = 0x1A;
     412                 :          4 :         cdb[2] = 0x3F;
     413                 :          4 :         cdb[4] = 0xFF;
     414                 :          4 :         task.cdb = cdb;
     415                 :            : 
     416                 :          4 :         snprintf(&dev.name[0], sizeof(dev.name), "spdk_iscsi_translation_test");
     417                 :          4 :         lun.bdev = &bdev;
     418                 :          4 :         lun.dev = &dev;
     419                 :          4 :         task.lun = &lun;
     420                 :            : 
     421                 :          4 :         rc = bdev_scsi_execute(&task);
     422         [ -  + ]:          4 :         SPDK_CU_ASSERT_FATAL(rc == 0);
     423                 :            : 
     424                 :          4 :         data = task.iovs[0].iov_base;
     425                 :          4 :         mode_data_len = data[0];
     426                 :          4 :         medium_type = data[1];
     427                 :          4 :         dev_specific_param = data[2];
     428                 :          4 :         blk_descriptor_len = data[3];
     429                 :            : 
     430                 :          4 :         CU_ASSERT(mode_data_len >= 11);
     431                 :          4 :         CU_ASSERT_EQUAL(medium_type, 0);
     432                 :          4 :         CU_ASSERT_EQUAL(dev_specific_param, 0);
     433                 :          4 :         CU_ASSERT_EQUAL(blk_descriptor_len, 8);
     434                 :            : 
     435                 :          4 :         ut_put_task(&task);
     436                 :          4 : }
     437                 :            : 
     438                 :            : /*
     439                 :            :  * This test specifically tests a mode sense 10 command which
     440                 :            :  *  return all subpage 00h mode pages.
     441                 :            :  */
     442                 :            : static void
     443                 :          4 : mode_sense_10_test(void)
     444                 :            : {
     445                 :          4 :         struct spdk_bdev bdev;
     446                 :          4 :         struct spdk_scsi_task task;
     447                 :          4 :         struct spdk_scsi_lun lun;
     448                 :          4 :         struct spdk_scsi_dev dev;
     449                 :          4 :         char cdb[12];
     450                 :            :         unsigned char *data;
     451                 :            :         int rc;
     452                 :          4 :         unsigned short mode_data_len = 0;
     453                 :          4 :         unsigned char medium_type = 0;
     454                 :          4 :         unsigned char dev_specific_param = 0;
     455                 :          4 :         unsigned short blk_descriptor_len = 0;
     456                 :            : 
     457                 :          4 :         memset(&bdev, 0, sizeof(struct spdk_bdev));
     458                 :          4 :         ut_init_task(&task);
     459                 :          4 :         memset(cdb, 0, sizeof(cdb));
     460                 :          4 :         cdb[0] = 0x5A;
     461                 :          4 :         cdb[2] = 0x3F;
     462                 :          4 :         cdb[8] = 0xFF;
     463                 :          4 :         task.cdb = cdb;
     464                 :            : 
     465                 :          4 :         snprintf(&dev.name[0], sizeof(dev.name), "spdk_iscsi_translation_test");
     466                 :          4 :         lun.bdev = &bdev;
     467                 :          4 :         lun.dev = &dev;
     468                 :          4 :         task.lun = &lun;
     469                 :            : 
     470                 :          4 :         rc = bdev_scsi_execute(&task);
     471         [ -  + ]:          4 :         SPDK_CU_ASSERT_FATAL(rc == 0);
     472                 :            : 
     473                 :          4 :         data = task.iovs[0].iov_base;
     474         [ -  + ]:          4 :         mode_data_len = ((data[0] << 8) + data[1]);
     475                 :          4 :         medium_type = data[2];
     476                 :          4 :         dev_specific_param = data[3];
     477         [ -  + ]:          4 :         blk_descriptor_len = ((data[6] << 8) + data[7]);
     478                 :            : 
     479                 :          4 :         CU_ASSERT(mode_data_len >= 14);
     480                 :          4 :         CU_ASSERT_EQUAL(medium_type, 0);
     481                 :          4 :         CU_ASSERT_EQUAL(dev_specific_param, 0);
     482                 :          4 :         CU_ASSERT_EQUAL(blk_descriptor_len, 8);
     483                 :            : 
     484                 :          4 :         ut_put_task(&task);
     485                 :          4 : }
     486                 :            : 
     487                 :            : /*
     488                 :            :  * This test specifically tests a scsi inquiry command from the
     489                 :            :  *  Windows SCSI compliance test that failed to return the
     490                 :            :  *  expected SCSI error sense code.
     491                 :            :  */
     492                 :            : static void
     493                 :          4 : inquiry_evpd_test(void)
     494                 :            : {
     495                 :          4 :         struct spdk_bdev bdev;
     496                 :          4 :         struct spdk_scsi_task task;
     497                 :          4 :         struct spdk_scsi_lun lun;
     498                 :          4 :         struct spdk_scsi_dev dev;
     499                 :          4 :         char cdb[6];
     500                 :            :         int rc;
     501                 :            : 
     502                 :          4 :         ut_init_task(&task);
     503                 :            : 
     504                 :          4 :         cdb[0] = 0x12;
     505                 :          4 :         cdb[1] = 0x00;  /* EVPD = 0 */
     506                 :          4 :         cdb[2] = 0xff;  /* PageCode non-zero */
     507                 :          4 :         cdb[3] = 0x00;
     508                 :          4 :         cdb[4] = 0xff;
     509                 :          4 :         cdb[5] = 0x00;
     510                 :          4 :         task.cdb = cdb;
     511                 :            : 
     512                 :          4 :         snprintf(&dev.name[0], sizeof(dev.name), "spdk_iscsi_translation_test");
     513                 :          4 :         lun.bdev = &bdev;
     514                 :          4 :         lun.dev = &dev;
     515                 :          4 :         task.lun = &lun;
     516                 :            : 
     517                 :          4 :         rc = bdev_scsi_execute(&task);
     518         [ -  + ]:          4 :         SPDK_CU_ASSERT_FATAL(rc == 0);
     519                 :            : 
     520                 :          4 :         CU_ASSERT_EQUAL(task.status, SPDK_SCSI_STATUS_CHECK_CONDITION);
     521                 :          4 :         CU_ASSERT_EQUAL(task.sense_data[2] & 0xf, SPDK_SCSI_SENSE_ILLEGAL_REQUEST);
     522                 :          4 :         CU_ASSERT_EQUAL(task.sense_data[12], 0x24);
     523                 :          4 :         CU_ASSERT_EQUAL(task.sense_data[13], 0x0);
     524                 :            : 
     525                 :          4 :         ut_put_task(&task);
     526                 :          4 : }
     527                 :            : 
     528                 :            : /*
     529                 :            :  * This test is to verify specific return data for a standard scsi inquiry
     530                 :            :  *  command: Version
     531                 :            :  */
     532                 :            : static void
     533                 :          4 : inquiry_standard_test(void)
     534                 :            : {
     535                 :          4 :         struct spdk_bdev bdev = { .blocklen = 512 };
     536                 :          4 :         struct spdk_scsi_task task;
     537                 :          4 :         struct spdk_scsi_lun lun;
     538                 :          4 :         struct spdk_scsi_dev dev;
     539                 :          4 :         char cdb[6];
     540                 :            :         char *data;
     541                 :            :         struct spdk_scsi_cdb_inquiry_data *inq_data;
     542                 :            :         int rc;
     543                 :            : 
     544                 :          4 :         ut_init_task(&task);
     545                 :            : 
     546                 :          4 :         cdb[0] = 0x12;
     547                 :          4 :         cdb[1] = 0x00;  /* EVPD = 0 */
     548                 :          4 :         cdb[2] = 0x00;  /* PageCode zero - requesting standard inquiry */
     549                 :          4 :         cdb[3] = 0x00;
     550                 :          4 :         cdb[4] = 0xff;  /* Indicate data size used by conformance test */
     551                 :          4 :         cdb[5] = 0x00;
     552                 :          4 :         task.cdb = cdb;
     553                 :            : 
     554         [ -  + ]:          4 :         snprintf(&dev.name[0], sizeof(dev.name), "spdk_iscsi_translation_test");
     555                 :          4 :         lun.bdev = &bdev;
     556                 :          4 :         lun.dev = &dev;
     557                 :          4 :         task.lun = &lun;
     558                 :            : 
     559                 :          4 :         rc = bdev_scsi_execute(&task);
     560                 :            : 
     561                 :          4 :         data = task.iovs[0].iov_base;
     562                 :          4 :         inq_data = (struct spdk_scsi_cdb_inquiry_data *)&data[0];
     563                 :            : 
     564                 :          4 :         CU_ASSERT_EQUAL(inq_data->version, SPDK_SPC_VERSION_SPC3);
     565                 :          4 :         CU_ASSERT_EQUAL(rc, 0);
     566                 :            : 
     567                 :          4 :         ut_put_task(&task);
     568                 :          4 : }
     569                 :            : 
     570                 :            : static void
     571                 :       1024 : _inquiry_overflow_test(uint8_t alloc_len)
     572                 :            : {
     573                 :       1024 :         struct spdk_bdev bdev = { .blocklen = 512 };
     574                 :       1024 :         struct spdk_scsi_task task;
     575                 :       1024 :         struct spdk_scsi_lun lun;
     576                 :       1024 :         struct spdk_scsi_dev dev;
     577                 :       1024 :         uint8_t cdb[6];
     578                 :            :         int rc;
     579                 :            :         /* expects a 4K internal data buffer */
     580                 :       1024 :         char data[4096], data_compare[4096];
     581                 :            : 
     582                 :       1024 :         ut_init_task(&task);
     583                 :            : 
     584                 :       1024 :         cdb[0] = 0x12;
     585                 :       1024 :         cdb[1] = 0x00;          /* EVPD = 0 */
     586                 :       1024 :         cdb[2] = 0x00;          /* PageCode zero - requesting standard inquiry */
     587                 :       1024 :         cdb[3] = 0x00;
     588                 :       1024 :         cdb[4] = alloc_len;     /* Indicate data size used by conformance test */
     589                 :       1024 :         cdb[5] = 0x00;
     590                 :       1024 :         task.cdb = cdb;
     591                 :            : 
     592                 :       1024 :         snprintf(&dev.name[0], sizeof(dev.name), "spdk_iscsi_translation_test");
     593                 :       1024 :         lun.bdev = &bdev;
     594                 :       1024 :         lun.dev = &dev;
     595                 :       1024 :         task.lun = &lun;
     596                 :            : 
     597                 :       1024 :         memset(data, 0, sizeof(data));
     598                 :       1024 :         memset(data_compare, 0, sizeof(data_compare));
     599                 :            : 
     600                 :       1024 :         spdk_scsi_task_set_data(&task, data, sizeof(data));
     601                 :            : 
     602                 :       1024 :         rc = bdev_scsi_execute(&task);
     603         [ -  + ]:       1024 :         SPDK_CU_ASSERT_FATAL(rc == 0);
     604                 :            : 
     605   [ -  +  -  + ]:       1024 :         CU_ASSERT_EQUAL(memcmp(data + alloc_len, data_compare + alloc_len, sizeof(data) - alloc_len), 0);
     606                 :       1024 :         CU_ASSERT(task.data_transferred <= alloc_len);
     607                 :            : 
     608                 :       1024 :         ut_put_task(&task);
     609                 :       1024 : }
     610                 :            : 
     611                 :            : static void
     612                 :          4 : inquiry_overflow_test(void)
     613                 :            : {
     614                 :            :         int i;
     615                 :            : 
     616         [ +  + ]:       1028 :         for (i = 0; i < 256; i++) {
     617                 :       1024 :                 _inquiry_overflow_test(i);
     618                 :            :         }
     619                 :          4 : }
     620                 :            : 
     621                 :            : static void
     622                 :          4 : scsi_name_padding_test(void)
     623                 :            : {
     624                 :          4 :         char name[SPDK_SCSI_DEV_MAX_NAME + 1];
     625                 :          4 :         char buf[SPDK_SCSI_DEV_MAX_NAME + 1];
     626                 :            :         int written, i;
     627                 :            : 
     628                 :            :         /* case 1 */
     629         [ -  + ]:          4 :         memset(name, '\0', sizeof(name));
     630         [ -  + ]:          4 :         memset(name, 'x', 251);
     631                 :          4 :         written = bdev_scsi_pad_scsi_name(buf, name);
     632                 :            : 
     633                 :          4 :         CU_ASSERT(written == 252);
     634                 :          4 :         CU_ASSERT(buf[250] == 'x');
     635                 :          4 :         CU_ASSERT(buf[251] == '\0');
     636                 :            : 
     637                 :            :         /* case 2:  */
     638         [ -  + ]:          4 :         memset(name, '\0', sizeof(name));
     639         [ -  + ]:          4 :         memset(name, 'x', 252);
     640                 :          4 :         written = bdev_scsi_pad_scsi_name(buf, name);
     641                 :            : 
     642                 :          4 :         CU_ASSERT(written == 256);
     643                 :          4 :         CU_ASSERT(buf[251] == 'x');
     644         [ +  + ]:         20 :         for (i = 252; i < 256; i++) {
     645                 :         16 :                 CU_ASSERT(buf[i] == '\0');
     646                 :            :         }
     647                 :            : 
     648                 :            :         /* case 3 */
     649         [ -  + ]:          4 :         memset(name, '\0', sizeof(name));
     650         [ -  + ]:          4 :         memset(name, 'x', 255);
     651                 :          4 :         written = bdev_scsi_pad_scsi_name(buf, name);
     652                 :            : 
     653                 :          4 :         CU_ASSERT(written == 256);
     654                 :          4 :         CU_ASSERT(buf[254] == 'x');
     655                 :          4 :         CU_ASSERT(buf[255] == '\0');
     656                 :          4 : }
     657                 :            : 
     658                 :            : /*
     659                 :            :  * This test is to verify specific error translation from bdev to scsi.
     660                 :            :  */
     661                 :            : static void
     662                 :          4 : task_complete_test(void)
     663                 :            : {
     664                 :          4 :         struct spdk_scsi_task task;
     665                 :          4 :         struct spdk_bdev_io bdev_io = {};
     666                 :          4 :         struct spdk_scsi_lun lun;
     667                 :            : 
     668                 :          4 :         ut_init_task(&task);
     669                 :            : 
     670                 :          4 :         TAILQ_INIT(&lun.tasks);
     671                 :          4 :         TAILQ_INSERT_TAIL(&lun.tasks, &task, scsi_link);
     672                 :          4 :         task.lun = &lun;
     673                 :            : 
     674                 :          4 :         bdev_io.internal.status = SPDK_BDEV_IO_STATUS_SUCCESS;
     675                 :          4 :         bdev_scsi_task_complete_cmd(&bdev_io, bdev_io.internal.status, &task);
     676                 :          4 :         CU_ASSERT_EQUAL(task.status, SPDK_SCSI_STATUS_GOOD);
     677                 :          4 :         CU_ASSERT(g_scsi_cb_called == 1);
     678                 :          4 :         g_scsi_cb_called = 0;
     679                 :            : 
     680                 :          4 :         bdev_io.internal.status = SPDK_BDEV_IO_STATUS_SCSI_ERROR;
     681                 :          4 :         bdev_io.internal.error.scsi.sc = SPDK_SCSI_STATUS_CHECK_CONDITION;
     682                 :          4 :         bdev_io.internal.error.scsi.sk = SPDK_SCSI_SENSE_HARDWARE_ERROR;
     683                 :          4 :         bdev_io.internal.error.scsi.asc = SPDK_SCSI_ASC_WARNING;
     684                 :          4 :         bdev_io.internal.error.scsi.ascq = SPDK_SCSI_ASCQ_POWER_LOSS_EXPECTED;
     685                 :          4 :         bdev_scsi_task_complete_cmd(&bdev_io, bdev_io.internal.status, &task);
     686                 :          4 :         CU_ASSERT_EQUAL(task.status, SPDK_SCSI_STATUS_CHECK_CONDITION);
     687                 :          4 :         CU_ASSERT_EQUAL(task.sense_data[2] & 0xf, SPDK_SCSI_SENSE_HARDWARE_ERROR);
     688                 :          4 :         CU_ASSERT_EQUAL(task.sense_data[12], SPDK_SCSI_ASC_WARNING);
     689                 :          4 :         CU_ASSERT_EQUAL(task.sense_data[13], SPDK_SCSI_ASCQ_POWER_LOSS_EXPECTED);
     690                 :          4 :         CU_ASSERT(g_scsi_cb_called == 1);
     691                 :          4 :         g_scsi_cb_called = 0;
     692                 :            : 
     693                 :          4 :         bdev_io.internal.status = SPDK_BDEV_IO_STATUS_FAILED;
     694                 :          4 :         bdev_scsi_task_complete_cmd(&bdev_io, bdev_io.internal.status, &task);
     695                 :          4 :         CU_ASSERT_EQUAL(task.status, SPDK_SCSI_STATUS_CHECK_CONDITION);
     696                 :          4 :         CU_ASSERT_EQUAL(task.sense_data[2] & 0xf, SPDK_SCSI_SENSE_ABORTED_COMMAND);
     697                 :          4 :         CU_ASSERT_EQUAL(task.sense_data[12], SPDK_SCSI_ASC_NO_ADDITIONAL_SENSE);
     698                 :          4 :         CU_ASSERT_EQUAL(task.sense_data[13], SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE);
     699                 :          4 :         CU_ASSERT(g_scsi_cb_called == 1);
     700                 :          4 :         g_scsi_cb_called = 0;
     701                 :            : 
     702                 :          4 :         ut_put_task(&task);
     703                 :          4 : }
     704                 :            : 
     705                 :            : static void
     706                 :          4 : lba_range_test(void)
     707                 :            : {
     708                 :          4 :         struct spdk_bdev bdev = { .blocklen = 512 };
     709                 :          4 :         struct spdk_scsi_lun lun;
     710                 :          4 :         struct spdk_scsi_task task;
     711                 :          4 :         uint8_t cdb[16];
     712                 :            :         int rc;
     713                 :            : 
     714                 :          4 :         lun.bdev = &bdev;
     715                 :            : 
     716                 :          4 :         ut_init_task(&task);
     717                 :          4 :         task.lun = &lun;
     718                 :          4 :         task.lun->bdev_desc = NULL;
     719                 :          4 :         task.lun->io_channel = NULL;
     720                 :          4 :         task.cdb = cdb;
     721                 :            : 
     722                 :          4 :         memset(cdb, 0, sizeof(cdb));
     723                 :          4 :         cdb[0] = 0x88; /* READ (16) */
     724                 :            : 
     725                 :            :         /* Test block device size of 4 blocks */
     726                 :          4 :         g_test_bdev_num_blocks = 4;
     727                 :            : 
     728                 :            :         /* LBA = 0, length = 1 (in range) */
     729                 :          4 :         to_be64(&cdb[2], 0); /* LBA */
     730                 :          4 :         to_be32(&cdb[10], 1); /* transfer length */
     731                 :          4 :         task.transfer_len = 1 * 512;
     732                 :          4 :         task.offset = 0;
     733                 :          4 :         task.length = 1 * 512;
     734                 :          4 :         rc = bdev_scsi_execute(&task);
     735                 :          4 :         CU_ASSERT(rc == SPDK_SCSI_TASK_PENDING);
     736                 :          4 :         CU_ASSERT(task.status == 0xFF);
     737         [ -  + ]:          4 :         SPDK_CU_ASSERT_FATAL(!TAILQ_EMPTY(&g_bdev_io_queue));
     738                 :          4 :         ut_bdev_io_flush();
     739                 :          4 :         CU_ASSERT(task.status == SPDK_SCSI_STATUS_GOOD);
     740                 :          4 :         CU_ASSERT(g_scsi_cb_called == 1);
     741                 :          4 :         g_scsi_cb_called = 0;
     742                 :            : 
     743                 :            :         /* LBA = 4, length = 1 (LBA out of range) */
     744                 :          4 :         to_be64(&cdb[2], 4); /* LBA */
     745                 :          4 :         to_be32(&cdb[10], 1); /* transfer length */
     746                 :          4 :         task.transfer_len = 1 * 512;
     747                 :          4 :         task.offset = 0;
     748                 :          4 :         task.length = 1 * 512;
     749                 :          4 :         rc = bdev_scsi_execute(&task);
     750                 :          4 :         CU_ASSERT(rc == SPDK_SCSI_TASK_COMPLETE);
     751                 :          4 :         CU_ASSERT(task.status == SPDK_SCSI_STATUS_CHECK_CONDITION);
     752                 :          4 :         CU_ASSERT(task.sense_data[12] == SPDK_SCSI_ASC_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE);
     753         [ -  + ]:          4 :         SPDK_CU_ASSERT_FATAL(TAILQ_EMPTY(&g_bdev_io_queue));
     754                 :            : 
     755                 :            :         /* LBA = 0, length = 4 (in range, max valid size) */
     756                 :          4 :         to_be64(&cdb[2], 0); /* LBA */
     757                 :          4 :         to_be32(&cdb[10], 4); /* transfer length */
     758                 :          4 :         task.transfer_len = 4 * 512;
     759                 :          4 :         task.status = 0xFF;
     760                 :          4 :         task.offset = 0;
     761                 :          4 :         task.length = 1 * 512;
     762                 :          4 :         rc = bdev_scsi_execute(&task);
     763                 :          4 :         CU_ASSERT(rc == SPDK_SCSI_TASK_PENDING);
     764                 :          4 :         CU_ASSERT(task.status == 0xFF);
     765         [ -  + ]:          4 :         SPDK_CU_ASSERT_FATAL(!TAILQ_EMPTY(&g_bdev_io_queue));
     766                 :          4 :         ut_bdev_io_flush();
     767                 :          4 :         CU_ASSERT(task.status == SPDK_SCSI_STATUS_GOOD);
     768                 :          4 :         CU_ASSERT(g_scsi_cb_called == 1);
     769                 :          4 :         g_scsi_cb_called = 0;
     770                 :            : 
     771                 :            :         /* LBA = 0, length = 5 (LBA in range, length beyond end of bdev) */
     772                 :          4 :         to_be64(&cdb[2], 0); /* LBA */
     773                 :          4 :         to_be32(&cdb[10], 5); /* transfer length */
     774                 :          4 :         task.transfer_len = 5 * 512;
     775                 :          4 :         task.offset = 0;
     776                 :          4 :         task.length = 1 * 512;
     777                 :          4 :         rc = bdev_scsi_execute(&task);
     778                 :          4 :         CU_ASSERT(rc == SPDK_SCSI_TASK_COMPLETE);
     779                 :          4 :         CU_ASSERT(task.status == SPDK_SCSI_STATUS_CHECK_CONDITION);
     780                 :          4 :         CU_ASSERT(task.sense_data[12] == SPDK_SCSI_ASC_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE);
     781         [ -  + ]:          4 :         SPDK_CU_ASSERT_FATAL(TAILQ_EMPTY(&g_bdev_io_queue));
     782                 :            : 
     783                 :          4 :         ut_put_task(&task);
     784                 :          4 : }
     785                 :            : 
     786                 :            : static void
     787                 :          4 : xfer_len_test(void)
     788                 :            : {
     789                 :          4 :         struct spdk_bdev bdev = { .blocklen = 512 };
     790                 :          4 :         struct spdk_scsi_lun lun;
     791                 :          4 :         struct spdk_scsi_task task;
     792                 :          4 :         uint8_t cdb[16];
     793                 :            :         int rc;
     794                 :            : 
     795                 :          4 :         lun.bdev = &bdev;
     796                 :            : 
     797                 :          4 :         ut_init_task(&task);
     798                 :          4 :         task.lun = &lun;
     799                 :          4 :         task.lun->bdev_desc = NULL;
     800                 :          4 :         task.lun->io_channel = NULL;
     801                 :          4 :         task.cdb = cdb;
     802                 :            : 
     803                 :          4 :         memset(cdb, 0, sizeof(cdb));
     804                 :          4 :         cdb[0] = 0x88; /* READ (16) */
     805                 :            : 
     806                 :            :         /* Test block device size of 512 MiB */
     807                 :          4 :         g_test_bdev_num_blocks = 512 * 1024 * 1024;
     808                 :            : 
     809                 :            :         /* 1 block */
     810                 :          4 :         to_be64(&cdb[2], 0); /* LBA */
     811                 :          4 :         to_be32(&cdb[10], 1); /* transfer length */
     812                 :          4 :         task.transfer_len = 1 * 512;
     813                 :          4 :         task.offset = 0;
     814                 :          4 :         task.length = 1 * 512;
     815                 :          4 :         rc = bdev_scsi_execute(&task);
     816                 :          4 :         CU_ASSERT(rc == SPDK_SCSI_TASK_PENDING);
     817                 :          4 :         CU_ASSERT(task.status == 0xFF);
     818         [ -  + ]:          4 :         SPDK_CU_ASSERT_FATAL(!TAILQ_EMPTY(&g_bdev_io_queue));
     819                 :          4 :         ut_bdev_io_flush();
     820                 :          4 :         CU_ASSERT(task.status == SPDK_SCSI_STATUS_GOOD);
     821                 :          4 :         CU_ASSERT(g_scsi_cb_called == 1);
     822                 :          4 :         g_scsi_cb_called = 0;
     823                 :            : 
     824                 :            :         /* max transfer length (as reported in block limits VPD page) */
     825                 :          4 :         to_be64(&cdb[2], 0); /* LBA */
     826                 :          4 :         to_be32(&cdb[10], SPDK_WORK_BLOCK_SIZE / 512); /* transfer length */
     827                 :          4 :         task.transfer_len = SPDK_WORK_BLOCK_SIZE;
     828                 :          4 :         task.status = 0xFF;
     829                 :          4 :         task.offset = 0;
     830                 :          4 :         task.length = 1 * 512;
     831                 :          4 :         rc = bdev_scsi_execute(&task);
     832                 :          4 :         CU_ASSERT(rc == SPDK_SCSI_TASK_PENDING);
     833                 :          4 :         CU_ASSERT(task.status == 0xFF);
     834         [ -  + ]:          4 :         SPDK_CU_ASSERT_FATAL(!TAILQ_EMPTY(&g_bdev_io_queue));
     835                 :          4 :         ut_bdev_io_flush();
     836                 :          4 :         CU_ASSERT(task.status == SPDK_SCSI_STATUS_GOOD);
     837                 :          4 :         CU_ASSERT(g_scsi_cb_called == 1);
     838                 :          4 :         g_scsi_cb_called = 0;
     839                 :            : 
     840                 :            :         /* max transfer length plus one block (invalid) */
     841                 :          4 :         to_be64(&cdb[2], 0); /* LBA */
     842                 :          4 :         to_be32(&cdb[10], SPDK_WORK_BLOCK_SIZE / 512 + 1); /* transfer length */
     843                 :          4 :         task.transfer_len = SPDK_WORK_BLOCK_SIZE + 512;
     844                 :          4 :         task.offset = 0;
     845                 :          4 :         task.length = 1 * 512;
     846                 :          4 :         rc = bdev_scsi_execute(&task);
     847                 :          4 :         CU_ASSERT(rc == SPDK_SCSI_TASK_COMPLETE);
     848                 :          4 :         CU_ASSERT(task.status == SPDK_SCSI_STATUS_CHECK_CONDITION);
     849                 :          4 :         CU_ASSERT((task.sense_data[2] & 0xf) == SPDK_SCSI_SENSE_ILLEGAL_REQUEST);
     850                 :          4 :         CU_ASSERT(task.sense_data[12] == SPDK_SCSI_ASC_INVALID_FIELD_IN_CDB);
     851         [ -  + ]:          4 :         SPDK_CU_ASSERT_FATAL(TAILQ_EMPTY(&g_bdev_io_queue));
     852                 :            : 
     853                 :            :         /* zero transfer length (valid) */
     854                 :          4 :         to_be64(&cdb[2], 0); /* LBA */
     855                 :          4 :         to_be32(&cdb[10], 0); /* transfer length */
     856                 :          4 :         task.transfer_len = 0;
     857                 :          4 :         task.offset = 0;
     858                 :          4 :         task.length = 0;
     859                 :          4 :         rc = bdev_scsi_execute(&task);
     860                 :          4 :         CU_ASSERT(rc == SPDK_SCSI_TASK_COMPLETE);
     861                 :          4 :         CU_ASSERT(task.status == SPDK_SCSI_STATUS_GOOD);
     862                 :          4 :         CU_ASSERT(task.data_transferred == 0);
     863         [ -  + ]:          4 :         SPDK_CU_ASSERT_FATAL(TAILQ_EMPTY(&g_bdev_io_queue));
     864                 :            : 
     865                 :            :         /* zero transfer length past end of disk (invalid) */
     866                 :          4 :         to_be64(&cdb[2], g_test_bdev_num_blocks); /* LBA */
     867                 :          4 :         to_be32(&cdb[10], 0); /* transfer length */
     868                 :          4 :         task.transfer_len = 0;
     869                 :          4 :         task.offset = 0;
     870                 :          4 :         task.length = 0;
     871                 :          4 :         rc = bdev_scsi_execute(&task);
     872                 :          4 :         CU_ASSERT(rc == SPDK_SCSI_TASK_COMPLETE);
     873                 :          4 :         CU_ASSERT(task.status == SPDK_SCSI_STATUS_CHECK_CONDITION);
     874                 :          4 :         CU_ASSERT(task.sense_data[12] == SPDK_SCSI_ASC_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE);
     875         [ -  + ]:          4 :         SPDK_CU_ASSERT_FATAL(TAILQ_EMPTY(&g_bdev_io_queue));
     876                 :            : 
     877                 :          4 :         ut_put_task(&task);
     878                 :          4 : }
     879                 :            : 
     880                 :            : static void
     881                 :          8 : _xfer_test(bool bdev_io_pool_full)
     882                 :            : {
     883                 :          8 :         struct spdk_bdev bdev = { .blocklen = 512 };
     884                 :          8 :         struct spdk_scsi_lun lun;
     885                 :          8 :         struct spdk_scsi_task task;
     886                 :          8 :         uint8_t cdb[16];
     887                 :          8 :         char data[4096];
     888                 :            :         int rc;
     889                 :            : 
     890                 :          8 :         lun.bdev = &bdev;
     891                 :            : 
     892                 :            :         /* Test block device size of 512 MiB */
     893                 :          8 :         g_test_bdev_num_blocks = 512 * 1024 * 1024;
     894                 :            : 
     895                 :            :         /* Read 1 block */
     896                 :          8 :         ut_init_task(&task);
     897                 :          8 :         task.lun = &lun;
     898                 :          8 :         task.lun->bdev_desc = NULL;
     899                 :          8 :         task.lun->io_channel = NULL;
     900                 :          8 :         task.cdb = cdb;
     901                 :          8 :         memset(cdb, 0, sizeof(cdb));
     902                 :          8 :         cdb[0] = 0x88; /* READ (16) */
     903                 :          8 :         to_be64(&cdb[2], 0); /* LBA */
     904                 :          8 :         to_be32(&cdb[10], 1); /* transfer length */
     905                 :          8 :         task.transfer_len = 1 * 512;
     906                 :          8 :         task.offset = 0;
     907                 :          8 :         task.length = 1 * 512;
     908                 :          8 :         g_bdev_io_pool_full = bdev_io_pool_full;
     909                 :          8 :         rc = bdev_scsi_execute(&task);
     910                 :          8 :         CU_ASSERT(rc == SPDK_SCSI_TASK_PENDING);
     911                 :          8 :         CU_ASSERT(task.status == 0xFF);
     912                 :            : 
     913                 :          8 :         ut_bdev_io_flush();
     914                 :          8 :         CU_ASSERT(task.status == SPDK_SCSI_STATUS_GOOD);
     915                 :          8 :         CU_ASSERT(g_scsi_cb_called == 1);
     916                 :          8 :         g_scsi_cb_called = 0;
     917                 :          8 :         ut_put_task(&task);
     918                 :            : 
     919                 :            :         /* Write 1 block */
     920                 :          8 :         ut_init_task(&task);
     921                 :          8 :         task.lun = &lun;
     922                 :          8 :         task.cdb = cdb;
     923                 :          8 :         memset(cdb, 0, sizeof(cdb));
     924                 :          8 :         cdb[0] = 0x8a; /* WRITE (16) */
     925                 :          8 :         to_be64(&cdb[2], 0); /* LBA */
     926                 :          8 :         to_be32(&cdb[10], 1); /* transfer length */
     927                 :          8 :         task.transfer_len = 1 * 512;
     928                 :          8 :         task.offset = 0;
     929                 :          8 :         task.length = 1 * 512;
     930                 :          8 :         g_bdev_io_pool_full = bdev_io_pool_full;
     931                 :          8 :         rc = bdev_scsi_execute(&task);
     932                 :          8 :         CU_ASSERT(rc == SPDK_SCSI_TASK_PENDING);
     933                 :          8 :         CU_ASSERT(task.status == 0xFF);
     934                 :            : 
     935                 :          8 :         ut_bdev_io_flush();
     936                 :          8 :         CU_ASSERT(task.status == SPDK_SCSI_STATUS_GOOD);
     937                 :          8 :         CU_ASSERT(g_scsi_cb_called == 1);
     938                 :          8 :         g_scsi_cb_called = 0;
     939                 :          8 :         ut_put_task(&task);
     940                 :            : 
     941                 :            :         /* Unmap 5 blocks using 2 descriptors */
     942                 :          8 :         ut_init_task(&task);
     943                 :          8 :         task.lun = &lun;
     944                 :          8 :         task.cdb = cdb;
     945                 :          8 :         memset(cdb, 0, sizeof(cdb));
     946                 :          8 :         cdb[0] = 0x42; /* UNMAP */
     947                 :          8 :         to_be16(&data[7], 2); /* 2 parameters in list */
     948                 :          8 :         memset(data, 0, sizeof(data));
     949                 :          8 :         to_be16(&data[2], 32); /* 2 descriptors */
     950                 :          8 :         to_be64(&data[8], 1); /* LBA 1 */
     951                 :          8 :         to_be32(&data[16], 2); /* 2 blocks */
     952                 :          8 :         to_be64(&data[24], 10); /* LBA 10 */
     953                 :          8 :         to_be32(&data[32], 3); /* 3 blocks */
     954                 :          8 :         spdk_scsi_task_set_data(&task, data, sizeof(data));
     955                 :          8 :         task.status = SPDK_SCSI_STATUS_GOOD;
     956                 :          8 :         g_bdev_io_pool_full = bdev_io_pool_full;
     957                 :          8 :         rc = bdev_scsi_execute(&task);
     958                 :          8 :         CU_ASSERT(rc == SPDK_SCSI_TASK_PENDING);
     959                 :          8 :         CU_ASSERT(task.status == SPDK_SCSI_STATUS_GOOD);
     960                 :            : 
     961                 :          8 :         ut_bdev_io_flush();
     962                 :          8 :         CU_ASSERT(task.status == SPDK_SCSI_STATUS_GOOD);
     963                 :          8 :         CU_ASSERT(g_scsi_cb_called == 1);
     964                 :          8 :         g_scsi_cb_called = 0;
     965                 :          8 :         ut_put_task(&task);
     966                 :            : 
     967                 :            :         /* Flush 1 block */
     968                 :          8 :         ut_init_task(&task);
     969                 :          8 :         task.lun = &lun;
     970                 :          8 :         task.cdb = cdb;
     971                 :          8 :         memset(cdb, 0, sizeof(cdb));
     972                 :          8 :         cdb[0] = 0x91; /* SYNCHRONIZE CACHE (16) */
     973                 :          8 :         to_be64(&cdb[2], 0); /* LBA */
     974                 :          8 :         to_be32(&cdb[10], 1); /* 1 blocks */
     975                 :          8 :         g_bdev_io_pool_full = bdev_io_pool_full;
     976                 :          8 :         rc = bdev_scsi_execute(&task);
     977                 :          8 :         CU_ASSERT(rc == SPDK_SCSI_TASK_PENDING);
     978                 :          8 :         CU_ASSERT(task.status == 0xFF);
     979                 :            : 
     980                 :          8 :         ut_bdev_io_flush();
     981                 :          8 :         CU_ASSERT(task.status == SPDK_SCSI_STATUS_GOOD);
     982                 :          8 :         CU_ASSERT(g_scsi_cb_called == 1);
     983                 :          8 :         g_scsi_cb_called = 0;
     984         [ -  + ]:          8 :         SPDK_CU_ASSERT_FATAL(TAILQ_EMPTY(&g_bdev_io_queue));
     985                 :            : 
     986                 :          8 :         ut_put_task(&task);
     987                 :          8 : }
     988                 :            : 
     989                 :            : static void
     990                 :          4 : xfer_test(void)
     991                 :            : {
     992                 :          4 :         _xfer_test(false);
     993                 :          4 :         _xfer_test(true);
     994                 :          4 : }
     995                 :            : 
     996                 :            : static void
     997                 :          4 : get_dif_ctx_test(void)
     998                 :            : {
     999                 :          4 :         struct spdk_bdev bdev = {};
    1000                 :          4 :         struct spdk_scsi_task task = {};
    1001                 :          4 :         struct spdk_dif_ctx dif_ctx = {};
    1002                 :          4 :         uint8_t cdb[16];
    1003                 :            :         bool ret;
    1004                 :            : 
    1005                 :          4 :         cdb[0] = SPDK_SBC_READ_6;
    1006                 :          4 :         cdb[1] = 0x12;
    1007                 :          4 :         cdb[2] = 0x34;
    1008                 :          4 :         cdb[3] = 0x50;
    1009                 :          4 :         task.cdb = cdb;
    1010                 :          4 :         task.offset = 0x6 * 512;
    1011                 :            : 
    1012                 :          4 :         ret = bdev_scsi_get_dif_ctx(&bdev, &task, &dif_ctx);
    1013                 :          4 :         CU_ASSERT(ret == true);
    1014                 :          4 :         CU_ASSERT(dif_ctx.init_ref_tag + dif_ctx.ref_tag_offset == 0x123456);
    1015                 :            : 
    1016                 :          4 :         cdb[0] = SPDK_SBC_WRITE_12;
    1017                 :          4 :         to_be32(&cdb[2], 0x12345670);
    1018                 :          4 :         task.offset = 0x8 * 512;
    1019                 :            : 
    1020                 :          4 :         ret = bdev_scsi_get_dif_ctx(&bdev, &task, &dif_ctx);
    1021                 :          4 :         CU_ASSERT(ret == true);
    1022                 :          4 :         CU_ASSERT(dif_ctx.init_ref_tag + dif_ctx.ref_tag_offset == 0x12345678);
    1023                 :            : 
    1024                 :          4 :         cdb[0] = SPDK_SBC_WRITE_16;
    1025                 :          4 :         to_be64(&cdb[2], 0x0000000012345670);
    1026                 :          4 :         task.offset = 0x8 * 512;
    1027                 :            : 
    1028                 :          4 :         ret = bdev_scsi_get_dif_ctx(&bdev, &task, &dif_ctx);
    1029                 :          4 :         CU_ASSERT(ret == true);
    1030                 :          4 :         CU_ASSERT(dif_ctx.init_ref_tag + dif_ctx.ref_tag_offset == 0x12345678);
    1031                 :          4 : }
    1032                 :            : 
    1033                 :            : static void
    1034                 :          4 : unmap_split_test(void)
    1035                 :            : {
    1036                 :          4 :         struct spdk_bdev bdev = { .blocklen = 512 };
    1037                 :          4 :         struct spdk_scsi_lun lun;
    1038                 :          4 :         struct spdk_scsi_task task;
    1039                 :          4 :         uint8_t cdb[16];
    1040                 :          4 :         char data[4096];
    1041                 :            :         int rc;
    1042                 :            : 
    1043                 :          4 :         lun.bdev = &bdev;
    1044                 :            : 
    1045                 :            :         /* Test block device size of 512 MiB */
    1046                 :          4 :         g_test_bdev_num_blocks = 512 * 1024 * 1024;
    1047                 :            : 
    1048                 :            :         /* Unmap 5 blocks using 6 descriptors(descriptor 2 has 0 blocks). bdev_io pool size is 2.
    1049                 :            :          * Hence, unmap should be done by 3 iterations.
    1050                 :            :          * 1st - 2 unmaps(0, 1), 2nd - 3 unmaps(2, 3, 4), and 3rd - 1 unmap(5).
    1051                 :            :          */
    1052                 :          4 :         ut_init_task(&task);
    1053                 :          4 :         task.lun = &lun;
    1054                 :          4 :         task.cdb = cdb;
    1055                 :          4 :         memset(cdb, 0, sizeof(cdb));
    1056                 :          4 :         cdb[0] = 0x42; /* UNMAP */
    1057                 :          4 :         to_be16(&data[7], 6); /* 6 parameters in list */
    1058                 :          4 :         memset(data, 0, sizeof(data));
    1059                 :          4 :         to_be16(&data[2], 16 * 6); /* 6 descriptors */
    1060                 :          4 :         to_be64(&data[8], 1); /* LBA 1 */
    1061                 :          4 :         to_be32(&data[16], 2); /* 2 blocks */
    1062                 :          4 :         to_be64(&data[24], 5); /* LBA 5 */
    1063                 :          4 :         to_be32(&data[32], 3); /* 3 blocks */
    1064                 :          4 :         to_be64(&data[40], 10); /* LBA 10 */
    1065                 :          4 :         to_be32(&data[48], 0); /* 0 block */
    1066                 :          4 :         to_be64(&data[56], 15); /* LBA 15 */
    1067                 :          4 :         to_be32(&data[64], 4); /* 4 blocks */
    1068                 :          4 :         to_be64(&data[72], 30); /* LBA 30 */
    1069                 :          4 :         to_be32(&data[80], 1); /* 1 block */
    1070                 :          4 :         to_be64(&data[88], 40); /* LBA 40 */
    1071                 :          4 :         to_be32(&data[96], 1); /* 1 block */
    1072                 :          4 :         spdk_scsi_task_set_data(&task, data, sizeof(data));
    1073                 :          4 :         task.status = SPDK_SCSI_STATUS_GOOD;
    1074                 :            : 
    1075                 :          4 :         g_bdev_io_pool_full = true;
    1076                 :            : 
    1077                 :          4 :         rc = bdev_scsi_execute(&task);
    1078                 :          4 :         CU_ASSERT(rc == SPDK_SCSI_TASK_PENDING);
    1079                 :          4 :         CU_ASSERT(task.status == SPDK_SCSI_STATUS_GOOD);
    1080                 :          4 :         CU_ASSERT(g_scsi_cb_called == 0);
    1081                 :          4 :         CU_ASSERT(g_outstanding_bdev_io_count == 0);
    1082                 :          4 :         CU_ASSERT(g_pending_bdev_io_count == 1);
    1083                 :            : 
    1084                 :          4 :         g_bdev_io_pool_count = 2;
    1085                 :          4 :         ut_bdev_io_retry();
    1086                 :            : 
    1087                 :            :         /* descriptor 0 and 1 */
    1088                 :          4 :         CU_ASSERT(g_outstanding_bdev_io_count == 2);
    1089                 :          4 :         CU_ASSERT(g_pending_bdev_io_count == 0);
    1090                 :            : 
    1091                 :          4 :         g_bdev_io_pool_full = true;
    1092                 :          4 :         ut_bdev_io_complete();
    1093                 :            : 
    1094                 :          4 :         CU_ASSERT(g_outstanding_bdev_io_count == 0);
    1095                 :          4 :         CU_ASSERT(g_pending_bdev_io_count == 1);
    1096                 :            : 
    1097                 :          4 :         ut_bdev_io_retry();
    1098                 :            : 
    1099                 :            :         /* descriptor 2 and 3 (descriptor 2 is valid even though it is 0 blocks) */
    1100                 :          4 :         CU_ASSERT(g_outstanding_bdev_io_count == 2);
    1101                 :          4 :         CU_ASSERT(g_pending_bdev_io_count == 0);
    1102                 :            : 
    1103                 :          4 :         g_bdev_io_pool_full = true;
    1104                 :          4 :         ut_bdev_io_complete();
    1105                 :            : 
    1106                 :          4 :         CU_ASSERT(g_outstanding_bdev_io_count == 0);
    1107                 :          4 :         CU_ASSERT(g_pending_bdev_io_count == 1);
    1108                 :            : 
    1109                 :          4 :         ut_bdev_io_retry();
    1110                 :            : 
    1111                 :            :         /* descriptor 4 and 5 */
    1112                 :          4 :         CU_ASSERT(g_outstanding_bdev_io_count == 2);
    1113                 :          4 :         CU_ASSERT(g_pending_bdev_io_count == 0);
    1114                 :            : 
    1115                 :          4 :         ut_bdev_io_complete();
    1116                 :            : 
    1117                 :          4 :         CU_ASSERT(task.status == SPDK_SCSI_STATUS_GOOD);
    1118                 :          4 :         CU_ASSERT(g_scsi_cb_called == 1);
    1119                 :            : 
    1120                 :          4 :         g_scsi_cb_called = 0;
    1121                 :          4 :         g_bdev_io_pool_count = -1;
    1122                 :            : 
    1123         [ -  + ]:          4 :         SPDK_CU_ASSERT_FATAL(TAILQ_EMPTY(&g_bdev_io_queue));
    1124         [ -  + ]:          4 :         SPDK_CU_ASSERT_FATAL(TAILQ_EMPTY(&g_io_wait_queue));
    1125                 :            : 
    1126                 :          4 :         ut_put_task(&task);
    1127                 :          4 : }
    1128                 :            : 
    1129                 :            : int
    1130                 :          4 : main(int argc, char **argv)
    1131                 :            : {
    1132                 :          4 :         CU_pSuite       suite = NULL;
    1133                 :            :         unsigned int    num_failures;
    1134                 :            : 
    1135                 :          4 :         TAILQ_INIT(&g_bdev_io_queue);
    1136                 :          4 :         TAILQ_INIT(&g_io_wait_queue);
    1137                 :            : 
    1138                 :          4 :         CU_initialize_registry();
    1139                 :            : 
    1140                 :          4 :         suite = CU_add_suite("translation_suite", NULL, NULL);
    1141                 :            : 
    1142                 :          4 :         CU_ADD_TEST(suite, mode_select_6_test);
    1143                 :          4 :         CU_ADD_TEST(suite, mode_select_6_test2);
    1144                 :          4 :         CU_ADD_TEST(suite, mode_sense_6_test);
    1145                 :          4 :         CU_ADD_TEST(suite, mode_sense_10_test);
    1146                 :          4 :         CU_ADD_TEST(suite, inquiry_evpd_test);
    1147                 :          4 :         CU_ADD_TEST(suite, inquiry_standard_test);
    1148                 :          4 :         CU_ADD_TEST(suite, inquiry_overflow_test);
    1149                 :          4 :         CU_ADD_TEST(suite, task_complete_test);
    1150                 :          4 :         CU_ADD_TEST(suite, lba_range_test);
    1151                 :          4 :         CU_ADD_TEST(suite, xfer_len_test);
    1152                 :          4 :         CU_ADD_TEST(suite, xfer_test);
    1153                 :          4 :         CU_ADD_TEST(suite, scsi_name_padding_test);
    1154                 :          4 :         CU_ADD_TEST(suite, get_dif_ctx_test);
    1155                 :          4 :         CU_ADD_TEST(suite, unmap_split_test);
    1156                 :            : 
    1157                 :          4 :         num_failures = spdk_ut_run_tests(argc, argv, NULL);
    1158                 :          4 :         CU_cleanup_registry();
    1159                 :          4 :         return num_failures;
    1160                 :            : }

Generated by: LCOV version 1.14