drivers/net/failsafe/failsafe_rxtx.c

   1 /*-
   2  *   BSD LICENSE
   3  *
   4  *   Copyright 2017 6WIND S.A.
   5  *   Copyright 2017 Mellanox.
   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 6WIND S.A. 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
  34 #include <rte_mbuf.h>
  35 #include <rte_ethdev.h>
  36
  37 #include "failsafe_private.h"
  38
  39 /*
  40  * TODO: write fast version,
  41  * without additional checks, to be activated once
  42  * everything has been verified to comply.
  43  */
  44 uint16_t
  45 failsafe_rx_burst(void *queue,
  46                   struct rte_mbuf **rx_pkts,
  47                   uint16_t nb_pkts)
  48 {
  49         struct fs_priv *priv;
  50         struct sub_device *sdev;
  51         struct rxq *rxq;
  52         void *sub_rxq;
  53         uint16_t nb_rx;
  54         uint8_t nb_polled, nb_subs;
  55         uint8_t i;
  56
  57         rxq = queue;
  58         priv = rxq->priv;
  59         nb_subs = priv->subs_tail - priv->subs_head;
  60         nb_polled = 0;
  61         for (i = rxq->last_polled; nb_polled < nb_subs; nb_polled++) {
  62                 i++;
  63                 if (i == priv->subs_tail)
  64                         i = priv->subs_head;
  65                 sdev = &priv->subs[i];
  66                 if (unlikely(ETH(sdev) == NULL))
  67                         continue;
  68                 if (unlikely(ETH(sdev)->rx_pkt_burst == NULL))
  69                         continue;
  70                 if (unlikely(sdev->state != DEV_STARTED))
  71                         continue;
  72                 sub_rxq = ETH(sdev)->data->rx_queues[rxq->qid];
  73                 nb_rx = ETH(sdev)->
  74                         rx_pkt_burst(sub_rxq, rx_pkts, nb_pkts);
  75                 if (nb_rx) {
  76                         rxq->last_polled = i;
  77                         return nb_rx;
  78                 }
  79         }
  80         return 0;
  81 }
  82
  83 /*
  84  * TODO: write fast version,
  85  * without additional checks, to be activated once
  86  * everything has been verified to comply.
  87  */
  88 uint16_t
  89 failsafe_tx_burst(void *queue,
  90                   struct rte_mbuf **tx_pkts,
  91                   uint16_t nb_pkts)
  92 {
  93         struct sub_device *sdev;
  94         struct txq *txq;
  95         void *sub_txq;
  96
  97         txq = queue;
  98         sdev = TX_SUBDEV(txq->priv->dev);
  99         if (unlikely(sdev == NULL))
 100                 return 0;
 101         if (unlikely(ETH(sdev) == NULL))
 102                 return 0;
 103         if (unlikely(ETH(sdev)->tx_pkt_burst == NULL))
 104                 return 0;
 105         sub_txq = ETH(sdev)->data->tx_queues[txq->qid];
 106         return ETH(sdev)->tx_pkt_burst(sub_txq, tx_pkts, nb_pkts);
 107 }