drivers/event/opdl/opdl_test.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-3-Clause
   3  * Copyright(c) 2010-2014 Intel Corporation
   4  */
   5
   6 #include <stdio.h>
   7 #include <string.h>
   8 #include <stdint.h>
   9 #include <errno.h>
  10 #include <unistd.h>
  11 #include <sys/queue.h>
  12
  13 #include <rte_memory.h>
  14 #include <rte_memzone.h>
  15 #include <rte_launch.h>
  16 #include <rte_eal.h>
  17 #include <rte_per_lcore.h>
  18 #include <rte_lcore.h>
  19 #include <rte_debug.h>
  20 #include <rte_ethdev.h>
  21 #include <rte_cycles.h>
  22 #include <rte_eventdev.h>
  23 #include <rte_bus_vdev.h>
  24 #include <rte_pause.h>
  25
  26 #include "opdl_evdev.h"
  27 #include "opdl_log.h"
  28
  29
  30 #define MAX_PORTS 16
  31 #define MAX_QIDS 16
  32 #define NUM_PACKETS (1<<18)
  33 #define NUM_EVENTS 256
  34 #define BURST_SIZE 32
  35
  36
  37
  38 static int evdev;
  39
  40 struct test {
  41         struct rte_mempool *mbuf_pool;
  42         uint8_t port[MAX_PORTS];
  43         uint8_t qid[MAX_QIDS];
  44         int nb_qids;
  45 };
  46
  47 static struct rte_mempool *eventdev_func_mempool;
  48
  49 static __rte_always_inline struct rte_mbuf *
  50 rte_gen_arp(int portid, struct rte_mempool *mp)
  51 {
  52         /*
  53          * len = 14 + 46
  54          * ARP, Request who-has 10.0.0.1 tell 10.0.0.2, length 46
  55          */
  56         static const uint8_t arp_request[] = {
  57                 /*0x0000:*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xec, 0xa8,
  58                 0x6b, 0xfd, 0x02, 0x29, 0x08, 0x06, 0x00, 0x01,
  59                 /*0x0010:*/ 0x08, 0x00, 0x06, 0x04, 0x00, 0x01, 0xec, 0xa8,
  60                 0x6b, 0xfd, 0x02, 0x29, 0x0a, 0x00, 0x00, 0x01,
  61                 /*0x0020:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00,
  62                 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  63                 /*0x0030:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  64                 0x00, 0x00, 0x00, 0x00
  65         };
  66         struct rte_mbuf *m;
  67         int pkt_len = sizeof(arp_request) - 1;
  68
  69         m = rte_pktmbuf_alloc(mp);
  70         if (!m)
  71                 return 0;
  72
  73         memcpy((void *)((uintptr_t)m->buf_addr + m->data_off),
  74                 arp_request, pkt_len);
  75         rte_pktmbuf_pkt_len(m) = pkt_len;
  76         rte_pktmbuf_data_len(m) = pkt_len;
  77
  78         RTE_SET_USED(portid);
  79
  80         return m;
  81 }
  82
  83 /* initialization and config */
  84 static __rte_always_inline int
  85 init(struct test *t, int nb_queues, int nb_ports)
  86 {
  87         struct rte_event_dev_config config = {
  88                         .nb_event_queues = nb_queues,
  89                         .nb_event_ports = nb_ports,
  90                         .nb_event_queue_flows = 1024,
  91                         .nb_events_limit = 4096,
  92                         .nb_event_port_dequeue_depth = 128,
  93                         .nb_event_port_enqueue_depth = 128,
  94         };
  95         int ret;
  96
  97         void *temp = t->mbuf_pool; /* save and restore mbuf pool */
  98
  99         memset(t, 0, sizeof(*t));
 100         t->mbuf_pool = temp;
 101
 102         ret = rte_event_dev_configure(evdev, &config);
 103         if (ret < 0)
 104                 PMD_DRV_LOG(ERR, "%d: Error configuring device\n", __LINE__);
 105         return ret;
 106 };
 107
 108 static __rte_always_inline int
 109 create_ports(struct test *t, int num_ports)
 110 {
 111         int i;
 112         static const struct rte_event_port_conf conf = {
 113                         .new_event_threshold = 1024,
 114                         .dequeue_depth = 32,
 115                         .enqueue_depth = 32,
 116         };
 117         if (num_ports > MAX_PORTS)
 118                 return -1;
 119
 120         for (i = 0; i < num_ports; i++) {
 121                 if (rte_event_port_setup(evdev, i, &conf) < 0) {
 122                         PMD_DRV_LOG(ERR, "Error setting up port %d\n", i);
 123                         return -1;
 124                 }
 125                 t->port[i] = i;
 126         }
 127
 128         return 0;
 129 };
 130
 131 static __rte_always_inline int
 132 create_queues_type(struct test *t, int num_qids, enum queue_type flags)
 133 {
 134         int i;
 135         uint8_t type;
 136
 137         switch (flags) {
 138         case OPDL_Q_TYPE_ORDERED:
 139                 type = RTE_SCHED_TYPE_ORDERED;
 140                 break;
 141         case OPDL_Q_TYPE_ATOMIC:
 142                 type = RTE_SCHED_TYPE_ATOMIC;
 143                 break;
 144         default:
 145                 type = 0;
 146         }
 147
 148         /* Q creation */
 149         const struct rte_event_queue_conf conf = {
 150                 .event_queue_cfg =
 151                 (flags == OPDL_Q_TYPE_SINGLE_LINK ?
 152                  RTE_EVENT_QUEUE_CFG_SINGLE_LINK : 0),
 153                 .schedule_type = type,
 154                 .priority = RTE_EVENT_DEV_PRIORITY_NORMAL,
 155                 .nb_atomic_flows = 1024,
 156                 .nb_atomic_order_sequences = 1024,
 157         };
 158
 159         for (i = t->nb_qids ; i < t->nb_qids + num_qids; i++) {
 160                 if (rte_event_queue_setup(evdev, i, &conf) < 0) {
 161                         PMD_DRV_LOG(ERR, "%d: error creating qid %d\n ",
 162                                         __LINE__, i);
 163                         return -1;
 164                 }
 165                 t->qid[i] = i;
 166         }
 167
 168         t->nb_qids += num_qids;
 169
 170         if (t->nb_qids > MAX_QIDS)
 171                 return -1;
 172
 173         return 0;
 174 }
 175
 176
 177 /* destruction */
 178 static __rte_always_inline int
 179 cleanup(struct test *t __rte_unused)
 180 {
 181         rte_event_dev_stop(evdev);
 182         rte_event_dev_close(evdev);
 183         PMD_DRV_LOG(ERR, "clean up for test done\n");
 184         return 0;
 185 };
 186
 187 static int
 188 ordered_basic(struct test *t)
 189 {
 190         const uint8_t rx_port = 0;
 191         const uint8_t w1_port = 1;
 192         const uint8_t w3_port = 3;
 193         const uint8_t tx_port = 4;
 194         int err;
 195         uint32_t i;
 196         uint32_t deq_pkts;
 197         struct rte_mbuf *mbufs[3];
 198
 199         const uint32_t MAGIC_SEQN = 1234;
 200
 201         /* Create instance with 5 ports */
 202         if (init(t, 2, tx_port+1) < 0 ||
 203             create_ports(t, tx_port+1) < 0 ||
 204             create_queues_type(t, 2, OPDL_Q_TYPE_ORDERED)) {
 205                 PMD_DRV_LOG(ERR, "%d: Error initializing device\n", __LINE__);
 206                 return -1;
 207         }
 208
 209         /*
 210          * CQ mapping to QID
 211          * We need three ports, all mapped to the same ordered qid0. Then we'll
 212          * take a packet out to each port, re-enqueue in reverse order,
 213          * then make sure the reordering has taken place properly when we
 214          * dequeue from the tx_port.
 215          *
 216          * Simplified test setup diagram:
 217          *
 218          * rx_port        w1_port
 219          *        \     /         \
 220          *         qid0 - w2_port - qid1
 221          *              \         /     \
 222          *                w3_port        tx_port
 223          */
 224         /* CQ mapping to QID for LB ports (directed mapped on create) */
 225         for (i = w1_port; i <= w3_port; i++) {
 226                 err = rte_event_port_link(evdev, t->port[i], &t->qid[0], NULL,
 227                                 1);
 228                 if (err != 1) {
 229                         PMD_DRV_LOG(ERR, "%d: error mapping lb qid\n",
 230                                         __LINE__);
 231                         cleanup(t);
 232                         return -1;
 233                 }
 234         }
 235
 236         err = rte_event_port_link(evdev, t->port[tx_port], &t->qid[1], NULL,
 237                         1);
 238         if (err != 1) {
 239                 PMD_DRV_LOG(ERR, "%d: error mapping TX  qid\n", __LINE__);
 240                 cleanup(t);
 241                 return -1;
 242         }
 243
 244         if (rte_event_dev_start(evdev) < 0) {
 245                 PMD_DRV_LOG(ERR, "%d: Error with start call\n", __LINE__);
 246                 return -1;
 247         }
 248         /* Enqueue 3 packets to the rx port */
 249         for (i = 0; i < 3; i++) {
 250                 struct rte_event ev;
 251                 mbufs[i] = rte_gen_arp(0, t->mbuf_pool);
 252                 if (!mbufs[i]) {
 253                         PMD_DRV_LOG(ERR, "%d: gen of pkt failed\n", __LINE__);
 254                         return -1;
 255                 }
 256
 257                 ev.queue_id = t->qid[0];
 258                 ev.op = RTE_EVENT_OP_NEW;
 259                 ev.mbuf = mbufs[i];
 260                 mbufs[i]->seqn = MAGIC_SEQN + i;
 261
 262                 /* generate pkt and enqueue */
 263                 err = rte_event_enqueue_burst(evdev, t->port[rx_port], &ev, 1);
 264                 if (err != 1) {
 265                         PMD_DRV_LOG(ERR, "%d: Failed to enqueue pkt %u, retval = %u\n",
 266                                         __LINE__, i, err);
 267                         return -1;
 268                 }
 269         }
 270
 271         /* use extra slot to make logic in loops easier */
 272         struct rte_event deq_ev[w3_port + 1];
 273
 274         uint32_t  seq  = 0;
 275
 276         /* Dequeue the 3 packets, one from each worker port */
 277         for (i = w1_port; i <= w3_port; i++) {
 278                 deq_pkts = rte_event_dequeue_burst(evdev, t->port[i],
 279                                 &deq_ev[i], 1, 0);
 280                 if (deq_pkts != 1) {
 281                         PMD_DRV_LOG(ERR, "%d: Failed to deq\n", __LINE__);
 282                         rte_event_dev_dump(evdev, stdout);
 283                         return -1;
 284                 }
 285                 seq = deq_ev[i].mbuf->seqn  - MAGIC_SEQN;
 286
 287                 if (seq != (i-1)) {
 288                         PMD_DRV_LOG(ERR, " seq test failed ! eq is %d , "
 289                                         "port number is %u\n", seq, i);
 290                         return -1;
 291                 }
 292         }
 293
 294         /* Enqueue each packet in reverse order, flushing after each one */
 295         for (i = w3_port; i >= w1_port; i--) {
 296
 297                 deq_ev[i].op = RTE_EVENT_OP_FORWARD;
 298                 deq_ev[i].queue_id = t->qid[1];
 299                 err = rte_event_enqueue_burst(evdev, t->port[i], &deq_ev[i], 1);
 300                 if (err != 1) {
 301                         PMD_DRV_LOG(ERR, "%d: Failed to enqueue\n", __LINE__);
 302                         return -1;
 303                 }
 304         }
 305
 306         /* dequeue from the tx ports, we should get 3 packets */
 307         deq_pkts = rte_event_dequeue_burst(evdev, t->port[tx_port], deq_ev,
 308                         3, 0);
 309
 310         /* Check to see if we've got all 3 packets */
 311         if (deq_pkts != 3) {
 312                 PMD_DRV_LOG(ERR, "%d: expected 3 pkts at tx port got %d from port %d\n",
 313                         __LINE__, deq_pkts, tx_port);
 314                 rte_event_dev_dump(evdev, stdout);
 315                 return 1;
 316         }
 317
 318         /* Destroy the instance */
 319         cleanup(t);
 320
 321         return 0;
 322 }
 323
 324
 325 static int
 326 atomic_basic(struct test *t)
 327 {
 328         const uint8_t rx_port = 0;
 329         const uint8_t w1_port = 1;
 330         const uint8_t w3_port = 3;
 331         const uint8_t tx_port = 4;
 332         int err;
 333         int i;
 334         uint32_t deq_pkts;
 335         struct rte_mbuf *mbufs[3];
 336         const uint32_t MAGIC_SEQN = 1234;
 337
 338         /* Create instance with 5 ports */
 339         if (init(t, 2, tx_port+1) < 0 ||
 340             create_ports(t, tx_port+1) < 0 ||
 341             create_queues_type(t, 2, OPDL_Q_TYPE_ATOMIC)) {
 342                 PMD_DRV_LOG(ERR, "%d: Error initializing device\n", __LINE__);
 343                 return -1;
 344         }
 345
 346
 347         /*
 348          * CQ mapping to QID
 349          * We need three ports, all mapped to the same ordered qid0. Then we'll
 350          * take a packet out to each port, re-enqueue in reverse order,
 351          * then make sure the reordering has taken place properly when we
 352          * dequeue from the tx_port.
 353          *
 354          * Simplified test setup diagram:
 355          *
 356          * rx_port        w1_port
 357          *        \     /         \
 358          *         qid0 - w2_port - qid1
 359          *              \         /     \
 360          *                w3_port        tx_port
 361          */
 362         /* CQ mapping to QID for Atomic  ports (directed mapped on create) */
 363         for (i = w1_port; i <= w3_port; i++) {
 364                 err = rte_event_port_link(evdev, t->port[i], &t->qid[0], NULL,
 365                                 1);
 366                 if (err != 1) {
 367                         PMD_DRV_LOG(ERR, "%d: error mapping lb qid\n",
 368                                         __LINE__);
 369                         cleanup(t);
 370                         return -1;
 371                 }
 372         }
 373
 374         err = rte_event_port_link(evdev, t->port[tx_port], &t->qid[1], NULL,
 375                         1);
 376         if (err != 1) {
 377                 PMD_DRV_LOG(ERR, "%d: error mapping TX  qid\n", __LINE__);
 378                 cleanup(t);
 379                 return -1;
 380         }
 381
 382         if (rte_event_dev_start(evdev) < 0) {
 383                 PMD_DRV_LOG(ERR, "%d: Error with start call\n", __LINE__);
 384                 return -1;
 385         }
 386
 387         /* Enqueue 3 packets to the rx port */
 388         for (i = 0; i < 3; i++) {
 389                 struct rte_event ev;
 390                 mbufs[i] = rte_gen_arp(0, t->mbuf_pool);
 391                 if (!mbufs[i]) {
 392                         PMD_DRV_LOG(ERR, "%d: gen of pkt failed\n", __LINE__);
 393                         return -1;
 394                 }
 395
 396                 ev.queue_id = t->qid[0];
 397                 ev.op = RTE_EVENT_OP_NEW;
 398                 ev.flow_id = 1;
 399                 ev.mbuf = mbufs[i];
 400                 mbufs[i]->seqn = MAGIC_SEQN + i;
 401
 402                 /* generate pkt and enqueue */
 403                 err = rte_event_enqueue_burst(evdev, t->port[rx_port], &ev, 1);
 404                 if (err != 1) {
 405                         PMD_DRV_LOG(ERR, "%d: Failed to enqueue pkt %u, retval = %u\n",
 406                                         __LINE__, i, err);
 407                         return -1;
 408                 }
 409         }
 410
 411         /* use extra slot to make logic in loops easier */
 412         struct rte_event deq_ev[w3_port + 1];
 413
 414         /* Dequeue the 3 packets, one from each worker port */
 415         for (i = w1_port; i <= w3_port; i++) {
 416
 417                 deq_pkts = rte_event_dequeue_burst(evdev, t->port[i],
 418                                 deq_ev, 3, 0);
 419
 420                 if (t->port[i] != 2) {
 421                         if (deq_pkts != 0) {
 422                                 PMD_DRV_LOG(ERR, "%d: deq none zero !\n",
 423                                                 __LINE__);
 424                                 rte_event_dev_dump(evdev, stdout);
 425                                 return -1;
 426                         }
 427                 } else {
 428
 429                         if (deq_pkts != 3) {
 430                                 PMD_DRV_LOG(ERR, "%d: deq not eqal to 3 %u !\n",
 431                                                 __LINE__, deq_pkts);
 432                                 rte_event_dev_dump(evdev, stdout);
 433                                 return -1;
 434                         }
 435
 436                         for (int j = 0; j < 3; j++) {
 437                                 deq_ev[j].op = RTE_EVENT_OP_FORWARD;
 438                                 deq_ev[j].queue_id = t->qid[1];
 439                         }
 440
 441                         err = rte_event_enqueue_burst(evdev, t->port[i],
 442                                         deq_ev, 3);
 443
 444                         if (err != 3) {
 445                                 PMD_DRV_LOG(ERR, "port %d: Failed to enqueue pkt %u, "
 446                                                 "retval = %u\n",
 447                                                 t->port[i], 3, err);
 448                                 return -1;
 449                         }
 450
 451                 }
 452
 453         }
 454
 455
 456         /* dequeue from the tx ports, we should get 3 packets */
 457         deq_pkts = rte_event_dequeue_burst(evdev, t->port[tx_port], deq_ev,
 458                         3, 0);
 459
 460         /* Check to see if we've got all 3 packets */
 461         if (deq_pkts != 3) {
 462                 PMD_DRV_LOG(ERR, "%d: expected 3 pkts at tx port got %d from port %d\n",
 463                         __LINE__, deq_pkts, tx_port);
 464                 rte_event_dev_dump(evdev, stdout);
 465                 return 1;
 466         }
 467
 468         cleanup(t);
 469
 470         return 0;
 471 }
 472 static __rte_always_inline int
 473 check_qid_stats(uint32_t id[], int index)
 474 {
 475
 476         if (index == 0) {
 477                 if (id[0] != 3 || id[1] != 3
 478                                 || id[2] != 3)
 479                         return -1;
 480         } else if (index == 1) {
 481                 if (id[0] != 5 || id[1] != 5
 482                                 || id[2] != 2)
 483                         return -1;
 484         } else if (index == 2) {
 485                 if (id[0] != 3 || id[1] != 1
 486                                 || id[2] != 1)
 487                         return -1;
 488         }
 489
 490         return 0;
 491 }
 492
 493
 494 static int
 495 check_statistics(void)
 496 {
 497         int num_ports = 3; /* Hard-coded for this app */
 498
 499         for (int i = 0; i < num_ports; i++) {
 500                 int num_stats, num_stats_returned;
 501
 502                 num_stats = rte_event_dev_xstats_names_get(0,
 503                                 RTE_EVENT_DEV_XSTATS_PORT,
 504                                 i,
 505                                 NULL,
 506                                 NULL,
 507                                 0);
 508                 if (num_stats > 0) {
 509
 510                         uint32_t id[num_stats];
 511                         struct rte_event_dev_xstats_name names[num_stats];
 512                         uint64_t values[num_stats];
 513
 514                         num_stats_returned = rte_event_dev_xstats_names_get(0,
 515                                         RTE_EVENT_DEV_XSTATS_PORT,
 516                                         i,
 517                                         names,
 518                                         id,
 519                                         num_stats);
 520
 521                         if (num_stats == num_stats_returned) {
 522                                 num_stats_returned = rte_event_dev_xstats_get(0,
 523                                                 RTE_EVENT_DEV_XSTATS_PORT,
 524                                                 i,
 525                                                 id,
 526                                                 values,
 527                                                 num_stats);
 528
 529                                 if (num_stats == num_stats_returned) {
 530                                         int err;
 531
 532                                         err = check_qid_stats(id, i);
 533
 534                                         if (err)
 535                                                 return err;
 536
 537                                 } else {
 538                                         return -1;
 539                                 }
 540                         } else {
 541                                 return -1;
 542                         }
 543                 } else {
 544                         return -1;
 545                 }
 546         }
 547         return 0;
 548 }
 549
 550 #define OLD_NUM_PACKETS 3
 551 #define NEW_NUM_PACKETS 2
 552 static int
 553 single_link_w_stats(struct test *t)
 554 {
 555         const uint8_t rx_port = 0;
 556         const uint8_t w1_port = 1;
 557         const uint8_t tx_port = 2;
 558         int err;
 559         int i;
 560         uint32_t deq_pkts;
 561         struct rte_mbuf *mbufs[3];
 562         RTE_SET_USED(mbufs);
 563         RTE_SET_USED(i);
 564
 565         /* Create instance with 3 ports */
 566         if (init(t, 2, tx_port + 1) < 0 ||
 567             create_ports(t, 3) < 0 || /* 0,1,2 */
 568             create_queues_type(t, 1, OPDL_Q_TYPE_SINGLE_LINK) < 0 ||
 569             create_queues_type(t, 1, OPDL_Q_TYPE_ORDERED) < 0) {
 570                 PMD_DRV_LOG(ERR, "%d: Error initializing device\n", __LINE__);
 571                 return -1;
 572         }
 573
 574
 575         /*
 576          *
 577          * Simplified test setup diagram:
 578          *
 579          * rx_port(0)
 580          *           \
 581          *            qid0 - w1_port(1) - qid1
 582          *                                    \
 583          *                                     tx_port(2)
 584          */
 585
 586         err = rte_event_port_link(evdev, t->port[1], &t->qid[0], NULL,
 587                                   1);
 588         if (err != 1) {
 589                 PMD_DRV_LOG(ERR, "%d: error linking port:[%u] to queue:[%u]\n",
 590                        __LINE__,
 591                        t->port[1],
 592                        t->qid[0]);
 593                 cleanup(t);
 594                 return -1;
 595         }
 596
 597         err = rte_event_port_link(evdev, t->port[2], &t->qid[1], NULL,
 598                                   1);
 599         if (err != 1) {
 600                 PMD_DRV_LOG(ERR, "%d: error linking port:[%u] to queue:[%u]\n",
 601                        __LINE__,
 602                        t->port[2],
 603                        t->qid[1]);
 604                 cleanup(t);
 605                 return -1;
 606         }
 607
 608         if (rte_event_dev_start(evdev) != 0) {
 609                 PMD_DRV_LOG(ERR, "%d: failed to start device\n", __LINE__);
 610                 cleanup(t);
 611                 return -1;
 612         }
 613
 614         /*
 615          * Enqueue 3 packets to the rx port
 616          */
 617         for (i = 0; i < 3; i++) {
 618                 struct rte_event ev;
 619                 mbufs[i] = rte_gen_arp(0, t->mbuf_pool);
 620                 if (!mbufs[i]) {
 621                         PMD_DRV_LOG(ERR, "%d: gen of pkt failed\n", __LINE__);
 622                         return -1;
 623                 }
 624
 625                 ev.queue_id = t->qid[0];
 626                 ev.op = RTE_EVENT_OP_NEW;
 627                 ev.mbuf = mbufs[i];
 628                 mbufs[i]->seqn = 1234 + i;
 629
 630                 /* generate pkt and enqueue */
 631                 err = rte_event_enqueue_burst(evdev, t->port[rx_port], &ev, 1);
 632                 if (err != 1) {
 633                         PMD_DRV_LOG(ERR, "%d: Failed to enqueue pkt %u, retval = %u\n",
 634                                __LINE__,
 635                                t->port[rx_port],
 636                                err);
 637                         return -1;
 638                 }
 639         }
 640
 641         /* Dequeue the 3 packets, from SINGLE_LINK worker port */
 642         struct rte_event deq_ev[3];
 643
 644         deq_pkts = rte_event_dequeue_burst(evdev,
 645                                            t->port[w1_port],
 646                                            deq_ev, 3, 0);
 647
 648         if (deq_pkts != 3) {
 649                 PMD_DRV_LOG(ERR, "%d: deq not 3 !\n", __LINE__);
 650                 cleanup(t);
 651                 return -1;
 652         }
 653
 654         /* Just enqueue 2 onto new ring */
 655         for (i = 0; i < NEW_NUM_PACKETS; i++)
 656                 deq_ev[i].queue_id = t->qid[1];
 657
 658         deq_pkts = rte_event_enqueue_burst(evdev,
 659                                            t->port[w1_port],
 660                                            deq_ev,
 661                                            NEW_NUM_PACKETS);
 662
 663         if (deq_pkts != 2) {
 664                 PMD_DRV_LOG(ERR, "%d: enq not 2 but %u!\n", __LINE__, deq_pkts);
 665                 cleanup(t);
 666                 return -1;
 667         }
 668
 669         /* dequeue from the tx ports, we should get 2 packets */
 670         deq_pkts = rte_event_dequeue_burst(evdev,
 671                                            t->port[tx_port],
 672                                            deq_ev,
 673                                            3,
 674                                            0);
 675
 676         /* Check to see if we've got all 2 packets */
 677         if (deq_pkts != 2) {
 678                 PMD_DRV_LOG(ERR, "%d: expected 2 pkts at tx port got %d from port %d\n",
 679                         __LINE__, deq_pkts, tx_port);
 680                 cleanup(t);
 681                 return -1;
 682         }
 683
 684         if (!check_statistics()) {
 685                 PMD_DRV_LOG(ERR, "xstats check failed");
 686                 cleanup(t);
 687                 return -1;
 688         }
 689
 690         cleanup(t);
 691
 692         return 0;
 693 }
 694
 695 static int
 696 single_link(struct test *t)
 697 {
 698         /* const uint8_t rx_port = 0; */
 699         /* const uint8_t w1_port = 1; */
 700         /* const uint8_t w3_port = 3; */
 701         const uint8_t tx_port = 2;
 702         int err;
 703         int i;
 704         struct rte_mbuf *mbufs[3];
 705         RTE_SET_USED(mbufs);
 706         RTE_SET_USED(i);
 707
 708         /* Create instance with 5 ports */
 709         if (init(t, 2, tx_port+1) < 0 ||
 710             create_ports(t, 3) < 0 || /* 0,1,2 */
 711             create_queues_type(t, 1, OPDL_Q_TYPE_SINGLE_LINK) < 0 ||
 712             create_queues_type(t, 1, OPDL_Q_TYPE_ORDERED) < 0) {
 713                 PMD_DRV_LOG(ERR, "%d: Error initializing device\n", __LINE__);
 714                 return -1;
 715         }
 716
 717
 718         /*
 719          *
 720          * Simplified test setup diagram:
 721          *
 722          * rx_port(0)
 723          *           \
 724          *            qid0 - w1_port(1) - qid1
 725          *                                    \
 726          *                                     tx_port(2)
 727          */
 728
 729         err = rte_event_port_link(evdev, t->port[1], &t->qid[0], NULL,
 730                                   1);
 731         if (err != 1) {
 732                 PMD_DRV_LOG(ERR, "%d: error mapping lb qid\n", __LINE__);
 733                 cleanup(t);
 734                 return -1;
 735         }
 736
 737         err = rte_event_port_link(evdev, t->port[2], &t->qid[0], NULL,
 738                                   1);
 739         if (err != 1) {
 740                 PMD_DRV_LOG(ERR, "%d: error mapping lb qid\n", __LINE__);
 741                 cleanup(t);
 742                 return -1;
 743         }
 744
 745         if (rte_event_dev_start(evdev) == 0) {
 746                 PMD_DRV_LOG(ERR, "%d: start DIDN'T FAIL with more than 1 "
 747                                 "SINGLE_LINK PORT\n", __LINE__);
 748                 cleanup(t);
 749                 return -1;
 750         }
 751
 752         cleanup(t);
 753
 754         return 0;
 755 }
 756
 757
 758 static __rte_always_inline void
 759 populate_event_burst(struct rte_event ev[],
 760                      uint8_t qid,
 761                      uint16_t num_events)
 762 {
 763         uint16_t i;
 764         for (i = 0; i < num_events; i++) {
 765                 ev[i].flow_id = 1;
 766                 ev[i].op = RTE_EVENT_OP_NEW;
 767                 ev[i].sched_type = RTE_SCHED_TYPE_ORDERED;
 768                 ev[i].queue_id = qid;
 769                 ev[i].event_type = RTE_EVENT_TYPE_ETHDEV;
 770                 ev[i].sub_event_type = 0;
 771                 ev[i].priority = RTE_EVENT_DEV_PRIORITY_NORMAL;
 772                 ev[i].mbuf = (struct rte_mbuf *)0xdead0000;
 773         }
 774 }
 775
 776 #define NUM_QUEUES 3
 777 #define BATCH_SIZE 32
 778
 779 static int
 780 qid_basic(struct test *t)
 781 {
 782         int err = 0;
 783
 784         uint8_t q_id = 0;
 785         uint8_t p_id = 0;
 786
 787         uint32_t num_events;
 788         uint32_t i;
 789
 790         struct rte_event ev[BATCH_SIZE];
 791
 792         /* Create instance with 4 ports */
 793         if (init(t, NUM_QUEUES, NUM_QUEUES+1) < 0 ||
 794             create_ports(t, NUM_QUEUES+1) < 0 ||
 795             create_queues_type(t, NUM_QUEUES, OPDL_Q_TYPE_ORDERED)) {
 796                 PMD_DRV_LOG(ERR, "%d: Error initializing device\n", __LINE__);
 797                 return -1;
 798         }
 799
 800         for (i = 0; i < NUM_QUEUES; i++) {
 801                 int nb_linked;
 802                 q_id = i;
 803
 804                 nb_linked = rte_event_port_link(evdev,
 805                                 i+1, /* port = q_id + 1*/
 806                                 &q_id,
 807                                 NULL,
 808                                 1);
 809
 810                 if (nb_linked != 1) {
 811
 812                         PMD_DRV_LOG(ERR, "%s:%d: error mapping port:%u to queue:%u\n",
 813                                         __FILE__,
 814                                         __LINE__,
 815                                         i + 1,
 816                                         q_id);
 817
 818                         err = -1;
 819                         break;
 820                 }
 821
 822         }
 823
 824
 825         /* Try and link to the same port again */
 826         if (!err) {
 827                 uint8_t t_qid = 0;
 828                 if (rte_event_port_link(evdev,
 829                                         1,
 830                                         &t_qid,
 831                                         NULL,
 832                                         1) > 0) {
 833                         PMD_DRV_LOG(ERR, "%s:%d: Second call to port link on same port DID NOT fail\n",
 834                                         __FILE__,
 835                                         __LINE__);
 836                         err = -1;
 837                 }
 838
 839                 uint32_t test_num_events;
 840
 841                 if (!err) {
 842                         test_num_events = rte_event_dequeue_burst(evdev,
 843                                         p_id,
 844                                         ev,
 845                                         BATCH_SIZE,
 846                                         0);
 847                         if (test_num_events != 0) {
 848                                 PMD_DRV_LOG(ERR, "%s:%d: Error dequeuing 0 packets from port %u on stopped device\n",
 849                                                 __FILE__,
 850                                                 __LINE__,
 851                                                 p_id);
 852                                 err = -1;
 853                         }
 854                 }
 855
 856                 if (!err) {
 857                         test_num_events = rte_event_enqueue_burst(evdev,
 858                                         p_id,
 859                                         ev,
 860                                         BATCH_SIZE);
 861                         if (test_num_events != 0) {
 862                                 PMD_DRV_LOG(ERR, "%s:%d: Error enqueuing 0 packets to port %u on stopped device\n",
 863                                                 __FILE__,
 864                                                 __LINE__,
 865                                                 p_id);
 866                                 err = -1;
 867                         }
 868                 }
 869         }
 870
 871
 872         /* Start the devicea */
 873         if (!err) {
 874                 if (rte_event_dev_start(evdev) < 0) {
 875                         PMD_DRV_LOG(ERR, "%s:%d: Error with start call\n",
 876                                         __FILE__,
 877                                         __LINE__);
 878                         err = -1;
 879                 }
 880         }
 881
 882
 883         /* Check we can't do any more links now that device is started.*/
 884         if (!err) {
 885                 uint8_t t_qid = 0;
 886                 if (rte_event_port_link(evdev,
 887                                         1,
 888                                         &t_qid,
 889                                         NULL,
 890                                         1) > 0) {
 891                         PMD_DRV_LOG(ERR, "%s:%d: Call to port link on started device DID NOT fail\n",
 892                                         __FILE__,
 893                                         __LINE__);
 894                         err = -1;
 895                 }
 896         }
 897
 898         if (!err) {
 899
 900                 q_id = 0;
 901
 902                 populate_event_burst(ev,
 903                                 q_id,
 904                                 BATCH_SIZE);
 905
 906                 num_events = rte_event_enqueue_burst(evdev,
 907                                 p_id,
 908                                 ev,
 909                                 BATCH_SIZE);
 910                 if (num_events != BATCH_SIZE) {
 911                         PMD_DRV_LOG(ERR, "%s:%d: Error enqueuing rx packets\n",
 912                                         __FILE__,
 913                                         __LINE__);
 914                         err = -1;
 915                 }
 916         }
 917
 918         if (!err) {
 919                 while (++p_id < NUM_QUEUES) {
 920
 921                         num_events = rte_event_dequeue_burst(evdev,
 922                                         p_id,
 923                                         ev,
 924                                         BATCH_SIZE,
 925                                         0);
 926
 927                         if (num_events != BATCH_SIZE) {
 928                                 PMD_DRV_LOG(ERR, "%s:%d: Error dequeuing packets from port %u\n",
 929                                                 __FILE__,
 930                                                 __LINE__,
 931                                                 p_id);
 932                                 err = -1;
 933                                 break;
 934                         }
 935
 936                         if (ev[0].queue_id != q_id) {
 937                                 PMD_DRV_LOG(ERR, "%s:%d: Error event portid[%u] q_id:[%u] does not match expected:[%u]\n",
 938                                                 __FILE__,
 939                                                 __LINE__,
 940                                                 p_id,
 941                                                 ev[0].queue_id,
 942                                                 q_id);
 943                                 err = -1;
 944                                 break;
 945                         }
 946
 947                         populate_event_burst(ev,
 948                                         ++q_id,
 949                                         BATCH_SIZE);
 950
 951                         num_events = rte_event_enqueue_burst(evdev,
 952                                         p_id,
 953                                         ev,
 954                                         BATCH_SIZE);
 955                         if (num_events != BATCH_SIZE) {
 956                                 PMD_DRV_LOG(ERR, "%s:%d: Error enqueuing packets from port:%u to queue:%u\n",
 957                                                 __FILE__,
 958                                                 __LINE__,
 959                                                 p_id,
 960                                                 q_id);
 961                                 err = -1;
 962                                 break;
 963                         }
 964                 }
 965         }
 966
 967         if (!err) {
 968                 num_events = rte_event_dequeue_burst(evdev,
 969                                 p_id,
 970                                 ev,
 971                                 BATCH_SIZE,
 972                                 0);
 973                 if (num_events != BATCH_SIZE) {
 974                         PMD_DRV_LOG(ERR, "%s:%d: Error dequeuing packets from tx port %u\n",
 975                                         __FILE__,
 976                                         __LINE__,
 977                                         p_id);
 978                         err = -1;
 979                 }
 980         }
 981
 982         cleanup(t);
 983
 984         return err;
 985 }
 986
 987
 988
 989 int
 990 opdl_selftest(void)
 991 {
 992         struct test *t = malloc(sizeof(struct test));
 993         int ret;
 994
 995         const char *eventdev_name = "event_opdl0";
 996
 997         evdev = rte_event_dev_get_dev_id(eventdev_name);
 998
 999         if (evdev < 0) {
1000                 PMD_DRV_LOG(ERR, "%d: Eventdev %s not found - creating.\n",
1001                                 __LINE__, eventdev_name);
1002                 /* turn on stats by default */
1003                 if (rte_vdev_init(eventdev_name, "do_validation=1") < 0) {
1004                         PMD_DRV_LOG(ERR, "Error creating eventdev\n");
1005                         return -1;
1006                 }
1007                 evdev = rte_event_dev_get_dev_id(eventdev_name);
1008                 if (evdev < 0) {
1009                         PMD_DRV_LOG(ERR, "Error finding newly created eventdev\n");
1010                         return -1;
1011                 }
1012         }
1013
1014         /* Only create mbuf pool once, reuse for each test run */
1015         if (!eventdev_func_mempool) {
1016                 eventdev_func_mempool = rte_pktmbuf_pool_create(
1017                                 "EVENTDEV_SW_SA_MBUF_POOL",
1018                                 (1<<12), /* 4k buffers */
1019                                 32 /*MBUF_CACHE_SIZE*/,
1020                                 0,
1021                                 512, /* use very small mbufs */
1022                                 rte_socket_id());
1023                 if (!eventdev_func_mempool) {
1024                         PMD_DRV_LOG(ERR, "ERROR creating mempool\n");
1025                         return -1;
1026                 }
1027         }
1028         t->mbuf_pool = eventdev_func_mempool;
1029
1030         PMD_DRV_LOG(ERR, "*** Running Ordered Basic test...\n");
1031         ret = ordered_basic(t);
1032
1033         PMD_DRV_LOG(ERR, "*** Running Atomic Basic test...\n");
1034         ret = atomic_basic(t);
1035
1036
1037         PMD_DRV_LOG(ERR, "*** Running QID  Basic test...\n");
1038         ret = qid_basic(t);
1039
1040         PMD_DRV_LOG(ERR, "*** Running SINGLE LINK failure test...\n");
1041         ret = single_link(t);
1042
1043         PMD_DRV_LOG(ERR, "*** Running SINGLE LINK w stats test...\n");
1044         ret = single_link_w_stats(t);
1045
1046         /*
1047          * Free test instance, leaving mempool initialized, and a pointer to it
1048          * in static eventdev_func_mempool, as it is re-used on re-runs
1049          */
1050         free(t);
1051
1052         if (ret != 0)
1053                 return ret;
1054         return 0;
1055
1056 }