4 * Copyright 2017 6WIND S.A.
5 * Copyright 2017 Mellanox.
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
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
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.
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.
34 #include <rte_debug.h>
36 #include <rte_ethdev.h>
38 #include "failsafe_private.h"
41 fs_rx_unsafe(struct sub_device *sdev)
43 return (ETH(sdev) == NULL) ||
44 (ETH(sdev)->rx_pkt_burst == NULL) ||
45 (sdev->state != DEV_STARTED);
49 fs_tx_unsafe(struct sub_device *sdev)
51 return (sdev == NULL) ||
52 (ETH(sdev) == NULL) ||
53 (ETH(sdev)->tx_pkt_burst == NULL) ||
54 (sdev->state != DEV_STARTED);
58 set_burst_fn(struct rte_eth_dev *dev, int force_safe)
60 struct sub_device *sdev;
65 need_safe = force_safe;
66 FOREACH_SUBDEV(sdev, i, dev)
67 need_safe |= fs_rx_unsafe(sdev);
68 safe_set = (dev->rx_pkt_burst == &failsafe_rx_burst);
69 if (need_safe && !safe_set) {
70 DEBUG("Using safe RX bursts%s",
71 (force_safe ? " (forced)" : ""));
72 dev->rx_pkt_burst = &failsafe_rx_burst;
73 } else if (!need_safe && safe_set) {
74 DEBUG("Using fast RX bursts");
75 dev->rx_pkt_burst = &failsafe_rx_burst_fast;
77 need_safe = force_safe || fs_tx_unsafe(TX_SUBDEV(dev));
78 safe_set = (dev->tx_pkt_burst == &failsafe_tx_burst);
79 if (need_safe && !safe_set) {
80 DEBUG("Using safe TX bursts%s",
81 (force_safe ? " (forced)" : ""));
82 dev->tx_pkt_burst = &failsafe_tx_burst;
83 } else if (!need_safe && safe_set) {
84 DEBUG("Using fast TX bursts");
85 dev->tx_pkt_burst = &failsafe_tx_burst_fast;
91 failsafe_rx_burst(void *queue,
92 struct rte_mbuf **rx_pkts,
96 struct sub_device *sdev;
100 uint8_t nb_polled, nb_subs;
105 nb_subs = priv->subs_tail - priv->subs_head;
107 for (i = rxq->last_polled; nb_polled < nb_subs; nb_polled++) {
109 if (i == priv->subs_tail)
111 sdev = &priv->subs[i];
112 if (unlikely(fs_rx_unsafe(sdev)))
114 sub_rxq = ETH(sdev)->data->rx_queues[rxq->qid];
116 rx_pkt_burst(sub_rxq, rx_pkts, nb_pkts);
118 rxq->last_polled = i;
126 failsafe_rx_burst_fast(void *queue,
127 struct rte_mbuf **rx_pkts,
130 struct fs_priv *priv;
131 struct sub_device *sdev;
135 uint8_t nb_polled, nb_subs;
140 nb_subs = priv->subs_tail - priv->subs_head;
142 for (i = rxq->last_polled; nb_polled < nb_subs; nb_polled++) {
144 if (i == priv->subs_tail)
146 sdev = &priv->subs[i];
147 RTE_ASSERT(!fs_rx_unsafe(sdev));
148 sub_rxq = ETH(sdev)->data->rx_queues[rxq->qid];
150 rx_pkt_burst(sub_rxq, rx_pkts, nb_pkts);
152 rxq->last_polled = i;
160 failsafe_tx_burst(void *queue,
161 struct rte_mbuf **tx_pkts,
164 struct sub_device *sdev;
169 sdev = TX_SUBDEV(txq->priv->dev);
170 if (unlikely(fs_tx_unsafe(sdev)))
172 sub_txq = ETH(sdev)->data->tx_queues[txq->qid];
173 return ETH(sdev)->tx_pkt_burst(sub_txq, tx_pkts, nb_pkts);
177 failsafe_tx_burst_fast(void *queue,
178 struct rte_mbuf **tx_pkts,
181 struct sub_device *sdev;
186 sdev = TX_SUBDEV(txq->priv->dev);
187 RTE_ASSERT(!fs_tx_unsafe(sdev));
188 sub_txq = ETH(sdev)->data->tx_queues[txq->qid];
189 return ETH(sdev)->tx_pkt_burst(sub_txq, tx_pkts, nb_pkts);