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_atomic.h>
35 #include <rte_debug.h>
37 #include <rte_ethdev.h>
39 #include "failsafe_private.h"
42 fs_rx_unsafe(struct sub_device *sdev)
44 return (ETH(sdev) == NULL) ||
45 (ETH(sdev)->rx_pkt_burst == NULL) ||
46 (sdev->state != DEV_STARTED) ||
51 fs_tx_unsafe(struct sub_device *sdev)
53 return (sdev == NULL) ||
54 (ETH(sdev) == NULL) ||
55 (ETH(sdev)->tx_pkt_burst == NULL) ||
56 (sdev->state != DEV_STARTED);
60 set_burst_fn(struct rte_eth_dev *dev, int force_safe)
62 struct sub_device *sdev;
67 need_safe = force_safe;
68 FOREACH_SUBDEV(sdev, i, dev)
69 need_safe |= fs_rx_unsafe(sdev);
70 safe_set = (dev->rx_pkt_burst == &failsafe_rx_burst);
71 if (need_safe && !safe_set) {
72 DEBUG("Using safe RX bursts%s",
73 (force_safe ? " (forced)" : ""));
74 dev->rx_pkt_burst = &failsafe_rx_burst;
75 } else if (!need_safe && safe_set) {
76 DEBUG("Using fast RX bursts");
77 dev->rx_pkt_burst = &failsafe_rx_burst_fast;
79 need_safe = force_safe || fs_tx_unsafe(TX_SUBDEV(dev));
80 safe_set = (dev->tx_pkt_burst == &failsafe_tx_burst);
81 if (need_safe && !safe_set) {
82 DEBUG("Using safe TX bursts%s",
83 (force_safe ? " (forced)" : ""));
84 dev->tx_pkt_burst = &failsafe_tx_burst;
85 } else if (!need_safe && safe_set) {
86 DEBUG("Using fast TX bursts");
87 dev->tx_pkt_burst = &failsafe_tx_burst_fast;
93 failsafe_rx_burst(void *queue,
94 struct rte_mbuf **rx_pkts,
98 struct sub_device *sdev;
102 uint8_t nb_polled, nb_subs;
107 nb_subs = priv->subs_tail - priv->subs_head;
109 for (i = rxq->last_polled; nb_polled < nb_subs; nb_polled++) {
111 if (i == priv->subs_tail)
113 sdev = &priv->subs[i];
114 if (unlikely(fs_rx_unsafe(sdev)))
116 sub_rxq = ETH(sdev)->data->rx_queues[rxq->qid];
117 FS_ATOMIC_P(rxq->refcnt[sdev->sid]);
119 rx_pkt_burst(sub_rxq, rx_pkts, nb_pkts);
120 FS_ATOMIC_V(rxq->refcnt[sdev->sid]);
122 rxq->last_polled = i;
130 failsafe_rx_burst_fast(void *queue,
131 struct rte_mbuf **rx_pkts,
134 struct fs_priv *priv;
135 struct sub_device *sdev;
139 uint8_t nb_polled, nb_subs;
144 nb_subs = priv->subs_tail - priv->subs_head;
146 for (i = rxq->last_polled; nb_polled < nb_subs; nb_polled++) {
148 if (i == priv->subs_tail)
150 sdev = &priv->subs[i];
151 RTE_ASSERT(!fs_rx_unsafe(sdev));
152 sub_rxq = ETH(sdev)->data->rx_queues[rxq->qid];
153 FS_ATOMIC_P(rxq->refcnt[sdev->sid]);
155 rx_pkt_burst(sub_rxq, rx_pkts, nb_pkts);
156 FS_ATOMIC_V(rxq->refcnt[sdev->sid]);
158 rxq->last_polled = i;
166 failsafe_tx_burst(void *queue,
167 struct rte_mbuf **tx_pkts,
170 struct sub_device *sdev;
176 sdev = TX_SUBDEV(txq->priv->dev);
177 if (unlikely(fs_tx_unsafe(sdev)))
179 sub_txq = ETH(sdev)->data->tx_queues[txq->qid];
180 FS_ATOMIC_P(txq->refcnt[sdev->sid]);
181 nb_tx = ETH(sdev)->tx_pkt_burst(sub_txq, tx_pkts, nb_pkts);
182 FS_ATOMIC_V(txq->refcnt[sdev->sid]);
187 failsafe_tx_burst_fast(void *queue,
188 struct rte_mbuf **tx_pkts,
191 struct sub_device *sdev;
197 sdev = TX_SUBDEV(txq->priv->dev);
198 RTE_ASSERT(!fs_tx_unsafe(sdev));
199 sub_txq = ETH(sdev)->data->tx_queues[txq->qid];
200 FS_ATOMIC_P(txq->refcnt[sdev->sid]);
201 nb_tx = ETH(sdev)->tx_pkt_burst(sub_txq, tx_pkts, nb_pkts);
202 FS_ATOMIC_V(txq->refcnt[sdev->sid]);