Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
1/* SPDX-License-Identifier: GPL-2.0 */
2#ifndef _LINUX_NET_QUEUES_H
3#define _LINUX_NET_QUEUES_H
4
5#include <linux/netdevice.h>
6
7/**
8 * struct netdev_config - queue-related configuration for a netdev
9 * @hds_thresh: HDS Threshold value.
10 * @hds_config: HDS value from userspace.
11 */
12struct netdev_config {
13 u32 hds_thresh;
14 u8 hds_config;
15};
16
17struct netdev_queue_config {
18 u32 rx_page_size;
19};
20
21/* See the netdev.yaml spec for definition of each statistic */
22struct netdev_queue_stats_rx {
23 u64 bytes;
24 u64 packets;
25 u64 alloc_fail;
26
27 u64 hw_drops;
28 u64 hw_drop_overruns;
29
30 u64 csum_complete;
31 u64 csum_unnecessary;
32 u64 csum_none;
33 u64 csum_bad;
34
35 u64 hw_gro_packets;
36 u64 hw_gro_bytes;
37 u64 hw_gro_wire_packets;
38 u64 hw_gro_wire_bytes;
39
40 u64 hw_drop_ratelimits;
41};
42
43struct netdev_queue_stats_tx {
44 u64 bytes;
45 u64 packets;
46
47 u64 hw_drops;
48 u64 hw_drop_errors;
49
50 u64 csum_none;
51 u64 needs_csum;
52
53 u64 hw_gso_packets;
54 u64 hw_gso_bytes;
55 u64 hw_gso_wire_packets;
56 u64 hw_gso_wire_bytes;
57
58 u64 hw_drop_ratelimits;
59
60 u64 stop;
61 u64 wake;
62};
63
64/**
65 * struct netdev_stat_ops - netdev ops for fine grained stats
66 * @get_queue_stats_rx: get stats for a given Rx queue
67 * @get_queue_stats_tx: get stats for a given Tx queue
68 * @get_base_stats: get base stats (not belonging to any live instance)
69 *
70 * Query stats for a given object. The values of the statistics are undefined
71 * on entry (specifically they are *not* zero-initialized). Drivers should
72 * assign values only to the statistics they collect. Statistics which are not
73 * collected must be left undefined.
74 *
75 * Queue objects are not necessarily persistent, and only currently active
76 * queues are queried by the per-queue callbacks. This means that per-queue
77 * statistics will not generally add up to the total number of events for
78 * the device. The @get_base_stats callback allows filling in the delta
79 * between events for currently live queues and overall device history.
80 * @get_base_stats can also be used to report any miscellaneous packets
81 * transferred outside of the main set of queues used by the networking stack.
82 * When the statistics for the entire device are queried, first @get_base_stats
83 * is issued to collect the delta, and then a series of per-queue callbacks.
84 * Only statistics which are set in @get_base_stats will be reported
85 * at the device level, meaning that unlike in queue callbacks, setting
86 * a statistic to zero in @get_base_stats is a legitimate thing to do.
87 * This is because @get_base_stats has a second function of designating which
88 * statistics are in fact correct for the entire device (e.g. when history
89 * for some of the events is not maintained, and reliable "total" cannot
90 * be provided).
91 *
92 * Ops are called under the instance lock if netdev_need_ops_lock()
93 * returns true, otherwise under rtnl_lock.
94 * Device drivers can assume that when collecting total device stats,
95 * the @get_base_stats and subsequent per-queue calls are performed
96 * "atomically" (without releasing the relevant lock).
97 *
98 * Device drivers are encouraged to reset the per-queue statistics when
99 * number of queues change. This is because the primary use case for
100 * per-queue statistics is currently to detect traffic imbalance.
101 */
102struct netdev_stat_ops {
103 void (*get_queue_stats_rx)(struct net_device *dev, int idx,
104 struct netdev_queue_stats_rx *stats);
105 void (*get_queue_stats_tx)(struct net_device *dev, int idx,
106 struct netdev_queue_stats_tx *stats);
107 void (*get_base_stats)(struct net_device *dev,
108 struct netdev_queue_stats_rx *rx,
109 struct netdev_queue_stats_tx *tx);
110};
111
112void netdev_stat_queue_sum(struct net_device *netdev,
113 int rx_start, int rx_end,
114 struct netdev_queue_stats_rx *rx_sum,
115 int tx_start, int tx_end,
116 struct netdev_queue_stats_tx *tx_sum);
117
118enum {
119 /* The queue checks and honours the page size qcfg parameter */
120 QCFG_RX_PAGE_SIZE = 0x1,
121};
122
123/**
124 * struct netdev_queue_mgmt_ops - netdev ops for queue management
125 *
126 * @ndo_queue_mem_size: Size of the struct that describes a queue's memory.
127 *
128 * @ndo_queue_mem_alloc: Allocate memory for an RX queue at the specified index.
129 * The new memory is written at the specified address.
130 *
131 * @ndo_queue_mem_free: Free memory from an RX queue.
132 *
133 * @ndo_queue_start: Start an RX queue with the specified memory and at the
134 * specified index.
135 *
136 * @ndo_queue_stop: Stop the RX queue at the specified index. The stopped
137 * queue's memory is written at the specified address.
138 *
139 * @ndo_queue_get_dma_dev: Get dma device for zero-copy operations to be used
140 * for this queue. Return NULL on error.
141 *
142 * @ndo_default_qcfg: (Optional) Populate queue config struct with defaults.
143 * Queue config structs are passed to this helper before
144 * the user-requested settings are applied.
145 *
146 * @ndo_validate_qcfg: (Optional) Check if queue config is supported.
147 * Called when configuration affecting a queue may be
148 * changing, either due to NIC-wide config, or config
149 * scoped to the queue at a specified index.
150 * When NIC-wide config is changed the callback will
151 * be invoked for all queues.
152 *
153 * @ndo_queue_create: Create a new RX queue on a virtual device that will
154 * be paired with a physical device's queue via leasing.
155 * Return the new queue id on success, negative error
156 * on failure.
157 *
158 * @supported_params: Bitmask of supported parameters, see QCFG_*.
159 *
160 * Note that @ndo_queue_mem_alloc and @ndo_queue_mem_free may be called while
161 * the interface is closed. @ndo_queue_start and @ndo_queue_stop will only
162 * be called for an interface which is open.
163 */
164struct netdev_queue_mgmt_ops {
165 size_t ndo_queue_mem_size;
166 int (*ndo_queue_mem_alloc)(struct net_device *dev,
167 struct netdev_queue_config *qcfg,
168 void *per_queue_mem,
169 int idx);
170 void (*ndo_queue_mem_free)(struct net_device *dev,
171 void *per_queue_mem);
172 int (*ndo_queue_start)(struct net_device *dev,
173 struct netdev_queue_config *qcfg,
174 void *per_queue_mem,
175 int idx);
176 int (*ndo_queue_stop)(struct net_device *dev,
177 void *per_queue_mem,
178 int idx);
179 void (*ndo_default_qcfg)(struct net_device *dev,
180 struct netdev_queue_config *qcfg);
181 int (*ndo_validate_qcfg)(struct net_device *dev,
182 struct netdev_queue_config *qcfg,
183 struct netlink_ext_ack *extack);
184 struct device * (*ndo_queue_get_dma_dev)(struct net_device *dev,
185 int idx);
186 int (*ndo_queue_create)(struct net_device *dev,
187 struct netlink_ext_ack *extack);
188
189 unsigned int supported_params;
190};
191
192void netdev_queue_config(struct net_device *dev, int rxq,
193 struct netdev_queue_config *qcfg);
194
195bool netif_rxq_has_unreadable_mp(struct net_device *dev, unsigned int rxq_idx);
196
197/**
198 * DOC: Lockless queue stopping / waking helpers.
199 *
200 * The netif_txq_maybe_stop() and __netif_txq_completed_wake()
201 * macros are designed to safely implement stopping
202 * and waking netdev queues without full lock protection.
203 *
204 * We assume that there can be no concurrent stop attempts and no concurrent
205 * wake attempts. The try-stop should happen from the xmit handler,
206 * while wake up should be triggered from NAPI poll context.
207 * The two may run concurrently (single producer, single consumer).
208 *
209 * The try-stop side is expected to run from the xmit handler and therefore
210 * it does not reschedule Tx (netif_tx_start_queue() instead of
211 * netif_tx_wake_queue()). Uses of the ``stop`` macros outside of the xmit
212 * handler may lead to xmit queue being enabled but not run.
213 * The waking side does not have similar context restrictions.
214 *
215 * The macros guarantee that rings will not remain stopped if there's
216 * space available, but they do *not* prevent false wake ups when
217 * the ring is full! Drivers should check for ring full at the start
218 * for the xmit handler.
219 *
220 * All descriptor ring indexes (and other relevant shared state) must
221 * be updated before invoking the macros.
222 */
223
224#define netif_txq_try_stop(txq, get_desc, start_thrs) \
225 ({ \
226 int _res; \
227 \
228 netif_tx_stop_queue(txq); \
229 /* Producer index and stop bit must be visible \
230 * to consumer before we recheck. \
231 * Pairs with a barrier in __netif_txq_completed_wake(). \
232 */ \
233 smp_mb__after_atomic(); \
234 \
235 /* We need to check again in a case another \
236 * CPU has just made room available. \
237 */ \
238 _res = 0; \
239 if (unlikely(get_desc >= start_thrs)) { \
240 netif_tx_start_queue(txq); \
241 _res = -1; \
242 } \
243 _res; \
244 }) \
245
246/**
247 * netif_txq_maybe_stop() - locklessly stop a Tx queue, if needed
248 * @txq: struct netdev_queue to stop/start
249 * @get_desc: get current number of free descriptors (see requirements below!)
250 * @stop_thrs: minimal number of available descriptors for queue to be left
251 * enabled
252 * @start_thrs: minimal number of descriptors to re-enable the queue, can be
253 * equal to @stop_thrs or higher to avoid frequent waking
254 *
255 * All arguments may be evaluated multiple times, beware of side effects.
256 * @get_desc must be a formula or a function call, it must always
257 * return up-to-date information when evaluated!
258 * Expected to be used from ndo_start_xmit, see the comment on top of the file.
259 *
260 * Returns:
261 * 0 if the queue was stopped
262 * 1 if the queue was left enabled
263 * -1 if the queue was re-enabled (raced with waking)
264 */
265#define netif_txq_maybe_stop(txq, get_desc, stop_thrs, start_thrs) \
266 ({ \
267 int _res; \
268 \
269 _res = 1; \
270 if (unlikely(get_desc < stop_thrs)) \
271 _res = netif_txq_try_stop(txq, get_desc, start_thrs); \
272 _res; \
273 }) \
274
275/* Variant of netdev_tx_completed_queue() which guarantees smp_mb() if
276 * @bytes != 0, regardless of kernel config.
277 */
278static inline void
279netdev_txq_completed_mb(struct netdev_queue *dev_queue,
280 unsigned int pkts, unsigned int bytes)
281{
282 if (IS_ENABLED(CONFIG_BQL))
283 netdev_tx_completed_queue(dev_queue, pkts, bytes);
284 else if (bytes)
285 smp_mb();
286}
287
288/**
289 * __netif_txq_completed_wake() - locklessly wake a Tx queue, if needed
290 * @txq: struct netdev_queue to stop/start
291 * @pkts: number of packets completed
292 * @bytes: number of bytes completed
293 * @get_desc: get current number of free descriptors (see requirements below!)
294 * @start_thrs: minimal number of descriptors to re-enable the queue
295 * @down_cond: down condition, predicate indicating that the queue should
296 * not be woken up even if descriptors are available
297 *
298 * All arguments may be evaluated multiple times.
299 * @get_desc must be a formula or a function call, it must always
300 * return up-to-date information when evaluated!
301 * Reports completed pkts/bytes to BQL.
302 *
303 * Returns:
304 * 0 if the queue was woken up
305 * 1 if the queue was already enabled (or disabled but @down_cond is true)
306 * -1 if the queue was left unchanged (@start_thrs not reached)
307 */
308#define __netif_txq_completed_wake(txq, pkts, bytes, \
309 get_desc, start_thrs, down_cond) \
310 ({ \
311 int _res; \
312 \
313 /* Report to BQL and piggy back on its barrier. \
314 * Barrier makes sure that anybody stopping the queue \
315 * after this point sees the new consumer index. \
316 * Pairs with barrier in netif_txq_try_stop(). \
317 */ \
318 netdev_txq_completed_mb(txq, pkts, bytes); \
319 \
320 _res = -1; \
321 if (pkts && likely(get_desc >= start_thrs)) { \
322 _res = 1; \
323 if (unlikely(netif_tx_queue_stopped(txq)) && \
324 !(down_cond)) { \
325 netif_tx_wake_queue(txq); \
326 _res = 0; \
327 } \
328 } \
329 _res; \
330 })
331
332#define netif_txq_completed_wake(txq, pkts, bytes, get_desc, start_thrs) \
333 __netif_txq_completed_wake(txq, pkts, bytes, get_desc, start_thrs, false)
334
335/* subqueue variants follow */
336
337#define netif_subqueue_try_stop(dev, idx, get_desc, start_thrs) \
338 ({ \
339 struct netdev_queue *_txq; \
340 \
341 _txq = netdev_get_tx_queue(dev, idx); \
342 netif_txq_try_stop(_txq, get_desc, start_thrs); \
343 })
344
345static inline void netif_subqueue_sent(const struct net_device *dev,
346 unsigned int idx, unsigned int bytes)
347{
348 struct netdev_queue *txq;
349
350 txq = netdev_get_tx_queue(dev, idx);
351 netdev_tx_sent_queue(txq, bytes);
352}
353
354static inline unsigned int netif_xmit_timeout_ms(struct netdev_queue *txq)
355{
356 unsigned long trans_start = READ_ONCE(txq->trans_start);
357
358 if (netif_xmit_stopped(txq) &&
359 time_after(jiffies, trans_start + txq->dev->watchdog_timeo))
360 return jiffies_to_msecs(jiffies - trans_start);
361
362 return 0;
363}
364
365#define netif_subqueue_maybe_stop(dev, idx, get_desc, stop_thrs, start_thrs) \
366 ({ \
367 struct netdev_queue *_txq; \
368 \
369 _txq = netdev_get_tx_queue(dev, idx); \
370 netif_txq_maybe_stop(_txq, get_desc, stop_thrs, start_thrs); \
371 })
372
373#define netif_subqueue_completed_wake(dev, idx, pkts, bytes, \
374 get_desc, start_thrs) \
375 ({ \
376 struct netdev_queue *_txq; \
377 \
378 _txq = netdev_get_tx_queue(dev, idx); \
379 netif_txq_completed_wake(_txq, pkts, bytes, \
380 get_desc, start_thrs); \
381 })
382
383struct device *netdev_queue_get_dma_dev(struct net_device *dev,
384 unsigned int idx,
385 enum netdev_queue_type type);
386bool netdev_can_create_queue(const struct net_device *dev,
387 struct netlink_ext_ack *extack);
388bool netdev_can_lease_queue(const struct net_device *dev,
389 struct netlink_ext_ack *extack);
390bool netdev_queue_busy(struct net_device *dev, unsigned int idx,
391 enum netdev_queue_type type,
392 struct netlink_ext_ack *extack);
393#endif /* _LINUX_NET_QUEUES_H */