LCOV - code coverage report
Current view: top level - spdk/test/accel/dif - dif.c (source / functions) Hit Total Coverage
Test: Combined Lines: 731 776 94.2 %
Date: 2024-08-13 16:37:32 Functions: 54 57 94.7 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 188 362 51.9 %

           Branch data     Line data    Source code
       1                 :            : /*   SPDX-License-Identifier: BSD-3-Clause
       2                 :            :  *   Copyright (C) 2023 Intel Corporation.
       3                 :            :  *   All rights reserved.
       4                 :            :  */
       5                 :            : 
       6                 :            : #include "spdk/stdinc.h"
       7                 :            : 
       8                 :            : #include "spdk/accel.h"
       9                 :            : #include "spdk/env.h"
      10                 :            : #include "spdk/log.h"
      11                 :            : #include "spdk/thread.h"
      12                 :            : #include "spdk/event.h"
      13                 :            : #include "spdk/rpc.h"
      14                 :            : #include "spdk/util.h"
      15                 :            : #include "spdk/string.h"
      16                 :            : #include "spdk_internal/cunit.h"
      17                 :            : 
      18                 :            : #include "CUnit/Basic.h"
      19                 :            : 
      20                 :            : pthread_mutex_t g_test_mutex;
      21                 :            : pthread_cond_t g_test_cond;
      22                 :            : 
      23                 :            : #define WORKER_COUNT 2
      24                 :            : #define WORKER_IO 0
      25                 :            : #define WORKER_UT 1
      26                 :            : 
      27                 :            : static struct spdk_thread *g_thread[WORKER_COUNT];
      28                 :            : static int g_num_failures = 0;
      29                 :            : static bool g_shutdown = false;
      30                 :            : static bool g_completion_success;
      31                 :            : struct spdk_io_channel  *g_channel = NULL;
      32                 :            : 
      33                 :            : struct dif_task {
      34                 :            :         struct iovec            *dst_iovs;
      35                 :            :         uint32_t                dst_iovcnt;
      36                 :            :         struct iovec            *src_iovs;
      37                 :            :         uint32_t                src_iovcnt;
      38                 :            :         uint32_t                num_blocks; /* used for the DIF related operations */
      39                 :            :         struct spdk_dif_ctx     dif_ctx;
      40                 :            :         struct spdk_dif_error   dif_err;
      41                 :            : };
      42                 :            : 
      43                 :            : static void
      44                 :         87 : execute_spdk_function(spdk_msg_fn fn, void *arg)
      45                 :            : {
      46         [ -  + ]:         87 :         pthread_mutex_lock(&g_test_mutex);
      47                 :         87 :         spdk_thread_send_msg(g_thread[WORKER_IO], fn, arg);
      48   [ -  +  -  + ]:         87 :         pthread_cond_wait(&g_test_cond, &g_test_mutex);
      49         [ -  + ]:         87 :         pthread_mutex_unlock(&g_test_mutex);
      50                 :         87 : }
      51                 :            : 
      52                 :            : static void
      53                 :         87 : wake_ut_thread(void)
      54                 :            : {
      55         [ -  + ]:         87 :         pthread_mutex_lock(&g_test_mutex);
      56         [ -  + ]:         87 :         pthread_cond_signal(&g_test_cond);
      57         [ -  + ]:         87 :         pthread_mutex_unlock(&g_test_mutex);
      58                 :         87 : }
      59                 :            : 
      60                 :            : static void
      61                 :          3 : exit_io_thread(void *arg)
      62                 :            : {
      63         [ -  + ]:          3 :         assert(spdk_get_thread() == g_thread[WORKER_IO]);
      64                 :          3 :         spdk_thread_exit(g_thread[WORKER_IO]);
      65                 :          3 :         wake_ut_thread();
      66                 :          3 : }
      67                 :            : 
      68                 :            : #define DATA_PATTERN 0x5A
      69                 :            : 
      70                 :            : static int g_xfer_size_bytes = 4096;
      71                 :            : static int g_block_size_bytes = 512;
      72                 :            : static int g_md_size_bytes = 8;
      73                 :            : struct dif_task g_dif_task;
      74                 :            : 
      75                 :            : struct accel_dif_request {
      76                 :            :         struct spdk_io_channel *channel;
      77                 :            :         struct iovec *dst_iovs;
      78                 :            :         size_t dst_iovcnt;
      79                 :            :         struct iovec *src_iovs;
      80                 :            :         size_t src_iovcnt;
      81                 :            :         uint32_t num_blocks;
      82                 :            :         const struct spdk_dif_ctx *ctx;
      83                 :            :         struct spdk_dif_error *err;
      84                 :            :         spdk_accel_completion_cb cb_fn;
      85                 :            :         void *cb_arg;
      86                 :            : };
      87                 :            : 
      88                 :            : static void
      89                 :         78 : accel_dif_oper_done(void *arg1, int status)
      90                 :            : {
      91         [ +  + ]:         78 :         if (status == 0) {
      92                 :         51 :                 g_completion_success = true;
      93                 :            :         }
      94                 :         78 :         wake_ut_thread();
      95                 :         78 : }
      96                 :            : 
      97                 :            : static bool
      98                 :         18 : accel_dif_error_validate(const uint32_t dif_flags,
      99                 :            :                          const struct spdk_dif_error *err)
     100                 :            : {
     101   [ +  +  +  - ]:         18 :         switch (dif_flags) {
     102                 :          6 :         case SPDK_DIF_FLAGS_GUARD_CHECK:
     103                 :          6 :                 return err->err_type == SPDK_DIF_GUARD_ERROR;
     104                 :          6 :         case SPDK_DIF_FLAGS_APPTAG_CHECK:
     105                 :          6 :                 return err->err_type == SPDK_DIF_APPTAG_ERROR;
     106                 :          6 :         case SPDK_DIF_FLAGS_REFTAG_CHECK:
     107                 :          6 :                 return err->err_type == SPDK_DIF_REFTAG_ERROR;
     108                 :          0 :         default:
     109                 :          0 :                 return false;
     110                 :            :         }
     111                 :            : }
     112                 :            : 
     113                 :            : static int
     114                 :         36 : alloc_dif_verify_bufs(struct dif_task *task, uint32_t chained_count)
     115                 :            : {
     116                 :         36 :         int src_buff_len = g_xfer_size_bytes;
     117                 :         36 :         uint32_t i = 0;
     118                 :            : 
     119         [ -  + ]:         36 :         assert(chained_count > 0);
     120                 :         36 :         task->src_iovcnt = chained_count;
     121                 :         36 :         task->src_iovs = calloc(task->src_iovcnt, sizeof(struct iovec));
     122         [ -  + ]:         36 :         if (spdk_unlikely(task->src_iovs == NULL)) {
     123                 :          0 :                 return -ENOMEM;
     124                 :            :         }
     125                 :            : 
     126         [ -  + ]:         36 :         src_buff_len += (g_xfer_size_bytes / g_block_size_bytes) * g_md_size_bytes;
     127                 :            : 
     128         [ +  + ]:         78 :         for (i = 0; i < task->src_iovcnt; i++) {
     129                 :         42 :                 task->src_iovs[i].iov_base = spdk_dma_zmalloc(src_buff_len, 0, NULL);
     130         [ -  + ]:         42 :                 if (spdk_unlikely(task->src_iovs[i].iov_base == NULL)) {
     131                 :          0 :                         return -ENOMEM;
     132                 :            :                 }
     133                 :            : 
     134         [ -  + ]:         42 :                 memset(task->src_iovs[i].iov_base, DATA_PATTERN, src_buff_len);
     135                 :         42 :                 task->src_iovs[i].iov_len = src_buff_len;
     136                 :            :         }
     137                 :            : 
     138         [ -  + ]:         36 :         task->num_blocks = (g_xfer_size_bytes * chained_count) / g_block_size_bytes;
     139                 :            : 
     140                 :         36 :         return 0;
     141                 :            : }
     142                 :            : 
     143                 :            : static void
     144                 :         36 : free_dif_verify_bufs(struct dif_task *task)
     145                 :            : {
     146                 :         36 :         uint32_t i = 0;
     147                 :            : 
     148         [ +  - ]:         36 :         if (task->src_iovs != NULL) {
     149         [ +  + ]:         78 :                 for (i = 0; i < task->src_iovcnt; i++) {
     150         [ +  - ]:         42 :                         if (task->src_iovs[i].iov_base != NULL) {
     151                 :         42 :                                 spdk_dma_free(task->src_iovs[i].iov_base);
     152                 :            :                         }
     153                 :            :                 }
     154                 :         36 :                 free(task->src_iovs);
     155                 :            :         }
     156                 :         36 : }
     157                 :            : 
     158                 :            : static int
     159                 :         18 : alloc_dif_verify_copy_bufs(struct dif_task *task, uint32_t chained_count)
     160                 :            : {
     161                 :         18 :         int dst_buff_len = g_xfer_size_bytes;
     162                 :            :         uint32_t data_size_with_md;
     163                 :         18 :         uint32_t i = 0;
     164                 :            : 
     165         [ -  + ]:         18 :         assert(chained_count > 0);
     166                 :         18 :         task->src_iovcnt = chained_count;
     167                 :         18 :         task->src_iovs = calloc(task->src_iovcnt, sizeof(struct iovec));
     168         [ -  + ]:         18 :         if (spdk_unlikely(task->src_iovs == NULL)) {
     169                 :          0 :                 return -ENOMEM;
     170                 :            :         }
     171                 :            : 
     172         [ -  + ]:         18 :         task->num_blocks = g_xfer_size_bytes / g_block_size_bytes;
     173                 :            : 
     174                 :            :         /* Add bytes for each block for metadata */
     175                 :         18 :         data_size_with_md = g_xfer_size_bytes + (task->num_blocks * g_md_size_bytes);
     176                 :            : 
     177         [ +  + ]:         36 :         for (i = 0; i < task->src_iovcnt; i++) {
     178                 :         18 :                 task->src_iovs[i].iov_base = spdk_dma_zmalloc(data_size_with_md, 0, NULL);
     179         [ -  + ]:         18 :                 if (spdk_unlikely(task->src_iovs[i].iov_base == NULL)) {
     180                 :          0 :                         return -ENOMEM;
     181                 :            :                 }
     182                 :            : 
     183         [ -  + ]:         18 :                 memset(task->src_iovs[i].iov_base, DATA_PATTERN, data_size_with_md);
     184                 :         18 :                 task->src_iovs[i].iov_len = data_size_with_md;
     185                 :            :         }
     186                 :            : 
     187                 :         18 :         task->dst_iovcnt = chained_count;
     188                 :         18 :         task->dst_iovs = calloc(task->dst_iovcnt, sizeof(struct iovec));
     189         [ -  + ]:         18 :         if (spdk_unlikely(task->dst_iovs == NULL)) {
     190                 :          0 :                 return -ENOMEM;
     191                 :            :         }
     192                 :            : 
     193         [ +  + ]:         36 :         for (i = 0; i < task->dst_iovcnt; i++) {
     194                 :         18 :                 task->dst_iovs[i].iov_base = spdk_dma_zmalloc(dst_buff_len, 0, NULL);
     195         [ -  + ]:         18 :                 if (spdk_unlikely(task->dst_iovs[i].iov_base == NULL)) {
     196                 :          0 :                         return -ENOMEM;
     197                 :            :                 }
     198                 :            : 
     199         [ -  + ]:         18 :                 memset(task->dst_iovs[i].iov_base, 0, dst_buff_len);
     200                 :         18 :                 task->dst_iovs[i].iov_len = dst_buff_len;
     201                 :            :         }
     202                 :            : 
     203                 :         18 :         return 0;
     204                 :            : }
     205                 :            : 
     206                 :            : static void
     207                 :         18 : free_dif_verify_copy_bufs(struct dif_task *task)
     208                 :            : {
     209                 :         18 :         uint32_t i = 0;
     210                 :            : 
     211         [ +  - ]:         18 :         if (task->dst_iovs != NULL) {
     212         [ +  + ]:         36 :                 for (i = 0; i < task->dst_iovcnt; i++) {
     213         [ +  - ]:         18 :                         if (task->dst_iovs[i].iov_base != NULL) {
     214                 :         18 :                                 spdk_dma_free(task->dst_iovs[i].iov_base);
     215                 :            :                         }
     216                 :            :                 }
     217                 :         18 :                 free(task->dst_iovs);
     218                 :            :         }
     219                 :            : 
     220         [ +  - ]:         18 :         if (task->src_iovs != NULL) {
     221         [ +  + ]:         36 :                 for (i = 0; i < task->src_iovcnt; i++) {
     222         [ +  - ]:         18 :                         if (task->src_iovs[i].iov_base != NULL) {
     223                 :         18 :                                 spdk_dma_free(task->src_iovs[i].iov_base);
     224                 :            :                         }
     225                 :            :                 }
     226                 :         18 :                 free(task->src_iovs);
     227                 :            :         }
     228                 :         18 : }
     229                 :            : 
     230                 :            : static int
     231                 :         24 : alloc_dif_generate_copy_bufs(struct dif_task *task, uint32_t chained_count)
     232                 :            : {
     233                 :         24 :         int src_buff_len = g_xfer_size_bytes;
     234                 :            :         uint32_t transfer_size_with_md;
     235                 :         24 :         uint32_t i = 0;
     236                 :            : 
     237         [ -  + ]:         24 :         assert(chained_count > 0);
     238                 :         24 :         task->dst_iovcnt = chained_count;
     239                 :         24 :         task->dst_iovs = calloc(task->dst_iovcnt, sizeof(struct iovec));
     240         [ -  + ]:         24 :         if (spdk_unlikely(task->dst_iovs == NULL)) {
     241                 :          0 :                 return -ENOMEM;
     242                 :            :         }
     243                 :            : 
     244         [ -  + ]:         24 :         task->num_blocks = g_xfer_size_bytes / g_block_size_bytes;
     245                 :            : 
     246                 :            :         /* Add bytes for each block for metadata */
     247                 :         24 :         transfer_size_with_md = g_xfer_size_bytes + (task->num_blocks * g_md_size_bytes);
     248                 :            : 
     249         [ +  + ]:         48 :         for (i = 0; i < task->dst_iovcnt; i++) {
     250                 :         24 :                 task->dst_iovs[i].iov_base = spdk_dma_zmalloc(transfer_size_with_md, 0, NULL);
     251         [ -  + ]:         24 :                 if (spdk_unlikely(task->dst_iovs[i].iov_base == NULL)) {
     252                 :          0 :                         return -ENOMEM;
     253                 :            :                 }
     254                 :            : 
     255         [ -  + ]:         24 :                 memset(task->dst_iovs[i].iov_base, 0, transfer_size_with_md);
     256                 :         24 :                 task->dst_iovs[i].iov_len = transfer_size_with_md;
     257                 :            :         }
     258                 :            : 
     259                 :         24 :         task->src_iovcnt = chained_count;
     260                 :         24 :         task->src_iovs = calloc(task->src_iovcnt, sizeof(struct iovec));
     261         [ -  + ]:         24 :         if (spdk_unlikely(task->src_iovs == NULL)) {
     262                 :          0 :                 return -ENOMEM;
     263                 :            :         }
     264                 :            : 
     265         [ +  + ]:         48 :         for (i = 0; i < task->src_iovcnt; i++) {
     266                 :         24 :                 task->src_iovs[i].iov_base = spdk_dma_zmalloc(src_buff_len, 0, NULL);
     267         [ -  + ]:         24 :                 if (spdk_unlikely(task->src_iovs[i].iov_base == NULL)) {
     268                 :          0 :                         return -ENOMEM;
     269                 :            :                 }
     270                 :            : 
     271         [ -  + ]:         24 :                 memset(task->src_iovs[i].iov_base, DATA_PATTERN, src_buff_len);
     272                 :         24 :                 task->src_iovs[i].iov_len = src_buff_len;
     273                 :            :         }
     274                 :            : 
     275                 :         24 :         return 0;
     276                 :            : }
     277                 :            : 
     278                 :            : static void
     279                 :         24 : free_dif_generate_copy_bufs(struct dif_task *task)
     280                 :            : {
     281                 :         24 :         uint32_t i = 0;
     282                 :            : 
     283         [ +  - ]:         24 :         if (task->dst_iovs != NULL) {
     284         [ +  + ]:         48 :                 for (i = 0; i < task->dst_iovcnt; i++) {
     285         [ +  - ]:         24 :                         if (task->dst_iovs[i].iov_base != NULL) {
     286                 :         24 :                                 spdk_dma_free(task->dst_iovs[i].iov_base);
     287                 :            :                         }
     288                 :            :                 }
     289                 :         24 :                 free(task->dst_iovs);
     290                 :            :         }
     291                 :            : 
     292         [ +  - ]:         24 :         if (task->src_iovs != NULL) {
     293         [ +  + ]:         48 :                 for (i = 0; i < task->src_iovcnt; i++) {
     294         [ +  - ]:         24 :                         if (task->src_iovs[i].iov_base != NULL) {
     295                 :         24 :                                 spdk_dma_free(task->src_iovs[i].iov_base);
     296                 :            :                         }
     297                 :            :                 }
     298                 :         24 :                 free(task->src_iovs);
     299                 :            :         }
     300                 :         24 : }
     301                 :            : 
     302                 :            : static void
     303                 :         36 : accel_dif_verify_test(void *arg)
     304                 :            : {
     305                 :            :         int rc;
     306                 :         36 :         struct accel_dif_request *req = arg;
     307                 :            : 
     308                 :         36 :         g_completion_success = false;
     309                 :         36 :         rc = spdk_accel_submit_dif_verify(req->channel, req->src_iovs, req->src_iovcnt,
     310                 :            :                                           req->num_blocks, req->ctx, req->err,
     311                 :            :                                           req->cb_fn, req->cb_arg);
     312         [ -  + ]:         36 :         if (rc) {
     313                 :          0 :                 wake_ut_thread();
     314                 :            :         }
     315                 :         36 : }
     316                 :            : 
     317                 :            : static void
     318                 :         18 : accel_dif_verify_copy_test(void *arg)
     319                 :            : {
     320                 :            :         int rc;
     321                 :         18 :         struct accel_dif_request *req = arg;
     322                 :            : 
     323                 :         18 :         g_completion_success = false;
     324                 :         18 :         rc = spdk_accel_submit_dif_verify_copy(req->channel, req->dst_iovs, req->dst_iovcnt,
     325                 :            :                                                req->src_iovs, req->src_iovcnt,
     326                 :            :                                                req->num_blocks, req->ctx, req->err,
     327                 :            :                                                req->cb_fn, req->cb_arg);
     328         [ -  + ]:         18 :         if (rc) {
     329                 :          0 :                 wake_ut_thread();
     330                 :            :         }
     331                 :         18 : }
     332                 :            : 
     333                 :            : static void
     334                 :         24 : accel_dif_generate_copy_test(void *arg)
     335                 :            : {
     336                 :            :         int rc;
     337                 :         24 :         struct accel_dif_request *req = arg;
     338                 :            : 
     339                 :         24 :         g_completion_success = false;
     340                 :         24 :         rc = spdk_accel_submit_dif_generate_copy(req->channel, req->dst_iovs, req->dst_iovcnt,
     341                 :            :                         req->src_iovs, req->src_iovcnt, req->num_blocks, req->ctx,
     342                 :            :                         req->cb_fn, req->cb_arg);
     343         [ -  + ]:         24 :         if (rc) {
     344                 :          0 :                 wake_ut_thread();
     345                 :            :         }
     346                 :         24 : }
     347                 :            : 
     348                 :            : static void
     349                 :          9 : accel_dif_verify_op_dif_generated_do_check(uint32_t dif_flags)
     350                 :            : {
     351                 :          3 :         struct spdk_dif_ctx_init_ext_opts dif_opts;
     352                 :          3 :         struct accel_dif_request req;
     353                 :          9 :         struct dif_task *task = &g_dif_task;
     354                 :            :         int rc;
     355                 :            : 
     356                 :          9 :         rc = alloc_dif_verify_bufs(task, 1);
     357         [ -  + ]:          9 :         SPDK_CU_ASSERT_FATAL(rc == 0);
     358                 :            : 
     359                 :          9 :         dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
     360                 :          9 :         dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16;
     361                 :            : 
     362                 :          9 :         rc = spdk_dif_ctx_init(&task->dif_ctx,
     363                 :          9 :                                g_block_size_bytes + g_md_size_bytes,
     364                 :            :                                g_md_size_bytes, true, true,
     365                 :            :                                SPDK_DIF_TYPE1,
     366                 :            :                                SPDK_DIF_FLAGS_GUARD_CHECK |
     367                 :            :                                SPDK_DIF_FLAGS_APPTAG_CHECK |
     368                 :            :                                SPDK_DIF_FLAGS_REFTAG_CHECK,
     369                 :            :                                10, 0xFFFF, 20, 0, 0, &dif_opts);
     370         [ -  + ]:          9 :         SPDK_CU_ASSERT_FATAL(rc == 0);
     371                 :            : 
     372                 :          9 :         rc = spdk_dif_generate(task->src_iovs, task->src_iovcnt, task->num_blocks, &task->dif_ctx);
     373         [ -  + ]:          9 :         SPDK_CU_ASSERT_FATAL(rc == 0);
     374                 :            : 
     375                 :          9 :         rc = spdk_dif_ctx_init(&task->dif_ctx,
     376                 :          9 :                                g_block_size_bytes + g_md_size_bytes,
     377                 :            :                                g_md_size_bytes, true, true,
     378                 :            :                                SPDK_DIF_TYPE1,
     379                 :            :                                dif_flags,
     380                 :            :                                10, 0xFFFF, 20, 0, 0, &dif_opts);
     381         [ -  + ]:          9 :         SPDK_CU_ASSERT_FATAL(rc == 0);
     382                 :            : 
     383                 :          9 :         req.channel = g_channel;
     384                 :          9 :         req.src_iovs = task->src_iovs;
     385                 :          9 :         req.src_iovcnt = task->src_iovcnt;
     386                 :          9 :         req.num_blocks = task->num_blocks;
     387                 :          9 :         req.ctx = &task->dif_ctx;
     388                 :          9 :         req.err = &task->dif_err;
     389                 :          9 :         req.cb_fn = accel_dif_oper_done;
     390                 :          9 :         req.cb_arg = task;
     391                 :            : 
     392                 :          9 :         execute_spdk_function(accel_dif_verify_test, &req);
     393         [ -  + ]:          9 :         CU_ASSERT_EQUAL(g_completion_success, true);
     394                 :            : 
     395                 :          9 :         free_dif_verify_bufs(task);
     396                 :          9 : }
     397                 :            : 
     398                 :            : static void
     399                 :          3 : accel_dif_verify_op_dif_generated_guard_check(void)
     400                 :            : {
     401                 :          3 :         accel_dif_verify_op_dif_generated_do_check(SPDK_DIF_FLAGS_GUARD_CHECK);
     402                 :          3 : }
     403                 :            : 
     404                 :            : static void
     405                 :          3 : accel_dif_verify_op_dif_generated_apptag_check(void)
     406                 :            : {
     407                 :          3 :         accel_dif_verify_op_dif_generated_do_check(SPDK_DIF_FLAGS_APPTAG_CHECK);
     408                 :          3 : }
     409                 :            : 
     410                 :            : static void
     411                 :          3 : accel_dif_verify_op_dif_generated_reftag_check(void)
     412                 :            : {
     413                 :          3 :         accel_dif_verify_op_dif_generated_do_check(SPDK_DIF_FLAGS_REFTAG_CHECK);
     414                 :          3 : }
     415                 :            : 
     416                 :            : static void
     417                 :          9 : accel_dif_verify_op_dif_not_generated_do_check(uint32_t dif_flags)
     418                 :            : {
     419                 :          3 :         struct spdk_dif_ctx_init_ext_opts dif_opts;
     420                 :          3 :         struct accel_dif_request req;
     421                 :          9 :         struct dif_task *task = &g_dif_task;
     422                 :            :         int rc;
     423                 :            : 
     424                 :          9 :         rc = alloc_dif_verify_bufs(task, 1);
     425         [ -  + ]:          9 :         SPDK_CU_ASSERT_FATAL(rc == 0);
     426                 :            : 
     427                 :          9 :         dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
     428                 :          9 :         dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16;
     429                 :            : 
     430                 :          9 :         rc = spdk_dif_ctx_init(&task->dif_ctx,
     431                 :          9 :                                g_block_size_bytes + g_md_size_bytes,
     432                 :            :                                g_md_size_bytes, true, true,
     433                 :            :                                SPDK_DIF_TYPE1,
     434                 :            :                                dif_flags,
     435                 :            :                                10, 0xFFFF, 20, 0, 0, &dif_opts);
     436         [ -  + ]:          9 :         SPDK_CU_ASSERT_FATAL(rc == 0);
     437                 :            : 
     438                 :          9 :         req.channel = g_channel;
     439                 :          9 :         req.src_iovs = task->src_iovs;
     440                 :          9 :         req.src_iovcnt = task->src_iovcnt;
     441                 :          9 :         req.num_blocks = task->num_blocks;
     442                 :          9 :         req.ctx = &task->dif_ctx;
     443                 :          9 :         req.err = &task->dif_err;
     444                 :          9 :         req.cb_fn = accel_dif_oper_done;
     445                 :          9 :         req.cb_arg = task;
     446                 :            : 
     447                 :          9 :         execute_spdk_function(accel_dif_verify_test, &req);
     448         [ -  + ]:          9 :         CU_ASSERT_EQUAL(g_completion_success, false);
     449                 :          9 :         CU_ASSERT_EQUAL(accel_dif_error_validate(dif_flags, req.err), true);
     450                 :            : 
     451                 :          9 :         free_dif_verify_bufs(task);
     452                 :          9 : }
     453                 :            : 
     454                 :            : static void
     455                 :          3 : accel_dif_verify_op_dif_not_generated_guard_check(void)
     456                 :            : {
     457                 :          3 :         accel_dif_verify_op_dif_not_generated_do_check(SPDK_DIF_FLAGS_GUARD_CHECK);
     458                 :          3 : }
     459                 :            : 
     460                 :            : static void
     461                 :          3 : accel_dif_verify_op_dif_not_generated_apptag_check(void)
     462                 :            : {
     463                 :          3 :         accel_dif_verify_op_dif_not_generated_do_check(SPDK_DIF_FLAGS_APPTAG_CHECK);
     464                 :          3 : }
     465                 :            : 
     466                 :            : static void
     467                 :          3 : accel_dif_verify_op_dif_not_generated_reftag_check(void)
     468                 :            : {
     469                 :          3 :         accel_dif_verify_op_dif_not_generated_do_check(SPDK_DIF_FLAGS_REFTAG_CHECK);
     470                 :          3 : }
     471                 :            : 
     472                 :            : static void
     473                 :          3 : accel_dif_verify_op_apptag_correct_apptag_check(void)
     474                 :            : {
     475                 :          1 :         struct spdk_dif_ctx_init_ext_opts dif_opts;
     476                 :          1 :         struct accel_dif_request req;
     477                 :          3 :         struct dif_task *task = &g_dif_task;
     478                 :            :         int rc;
     479                 :            : 
     480                 :          3 :         rc = alloc_dif_verify_bufs(task, 1);
     481         [ -  + ]:          3 :         SPDK_CU_ASSERT_FATAL(rc == 0);
     482                 :            : 
     483                 :          3 :         dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
     484                 :          3 :         dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16;
     485                 :            : 
     486                 :          3 :         rc = spdk_dif_ctx_init(&task->dif_ctx,
     487                 :          3 :                                g_block_size_bytes + g_md_size_bytes,
     488                 :            :                                g_md_size_bytes, true, true,
     489                 :            :                                SPDK_DIF_TYPE1,
     490                 :            :                                SPDK_DIF_FLAGS_APPTAG_CHECK,
     491                 :            :                                10, 0xFFFF, 20, 0, 0, &dif_opts);
     492         [ -  + ]:          3 :         SPDK_CU_ASSERT_FATAL(rc == 0);
     493                 :            : 
     494                 :          3 :         rc = spdk_dif_generate(task->src_iovs, task->src_iovcnt, task->num_blocks, &task->dif_ctx);
     495         [ -  + ]:          3 :         SPDK_CU_ASSERT_FATAL(rc == 0);
     496                 :            : 
     497                 :          3 :         req.channel = g_channel;
     498                 :          3 :         req.src_iovs = task->src_iovs;
     499                 :          3 :         req.src_iovcnt = task->src_iovcnt;
     500                 :          3 :         req.num_blocks = task->num_blocks;
     501                 :          3 :         req.ctx = &task->dif_ctx;
     502                 :          3 :         req.err = &task->dif_err;
     503                 :          3 :         req.cb_fn = accel_dif_oper_done;
     504                 :          3 :         req.cb_arg = task;
     505                 :            : 
     506                 :          3 :         execute_spdk_function(accel_dif_verify_test, &req);
     507         [ -  + ]:          3 :         CU_ASSERT_EQUAL(g_completion_success, true);
     508                 :            : 
     509                 :          3 :         free_dif_verify_bufs(task);
     510                 :          3 : }
     511                 :            : 
     512                 :            : static void
     513                 :          3 : accel_dif_verify_op_apptag_incorrect_apptag_check(void)
     514                 :            : {
     515                 :          1 :         struct spdk_dif_ctx_init_ext_opts dif_opts;
     516                 :          1 :         struct accel_dif_request req;
     517                 :          3 :         struct dif_task *task = &g_dif_task;
     518                 :            :         int rc;
     519                 :            : 
     520                 :          3 :         rc = alloc_dif_verify_bufs(task, 1);
     521         [ -  + ]:          3 :         SPDK_CU_ASSERT_FATAL(rc == 0);
     522                 :            : 
     523                 :          3 :         dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
     524                 :          3 :         dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16;
     525                 :            : 
     526                 :          3 :         rc = spdk_dif_ctx_init(&task->dif_ctx,
     527                 :          3 :                                g_block_size_bytes + g_md_size_bytes,
     528                 :            :                                g_md_size_bytes, true, true,
     529                 :            :                                SPDK_DIF_TYPE1,
     530                 :            :                                SPDK_DIF_FLAGS_APPTAG_CHECK,
     531                 :            :                                10, 0xFFFF, 20, 0, 0, &dif_opts);
     532         [ -  + ]:          3 :         SPDK_CU_ASSERT_FATAL(rc == 0);
     533                 :            : 
     534                 :          3 :         rc = spdk_dif_generate(task->src_iovs, task->src_iovcnt, task->num_blocks, &task->dif_ctx);
     535         [ -  + ]:          3 :         SPDK_CU_ASSERT_FATAL(rc == 0);
     536                 :            : 
     537                 :          3 :         rc = spdk_dif_ctx_init(&task->dif_ctx,
     538                 :          3 :                                g_block_size_bytes + g_md_size_bytes,
     539                 :            :                                g_md_size_bytes, true, true,
     540                 :            :                                SPDK_DIF_TYPE1,
     541                 :            :                                SPDK_DIF_FLAGS_APPTAG_CHECK,
     542                 :            :                                30, 0xFFFF, 40, 0, 0, &dif_opts);
     543         [ -  + ]:          3 :         SPDK_CU_ASSERT_FATAL(rc == 0);
     544                 :            : 
     545                 :          3 :         req.channel = g_channel;
     546                 :          3 :         req.src_iovs = task->src_iovs;
     547                 :          3 :         req.src_iovcnt = task->src_iovcnt;
     548                 :          3 :         req.num_blocks = task->num_blocks;
     549                 :          3 :         req.ctx = &task->dif_ctx;
     550                 :          3 :         req.err = &task->dif_err;
     551                 :          3 :         req.cb_fn = accel_dif_oper_done;
     552                 :          3 :         req.cb_arg = task;
     553                 :            : 
     554                 :          3 :         execute_spdk_function(accel_dif_verify_test, &req);
     555         [ -  + ]:          3 :         CU_ASSERT_EQUAL(g_completion_success, false);
     556                 :            : 
     557                 :          3 :         free_dif_verify_bufs(task);
     558                 :          3 : }
     559                 :            : 
     560                 :            : static void
     561                 :          6 : accel_dif_verify_op_tag_incorrect_no_check_or_ignore(uint32_t dif_flags)
     562                 :            : {
     563                 :          2 :         struct spdk_dif_ctx_init_ext_opts dif_opts;
     564                 :          2 :         struct accel_dif_request req;
     565                 :          6 :         struct dif_task *task = &g_dif_task;
     566                 :            :         int rc;
     567                 :            : 
     568                 :          6 :         rc = alloc_dif_verify_bufs(task, 1);
     569         [ -  + ]:          6 :         SPDK_CU_ASSERT_FATAL(rc == 0);
     570                 :            : 
     571                 :          6 :         dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
     572                 :          6 :         dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16;
     573                 :            : 
     574                 :            :         /* For set 'Application Tag F Detect' (Source DIF Flags)
     575                 :            :          * When all bits of the Application Tag field of the source Data Integrity Field
     576                 :            :          * are equal to 1, the Application Tag check is not done and the Guard field and
     577                 :            :          * Reference Tag field are ignored. */
     578                 :          6 :         rc = spdk_dif_ctx_init(&task->dif_ctx,
     579                 :          6 :                                g_block_size_bytes + g_md_size_bytes,
     580                 :            :                                g_md_size_bytes, true, true,
     581                 :            :                                SPDK_DIF_TYPE1,
     582                 :            :                                SPDK_DIF_FLAGS_GUARD_CHECK |
     583                 :            :                                SPDK_DIF_FLAGS_APPTAG_CHECK |
     584                 :            :                                SPDK_DIF_FLAGS_REFTAG_CHECK,
     585                 :            :                                10, 0xFFFF, 0xFFFF, 0, 0, &dif_opts);
     586         [ -  + ]:          6 :         SPDK_CU_ASSERT_FATAL(rc == 0);
     587                 :            : 
     588                 :          6 :         rc = spdk_dif_generate(task->src_iovs, task->src_iovcnt, task->num_blocks, &task->dif_ctx);
     589         [ -  + ]:          6 :         SPDK_CU_ASSERT_FATAL(rc == 0);
     590                 :            : 
     591                 :          6 :         rc = spdk_dif_ctx_init(&task->dif_ctx,
     592                 :          6 :                                g_block_size_bytes + g_md_size_bytes,
     593                 :            :                                g_md_size_bytes, true, true,
     594                 :            :                                SPDK_DIF_TYPE1,
     595                 :            :                                dif_flags,
     596                 :            :                                30, 0xFFFF, 40, 0, 0, &dif_opts);
     597         [ -  + ]:          6 :         SPDK_CU_ASSERT_FATAL(rc == 0);
     598                 :            : 
     599                 :          6 :         req.channel = g_channel;
     600                 :          6 :         req.src_iovs = task->src_iovs;
     601                 :          6 :         req.src_iovcnt = task->src_iovcnt;
     602                 :          6 :         req.num_blocks = task->num_blocks;
     603                 :          6 :         req.ctx = &task->dif_ctx;
     604                 :          6 :         req.err = &task->dif_err;
     605                 :          6 :         req.cb_fn = accel_dif_oper_done;
     606                 :          6 :         req.cb_arg = task;
     607                 :            : 
     608                 :          6 :         execute_spdk_function(accel_dif_verify_test, &req);
     609         [ -  + ]:          6 :         CU_ASSERT_EQUAL(g_completion_success, true);
     610                 :            : 
     611                 :          6 :         free_dif_verify_bufs(task);
     612                 :          6 : }
     613                 :            : 
     614                 :            : static void
     615                 :          3 : accel_dif_verify_op_apptag_incorrect_no_apptag_check(void)
     616                 :            : {
     617                 :          3 :         accel_dif_verify_op_tag_incorrect_no_check_or_ignore(SPDK_DIF_FLAGS_APPTAG_CHECK);
     618                 :          3 : }
     619                 :            : 
     620                 :            : static void
     621                 :          3 : accel_dif_verify_op_reftag_incorrect_reftag_ignore(void)
     622                 :            : {
     623                 :          3 :         accel_dif_verify_op_tag_incorrect_no_check_or_ignore(SPDK_DIF_FLAGS_REFTAG_CHECK);
     624                 :          3 : }
     625                 :            : 
     626                 :            : static void
     627                 :          3 : accel_dif_verify_op_reftag_init_correct_reftag_check(void)
     628                 :            : {
     629                 :          1 :         struct spdk_dif_ctx_init_ext_opts dif_opts;
     630                 :          1 :         struct accel_dif_request req;
     631                 :          3 :         struct dif_task *task = &g_dif_task;
     632                 :            :         int rc;
     633                 :            : 
     634                 :          3 :         rc = alloc_dif_verify_bufs(task, 2);
     635         [ -  + ]:          3 :         SPDK_CU_ASSERT_FATAL(rc == 0);
     636                 :            : 
     637                 :          3 :         dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
     638                 :          3 :         dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16;
     639                 :            : 
     640                 :          3 :         rc = spdk_dif_ctx_init(&task->dif_ctx,
     641                 :          3 :                                g_block_size_bytes + g_md_size_bytes,
     642                 :            :                                g_md_size_bytes, true, true,
     643                 :            :                                SPDK_DIF_TYPE1,
     644                 :            :                                SPDK_DIF_FLAGS_REFTAG_CHECK,
     645                 :            :                                10, 0xFFFF, 20, 0, 0, &dif_opts);
     646         [ -  + ]:          3 :         SPDK_CU_ASSERT_FATAL(rc == 0);
     647                 :            : 
     648                 :          3 :         rc = spdk_dif_generate(task->src_iovs, task->src_iovcnt, task->num_blocks, &task->dif_ctx);
     649         [ -  + ]:          3 :         SPDK_CU_ASSERT_FATAL(rc == 0);
     650                 :            : 
     651                 :          3 :         req.channel = g_channel;
     652                 :          3 :         req.src_iovs = task->src_iovs;
     653                 :          3 :         req.src_iovcnt = task->src_iovcnt;
     654                 :          3 :         req.num_blocks = task->num_blocks;
     655                 :          3 :         req.ctx = &task->dif_ctx;
     656                 :          3 :         req.err = &task->dif_err;
     657                 :          3 :         req.cb_fn = accel_dif_oper_done;
     658                 :          3 :         req.cb_arg = task;
     659                 :            : 
     660                 :          3 :         execute_spdk_function(accel_dif_verify_test, &req);
     661         [ -  + ]:          3 :         CU_ASSERT_EQUAL(g_completion_success, true);
     662                 :            : 
     663                 :          3 :         free_dif_verify_bufs(task);
     664                 :          3 : }
     665                 :            : 
     666                 :            : static void
     667                 :          3 : accel_dif_verify_op_reftag_init_incorrect_reftag_check(void)
     668                 :            : {
     669                 :          1 :         struct spdk_dif_ctx_init_ext_opts dif_opts;
     670                 :          1 :         struct accel_dif_request req;
     671                 :          3 :         struct dif_task *task = &g_dif_task;
     672                 :            :         int rc;
     673                 :            : 
     674                 :          3 :         rc = alloc_dif_verify_bufs(task, 2);
     675         [ -  + ]:          3 :         SPDK_CU_ASSERT_FATAL(rc == 0);
     676                 :            : 
     677                 :          3 :         dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
     678                 :          3 :         dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16;
     679                 :            : 
     680                 :          3 :         rc = spdk_dif_ctx_init(&task->dif_ctx,
     681                 :          3 :                                g_block_size_bytes + g_md_size_bytes,
     682                 :            :                                g_md_size_bytes, true, true,
     683                 :            :                                SPDK_DIF_TYPE1,
     684                 :            :                                SPDK_DIF_FLAGS_REFTAG_CHECK,
     685                 :            :                                16, 0xFFFF, 20, 0, 0, &dif_opts);
     686         [ -  + ]:          3 :         SPDK_CU_ASSERT_FATAL(rc == 0);
     687                 :            : 
     688                 :          3 :         rc = spdk_dif_generate(task->src_iovs, task->src_iovcnt, task->num_blocks, &task->dif_ctx);
     689         [ -  + ]:          3 :         SPDK_CU_ASSERT_FATAL(rc == 0);
     690                 :            : 
     691                 :          3 :         rc = spdk_dif_ctx_init(&task->dif_ctx,
     692                 :          3 :                                g_block_size_bytes + g_md_size_bytes,
     693                 :            :                                g_md_size_bytes, true, true,
     694                 :            :                                SPDK_DIF_TYPE1,
     695                 :            :                                SPDK_DIF_FLAGS_REFTAG_CHECK,
     696                 :            :                                10, 0xFFFF, 20, 0, 0, &dif_opts);
     697         [ -  + ]:          3 :         SPDK_CU_ASSERT_FATAL(rc == 0);
     698                 :            : 
     699                 :          3 :         req.channel = g_channel;
     700                 :          3 :         req.src_iovs = task->src_iovs;
     701                 :          3 :         req.src_iovcnt = task->src_iovcnt;
     702                 :          3 :         req.num_blocks = task->num_blocks;
     703                 :          3 :         req.ctx = &task->dif_ctx;
     704                 :          3 :         req.err = &task->dif_err;
     705                 :          3 :         req.cb_fn = accel_dif_oper_done;
     706                 :          3 :         req.cb_arg = task;
     707                 :            : 
     708                 :          3 :         execute_spdk_function(accel_dif_verify_test, &req);
     709         [ -  + ]:          3 :         CU_ASSERT_EQUAL(g_completion_success, false);
     710                 :            : 
     711                 :          3 :         free_dif_verify_bufs(task);
     712                 :          3 : }
     713                 :            : 
     714                 :            : static void
     715                 :          9 : accel_dif_verify_copy_op_dif_generated_do_check(uint32_t dif_flags)
     716                 :            : {
     717                 :          3 :         struct spdk_dif_ctx_init_ext_opts dif_opts;
     718                 :          3 :         struct accel_dif_request req;
     719                 :          9 :         struct dif_task *task = &g_dif_task;
     720                 :            :         int rc;
     721                 :            : 
     722                 :          9 :         rc = alloc_dif_verify_copy_bufs(task, 1);
     723         [ -  + ]:          9 :         SPDK_CU_ASSERT_FATAL(rc == 0);
     724                 :            : 
     725                 :          9 :         dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
     726                 :          9 :         dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16;
     727                 :            : 
     728                 :          9 :         rc = spdk_dif_ctx_init(&task->dif_ctx,
     729                 :          9 :                                g_block_size_bytes + g_md_size_bytes,
     730                 :            :                                g_md_size_bytes, true, true,
     731                 :            :                                SPDK_DIF_TYPE1,
     732                 :            :                                SPDK_DIF_FLAGS_GUARD_CHECK |
     733                 :            :                                SPDK_DIF_FLAGS_APPTAG_CHECK |
     734                 :            :                                SPDK_DIF_FLAGS_REFTAG_CHECK,
     735                 :            :                                10, 0xFFFF, 20, 0, 0, &dif_opts);
     736         [ -  + ]:          9 :         SPDK_CU_ASSERT_FATAL(rc == 0);
     737                 :            : 
     738                 :          9 :         rc = spdk_dif_generate(task->src_iovs, task->src_iovcnt, task->num_blocks, &task->dif_ctx);
     739         [ -  + ]:          9 :         SPDK_CU_ASSERT_FATAL(rc == 0);
     740                 :            : 
     741                 :          9 :         rc = spdk_dif_ctx_init(&task->dif_ctx,
     742                 :          9 :                                g_block_size_bytes + g_md_size_bytes,
     743                 :            :                                g_md_size_bytes, true, true,
     744                 :            :                                SPDK_DIF_TYPE1,
     745                 :            :                                dif_flags,
     746                 :            :                                10, 0xFFFF, 20, 0, 0, &dif_opts);
     747         [ -  + ]:          9 :         SPDK_CU_ASSERT_FATAL(rc == 0);
     748                 :            : 
     749                 :          9 :         req.channel = g_channel;
     750                 :          9 :         req.dst_iovs = task->dst_iovs;
     751                 :          9 :         req.dst_iovcnt = task->dst_iovcnt;
     752                 :          9 :         req.src_iovs = task->src_iovs;
     753                 :          9 :         req.src_iovcnt = task->src_iovcnt;
     754                 :          9 :         req.num_blocks = task->num_blocks;
     755                 :          9 :         req.ctx = &task->dif_ctx;
     756                 :          9 :         req.err = &task->dif_err;
     757                 :          9 :         req.cb_fn = accel_dif_oper_done;
     758                 :          9 :         req.cb_arg = task;
     759                 :            : 
     760                 :          9 :         execute_spdk_function(accel_dif_verify_copy_test, &req);
     761         [ -  + ]:          9 :         CU_ASSERT_EQUAL(g_completion_success, true);
     762                 :            : 
     763                 :          9 :         free_dif_verify_copy_bufs(task);
     764                 :          9 : }
     765                 :            : 
     766                 :            : static void
     767                 :          3 : accel_dif_verify_copy_op_dif_generated_guard_check(void)
     768                 :            : {
     769                 :          3 :         accel_dif_verify_copy_op_dif_generated_do_check(SPDK_DIF_FLAGS_GUARD_CHECK);
     770                 :          3 : }
     771                 :            : 
     772                 :            : static void
     773                 :          3 : accel_dif_verify_copy_op_dif_generated_apptag_check(void)
     774                 :            : {
     775                 :          3 :         accel_dif_verify_copy_op_dif_generated_do_check(SPDK_DIF_FLAGS_APPTAG_CHECK);
     776                 :          3 : }
     777                 :            : 
     778                 :            : static void
     779                 :          3 : accel_dif_verify_copy_op_dif_generated_reftag_check(void)
     780                 :            : {
     781                 :          3 :         accel_dif_verify_copy_op_dif_generated_do_check(SPDK_DIF_FLAGS_REFTAG_CHECK);
     782                 :          3 : }
     783                 :            : 
     784                 :            : static void
     785                 :          9 : accel_dif_verify_copy_op_dif_not_generated_do_check(uint32_t dif_flags)
     786                 :            : {
     787                 :          3 :         struct spdk_dif_ctx_init_ext_opts dif_opts;
     788                 :          3 :         struct accel_dif_request req;
     789                 :          9 :         struct dif_task *task = &g_dif_task;
     790                 :            :         int rc;
     791                 :            : 
     792                 :          9 :         rc = alloc_dif_verify_copy_bufs(task, 1);
     793         [ -  + ]:          9 :         SPDK_CU_ASSERT_FATAL(rc == 0);
     794                 :            : 
     795                 :          9 :         dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
     796                 :          9 :         dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16;
     797                 :            : 
     798                 :          9 :         rc = spdk_dif_ctx_init(&task->dif_ctx,
     799                 :          9 :                                g_block_size_bytes + g_md_size_bytes,
     800                 :            :                                g_md_size_bytes, true, true,
     801                 :            :                                SPDK_DIF_TYPE1,
     802                 :            :                                dif_flags,
     803                 :            :                                10, 0xFFFF, 20, 0, 0, &dif_opts);
     804         [ -  + ]:          9 :         SPDK_CU_ASSERT_FATAL(rc == 0);
     805                 :            : 
     806                 :          9 :         req.channel = g_channel;
     807                 :          9 :         req.dst_iovs = task->dst_iovs;
     808                 :          9 :         req.dst_iovcnt = task->dst_iovcnt;
     809                 :          9 :         req.src_iovs = task->src_iovs;
     810                 :          9 :         req.src_iovcnt = task->src_iovcnt;
     811                 :          9 :         req.num_blocks = task->num_blocks;
     812                 :          9 :         req.ctx = &task->dif_ctx;
     813                 :          9 :         req.err = &task->dif_err;
     814                 :          9 :         req.cb_fn = accel_dif_oper_done;
     815                 :          9 :         req.cb_arg = task;
     816                 :            : 
     817                 :          9 :         execute_spdk_function(accel_dif_verify_copy_test, &req);
     818         [ -  + ]:          9 :         CU_ASSERT_EQUAL(g_completion_success, false);
     819                 :          9 :         CU_ASSERT_EQUAL(accel_dif_error_validate(dif_flags, req.err), true);
     820                 :            : 
     821                 :          9 :         free_dif_verify_copy_bufs(task);
     822                 :          9 : }
     823                 :            : 
     824                 :            : static void
     825                 :          3 : accel_dif_verify_copy_op_dif_not_generated_guard_check(void)
     826                 :            : {
     827                 :          3 :         accel_dif_verify_copy_op_dif_not_generated_do_check(SPDK_DIF_FLAGS_GUARD_CHECK);
     828                 :          3 : }
     829                 :            : 
     830                 :            : static void
     831                 :          3 : accel_dif_verify_copy_op_dif_not_generated_apptag_check(void)
     832                 :            : {
     833                 :          3 :         accel_dif_verify_copy_op_dif_not_generated_do_check(SPDK_DIF_FLAGS_APPTAG_CHECK);
     834                 :          3 : }
     835                 :            : 
     836                 :            : static void
     837                 :          3 : accel_dif_verify_copy_op_dif_not_generated_reftag_check(void)
     838                 :            : {
     839                 :          3 :         accel_dif_verify_copy_op_dif_not_generated_do_check(SPDK_DIF_FLAGS_REFTAG_CHECK);
     840                 :          3 : }
     841                 :            : 
     842                 :            : static void
     843                 :          9 : accel_dif_generate_copy_op_dif_generated_do_check(uint32_t dif_flags)
     844                 :            : {
     845                 :          3 :         struct spdk_dif_ctx_init_ext_opts dif_opts;
     846                 :          3 :         struct accel_dif_request req;
     847                 :          9 :         struct dif_task *task = &g_dif_task;
     848                 :          3 :         struct spdk_dif_error err_blk;
     849                 :            :         int rc;
     850                 :            : 
     851                 :          9 :         rc = alloc_dif_generate_copy_bufs(task, 1);
     852         [ -  + ]:          9 :         SPDK_CU_ASSERT_FATAL(rc == 0);
     853                 :            : 
     854                 :          9 :         dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
     855                 :          9 :         dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16;
     856                 :            : 
     857                 :          9 :         rc = spdk_dif_ctx_init(&task->dif_ctx,
     858                 :          9 :                                g_block_size_bytes + g_md_size_bytes,
     859                 :            :                                g_md_size_bytes, true, true,
     860                 :            :                                SPDK_DIF_TYPE1,
     861                 :            :                                SPDK_DIF_FLAGS_GUARD_CHECK |
     862                 :            :                                SPDK_DIF_FLAGS_APPTAG_CHECK |
     863                 :            :                                SPDK_DIF_FLAGS_REFTAG_CHECK,
     864                 :            :                                16, 0xFFFF, 10, 0, 0, &dif_opts);
     865         [ -  + ]:          9 :         SPDK_CU_ASSERT_FATAL(rc == 0);
     866                 :            : 
     867                 :          9 :         req.channel = g_channel;
     868                 :          9 :         req.dst_iovs = task->dst_iovs;
     869                 :          9 :         req.dst_iovcnt = task->dst_iovcnt;
     870                 :          9 :         req.src_iovs = task->src_iovs;
     871                 :          9 :         req.src_iovcnt = task->src_iovcnt;
     872                 :          9 :         req.num_blocks = task->num_blocks;
     873                 :          9 :         req.ctx = &task->dif_ctx;
     874                 :          9 :         req.err = &task->dif_err;
     875                 :          9 :         req.cb_fn = accel_dif_oper_done;
     876                 :          9 :         req.cb_arg = task;
     877                 :            : 
     878                 :          9 :         execute_spdk_function(accel_dif_generate_copy_test, &req);
     879         [ -  + ]:          9 :         CU_ASSERT_EQUAL(g_completion_success, true);
     880                 :            : 
     881                 :          9 :         rc = spdk_dif_ctx_init(&task->dif_ctx,
     882                 :          9 :                                g_block_size_bytes + g_md_size_bytes,
     883                 :            :                                g_md_size_bytes, true, true,
     884                 :            :                                SPDK_DIF_TYPE1,
     885                 :            :                                dif_flags,
     886                 :            :                                16, 0xFFFF, 10, 0, 0, &dif_opts);
     887         [ -  + ]:          9 :         SPDK_CU_ASSERT_FATAL(rc == 0);
     888                 :            : 
     889                 :          9 :         rc = spdk_dif_verify(req.dst_iovs, req.dst_iovcnt, req.num_blocks,
     890                 :          9 :                              &task->dif_ctx, &err_blk);
     891         [ -  + ]:          9 :         SPDK_CU_ASSERT_FATAL(rc == 0);
     892                 :            : 
     893                 :          9 :         free_dif_generate_copy_bufs(task);
     894                 :          9 : }
     895                 :            : 
     896                 :            : static void
     897                 :          3 : accel_dif_generate_copy_op_dif_generated_guard_check(void)
     898                 :            : {
     899                 :          3 :         accel_dif_generate_copy_op_dif_generated_do_check(SPDK_DIF_FLAGS_GUARD_CHECK);
     900                 :          3 : }
     901                 :            : 
     902                 :            : static void
     903                 :          3 : accel_dif_generate_copy_op_dif_generated_apptag_check(void)
     904                 :            : {
     905                 :          3 :         accel_dif_generate_copy_op_dif_generated_do_check(SPDK_DIF_FLAGS_APPTAG_CHECK);
     906                 :          3 : }
     907                 :            : 
     908                 :            : static void
     909                 :          3 : accel_dif_generate_copy_op_dif_generated_reftag_check(void)
     910                 :            : {
     911                 :          3 :         accel_dif_generate_copy_op_dif_generated_do_check(SPDK_DIF_FLAGS_REFTAG_CHECK);
     912                 :          3 : }
     913                 :            : 
     914                 :            : static void
     915                 :          3 : accel_dif_generate_copy_op_dif_generated_no_guard_check_flag_set(void)
     916                 :            : {
     917                 :          3 :         const char *module_name = NULL;
     918                 :          1 :         struct spdk_dif_ctx_init_ext_opts dif_opts;
     919                 :          1 :         struct accel_dif_request req;
     920                 :          3 :         struct dif_task *task = &g_dif_task;
     921                 :            :         int rc;
     922                 :            : 
     923                 :          3 :         rc = spdk_accel_get_opc_module_name(SPDK_ACCEL_OPC_DIF_GENERATE_COPY, &module_name);
     924         [ -  + ]:          3 :         SPDK_CU_ASSERT_FATAL(rc == 0);
     925                 :            : 
     926                 :          3 :         rc = alloc_dif_generate_copy_bufs(task, 1);
     927         [ -  + ]:          3 :         SPDK_CU_ASSERT_FATAL(rc == 0);
     928                 :            : 
     929                 :          3 :         dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
     930                 :          3 :         dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16;
     931                 :            : 
     932                 :          3 :         rc = spdk_dif_ctx_init(&task->dif_ctx,
     933                 :          3 :                                g_block_size_bytes + g_md_size_bytes,
     934                 :            :                                g_md_size_bytes, true, true,
     935                 :            :                                SPDK_DIF_TYPE1,
     936                 :            :                                SPDK_DIF_FLAGS_APPTAG_CHECK |
     937                 :            :                                SPDK_DIF_FLAGS_REFTAG_CHECK,
     938                 :            :                                16, 0xFFFF, 10, 0, 0, &dif_opts);
     939         [ -  + ]:          3 :         SPDK_CU_ASSERT_FATAL(rc == 0);
     940                 :            : 
     941                 :          3 :         req.channel = g_channel;
     942                 :          3 :         req.dst_iovs = task->dst_iovs;
     943                 :          3 :         req.dst_iovcnt = task->dst_iovcnt;
     944                 :          3 :         req.src_iovs = task->src_iovs;
     945                 :          3 :         req.src_iovcnt = task->src_iovcnt;
     946                 :          3 :         req.num_blocks = task->num_blocks;
     947                 :          3 :         req.ctx = &task->dif_ctx;
     948                 :          3 :         req.err = &task->dif_err;
     949                 :          3 :         req.cb_fn = accel_dif_oper_done;
     950                 :          3 :         req.cb_arg = task;
     951                 :            : 
     952                 :          3 :         execute_spdk_function(accel_dif_generate_copy_test, &req);
     953                 :            : 
     954                 :            :         /* Intel DSA does not allow for selective DIF fields generation */
     955   [ -  +  -  + ]:          3 :         if (!strcmp(module_name, "dsa")) {
     956         [ #  # ]:          0 :                 CU_ASSERT_EQUAL(g_completion_success, false);
     957   [ -  +  +  - ]:          3 :         } else if (!strcmp(module_name, "software")) {
     958         [ -  + ]:          3 :                 CU_ASSERT_EQUAL(g_completion_success, true);
     959                 :            :         } else {
     960         [ #  # ]:          0 :                 SPDK_CU_ASSERT_FATAL(false);
     961                 :            :         }
     962                 :            : 
     963                 :          3 :         free_dif_generate_copy_bufs(task);
     964                 :          3 : }
     965                 :            : 
     966                 :            : static void
     967                 :          3 : accel_dif_generate_copy_op_dif_generated_no_apptag_check_flag_set(void)
     968                 :            : {
     969                 :          3 :         const char *module_name = NULL;
     970                 :          1 :         struct spdk_dif_ctx_init_ext_opts dif_opts;
     971                 :          1 :         struct accel_dif_request req;
     972                 :          3 :         struct dif_task *task = &g_dif_task;
     973                 :            :         int rc;
     974                 :            : 
     975                 :          3 :         rc = spdk_accel_get_opc_module_name(SPDK_ACCEL_OPC_DIF_GENERATE_COPY, &module_name);
     976         [ -  + ]:          3 :         SPDK_CU_ASSERT_FATAL(rc == 0);
     977                 :            : 
     978                 :          3 :         rc = alloc_dif_generate_copy_bufs(task, 1);
     979         [ -  + ]:          3 :         SPDK_CU_ASSERT_FATAL(rc == 0);
     980                 :            : 
     981                 :          3 :         dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
     982                 :          3 :         dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16;
     983                 :            : 
     984                 :          3 :         rc = spdk_dif_ctx_init(&task->dif_ctx,
     985                 :          3 :                                g_block_size_bytes + g_md_size_bytes,
     986                 :            :                                g_md_size_bytes, true, true,
     987                 :            :                                SPDK_DIF_TYPE1,
     988                 :            :                                SPDK_DIF_FLAGS_GUARD_CHECK |
     989                 :            :                                SPDK_DIF_FLAGS_REFTAG_CHECK,
     990                 :            :                                16, 0xFFFF, 10, 0, 0, &dif_opts);
     991         [ -  + ]:          3 :         SPDK_CU_ASSERT_FATAL(rc == 0);
     992                 :            : 
     993                 :          3 :         req.channel = g_channel;
     994                 :          3 :         req.dst_iovs = task->dst_iovs;
     995                 :          3 :         req.dst_iovcnt = task->dst_iovcnt;
     996                 :          3 :         req.src_iovs = task->src_iovs;
     997                 :          3 :         req.src_iovcnt = task->src_iovcnt;
     998                 :          3 :         req.num_blocks = task->num_blocks;
     999                 :          3 :         req.ctx = &task->dif_ctx;
    1000                 :          3 :         req.err = &task->dif_err;
    1001                 :          3 :         req.cb_fn = accel_dif_oper_done;
    1002                 :          3 :         req.cb_arg = task;
    1003                 :            : 
    1004                 :          3 :         execute_spdk_function(accel_dif_generate_copy_test, &req);
    1005                 :            : 
    1006                 :            :         /* Intel DSA does not allow for selective DIF fields generation */
    1007   [ -  +  -  + ]:          3 :         if (!strcmp(module_name, "dsa")) {
    1008         [ #  # ]:          0 :                 CU_ASSERT_EQUAL(g_completion_success, false);
    1009   [ -  +  +  - ]:          3 :         } else if (!strcmp(module_name, "software")) {
    1010         [ -  + ]:          3 :                 CU_ASSERT_EQUAL(g_completion_success, true);
    1011                 :            :         } else {
    1012         [ #  # ]:          0 :                 SPDK_CU_ASSERT_FATAL(false);
    1013                 :            :         }
    1014                 :            : 
    1015                 :          3 :         free_dif_generate_copy_bufs(task);
    1016                 :          3 : }
    1017                 :            : 
    1018                 :            : static void
    1019                 :          3 : accel_dif_generate_copy_op_dif_generated_no_reftag_check_flag_set(void)
    1020                 :            : {
    1021                 :          3 :         const char *module_name = NULL;
    1022                 :          1 :         struct spdk_dif_ctx_init_ext_opts dif_opts;
    1023                 :          1 :         struct accel_dif_request req;
    1024                 :          3 :         struct dif_task *task = &g_dif_task;
    1025                 :            :         int rc;
    1026                 :            : 
    1027                 :          3 :         rc = spdk_accel_get_opc_module_name(SPDK_ACCEL_OPC_DIF_GENERATE_COPY, &module_name);
    1028         [ -  + ]:          3 :         SPDK_CU_ASSERT_FATAL(rc == 0);
    1029                 :            : 
    1030                 :          3 :         rc = alloc_dif_generate_copy_bufs(task, 1);
    1031         [ -  + ]:          3 :         SPDK_CU_ASSERT_FATAL(rc == 0);
    1032                 :            : 
    1033                 :          3 :         dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
    1034                 :          3 :         dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16;
    1035                 :            : 
    1036                 :          3 :         rc = spdk_dif_ctx_init(&task->dif_ctx,
    1037                 :          3 :                                g_block_size_bytes + g_md_size_bytes,
    1038                 :            :                                g_md_size_bytes, true, true,
    1039                 :            :                                SPDK_DIF_TYPE1,
    1040                 :            :                                SPDK_DIF_FLAGS_GUARD_CHECK |
    1041                 :            :                                SPDK_DIF_FLAGS_APPTAG_CHECK,
    1042                 :            :                                16, 0xFFFF, 10, 0, 0, &dif_opts);
    1043         [ -  + ]:          3 :         SPDK_CU_ASSERT_FATAL(rc == 0);
    1044                 :            : 
    1045                 :          3 :         req.channel = g_channel;
    1046                 :          3 :         req.dst_iovs = task->dst_iovs;
    1047                 :          3 :         req.dst_iovcnt = task->dst_iovcnt;
    1048                 :          3 :         req.src_iovs = task->src_iovs;
    1049                 :          3 :         req.src_iovcnt = task->src_iovcnt;
    1050                 :          3 :         req.num_blocks = task->num_blocks;
    1051                 :          3 :         req.ctx = &task->dif_ctx;
    1052                 :          3 :         req.err = &task->dif_err;
    1053                 :          3 :         req.cb_fn = accel_dif_oper_done;
    1054                 :          3 :         req.cb_arg = task;
    1055                 :            : 
    1056                 :          3 :         execute_spdk_function(accel_dif_generate_copy_test, &req);
    1057                 :            : 
    1058                 :            :         /* Intel DSA does not allow for selective DIF fields generation */
    1059   [ -  +  -  + ]:          3 :         if (!strcmp(module_name, "dsa")) {
    1060         [ #  # ]:          0 :                 CU_ASSERT_EQUAL(g_completion_success, false);
    1061   [ -  +  +  - ]:          3 :         } else if (!strcmp(module_name, "software")) {
    1062         [ -  + ]:          3 :                 CU_ASSERT_EQUAL(g_completion_success, true);
    1063                 :            :         } else {
    1064         [ #  # ]:          0 :                 SPDK_CU_ASSERT_FATAL(false);
    1065                 :            :         }
    1066                 :            : 
    1067                 :          3 :         free_dif_generate_copy_bufs(task);
    1068                 :          3 : }
    1069                 :            : 
    1070                 :            : static void
    1071                 :          3 : accel_dif_generate_copy_op_iovecs_len_validate(void)
    1072                 :            : {
    1073                 :          1 :         struct spdk_dif_ctx_init_ext_opts dif_opts;
    1074                 :          1 :         struct accel_dif_request req;
    1075                 :          3 :         struct dif_task *task = &g_dif_task;
    1076                 :            :         int rc;
    1077                 :            : 
    1078                 :          3 :         rc = alloc_dif_generate_copy_bufs(task, 1);
    1079         [ -  + ]:          3 :         SPDK_CU_ASSERT_FATAL(rc == 0);
    1080                 :            : 
    1081                 :          3 :         dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
    1082                 :          3 :         dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16;
    1083                 :            : 
    1084                 :          3 :         rc = spdk_dif_ctx_init(&task->dif_ctx,
    1085                 :          3 :                                g_block_size_bytes + g_md_size_bytes,
    1086                 :            :                                g_md_size_bytes, true, true,
    1087                 :            :                                SPDK_DIF_TYPE1,
    1088                 :            :                                SPDK_DIF_FLAGS_GUARD_CHECK |
    1089                 :            :                                SPDK_DIF_FLAGS_APPTAG_CHECK |
    1090                 :            :                                SPDK_DIF_FLAGS_REFTAG_CHECK,
    1091                 :            :                                16, 0xFFFF, 10, 0, 0, &dif_opts);
    1092         [ -  + ]:          3 :         SPDK_CU_ASSERT_FATAL(rc == 0);
    1093                 :            : 
    1094                 :          3 :         req.channel = g_channel;
    1095                 :          3 :         req.dst_iovs = task->dst_iovs;
    1096                 :            :         /* Make iov_len param incorrect */
    1097                 :          3 :         req.dst_iovs->iov_len += 16;
    1098                 :          3 :         req.dst_iovcnt = task->dst_iovcnt;
    1099                 :          3 :         req.src_iovs = task->src_iovs;
    1100                 :          3 :         req.src_iovcnt = task->src_iovcnt;
    1101                 :          3 :         req.num_blocks = task->num_blocks;
    1102                 :          3 :         req.ctx = &task->dif_ctx;
    1103                 :          3 :         req.err = &task->dif_err;
    1104                 :          3 :         req.cb_fn = accel_dif_oper_done;
    1105                 :          3 :         req.cb_arg = task;
    1106                 :            : 
    1107                 :          3 :         execute_spdk_function(accel_dif_generate_copy_test, &req);
    1108         [ -  + ]:          3 :         CU_ASSERT_EQUAL(g_completion_success, false);
    1109                 :            : 
    1110                 :          3 :         free_dif_generate_copy_bufs(task);
    1111                 :          3 : }
    1112                 :            : 
    1113                 :            : static void
    1114                 :          3 : accel_dif_generate_copy_op_buf_align_validate(void)
    1115                 :            : {
    1116                 :          1 :         struct spdk_dif_ctx_init_ext_opts dif_opts;
    1117                 :          1 :         struct accel_dif_request req;
    1118                 :          3 :         struct dif_task *task = &g_dif_task;
    1119                 :            :         int rc;
    1120                 :            : 
    1121                 :          3 :         rc = alloc_dif_generate_copy_bufs(task, 1);
    1122         [ -  + ]:          3 :         SPDK_CU_ASSERT_FATAL(rc == 0);
    1123                 :            : 
    1124                 :          3 :         dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
    1125                 :          3 :         dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16;
    1126                 :            : 
    1127                 :          3 :         rc = spdk_dif_ctx_init(&task->dif_ctx,
    1128                 :          3 :                                g_block_size_bytes + g_md_size_bytes,
    1129                 :            :                                g_md_size_bytes, true, true,
    1130                 :            :                                SPDK_DIF_TYPE1,
    1131                 :            :                                SPDK_DIF_FLAGS_GUARD_CHECK |
    1132                 :            :                                SPDK_DIF_FLAGS_APPTAG_CHECK |
    1133                 :            :                                SPDK_DIF_FLAGS_REFTAG_CHECK,
    1134                 :            :                                16, 0xFFFF, 10, 0, 0, &dif_opts);
    1135         [ -  + ]:          3 :         SPDK_CU_ASSERT_FATAL(rc == 0);
    1136                 :            : 
    1137                 :          3 :         req.channel = g_channel;
    1138                 :          3 :         req.dst_iovs = task->dst_iovs;
    1139                 :          3 :         req.dst_iovcnt = task->dst_iovcnt;
    1140                 :          3 :         req.src_iovs = task->src_iovs;
    1141                 :          3 :         req.src_iovcnt = task->src_iovcnt;
    1142                 :          3 :         req.num_blocks = task->num_blocks;
    1143                 :          3 :         req.ctx = &task->dif_ctx;
    1144                 :          3 :         req.err = &task->dif_err;
    1145                 :          3 :         req.cb_fn = accel_dif_oper_done;
    1146                 :          3 :         req.cb_arg = task;
    1147                 :            : 
    1148                 :          3 :         execute_spdk_function(accel_dif_generate_copy_test, &req);
    1149         [ -  + ]:          3 :         CU_ASSERT_EQUAL(g_completion_success, true);
    1150                 :            : 
    1151                 :          3 :         free_dif_generate_copy_bufs(task);
    1152                 :          3 : }
    1153                 :            : 
    1154                 :            : static void
    1155                 :          3 : _stop_init_thread(void *arg)
    1156                 :            : {
    1157                 :          3 :         unsigned num_failures = g_num_failures;
    1158                 :            : 
    1159                 :          3 :         g_num_failures = 0;
    1160                 :            : 
    1161         [ -  + ]:          3 :         assert(spdk_get_thread() == g_thread[WORKER_UT]);
    1162         [ -  + ]:          3 :         assert(spdk_thread_is_app_thread(NULL));
    1163                 :          3 :         execute_spdk_function(exit_io_thread, NULL);
    1164                 :          3 :         spdk_app_stop(num_failures);
    1165                 :          3 : }
    1166                 :            : 
    1167                 :            : static void
    1168                 :          3 : stop_init_thread(unsigned num_failures, struct spdk_jsonrpc_request *request)
    1169                 :            : {
    1170                 :          3 :         g_num_failures = num_failures;
    1171                 :            : 
    1172                 :          3 :         spdk_thread_send_msg(g_thread[WORKER_UT], _stop_init_thread, request);
    1173                 :          3 : }
    1174                 :            : 
    1175                 :            : static int
    1176                 :          3 : setup_accel_tests(void)
    1177                 :            : {
    1178                 :          3 :         unsigned rc = 0;
    1179                 :          3 :         CU_pSuite suite = NULL;
    1180                 :            : 
    1181                 :          3 :         suite = CU_add_suite("accel_dif", NULL, NULL);
    1182         [ -  + ]:          3 :         if (suite == NULL) {
    1183                 :          0 :                 CU_cleanup_registry();
    1184                 :          0 :                 rc = CU_get_error();
    1185                 :          0 :                 return -rc;
    1186                 :            :         }
    1187                 :            : 
    1188         [ +  - ]:          3 :         if (CU_add_test(suite, "verify: DIF generated, GUARD check",
    1189         [ +  - ]:          3 :                         accel_dif_verify_op_dif_generated_guard_check) == NULL ||
    1190                 :          3 :             CU_add_test(suite, "verify: DIF generated, APPTAG check",
    1191         [ +  - ]:          3 :                         accel_dif_verify_op_dif_generated_apptag_check) == NULL ||
    1192                 :          3 :             CU_add_test(suite, "verify: DIF generated, REFTAG check",
    1193         [ +  - ]:          3 :                         accel_dif_verify_op_dif_generated_reftag_check) == NULL ||
    1194                 :            : 
    1195                 :          3 :             CU_add_test(suite, "verify: DIF not generated, GUARD check",
    1196         [ +  - ]:          3 :                         accel_dif_verify_op_dif_not_generated_guard_check) == NULL ||
    1197                 :          3 :             CU_add_test(suite, "verify: DIF not generated, APPTAG check",
    1198         [ +  - ]:          3 :                         accel_dif_verify_op_dif_not_generated_apptag_check) == NULL ||
    1199                 :          3 :             CU_add_test(suite, "verify: DIF not generated, REFTAG check",
    1200         [ +  - ]:          3 :                         accel_dif_verify_op_dif_not_generated_reftag_check) == NULL ||
    1201                 :            : 
    1202                 :          3 :             CU_add_test(suite, "verify: APPTAG correct, APPTAG check",
    1203         [ +  - ]:          3 :                         accel_dif_verify_op_apptag_correct_apptag_check) == NULL ||
    1204                 :          3 :             CU_add_test(suite, "verify: APPTAG incorrect, APPTAG check",
    1205         [ +  - ]:          3 :                         accel_dif_verify_op_apptag_incorrect_apptag_check) == NULL ||
    1206                 :          3 :             CU_add_test(suite, "verify: APPTAG incorrect, no APPTAG check",
    1207         [ +  - ]:          3 :                         accel_dif_verify_op_apptag_incorrect_no_apptag_check) == NULL ||
    1208                 :          3 :             CU_add_test(suite, "verify: REFTAG incorrect, REFTAG ignore",
    1209         [ +  - ]:          3 :                         accel_dif_verify_op_reftag_incorrect_reftag_ignore) == NULL ||
    1210                 :            : 
    1211                 :          3 :             CU_add_test(suite, "verify: REFTAG_INIT correct, REFTAG check",
    1212         [ +  - ]:          3 :                         accel_dif_verify_op_reftag_init_correct_reftag_check) == NULL ||
    1213                 :          3 :             CU_add_test(suite, "verify: REFTAG_INIT incorrect, REFTAG check",
    1214         [ +  - ]:          3 :                         accel_dif_verify_op_reftag_init_incorrect_reftag_check) == NULL ||
    1215                 :            : 
    1216                 :          3 :             CU_add_test(suite, "verify copy: DIF generated, GUARD check",
    1217         [ +  - ]:          3 :                         accel_dif_verify_copy_op_dif_generated_guard_check) == NULL ||
    1218                 :          3 :             CU_add_test(suite, "verify copy: DIF generated, APPTAG check",
    1219         [ +  - ]:          3 :                         accel_dif_verify_copy_op_dif_generated_apptag_check) == NULL ||
    1220                 :          3 :             CU_add_test(suite, "verify copy: DIF generated, REFTAG check",
    1221         [ +  - ]:          3 :                         accel_dif_verify_copy_op_dif_generated_reftag_check) == NULL ||
    1222                 :            : 
    1223                 :          3 :             CU_add_test(suite, "verify copy: DIF not generated, GUARD check",
    1224         [ +  - ]:          3 :                         accel_dif_verify_copy_op_dif_not_generated_guard_check) == NULL ||
    1225                 :          3 :             CU_add_test(suite, "verify copy: DIF not generated, APPTAG check",
    1226         [ +  - ]:          3 :                         accel_dif_verify_copy_op_dif_not_generated_apptag_check) == NULL ||
    1227                 :          3 :             CU_add_test(suite, "verify copy: DIF not generated, REFTAG check",
    1228         [ +  - ]:          3 :                         accel_dif_verify_copy_op_dif_not_generated_reftag_check) == NULL ||
    1229                 :            : 
    1230                 :          3 :             CU_add_test(suite, "generate copy: DIF generated, GUARD check",
    1231         [ +  - ]:          3 :                         accel_dif_generate_copy_op_dif_generated_guard_check) == NULL ||
    1232                 :          3 :             CU_add_test(suite, "generate copy: DIF generated, APTTAG check",
    1233         [ +  - ]:          3 :                         accel_dif_generate_copy_op_dif_generated_apptag_check) == NULL ||
    1234                 :          3 :             CU_add_test(suite, "generate copy: DIF generated, REFTAG check",
    1235         [ +  - ]:          3 :                         accel_dif_generate_copy_op_dif_generated_reftag_check) == NULL ||
    1236                 :            : 
    1237                 :          3 :             CU_add_test(suite, "generate copy: DIF generated, no GUARD check flag set",
    1238         [ +  - ]:          3 :                         accel_dif_generate_copy_op_dif_generated_no_guard_check_flag_set) == NULL ||
    1239                 :          3 :             CU_add_test(suite, "generate copy: DIF generated, no APPTAG check flag set",
    1240         [ +  - ]:          3 :                         accel_dif_generate_copy_op_dif_generated_no_apptag_check_flag_set) == NULL ||
    1241                 :          3 :             CU_add_test(suite, "generate copy: DIF generated, no REFTAG check flag set",
    1242         [ +  - ]:          3 :                         accel_dif_generate_copy_op_dif_generated_no_reftag_check_flag_set) == NULL ||
    1243                 :            : 
    1244                 :          3 :             CU_add_test(suite, "generate copy: iovecs-len validate",
    1245         [ -  + ]:          3 :                         accel_dif_generate_copy_op_iovecs_len_validate) == NULL ||
    1246                 :          3 :             CU_add_test(suite, "generate copy: buffer alignment validate",
    1247                 :            :                         accel_dif_generate_copy_op_buf_align_validate) == NULL) {
    1248                 :          0 :                 CU_cleanup_registry();
    1249                 :          0 :                 rc = CU_get_error();
    1250                 :          0 :                 return -rc;
    1251                 :            :         }
    1252                 :          3 :         return 0;
    1253                 :            : }
    1254                 :            : 
    1255                 :            : static void
    1256                 :          3 : get_io_channel(void *arg)
    1257                 :            : {
    1258                 :          3 :         g_channel = spdk_accel_get_io_channel();
    1259         [ -  + ]:          3 :         assert(g_channel);
    1260                 :          3 :         wake_ut_thread();
    1261                 :          3 : }
    1262                 :            : 
    1263                 :            : static void
    1264                 :          3 : put_io_channel(void *arg)
    1265                 :            : {
    1266         [ -  + ]:          3 :         assert(g_channel);
    1267                 :          3 :         spdk_put_io_channel(g_channel);
    1268                 :          3 :         wake_ut_thread();
    1269                 :          3 : }
    1270                 :            : 
    1271                 :            : static void
    1272                 :          3 : run_accel_test_thread(void *arg)
    1273                 :            : {
    1274                 :          3 :         struct spdk_jsonrpc_request *request = arg;
    1275                 :          3 :         int rc = 0;
    1276                 :            : 
    1277                 :          3 :         execute_spdk_function(get_io_channel, NULL);
    1278         [ -  + ]:          3 :         if (g_channel == NULL) {
    1279   [ #  #  #  # ]:          0 :                 fprintf(stderr, "Unable to get an accel channel\n");
    1280                 :          0 :                 goto ret;
    1281                 :            :         }
    1282                 :            : 
    1283         [ -  + ]:          3 :         if (CU_initialize_registry() != CUE_SUCCESS) {
    1284                 :            :                 /* CUnit error, probably won't recover */
    1285                 :          0 :                 rc = CU_get_error();
    1286                 :          0 :                 rc = -rc;
    1287                 :          0 :                 goto ret;
    1288                 :            :         }
    1289                 :            : 
    1290                 :          3 :         rc = setup_accel_tests();
    1291         [ -  + ]:          3 :         if (rc < 0) {
    1292                 :            :                 /* CUnit error, probably won't recover */
    1293                 :          0 :                 rc = -rc;
    1294                 :          0 :                 goto ret;
    1295                 :            :         }
    1296                 :          3 :         CU_basic_set_mode(CU_BRM_VERBOSE);
    1297                 :          3 :         CU_basic_run_tests();
    1298                 :          3 :         rc = CU_get_number_of_failures();
    1299                 :          3 :         CU_cleanup_registry();
    1300                 :            : 
    1301                 :          3 : ret:
    1302         [ +  - ]:          3 :         if (g_channel != NULL) {
    1303                 :          3 :                 execute_spdk_function(put_io_channel, NULL);
    1304                 :            :         }
    1305                 :          3 :         stop_init_thread(rc, request);
    1306                 :          3 : }
    1307                 :            : 
    1308                 :            : static void
    1309                 :          3 : accel_dif_test_main(void *arg1)
    1310                 :            : {
    1311                 :          3 :         struct spdk_cpuset tmpmask = {};
    1312                 :            :         uint32_t i;
    1313                 :            : 
    1314         [ -  + ]:          3 :         pthread_mutex_init(&g_test_mutex, NULL);
    1315         [ -  + ]:          3 :         pthread_cond_init(&g_test_cond, NULL);
    1316                 :            : 
    1317                 :            :         /* This test runs specifically on at least two cores.
    1318                 :            :          * g_thread[WORKER_UT] is the app_thread on main core from event framework.
    1319                 :            :          * Next one is only for the tests and should always be on separate CPU cores. */
    1320         [ -  + ]:          3 :         if (spdk_env_get_core_count() < 3) {
    1321                 :          0 :                 spdk_app_stop(-1);
    1322                 :          0 :                 return;
    1323                 :            :         }
    1324                 :            : 
    1325         [ +  + ]:         12 :         SPDK_ENV_FOREACH_CORE(i) {
    1326         [ +  + ]:          9 :                 if (i == spdk_env_get_current_core()) {
    1327                 :          3 :                         g_thread[WORKER_UT] = spdk_get_thread();
    1328                 :          3 :                         continue;
    1329                 :            :                 }
    1330                 :          6 :                 spdk_cpuset_zero(&tmpmask);
    1331                 :          6 :                 spdk_cpuset_set_cpu(&tmpmask, i, true);
    1332         [ +  + ]:          6 :                 if (g_thread[WORKER_IO] == NULL) {
    1333                 :          3 :                         g_thread[WORKER_IO] = spdk_thread_create("io_thread", &tmpmask);
    1334                 :            :                 }
    1335                 :            : 
    1336                 :            :         }
    1337                 :            : 
    1338                 :          3 :         spdk_thread_send_msg(g_thread[WORKER_UT], run_accel_test_thread, NULL);
    1339                 :            : }
    1340                 :            : 
    1341                 :            : static void
    1342                 :          0 : accel_dif_usage(void)
    1343                 :            : {
    1344                 :          0 : }
    1345                 :            : 
    1346                 :            : static int
    1347                 :          0 : accel_dif_parse_arg(int ch, char *arg)
    1348                 :            : {
    1349                 :          0 :         return 0;
    1350                 :            : }
    1351                 :            : 
    1352                 :            : static void
    1353                 :          0 : spdk_dif_shutdown_cb(void)
    1354                 :            : {
    1355                 :          0 :         g_shutdown = true;
    1356                 :          0 :         spdk_thread_send_msg(g_thread[WORKER_UT], _stop_init_thread, NULL);
    1357                 :          0 : }
    1358                 :            : 
    1359                 :            : int
    1360                 :          3 : main(int argc, char **argv)
    1361                 :            : {
    1362                 :          3 :         struct spdk_app_opts opts = {};
    1363                 :          1 :         char reactor_mask[8];
    1364                 :            :         int rc;
    1365                 :            : 
    1366                 :          3 :         spdk_app_opts_init(&opts, sizeof(opts));
    1367                 :          3 :         opts.name = "DIF";
    1368         [ -  + ]:          3 :         snprintf(reactor_mask, sizeof(reactor_mask), "0x%x", (1 << (SPDK_COUNTOF(g_thread) + 1)) - 1);
    1369                 :          3 :         opts.reactor_mask = reactor_mask;
    1370                 :          3 :         opts.shutdown_cb = spdk_dif_shutdown_cb;
    1371                 :          3 :         opts.rpc_addr = NULL;
    1372                 :            : 
    1373         [ -  + ]:          3 :         if ((rc = spdk_app_parse_args(argc, argv, &opts, "", NULL,
    1374                 :            :                                       accel_dif_parse_arg, accel_dif_usage)) !=
    1375                 :            :             SPDK_APP_PARSE_ARGS_SUCCESS) {
    1376                 :          0 :                 return rc;
    1377                 :            :         }
    1378                 :            : 
    1379                 :          3 :         rc = spdk_app_start(&opts, accel_dif_test_main, NULL);
    1380                 :          3 :         spdk_app_fini();
    1381                 :            : 
    1382                 :          3 :         return rc;
    1383                 :            : }

Generated by: LCOV version 1.14