lib/librte_port/rte_port_source_sink.c

   1 /*-
   2  *   BSD LICENSE
   3  *
   4  *   Copyright(c) 2010-2016 Intel Corporation. All rights reserved.
   5  *   All rights reserved.
   6  *
   7  *   Redistribution and use in source and binary forms, with or without
   8  *   modification, are permitted provided that the following conditions
   9  *   are met:
  10  *
  11  *     * Redistributions of source code must retain the above copyright
  12  *       notice, this list of conditions and the following disclaimer.
  13  *     * Redistributions in binary form must reproduce the above copyright
  14  *       notice, this list of conditions and the following disclaimer in
  15  *       the documentation and/or other materials provided with the
  16  *       distribution.
  17  *     * Neither the name of Intel Corporation nor the names of its
  18  *       contributors may be used to endorse or promote products derived
  19  *       from this software without specific prior written permission.
  20  *
  21  *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  22  *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  23  *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  24  *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  25  *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  26  *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  27  *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  28  *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  29  *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  30  *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  31  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  32  */
  33 #include <stdint.h>
  34 #include <string.h>
  35
  36 #include <rte_mbuf.h>
  37 #include <rte_mempool.h>
  38 #include <rte_malloc.h>
  39 #include <rte_memcpy.h>
  40
  41 #ifdef RTE_NEXT_ABI
  42
  43 #ifdef RTE_PORT_PCAP
  44 #include <rte_ether.h>
  45 #include <pcap.h>
  46 #endif
  47
  48 #else
  49 #undef RTE_PORT_PCAP
  50 #endif
  51
  52 #include "rte_port_source_sink.h"
  53
  54 /*
  55  * Port SOURCE
  56  */
  57 #ifdef RTE_PORT_STATS_COLLECT
  58
  59 #define RTE_PORT_SOURCE_STATS_PKTS_IN_ADD(port, val) \
  60         port->stats.n_pkts_in += val
  61 #define RTE_PORT_SOURCE_STATS_PKTS_DROP_ADD(port, val) \
  62         port->stats.n_pkts_drop += val
  63
  64 #else
  65
  66 #define RTE_PORT_SOURCE_STATS_PKTS_IN_ADD(port, val)
  67 #define RTE_PORT_SOURCE_STATS_PKTS_DROP_ADD(port, val)
  68
  69 #endif
  70
  71 struct rte_port_source {
  72         struct rte_port_in_stats stats;
  73
  74         struct rte_mempool *mempool;
  75
  76         /* PCAP buffers and indices */
  77         uint8_t **pkts;
  78         uint8_t *pkt_buff;
  79         uint32_t *pkt_len;
  80         uint32_t n_pkts;
  81         uint32_t pkt_index;
  82 };
  83
  84 #ifdef RTE_NEXT_ABI
  85
  86 #ifdef RTE_PORT_PCAP
  87
  88 static int
  89 pcap_source_load(struct rte_port_source *port,
  90                 const char *file_name,
  91                 uint32_t n_bytes_per_pkt,
  92                 int socket_id)
  93 {
  94         uint32_t n_pkts = 0;
  95         uint32_t i;
  96         uint32_t *pkt_len_aligns = NULL;
  97         size_t total_buff_len = 0;
  98         pcap_t *pcap_handle;
  99         char pcap_errbuf[PCAP_ERRBUF_SIZE];
 100         uint32_t max_len;
 101         struct pcap_pkthdr pcap_hdr;
 102         const uint8_t *pkt;
 103         uint8_t *buff = NULL;
 104         uint32_t pktmbuf_maxlen = (uint32_t)
 105                         (rte_pktmbuf_data_room_size(port->mempool) -
 106                         RTE_PKTMBUF_HEADROOM);
 107
 108         if (n_bytes_per_pkt == 0)
 109                 max_len = pktmbuf_maxlen;
 110         else
 111                 max_len = RTE_MIN(n_bytes_per_pkt, pktmbuf_maxlen);
 112
 113         /* first time open, get packet number */
 114         pcap_handle = pcap_open_offline(file_name, pcap_errbuf);
 115         if (pcap_handle == NULL) {
 116                 RTE_LOG(ERR, PORT, "Failed to open pcap file "
 117                         "'%s' for reading\n", file_name);
 118                 goto error_exit;
 119         }
 120
 121         while ((pkt = pcap_next(pcap_handle, &pcap_hdr)) != NULL)
 122                 n_pkts++;
 123
 124         pcap_close(pcap_handle);
 125
 126         port->pkt_len = rte_zmalloc_socket("PCAP",
 127                 (sizeof(*port->pkt_len) * n_pkts), 0, socket_id);
 128         if (port->pkt_len == NULL) {
 129                 RTE_LOG(ERR, PORT, "No enough memory\n");
 130                 goto error_exit;
 131         }
 132
 133         pkt_len_aligns = rte_malloc("PCAP",
 134                 (sizeof(*pkt_len_aligns) * n_pkts), 0);
 135         if (pkt_len_aligns == NULL) {
 136                 RTE_LOG(ERR, PORT, "No enough memory\n");
 137                 goto error_exit;
 138         }
 139
 140         port->pkts = rte_zmalloc_socket("PCAP",
 141                 (sizeof(*port->pkts) * n_pkts), 0, socket_id);
 142         if (port->pkts == NULL) {
 143                 RTE_LOG(ERR, PORT, "No enough memory\n");
 144                 goto error_exit;
 145         }
 146
 147         /* open 2nd time, get pkt_len */
 148         pcap_handle = pcap_open_offline(file_name, pcap_errbuf);
 149         if (pcap_handle == NULL) {
 150                 RTE_LOG(ERR, PORT, "Failed to open pcap file "
 151                         "'%s' for reading\n", file_name);
 152                 goto error_exit;
 153         }
 154
 155         for (i = 0; i < n_pkts; i++) {
 156                 pkt = pcap_next(pcap_handle, &pcap_hdr);
 157                 port->pkt_len[i] = RTE_MIN(max_len, pcap_hdr.len);
 158                 pkt_len_aligns[i] = RTE_CACHE_LINE_ROUNDUP(
 159                         port->pkt_len[i]);
 160                 total_buff_len += pkt_len_aligns[i];
 161         }
 162
 163         pcap_close(pcap_handle);
 164
 165         /* allocate a big trunk of data for pcap file load */
 166         buff = rte_zmalloc_socket("PCAP",
 167                 total_buff_len, 0, socket_id);
 168         if (buff == NULL) {
 169                 RTE_LOG(ERR, PORT, "No enough memory\n");
 170                 goto error_exit;
 171         }
 172
 173         port->pkt_buff = buff;
 174
 175         /* open file one last time to copy the pkt content */
 176         pcap_handle = pcap_open_offline(file_name, pcap_errbuf);
 177         if (pcap_handle == NULL) {
 178                 RTE_LOG(ERR, PORT, "Failed to open pcap file "
 179                         "'%s' for reading\n", file_name);
 180                 goto error_exit;
 181         }
 182
 183         for (i = 0; i < n_pkts; i++) {
 184                 pkt = pcap_next(pcap_handle, &pcap_hdr);
 185                 rte_memcpy(buff, pkt, port->pkt_len[i]);
 186                 port->pkts[i] = buff;
 187                 buff += pkt_len_aligns[i];
 188         }
 189
 190         pcap_close(pcap_handle);
 191
 192         port->n_pkts = n_pkts;
 193
 194         rte_free(pkt_len_aligns);
 195
 196         RTE_LOG(INFO, PORT, "Successfully load pcap file "
 197                 "'%s' with %u pkts\n",
 198                 file_name, port->n_pkts);
 199
 200         return 0;
 201
 202 error_exit:
 203         if (pkt_len_aligns)
 204                 rte_free(pkt_len_aligns);
 205         if (port->pkt_len)
 206                 rte_free(port->pkt_len);
 207         if (port->pkts)
 208                 rte_free(port->pkts);
 209         if (port->pkt_buff)
 210                 rte_free(port->pkt_buff);
 211
 212         return -1;
 213 }
 214
 215 #define PCAP_SOURCE_LOAD(port, file_name, n_bytes, socket_id)   \
 216         pcap_source_load(port, file_name, n_bytes, socket_id)
 217
 218 #else /* RTE_PORT_PCAP */
 219
 220 #define PCAP_SOURCE_LOAD(port, file_name, n_bytes, socket_id)   \
 221 ({                                                              \
 222         int _ret = 0;                                           \
 223                                                                 \
 224         if (file_name) {                                        \
 225                 RTE_LOG(ERR, PORT, "Source port field "         \
 226                         "\"file_name\" is not NULL.\n");        \
 227                 _ret = -1;                                      \
 228         }                                                       \
 229                                                                 \
 230         _ret;                                                   \
 231 })
 232
 233 #endif /* RTE_PORT_PCAP */
 234
 235 #endif /* RTE_NEXT_ABI */
 236
 237 static void *
 238 rte_port_source_create(void *params, int socket_id)
 239 {
 240         struct rte_port_source_params *p =
 241                         (struct rte_port_source_params *) params;
 242         struct rte_port_source *port;
 243
 244         /* Check input arguments*/
 245         if ((p == NULL) || (p->mempool == NULL)) {
 246                 RTE_LOG(ERR, PORT, "%s: Invalid params\n", __func__);
 247                 return NULL;
 248         }
 249
 250         /* Memory allocation */
 251         port = rte_zmalloc_socket("PORT", sizeof(*port),
 252                         RTE_CACHE_LINE_SIZE, socket_id);
 253         if (port == NULL) {
 254                 RTE_LOG(ERR, PORT, "%s: Failed to allocate port\n", __func__);
 255                 return NULL;
 256         }
 257
 258         /* Initialization */
 259         port->mempool = (struct rte_mempool *) p->mempool;
 260
 261 #ifdef RTE_NEXT_ABI
 262
 263         if (p->file_name) {
 264                 int status = PCAP_SOURCE_LOAD(port, p->file_name,
 265                         p->n_bytes_per_pkt, socket_id);
 266
 267                 if (status < 0) {
 268                         rte_free(port);
 269                         port = NULL;
 270                 }
 271         }
 272
 273 #endif
 274
 275         return port;
 276 }
 277
 278 static int
 279 rte_port_source_free(void *port)
 280 {
 281         struct rte_port_source *p =
 282                         (struct rte_port_source *)port;
 283
 284         /* Check input parameters */
 285         if (p == NULL)
 286                 return 0;
 287
 288         if (p->pkt_len)
 289                 rte_free(p->pkt_len);
 290         if (p->pkts)
 291                 rte_free(p->pkts);
 292         if (p->pkt_buff)
 293                 rte_free(p->pkt_buff);
 294
 295         rte_free(p);
 296
 297         return 0;
 298 }
 299
 300 static int
 301 rte_port_source_rx(void *port, struct rte_mbuf **pkts, uint32_t n_pkts)
 302 {
 303         struct rte_port_source *p = (struct rte_port_source *) port;
 304         uint32_t i;
 305
 306         if (rte_mempool_get_bulk(p->mempool, (void **) pkts, n_pkts) != 0)
 307                 return 0;
 308
 309         for (i = 0; i < n_pkts; i++) {
 310                 rte_mbuf_refcnt_set(pkts[i], 1);
 311                 rte_pktmbuf_reset(pkts[i]);
 312         }
 313
 314         if (p->pkt_buff != NULL) {
 315                 for (i = 0; i < n_pkts; i++) {
 316                         uint8_t *pkt_data = rte_pktmbuf_mtod(pkts[i],
 317                                 uint8_t *);
 318
 319                         rte_memcpy(pkt_data, p->pkts[p->pkt_index],
 320                                         p->pkt_len[p->pkt_index]);
 321                         pkts[i]->data_len = p->pkt_len[p->pkt_index];
 322                         pkts[i]->pkt_len = pkts[i]->data_len;
 323
 324                         p->pkt_index++;
 325                         if (p->pkt_index >= p->n_pkts)
 326                                 p->pkt_index = 0;
 327                 }
 328         }
 329
 330         RTE_PORT_SOURCE_STATS_PKTS_IN_ADD(p, n_pkts);
 331
 332         return n_pkts;
 333 }
 334
 335 static int
 336 rte_port_source_stats_read(void *port,
 337                 struct rte_port_in_stats *stats, int clear)
 338 {
 339         struct rte_port_source *p =
 340                 (struct rte_port_source *) port;
 341
 342         if (stats != NULL)
 343                 memcpy(stats, &p->stats, sizeof(p->stats));
 344
 345         if (clear)
 346                 memset(&p->stats, 0, sizeof(p->stats));
 347
 348         return 0;
 349 }
 350
 351 /*
 352  * Port SINK
 353  */
 354 #ifdef RTE_PORT_STATS_COLLECT
 355
 356 #define RTE_PORT_SINK_STATS_PKTS_IN_ADD(port, val) \
 357         (port->stats.n_pkts_in += val)
 358 #define RTE_PORT_SINK_STATS_PKTS_DROP_ADD(port, val) \
 359         (port->stats.n_pkts_drop += val)
 360
 361 #else
 362
 363 #define RTE_PORT_SINK_STATS_PKTS_IN_ADD(port, val)
 364 #define RTE_PORT_SINK_STATS_PKTS_DROP_ADD(port, val)
 365
 366 #endif
 367
 368 struct rte_port_sink {
 369         struct rte_port_out_stats stats;
 370
 371         /* PCAP dumper handle and pkts number */
 372         void *dumper;
 373         uint32_t max_pkts;
 374         uint32_t pkt_index;
 375         uint32_t dump_finish;
 376 };
 377
 378 #ifdef RTE_PORT_PCAP
 379
 380 static int
 381 pcap_sink_open(struct rte_port_sink *port,
 382         const char *file_name,
 383         uint32_t max_n_pkts)
 384 {
 385         pcap_t *tx_pcap;
 386         pcap_dumper_t *pcap_dumper;
 387
 388         /** Open a dead pcap handler for opening dumper file */
 389         tx_pcap = pcap_open_dead(DLT_EN10MB, 65535);
 390         if (tx_pcap == NULL) {
 391                 RTE_LOG(ERR, PORT, "Cannot open pcap dead handler\n");
 392                 return -1;
 393         }
 394
 395         /* The dumper is created using the previous pcap_t reference */
 396         pcap_dumper = pcap_dump_open(tx_pcap, file_name);
 397         if (pcap_dumper == NULL) {
 398                 RTE_LOG(ERR, PORT, "Failed to open pcap file "
 399                         "\"%s\" for writing\n", file_name);
 400                 return -1;
 401         }
 402
 403         port->dumper = pcap_dumper;
 404         port->max_pkts = max_n_pkts;
 405         port->pkt_index = 0;
 406         port->dump_finish = 0;
 407
 408         RTE_LOG(INFO, PORT, "Ready to dump packets to file \"%s\"\n",
 409                 file_name);
 410
 411         return 0;
 412 }
 413
 414 static void
 415 pcap_sink_write_pkt(struct rte_port_sink *port, struct rte_mbuf *mbuf)
 416 {
 417         uint8_t *pcap_dumper = (uint8_t *)(port->dumper);
 418         struct pcap_pkthdr pcap_hdr;
 419         uint8_t jumbo_pkt_buf[ETHER_MAX_JUMBO_FRAME_LEN];
 420         uint8_t *pkt;
 421
 422         /* Maximum num packets already reached */
 423         if (port->dump_finish)
 424                 return;
 425
 426         pkt = rte_pktmbuf_mtod(mbuf, uint8_t *);
 427
 428         pcap_hdr.len = mbuf->pkt_len;
 429         pcap_hdr.caplen = pcap_hdr.len;
 430         gettimeofday(&(pcap_hdr.ts), NULL);
 431
 432         if (mbuf->nb_segs > 1) {
 433                 struct rte_mbuf *jumbo_mbuf;
 434                 uint32_t pkt_index = 0;
 435
 436                 /* if packet size longer than ETHER_MAX_JUMBO_FRAME_LEN,
 437                  * ignore it.
 438                  */
 439                 if (mbuf->pkt_len > ETHER_MAX_JUMBO_FRAME_LEN)
 440                         return;
 441
 442                 for (jumbo_mbuf = mbuf; jumbo_mbuf != NULL;
 443                                 jumbo_mbuf = jumbo_mbuf->next) {
 444                         rte_memcpy(&jumbo_pkt_buf[pkt_index],
 445                                 rte_pktmbuf_mtod(jumbo_mbuf, uint8_t *),
 446                                 jumbo_mbuf->data_len);
 447                         pkt_index += jumbo_mbuf->data_len;
 448                 }
 449
 450                 jumbo_pkt_buf[pkt_index] = '\0';
 451
 452                 pkt = jumbo_pkt_buf;
 453         }
 454
 455         pcap_dump(pcap_dumper, &pcap_hdr, pkt);
 456
 457         port->pkt_index++;
 458
 459         if ((port->max_pkts != 0) && (port->pkt_index >= port->max_pkts)) {
 460                 port->dump_finish = 1;
 461                 RTE_LOG(INFO, PORT, "Dumped %u packets to file\n",
 462                                 port->pkt_index);
 463         }
 464
 465 }
 466
 467 #define PCAP_SINK_OPEN(port, file_name, max_n_pkts)             \
 468         pcap_sink_open(port, file_name, max_n_pkts)
 469
 470 #define PCAP_SINK_WRITE_PKT(port, mbuf)                         \
 471         pcap_sink_write_pkt(port, mbuf)
 472
 473 #define PCAP_SINK_FLUSH_PKT(dumper)                             \
 474 do {                                                            \
 475         if (dumper)                                             \
 476                 pcap_dump_flush((pcap_dumper_t *)dumper);       \
 477 } while (0)
 478
 479 #define PCAP_SINK_CLOSE(dumper)                                 \
 480 do {                                                            \
 481         if (dumper)                                             \
 482                 pcap_dump_close((pcap_dumper_t *)dumper);       \
 483 } while (0)
 484
 485 #else
 486
 487 #define PCAP_SINK_OPEN(port, file_name, max_n_pkts)             \
 488 ({                                                              \
 489         int _ret = 0;                                           \
 490                                                                 \
 491         if (file_name) {                                        \
 492                 RTE_LOG(ERR, PORT, "Sink port field "           \
 493                         "\"file_name\" is not NULL.\n");        \
 494                 _ret = -1;                                      \
 495         }                                                       \
 496                                                                 \
 497         _ret;                                                   \
 498 })
 499
 500 #define PCAP_SINK_WRITE_PKT(port, mbuf) {}
 501
 502 #define PCAP_SINK_FLUSH_PKT(dumper)
 503
 504 #define PCAP_SINK_CLOSE(dumper)
 505
 506 #endif
 507
 508 static void *
 509 rte_port_sink_create(void *params, int socket_id)
 510 {
 511         struct rte_port_sink *port;
 512         struct rte_port_sink_params *p = params;
 513
 514         /* Memory allocation */
 515         port = rte_zmalloc_socket("PORT", sizeof(*port),
 516                         RTE_CACHE_LINE_SIZE, socket_id);
 517         if (port == NULL) {
 518                 RTE_LOG(ERR, PORT, "%s: Failed to allocate port\n", __func__);
 519                 return NULL;
 520         }
 521
 522         if (!p)
 523                 return port;
 524
 525         if (p->file_name) {
 526                 int status = PCAP_SINK_OPEN(port, p->file_name,
 527                         p->max_n_pkts);
 528
 529                 if (status < 0) {
 530                         rte_free(port);
 531                         port = NULL;
 532                 }
 533         }
 534
 535         return port;
 536 }
 537
 538 static int
 539 rte_port_sink_tx(void *port, struct rte_mbuf *pkt)
 540 {
 541         struct rte_port_sink *p = (struct rte_port_sink *) port;
 542
 543         RTE_PORT_SINK_STATS_PKTS_IN_ADD(p, 1);
 544         if (p->dumper != NULL)
 545                 PCAP_SINK_WRITE_PKT(p, pkt);
 546         rte_pktmbuf_free(pkt);
 547         RTE_PORT_SINK_STATS_PKTS_DROP_ADD(p, 1);
 548
 549         return 0;
 550 }
 551
 552 static int
 553 rte_port_sink_tx_bulk(void *port, struct rte_mbuf **pkts,
 554         uint64_t pkts_mask)
 555 {
 556         struct rte_port_sink *p = (struct rte_port_sink *) port;
 557
 558         if ((pkts_mask & (pkts_mask + 1)) == 0) {
 559                 uint64_t n_pkts = __builtin_popcountll(pkts_mask);
 560                 uint32_t i;
 561
 562                 RTE_PORT_SINK_STATS_PKTS_IN_ADD(p, n_pkts);
 563                 RTE_PORT_SINK_STATS_PKTS_DROP_ADD(p, n_pkts);
 564
 565                 if (p->dumper) {
 566                         for (i = 0; i < n_pkts; i++)
 567                                 PCAP_SINK_WRITE_PKT(p, pkts[i]);
 568                 }
 569
 570                 for (i = 0; i < n_pkts; i++) {
 571                         struct rte_mbuf *pkt = pkts[i];
 572
 573                         rte_pktmbuf_free(pkt);
 574                 }
 575
 576         } else {
 577                 if (p->dumper) {
 578                         uint64_t dump_pkts_mask = pkts_mask;
 579                         uint32_t pkt_index;
 580
 581                         for ( ; dump_pkts_mask; ) {
 582                                 pkt_index = __builtin_ctzll(
 583                                         dump_pkts_mask);
 584                                 PCAP_SINK_WRITE_PKT(p, pkts[pkt_index]);
 585                                 dump_pkts_mask &= ~(1LLU << pkt_index);
 586                         }
 587                 }
 588
 589                 for ( ; pkts_mask; ) {
 590                         uint32_t pkt_index = __builtin_ctzll(pkts_mask);
 591                         uint64_t pkt_mask = 1LLU << pkt_index;
 592                         struct rte_mbuf *pkt = pkts[pkt_index];
 593
 594                         RTE_PORT_SINK_STATS_PKTS_IN_ADD(p, 1);
 595                         RTE_PORT_SINK_STATS_PKTS_DROP_ADD(p, 1);
 596                         rte_pktmbuf_free(pkt);
 597                         pkts_mask &= ~pkt_mask;
 598                 }
 599         }
 600
 601         return 0;
 602 }
 603
 604 static int
 605 rte_port_sink_flush(void *port)
 606 {
 607         struct rte_port_sink *p =
 608                         (struct rte_port_sink *)port;
 609
 610         if (p == NULL)
 611                 return 0;
 612
 613         PCAP_SINK_FLUSH_PKT(p->dumper);
 614
 615         return 0;
 616 }
 617
 618 static int
 619 rte_port_sink_free(void *port)
 620 {
 621         struct rte_port_sink *p =
 622                         (struct rte_port_sink *)port;
 623
 624         if (p == NULL)
 625                 return 0;
 626
 627         PCAP_SINK_CLOSE(p->dumper);
 628
 629         rte_free(p);
 630
 631         return 0;
 632 }
 633
 634 static int
 635 rte_port_sink_stats_read(void *port, struct rte_port_out_stats *stats,
 636                 int clear)
 637 {
 638         struct rte_port_sink *p =
 639                 (struct rte_port_sink *) port;
 640
 641         if (stats != NULL)
 642                 memcpy(stats, &p->stats, sizeof(p->stats));
 643
 644         if (clear)
 645                 memset(&p->stats, 0, sizeof(p->stats));
 646
 647         return 0;
 648 }
 649
 650 /*
 651  * Summary of port operations
 652  */
 653 struct rte_port_in_ops rte_port_source_ops = {
 654         .f_create = rte_port_source_create,
 655         .f_free = rte_port_source_free,
 656         .f_rx = rte_port_source_rx,
 657         .f_stats = rte_port_source_stats_read,
 658 };
 659
 660 struct rte_port_out_ops rte_port_sink_ops = {
 661         .f_create = rte_port_sink_create,
 662         .f_free = rte_port_sink_free,
 663         .f_tx = rte_port_sink_tx,
 664         .f_tx_bulk = rte_port_sink_tx_bulk,
 665         .f_flush = rte_port_sink_flush,
 666         .f_stats = rte_port_sink_stats_read,
 667 };