lib/librte_port/rte_port_ethdev.c

   1 /*-
   2  *   BSD LICENSE
   3  *
   4  *   Copyright(c) 2010-2014 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 <string.h>
  34 #include <stdint.h>
  35
  36 #include <rte_mbuf.h>
  37 #include <rte_ethdev.h>
  38 #include <rte_malloc.h>
  39
  40 #include "rte_port_ethdev.h"
  41
  42 /*
  43  * Port ETHDEV Reader
  44  */
  45 #ifdef RTE_PORT_STATS_COLLECT
  46
  47 #define RTE_PORT_ETHDEV_READER_STATS_PKTS_IN_ADD(port, val) \
  48         port->stats.n_pkts_in += val
  49 #define RTE_PORT_ETHDEV_READER_STATS_PKTS_DROP_ADD(port, val) \
  50         port->stats.n_pkts_drop += val
  51
  52 #else
  53
  54 #define RTE_PORT_ETHDEV_READER_STATS_PKTS_IN_ADD(port, val)
  55 #define RTE_PORT_ETHDEV_READER_STATS_PKTS_DROP_ADD(port, val)
  56
  57 #endif
  58
  59 struct rte_port_ethdev_reader {
  60         struct rte_port_in_stats stats;
  61
  62         uint16_t queue_id;
  63         uint8_t port_id;
  64 };
  65
  66 static void *
  67 rte_port_ethdev_reader_create(void *params, int socket_id)
  68 {
  69         struct rte_port_ethdev_reader_params *conf =
  70                         (struct rte_port_ethdev_reader_params *) params;
  71         struct rte_port_ethdev_reader *port;
  72
  73         /* Check input parameters */
  74         if (conf == NULL) {
  75                 RTE_LOG(ERR, PORT, "%s: params is NULL\n", __func__);
  76                 return NULL;
  77         }
  78
  79         /* Memory allocation */
  80         port = rte_zmalloc_socket("PORT", sizeof(*port),
  81                         RTE_CACHE_LINE_SIZE, socket_id);
  82         if (port == NULL) {
  83                 RTE_LOG(ERR, PORT, "%s: Failed to allocate port\n", __func__);
  84                 return NULL;
  85         }
  86
  87         /* Initialization */
  88         port->port_id = conf->port_id;
  89         port->queue_id = conf->queue_id;
  90
  91         return port;
  92 }
  93
  94 static int
  95 rte_port_ethdev_reader_rx(void *port, struct rte_mbuf **pkts, uint32_t n_pkts)
  96 {
  97         struct rte_port_ethdev_reader *p =
  98                 (struct rte_port_ethdev_reader *) port;
  99         uint16_t rx_pkt_cnt;
 100
 101         rx_pkt_cnt = rte_eth_rx_burst(p->port_id, p->queue_id, pkts, n_pkts);
 102         RTE_PORT_ETHDEV_READER_STATS_PKTS_IN_ADD(p, rx_pkt_cnt);
 103         return rx_pkt_cnt;
 104 }
 105
 106 static int
 107 rte_port_ethdev_reader_free(void *port)
 108 {
 109         if (port == NULL) {
 110                 RTE_LOG(ERR, PORT, "%s: port is NULL\n", __func__);
 111                 return -EINVAL;
 112         }
 113
 114         rte_free(port);
 115
 116         return 0;
 117 }
 118
 119 static int rte_port_ethdev_reader_stats_read(void *port,
 120                 struct rte_port_in_stats *stats, int clear)
 121 {
 122         struct rte_port_ethdev_reader *p =
 123                         (struct rte_port_ethdev_reader *) port;
 124
 125         if (stats != NULL)
 126                 memcpy(stats, &p->stats, sizeof(p->stats));
 127
 128         if (clear)
 129                 memset(&p->stats, 0, sizeof(p->stats));
 130
 131         return 0;
 132 }
 133
 134 /*
 135  * Port ETHDEV Writer
 136  */
 137 #ifdef RTE_PORT_STATS_COLLECT
 138
 139 #define RTE_PORT_ETHDEV_WRITER_STATS_PKTS_IN_ADD(port, val) \
 140         port->stats.n_pkts_in += val
 141 #define RTE_PORT_ETHDEV_WRITER_STATS_PKTS_DROP_ADD(port, val) \
 142         port->stats.n_pkts_drop += val
 143
 144 #else
 145
 146 #define RTE_PORT_ETHDEV_WRITER_STATS_PKTS_IN_ADD(port, val)
 147 #define RTE_PORT_ETHDEV_WRITER_STATS_PKTS_DROP_ADD(port, val)
 148
 149 #endif
 150
 151 struct rte_port_ethdev_writer {
 152         struct rte_port_out_stats stats;
 153
 154         struct rte_mbuf *tx_buf[2 * RTE_PORT_IN_BURST_SIZE_MAX];
 155         uint32_t tx_burst_sz;
 156         uint16_t tx_buf_count;
 157         uint64_t bsz_mask;
 158         uint16_t queue_id;
 159         uint8_t port_id;
 160 };
 161
 162 static void *
 163 rte_port_ethdev_writer_create(void *params, int socket_id)
 164 {
 165         struct rte_port_ethdev_writer_params *conf =
 166                         (struct rte_port_ethdev_writer_params *) params;
 167         struct rte_port_ethdev_writer *port;
 168
 169         /* Check input parameters */
 170         if ((conf == NULL) ||
 171                 (conf->tx_burst_sz == 0) ||
 172                 (conf->tx_burst_sz > RTE_PORT_IN_BURST_SIZE_MAX) ||
 173                 (!rte_is_power_of_2(conf->tx_burst_sz))) {
 174                 RTE_LOG(ERR, PORT, "%s: Invalid input parameters\n", __func__);
 175                 return NULL;
 176         }
 177
 178         /* Memory allocation */
 179         port = rte_zmalloc_socket("PORT", sizeof(*port),
 180                         RTE_CACHE_LINE_SIZE, socket_id);
 181         if (port == NULL) {
 182                 RTE_LOG(ERR, PORT, "%s: Failed to allocate port\n", __func__);
 183                 return NULL;
 184         }
 185
 186         /* Initialization */
 187         port->port_id = conf->port_id;
 188         port->queue_id = conf->queue_id;
 189         port->tx_burst_sz = conf->tx_burst_sz;
 190         port->tx_buf_count = 0;
 191         port->bsz_mask = 1LLU << (conf->tx_burst_sz - 1);
 192
 193         return port;
 194 }
 195
 196 static inline void
 197 send_burst(struct rte_port_ethdev_writer *p)
 198 {
 199         uint32_t nb_tx;
 200
 201         nb_tx = rte_eth_tx_burst(p->port_id, p->queue_id,
 202                          p->tx_buf, p->tx_buf_count);
 203
 204         RTE_PORT_ETHDEV_WRITER_STATS_PKTS_DROP_ADD(p, p->tx_buf_count - nb_tx);
 205         for ( ; nb_tx < p->tx_buf_count; nb_tx++)
 206                 rte_pktmbuf_free(p->tx_buf[nb_tx]);
 207
 208         p->tx_buf_count = 0;
 209 }
 210
 211 static int
 212 rte_port_ethdev_writer_tx(void *port, struct rte_mbuf *pkt)
 213 {
 214         struct rte_port_ethdev_writer *p =
 215                 (struct rte_port_ethdev_writer *) port;
 216
 217         p->tx_buf[p->tx_buf_count++] = pkt;
 218         RTE_PORT_ETHDEV_WRITER_STATS_PKTS_IN_ADD(p, 1);
 219         if (p->tx_buf_count >= p->tx_burst_sz)
 220                 send_burst(p);
 221
 222         return 0;
 223 }
 224
 225 static int
 226 rte_port_ethdev_writer_tx_bulk(void *port,
 227                 struct rte_mbuf **pkts,
 228                 uint64_t pkts_mask)
 229 {
 230         struct rte_port_ethdev_writer *p =
 231                 (struct rte_port_ethdev_writer *) port;
 232         uint32_t bsz_mask = p->bsz_mask;
 233         uint32_t tx_buf_count = p->tx_buf_count;
 234         uint64_t expr = (pkts_mask & (pkts_mask + 1)) |
 235                         ((pkts_mask & bsz_mask) ^ bsz_mask);
 236
 237         if (expr == 0) {
 238                 uint64_t n_pkts = __builtin_popcountll(pkts_mask);
 239                 uint32_t n_pkts_ok;
 240
 241                 if (tx_buf_count)
 242                         send_burst(p);
 243
 244                 RTE_PORT_ETHDEV_WRITER_STATS_PKTS_IN_ADD(p, n_pkts);
 245                 n_pkts_ok = rte_eth_tx_burst(p->port_id, p->queue_id, pkts,
 246                         n_pkts);
 247
 248                 RTE_PORT_ETHDEV_WRITER_STATS_PKTS_DROP_ADD(p, n_pkts - n_pkts_ok);
 249                 for ( ; n_pkts_ok < n_pkts; n_pkts_ok++) {
 250                         struct rte_mbuf *pkt = pkts[n_pkts_ok];
 251
 252                         rte_pktmbuf_free(pkt);
 253                 }
 254         } else {
 255                 for ( ; pkts_mask; ) {
 256                         uint32_t pkt_index = __builtin_ctzll(pkts_mask);
 257                         uint64_t pkt_mask = 1LLU << pkt_index;
 258                         struct rte_mbuf *pkt = pkts[pkt_index];
 259
 260                         p->tx_buf[tx_buf_count++] = pkt;
 261                         RTE_PORT_ETHDEV_WRITER_STATS_PKTS_IN_ADD(p, 1);
 262                         pkts_mask &= ~pkt_mask;
 263                 }
 264
 265                 p->tx_buf_count = tx_buf_count;
 266                 if (tx_buf_count >= p->tx_burst_sz)
 267                         send_burst(p);
 268         }
 269
 270         return 0;
 271 }
 272
 273 static int
 274 rte_port_ethdev_writer_flush(void *port)
 275 {
 276         struct rte_port_ethdev_writer *p =
 277                 (struct rte_port_ethdev_writer *) port;
 278
 279         if (p->tx_buf_count > 0)
 280                 send_burst(p);
 281
 282         return 0;
 283 }
 284
 285 static int
 286 rte_port_ethdev_writer_free(void *port)
 287 {
 288         if (port == NULL) {
 289                 RTE_LOG(ERR, PORT, "%s: Port is NULL\n", __func__);
 290                 return -EINVAL;
 291         }
 292
 293         rte_port_ethdev_writer_flush(port);
 294         rte_free(port);
 295
 296         return 0;
 297 }
 298
 299 static int rte_port_ethdev_writer_stats_read(void *port,
 300                 struct rte_port_out_stats *stats, int clear)
 301 {
 302         struct rte_port_ethdev_writer *p =
 303                 (struct rte_port_ethdev_writer *) port;
 304
 305         if (stats != NULL)
 306                 memcpy(stats, &p->stats, sizeof(p->stats));
 307
 308         if (clear)
 309                 memset(&p->stats, 0, sizeof(p->stats));
 310
 311         return 0;
 312 }
 313
 314 /*
 315  * Port ETHDEV Writer Nodrop
 316  */
 317 #ifdef RTE_PORT_STATS_COLLECT
 318
 319 #define RTE_PORT_ETHDEV_WRITER_NODROP_STATS_PKTS_IN_ADD(port, val) \
 320         port->stats.n_pkts_in += val
 321 #define RTE_PORT_ETHDEV_WRITER_NODROP_STATS_PKTS_DROP_ADD(port, val) \
 322         port->stats.n_pkts_drop += val
 323
 324 #else
 325
 326 #define RTE_PORT_ETHDEV_WRITER_NODROP_STATS_PKTS_IN_ADD(port, val)
 327 #define RTE_PORT_ETHDEV_WRITER_NODROP_STATS_PKTS_DROP_ADD(port, val)
 328
 329 #endif
 330
 331 struct rte_port_ethdev_writer_nodrop {
 332         struct rte_port_out_stats stats;
 333
 334         struct rte_mbuf *tx_buf[2 * RTE_PORT_IN_BURST_SIZE_MAX];
 335         uint32_t tx_burst_sz;
 336         uint16_t tx_buf_count;
 337         uint64_t bsz_mask;
 338         uint64_t n_retries;
 339         uint16_t queue_id;
 340         uint8_t port_id;
 341 };
 342
 343 static void *
 344 rte_port_ethdev_writer_nodrop_create(void *params, int socket_id)
 345 {
 346         struct rte_port_ethdev_writer_nodrop_params *conf =
 347                         (struct rte_port_ethdev_writer_nodrop_params *) params;
 348         struct rte_port_ethdev_writer_nodrop *port;
 349
 350         /* Check input parameters */
 351         if ((conf == NULL) ||
 352                 (conf->tx_burst_sz == 0) ||
 353                 (conf->tx_burst_sz > RTE_PORT_IN_BURST_SIZE_MAX) ||
 354                 (!rte_is_power_of_2(conf->tx_burst_sz))) {
 355                 RTE_LOG(ERR, PORT, "%s: Invalid input parameters\n", __func__);
 356                 return NULL;
 357         }
 358
 359         /* Memory allocation */
 360         port = rte_zmalloc_socket("PORT", sizeof(*port),
 361                         RTE_CACHE_LINE_SIZE, socket_id);
 362         if (port == NULL) {
 363                 RTE_LOG(ERR, PORT, "%s: Failed to allocate port\n", __func__);
 364                 return NULL;
 365         }
 366
 367         /* Initialization */
 368         port->port_id = conf->port_id;
 369         port->queue_id = conf->queue_id;
 370         port->tx_burst_sz = conf->tx_burst_sz;
 371         port->tx_buf_count = 0;
 372         port->bsz_mask = 1LLU << (conf->tx_burst_sz - 1);
 373
 374         /*
 375          * When n_retries is 0 it means that we should wait for every packet to
 376          * send no matter how many retries should it take. To limit number of
 377          * branches in fast path, we use UINT64_MAX instead of branching.
 378          */
 379         port->n_retries = (conf->n_retries == 0) ? UINT64_MAX : conf->n_retries;
 380
 381         return port;
 382 }
 383
 384 static inline void
 385 send_burst_nodrop(struct rte_port_ethdev_writer_nodrop *p)
 386 {
 387         uint32_t nb_tx = 0, i;
 388
 389         nb_tx = rte_eth_tx_burst(p->port_id, p->queue_id, p->tx_buf,
 390                         p->tx_buf_count);
 391
 392         /* We sent all the packets in a first try */
 393         if (nb_tx >= p->tx_buf_count)
 394                 return;
 395
 396         for (i = 0; i < p->n_retries; i++) {
 397                 nb_tx += rte_eth_tx_burst(p->port_id, p->queue_id,
 398                                                          p->tx_buf + nb_tx, p->tx_buf_count - nb_tx);
 399
 400                 /* We sent all the packets in more than one try */
 401                 if (nb_tx >= p->tx_buf_count)
 402                         return;
 403         }
 404
 405         /* We didn't send the packets in maximum allowed attempts */
 406         RTE_PORT_ETHDEV_WRITER_NODROP_STATS_PKTS_DROP_ADD(p, p->tx_buf_count - nb_tx);
 407         for ( ; nb_tx < p->tx_buf_count; nb_tx++)
 408                 rte_pktmbuf_free(p->tx_buf[nb_tx]);
 409
 410         p->tx_buf_count = 0;
 411 }
 412
 413 static int
 414 rte_port_ethdev_writer_nodrop_tx(void *port, struct rte_mbuf *pkt)
 415 {
 416         struct rte_port_ethdev_writer_nodrop *p =
 417                 (struct rte_port_ethdev_writer_nodrop *) port;
 418
 419         p->tx_buf[p->tx_buf_count++] = pkt;
 420         RTE_PORT_ETHDEV_WRITER_NODROP_STATS_PKTS_IN_ADD(p, 1);
 421         if (p->tx_buf_count >= p->tx_burst_sz)
 422                 send_burst_nodrop(p);
 423
 424         return 0;
 425 }
 426
 427 static int
 428 rte_port_ethdev_writer_nodrop_tx_bulk(void *port,
 429                 struct rte_mbuf **pkts,
 430                 uint64_t pkts_mask)
 431 {
 432         struct rte_port_ethdev_writer_nodrop *p =
 433                 (struct rte_port_ethdev_writer_nodrop *) port;
 434
 435         uint32_t bsz_mask = p->bsz_mask;
 436         uint32_t tx_buf_count = p->tx_buf_count;
 437         uint64_t expr = (pkts_mask & (pkts_mask + 1)) |
 438                         ((pkts_mask & bsz_mask) ^ bsz_mask);
 439
 440         if (expr == 0) {
 441                 uint64_t n_pkts = __builtin_popcountll(pkts_mask);
 442                 uint32_t n_pkts_ok;
 443
 444                 if (tx_buf_count)
 445                         send_burst_nodrop(p);
 446
 447                 RTE_PORT_ETHDEV_WRITER_NODROP_STATS_PKTS_IN_ADD(p, n_pkts);
 448                 n_pkts_ok = rte_eth_tx_burst(p->port_id, p->queue_id, pkts,
 449                         n_pkts);
 450
 451                 if (n_pkts_ok >= n_pkts)
 452                         return 0;
 453
 454                 /*
 455                  * If we didnt manage to send all packets in single burst, move
 456                  * remaining packets to the buffer and call send burst.
 457                  */
 458                 for (; n_pkts_ok < n_pkts; n_pkts_ok++) {
 459                         struct rte_mbuf *pkt = pkts[n_pkts_ok];
 460                         p->tx_buf[p->tx_buf_count++] = pkt;
 461                 }
 462                 send_burst_nodrop(p);
 463         } else {
 464                 for ( ; pkts_mask; ) {
 465                         uint32_t pkt_index = __builtin_ctzll(pkts_mask);
 466                         uint64_t pkt_mask = 1LLU << pkt_index;
 467                         struct rte_mbuf *pkt = pkts[pkt_index];
 468
 469                         p->tx_buf[tx_buf_count++] = pkt;
 470                         RTE_PORT_ETHDEV_WRITER_NODROP_STATS_PKTS_IN_ADD(p, 1);
 471                         pkts_mask &= ~pkt_mask;
 472                 }
 473
 474                 p->tx_buf_count = tx_buf_count;
 475                 if (tx_buf_count >= p->tx_burst_sz)
 476                         send_burst_nodrop(p);
 477         }
 478
 479         return 0;
 480 }
 481
 482 static int
 483 rte_port_ethdev_writer_nodrop_flush(void *port)
 484 {
 485         struct rte_port_ethdev_writer_nodrop *p =
 486                 (struct rte_port_ethdev_writer_nodrop *) port;
 487
 488         if (p->tx_buf_count > 0)
 489                 send_burst_nodrop(p);
 490
 491         return 0;
 492 }
 493
 494 static int
 495 rte_port_ethdev_writer_nodrop_free(void *port)
 496 {
 497         if (port == NULL) {
 498                 RTE_LOG(ERR, PORT, "%s: Port is NULL\n", __func__);
 499                 return -EINVAL;
 500         }
 501
 502         rte_port_ethdev_writer_nodrop_flush(port);
 503         rte_free(port);
 504
 505         return 0;
 506 }
 507
 508 static int rte_port_ethdev_writer_nodrop_stats_read(void *port,
 509                 struct rte_port_out_stats *stats, int clear)
 510 {
 511         struct rte_port_ethdev_writer_nodrop *p =
 512                 (struct rte_port_ethdev_writer_nodrop *) port;
 513
 514         if (stats != NULL)
 515                 memcpy(stats, &p->stats, sizeof(p->stats));
 516
 517         if (clear)
 518                 memset(&p->stats, 0, sizeof(p->stats));
 519
 520         return 0;
 521 }
 522
 523 /*
 524  * Summary of port operations
 525  */
 526 struct rte_port_in_ops rte_port_ethdev_reader_ops = {
 527         .f_create = rte_port_ethdev_reader_create,
 528         .f_free = rte_port_ethdev_reader_free,
 529         .f_rx = rte_port_ethdev_reader_rx,
 530         .f_stats = rte_port_ethdev_reader_stats_read,
 531 };
 532
 533 struct rte_port_out_ops rte_port_ethdev_writer_ops = {
 534         .f_create = rte_port_ethdev_writer_create,
 535         .f_free = rte_port_ethdev_writer_free,
 536         .f_tx = rte_port_ethdev_writer_tx,
 537         .f_tx_bulk = rte_port_ethdev_writer_tx_bulk,
 538         .f_flush = rte_port_ethdev_writer_flush,
 539         .f_stats = rte_port_ethdev_writer_stats_read,
 540 };
 541
 542 struct rte_port_out_ops rte_port_ethdev_writer_nodrop_ops = {
 543         .f_create = rte_port_ethdev_writer_nodrop_create,
 544         .f_free = rte_port_ethdev_writer_nodrop_free,
 545         .f_tx = rte_port_ethdev_writer_nodrop_tx,
 546         .f_tx_bulk = rte_port_ethdev_writer_nodrop_tx_bulk,
 547         .f_flush = rte_port_ethdev_writer_nodrop_flush,
 548         .f_stats = rte_port_ethdev_writer_nodrop_stats_read,
 549 };