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);
50 fs_tx_unsafe(struct sub_device *sdev)
52 return (sdev == NULL) ||
53 (ETH(sdev) == NULL) ||
54 (ETH(sdev)->tx_pkt_burst == NULL) ||
55 (sdev->state != DEV_STARTED);
59 set_burst_fn(struct rte_eth_dev *dev, int force_safe)
61 struct sub_device *sdev;
66 need_safe = force_safe;
67 FOREACH_SUBDEV(sdev, i, dev)
68 need_safe |= fs_rx_unsafe(sdev);
69 safe_set = (dev->rx_pkt_burst == &failsafe_rx_burst);
70 if (need_safe && !safe_set) {
71 DEBUG("Using safe RX bursts%s",
72 (force_safe ? " (forced)" : ""));
73 dev->rx_pkt_burst = &failsafe_rx_burst;
74 } else if (!need_safe && safe_set) {
75 DEBUG("Using fast RX bursts");
76 dev->rx_pkt_burst = &failsafe_rx_burst_fast;
78 need_safe = force_safe || fs_tx_unsafe(TX_SUBDEV(dev));
79 safe_set = (dev->tx_pkt_burst == &failsafe_tx_burst);
80 if (need_safe && !safe_set) {
81 DEBUG("Using safe TX bursts%s",
82 (force_safe ? " (forced)" : ""));
83 dev->tx_pkt_burst = &failsafe_tx_burst;
84 } else if (!need_safe && safe_set) {
85 DEBUG("Using fast TX bursts");
86 dev->tx_pkt_burst = &failsafe_tx_burst_fast;
92 failsafe_rx_burst(void *queue,
93 struct rte_mbuf **rx_pkts,
97 struct sub_device *sdev;
101 uint8_t nb_polled, nb_subs;
106 nb_subs = priv->subs_tail - priv->subs_head;
108 for (i = rxq->last_polled; nb_polled < nb_subs; nb_polled++) {
110 if (i == priv->subs_tail)
112 sdev = &priv->subs[i];
113 if (unlikely(fs_rx_unsafe(sdev)))
115 sub_rxq = ETH(sdev)->data->rx_queues[rxq->qid];
116 FS_ATOMIC_P(rxq->refcnt[sdev->sid]);
118 rx_pkt_burst(sub_rxq, rx_pkts, nb_pkts);
119 FS_ATOMIC_V(rxq->refcnt[sdev->sid]);
121 rxq->last_polled = i;
129 failsafe_rx_burst_fast(void *queue,
130 struct rte_mbuf **rx_pkts,
133 struct fs_priv *priv;
134 struct sub_device *sdev;
138 uint8_t nb_polled, nb_subs;
143 nb_subs = priv->subs_tail - priv->subs_head;
145 for (i = rxq->last_polled; nb_polled < nb_subs; nb_polled++) {
147 if (i == priv->subs_tail)
149 sdev = &priv->subs[i];
150 RTE_ASSERT(!fs_rx_unsafe(sdev));
151 sub_rxq = ETH(sdev)->data->rx_queues[rxq->qid];
152 FS_ATOMIC_P(rxq->refcnt[sdev->sid]);
154 rx_pkt_burst(sub_rxq, rx_pkts, nb_pkts);
155 FS_ATOMIC_V(rxq->refcnt[sdev->sid]);
157 rxq->last_polled = i;
165 failsafe_tx_burst(void *queue,
166 struct rte_mbuf **tx_pkts,
169 struct sub_device *sdev;
175 sdev = TX_SUBDEV(txq->priv->dev);
176 if (unlikely(fs_tx_unsafe(sdev)))
178 sub_txq = ETH(sdev)->data->tx_queues[txq->qid];
179 FS_ATOMIC_P(txq->refcnt[sdev->sid]);
180 nb_tx = ETH(sdev)->tx_pkt_burst(sub_txq, tx_pkts, nb_pkts);
181 FS_ATOMIC_V(txq->refcnt[sdev->sid]);
186 failsafe_tx_burst_fast(void *queue,
187 struct rte_mbuf **tx_pkts,
190 struct sub_device *sdev;
196 sdev = TX_SUBDEV(txq->priv->dev);
197 RTE_ASSERT(!fs_tx_unsafe(sdev));
198 sub_txq = ETH(sdev)->data->tx_queues[txq->qid];
199 FS_ATOMIC_P(txq->refcnt[sdev->sid]);
200 nb_tx = ETH(sdev)->tx_pkt_burst(sub_txq, tx_pkts, nb_pkts);
201 FS_ATOMIC_V(txq->refcnt[sdev->sid]);