app/test/test_dmadev.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2021 HiSilicon Limited
   3  * Copyright(c) 2021 Intel Corporation
   4  */
   5
   6 #include <inttypes.h>
   7
   8 #include <rte_dmadev.h>
   9 #include <rte_mbuf.h>
  10 #include <rte_pause.h>
  11 #include <rte_cycles.h>
  12 #include <rte_random.h>
  13 #include <rte_bus_vdev.h>
  14 #include <rte_dmadev_pmd.h>
  15
  16 #include "test.h"
  17 #include "test_dmadev_api.h"
  18
  19 #define ERR_RETURN(...) do { print_err(__func__, __LINE__, __VA_ARGS__); return -1; } while (0)
  20
  21 #define COPY_LEN 1024
  22
  23 static struct rte_mempool *pool;
  24 static uint16_t id_count;
  25
  26 static void
  27 __rte_format_printf(3, 4)
  28 print_err(const char *func, int lineno, const char *format, ...)
  29 {
  30         va_list ap;
  31
  32         fprintf(stderr, "In %s:%d - ", func, lineno);
  33         va_start(ap, format);
  34         vfprintf(stderr, format, ap);
  35         va_end(ap);
  36 }
  37
  38 static int
  39 runtest(const char *printable, int (*test_fn)(int16_t dev_id, uint16_t vchan), int iterations,
  40                 int16_t dev_id, uint16_t vchan, bool check_err_stats)
  41 {
  42         struct rte_dma_stats stats;
  43         int i;
  44
  45         rte_dma_stats_reset(dev_id, vchan);
  46         printf("DMA Dev %d: Running %s Tests %s\n", dev_id, printable,
  47                         check_err_stats ? " " : "(errors expected)");
  48         for (i = 0; i < iterations; i++) {
  49                 if (test_fn(dev_id, vchan) < 0)
  50                         return -1;
  51
  52                 rte_dma_stats_get(dev_id, 0, &stats);
  53                 printf("Ops submitted: %"PRIu64"\t", stats.submitted);
  54                 printf("Ops completed: %"PRIu64"\t", stats.completed);
  55                 printf("Errors: %"PRIu64"\r", stats.errors);
  56
  57                 if (stats.completed != stats.submitted)
  58                         ERR_RETURN("\nError, not all submitted jobs are reported as completed\n");
  59                 if (check_err_stats && stats.errors != 0)
  60                         ERR_RETURN("\nErrors reported during op processing, aborting tests\n");
  61         }
  62         printf("\n");
  63         return 0;
  64 }
  65
  66 static void
  67 await_hw(int16_t dev_id, uint16_t vchan)
  68 {
  69         enum rte_dma_vchan_status st;
  70
  71         if (rte_dma_vchan_status(dev_id, vchan, &st) < 0) {
  72                 /* for drivers that don't support this op, just sleep for 1 millisecond */
  73                 rte_delay_us_sleep(1000);
  74                 return;
  75         }
  76
  77         /* for those that do, *max* end time is one second from now, but all should be faster */
  78         const uint64_t end_cycles = rte_get_timer_cycles() + rte_get_timer_hz();
  79         while (st == RTE_DMA_VCHAN_ACTIVE && rte_get_timer_cycles() < end_cycles) {
  80                 rte_pause();
  81                 rte_dma_vchan_status(dev_id, vchan, &st);
  82         }
  83 }
  84
  85 /* run a series of copy tests just using some different options for enqueues and completions */
  86 static int
  87 do_multi_copies(int16_t dev_id, uint16_t vchan,
  88                 int split_batches,     /* submit 2 x 16 or 1 x 32 burst */
  89                 int split_completions, /* gather 2 x 16 or 1 x 32 completions */
  90                 int use_completed_status) /* use completed or completed_status function */
  91 {
  92         struct rte_mbuf *srcs[32], *dsts[32];
  93         enum rte_dma_status_code sc[32];
  94         unsigned int i, j;
  95         bool dma_err = false;
  96
  97         /* Enqueue burst of copies and hit doorbell */
  98         for (i = 0; i < RTE_DIM(srcs); i++) {
  99                 uint64_t *src_data;
 100
 101                 if (split_batches && i == RTE_DIM(srcs) / 2)
 102                         rte_dma_submit(dev_id, vchan);
 103
 104                 srcs[i] = rte_pktmbuf_alloc(pool);
 105                 dsts[i] = rte_pktmbuf_alloc(pool);
 106                 if (srcs[i] == NULL || dsts[i] == NULL)
 107                         ERR_RETURN("Error allocating buffers\n");
 108
 109                 src_data = rte_pktmbuf_mtod(srcs[i], uint64_t *);
 110                 for (j = 0; j < COPY_LEN/sizeof(uint64_t); j++)
 111                         src_data[j] = rte_rand();
 112
 113                 if (rte_dma_copy(dev_id, vchan, srcs[i]->buf_iova + srcs[i]->data_off,
 114                                 dsts[i]->buf_iova + dsts[i]->data_off, COPY_LEN, 0) != id_count++)
 115                         ERR_RETURN("Error with rte_dma_copy for buffer %u\n", i);
 116         }
 117         rte_dma_submit(dev_id, vchan);
 118
 119         await_hw(dev_id, vchan);
 120
 121         if (split_completions) {
 122                 /* gather completions in two halves */
 123                 uint16_t half_len = RTE_DIM(srcs) / 2;
 124                 int ret = rte_dma_completed(dev_id, vchan, half_len, NULL, &dma_err);
 125                 if (ret != half_len || dma_err)
 126                         ERR_RETURN("Error with rte_dma_completed - first half. ret = %d, expected ret = %u, dma_err = %d\n",
 127                                         ret, half_len, dma_err);
 128
 129                 ret = rte_dma_completed(dev_id, vchan, half_len, NULL, &dma_err);
 130                 if (ret != half_len || dma_err)
 131                         ERR_RETURN("Error with rte_dma_completed - second half. ret = %d, expected ret = %u, dma_err = %d\n",
 132                                         ret, half_len, dma_err);
 133         } else {
 134                 /* gather all completions in one go, using either
 135                  * completed or completed_status fns
 136                  */
 137                 if (!use_completed_status) {
 138                         int n = rte_dma_completed(dev_id, vchan, RTE_DIM(srcs), NULL, &dma_err);
 139                         if (n != RTE_DIM(srcs) || dma_err)
 140                                 ERR_RETURN("Error with rte_dma_completed, %u [expected: %zu], dma_err = %d\n",
 141                                                 n, RTE_DIM(srcs), dma_err);
 142                 } else {
 143                         int n = rte_dma_completed_status(dev_id, vchan, RTE_DIM(srcs), NULL, sc);
 144                         if (n != RTE_DIM(srcs))
 145                                 ERR_RETURN("Error with rte_dma_completed_status, %u [expected: %zu]\n",
 146                                                 n, RTE_DIM(srcs));
 147
 148                         for (j = 0; j < (uint16_t)n; j++)
 149                                 if (sc[j] != RTE_DMA_STATUS_SUCCESSFUL)
 150                                         ERR_RETURN("Error with rte_dma_completed_status, job %u reports failure [code %u]\n",
 151                                                         j, sc[j]);
 152                 }
 153         }
 154
 155         /* check for empty */
 156         int ret = use_completed_status ?
 157                         rte_dma_completed_status(dev_id, vchan, RTE_DIM(srcs), NULL, sc) :
 158                         rte_dma_completed(dev_id, vchan, RTE_DIM(srcs), NULL, &dma_err);
 159         if (ret != 0)
 160                 ERR_RETURN("Error with completion check - ops unexpectedly returned\n");
 161
 162         for (i = 0; i < RTE_DIM(srcs); i++) {
 163                 char *src_data, *dst_data;
 164
 165                 src_data = rte_pktmbuf_mtod(srcs[i], char *);
 166                 dst_data = rte_pktmbuf_mtod(dsts[i], char *);
 167                 for (j = 0; j < COPY_LEN; j++)
 168                         if (src_data[j] != dst_data[j])
 169                                 ERR_RETURN("Error with copy of packet %u, byte %u\n", i, j);
 170
 171                 rte_pktmbuf_free(srcs[i]);
 172                 rte_pktmbuf_free(dsts[i]);
 173         }
 174         return 0;
 175 }
 176
 177 static int
 178 test_enqueue_copies(int16_t dev_id, uint16_t vchan)
 179 {
 180         enum rte_dma_status_code status;
 181         unsigned int i;
 182         uint16_t id;
 183
 184         /* test doing a single copy */
 185         do {
 186                 struct rte_mbuf *src, *dst;
 187                 char *src_data, *dst_data;
 188
 189                 src = rte_pktmbuf_alloc(pool);
 190                 dst = rte_pktmbuf_alloc(pool);
 191                 src_data = rte_pktmbuf_mtod(src, char *);
 192                 dst_data = rte_pktmbuf_mtod(dst, char *);
 193
 194                 for (i = 0; i < COPY_LEN; i++)
 195                         src_data[i] = rte_rand() & 0xFF;
 196
 197                 id = rte_dma_copy(dev_id, vchan, rte_pktmbuf_iova(src), rte_pktmbuf_iova(dst),
 198                                 COPY_LEN, RTE_DMA_OP_FLAG_SUBMIT);
 199                 if (id != id_count)
 200                         ERR_RETURN("Error with rte_dma_copy, got %u, expected %u\n",
 201                                         id, id_count);
 202
 203                 /* give time for copy to finish, then check it was done */
 204                 await_hw(dev_id, vchan);
 205
 206                 for (i = 0; i < COPY_LEN; i++)
 207                         if (dst_data[i] != src_data[i])
 208                                 ERR_RETURN("Data mismatch at char %u [Got %02x not %02x]\n", i,
 209                                                 dst_data[i], src_data[i]);
 210
 211                 /* now check completion works */
 212                 if (rte_dma_completed(dev_id, vchan, 1, &id, NULL) != 1)
 213                         ERR_RETURN("Error with rte_dma_completed\n");
 214
 215                 if (id != id_count)
 216                         ERR_RETURN("Error:incorrect job id received, %u [expected %u]\n",
 217                                         id, id_count);
 218
 219                 /* check for completed and id when no job done */
 220                 if (rte_dma_completed(dev_id, vchan, 1, &id, NULL) != 0)
 221                         ERR_RETURN("Error with rte_dma_completed when no job done\n");
 222                 if (id != id_count)
 223                         ERR_RETURN("Error:incorrect job id received when no job done, %u [expected %u]\n",
 224                                         id, id_count);
 225
 226                 /* check for completed_status and id when no job done */
 227                 if (rte_dma_completed_status(dev_id, vchan, 1, &id, &status) != 0)
 228                         ERR_RETURN("Error with rte_dma_completed_status when no job done\n");
 229                 if (id != id_count)
 230                         ERR_RETURN("Error:incorrect job id received when no job done, %u [expected %u]\n",
 231                                         id, id_count);
 232
 233                 rte_pktmbuf_free(src);
 234                 rte_pktmbuf_free(dst);
 235
 236                 /* now check completion returns nothing more */
 237                 if (rte_dma_completed(dev_id, 0, 1, NULL, NULL) != 0)
 238                         ERR_RETURN("Error with rte_dma_completed in empty check\n");
 239
 240                 id_count++;
 241
 242         } while (0);
 243
 244         /* test doing a multiple single copies */
 245         do {
 246                 const uint16_t max_ops = 4;
 247                 struct rte_mbuf *src, *dst;
 248                 char *src_data, *dst_data;
 249                 uint16_t count;
 250
 251                 src = rte_pktmbuf_alloc(pool);
 252                 dst = rte_pktmbuf_alloc(pool);
 253                 src_data = rte_pktmbuf_mtod(src, char *);
 254                 dst_data = rte_pktmbuf_mtod(dst, char *);
 255
 256                 for (i = 0; i < COPY_LEN; i++)
 257                         src_data[i] = rte_rand() & 0xFF;
 258
 259                 /* perform the same copy <max_ops> times */
 260                 for (i = 0; i < max_ops; i++)
 261                         if (rte_dma_copy(dev_id, vchan,
 262                                         rte_pktmbuf_iova(src),
 263                                         rte_pktmbuf_iova(dst),
 264                                         COPY_LEN, RTE_DMA_OP_FLAG_SUBMIT) != id_count++)
 265                                 ERR_RETURN("Error with rte_dma_copy\n");
 266
 267                 await_hw(dev_id, vchan);
 268
 269                 count = rte_dma_completed(dev_id, vchan, max_ops * 2, &id, NULL);
 270                 if (count != max_ops)
 271                         ERR_RETURN("Error with rte_dma_completed, got %u not %u\n",
 272                                         count, max_ops);
 273
 274                 if (id != id_count - 1)
 275                         ERR_RETURN("Error, incorrect job id returned: got %u not %u\n",
 276                                         id, id_count - 1);
 277
 278                 for (i = 0; i < COPY_LEN; i++)
 279                         if (dst_data[i] != src_data[i])
 280                                 ERR_RETURN("Data mismatch at char %u\n", i);
 281
 282                 rte_pktmbuf_free(src);
 283                 rte_pktmbuf_free(dst);
 284         } while (0);
 285
 286         /* test doing multiple copies */
 287         return do_multi_copies(dev_id, vchan, 0, 0, 0) /* enqueue and complete 1 batch at a time */
 288                         /* enqueue 2 batches and then complete both */
 289                         || do_multi_copies(dev_id, vchan, 1, 0, 0)
 290                         /* enqueue 1 batch, then complete in two halves */
 291                         || do_multi_copies(dev_id, vchan, 0, 1, 0)
 292                         /* test using completed_status in place of regular completed API */
 293                         || do_multi_copies(dev_id, vchan, 0, 0, 1);
 294 }
 295
 296 /* Failure handling test cases - global macros and variables for those tests*/
 297 #define COMP_BURST_SZ   16
 298 #define OPT_FENCE(idx) ((fence && idx == 8) ? RTE_DMA_OP_FLAG_FENCE : 0)
 299
 300 static int
 301 test_failure_in_full_burst(int16_t dev_id, uint16_t vchan, bool fence,
 302                 struct rte_mbuf **srcs, struct rte_mbuf **dsts, unsigned int fail_idx)
 303 {
 304         /* Test single full batch statuses with failures */
 305         enum rte_dma_status_code status[COMP_BURST_SZ];
 306         struct rte_dma_stats baseline, stats;
 307         uint16_t invalid_addr_id = 0;
 308         uint16_t idx;
 309         uint16_t count, status_count;
 310         unsigned int i;
 311         bool error = false;
 312         int err_count = 0;
 313
 314         rte_dma_stats_get(dev_id, vchan, &baseline); /* get a baseline set of stats */
 315         for (i = 0; i < COMP_BURST_SZ; i++) {
 316                 int id = rte_dma_copy(dev_id, vchan,
 317                                 (i == fail_idx ? 0 : (srcs[i]->buf_iova + srcs[i]->data_off)),
 318                                 dsts[i]->buf_iova + dsts[i]->data_off,
 319                                 COPY_LEN, OPT_FENCE(i));
 320                 if (id < 0)
 321                         ERR_RETURN("Error with rte_dma_copy for buffer %u\n", i);
 322                 if (i == fail_idx)
 323                         invalid_addr_id = id;
 324         }
 325         rte_dma_submit(dev_id, vchan);
 326         rte_dma_stats_get(dev_id, vchan, &stats);
 327         if (stats.submitted != baseline.submitted + COMP_BURST_SZ)
 328                 ERR_RETURN("Submitted stats value not as expected, %"PRIu64" not %"PRIu64"\n",
 329                                 stats.submitted, baseline.submitted + COMP_BURST_SZ);
 330
 331         await_hw(dev_id, vchan);
 332
 333         count = rte_dma_completed(dev_id, vchan, COMP_BURST_SZ, &idx, &error);
 334         if (count != fail_idx)
 335                 ERR_RETURN("Error with rte_dma_completed for failure test. Got returned %u not %u.\n",
 336                                 count, fail_idx);
 337         if (!error)
 338                 ERR_RETURN("Error, missing expected failed copy, %u. has_error is not set\n",
 339                                 fail_idx);
 340         if (idx != invalid_addr_id - 1)
 341                 ERR_RETURN("Error, missing expected failed copy, %u. Got last idx %u, not %u\n",
 342                                 fail_idx, idx, invalid_addr_id - 1);
 343
 344         /* all checks ok, now verify calling completed() again always returns 0 */
 345         for (i = 0; i < 10; i++)
 346                 if (rte_dma_completed(dev_id, vchan, COMP_BURST_SZ, &idx, &error) != 0
 347                                 || error == false || idx != (invalid_addr_id - 1))
 348                         ERR_RETURN("Error with follow-up completed calls for fail idx %u\n",
 349                                         fail_idx);
 350
 351         status_count = rte_dma_completed_status(dev_id, vchan, COMP_BURST_SZ,
 352                         &idx, status);
 353         /* some HW may stop on error and be restarted after getting error status for single value
 354          * To handle this case, if we get just one error back, wait for more completions and get
 355          * status for rest of the burst
 356          */
 357         if (status_count == 1) {
 358                 await_hw(dev_id, vchan);
 359                 status_count += rte_dma_completed_status(dev_id, vchan, COMP_BURST_SZ - 1,
 360                                         &idx, &status[1]);
 361         }
 362         /* check that at this point we have all status values */
 363         if (status_count != COMP_BURST_SZ - count)
 364                 ERR_RETURN("Error with completed_status calls for fail idx %u. Got %u not %u\n",
 365                                 fail_idx, status_count, COMP_BURST_SZ - count);
 366         /* now verify just one failure followed by multiple successful or skipped entries */
 367         if (status[0] == RTE_DMA_STATUS_SUCCESSFUL)
 368                 ERR_RETURN("Error with status returned for fail idx %u. First status was not failure\n",
 369                                 fail_idx);
 370         for (i = 1; i < status_count; i++)
 371                 /* after a failure in a burst, depending on ordering/fencing,
 372                  * operations may be successful or skipped because of previous error.
 373                  */
 374                 if (status[i] != RTE_DMA_STATUS_SUCCESSFUL
 375                                 && status[i] != RTE_DMA_STATUS_NOT_ATTEMPTED)
 376                         ERR_RETURN("Error with status calls for fail idx %u. Status for job %u (of %u) is not successful\n",
 377                                         fail_idx, count + i, COMP_BURST_SZ);
 378
 379         /* check the completed + errors stats are as expected */
 380         rte_dma_stats_get(dev_id, vchan, &stats);
 381         if (stats.completed != baseline.completed + COMP_BURST_SZ)
 382                 ERR_RETURN("Completed stats value not as expected, %"PRIu64" not %"PRIu64"\n",
 383                                 stats.completed, baseline.completed + COMP_BURST_SZ);
 384         for (i = 0; i < status_count; i++)
 385                 err_count += (status[i] != RTE_DMA_STATUS_SUCCESSFUL);
 386         if (stats.errors != baseline.errors + err_count)
 387                 ERR_RETURN("'Errors' stats value not as expected, %"PRIu64" not %"PRIu64"\n",
 388                                 stats.errors, baseline.errors + err_count);
 389
 390         return 0;
 391 }
 392
 393 static int
 394 test_individual_status_query_with_failure(int16_t dev_id, uint16_t vchan, bool fence,
 395                 struct rte_mbuf **srcs, struct rte_mbuf **dsts, unsigned int fail_idx)
 396 {
 397         /* Test gathering batch statuses one at a time */
 398         enum rte_dma_status_code status[COMP_BURST_SZ];
 399         uint16_t invalid_addr_id = 0;
 400         uint16_t idx;
 401         uint16_t count = 0, status_count = 0;
 402         unsigned int j;
 403         bool error = false;
 404
 405         for (j = 0; j < COMP_BURST_SZ; j++) {
 406                 int id = rte_dma_copy(dev_id, vchan,
 407                                 (j == fail_idx ? 0 : (srcs[j]->buf_iova + srcs[j]->data_off)),
 408                                 dsts[j]->buf_iova + dsts[j]->data_off,
 409                                 COPY_LEN, OPT_FENCE(j));
 410                 if (id < 0)
 411                         ERR_RETURN("Error with rte_dma_copy for buffer %u\n", j);
 412                 if (j == fail_idx)
 413                         invalid_addr_id = id;
 414         }
 415         rte_dma_submit(dev_id, vchan);
 416         await_hw(dev_id, vchan);
 417
 418         /* use regular "completed" until we hit error */
 419         while (!error) {
 420                 uint16_t n = rte_dma_completed(dev_id, vchan, 1, &idx, &error);
 421                 count += n;
 422                 if (n > 1 || count >= COMP_BURST_SZ)
 423                         ERR_RETURN("Error - too many completions got\n");
 424                 if (n == 0 && !error)
 425                         ERR_RETURN("Error, unexpectedly got zero completions after %u completed\n",
 426                                         count);
 427         }
 428         if (idx != invalid_addr_id - 1)
 429                 ERR_RETURN("Error, last successful index not as expected, got %u, expected %u\n",
 430                                 idx, invalid_addr_id - 1);
 431
 432         /* use completed_status until we hit end of burst */
 433         while (count + status_count < COMP_BURST_SZ) {
 434                 uint16_t n = rte_dma_completed_status(dev_id, vchan, 1, &idx,
 435                                 &status[status_count]);
 436                 await_hw(dev_id, vchan); /* allow delay to ensure jobs are completed */
 437                 status_count += n;
 438                 if (n != 1)
 439                         ERR_RETURN("Error: unexpected number of completions received, %u, not 1\n",
 440                                         n);
 441         }
 442
 443         /* check for single failure */
 444         if (status[0] == RTE_DMA_STATUS_SUCCESSFUL)
 445                 ERR_RETURN("Error, unexpected successful DMA transaction\n");
 446         for (j = 1; j < status_count; j++)
 447                 if (status[j] != RTE_DMA_STATUS_SUCCESSFUL
 448                                 && status[j] != RTE_DMA_STATUS_NOT_ATTEMPTED)
 449                         ERR_RETURN("Error, unexpected DMA error reported\n");
 450
 451         return 0;
 452 }
 453
 454 static int
 455 test_single_item_status_query_with_failure(int16_t dev_id, uint16_t vchan,
 456                 struct rte_mbuf **srcs, struct rte_mbuf **dsts, unsigned int fail_idx)
 457 {
 458         /* When error occurs just collect a single error using "completed_status()"
 459          * before going to back to completed() calls
 460          */
 461         enum rte_dma_status_code status;
 462         uint16_t invalid_addr_id = 0;
 463         uint16_t idx;
 464         uint16_t count, status_count, count2;
 465         unsigned int j;
 466         bool error = false;
 467
 468         for (j = 0; j < COMP_BURST_SZ; j++) {
 469                 int id = rte_dma_copy(dev_id, vchan,
 470                                 (j == fail_idx ? 0 : (srcs[j]->buf_iova + srcs[j]->data_off)),
 471                                 dsts[j]->buf_iova + dsts[j]->data_off,
 472                                 COPY_LEN, 0);
 473                 if (id < 0)
 474                         ERR_RETURN("Error with rte_dma_copy for buffer %u\n", j);
 475                 if (j == fail_idx)
 476                         invalid_addr_id = id;
 477         }
 478         rte_dma_submit(dev_id, vchan);
 479         await_hw(dev_id, vchan);
 480
 481         /* get up to the error point */
 482         count = rte_dma_completed(dev_id, vchan, COMP_BURST_SZ, &idx, &error);
 483         if (count != fail_idx)
 484                 ERR_RETURN("Error with rte_dma_completed for failure test. Got returned %u not %u.\n",
 485                                 count, fail_idx);
 486         if (!error)
 487                 ERR_RETURN("Error, missing expected failed copy, %u. has_error is not set\n",
 488                                 fail_idx);
 489         if (idx != invalid_addr_id - 1)
 490                 ERR_RETURN("Error, missing expected failed copy, %u. Got last idx %u, not %u\n",
 491                                 fail_idx, idx, invalid_addr_id - 1);
 492
 493         /* get the error code */
 494         status_count = rte_dma_completed_status(dev_id, vchan, 1, &idx, &status);
 495         if (status_count != 1)
 496                 ERR_RETURN("Error with completed_status calls for fail idx %u. Got %u not %u\n",
 497                                 fail_idx, status_count, COMP_BURST_SZ - count);
 498         if (status == RTE_DMA_STATUS_SUCCESSFUL)
 499                 ERR_RETURN("Error with status returned for fail idx %u. First status was not failure\n",
 500                                 fail_idx);
 501
 502         /* delay in case time needed after err handled to complete other jobs */
 503         await_hw(dev_id, vchan);
 504
 505         /* get the rest of the completions without status */
 506         count2 = rte_dma_completed(dev_id, vchan, COMP_BURST_SZ, &idx, &error);
 507         if (error == true)
 508                 ERR_RETURN("Error, got further errors post completed_status() call, for failure case %u.\n",
 509                                 fail_idx);
 510         if (count + status_count + count2 != COMP_BURST_SZ)
 511                 ERR_RETURN("Error, incorrect number of completions received, got %u not %u\n",
 512                                 count + status_count + count2, COMP_BURST_SZ);
 513
 514         return 0;
 515 }
 516
 517 static int
 518 test_multi_failure(int16_t dev_id, uint16_t vchan, struct rte_mbuf **srcs, struct rte_mbuf **dsts,
 519                 const unsigned int *fail, size_t num_fail)
 520 {
 521         /* test having multiple errors in one go */
 522         enum rte_dma_status_code status[COMP_BURST_SZ];
 523         unsigned int i, j;
 524         uint16_t count, err_count = 0;
 525         bool error = false;
 526
 527         /* enqueue and gather completions in one go */
 528         for (j = 0; j < COMP_BURST_SZ; j++) {
 529                 uintptr_t src = srcs[j]->buf_iova + srcs[j]->data_off;
 530                 /* set up for failure if the current index is anywhere is the fails array */
 531                 for (i = 0; i < num_fail; i++)
 532                         if (j == fail[i])
 533                                 src = 0;
 534
 535                 int id = rte_dma_copy(dev_id, vchan,
 536                                 src, dsts[j]->buf_iova + dsts[j]->data_off,
 537                                 COPY_LEN, 0);
 538                 if (id < 0)
 539                         ERR_RETURN("Error with rte_dma_copy for buffer %u\n", j);
 540         }
 541         rte_dma_submit(dev_id, vchan);
 542         await_hw(dev_id, vchan);
 543
 544         count = rte_dma_completed_status(dev_id, vchan, COMP_BURST_SZ, NULL, status);
 545         while (count < COMP_BURST_SZ) {
 546                 await_hw(dev_id, vchan);
 547
 548                 uint16_t ret = rte_dma_completed_status(dev_id, vchan, COMP_BURST_SZ - count,
 549                                 NULL, &status[count]);
 550                 if (ret == 0)
 551                         ERR_RETURN("Error getting all completions for jobs. Got %u of %u\n",
 552                                         count, COMP_BURST_SZ);
 553                 count += ret;
 554         }
 555         for (i = 0; i < count; i++)
 556                 if (status[i] != RTE_DMA_STATUS_SUCCESSFUL)
 557                         err_count++;
 558
 559         if (err_count != num_fail)
 560                 ERR_RETURN("Error: Invalid number of failed completions returned, %u; expected %zu\n",
 561                         err_count, num_fail);
 562
 563         /* enqueue and gather completions in bursts, but getting errors one at a time */
 564         for (j = 0; j < COMP_BURST_SZ; j++) {
 565                 uintptr_t src = srcs[j]->buf_iova + srcs[j]->data_off;
 566                 /* set up for failure if the current index is anywhere is the fails array */
 567                 for (i = 0; i < num_fail; i++)
 568                         if (j == fail[i])
 569                                 src = 0;
 570
 571                 int id = rte_dma_copy(dev_id, vchan,
 572                                 src, dsts[j]->buf_iova + dsts[j]->data_off,
 573                                 COPY_LEN, 0);
 574                 if (id < 0)
 575                         ERR_RETURN("Error with rte_dma_copy for buffer %u\n", j);
 576         }
 577         rte_dma_submit(dev_id, vchan);
 578         await_hw(dev_id, vchan);
 579
 580         count = 0;
 581         err_count = 0;
 582         while (count + err_count < COMP_BURST_SZ) {
 583                 count += rte_dma_completed(dev_id, vchan, COMP_BURST_SZ, NULL, &error);
 584                 if (error) {
 585                         uint16_t ret = rte_dma_completed_status(dev_id, vchan, 1,
 586                                         NULL, status);
 587                         if (ret != 1)
 588                                 ERR_RETURN("Error getting error-status for completions\n");
 589                         err_count += ret;
 590                         await_hw(dev_id, vchan);
 591                 }
 592         }
 593         if (err_count != num_fail)
 594                 ERR_RETURN("Error: Incorrect number of failed completions received, got %u not %zu\n",
 595                                 err_count, num_fail);
 596
 597         return 0;
 598 }
 599
 600 static int
 601 test_completion_status(int16_t dev_id, uint16_t vchan, bool fence)
 602 {
 603         const unsigned int fail[] = {0, 7, 14, 15};
 604         struct rte_mbuf *srcs[COMP_BURST_SZ], *dsts[COMP_BURST_SZ];
 605         unsigned int i;
 606
 607         for (i = 0; i < COMP_BURST_SZ; i++) {
 608                 srcs[i] = rte_pktmbuf_alloc(pool);
 609                 dsts[i] = rte_pktmbuf_alloc(pool);
 610         }
 611
 612         for (i = 0; i < RTE_DIM(fail); i++) {
 613                 if (test_failure_in_full_burst(dev_id, vchan, fence, srcs, dsts, fail[i]) < 0)
 614                         return -1;
 615
 616                 if (test_individual_status_query_with_failure(dev_id, vchan, fence,
 617                                 srcs, dsts, fail[i]) < 0)
 618                         return -1;
 619
 620                 /* test is run the same fenced, or unfenced, but no harm in running it twice */
 621                 if (test_single_item_status_query_with_failure(dev_id, vchan,
 622                                 srcs, dsts, fail[i]) < 0)
 623                         return -1;
 624         }
 625
 626         if (test_multi_failure(dev_id, vchan, srcs, dsts, fail, RTE_DIM(fail)) < 0)
 627                 return -1;
 628
 629         for (i = 0; i < COMP_BURST_SZ; i++) {
 630                 rte_pktmbuf_free(srcs[i]);
 631                 rte_pktmbuf_free(dsts[i]);
 632         }
 633         return 0;
 634 }
 635
 636 static int
 637 test_completion_handling(int16_t dev_id, uint16_t vchan)
 638 {
 639         return test_completion_status(dev_id, vchan, false)              /* without fences */
 640                         || test_completion_status(dev_id, vchan, true);  /* with fences */
 641 }
 642
 643 static int
 644 test_enqueue_fill(int16_t dev_id, uint16_t vchan)
 645 {
 646         const unsigned int lengths[] = {8, 64, 1024, 50, 100, 89};
 647         struct rte_mbuf *dst;
 648         char *dst_data;
 649         uint64_t pattern = 0xfedcba9876543210;
 650         unsigned int i, j;
 651
 652         dst = rte_pktmbuf_alloc(pool);
 653         if (dst == NULL)
 654                 ERR_RETURN("Failed to allocate mbuf\n");
 655         dst_data = rte_pktmbuf_mtod(dst, char *);
 656
 657         for (i = 0; i < RTE_DIM(lengths); i++) {
 658                 /* reset dst_data */
 659                 memset(dst_data, 0, rte_pktmbuf_data_len(dst));
 660
 661                 /* perform the fill operation */
 662                 int id = rte_dma_fill(dev_id, vchan, pattern,
 663                                 rte_pktmbuf_iova(dst), lengths[i], RTE_DMA_OP_FLAG_SUBMIT);
 664                 if (id < 0)
 665                         ERR_RETURN("Error with rte_dma_fill\n");
 666                 await_hw(dev_id, vchan);
 667
 668                 if (rte_dma_completed(dev_id, vchan, 1, NULL, NULL) != 1)
 669                         ERR_RETURN("Error: fill operation failed (length: %u)\n", lengths[i]);
 670                 /* check the data from the fill operation is correct */
 671                 for (j = 0; j < lengths[i]; j++) {
 672                         char pat_byte = ((char *)&pattern)[j % 8];
 673                         if (dst_data[j] != pat_byte)
 674                                 ERR_RETURN("Error with fill operation (lengths = %u): got (%x), not (%x)\n",
 675                                                 lengths[i], dst_data[j], pat_byte);
 676                 }
 677                 /* check that the data after the fill operation was not written to */
 678                 for (; j < rte_pktmbuf_data_len(dst); j++)
 679                         if (dst_data[j] != 0)
 680                                 ERR_RETURN("Error, fill operation wrote too far (lengths = %u): got (%x), not (%x)\n",
 681                                                 lengths[i], dst_data[j], 0);
 682         }
 683
 684         rte_pktmbuf_free(dst);
 685         return 0;
 686 }
 687
 688 static int
 689 test_burst_capacity(int16_t dev_id, uint16_t vchan)
 690 {
 691 #define CAP_TEST_BURST_SIZE     64
 692         const int ring_space = rte_dma_burst_capacity(dev_id, vchan);
 693         struct rte_mbuf *src, *dst;
 694         int i, j, iter;
 695         int cap, ret;
 696         bool dma_err;
 697
 698         src = rte_pktmbuf_alloc(pool);
 699         dst = rte_pktmbuf_alloc(pool);
 700
 701         /* to test capacity, we enqueue elements and check capacity is reduced
 702          * by one each time - rebaselining the expected value after each burst
 703          * as the capacity is only for a burst. We enqueue multiple bursts to
 704          * fill up half the ring, before emptying it again. We do this multiple
 705          * times to ensure that we get to test scenarios where we get ring
 706          * wrap-around and wrap-around of the ids returned (at UINT16_MAX).
 707          */
 708         for (iter = 0; iter < 2 * (((int)UINT16_MAX + 1) / ring_space); iter++) {
 709                 for (i = 0; i < (ring_space / (2 * CAP_TEST_BURST_SIZE)) + 1; i++) {
 710                         cap = rte_dma_burst_capacity(dev_id, vchan);
 711
 712                         for (j = 0; j < CAP_TEST_BURST_SIZE; j++) {
 713                                 ret = rte_dma_copy(dev_id, vchan, rte_pktmbuf_iova(src),
 714                                                 rte_pktmbuf_iova(dst), COPY_LEN, 0);
 715                                 if (ret < 0)
 716                                         ERR_RETURN("Error with rte_dmadev_copy\n");
 717
 718                                 if (rte_dma_burst_capacity(dev_id, vchan) != cap - (j + 1))
 719                                         ERR_RETURN("Error, ring capacity did not change as expected\n");
 720                         }
 721                         if (rte_dma_submit(dev_id, vchan) < 0)
 722                                 ERR_RETURN("Error, failed to submit burst\n");
 723
 724                         if (cap < rte_dma_burst_capacity(dev_id, vchan))
 725                                 ERR_RETURN("Error, avail ring capacity has gone up, not down\n");
 726                 }
 727                 await_hw(dev_id, vchan);
 728
 729                 for (i = 0; i < (ring_space / (2 * CAP_TEST_BURST_SIZE)) + 1; i++) {
 730                         ret = rte_dma_completed(dev_id, vchan,
 731                                         CAP_TEST_BURST_SIZE, NULL, &dma_err);
 732                         if (ret != CAP_TEST_BURST_SIZE || dma_err) {
 733                                 enum rte_dma_status_code status;
 734
 735                                 rte_dma_completed_status(dev_id, vchan, 1, NULL, &status);
 736                                 ERR_RETURN("Error with rte_dmadev_completed, %u [expected: %u], dma_err = %d, i = %u, iter = %u, status = %u\n",
 737                                                 ret, CAP_TEST_BURST_SIZE, dma_err, i, iter, status);
 738                         }
 739                 }
 740                 cap = rte_dma_burst_capacity(dev_id, vchan);
 741                 if (cap != ring_space)
 742                         ERR_RETURN("Error, ring capacity has not reset to original value, got %u, expected %u\n",
 743                                         cap, ring_space);
 744         }
 745
 746         rte_pktmbuf_free(src);
 747         rte_pktmbuf_free(dst);
 748
 749         return 0;
 750 }
 751
 752 static int
 753 test_dmadev_instance(int16_t dev_id)
 754 {
 755 #define TEST_RINGSIZE 512
 756 #define CHECK_ERRS    true
 757         struct rte_dma_stats stats;
 758         struct rte_dma_info info;
 759         const struct rte_dma_conf conf = { .nb_vchans = 1};
 760         const struct rte_dma_vchan_conf qconf = {
 761                         .direction = RTE_DMA_DIR_MEM_TO_MEM,
 762                         .nb_desc = TEST_RINGSIZE,
 763         };
 764         const int vchan = 0;
 765         int ret;
 766
 767         ret = rte_dma_info_get(dev_id, &info);
 768         if (ret != 0)
 769                 ERR_RETURN("Error with rte_dma_info_get()\n");
 770
 771         printf("\n### Test dmadev instance %u [%s]\n",
 772                         dev_id, info.dev_name);
 773
 774         if (info.max_vchans < 1)
 775                 ERR_RETURN("Error, no channels available on device id %u\n", dev_id);
 776
 777         if (rte_dma_configure(dev_id, &conf) != 0)
 778                 ERR_RETURN("Error with rte_dma_configure()\n");
 779
 780         if (rte_dma_vchan_setup(dev_id, vchan, &qconf) < 0)
 781                 ERR_RETURN("Error with queue configuration\n");
 782
 783         ret = rte_dma_info_get(dev_id, &info);
 784         if (ret != 0 || info.nb_vchans != 1)
 785                 ERR_RETURN("Error, no configured queues reported on device id %u\n", dev_id);
 786
 787         if (rte_dma_start(dev_id) != 0)
 788                 ERR_RETURN("Error with rte_dma_start()\n");
 789
 790         if (rte_dma_stats_get(dev_id, vchan, &stats) != 0)
 791                 ERR_RETURN("Error with rte_dma_stats_get()\n");
 792
 793         if (rte_dma_burst_capacity(dev_id, vchan) < 32)
 794                 ERR_RETURN("Error: Device does not have sufficient burst capacity to run tests");
 795
 796         if (stats.completed != 0 || stats.submitted != 0 || stats.errors != 0)
 797                 ERR_RETURN("Error device stats are not all zero: completed = %"PRIu64", "
 798                                 "submitted = %"PRIu64", errors = %"PRIu64"\n",
 799                                 stats.completed, stats.submitted, stats.errors);
 800         id_count = 0;
 801
 802         /* create a mempool for running tests */
 803         pool = rte_pktmbuf_pool_create("TEST_DMADEV_POOL",
 804                         TEST_RINGSIZE * 2, /* n == num elements */
 805                         32,  /* cache size */
 806                         0,   /* priv size */
 807                         2048, /* data room size */
 808                         info.numa_node);
 809         if (pool == NULL)
 810                 ERR_RETURN("Error with mempool creation\n");
 811
 812         /* run the test cases, use many iterations to ensure UINT16_MAX id wraparound */
 813         if (runtest("copy", test_enqueue_copies, 640, dev_id, vchan, CHECK_ERRS) < 0)
 814                 goto err;
 815
 816         /* run some burst capacity tests */
 817         if (rte_dma_burst_capacity(dev_id, vchan) < 64)
 818                 printf("DMA Dev %u: insufficient burst capacity (64 required), skipping tests\n",
 819                                 dev_id);
 820         else if (runtest("burst capacity", test_burst_capacity, 1, dev_id, vchan, CHECK_ERRS) < 0)
 821                 goto err;
 822
 823         /* to test error handling we can provide null pointers for source or dest in copies. This
 824          * requires VA mode in DPDK, since NULL(0) is a valid physical address.
 825          * We also need hardware that can report errors back.
 826          */
 827         if (rte_eal_iova_mode() != RTE_IOVA_VA)
 828                 printf("DMA Dev %u: DPDK not in VA mode, skipping error handling tests\n", dev_id);
 829         else if ((info.dev_capa & RTE_DMA_CAPA_HANDLES_ERRORS) == 0)
 830                 printf("DMA Dev %u: device does not report errors, skipping error handling tests\n",
 831                                 dev_id);
 832         else if (runtest("error handling", test_completion_handling, 1,
 833                         dev_id, vchan, !CHECK_ERRS) < 0)
 834                 goto err;
 835
 836         if ((info.dev_capa & RTE_DMA_CAPA_OPS_FILL) == 0)
 837                 printf("DMA Dev %u: No device fill support, skipping fill tests\n", dev_id);
 838         else if (runtest("fill", test_enqueue_fill, 1, dev_id, vchan, CHECK_ERRS) < 0)
 839                 goto err;
 840
 841         rte_mempool_free(pool);
 842         rte_dma_stop(dev_id);
 843         rte_dma_stats_reset(dev_id, vchan);
 844         return 0;
 845
 846 err:
 847         rte_mempool_free(pool);
 848         rte_dma_stop(dev_id);
 849         return -1;
 850 }
 851
 852 static int
 853 test_apis(void)
 854 {
 855         const char *pmd = "dma_skeleton";
 856         int id;
 857         int ret;
 858
 859         /* attempt to create skeleton instance - ignore errors due to one being already present */
 860         rte_vdev_init(pmd, NULL);
 861         id = rte_dma_get_dev_id_by_name(pmd);
 862         if (id < 0)
 863                 return TEST_SKIPPED;
 864         printf("\n### Test dmadev infrastructure using skeleton driver\n");
 865         ret = test_dma_api(id);
 866
 867         return ret;
 868 }
 869
 870 static int
 871 test_dma(void)
 872 {
 873         int i;
 874
 875         /* basic sanity on dmadev infrastructure */
 876         if (test_apis() < 0)
 877                 ERR_RETURN("Error performing API tests\n");
 878
 879         if (rte_dma_count_avail() == 0)
 880                 return TEST_SKIPPED;
 881
 882         RTE_DMA_FOREACH_DEV(i)
 883                 if (test_dmadev_instance(i) < 0)
 884                         ERR_RETURN("Error, test failure for device %d\n", i);
 885
 886         return 0;
 887 }
 888
 889 REGISTER_TEST_COMMAND(dmadev_autotest, test_dma);