]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blame - include/linux/netdevice.h
net_sch: mqprio: Change TC_SETUP_MQPRIO to TC_SETUP_QDISC_MQPRIO
[mirror_ubuntu-bionic-kernel.git] / include / linux / netdevice.h
CommitLineData
1da177e4
LT
1/*
2 * INET An implementation of the TCP/IP protocol suite for the LINUX
3 * operating system. INET is implemented using the BSD Socket
4 * interface as the means of communication with the user level.
5 *
6 * Definitions for the Interfaces handler.
7 *
8 * Version: @(#)dev.h 1.0.10 08/12/93
9 *
02c30a84 10 * Authors: Ross Biro
1da177e4
LT
11 * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
12 * Corey Minyard <wf-rch!minyard@relay.EU.net>
13 * Donald J. Becker, <becker@cesdis.gsfc.nasa.gov>
113aa838 14 * Alan Cox, <alan@lxorguk.ukuu.org.uk>
1da177e4
LT
15 * Bjorn Ekwall. <bj0rn@blox.se>
16 * Pekka Riikonen <priikone@poseidon.pspt.fi>
17 *
18 * This program is free software; you can redistribute it and/or
19 * modify it under the terms of the GNU General Public License
20 * as published by the Free Software Foundation; either version
21 * 2 of the License, or (at your option) any later version.
22 *
23 * Moved to /usr/include/linux for NET3
24 */
25#ifndef _LINUX_NETDEVICE_H
26#define _LINUX_NETDEVICE_H
27
d7fe0f24 28#include <linux/timer.h>
187f1882 29#include <linux/bug.h>
bea3348e 30#include <linux/delay.h>
60063497 31#include <linux/atomic.h>
53511453 32#include <linux/prefetch.h>
1da177e4
LT
33#include <asm/cache.h>
34#include <asm/byteorder.h>
35
1da177e4 36#include <linux/percpu.h>
4d5b78c0 37#include <linux/rculist.h>
bea3348e 38#include <linux/workqueue.h>
114cf580 39#include <linux/dynamic_queue_limits.h>
1da177e4 40
b1b67dd4 41#include <linux/ethtool.h>
a050c33f 42#include <net/net_namespace.h>
7a6b6f51 43#ifdef CONFIG_DCB
2f90b865
AD
44#include <net/dcbnl.h>
45#endif
5bc1421e 46#include <net/netprio_cgroup.h>
a050c33f 47
a59e2ecb 48#include <linux/netdev_features.h>
77162022 49#include <linux/neighbour.h>
607ca46e 50#include <uapi/linux/netdevice.h>
61bd3857 51#include <uapi/linux/if_bonding.h>
e4c6734e 52#include <uapi/linux/pkt_cls.h>
59cc1f61 53#include <linux/hashtable.h>
a59e2ecb 54
115c1d6e 55struct netpoll_info;
313162d0 56struct device;
c1f19b51 57struct phy_device;
2f657a60 58struct dsa_port;
c6e970a0 59
704232c2
JB
60/* 802.11 specific */
61struct wireless_dev;
98a18b6f
AA
62/* 802.15.4 specific */
63struct wpan_dev;
03c57747 64struct mpls_dev;
7c46a640
AD
65/* UDP Tunnel offloads */
66struct udp_tunnel_info;
a7862b45 67struct bpf_prog;
814abfab 68struct xdp_buff;
1da177e4 69
f629d208
JP
70void netdev_set_default_ethtool_ops(struct net_device *dev,
71 const struct ethtool_ops *ops);
d07d7507 72
9a1654ba
JP
73/* Backlog congestion levels */
74#define NET_RX_SUCCESS 0 /* keep 'em coming, baby */
75#define NET_RX_DROP 1 /* packet dropped */
76
572a9d7b
PM
77/*
78 * Transmit return codes: transmit return codes originate from three different
79 * namespaces:
80 *
81 * - qdisc return codes
82 * - driver transmit return codes
83 * - errno values
84 *
85 * Drivers are allowed to return any one of those in their hard_start_xmit()
86 * function. Real network devices commonly used with qdiscs should only return
87 * the driver transmit return codes though - when qdiscs are used, the actual
88 * transmission happens asynchronously, so the value is not propagated to
5e82b4b2
BH
89 * higher layers. Virtual network devices transmit synchronously; in this case
90 * the driver transmit return codes are consumed by dev_queue_xmit(), and all
572a9d7b
PM
91 * others are propagated to higher layers.
92 */
93
94/* qdisc ->enqueue() return codes. */
95#define NET_XMIT_SUCCESS 0x00
9a1654ba
JP
96#define NET_XMIT_DROP 0x01 /* skb dropped */
97#define NET_XMIT_CN 0x02 /* congestion notification */
9a1654ba 98#define NET_XMIT_MASK 0x0f /* qdisc flags in net/sch_generic.h */
1da177e4 99
b9df3cb8
GR
100/* NET_XMIT_CN is special. It does not guarantee that this packet is lost. It
101 * indicates that the device will soon be dropping packets, or already drops
102 * some packets of the same priority; prompting us to send less aggressively. */
572a9d7b 103#define net_xmit_eval(e) ((e) == NET_XMIT_CN ? 0 : (e))
1da177e4
LT
104#define net_xmit_errno(e) ((e) != NET_XMIT_CN ? -ENOBUFS : 0)
105
dc1f8bf6 106/* Driver transmit return codes */
9a1654ba 107#define NETDEV_TX_MASK 0xf0
572a9d7b 108
dc1f8bf6 109enum netdev_tx {
572a9d7b 110 __NETDEV_TX_MIN = INT_MIN, /* make sure enum is signed */
9a1654ba
JP
111 NETDEV_TX_OK = 0x00, /* driver took care of packet */
112 NETDEV_TX_BUSY = 0x10, /* driver tx path was busy*/
dc1f8bf6
SH
113};
114typedef enum netdev_tx netdev_tx_t;
115
9a1654ba
JP
116/*
117 * Current order: NETDEV_TX_MASK > NET_XMIT_MASK >= 0 is significant;
118 * hard_start_xmit() return < NET_XMIT_MASK means skb was consumed.
119 */
120static inline bool dev_xmit_complete(int rc)
121{
122 /*
123 * Positive cases with an skb consumed by a driver:
124 * - successful transmission (rc == NETDEV_TX_OK)
125 * - error while transmitting (rc < 0)
126 * - error while queueing to a different device (rc & NET_XMIT_MASK)
127 */
128 if (likely(rc < NET_XMIT_MASK))
129 return true;
130
131 return false;
132}
133
1da177e4 134/*
5e82b4b2 135 * Compute the worst-case header length according to the protocols
1da177e4
LT
136 * used.
137 */
fe2918b0 138
c0eb4540
KS
139#if defined(CONFIG_HYPERV_NET)
140# define LL_MAX_HEADER 128
141#elif defined(CONFIG_WLAN) || IS_ENABLED(CONFIG_AX25)
8388e3da
DM
142# if defined(CONFIG_MAC80211_MESH)
143# define LL_MAX_HEADER 128
144# else
145# define LL_MAX_HEADER 96
146# endif
1da177e4 147#else
8388e3da 148# define LL_MAX_HEADER 32
1da177e4
LT
149#endif
150
d11ead75
BH
151#if !IS_ENABLED(CONFIG_NET_IPIP) && !IS_ENABLED(CONFIG_NET_IPGRE) && \
152 !IS_ENABLED(CONFIG_IPV6_SIT) && !IS_ENABLED(CONFIG_IPV6_TUNNEL)
1da177e4
LT
153#define MAX_HEADER LL_MAX_HEADER
154#else
155#define MAX_HEADER (LL_MAX_HEADER + 48)
156#endif
157
158/*
be1f3c2c
BH
159 * Old network device statistics. Fields are native words
160 * (unsigned long) so they can be read and written atomically.
1da177e4 161 */
fe2918b0 162
d94d9fee 163struct net_device_stats {
3cfde79c
BH
164 unsigned long rx_packets;
165 unsigned long tx_packets;
166 unsigned long rx_bytes;
167 unsigned long tx_bytes;
168 unsigned long rx_errors;
169 unsigned long tx_errors;
170 unsigned long rx_dropped;
171 unsigned long tx_dropped;
172 unsigned long multicast;
1da177e4 173 unsigned long collisions;
1da177e4 174 unsigned long rx_length_errors;
3cfde79c
BH
175 unsigned long rx_over_errors;
176 unsigned long rx_crc_errors;
177 unsigned long rx_frame_errors;
178 unsigned long rx_fifo_errors;
179 unsigned long rx_missed_errors;
1da177e4
LT
180 unsigned long tx_aborted_errors;
181 unsigned long tx_carrier_errors;
182 unsigned long tx_fifo_errors;
183 unsigned long tx_heartbeat_errors;
184 unsigned long tx_window_errors;
1da177e4
LT
185 unsigned long rx_compressed;
186 unsigned long tx_compressed;
187};
188
1da177e4
LT
189
190#include <linux/cache.h>
191#include <linux/skbuff.h>
192
adc9300e 193#ifdef CONFIG_RPS
c5905afb
IM
194#include <linux/static_key.h>
195extern struct static_key rps_needed;
13bfff25 196extern struct static_key rfs_needed;
adc9300e
ED
197#endif
198
1da177e4
LT
199struct neighbour;
200struct neigh_parms;
201struct sk_buff;
202
f001fde5
JP
203struct netdev_hw_addr {
204 struct list_head list;
205 unsigned char addr[MAX_ADDR_LEN];
206 unsigned char type;
ccffad25
JP
207#define NETDEV_HW_ADDR_T_LAN 1
208#define NETDEV_HW_ADDR_T_SAN 2
209#define NETDEV_HW_ADDR_T_SLAVE 3
210#define NETDEV_HW_ADDR_T_UNICAST 4
22bedad3 211#define NETDEV_HW_ADDR_T_MULTICAST 5
22bedad3 212 bool global_use;
4cd729b0 213 int sync_cnt;
8f8f103d 214 int refcount;
4543fbef 215 int synced;
f001fde5
JP
216 struct rcu_head rcu_head;
217};
218
31278e71
JP
219struct netdev_hw_addr_list {
220 struct list_head list;
221 int count;
222};
223
22bedad3
JP
224#define netdev_hw_addr_list_count(l) ((l)->count)
225#define netdev_hw_addr_list_empty(l) (netdev_hw_addr_list_count(l) == 0)
226#define netdev_hw_addr_list_for_each(ha, l) \
227 list_for_each_entry(ha, &(l)->list, list)
32e7bfc4 228
22bedad3
JP
229#define netdev_uc_count(dev) netdev_hw_addr_list_count(&(dev)->uc)
230#define netdev_uc_empty(dev) netdev_hw_addr_list_empty(&(dev)->uc)
231#define netdev_for_each_uc_addr(ha, dev) \
232 netdev_hw_addr_list_for_each(ha, &(dev)->uc)
6683ece3 233
22bedad3
JP
234#define netdev_mc_count(dev) netdev_hw_addr_list_count(&(dev)->mc)
235#define netdev_mc_empty(dev) netdev_hw_addr_list_empty(&(dev)->mc)
18e225f2 236#define netdev_for_each_mc_addr(ha, dev) \
22bedad3 237 netdev_hw_addr_list_for_each(ha, &(dev)->mc)
6683ece3 238
d94d9fee 239struct hh_cache {
5b3dc2f3 240 unsigned int hh_len;
3644f0ce 241 seqlock_t hh_lock;
1da177e4
LT
242
243 /* cached hardware header; allow for machine alignment needs. */
244#define HH_DATA_MOD 16
245#define HH_DATA_OFF(__len) \
5ba0eac6 246 (HH_DATA_MOD - (((__len - 1) & (HH_DATA_MOD - 1)) + 1))
1da177e4
LT
247#define HH_DATA_ALIGN(__len) \
248 (((__len)+(HH_DATA_MOD-1))&~(HH_DATA_MOD - 1))
249 unsigned long hh_data[HH_DATA_ALIGN(LL_MAX_HEADER) / sizeof(long)];
250};
251
5e82b4b2 252/* Reserve HH_DATA_MOD byte-aligned hard_header_len, but at least that much.
1da177e4
LT
253 * Alternative is:
254 * dev->hard_header_len ? (dev->hard_header_len +
255 * (HH_DATA_MOD - 1)) & ~(HH_DATA_MOD - 1) : 0
256 *
257 * We could use other alignment values, but we must maintain the
258 * relationship HH alignment <= LL alignment.
259 */
260#define LL_RESERVED_SPACE(dev) \
f5184d26 261 ((((dev)->hard_header_len+(dev)->needed_headroom)&~(HH_DATA_MOD - 1)) + HH_DATA_MOD)
1da177e4 262#define LL_RESERVED_SPACE_EXTRA(dev,extra) \
f5184d26 263 ((((dev)->hard_header_len+(dev)->needed_headroom+(extra))&~(HH_DATA_MOD - 1)) + HH_DATA_MOD)
1da177e4 264
3b04ddde
SH
265struct header_ops {
266 int (*create) (struct sk_buff *skb, struct net_device *dev,
267 unsigned short type, const void *daddr,
95c96174 268 const void *saddr, unsigned int len);
3b04ddde 269 int (*parse)(const struct sk_buff *skb, unsigned char *haddr);
e69dd336 270 int (*cache)(const struct neighbour *neigh, struct hh_cache *hh, __be16 type);
3b04ddde
SH
271 void (*cache_update)(struct hh_cache *hh,
272 const struct net_device *dev,
273 const unsigned char *haddr);
2793a23a 274 bool (*validate)(const char *ll_header, unsigned int len);
3b04ddde
SH
275};
276
1da177e4 277/* These flag bits are private to the generic network queueing
5e82b4b2 278 * layer; they may not be explicitly referenced by any other
1da177e4
LT
279 * code.
280 */
281
d94d9fee 282enum netdev_state_t {
1da177e4
LT
283 __LINK_STATE_START,
284 __LINK_STATE_PRESENT,
1da177e4 285 __LINK_STATE_NOCARRIER,
b00055aa
SR
286 __LINK_STATE_LINKWATCH_PENDING,
287 __LINK_STATE_DORMANT,
1da177e4
LT
288};
289
290
291/*
5e82b4b2 292 * This structure holds boot-time configured netdevice settings. They
fe2918b0 293 * are then used in the device probing.
1da177e4
LT
294 */
295struct netdev_boot_setup {
296 char name[IFNAMSIZ];
297 struct ifmap map;
298};
299#define NETDEV_BOOT_SETUP_MAX 8
300
f629d208 301int __init netdev_boot_setup(char *str);
1da177e4 302
bea3348e
SH
303/*
304 * Structure for NAPI scheduling similar to tasklet but with weighting
305 */
306struct napi_struct {
307 /* The poll_list must only be managed by the entity which
308 * changes the state of the NAPI_STATE_SCHED bit. This means
309 * whoever atomically sets that bit can add this napi_struct
5e82b4b2 310 * to the per-CPU poll_list, and whoever clears that bit
bea3348e
SH
311 * can remove from the list right before clearing the bit.
312 */
313 struct list_head poll_list;
314
315 unsigned long state;
316 int weight;
404f7c9e 317 unsigned int gro_count;
bea3348e
SH
318 int (*poll)(struct napi_struct *, int);
319#ifdef CONFIG_NETPOLL
bea3348e 320 int poll_owner;
bea3348e 321#endif
5d38a079 322 struct net_device *dev;
d565b0a1 323 struct sk_buff *gro_list;
5d38a079 324 struct sk_buff *skb;
3b47d303 325 struct hrtimer timer;
404f7c9e 326 struct list_head dev_list;
af12fa6e
ET
327 struct hlist_node napi_hash_node;
328 unsigned int napi_id;
bea3348e
SH
329};
330
d94d9fee 331enum {
bea3348e 332 NAPI_STATE_SCHED, /* Poll is scheduled */
39e6c820 333 NAPI_STATE_MISSED, /* reschedule a napi */
a0a46196 334 NAPI_STATE_DISABLE, /* Disable pending */
7b363e44 335 NAPI_STATE_NPSVC, /* Netpoll - don't dequeue from poll_list */
d64b5e85
ED
336 NAPI_STATE_HASHED, /* In NAPI hash (busy polling possible) */
337 NAPI_STATE_NO_BUSY_POLL,/* Do not add in napi_hash, no busy polling */
217f6974
ED
338 NAPI_STATE_IN_BUSY_POLL,/* sk_busy_loop() owns this NAPI */
339};
340
341enum {
39e6c820
ED
342 NAPIF_STATE_SCHED = BIT(NAPI_STATE_SCHED),
343 NAPIF_STATE_MISSED = BIT(NAPI_STATE_MISSED),
344 NAPIF_STATE_DISABLE = BIT(NAPI_STATE_DISABLE),
345 NAPIF_STATE_NPSVC = BIT(NAPI_STATE_NPSVC),
346 NAPIF_STATE_HASHED = BIT(NAPI_STATE_HASHED),
347 NAPIF_STATE_NO_BUSY_POLL = BIT(NAPI_STATE_NO_BUSY_POLL),
348 NAPIF_STATE_IN_BUSY_POLL = BIT(NAPI_STATE_IN_BUSY_POLL),
bea3348e
SH
349};
350
5b252f0c 351enum gro_result {
d1c76af9
HX
352 GRO_MERGED,
353 GRO_MERGED_FREE,
354 GRO_HELD,
355 GRO_NORMAL,
356 GRO_DROP,
25393d3f 357 GRO_CONSUMED,
d1c76af9 358};
5b252f0c 359typedef enum gro_result gro_result_t;
d1c76af9 360
8a4eb573
JP
361/*
362 * enum rx_handler_result - Possible return values for rx_handlers.
363 * @RX_HANDLER_CONSUMED: skb was consumed by rx_handler, do not process it
364 * further.
365 * @RX_HANDLER_ANOTHER: Do another round in receive path. This is indicated in
366 * case skb->dev was changed by rx_handler.
367 * @RX_HANDLER_EXACT: Force exact delivery, no wildcard.
5e82b4b2 368 * @RX_HANDLER_PASS: Do nothing, pass the skb as if no rx_handler was called.
8a4eb573
JP
369 *
370 * rx_handlers are functions called from inside __netif_receive_skb(), to do
371 * special processing of the skb, prior to delivery to protocol handlers.
372 *
373 * Currently, a net_device can only have a single rx_handler registered. Trying
374 * to register a second rx_handler will return -EBUSY.
375 *
376 * To register a rx_handler on a net_device, use netdev_rx_handler_register().
377 * To unregister a rx_handler on a net_device, use
378 * netdev_rx_handler_unregister().
379 *
380 * Upon return, rx_handler is expected to tell __netif_receive_skb() what to
381 * do with the skb.
382 *
5e82b4b2 383 * If the rx_handler consumed the skb in some way, it should return
8a4eb573 384 * RX_HANDLER_CONSUMED. This is appropriate when the rx_handler arranged for
5e82b4b2 385 * the skb to be delivered in some other way.
8a4eb573
JP
386 *
387 * If the rx_handler changed skb->dev, to divert the skb to another
388 * net_device, it should return RX_HANDLER_ANOTHER. The rx_handler for the
389 * new device will be called if it exists.
390 *
5e82b4b2 391 * If the rx_handler decides the skb should be ignored, it should return
8a4eb573 392 * RX_HANDLER_EXACT. The skb will only be delivered to protocol handlers that
d93cf068 393 * are registered on exact device (ptype->dev == skb->dev).
8a4eb573 394 *
5e82b4b2 395 * If the rx_handler didn't change skb->dev, but wants the skb to be normally
8a4eb573
JP
396 * delivered, it should return RX_HANDLER_PASS.
397 *
398 * A device without a registered rx_handler will behave as if rx_handler
399 * returned RX_HANDLER_PASS.
400 */
401
402enum rx_handler_result {
403 RX_HANDLER_CONSUMED,
404 RX_HANDLER_ANOTHER,
405 RX_HANDLER_EXACT,
406 RX_HANDLER_PASS,
407};
408typedef enum rx_handler_result rx_handler_result_t;
409typedef rx_handler_result_t rx_handler_func_t(struct sk_buff **pskb);
ab95bfe0 410
f629d208 411void __napi_schedule(struct napi_struct *n);
bc9ad166 412void __napi_schedule_irqoff(struct napi_struct *n);
bea3348e 413
4d29515f 414static inline bool napi_disable_pending(struct napi_struct *n)
a0a46196
DM
415{
416 return test_bit(NAPI_STATE_DISABLE, &n->state);
417}
418
39e6c820 419bool napi_schedule_prep(struct napi_struct *n);
bea3348e
SH
420
421/**
422 * napi_schedule - schedule NAPI poll
5e82b4b2 423 * @n: NAPI context
bea3348e
SH
424 *
425 * Schedule NAPI poll routine to be called if it is not already
426 * running.
427 */
428static inline void napi_schedule(struct napi_struct *n)
429{
430 if (napi_schedule_prep(n))
431 __napi_schedule(n);
432}
433
bc9ad166
ED
434/**
435 * napi_schedule_irqoff - schedule NAPI poll
5e82b4b2 436 * @n: NAPI context
bc9ad166
ED
437 *
438 * Variant of napi_schedule(), assuming hard irqs are masked.
439 */
440static inline void napi_schedule_irqoff(struct napi_struct *n)
441{
442 if (napi_schedule_prep(n))
443 __napi_schedule_irqoff(n);
444}
445
bfe13f54 446/* Try to reschedule poll. Called by dev->poll() after napi_complete(). */
4d29515f 447static inline bool napi_reschedule(struct napi_struct *napi)
bfe13f54
RD
448{
449 if (napi_schedule_prep(napi)) {
450 __napi_schedule(napi);
4d29515f 451 return true;
bfe13f54 452 }
4d29515f 453 return false;
bfe13f54
RD
454}
455
364b6055 456bool napi_complete_done(struct napi_struct *n, int work_done);
bea3348e
SH
457/**
458 * napi_complete - NAPI processing complete
5e82b4b2 459 * @n: NAPI context
bea3348e
SH
460 *
461 * Mark NAPI processing as complete.
3b47d303 462 * Consider using napi_complete_done() instead.
364b6055 463 * Return false if device should avoid rearming interrupts.
bea3348e 464 */
364b6055 465static inline bool napi_complete(struct napi_struct *n)
3b47d303
ED
466{
467 return napi_complete_done(n, 0);
468}
bea3348e 469
af12fa6e
ET
470/**
471 * napi_hash_del - remove a NAPI from global table
5e82b4b2 472 * @napi: NAPI context
af12fa6e 473 *
5e82b4b2 474 * Warning: caller must observe RCU grace period
34cbe27e
ED
475 * before freeing memory containing @napi, if
476 * this function returns true.
93d05d4a 477 * Note: core networking stack automatically calls it
5e82b4b2 478 * from netif_napi_del().
93d05d4a 479 * Drivers might want to call this helper to combine all
5e82b4b2 480 * the needed RCU grace periods into a single one.
af12fa6e 481 */
34cbe27e 482bool napi_hash_del(struct napi_struct *napi);
af12fa6e 483
bea3348e
SH
484/**
485 * napi_disable - prevent NAPI from scheduling
5e82b4b2 486 * @n: NAPI context
bea3348e
SH
487 *
488 * Stop NAPI from being scheduled on this context.
489 * Waits till any outstanding processing completes.
490 */
3b47d303 491void napi_disable(struct napi_struct *n);
bea3348e
SH
492
493/**
494 * napi_enable - enable NAPI scheduling
5e82b4b2 495 * @n: NAPI context
bea3348e
SH
496 *
497 * Resume NAPI from being scheduled on this context.
498 * Must be paired with napi_disable.
499 */
500static inline void napi_enable(struct napi_struct *n)
501{
502 BUG_ON(!test_bit(NAPI_STATE_SCHED, &n->state));
4e857c58 503 smp_mb__before_atomic();
bea3348e 504 clear_bit(NAPI_STATE_SCHED, &n->state);
2d8bff12 505 clear_bit(NAPI_STATE_NPSVC, &n->state);
bea3348e
SH
506}
507
c264c3de
SH
508/**
509 * napi_synchronize - wait until NAPI is not running
5e82b4b2 510 * @n: NAPI context
c264c3de
SH
511 *
512 * Wait until NAPI is done being scheduled on this context.
513 * Waits till any outstanding processing completes but
514 * does not disable future activations.
515 */
516static inline void napi_synchronize(const struct napi_struct *n)
517{
facc432f
AB
518 if (IS_ENABLED(CONFIG_SMP))
519 while (test_bit(NAPI_STATE_SCHED, &n->state))
520 msleep(1);
521 else
522 barrier();
c264c3de 523}
c264c3de 524
d94d9fee 525enum netdev_queue_state_t {
73466498
TH
526 __QUEUE_STATE_DRV_XOFF,
527 __QUEUE_STATE_STACK_XOFF,
c3f26a26 528 __QUEUE_STATE_FROZEN,
79d16385 529};
8e2f1a63
DB
530
531#define QUEUE_STATE_DRV_XOFF (1 << __QUEUE_STATE_DRV_XOFF)
532#define QUEUE_STATE_STACK_XOFF (1 << __QUEUE_STATE_STACK_XOFF)
533#define QUEUE_STATE_FROZEN (1 << __QUEUE_STATE_FROZEN)
534
535#define QUEUE_STATE_ANY_XOFF (QUEUE_STATE_DRV_XOFF | QUEUE_STATE_STACK_XOFF)
536#define QUEUE_STATE_ANY_XOFF_OR_FROZEN (QUEUE_STATE_ANY_XOFF | \
537 QUEUE_STATE_FROZEN)
538#define QUEUE_STATE_DRV_XOFF_OR_FROZEN (QUEUE_STATE_DRV_XOFF | \
539 QUEUE_STATE_FROZEN)
540
73466498
TH
541/*
542 * __QUEUE_STATE_DRV_XOFF is used by drivers to stop the transmit queue. The
543 * netif_tx_* functions below are used to manipulate this flag. The
544 * __QUEUE_STATE_STACK_XOFF flag is used by the stack to stop the transmit
545 * queue independently. The netif_xmit_*stopped functions below are called
546 * to check if the queue has been stopped by the driver or stack (either
547 * of the XOFF bits are set in the state). Drivers should not need to call
548 * netif_xmit*stopped functions, they should only be using netif_tx_*.
549 */
79d16385 550
bb949fbd 551struct netdev_queue {
6a321cb3 552/*
5e82b4b2 553 * read-mostly part
6a321cb3 554 */
bb949fbd 555 struct net_device *dev;
46e5da40 556 struct Qdisc __rcu *qdisc;
b0e1e646 557 struct Qdisc *qdisc_sleeping;
ccf5ff69 558#ifdef CONFIG_SYSFS
1d24eb48
TH
559 struct kobject kobj;
560#endif
f2cd2d3e
ED
561#if defined(CONFIG_XPS) && defined(CONFIG_NUMA)
562 int numa_node;
563#endif
c0ef079c
FW
564 unsigned long tx_maxrate;
565 /*
566 * Number of TX timeouts for this queue
567 * (/sys/class/net/DEV/Q/trans_timeout)
568 */
569 unsigned long trans_timeout;
6a321cb3 570/*
5e82b4b2 571 * write-mostly part
6a321cb3
ED
572 */
573 spinlock_t _xmit_lock ____cacheline_aligned_in_smp;
574 int xmit_lock_owner;
9d21493b 575 /*
9b36627a 576 * Time (in jiffies) of last Tx
9d21493b
ED
577 */
578 unsigned long trans_start;
ccf5ff69 579
114cf580
TH
580 unsigned long state;
581
582#ifdef CONFIG_BQL
583 struct dql dql;
584#endif
e8a0464c 585} ____cacheline_aligned_in_smp;
bb949fbd 586
f2cd2d3e
ED
587static inline int netdev_queue_numa_node_read(const struct netdev_queue *q)
588{
589#if defined(CONFIG_XPS) && defined(CONFIG_NUMA)
590 return q->numa_node;
591#else
b236da69 592 return NUMA_NO_NODE;
f2cd2d3e
ED
593#endif
594}
595
596static inline void netdev_queue_numa_node_write(struct netdev_queue *q, int node)
597{
598#if defined(CONFIG_XPS) && defined(CONFIG_NUMA)
599 q->numa_node = node;
600#endif
601}
602
df334545 603#ifdef CONFIG_RPS
0a9627f2
TH
604/*
605 * This structure holds an RPS map which can be of variable length. The
606 * map is an array of CPUs.
607 */
608struct rps_map {
609 unsigned int len;
610 struct rcu_head rcu;
611 u16 cpus[0];
612};
60b778ce 613#define RPS_MAP_SIZE(_num) (sizeof(struct rps_map) + ((_num) * sizeof(u16)))
0a9627f2 614
fec5e652 615/*
c445477d
BH
616 * The rps_dev_flow structure contains the mapping of a flow to a CPU, the
617 * tail pointer for that CPU's input queue at the time of last enqueue, and
618 * a hardware filter index.
fec5e652
TH
619 */
620struct rps_dev_flow {
621 u16 cpu;
c445477d 622 u16 filter;
fec5e652
TH
623 unsigned int last_qtail;
624};
c445477d 625#define RPS_NO_FILTER 0xffff
fec5e652
TH
626
627/*
628 * The rps_dev_flow_table structure contains a table of flow mappings.
629 */
630struct rps_dev_flow_table {
631 unsigned int mask;
632 struct rcu_head rcu;
fec5e652
TH
633 struct rps_dev_flow flows[0];
634};
635#define RPS_DEV_FLOW_TABLE_SIZE(_num) (sizeof(struct rps_dev_flow_table) + \
60b778ce 636 ((_num) * sizeof(struct rps_dev_flow)))
fec5e652
TH
637
638/*
639 * The rps_sock_flow_table contains mappings of flows to the last CPU
640 * on which they were processed by the application (set in recvmsg).
5e82b4b2
BH
641 * Each entry is a 32bit value. Upper part is the high-order bits
642 * of flow hash, lower part is CPU number.
567e4b79 643 * rps_cpu_mask is used to partition the space, depending on number of
5e82b4b2
BH
644 * possible CPUs : rps_cpu_mask = roundup_pow_of_two(nr_cpu_ids) - 1
645 * For example, if 64 CPUs are possible, rps_cpu_mask = 0x3f,
567e4b79 646 * meaning we use 32-6=26 bits for the hash.
fec5e652
TH
647 */
648struct rps_sock_flow_table {
567e4b79 649 u32 mask;
93c1af6c
ED
650
651 u32 ents[0] ____cacheline_aligned_in_smp;
fec5e652 652};
567e4b79 653#define RPS_SOCK_FLOW_TABLE_SIZE(_num) (offsetof(struct rps_sock_flow_table, ents[_num]))
fec5e652
TH
654
655#define RPS_NO_CPU 0xffff
656
567e4b79
ED
657extern u32 rps_cpu_mask;
658extern struct rps_sock_flow_table __rcu *rps_sock_flow_table;
659
fec5e652
TH
660static inline void rps_record_sock_flow(struct rps_sock_flow_table *table,
661 u32 hash)
662{
663 if (table && hash) {
567e4b79
ED
664 unsigned int index = hash & table->mask;
665 u32 val = hash & ~rps_cpu_mask;
fec5e652 666
5e82b4b2 667 /* We only give a hint, preemption can change CPU under us */
567e4b79 668 val |= raw_smp_processor_id();
fec5e652 669
567e4b79
ED
670 if (table->ents[index] != val)
671 table->ents[index] = val;
fec5e652
TH
672 }
673}
674
c445477d 675#ifdef CONFIG_RFS_ACCEL
f629d208
JP
676bool rps_may_expire_flow(struct net_device *dev, u16 rxq_index, u32 flow_id,
677 u16 filter_id);
c445477d 678#endif
a953be53 679#endif /* CONFIG_RPS */
c445477d 680
0a9627f2
TH
681/* This structure contains an instance of an RX queue. */
682struct netdev_rx_queue {
a953be53 683#ifdef CONFIG_RPS
6e3f7faf
ED
684 struct rps_map __rcu *rps_map;
685 struct rps_dev_flow_table __rcu *rps_flow_table;
a953be53 686#endif
6e3f7faf 687 struct kobject kobj;
fe822240 688 struct net_device *dev;
0a9627f2 689} ____cacheline_aligned_in_smp;
a953be53
MD
690
691/*
692 * RX queue sysfs structures and functions.
693 */
694struct rx_queue_attribute {
695 struct attribute attr;
718ad681 696 ssize_t (*show)(struct netdev_rx_queue *queue, char *buf);
a953be53 697 ssize_t (*store)(struct netdev_rx_queue *queue,
718ad681 698 const char *buf, size_t len);
a953be53 699};
d314774c 700
bf264145
TH
701#ifdef CONFIG_XPS
702/*
703 * This structure holds an XPS map which can be of variable length. The
704 * map is an array of queues.
705 */
706struct xps_map {
707 unsigned int len;
708 unsigned int alloc_len;
709 struct rcu_head rcu;
710 u16 queues[0];
711};
60b778ce 712#define XPS_MAP_SIZE(_num) (sizeof(struct xps_map) + ((_num) * sizeof(u16)))
c59f419b
HD
713#define XPS_MIN_MAP_ALLOC ((L1_CACHE_ALIGN(offsetof(struct xps_map, queues[1])) \
714 - sizeof(struct xps_map)) / sizeof(u16))
bf264145
TH
715
716/*
717 * This structure holds all XPS maps for device. Maps are indexed by CPU.
718 */
719struct xps_dev_maps {
720 struct rcu_head rcu;
a4177869 721 struct xps_map __rcu *cpu_map[0];
bf264145 722};
184c449f
AD
723#define XPS_DEV_MAPS_SIZE(_tcs) (sizeof(struct xps_dev_maps) + \
724 (nr_cpu_ids * (_tcs) * sizeof(struct xps_map *)))
bf264145
TH
725#endif /* CONFIG_XPS */
726
4f57c087
JF
727#define TC_MAX_QUEUE 16
728#define TC_BITMASK 15
729/* HW offloaded queuing disciplines txq count and offset maps */
730struct netdev_tc_txq {
731 u16 count;
732 u16 offset;
733};
734
68bad94e
NP
735#if defined(CONFIG_FCOE) || defined(CONFIG_FCOE_MODULE)
736/*
737 * This structure is to hold information about the device
738 * configured to run FCoE protocol stack.
739 */
740struct netdev_fcoe_hbainfo {
741 char manufacturer[64];
742 char serial_number[64];
743 char hardware_version[64];
744 char driver_version[64];
745 char optionrom_version[64];
746 char firmware_version[64];
747 char model[256];
748 char model_description[256];
749};
750#endif
751
02637fce 752#define MAX_PHYS_ITEM_ID_LEN 32
66b52b0d 753
02637fce
JP
754/* This structure holds a unique identifier to identify some
755 * physical item (port for example) used by a netdevice.
66b52b0d 756 */
02637fce
JP
757struct netdev_phys_item_id {
758 unsigned char id[MAX_PHYS_ITEM_ID_LEN];
66b52b0d
JP
759 unsigned char id_len;
760};
761
d754f98b
SF
762static inline bool netdev_phys_item_id_same(struct netdev_phys_item_id *a,
763 struct netdev_phys_item_id *b)
764{
765 return a->id_len == b->id_len &&
766 memcmp(a->id, b->id, a->id_len) == 0;
767}
768
99932d4f
DB
769typedef u16 (*select_queue_fallback_t)(struct net_device *dev,
770 struct sk_buff *skb);
771
2572ac53 772enum tc_setup_type {
575ed7d3 773 TC_SETUP_QDISC_MQPRIO,
a1b7c5fd 774 TC_SETUP_CLSU32,
5b33f488 775 TC_SETUP_CLSFLOWER,
ade9b658 776 TC_SETUP_CLSMATCHALL,
332ae8e2 777 TC_SETUP_CLSBPF,
8c4083b3 778 TC_SETUP_BLOCK,
3d0bd028 779 TC_SETUP_CBS,
602f3baf 780 TC_SETUP_QDISC_RED,
16e5cc64
JF
781};
782
f4e63525
JK
783/* These structures hold the attributes of bpf state that are being passed
784 * to the netdevice through the bpf op.
a7862b45 785 */
f4e63525 786enum bpf_netdev_command {
a7862b45
BB
787 /* Set or clear a bpf program used in the earliest stages of packet
788 * rx. The prog will have been loaded as BPF_PROG_TYPE_XDP. The callee
789 * is responsible for calling bpf_prog_put on any old progs that are
790 * stored. In case of error, the callee need not release the new prog
791 * reference, but on success it takes ownership and must bpf_prog_put
792 * when it is no longer used.
793 */
794 XDP_SETUP_PROG,
ee5d032f 795 XDP_SETUP_PROG_HW,
a7862b45 796 /* Check if a bpf program is set on the device. The callee should
ce158e58
JK
797 * set @prog_attached to one of XDP_ATTACHED_* values, note that "true"
798 * is equivalent to XDP_ATTACHED_DRV.
a7862b45
BB
799 */
800 XDP_QUERY_PROG,
ab3f0063
JK
801 /* BPF program for offload callbacks, invoked at program load time. */
802 BPF_OFFLOAD_VERIFIER_PREP,
803 BPF_OFFLOAD_TRANSLATE,
804 BPF_OFFLOAD_DESTROY,
a7862b45
BB
805};
806
ab3f0063 807struct bpf_ext_analyzer_ops;
ddf9f970
JK
808struct netlink_ext_ack;
809
f4e63525
JK
810struct netdev_bpf {
811 enum bpf_netdev_command command;
a7862b45
BB
812 union {
813 /* XDP_SETUP_PROG */
ddf9f970 814 struct {
32d60277 815 u32 flags;
ddf9f970
JK
816 struct bpf_prog *prog;
817 struct netlink_ext_ack *extack;
818 };
a7862b45 819 /* XDP_QUERY_PROG */
58038695 820 struct {
ce158e58 821 u8 prog_attached;
58038695
MKL
822 u32 prog_id;
823 };
ab3f0063
JK
824 /* BPF_OFFLOAD_VERIFIER_PREP */
825 struct {
826 struct bpf_prog *prog;
827 const struct bpf_ext_analyzer_ops *ops; /* callee set */
828 } verifier;
829 /* BPF_OFFLOAD_TRANSLATE, BPF_OFFLOAD_DESTROY */
830 struct {
831 struct bpf_prog *prog;
832 } offload;
a7862b45
BB
833 };
834};
16e5cc64 835
d77e38e6
SK
836#ifdef CONFIG_XFRM_OFFLOAD
837struct xfrmdev_ops {
838 int (*xdo_dev_state_add) (struct xfrm_state *x);
839 void (*xdo_dev_state_delete) (struct xfrm_state *x);
840 void (*xdo_dev_state_free) (struct xfrm_state *x);
841 bool (*xdo_dev_offload_ok) (struct sk_buff *skb,
842 struct xfrm_state *x);
843};
844#endif
845
6c557001
FW
846struct dev_ifalias {
847 struct rcu_head rcuhead;
848 char ifalias[];
849};
850
d314774c
SH
851/*
852 * This structure defines the management hooks for network devices.
00829823
SH
853 * The following hooks can be defined; unless noted otherwise, they are
854 * optional and can be filled with a null pointer.
d314774c
SH
855 *
856 * int (*ndo_init)(struct net_device *dev);
5e82b4b2
BH
857 * This function is called once when a network device is registered.
858 * The network device can use this for any late stage initialization
859 * or semantic validation. It can fail with an error code which will
860 * be propagated back to register_netdev.
d314774c
SH
861 *
862 * void (*ndo_uninit)(struct net_device *dev);
863 * This function is called when device is unregistered or when registration
864 * fails. It is not called if init fails.
865 *
866 * int (*ndo_open)(struct net_device *dev);
5e82b4b2 867 * This function is called when a network device transitions to the up
d314774c
SH
868 * state.
869 *
870 * int (*ndo_stop)(struct net_device *dev);
5e82b4b2 871 * This function is called when a network device transitions to the down
d314774c
SH
872 * state.
873 *
dc1f8bf6
SH
874 * netdev_tx_t (*ndo_start_xmit)(struct sk_buff *skb,
875 * struct net_device *dev);
00829823 876 * Called when a packet needs to be transmitted.
e79d8429
RR
877 * Returns NETDEV_TX_OK. Can return NETDEV_TX_BUSY, but you should stop
878 * the queue before that can happen; it's for obsolete devices and weird
879 * corner cases, but the stack really does a non-trivial amount
880 * of useless work if you return NETDEV_TX_BUSY.
5e82b4b2 881 * Required; cannot be NULL.
00829823 882 *
1a2a1444
DM
883 * netdev_features_t (*ndo_features_check)(struct sk_buff *skb,
884 * struct net_device *dev
885 * netdev_features_t features);
886 * Called by core transmit path to determine if device is capable of
887 * performing offload operations on a given packet. This is to give
888 * the device an opportunity to implement any restrictions that cannot
889 * be otherwise expressed by feature flags. The check is called with
890 * the set of features that the stack has calculated and it returns
891 * those the driver believes to be appropriate.
cdba756f 892 *
f663dd9a 893 * u16 (*ndo_select_queue)(struct net_device *dev, struct sk_buff *skb,
99932d4f 894 * void *accel_priv, select_queue_fallback_t fallback);
5e82b4b2 895 * Called to decide which queue to use when device supports multiple
00829823
SH
896 * transmit queues.
897 *
d314774c
SH
898 * void (*ndo_change_rx_flags)(struct net_device *dev, int flags);
899 * This function is called to allow device receiver to make
5e82b4b2 900 * changes to configuration when multicast or promiscuous is enabled.
d314774c
SH
901 *
902 * void (*ndo_set_rx_mode)(struct net_device *dev);
903 * This function is called device changes address list filtering.
01789349 904 * If driver handles unicast address filtering, it should set
5e82b4b2 905 * IFF_UNICAST_FLT in its priv_flags.
d314774c
SH
906 *
907 * int (*ndo_set_mac_address)(struct net_device *dev, void *addr);
908 * This function is called when the Media Access Control address
37b607c5 909 * needs to be changed. If this interface is not defined, the
5e82b4b2 910 * MAC address can not be changed.
d314774c
SH
911 *
912 * int (*ndo_validate_addr)(struct net_device *dev);
913 * Test if Media Access Control address is valid for the device.
914 *
915 * int (*ndo_do_ioctl)(struct net_device *dev, struct ifreq *ifr, int cmd);
5e82b4b2
BH
916 * Called when a user requests an ioctl which can't be handled by
917 * the generic interface code. If not defined ioctls return
d314774c
SH
918 * not supported error code.
919 *
920 * int (*ndo_set_config)(struct net_device *dev, struct ifmap *map);
921 * Used to set network devices bus interface parameters. This interface
5e82b4b2 922 * is retained for legacy reasons; new devices should use the bus
d314774c
SH
923 * interface (PCI) for low level management.
924 *
925 * int (*ndo_change_mtu)(struct net_device *dev, int new_mtu);
926 * Called when a user wants to change the Maximum Transfer Unit
db46a0e1 927 * of a device.
d314774c 928 *
00829823 929 * void (*ndo_tx_timeout)(struct net_device *dev);
5e82b4b2 930 * Callback used when the transmitter has not made any progress
d314774c
SH
931 * for dev->watchdog ticks.
932 *
bc1f4470 933 * void (*ndo_get_stats64)(struct net_device *dev,
934 * struct rtnl_link_stats64 *storage);
d308e38f 935 * struct net_device_stats* (*ndo_get_stats)(struct net_device *dev);
d314774c 936 * Called when a user wants to get the network device usage
be1f3c2c 937 * statistics. Drivers must do one of the following:
3cfde79c
BH
938 * 1. Define @ndo_get_stats64 to fill in a zero-initialised
939 * rtnl_link_stats64 structure passed by the caller.
82695d9b 940 * 2. Define @ndo_get_stats to update a net_device_stats structure
be1f3c2c
BH
941 * (which should normally be dev->stats) and return a pointer to
942 * it. The structure may be changed asynchronously only if each
943 * field is written atomically.
944 * 3. Update dev->stats asynchronously and atomically, and define
945 * neither operation.
d314774c 946 *
3df5b3c6 947 * bool (*ndo_has_offload_stats)(const struct net_device *dev, int attr_id)
2c9d85d4
NF
948 * Return true if this device supports offload stats of this attr_id.
949 *
950 * int (*ndo_get_offload_stats)(int attr_id, const struct net_device *dev,
951 * void *attr_data)
952 * Get statistics for offload operations by attr_id. Write it into the
953 * attr_data pointer.
954 *
5d632cb7 955 * int (*ndo_vlan_rx_add_vid)(struct net_device *dev, __be16 proto, u16 vid);
5e82b4b2 956 * If device supports VLAN filtering this function is called when a
80d5c368 957 * VLAN id is registered.
d314774c 958 *
5d632cb7 959 * int (*ndo_vlan_rx_kill_vid)(struct net_device *dev, __be16 proto, u16 vid);
5e82b4b2 960 * If device supports VLAN filtering this function is called when a
80d5c368 961 * VLAN id is unregistered.
d314774c
SH
962 *
963 * void (*ndo_poll_controller)(struct net_device *dev);
95c26df8
WM
964 *
965 * SR-IOV management functions.
966 * int (*ndo_set_vf_mac)(struct net_device *dev, int vf, u8* mac);
79aab093
MS
967 * int (*ndo_set_vf_vlan)(struct net_device *dev, int vf, u16 vlan,
968 * u8 qos, __be16 proto);
ed616689
SC
969 * int (*ndo_set_vf_rate)(struct net_device *dev, int vf, int min_tx_rate,
970 * int max_tx_rate);
5f8444a3 971 * int (*ndo_set_vf_spoofchk)(struct net_device *dev, int vf, bool setting);
dd461d6a 972 * int (*ndo_set_vf_trust)(struct net_device *dev, int vf, bool setting);
95c26df8
WM
973 * int (*ndo_get_vf_config)(struct net_device *dev,
974 * int vf, struct ifla_vf_info *ivf);
1d8faf48 975 * int (*ndo_set_vf_link_state)(struct net_device *dev, int vf, int link_state);
57b61080
SF
976 * int (*ndo_set_vf_port)(struct net_device *dev, int vf,
977 * struct nlattr *port[]);
01a3d796
VZ
978 *
979 * Enable or disable the VF ability to query its RSS Redirection Table and
980 * Hash Key. This is needed since on some devices VF share this information
5e82b4b2 981 * with PF and querying it may introduce a theoretical security risk.
01a3d796 982 * int (*ndo_set_vf_rss_query_en)(struct net_device *dev, int vf, bool setting);
57b61080 983 * int (*ndo_get_vf_port)(struct net_device *dev, int vf, struct sk_buff *skb);
2572ac53 984 * int (*ndo_setup_tc)(struct net_device *dev, enum tc_setup_type type,
de4784ca 985 * void *type_data);
6a4bc2b4
FF
986 * Called to setup any 'tc' scheduler, classifier or action on @dev.
987 * This is always called from the stack with the rtnl lock held and netif
988 * tx queues stopped. This allows the netdevice to perform queue
989 * management safely.
c445477d 990 *
e9bce845
YZ
991 * Fiber Channel over Ethernet (FCoE) offload functions.
992 * int (*ndo_fcoe_enable)(struct net_device *dev);
993 * Called when the FCoE protocol stack wants to start using LLD for FCoE
994 * so the underlying device can perform whatever needed configuration or
995 * initialization to support acceleration of FCoE traffic.
996 *
997 * int (*ndo_fcoe_disable)(struct net_device *dev);
998 * Called when the FCoE protocol stack wants to stop using LLD for FCoE
999 * so the underlying device can perform whatever needed clean-ups to
1000 * stop supporting acceleration of FCoE traffic.
1001 *
1002 * int (*ndo_fcoe_ddp_setup)(struct net_device *dev, u16 xid,
1003 * struct scatterlist *sgl, unsigned int sgc);
1004 * Called when the FCoE Initiator wants to initialize an I/O that
1005 * is a possible candidate for Direct Data Placement (DDP). The LLD can
1006 * perform necessary setup and returns 1 to indicate the device is set up
1007 * successfully to perform DDP on this I/O, otherwise this returns 0.
1008 *
1009 * int (*ndo_fcoe_ddp_done)(struct net_device *dev, u16 xid);
1010 * Called when the FCoE Initiator/Target is done with the DDPed I/O as
1011 * indicated by the FC exchange id 'xid', so the underlying device can
1012 * clean up and reuse resources for later DDP requests.
1013 *
1014 * int (*ndo_fcoe_ddp_target)(struct net_device *dev, u16 xid,
1015 * struct scatterlist *sgl, unsigned int sgc);
1016 * Called when the FCoE Target wants to initialize an I/O that
1017 * is a possible candidate for Direct Data Placement (DDP). The LLD can
1018 * perform necessary setup and returns 1 to indicate the device is set up
1019 * successfully to perform DDP on this I/O, otherwise this returns 0.
1020 *
68bad94e
NP
1021 * int (*ndo_fcoe_get_hbainfo)(struct net_device *dev,
1022 * struct netdev_fcoe_hbainfo *hbainfo);
1023 * Called when the FCoE Protocol stack wants information on the underlying
1024 * device. This information is utilized by the FCoE protocol stack to
1025 * register attributes with Fiber Channel management service as per the
1026 * FC-GS Fabric Device Management Information(FDMI) specification.
1027 *
e9bce845
YZ
1028 * int (*ndo_fcoe_get_wwn)(struct net_device *dev, u64 *wwn, int type);
1029 * Called when the underlying device wants to override default World Wide
1030 * Name (WWN) generation mechanism in FCoE protocol stack to pass its own
1031 * World Wide Port Name (WWPN) or World Wide Node Name (WWNN) to the FCoE
1032 * protocol stack to use.
1033 *
c445477d
BH
1034 * RFS acceleration.
1035 * int (*ndo_rx_flow_steer)(struct net_device *dev, const struct sk_buff *skb,
1036 * u16 rxq_index, u32 flow_id);
1037 * Set hardware filter for RFS. rxq_index is the target queue index;
1038 * flow_id is a flow ID to be passed to rps_may_expire_flow() later.
1039 * Return the filter ID on success, or a negative error code.
fbaec0ea 1040 *
8b98a70c 1041 * Slave management functions (for bridge, bonding, etc).
fbaec0ea
JP
1042 * int (*ndo_add_slave)(struct net_device *dev, struct net_device *slave_dev);
1043 * Called to make another netdev an underling.
1044 *
1045 * int (*ndo_del_slave)(struct net_device *dev, struct net_device *slave_dev);
1046 * Called to release previously enslaved netdev.
5455c699
MM
1047 *
1048 * Feature/offload setting functions.
1a2a1444
DM
1049 * netdev_features_t (*ndo_fix_features)(struct net_device *dev,
1050 * netdev_features_t features);
1051 * Adjusts the requested feature flags according to device-specific
1052 * constraints, and returns the resulting flags. Must not modify
1053 * the device state.
1054 *
c8f44aff 1055 * int (*ndo_set_features)(struct net_device *dev, netdev_features_t features);
5455c699
MM
1056 * Called to update device configuration to new features. Passed
1057 * feature set might be less than what was returned by ndo_fix_features()).
1058 * Must return >0 or -errno if it changed dev->features itself.
1059 *
edc7d573 1060 * int (*ndo_fdb_add)(struct ndmsg *ndm, struct nlattr *tb[],
1061 * struct net_device *dev,
f6f6424b 1062 * const unsigned char *addr, u16 vid, u16 flags)
77162022 1063 * Adds an FDB entry to dev for addr.
1690be63
VY
1064 * int (*ndo_fdb_del)(struct ndmsg *ndm, struct nlattr *tb[],
1065 * struct net_device *dev,
f6f6424b 1066 * const unsigned char *addr, u16 vid)
77162022
JF
1067 * Deletes the FDB entry from dev coresponding to addr.
1068 * int (*ndo_fdb_dump)(struct sk_buff *skb, struct netlink_callback *cb,
5d5eacb3 1069 * struct net_device *dev, struct net_device *filter_dev,
d297653d 1070 * int *idx)
77162022
JF
1071 * Used to add FDB entries to dump requests. Implementers should add
1072 * entries to skb and update idx with the number of entries.
e5a55a89 1073 *
ad41faa8
ND
1074 * int (*ndo_bridge_setlink)(struct net_device *dev, struct nlmsghdr *nlh,
1075 * u16 flags)
e5a55a89 1076 * int (*ndo_bridge_getlink)(struct sk_buff *skb, u32 pid, u32 seq,
46c264da
ND
1077 * struct net_device *dev, u32 filter_mask,
1078 * int nlflags)
ad41faa8
ND
1079 * int (*ndo_bridge_dellink)(struct net_device *dev, struct nlmsghdr *nlh,
1080 * u16 flags);
4bf84c35
JP
1081 *
1082 * int (*ndo_change_carrier)(struct net_device *dev, bool new_carrier);
1083 * Called to change device carrier. Soft-devices (like dummy, team, etc)
1084 * which do not represent real hardware may define this to allow their
1085 * userspace components to manage their virtual carrier state. Devices
1086 * that determine carrier state from physical hardware properties (eg
1087 * network cables) or protocol-dependent mechanisms (eg
1088 * USB_CDC_NOTIFY_NETWORK_CONNECTION) should NOT implement this function.
66b52b0d
JP
1089 *
1090 * int (*ndo_get_phys_port_id)(struct net_device *dev,
02637fce 1091 * struct netdev_phys_item_id *ppid);
66b52b0d
JP
1092 * Called to get ID of physical port of this device. If driver does
1093 * not implement this, it is assumed that the hw is not able to have
1094 * multiple net devices on single physical port.
53cf5275 1095 *
7c46a640
AD
1096 * void (*ndo_udp_tunnel_add)(struct net_device *dev,
1097 * struct udp_tunnel_info *ti);
1098 * Called by UDP tunnel to notify a driver about the UDP port and socket
1099 * address family that a UDP tunnel is listnening to. It is called only
1100 * when a new port starts listening. The operation is protected by the
1101 * RTNL.
1102 *
1103 * void (*ndo_udp_tunnel_del)(struct net_device *dev,
1104 * struct udp_tunnel_info *ti);
1105 * Called by UDP tunnel to notify the driver about a UDP port and socket
1106 * address family that the UDP tunnel is not listening to anymore. The
1107 * operation is protected by the RTNL.
1108 *
a6cc0cfa
JF
1109 * void* (*ndo_dfwd_add_station)(struct net_device *pdev,
1110 * struct net_device *dev)
1111 * Called by upper layer devices to accelerate switching or other
1112 * station functionality into hardware. 'pdev is the lowerdev
1113 * to use for the offload and 'dev' is the net device that will
1114 * back the offload. Returns a pointer to the private structure
1115 * the upper layer will maintain.
1116 * void (*ndo_dfwd_del_station)(struct net_device *pdev, void *priv)
1117 * Called by upper layer device to delete the station created
1118 * by 'ndo_dfwd_add_station'. 'pdev' is the net device backing
1119 * the station and priv is the structure returned by the add
1120 * operation.
822b3b2e
JF
1121 * int (*ndo_set_tx_maxrate)(struct net_device *dev,
1122 * int queue_index, u32 maxrate);
1123 * Called when a user wants to set a max-rate limitation of specific
1124 * TX queue.
a54acb3a
ND
1125 * int (*ndo_get_iflink)(const struct net_device *dev);
1126 * Called to get the iflink value of this device.
d746d707 1127 * void (*ndo_change_proto_down)(struct net_device *dev,
5e82b4b2 1128 * bool proto_down);
d746d707
AK
1129 * This function is used to pass protocol port error state information
1130 * to the switch driver. The switch driver can react to the proto_down
1131 * by doing a phys down on the associated switch port.
fc4099f1
PS
1132 * int (*ndo_fill_metadata_dst)(struct net_device *dev, struct sk_buff *skb);
1133 * This function is used to get egress tunnel information for given skb.
1134 * This is useful for retrieving outer tunnel header parameters while
1135 * sampling packet.
871b642a
PA
1136 * void (*ndo_set_rx_headroom)(struct net_device *dev, int needed_headroom);
1137 * This function is used to specify the headroom that the skb must
1138 * consider when allocation skb during packet reception. Setting
1139 * appropriate rx headroom value allows avoiding skb head copy on
5e82b4b2 1140 * forward. Setting a negative value resets the rx headroom to the
871b642a 1141 * default value.
f4e63525 1142 * int (*ndo_bpf)(struct net_device *dev, struct netdev_bpf *bpf);
a7862b45 1143 * This function is used to set or query state related to XDP on the
f4e63525
JK
1144 * netdevice and manage BPF offload. See definition of
1145 * enum bpf_netdev_command for details.
814abfab
JF
1146 * int (*ndo_xdp_xmit)(struct net_device *dev, struct xdp_buff *xdp);
1147 * This function is used to submit a XDP packet for transmit on a
1148 * netdevice.
11393cc9 1149 * void (*ndo_xdp_flush)(struct net_device *dev);
f16ded59
RR
1150 * This function is used to inform the driver to flush a particular
1151 * xdp tx queue. Must be called on same CPU as xdp_xmit.
d314774c
SH
1152 */
1153struct net_device_ops {
1154 int (*ndo_init)(struct net_device *dev);
1155 void (*ndo_uninit)(struct net_device *dev);
1156 int (*ndo_open)(struct net_device *dev);
1157 int (*ndo_stop)(struct net_device *dev);
cdba756f
ED
1158 netdev_tx_t (*ndo_start_xmit)(struct sk_buff *skb,
1159 struct net_device *dev);
1160 netdev_features_t (*ndo_features_check)(struct sk_buff *skb,
1161 struct net_device *dev,
1162 netdev_features_t features);
00829823 1163 u16 (*ndo_select_queue)(struct net_device *dev,
f663dd9a 1164 struct sk_buff *skb,
99932d4f
DB
1165 void *accel_priv,
1166 select_queue_fallback_t fallback);
d314774c
SH
1167 void (*ndo_change_rx_flags)(struct net_device *dev,
1168 int flags);
d314774c 1169 void (*ndo_set_rx_mode)(struct net_device *dev);
d314774c
SH
1170 int (*ndo_set_mac_address)(struct net_device *dev,
1171 void *addr);
d314774c 1172 int (*ndo_validate_addr)(struct net_device *dev);
d314774c
SH
1173 int (*ndo_do_ioctl)(struct net_device *dev,
1174 struct ifreq *ifr, int cmd);
d314774c
SH
1175 int (*ndo_set_config)(struct net_device *dev,
1176 struct ifmap *map);
00829823
SH
1177 int (*ndo_change_mtu)(struct net_device *dev,
1178 int new_mtu);
1179 int (*ndo_neigh_setup)(struct net_device *dev,
1180 struct neigh_parms *);
d314774c
SH
1181 void (*ndo_tx_timeout) (struct net_device *dev);
1182
bc1f4470 1183 void (*ndo_get_stats64)(struct net_device *dev,
1184 struct rtnl_link_stats64 *storage);
3df5b3c6 1185 bool (*ndo_has_offload_stats)(const struct net_device *dev, int attr_id);
2c9d85d4
NF
1186 int (*ndo_get_offload_stats)(int attr_id,
1187 const struct net_device *dev,
1188 void *attr_data);
d314774c
SH
1189 struct net_device_stats* (*ndo_get_stats)(struct net_device *dev);
1190
8e586137 1191 int (*ndo_vlan_rx_add_vid)(struct net_device *dev,
80d5c368 1192 __be16 proto, u16 vid);
8e586137 1193 int (*ndo_vlan_rx_kill_vid)(struct net_device *dev,
80d5c368 1194 __be16 proto, u16 vid);
d314774c 1195#ifdef CONFIG_NET_POLL_CONTROLLER
d314774c 1196 void (*ndo_poll_controller)(struct net_device *dev);
4247e161 1197 int (*ndo_netpoll_setup)(struct net_device *dev,
a8779ec1 1198 struct netpoll_info *info);
0e34e931 1199 void (*ndo_netpoll_cleanup)(struct net_device *dev);
d314774c 1200#endif
95c26df8
WM
1201 int (*ndo_set_vf_mac)(struct net_device *dev,
1202 int queue, u8 *mac);
1203 int (*ndo_set_vf_vlan)(struct net_device *dev,
79aab093
MS
1204 int queue, u16 vlan,
1205 u8 qos, __be16 proto);
ed616689
SC
1206 int (*ndo_set_vf_rate)(struct net_device *dev,
1207 int vf, int min_tx_rate,
1208 int max_tx_rate);
5f8444a3
GR
1209 int (*ndo_set_vf_spoofchk)(struct net_device *dev,
1210 int vf, bool setting);
dd461d6a
HS
1211 int (*ndo_set_vf_trust)(struct net_device *dev,
1212 int vf, bool setting);
95c26df8
WM
1213 int (*ndo_get_vf_config)(struct net_device *dev,
1214 int vf,
1215 struct ifla_vf_info *ivf);
1d8faf48
RE
1216 int (*ndo_set_vf_link_state)(struct net_device *dev,
1217 int vf, int link_state);
3b766cd8
EBE
1218 int (*ndo_get_vf_stats)(struct net_device *dev,
1219 int vf,
1220 struct ifla_vf_stats
1221 *vf_stats);
57b61080
SF
1222 int (*ndo_set_vf_port)(struct net_device *dev,
1223 int vf,
1224 struct nlattr *port[]);
1225 int (*ndo_get_vf_port)(struct net_device *dev,
1226 int vf, struct sk_buff *skb);
cc8e27cc
EC
1227 int (*ndo_set_vf_guid)(struct net_device *dev,
1228 int vf, u64 guid,
1229 int guid_type);
01a3d796
VZ
1230 int (*ndo_set_vf_rss_query_en)(
1231 struct net_device *dev,
1232 int vf, bool setting);
16e5cc64 1233 int (*ndo_setup_tc)(struct net_device *dev,
2572ac53 1234 enum tc_setup_type type,
de4784ca 1235 void *type_data);
d11ead75 1236#if IS_ENABLED(CONFIG_FCOE)
cb454399
YZ
1237 int (*ndo_fcoe_enable)(struct net_device *dev);
1238 int (*ndo_fcoe_disable)(struct net_device *dev);
4d288d57
YZ
1239 int (*ndo_fcoe_ddp_setup)(struct net_device *dev,
1240 u16 xid,
1241 struct scatterlist *sgl,
1242 unsigned int sgc);
1243 int (*ndo_fcoe_ddp_done)(struct net_device *dev,
1244 u16 xid);
6247e086
YZ
1245 int (*ndo_fcoe_ddp_target)(struct net_device *dev,
1246 u16 xid,
1247 struct scatterlist *sgl,
1248 unsigned int sgc);
68bad94e
NP
1249 int (*ndo_fcoe_get_hbainfo)(struct net_device *dev,
1250 struct netdev_fcoe_hbainfo *hbainfo);
3c9c36bc
BPG
1251#endif
1252
d11ead75 1253#if IS_ENABLED(CONFIG_LIBFCOE)
df5c7945
YZ
1254#define NETDEV_FCOE_WWNN 0
1255#define NETDEV_FCOE_WWPN 1
1256 int (*ndo_fcoe_get_wwn)(struct net_device *dev,
1257 u64 *wwn, int type);
4d288d57 1258#endif
3c9c36bc 1259
c445477d
BH
1260#ifdef CONFIG_RFS_ACCEL
1261 int (*ndo_rx_flow_steer)(struct net_device *dev,
1262 const struct sk_buff *skb,
1263 u16 rxq_index,
1264 u32 flow_id);
1265#endif
fbaec0ea 1266 int (*ndo_add_slave)(struct net_device *dev,
33eaf2a6
DA
1267 struct net_device *slave_dev,
1268 struct netlink_ext_ack *extack);
fbaec0ea
JP
1269 int (*ndo_del_slave)(struct net_device *dev,
1270 struct net_device *slave_dev);
c8f44aff
MM
1271 netdev_features_t (*ndo_fix_features)(struct net_device *dev,
1272 netdev_features_t features);
5455c699 1273 int (*ndo_set_features)(struct net_device *dev,
c8f44aff 1274 netdev_features_t features);
503eebc2
JP
1275 int (*ndo_neigh_construct)(struct net_device *dev,
1276 struct neighbour *n);
1277 void (*ndo_neigh_destroy)(struct net_device *dev,
1278 struct neighbour *n);
77162022
JF
1279
1280 int (*ndo_fdb_add)(struct ndmsg *ndm,
edc7d573 1281 struct nlattr *tb[],
77162022 1282 struct net_device *dev,
6b6e2725 1283 const unsigned char *addr,
f6f6424b 1284 u16 vid,
77162022
JF
1285 u16 flags);
1286 int (*ndo_fdb_del)(struct ndmsg *ndm,
1690be63 1287 struct nlattr *tb[],
77162022 1288 struct net_device *dev,
f6f6424b
JP
1289 const unsigned char *addr,
1290 u16 vid);
77162022
JF
1291 int (*ndo_fdb_dump)(struct sk_buff *skb,
1292 struct netlink_callback *cb,
1293 struct net_device *dev,
5d5eacb3 1294 struct net_device *filter_dev,
d297653d 1295 int *idx);
e5a55a89
JF
1296
1297 int (*ndo_bridge_setlink)(struct net_device *dev,
add511b3
RP
1298 struct nlmsghdr *nlh,
1299 u16 flags);
e5a55a89
JF
1300 int (*ndo_bridge_getlink)(struct sk_buff *skb,
1301 u32 pid, u32 seq,
6cbdceeb 1302 struct net_device *dev,
46c264da
ND
1303 u32 filter_mask,
1304 int nlflags);
407af329 1305 int (*ndo_bridge_dellink)(struct net_device *dev,
add511b3
RP
1306 struct nlmsghdr *nlh,
1307 u16 flags);
4bf84c35
JP
1308 int (*ndo_change_carrier)(struct net_device *dev,
1309 bool new_carrier);
66b52b0d 1310 int (*ndo_get_phys_port_id)(struct net_device *dev,
02637fce 1311 struct netdev_phys_item_id *ppid);
db24a904
DA
1312 int (*ndo_get_phys_port_name)(struct net_device *dev,
1313 char *name, size_t len);
7c46a640
AD
1314 void (*ndo_udp_tunnel_add)(struct net_device *dev,
1315 struct udp_tunnel_info *ti);
1316 void (*ndo_udp_tunnel_del)(struct net_device *dev,
1317 struct udp_tunnel_info *ti);
a6cc0cfa
JF
1318 void* (*ndo_dfwd_add_station)(struct net_device *pdev,
1319 struct net_device *dev);
1320 void (*ndo_dfwd_del_station)(struct net_device *pdev,
1321 void *priv);
1322
25175ba5 1323 int (*ndo_get_lock_subclass)(struct net_device *dev);
822b3b2e
JF
1324 int (*ndo_set_tx_maxrate)(struct net_device *dev,
1325 int queue_index,
1326 u32 maxrate);
a54acb3a 1327 int (*ndo_get_iflink)(const struct net_device *dev);
d746d707
AK
1328 int (*ndo_change_proto_down)(struct net_device *dev,
1329 bool proto_down);
fc4099f1
PS
1330 int (*ndo_fill_metadata_dst)(struct net_device *dev,
1331 struct sk_buff *skb);
871b642a
PA
1332 void (*ndo_set_rx_headroom)(struct net_device *dev,
1333 int needed_headroom);
f4e63525
JK
1334 int (*ndo_bpf)(struct net_device *dev,
1335 struct netdev_bpf *bpf);
814abfab
JF
1336 int (*ndo_xdp_xmit)(struct net_device *dev,
1337 struct xdp_buff *xdp);
11393cc9 1338 void (*ndo_xdp_flush)(struct net_device *dev);
d314774c
SH
1339};
1340
7aa98047
LR
1341/**
1342 * enum net_device_priv_flags - &struct net_device priv_flags
1343 *
1344 * These are the &struct net_device, they are only set internally
1345 * by drivers and used in the kernel. These flags are invisible to
5e82b4b2 1346 * userspace; this means that the order of these flags can change
7aa98047
LR
1347 * during any kernel release.
1348 *
1349 * You should have a pretty good reason to be extending these flags.
1350 *
1351 * @IFF_802_1Q_VLAN: 802.1Q VLAN device
1352 * @IFF_EBRIDGE: Ethernet bridging device
7aa98047 1353 * @IFF_BONDING: bonding master or slave
7aa98047 1354 * @IFF_ISATAP: ISATAP interface (RFC4214)
7aa98047
LR
1355 * @IFF_WAN_HDLC: WAN HDLC device
1356 * @IFF_XMIT_DST_RELEASE: dev_hard_start_xmit() is allowed to
1357 * release skb->dst
1358 * @IFF_DONT_BRIDGE: disallow bridging this ether dev
1359 * @IFF_DISABLE_NETPOLL: disable netpoll at run-time
1360 * @IFF_MACVLAN_PORT: device used as macvlan port
1361 * @IFF_BRIDGE_PORT: device used as bridge port
1362 * @IFF_OVS_DATAPATH: device used as Open vSwitch datapath port
1363 * @IFF_TX_SKB_SHARING: The interface supports sharing skbs on transmit
1364 * @IFF_UNICAST_FLT: Supports unicast filtering
1365 * @IFF_TEAM_PORT: device used as team port
1366 * @IFF_SUPP_NOFCS: device supports sending custom FCS
1367 * @IFF_LIVE_ADDR_CHANGE: device supports hardware address
1368 * change when it's running
1369 * @IFF_MACVLAN: Macvlan device
6d0e24cd
LB
1370 * @IFF_XMIT_DST_RELEASE_PERM: IFF_XMIT_DST_RELEASE not taking into account
1371 * underlying stacked devices
1372 * @IFF_IPVLAN_MASTER: IPvlan master device
1373 * @IFF_IPVLAN_SLAVE: IPvlan slave device
007979ea 1374 * @IFF_L3MDEV_MASTER: device is an L3 master device
fa8187c9 1375 * @IFF_NO_QUEUE: device can run without qdisc attached
35d4e172 1376 * @IFF_OPENVSWITCH: device is a Open vSwitch master
fee6d4c7 1377 * @IFF_L3MDEV_SLAVE: device is enslaved to an L3 master device
c981e421 1378 * @IFF_TEAM: device is a team device
d4ab4286 1379 * @IFF_RXFH_CONFIGURED: device has had Rx Flow indirection table configured
871b642a
PA
1380 * @IFF_PHONY_HEADROOM: the headroom value is controlled by an external
1381 * entity (i.e. the master device for bridged veth)
3c175784 1382 * @IFF_MACSEC: device is a MACsec device
7aa98047
LR
1383 */
1384enum netdev_priv_flags {
1385 IFF_802_1Q_VLAN = 1<<0,
1386 IFF_EBRIDGE = 1<<1,
0dc1549b
JP
1387 IFF_BONDING = 1<<2,
1388 IFF_ISATAP = 1<<3,
1389 IFF_WAN_HDLC = 1<<4,
1390 IFF_XMIT_DST_RELEASE = 1<<5,
1391 IFF_DONT_BRIDGE = 1<<6,
1392 IFF_DISABLE_NETPOLL = 1<<7,
1393 IFF_MACVLAN_PORT = 1<<8,
1394 IFF_BRIDGE_PORT = 1<<9,
1395 IFF_OVS_DATAPATH = 1<<10,
1396 IFF_TX_SKB_SHARING = 1<<11,
1397 IFF_UNICAST_FLT = 1<<12,
1398 IFF_TEAM_PORT = 1<<13,
1399 IFF_SUPP_NOFCS = 1<<14,
1400 IFF_LIVE_ADDR_CHANGE = 1<<15,
1401 IFF_MACVLAN = 1<<16,
1402 IFF_XMIT_DST_RELEASE_PERM = 1<<17,
1403 IFF_IPVLAN_MASTER = 1<<18,
1404 IFF_IPVLAN_SLAVE = 1<<19,
007979ea 1405 IFF_L3MDEV_MASTER = 1<<20,
0dc1549b
JP
1406 IFF_NO_QUEUE = 1<<21,
1407 IFF_OPENVSWITCH = 1<<22,
fee6d4c7 1408 IFF_L3MDEV_SLAVE = 1<<23,
c981e421 1409 IFF_TEAM = 1<<24,
d4ab4286 1410 IFF_RXFH_CONFIGURED = 1<<25,
871b642a 1411 IFF_PHONY_HEADROOM = 1<<26,
3c175784 1412 IFF_MACSEC = 1<<27,
7aa98047
LR
1413};
1414
1415#define IFF_802_1Q_VLAN IFF_802_1Q_VLAN
1416#define IFF_EBRIDGE IFF_EBRIDGE
7aa98047 1417#define IFF_BONDING IFF_BONDING
7aa98047 1418#define IFF_ISATAP IFF_ISATAP
7aa98047
LR
1419#define IFF_WAN_HDLC IFF_WAN_HDLC
1420#define IFF_XMIT_DST_RELEASE IFF_XMIT_DST_RELEASE
1421#define IFF_DONT_BRIDGE IFF_DONT_BRIDGE
1422#define IFF_DISABLE_NETPOLL IFF_DISABLE_NETPOLL
1423#define IFF_MACVLAN_PORT IFF_MACVLAN_PORT
1424#define IFF_BRIDGE_PORT IFF_BRIDGE_PORT
1425#define IFF_OVS_DATAPATH IFF_OVS_DATAPATH
1426#define IFF_TX_SKB_SHARING IFF_TX_SKB_SHARING
1427#define IFF_UNICAST_FLT IFF_UNICAST_FLT
1428#define IFF_TEAM_PORT IFF_TEAM_PORT
1429#define IFF_SUPP_NOFCS IFF_SUPP_NOFCS
1430#define IFF_LIVE_ADDR_CHANGE IFF_LIVE_ADDR_CHANGE
1431#define IFF_MACVLAN IFF_MACVLAN
02875878 1432#define IFF_XMIT_DST_RELEASE_PERM IFF_XMIT_DST_RELEASE_PERM
2ad7bf36
MB
1433#define IFF_IPVLAN_MASTER IFF_IPVLAN_MASTER
1434#define IFF_IPVLAN_SLAVE IFF_IPVLAN_SLAVE
007979ea 1435#define IFF_L3MDEV_MASTER IFF_L3MDEV_MASTER
fa8187c9 1436#define IFF_NO_QUEUE IFF_NO_QUEUE
35d4e172 1437#define IFF_OPENVSWITCH IFF_OPENVSWITCH
8f25348b 1438#define IFF_L3MDEV_SLAVE IFF_L3MDEV_SLAVE
c981e421 1439#define IFF_TEAM IFF_TEAM
d4ab4286 1440#define IFF_RXFH_CONFIGURED IFF_RXFH_CONFIGURED
3c175784 1441#define IFF_MACSEC IFF_MACSEC
7aa98047 1442
536721b1
KK
1443/**
1444 * struct net_device - The DEVICE structure.
d651983d
MCC
1445 *
1446 * Actually, this whole structure is a big mistake. It mixes I/O
1447 * data with strictly "high-level" data, and it has to know about
1448 * almost every data structure used in the INET module.
536721b1
KK
1449 *
1450 * @name: This is the first field of the "visible" part of this structure
1451 * (i.e. as seen by users in the "Space.c" file). It is the name
d651983d 1452 * of the interface.
536721b1
KK
1453 *
1454 * @name_hlist: Device name hash chain, please keep it close to name[]
1455 * @ifalias: SNMP alias
1456 * @mem_end: Shared memory end
1457 * @mem_start: Shared memory start
1458 * @base_addr: Device I/O address
1459 * @irq: Device IRQ number
1460 *
14ffbbb8
TG
1461 * @carrier_changes: Stats to monitor carrier on<->off transitions
1462 *
536721b1
KK
1463 * @state: Generic network queuing layer state, see netdev_state_t
1464 * @dev_list: The global list of network devices
5e82b4b2
BH
1465 * @napi_list: List entry used for polling NAPI devices
1466 * @unreg_list: List entry when we are unregistering the
1467 * device; see the function unregister_netdev
1468 * @close_list: List entry used when we are closing the device
62d885fe
BP
1469 * @ptype_all: Device-specific packet handlers for all protocols
1470 * @ptype_specific: Device-specific, protocol-specific packet handlers
536721b1
KK
1471 *
1472 * @adj_list: Directly linked devices, like slaves for bonding
536721b1
KK
1473 * @features: Currently active device features
1474 * @hw_features: User-changeable features
1475 *
1476 * @wanted_features: User-requested features
1477 * @vlan_features: Mask of features inheritable by VLAN devices
1478 *
1479 * @hw_enc_features: Mask of features inherited by encapsulating devices
1480 * This field indicates what encapsulation
1481 * offloads the hardware is capable of doing,
1482 * and drivers will need to set them appropriately.
1483 *
1484 * @mpls_features: Mask of features inheritable by MPLS
1485 *
1486 * @ifindex: interface index
5e82b4b2 1487 * @group: The group the device belongs to
536721b1
KK
1488 *
1489 * @stats: Statistics struct, which was left as a legacy, use
1490 * rtnl_link_stats64 instead
1491 *
1492 * @rx_dropped: Dropped packets by core network,
1493 * do not use this in drivers
1494 * @tx_dropped: Dropped packets by core network,
1495 * do not use this in drivers
6e7333d3
JW
1496 * @rx_nohandler: nohandler dropped packets by core network on
1497 * inactive devices, do not use this in drivers
536721b1 1498 *
536721b1
KK
1499 * @wireless_handlers: List of functions to handle Wireless Extensions,
1500 * instead of ioctl,
1501 * see <net/iw_handler.h> for details.
1502 * @wireless_data: Instance data managed by the core of wireless extensions
1503 *
1504 * @netdev_ops: Includes several pointers to callbacks,
1505 * if one wants to override the ndo_*() functions
1506 * @ethtool_ops: Management operations
f997c55c
AA
1507 * @ndisc_ops: Includes callbacks for different IPv6 neighbour
1508 * discovery handling. Necessary for e.g. 6LoWPAN.
d476059e 1509 * @header_ops: Includes callbacks for creating,parsing,caching,etc
536721b1
KK
1510 * of Layer 2 headers.
1511 *
1512 * @flags: Interface flags (a la BSD)
1513 * @priv_flags: Like 'flags' but invisible to userspace,
1514 * see if.h for the definitions
1515 * @gflags: Global flags ( kept as legacy )
1516 * @padded: How much padding added by alloc_netdev()
1517 * @operstate: RFC2863 operstate
1518 * @link_mode: Mapping policy to operstate
1519 * @if_port: Selectable AUI, TP, ...
1520 * @dma: DMA channel
1521 * @mtu: Interface MTU value
61e84623
JW
1522 * @min_mtu: Interface Minimum MTU value
1523 * @max_mtu: Interface Maximum MTU value
536721b1 1524 * @type: Interface hardware type
2793a23a 1525 * @hard_header_len: Maximum hardware header length.
217e6fa2 1526 * @min_header_len: Minimum hardware header length
536721b1
KK
1527 *
1528 * @needed_headroom: Extra headroom the hardware may need, but not in all
1529 * cases can this be guaranteed
1530 * @needed_tailroom: Extra tailroom the hardware may need, but not in all
1531 * cases can this be guaranteed. Some cases also use
1532 * LL_MAX_HEADER instead to allocate the skb
1533 *
1534 * interface address info:
1535 *
1536 * @perm_addr: Permanent hw address
1537 * @addr_assign_type: Hw address assignment type
1538 * @addr_len: Hardware address length
8626a0c8 1539 * @neigh_priv_len: Used in neigh_alloc()
536721b1
KK
1540 * @dev_id: Used to differentiate devices that share
1541 * the same link layer address
1542 * @dev_port: Used to differentiate devices that share
1543 * the same function
1544 * @addr_list_lock: XXX: need comments on this one
5e82b4b2 1545 * @uc_promisc: Counter that indicates promiscuous mode
536721b1
KK
1546 * has been enabled due to the need to listen to
1547 * additional unicast addresses in a device that
1548 * does not implement ndo_set_rx_mode()
14ffbbb8
TG
1549 * @uc: unicast mac addresses
1550 * @mc: multicast mac addresses
1551 * @dev_addrs: list of device hw addresses
1552 * @queues_kset: Group of all Kobjects in the Tx and RX queues
5e82b4b2
BH
1553 * @promiscuity: Number of times the NIC is told to work in
1554 * promiscuous mode; if it becomes 0 the NIC will
1555 * exit promiscuous mode
536721b1
KK
1556 * @allmulti: Counter, enables or disables allmulticast mode
1557 *
1558 * @vlan_info: VLAN info
1559 * @dsa_ptr: dsa specific data
1560 * @tipc_ptr: TIPC specific data
1561 * @atalk_ptr: AppleTalk link
1562 * @ip_ptr: IPv4 specific data
1563 * @dn_ptr: DECnet specific data
1564 * @ip6_ptr: IPv6 specific data
1565 * @ax25_ptr: AX.25 specific data
1566 * @ieee80211_ptr: IEEE 802.11 specific data, assign before registering
1567 *
536721b1
KK
1568 * @dev_addr: Hw address (before bcast,
1569 * because most packets are unicast)
1570 *
1571 * @_rx: Array of RX queues
1572 * @num_rx_queues: Number of RX queues
1573 * allocated at register_netdev() time
1574 * @real_num_rx_queues: Number of RX queues currently active in device
1575 *
1576 * @rx_handler: handler for received packets
1577 * @rx_handler_data: XXX: need comments on this one
46209401
JP
1578 * @miniq_ingress: ingress/clsact qdisc specific data for
1579 * ingress processing
536721b1
KK
1580 * @ingress_queue: XXX: need comments on this one
1581 * @broadcast: hw bcast address
1582 *
14ffbbb8
TG
1583 * @rx_cpu_rmap: CPU reverse-mapping for RX completion interrupts,
1584 * indexed by RX queue number. Assigned by driver.
1585 * This must only be set if the ndo_rx_flow_steer
1586 * operation is defined
1587 * @index_hlist: Device index hash chain
1588 *
536721b1
KK
1589 * @_tx: Array of TX queues
1590 * @num_tx_queues: Number of TX queues allocated at alloc_netdev_mq() time
1591 * @real_num_tx_queues: Number of TX queues currently active in device
1592 * @qdisc: Root qdisc from userspace point of view
1593 * @tx_queue_len: Max frames per queue allowed
1594 * @tx_global_lock: XXX: need comments on this one
1595 *
1596 * @xps_maps: XXX: need comments on this one
46209401
JP
1597 * @miniq_egress: clsact qdisc specific data for
1598 * egress processing
536721b1 1599 * @watchdog_timeo: Represents the timeout that is used by
5e82b4b2 1600 * the watchdog (see dev_watchdog())
536721b1
KK
1601 * @watchdog_timer: List of timers
1602 *
1603 * @pcpu_refcnt: Number of references to this device
1604 * @todo_list: Delayed register/unregister
536721b1
KK
1605 * @link_watch_list: XXX: need comments on this one
1606 *
1607 * @reg_state: Register/unregister state machine
1608 * @dismantle: Device is going to be freed
1609 * @rtnl_link_state: This enum represents the phases of creating
1610 * a new link
1611 *
cf124db5
DM
1612 * @needs_free_netdev: Should unregister perform free_netdev?
1613 * @priv_destructor: Called from unregister
536721b1
KK
1614 * @npinfo: XXX: need comments on this one
1615 * @nd_net: Network namespace this network device is inside
1616 *
1617 * @ml_priv: Mid-layer private
1618 * @lstats: Loopback statistics
1619 * @tstats: Tunnel statistics
1620 * @dstats: Dummy statistics
1621 * @vstats: Virtual ethernet statistics
1622 *
1623 * @garp_port: GARP
1624 * @mrp_port: MRP
1625 *
1626 * @dev: Class/net/name entry
1627 * @sysfs_groups: Space for optional device, statistics and wireless
1628 * sysfs groups
1629 *
1630 * @sysfs_rx_queue_group: Space for optional per-rx queue attributes
1631 * @rtnl_link_ops: Rtnl_link_ops
1632 *
1633 * @gso_max_size: Maximum size of generic segmentation offload
1634 * @gso_max_segs: Maximum number of segments that can be passed to the
1635 * NIC for GSO
1636 *
1637 * @dcbnl_ops: Data Center Bridging netlink ops
1638 * @num_tc: Number of traffic classes in the net device
1639 * @tc_to_txq: XXX: need comments on this one
920c1cd3 1640 * @prio_tc_map: XXX: need comments on this one
536721b1
KK
1641 *
1642 * @fcoe_ddp_xid: Max exchange id for FCoE LRO by ddp
1643 *
1644 * @priomap: XXX: need comments on this one
1645 * @phydev: Physical device may attach itself
1646 * for hardware timestamping
1647 *
123b3652
ED
1648 * @qdisc_tx_busylock: lockdep class annotating Qdisc->busylock spinlock
1649 * @qdisc_running_key: lockdep class annotating Qdisc->running seqcount
536721b1 1650 *
d746d707
AK
1651 * @proto_down: protocol port state information can be sent to the
1652 * switch driver and used to set the phys state of the
1653 * switch port.
1654 *
1da177e4
LT
1655 * FIXME: cleanup struct net_device such that network protocol info
1656 * moves out.
1657 */
1658
d94d9fee 1659struct net_device {
1da177e4 1660 char name[IFNAMSIZ];
9356b8fc 1661 struct hlist_node name_hlist;
6c557001 1662 struct dev_ifalias __rcu *ifalias;
1da177e4
LT
1663 /*
1664 * I/O specific fields
1665 * FIXME: Merge these and struct ifmap into one
1666 */
536721b1
KK
1667 unsigned long mem_end;
1668 unsigned long mem_start;
1669 unsigned long base_addr;
1670 int irq;
1da177e4 1671
14ffbbb8
TG
1672 atomic_t carrier_changes;
1673
1da177e4 1674 /*
536721b1
KK
1675 * Some hardware also needs these fields (state,dev_list,
1676 * napi_list,unreg_list,close_list) but they are not
1da177e4
LT
1677 * part of the usual set specified in Space.c.
1678 */
1679
1da177e4
LT
1680 unsigned long state;
1681
7562f876 1682 struct list_head dev_list;
bea3348e 1683 struct list_head napi_list;
44a0873d 1684 struct list_head unreg_list;
5cde2829 1685 struct list_head close_list;
7866a621
SN
1686 struct list_head ptype_all;
1687 struct list_head ptype_specific;
2f268f12 1688
2f268f12
VF
1689 struct {
1690 struct list_head upper;
1691 struct list_head lower;
1692 } adj_list;
1693
c8f44aff 1694 netdev_features_t features;
c8f44aff 1695 netdev_features_t hw_features;
c8f44aff 1696 netdev_features_t wanted_features;
c8f44aff 1697 netdev_features_t vlan_features;
6a674e9c 1698 netdev_features_t hw_enc_features;
0d89d203 1699 netdev_features_t mpls_features;
802ab55a 1700 netdev_features_t gso_partial_features;
04ed3e74 1701
1da177e4 1702 int ifindex;
7a66bbc9 1703 int group;
1da177e4 1704
c45d286e 1705 struct net_device_stats stats;
015f0688 1706
015f0688
ED
1707 atomic_long_t rx_dropped;
1708 atomic_long_t tx_dropped;
6e7333d3 1709 atomic_long_t rx_nohandler;
1da177e4 1710
b86e0280 1711#ifdef CONFIG_WIRELESS_EXT
5e82b4b2
BH
1712 const struct iw_handler_def *wireless_handlers;
1713 struct iw_public_data *wireless_data;
b86e0280 1714#endif
d314774c 1715 const struct net_device_ops *netdev_ops;
76fd8593 1716 const struct ethtool_ops *ethtool_ops;
4170604f 1717#ifdef CONFIG_NET_SWITCHDEV
9d47c0a2 1718 const struct switchdev_ops *switchdev_ops;
4170604f 1719#endif
1b69c6d0
DA
1720#ifdef CONFIG_NET_L3_MASTER_DEV
1721 const struct l3mdev_ops *l3mdev_ops;
1722#endif
f997c55c
AA
1723#if IS_ENABLED(CONFIG_IPV6)
1724 const struct ndisc_ops *ndisc_ops;
1725#endif
1da177e4 1726
d77e38e6
SK
1727#ifdef CONFIG_XFRM
1728 const struct xfrmdev_ops *xfrmdev_ops;
1729#endif
1730
3b04ddde
SH
1731 const struct header_ops *header_ops;
1732
536721b1
KK
1733 unsigned int flags;
1734 unsigned int priv_flags;
1735
1da177e4 1736 unsigned short gflags;
536721b1 1737 unsigned short padded;
1da177e4 1738
536721b1
KK
1739 unsigned char operstate;
1740 unsigned char link_mode;
b00055aa 1741
536721b1
KK
1742 unsigned char if_port;
1743 unsigned char dma;
bdc220da 1744
536721b1 1745 unsigned int mtu;
61e84623
JW
1746 unsigned int min_mtu;
1747 unsigned int max_mtu;
536721b1
KK
1748 unsigned short type;
1749 unsigned short hard_header_len;
d92be7a4 1750 unsigned char min_header_len;
1da177e4 1751
f5184d26
JB
1752 unsigned short needed_headroom;
1753 unsigned short needed_tailroom;
1754
1da177e4 1755 /* Interface address info. */
536721b1
KK
1756 unsigned char perm_addr[MAX_ADDR_LEN];
1757 unsigned char addr_assign_type;
1758 unsigned char addr_len;
a0a9663d 1759 unsigned short neigh_priv_len;
536721b1
KK
1760 unsigned short dev_id;
1761 unsigned short dev_port;
ccffad25 1762 spinlock_t addr_list_lock;
14ffbbb8
TG
1763 unsigned char name_assign_type;
1764 bool uc_promisc;
536721b1
KK
1765 struct netdev_hw_addr_list uc;
1766 struct netdev_hw_addr_list mc;
1767 struct netdev_hw_addr_list dev_addrs;
1768
4c3d5e7b
ED
1769#ifdef CONFIG_SYSFS
1770 struct kset *queues_kset;
1771#endif
9d45abe1
WC
1772 unsigned int promiscuity;
1773 unsigned int allmulti;
1da177e4 1774
1da177e4 1775
5e82b4b2 1776 /* Protocol-specific pointers */
65ac6a5f 1777
d11ead75 1778#if IS_ENABLED(CONFIG_VLAN_8021Q)
536721b1 1779 struct vlan_info __rcu *vlan_info;
65ac6a5f 1780#endif
34a430d7 1781#if IS_ENABLED(CONFIG_NET_DSA)
2f657a60 1782 struct dsa_port *dsa_ptr;
37cb0620
YX
1783#endif
1784#if IS_ENABLED(CONFIG_TIPC)
536721b1 1785 struct tipc_bearer __rcu *tipc_ptr;
91da11f8 1786#endif
536721b1
KK
1787 void *atalk_ptr;
1788 struct in_device __rcu *ip_ptr;
1789 struct dn_dev __rcu *dn_ptr;
1790 struct inet6_dev __rcu *ip6_ptr;
1791 void *ax25_ptr;
1792 struct wireless_dev *ieee80211_ptr;
98a18b6f 1793 struct wpan_dev *ieee802154_ptr;
03c57747
RS
1794#if IS_ENABLED(CONFIG_MPLS_ROUTING)
1795 struct mpls_dev __rcu *mpls_ptr;
1796#endif
1da177e4 1797
9356b8fc 1798/*
cd13539b 1799 * Cache lines mostly used on receive path (including eth_type_trans())
9356b8fc 1800 */
9356b8fc 1801 /* Interface address info used in eth_type_trans() */
536721b1 1802 unsigned char *dev_addr;
f001fde5 1803
a953be53 1804#ifdef CONFIG_SYSFS
0a9627f2
TH
1805 struct netdev_rx_queue *_rx;
1806
0a9627f2 1807 unsigned int num_rx_queues;
62fe0b40 1808 unsigned int real_num_rx_queues;
df334545 1809#endif
0a9627f2 1810
7acedaf5 1811 struct bpf_prog __rcu *xdp_prog;
3b47d303 1812 unsigned long gro_flush_timeout;
61391cde 1813 rx_handler_func_t __rcu *rx_handler;
1814 void __rcu *rx_handler_data;
e8a0464c 1815
4cda01e8 1816#ifdef CONFIG_NET_CLS_ACT
46209401 1817 struct mini_Qdisc __rcu *miniq_ingress;
d2788d34 1818#endif
24824a09 1819 struct netdev_queue __rcu *ingress_queue;
e687ad60 1820#ifdef CONFIG_NETFILTER_INGRESS
960632ec 1821 struct nf_hook_entries __rcu *nf_hooks_ingress;
e687ad60 1822#endif
d2788d34 1823
536721b1 1824 unsigned char broadcast[MAX_ADDR_LEN];
14ffbbb8
TG
1825#ifdef CONFIG_RFS_ACCEL
1826 struct cpu_rmap *rx_cpu_rmap;
1827#endif
1828 struct hlist_node index_hlist;
cd13539b
ED
1829
1830/*
1831 * Cache lines mostly used on transmit path
1832 */
e8a0464c
DM
1833 struct netdev_queue *_tx ____cacheline_aligned_in_smp;
1834 unsigned int num_tx_queues;
fd2ea0a7 1835 unsigned int real_num_tx_queues;
af356afa 1836 struct Qdisc *qdisc;
59cc1f61
JK
1837#ifdef CONFIG_NET_SCHED
1838 DECLARE_HASHTABLE (qdisc_hash, 4);
1839#endif
0cd29503 1840 unsigned int tx_queue_len;
c3f26a26 1841 spinlock_t tx_global_lock;
14ffbbb8 1842 int watchdog_timeo;
cd13539b 1843
bf264145 1844#ifdef CONFIG_XPS
a4177869 1845 struct xps_dev_maps __rcu *xps_maps;
bf264145 1846#endif
1f211a1b 1847#ifdef CONFIG_NET_CLS_ACT
46209401 1848 struct mini_Qdisc __rcu *miniq_egress;
1f211a1b 1849#endif
0c4f691f 1850
9356b8fc 1851 /* These may be needed for future network-power-down code. */
9356b8fc
ED
1852 struct timer_list watchdog_timer;
1853
29b4433d 1854 int __percpu *pcpu_refcnt;
1da177e4 1855 struct list_head todo_list;
1da177e4 1856
e014debe 1857 struct list_head link_watch_list;
572a103d 1858
1da177e4 1859 enum { NETREG_UNINITIALIZED=0,
b17a7c17 1860 NETREG_REGISTERED, /* completed register_netdevice */
1da177e4
LT
1861 NETREG_UNREGISTERING, /* called unregister_netdevice */
1862 NETREG_UNREGISTERED, /* completed unregister todo */
1863 NETREG_RELEASED, /* called free_netdev */
937f1ba5 1864 NETREG_DUMMY, /* dummy device for NAPI poll */
449f4544
ED
1865 } reg_state:8;
1866
536721b1 1867 bool dismantle;
a2835763
PM
1868
1869 enum {
1870 RTNL_LINK_INITIALIZED,
1871 RTNL_LINK_INITIALIZING,
1872 } rtnl_link_state:16;
1da177e4 1873
cf124db5
DM
1874 bool needs_free_netdev;
1875 void (*priv_destructor)(struct net_device *dev);
1da177e4 1876
1da177e4 1877#ifdef CONFIG_NETPOLL
5fbee843 1878 struct netpoll_info __rcu *npinfo;
1da177e4 1879#endif
eae792b7 1880
0c5c9fb5 1881 possible_net_t nd_net;
4a1c5371 1882
4951704b 1883 /* mid-layer private */
a7855c78 1884 union {
536721b1
KK
1885 void *ml_priv;
1886 struct pcpu_lstats __percpu *lstats;
8f84985f 1887 struct pcpu_sw_netstats __percpu *tstats;
536721b1
KK
1888 struct pcpu_dstats __percpu *dstats;
1889 struct pcpu_vstats __percpu *vstats;
a7855c78 1890 };
536721b1 1891
fb585b44 1892#if IS_ENABLED(CONFIG_GARP)
3cc77ec7 1893 struct garp_port __rcu *garp_port;
fb585b44
TK
1894#endif
1895#if IS_ENABLED(CONFIG_MRP)
febf018d 1896 struct mrp_port __rcu *mrp_port;
fb585b44 1897#endif
1da177e4 1898
5e82b4b2 1899 struct device dev;
0c509a6c 1900 const struct attribute_group *sysfs_groups[4];
a953be53 1901 const struct attribute_group *sysfs_rx_queue_group;
38f7b870 1902
38f7b870 1903 const struct rtnl_link_ops *rtnl_link_ops;
f25f4e44 1904
82cc1a7a
PWJ
1905 /* for setting kernel sock attribute on TCP connection setup */
1906#define GSO_MAX_SIZE 65536
1907 unsigned int gso_max_size;
30b678d8
BH
1908#define GSO_MAX_SEGS 65535
1909 u16 gso_max_segs;
743b03a8 1910
7a6b6f51 1911#ifdef CONFIG_DCB
32953543 1912 const struct dcbnl_rtnl_ops *dcbnl_ops;
2f90b865 1913#endif
5e82b4b2
BH
1914 u8 num_tc;
1915 struct netdev_tc_txq tc_to_txq[TC_MAX_QUEUE];
1916 u8 prio_tc_map[TC_BITMASK + 1];
2f90b865 1917
d11ead75 1918#if IS_ENABLED(CONFIG_FCOE)
4d288d57 1919 unsigned int fcoe_ddp_xid;
5bc1421e 1920#endif
86f8515f 1921#if IS_ENABLED(CONFIG_CGROUP_NET_PRIO)
5bc1421e 1922 struct netprio_map __rcu *priomap;
4d288d57 1923#endif
5e82b4b2
BH
1924 struct phy_device *phydev;
1925 struct lock_class_key *qdisc_tx_busylock;
f9eb8aea 1926 struct lock_class_key *qdisc_running_key;
5e82b4b2 1927 bool proto_down;
1da177e4 1928};
43cb76d9 1929#define to_net_dev(d) container_of(d, struct net_device, dev)
1da177e4 1930
b5cdae32
DM
1931static inline bool netif_elide_gro(const struct net_device *dev)
1932{
1933 if (!(dev->features & NETIF_F_GRO) || dev->xdp_prog)
1934 return true;
1935 return false;
1936}
1937
1da177e4 1938#define NETDEV_ALIGN 32
1da177e4 1939
4f57c087
JF
1940static inline
1941int netdev_get_prio_tc_map(const struct net_device *dev, u32 prio)
1942{
1943 return dev->prio_tc_map[prio & TC_BITMASK];
1944}
1945
1946static inline
1947int netdev_set_prio_tc_map(struct net_device *dev, u8 prio, u8 tc)
1948{
1949 if (tc >= dev->num_tc)
1950 return -EINVAL;
1951
1952 dev->prio_tc_map[prio & TC_BITMASK] = tc & TC_BITMASK;
1953 return 0;
1954}
1955
8d059b0f 1956int netdev_txq_to_tc(struct net_device *dev, unsigned int txq);
9cf1f6a8
AD
1957void netdev_reset_tc(struct net_device *dev);
1958int netdev_set_tc_queue(struct net_device *dev, u8 tc, u16 count, u16 offset);
1959int netdev_set_num_tc(struct net_device *dev, u8 num_tc);
4f57c087
JF
1960
1961static inline
1962int netdev_get_num_tc(struct net_device *dev)
1963{
1964 return dev->num_tc;
1965}
1966
e8a0464c
DM
1967static inline
1968struct netdev_queue *netdev_get_tx_queue(const struct net_device *dev,
1969 unsigned int index)
1970{
1971 return &dev->_tx[index];
1972}
1973
10c51b56
DB
1974static inline struct netdev_queue *skb_get_tx_queue(const struct net_device *dev,
1975 const struct sk_buff *skb)
1976{
1977 return netdev_get_tx_queue(dev, skb_get_queue_mapping(skb));
1978}
1979
e8a0464c
DM
1980static inline void netdev_for_each_tx_queue(struct net_device *dev,
1981 void (*f)(struct net_device *,
1982 struct netdev_queue *,
1983 void *),
1984 void *arg)
1985{
1986 unsigned int i;
1987
1988 for (i = 0; i < dev->num_tx_queues; i++)
1989 f(dev, &dev->_tx[i], arg);
1990}
1991
d3fff6c4
ED
1992#define netdev_lockdep_set_classes(dev) \
1993{ \
1994 static struct lock_class_key qdisc_tx_busylock_key; \
1995 static struct lock_class_key qdisc_running_key; \
1996 static struct lock_class_key qdisc_xmit_lock_key; \
1997 static struct lock_class_key dev_addr_list_lock_key; \
1998 unsigned int i; \
1999 \
2000 (dev)->qdisc_tx_busylock = &qdisc_tx_busylock_key; \
2001 (dev)->qdisc_running_key = &qdisc_running_key; \
2002 lockdep_set_class(&(dev)->addr_list_lock, \
2003 &dev_addr_list_lock_key); \
2004 for (i = 0; i < (dev)->num_tx_queues; i++) \
2005 lockdep_set_class(&(dev)->_tx[i]._xmit_lock, \
2006 &qdisc_xmit_lock_key); \
2007}
2008
f629d208 2009struct netdev_queue *netdev_pick_tx(struct net_device *dev,
f663dd9a
JW
2010 struct sk_buff *skb,
2011 void *accel_priv);
8c4c49df 2012
871b642a
PA
2013/* returns the headroom that the master device needs to take in account
2014 * when forwarding to this dev
2015 */
2016static inline unsigned netdev_get_fwd_headroom(struct net_device *dev)
2017{
2018 return dev->priv_flags & IFF_PHONY_HEADROOM ? 0 : dev->needed_headroom;
2019}
2020
2021static inline void netdev_set_rx_headroom(struct net_device *dev, int new_hr)
2022{
2023 if (dev->netdev_ops->ndo_set_rx_headroom)
2024 dev->netdev_ops->ndo_set_rx_headroom(dev, new_hr);
2025}
2026
2027/* set the device rx headroom to the dev's default */
2028static inline void netdev_reset_rx_headroom(struct net_device *dev)
2029{
2030 netdev_set_rx_headroom(dev, -1);
2031}
2032
c346dca1
YH
2033/*
2034 * Net namespace inlines
2035 */
2036static inline
2037struct net *dev_net(const struct net_device *dev)
2038{
c2d9ba9b 2039 return read_pnet(&dev->nd_net);
c346dca1
YH
2040}
2041
2042static inline
f5aa23fd 2043void dev_net_set(struct net_device *dev, struct net *net)
c346dca1 2044{
0c5c9fb5 2045 write_pnet(&dev->nd_net, net);
c346dca1
YH
2046}
2047
bea3348e
SH
2048/**
2049 * netdev_priv - access network device private data
2050 * @dev: network device
2051 *
2052 * Get network device private data
2053 */
6472ce60 2054static inline void *netdev_priv(const struct net_device *dev)
1da177e4 2055{
1ce8e7b5 2056 return (char *)dev + ALIGN(sizeof(struct net_device), NETDEV_ALIGN);
1da177e4
LT
2057}
2058
1da177e4
LT
2059/* Set the sysfs physical device reference for the network logical device
2060 * if set prior to registration will cause a symlink during initialization.
2061 */
43cb76d9 2062#define SET_NETDEV_DEV(net, pdev) ((net)->dev.parent = (pdev))
1da177e4 2063
384912ed 2064/* Set the sysfs device type for the network logical device to allow
3f79410c 2065 * fine-grained identification of different network device types. For
5e82b4b2 2066 * example Ethernet, Wireless LAN, Bluetooth, WiMAX etc.
384912ed
MH
2067 */
2068#define SET_NETDEV_DEVTYPE(net, devtype) ((net)->dev.type = (devtype))
2069
82dc3c63
ED
2070/* Default NAPI poll() weight
2071 * Device drivers are strongly advised to not use bigger value
2072 */
2073#define NAPI_POLL_WEIGHT 64
2074
3b582cc1 2075/**
5e82b4b2 2076 * netif_napi_add - initialize a NAPI context
3b582cc1 2077 * @dev: network device
5e82b4b2 2078 * @napi: NAPI context
3b582cc1
SH
2079 * @poll: polling function
2080 * @weight: default weight
2081 *
5e82b4b2
BH
2082 * netif_napi_add() must be used to initialize a NAPI context prior to calling
2083 * *any* of the other NAPI-related functions.
3b582cc1 2084 */
d565b0a1
HX
2085void netif_napi_add(struct net_device *dev, struct napi_struct *napi,
2086 int (*poll)(struct napi_struct *, int), int weight);
bea3348e 2087
d64b5e85 2088/**
5e82b4b2 2089 * netif_tx_napi_add - initialize a NAPI context
d64b5e85 2090 * @dev: network device
5e82b4b2 2091 * @napi: NAPI context
d64b5e85
ED
2092 * @poll: polling function
2093 * @weight: default weight
2094 *
2095 * This variant of netif_napi_add() should be used from drivers using NAPI
2096 * to exclusively poll a TX queue.
2097 * This will avoid we add it into napi_hash[], thus polluting this hash table.
2098 */
2099static inline void netif_tx_napi_add(struct net_device *dev,
2100 struct napi_struct *napi,
2101 int (*poll)(struct napi_struct *, int),
2102 int weight)
2103{
2104 set_bit(NAPI_STATE_NO_BUSY_POLL, &napi->state);
2105 netif_napi_add(dev, napi, poll, weight);
2106}
2107
d8156534 2108/**
5e82b4b2
BH
2109 * netif_napi_del - remove a NAPI context
2110 * @napi: NAPI context
d8156534 2111 *
5e82b4b2 2112 * netif_napi_del() removes a NAPI context from the network device NAPI list
d8156534 2113 */
d565b0a1
HX
2114void netif_napi_del(struct napi_struct *napi);
2115
2116struct napi_gro_cb {
78a478d0 2117 /* Virtual address of skb_shinfo(skb)->frags[0].page + offset. */
5e82b4b2 2118 void *frag0;
78a478d0 2119
7489594c
HX
2120 /* Length of frag0. */
2121 unsigned int frag0_len;
2122
86911732 2123 /* This indicates where we are processing relative to skb->data. */
5e82b4b2 2124 int data_offset;
86911732 2125
d565b0a1 2126 /* This is non-zero if the packet cannot be merged with the new skb. */
bf5a755f
JC
2127 u16 flush;
2128
2129 /* Save the IP ID here and check when we get to the transport layer */
2130 u16 flush_id;
d565b0a1
HX
2131
2132 /* Number of segments aggregated. */
2e71a6f8
ED
2133 u16 count;
2134
15e2396d
TH
2135 /* Start offset for remote checksum offload */
2136 u16 gro_remcsum_start;
2137
2e71a6f8
ED
2138 /* jiffies when first packet was created/queued */
2139 unsigned long age;
86347245 2140
afe93325 2141 /* Used in ipv6_gro_receive() and foo-over-udp */
b582ef09
OG
2142 u16 proto;
2143
baa32ff4
TH
2144 /* This is non-zero if the packet may be of the same flow. */
2145 u8 same_flow:1;
2146
fac8e0f5
JG
2147 /* Used in tunnel GRO receive */
2148 u8 encap_mark:1;
573e8fca
TH
2149
2150 /* GRO checksum is valid */
2151 u8 csum_valid:1;
2152
662880f4
TH
2153 /* Number of checksums via CHECKSUM_UNNECESSARY */
2154 u8 csum_cnt:3;
c3c7c254 2155
baa32ff4
TH
2156 /* Free the skb? */
2157 u8 free:2;
2158#define NAPI_GRO_FREE 1
2159#define NAPI_GRO_FREE_STOLEN_HEAD 2
2160
efc98d08
TH
2161 /* Used in foo-over-udp, set in udp[46]_gro_receive */
2162 u8 is_ipv6:1;
2163
a0ca153f
AD
2164 /* Used in GRE, set in fou/gue_gro_receive */
2165 u8 is_fou:1;
2166
1530545e
AD
2167 /* Used to determine if flush_id can be ignored */
2168 u8 is_atomic:1;
2169
fcd91dd4
SD
2170 /* Number of gro_receive callbacks this packet already went through */
2171 u8 recursion_counter:4;
2172
2173 /* 1 bit hole */
baa32ff4 2174
bf5a755f
JC
2175 /* used to support CHECKSUM_COMPLETE for tunneling protocols */
2176 __wsum csum;
2177
c3c7c254
ED
2178 /* used in skb_gro_receive() slow path */
2179 struct sk_buff *last;
d565b0a1
HX
2180};
2181
2182#define NAPI_GRO_CB(skb) ((struct napi_gro_cb *)(skb)->cb)
d8156534 2183
fcd91dd4
SD
2184#define GRO_RECURSION_LIMIT 15
2185static inline int gro_recursion_inc_test(struct sk_buff *skb)
2186{
2187 return ++NAPI_GRO_CB(skb)->recursion_counter == GRO_RECURSION_LIMIT;
2188}
2189
2190typedef struct sk_buff **(*gro_receive_t)(struct sk_buff **, struct sk_buff *);
2191static inline struct sk_buff **call_gro_receive(gro_receive_t cb,
2192 struct sk_buff **head,
2193 struct sk_buff *skb)
2194{
2195 if (unlikely(gro_recursion_inc_test(skb))) {
2196 NAPI_GRO_CB(skb)->flush |= 1;
2197 return NULL;
2198 }
2199
2200 return cb(head, skb);
2201}
2202
2203typedef struct sk_buff **(*gro_receive_sk_t)(struct sock *, struct sk_buff **,
2204 struct sk_buff *);
2205static inline struct sk_buff **call_gro_receive_sk(gro_receive_sk_t cb,
2206 struct sock *sk,
2207 struct sk_buff **head,
2208 struct sk_buff *skb)
2209{
2210 if (unlikely(gro_recursion_inc_test(skb))) {
2211 NAPI_GRO_CB(skb)->flush |= 1;
2212 return NULL;
2213 }
2214
2215 return cb(sk, head, skb);
2216}
2217
1da177e4 2218struct packet_type {
f2ccd8fa
DM
2219 __be16 type; /* This is really htons(ether_type). */
2220 struct net_device *dev; /* NULL is wildcarded here */
2221 int (*func) (struct sk_buff *,
2222 struct net_device *,
2223 struct packet_type *,
2224 struct net_device *);
c0de08d0
EL
2225 bool (*id_match)(struct packet_type *ptype,
2226 struct sock *sk);
1da177e4
LT
2227 void *af_packet_priv;
2228 struct list_head list;
2229};
2230
f191a1d1 2231struct offload_callbacks {
576a30eb 2232 struct sk_buff *(*gso_segment)(struct sk_buff *skb,
c8f44aff 2233 netdev_features_t features);
d565b0a1 2234 struct sk_buff **(*gro_receive)(struct sk_buff **head,
a2b12f3c 2235 struct sk_buff *skb);
299603e8 2236 int (*gro_complete)(struct sk_buff *skb, int nhoff);
f191a1d1
VY
2237};
2238
2239struct packet_offload {
2240 __be16 type; /* This is really htons(ether_type). */
bdef7de4 2241 u16 priority;
f191a1d1
VY
2242 struct offload_callbacks callbacks;
2243 struct list_head list;
1da177e4
LT
2244};
2245
5e82b4b2 2246/* often modified stats are per-CPU, other are shared (netdev->stats) */
8f84985f
LR
2247struct pcpu_sw_netstats {
2248 u64 rx_packets;
2249 u64 rx_bytes;
2250 u64 tx_packets;
2251 u64 tx_bytes;
2252 struct u64_stats_sync syncp;
2253};
2254
aabc92bb
PNA
2255#define __netdev_alloc_pcpu_stats(type, gfp) \
2256({ \
2257 typeof(type) __percpu *pcpu_stats = alloc_percpu_gfp(type, gfp);\
2258 if (pcpu_stats) { \
2259 int __cpu; \
2260 for_each_possible_cpu(__cpu) { \
2261 typeof(type) *stat; \
2262 stat = per_cpu_ptr(pcpu_stats, __cpu); \
2263 u64_stats_init(&stat->syncp); \
2264 } \
2265 } \
2266 pcpu_stats; \
1c213bd2
WC
2267})
2268
aabc92bb 2269#define netdev_alloc_pcpu_stats(type) \
326fcfa5 2270 __netdev_alloc_pcpu_stats(type, GFP_KERNEL)
aabc92bb 2271
764f5e54
JP
2272enum netdev_lag_tx_type {
2273 NETDEV_LAG_TX_TYPE_UNKNOWN,
2274 NETDEV_LAG_TX_TYPE_RANDOM,
2275 NETDEV_LAG_TX_TYPE_BROADCAST,
2276 NETDEV_LAG_TX_TYPE_ROUNDROBIN,
2277 NETDEV_LAG_TX_TYPE_ACTIVEBACKUP,
2278 NETDEV_LAG_TX_TYPE_HASH,
2279};
2280
2281struct netdev_lag_upper_info {
2282 enum netdev_lag_tx_type tx_type;
2283};
2284
fb1b2e3c
JP
2285struct netdev_lag_lower_state_info {
2286 u8 link_up : 1,
2287 tx_enabled : 1;
2288};
2289
1da177e4
LT
2290#include <linux/notifier.h>
2291
dcfe1421
AW
2292/* netdevice notifier chain. Please remember to update the rtnetlink
2293 * notification exclusion list in rtnetlink_event() when adding new
2294 * types.
2295 */
2296#define NETDEV_UP 0x0001 /* For now you can't veto a device up/down */
2297#define NETDEV_DOWN 0x0002
2298#define NETDEV_REBOOT 0x0003 /* Tell a protocol stack a network interface
2299 detected a hardware crash and restarted
2300 - we can use this eg to kick tcp sessions
2301 once done */
2302#define NETDEV_CHANGE 0x0004 /* Notify device state change */
2303#define NETDEV_REGISTER 0x0005
2304#define NETDEV_UNREGISTER 0x0006
1d486bfb 2305#define NETDEV_CHANGEMTU 0x0007 /* notify after mtu change happened */
dcfe1421
AW
2306#define NETDEV_CHANGEADDR 0x0008
2307#define NETDEV_GOING_DOWN 0x0009
2308#define NETDEV_CHANGENAME 0x000A
2309#define NETDEV_FEAT_CHANGE 0x000B
2310#define NETDEV_BONDING_FAILOVER 0x000C
2311#define NETDEV_PRE_UP 0x000D
2312#define NETDEV_PRE_TYPE_CHANGE 0x000E
2313#define NETDEV_POST_TYPE_CHANGE 0x000F
2314#define NETDEV_POST_INIT 0x0010
0115e8e3 2315#define NETDEV_UNREGISTER_FINAL 0x0011
dcfe1421
AW
2316#define NETDEV_RELEASE 0x0012
2317#define NETDEV_NOTIFY_PEERS 0x0013
2318#define NETDEV_JOIN 0x0014
42e52bf9 2319#define NETDEV_CHANGEUPPER 0x0015
4aa5dee4 2320#define NETDEV_RESEND_IGMP 0x0016
1d486bfb 2321#define NETDEV_PRECHANGEMTU 0x0017 /* notify before mtu change happened */
d4261e56 2322#define NETDEV_CHANGEINFODATA 0x0018
61bd3857 2323#define NETDEV_BONDING_INFO 0x0019
573c7ba0 2324#define NETDEV_PRECHANGEUPPER 0x001A
04d48266 2325#define NETDEV_CHANGELOWERSTATE 0x001B
7c46a640 2326#define NETDEV_UDP_TUNNEL_PUSH_INFO 0x001C
296d8ee3 2327#define NETDEV_UDP_TUNNEL_DROP_INFO 0x001D
08294a26 2328#define NETDEV_CHANGE_TX_QUEUE_LEN 0x001E
dcfe1421 2329
f629d208
JP
2330int register_netdevice_notifier(struct notifier_block *nb);
2331int unregister_netdevice_notifier(struct notifier_block *nb);
351638e7
JP
2332
2333struct netdev_notifier_info {
51d0c047
DA
2334 struct net_device *dev;
2335 struct netlink_ext_ack *extack;
351638e7
JP
2336};
2337
be9efd36
JP
2338struct netdev_notifier_change_info {
2339 struct netdev_notifier_info info; /* must be first */
2340 unsigned int flags_changed;
2341};
2342
0e4ead9d
JP
2343struct netdev_notifier_changeupper_info {
2344 struct netdev_notifier_info info; /* must be first */
2345 struct net_device *upper_dev; /* new upper dev */
2346 bool master; /* is upper dev master */
5e82b4b2 2347 bool linking; /* is the notification for link or unlink */
29bf24af 2348 void *upper_info; /* upper dev info */
0e4ead9d
JP
2349};
2350
04d48266
JP
2351struct netdev_notifier_changelowerstate_info {
2352 struct netdev_notifier_info info; /* must be first */
2353 void *lower_state_info; /* is lower dev state */
2354};
2355
75538c2b
CW
2356static inline void netdev_notifier_info_init(struct netdev_notifier_info *info,
2357 struct net_device *dev)
2358{
2359 info->dev = dev;
51d0c047 2360 info->extack = NULL;
75538c2b
CW
2361}
2362
351638e7
JP
2363static inline struct net_device *
2364netdev_notifier_info_to_dev(const struct netdev_notifier_info *info)
2365{
2366 return info->dev;
2367}
2368
51d0c047
DA
2369static inline struct netlink_ext_ack *
2370netdev_notifier_info_to_extack(const struct netdev_notifier_info *info)
2371{
2372 return info->extack;
2373}
2374
f629d208 2375int call_netdevice_notifiers(unsigned long val, struct net_device *dev);
dcfe1421
AW
2376
2377
1da177e4
LT
2378extern rwlock_t dev_base_lock; /* Device list lock */
2379
881d966b
EB
2380#define for_each_netdev(net, d) \
2381 list_for_each_entry(d, &(net)->dev_base_head, dev_list)
dcbccbd4
EB
2382#define for_each_netdev_reverse(net, d) \
2383 list_for_each_entry_reverse(d, &(net)->dev_base_head, dev_list)
c6d14c84
ED
2384#define for_each_netdev_rcu(net, d) \
2385 list_for_each_entry_rcu(d, &(net)->dev_base_head, dev_list)
881d966b
EB
2386#define for_each_netdev_safe(net, d, n) \
2387 list_for_each_entry_safe(d, n, &(net)->dev_base_head, dev_list)
2388#define for_each_netdev_continue(net, d) \
2389 list_for_each_entry_continue(d, &(net)->dev_base_head, dev_list)
254245d2 2390#define for_each_netdev_continue_rcu(net, d) \
2391 list_for_each_entry_continue_rcu(d, &(net)->dev_base_head, dev_list)
8a7fbfab 2392#define for_each_netdev_in_bond_rcu(bond, slave) \
2393 for_each_netdev_rcu(&init_net, slave) \
4ccce02e 2394 if (netdev_master_upper_dev_get_rcu(slave) == (bond))
881d966b 2395#define net_device_entry(lh) list_entry(lh, struct net_device, dev_list)
7562f876 2396
a050c33f
DL
2397static inline struct net_device *next_net_device(struct net_device *dev)
2398{
2399 struct list_head *lh;
2400 struct net *net;
2401
c346dca1 2402 net = dev_net(dev);
a050c33f
DL
2403 lh = dev->dev_list.next;
2404 return lh == &net->dev_base_head ? NULL : net_device_entry(lh);
2405}
2406
ce81b76a
ED
2407static inline struct net_device *next_net_device_rcu(struct net_device *dev)
2408{
2409 struct list_head *lh;
2410 struct net *net;
2411
2412 net = dev_net(dev);
ccf43438 2413 lh = rcu_dereference(list_next_rcu(&dev->dev_list));
ce81b76a
ED
2414 return lh == &net->dev_base_head ? NULL : net_device_entry(lh);
2415}
2416
a050c33f
DL
2417static inline struct net_device *first_net_device(struct net *net)
2418{
2419 return list_empty(&net->dev_base_head) ? NULL :
2420 net_device_entry(net->dev_base_head.next);
2421}
7562f876 2422
ccf43438
ED
2423static inline struct net_device *first_net_device_rcu(struct net *net)
2424{
2425 struct list_head *lh = rcu_dereference(list_next_rcu(&net->dev_base_head));
2426
2427 return lh == &net->dev_base_head ? NULL : net_device_entry(lh);
2428}
2429
f629d208
JP
2430int netdev_boot_setup_check(struct net_device *dev);
2431unsigned long netdev_boot_base(const char *prefix, int unit);
2432struct net_device *dev_getbyhwaddr_rcu(struct net *net, unsigned short type,
2433 const char *hwaddr);
2434struct net_device *dev_getfirstbyhwtype(struct net *net, unsigned short type);
2435struct net_device *__dev_getfirstbyhwtype(struct net *net, unsigned short type);
2436void dev_add_pack(struct packet_type *pt);
2437void dev_remove_pack(struct packet_type *pt);
2438void __dev_remove_pack(struct packet_type *pt);
2439void dev_add_offload(struct packet_offload *po);
2440void dev_remove_offload(struct packet_offload *po);
f629d208 2441
a54acb3a 2442int dev_get_iflink(const struct net_device *dev);
fc4099f1 2443int dev_fill_metadata_dst(struct net_device *dev, struct sk_buff *skb);
6c555490
WC
2444struct net_device *__dev_get_by_flags(struct net *net, unsigned short flags,
2445 unsigned short mask);
f629d208
JP
2446struct net_device *dev_get_by_name(struct net *net, const char *name);
2447struct net_device *dev_get_by_name_rcu(struct net *net, const char *name);
2448struct net_device *__dev_get_by_name(struct net *net, const char *name);
2449int dev_alloc_name(struct net_device *dev, const char *name);
2450int dev_open(struct net_device *dev);
7051b88a 2451void dev_close(struct net_device *dev);
2452void dev_close_many(struct list_head *head, bool unlink);
f629d208 2453void dev_disable_lro(struct net_device *dev);
0c4b51f0 2454int dev_loopback_xmit(struct net *net, struct sock *sk, struct sk_buff *newskb);
2b4aa3ce 2455int dev_queue_xmit(struct sk_buff *skb);
f663dd9a 2456int dev_queue_xmit_accel(struct sk_buff *skb, void *accel_priv);
f629d208
JP
2457int register_netdevice(struct net_device *dev);
2458void unregister_netdevice_queue(struct net_device *dev, struct list_head *head);
2459void unregister_netdevice_many(struct list_head *head);
44a0873d
ED
2460static inline void unregister_netdevice(struct net_device *dev)
2461{
2462 unregister_netdevice_queue(dev, NULL);
2463}
2464
f629d208
JP
2465int netdev_refcnt_read(const struct net_device *dev);
2466void free_netdev(struct net_device *dev);
74d332c1 2467void netdev_freemem(struct net_device *dev);
f629d208
JP
2468void synchronize_net(void);
2469int init_dummy_netdev(struct net_device *dev);
937f1ba5 2470
f60e5990 2471DECLARE_PER_CPU(int, xmit_recursion);
a70b506e
DB
2472#define XMIT_RECURSION_LIMIT 10
2473
f60e5990 2474static inline int dev_recursion_level(void)
2475{
2476 return this_cpu_read(xmit_recursion);
2477}
2478
f629d208
JP
2479struct net_device *dev_get_by_index(struct net *net, int ifindex);
2480struct net_device *__dev_get_by_index(struct net *net, int ifindex);
2481struct net_device *dev_get_by_index_rcu(struct net *net, int ifindex);
90b602f8 2482struct net_device *dev_get_by_napi_id(unsigned int napi_id);
f629d208
JP
2483int netdev_get_name(struct net *net, char *name, int ifindex);
2484int dev_restart(struct net_device *dev);
f629d208 2485int skb_gro_receive(struct sk_buff **head, struct sk_buff *skb);
86911732
HX
2486
2487static inline unsigned int skb_gro_offset(const struct sk_buff *skb)
2488{
2489 return NAPI_GRO_CB(skb)->data_offset;
2490}
2491
2492static inline unsigned int skb_gro_len(const struct sk_buff *skb)
2493{
2494 return skb->len - NAPI_GRO_CB(skb)->data_offset;
2495}
2496
2497static inline void skb_gro_pull(struct sk_buff *skb, unsigned int len)
2498{
2499 NAPI_GRO_CB(skb)->data_offset += len;
2500}
2501
a5b1cf28
HX
2502static inline void *skb_gro_header_fast(struct sk_buff *skb,
2503 unsigned int offset)
86911732 2504{
a5b1cf28
HX
2505 return NAPI_GRO_CB(skb)->frag0 + offset;
2506}
78a478d0 2507
a5b1cf28
HX
2508static inline int skb_gro_header_hard(struct sk_buff *skb, unsigned int hlen)
2509{
2510 return NAPI_GRO_CB(skb)->frag0_len < hlen;
2511}
78a478d0 2512
57ea52a8
HX
2513static inline void skb_gro_frag0_invalidate(struct sk_buff *skb)
2514{
2515 NAPI_GRO_CB(skb)->frag0 = NULL;
2516 NAPI_GRO_CB(skb)->frag0_len = 0;
2517}
2518
a5b1cf28
HX
2519static inline void *skb_gro_header_slow(struct sk_buff *skb, unsigned int hlen,
2520 unsigned int offset)
2521{
17dd759c
HX
2522 if (!pskb_may_pull(skb, hlen))
2523 return NULL;
2524
57ea52a8 2525 skb_gro_frag0_invalidate(skb);
17dd759c 2526 return skb->data + offset;
86911732 2527}
1da177e4 2528
36e7b1b8
HX
2529static inline void *skb_gro_network_header(struct sk_buff *skb)
2530{
78d3fd0b
HX
2531 return (NAPI_GRO_CB(skb)->frag0 ?: skb->data) +
2532 skb_network_offset(skb);
36e7b1b8
HX
2533}
2534
bf5a755f
JC
2535static inline void skb_gro_postpull_rcsum(struct sk_buff *skb,
2536 const void *start, unsigned int len)
2537{
573e8fca 2538 if (NAPI_GRO_CB(skb)->csum_valid)
bf5a755f
JC
2539 NAPI_GRO_CB(skb)->csum = csum_sub(NAPI_GRO_CB(skb)->csum,
2540 csum_partial(start, len, 0));
2541}
2542
573e8fca
TH
2543/* GRO checksum functions. These are logical equivalents of the normal
2544 * checksum functions (in skbuff.h) except that they operate on the GRO
2545 * offsets and fields in sk_buff.
2546 */
2547
2548__sum16 __skb_gro_checksum_complete(struct sk_buff *skb);
2549
15e2396d
TH
2550static inline bool skb_at_gro_remcsum_start(struct sk_buff *skb)
2551{
b7fe10e5 2552 return (NAPI_GRO_CB(skb)->gro_remcsum_start == skb_gro_offset(skb));
15e2396d
TH
2553}
2554
573e8fca
TH
2555static inline bool __skb_gro_checksum_validate_needed(struct sk_buff *skb,
2556 bool zero_okay,
2557 __sum16 check)
2558{
6edec0e6
TH
2559 return ((skb->ip_summed != CHECKSUM_PARTIAL ||
2560 skb_checksum_start_offset(skb) <
2561 skb_gro_offset(skb)) &&
15e2396d 2562 !skb_at_gro_remcsum_start(skb) &&
662880f4 2563 NAPI_GRO_CB(skb)->csum_cnt == 0 &&
573e8fca
TH
2564 (!zero_okay || check));
2565}
2566
2567static inline __sum16 __skb_gro_checksum_validate_complete(struct sk_buff *skb,
2568 __wsum psum)
2569{
2570 if (NAPI_GRO_CB(skb)->csum_valid &&
2571 !csum_fold(csum_add(psum, NAPI_GRO_CB(skb)->csum)))
2572 return 0;
2573
2574 NAPI_GRO_CB(skb)->csum = psum;
2575
2576 return __skb_gro_checksum_complete(skb);
2577}
2578
573e8fca
TH
2579static inline void skb_gro_incr_csum_unnecessary(struct sk_buff *skb)
2580{
662880f4
TH
2581 if (NAPI_GRO_CB(skb)->csum_cnt > 0) {
2582 /* Consume a checksum from CHECKSUM_UNNECESSARY */
2583 NAPI_GRO_CB(skb)->csum_cnt--;
2584 } else {
2585 /* Update skb for CHECKSUM_UNNECESSARY and csum_level when we
2586 * verified a new top level checksum or an encapsulated one
2587 * during GRO. This saves work if we fallback to normal path.
2588 */
2589 __skb_incr_checksum_unnecessary(skb);
573e8fca
TH
2590 }
2591}
2592
2593#define __skb_gro_checksum_validate(skb, proto, zero_okay, check, \
2594 compute_pseudo) \
2595({ \
2596 __sum16 __ret = 0; \
2597 if (__skb_gro_checksum_validate_needed(skb, zero_okay, check)) \
2598 __ret = __skb_gro_checksum_validate_complete(skb, \
2599 compute_pseudo(skb, proto)); \
219f1d79 2600 if (!__ret) \
573e8fca
TH
2601 skb_gro_incr_csum_unnecessary(skb); \
2602 __ret; \
2603})
2604
2605#define skb_gro_checksum_validate(skb, proto, compute_pseudo) \
2606 __skb_gro_checksum_validate(skb, proto, false, 0, compute_pseudo)
2607
2608#define skb_gro_checksum_validate_zero_check(skb, proto, check, \
2609 compute_pseudo) \
2610 __skb_gro_checksum_validate(skb, proto, true, check, compute_pseudo)
2611
2612#define skb_gro_checksum_simple_validate(skb) \
2613 __skb_gro_checksum_validate(skb, 0, false, 0, null_compute_pseudo)
2614
d96535a1
TH
2615static inline bool __skb_gro_checksum_convert_check(struct sk_buff *skb)
2616{
2617 return (NAPI_GRO_CB(skb)->csum_cnt == 0 &&
2618 !NAPI_GRO_CB(skb)->csum_valid);
2619}
2620
2621static inline void __skb_gro_checksum_convert(struct sk_buff *skb,
2622 __sum16 check, __wsum pseudo)
2623{
2624 NAPI_GRO_CB(skb)->csum = ~pseudo;
2625 NAPI_GRO_CB(skb)->csum_valid = 1;
2626}
2627
2628#define skb_gro_checksum_try_convert(skb, proto, check, compute_pseudo) \
2629do { \
2630 if (__skb_gro_checksum_convert_check(skb)) \
2631 __skb_gro_checksum_convert(skb, check, \
2632 compute_pseudo(skb, proto)); \
2633} while (0)
2634
26c4f7da
TH
2635struct gro_remcsum {
2636 int offset;
2637 __wsum delta;
2638};
2639
2640static inline void skb_gro_remcsum_init(struct gro_remcsum *grc)
2641{
846cd667 2642 grc->offset = 0;
26c4f7da
TH
2643 grc->delta = 0;
2644}
2645
b7fe10e5
TH
2646static inline void *skb_gro_remcsum_process(struct sk_buff *skb, void *ptr,
2647 unsigned int off, size_t hdrlen,
2648 int start, int offset,
2649 struct gro_remcsum *grc,
2650 bool nopartial)
dcdc8994
TH
2651{
2652 __wsum delta;
b7fe10e5 2653 size_t plen = hdrlen + max_t(size_t, offset + sizeof(u16), start);
dcdc8994
TH
2654
2655 BUG_ON(!NAPI_GRO_CB(skb)->csum_valid);
2656
15e2396d 2657 if (!nopartial) {
b7fe10e5
TH
2658 NAPI_GRO_CB(skb)->gro_remcsum_start = off + hdrlen + start;
2659 return ptr;
2660 }
2661
2662 ptr = skb_gro_header_fast(skb, off);
2663 if (skb_gro_header_hard(skb, off + plen)) {
2664 ptr = skb_gro_header_slow(skb, off + plen, off);
2665 if (!ptr)
2666 return NULL;
15e2396d
TH
2667 }
2668
b7fe10e5
TH
2669 delta = remcsum_adjust(ptr + hdrlen, NAPI_GRO_CB(skb)->csum,
2670 start, offset);
dcdc8994
TH
2671
2672 /* Adjust skb->csum since we changed the packet */
dcdc8994 2673 NAPI_GRO_CB(skb)->csum = csum_add(NAPI_GRO_CB(skb)->csum, delta);
26c4f7da 2674
b7fe10e5 2675 grc->offset = off + hdrlen + offset;
26c4f7da 2676 grc->delta = delta;
b7fe10e5
TH
2677
2678 return ptr;
dcdc8994
TH
2679}
2680
26c4f7da
TH
2681static inline void skb_gro_remcsum_cleanup(struct sk_buff *skb,
2682 struct gro_remcsum *grc)
2683{
b7fe10e5
TH
2684 void *ptr;
2685 size_t plen = grc->offset + sizeof(u16);
2686
26c4f7da
TH
2687 if (!grc->delta)
2688 return;
2689
b7fe10e5
TH
2690 ptr = skb_gro_header_fast(skb, grc->offset);
2691 if (skb_gro_header_hard(skb, grc->offset + sizeof(u16))) {
2692 ptr = skb_gro_header_slow(skb, plen, grc->offset);
2693 if (!ptr)
2694 return;
2695 }
2696
2697 remcsum_unadjust((__sum16 *)ptr, grc->delta);
26c4f7da 2698}
dcdc8994 2699
25393d3f
SK
2700#ifdef CONFIG_XFRM_OFFLOAD
2701static inline void skb_gro_flush_final(struct sk_buff *skb, struct sk_buff **pp, int flush)
2702{
2703 if (PTR_ERR(pp) != -EINPROGRESS)
2704 NAPI_GRO_CB(skb)->flush |= flush;
2705}
2706#else
5f114163
SK
2707static inline void skb_gro_flush_final(struct sk_buff *skb, struct sk_buff **pp, int flush)
2708{
2709 NAPI_GRO_CB(skb)->flush |= flush;
2710}
25393d3f 2711#endif
5f114163 2712
0c4e8581
SH
2713static inline int dev_hard_header(struct sk_buff *skb, struct net_device *dev,
2714 unsigned short type,
3b04ddde 2715 const void *daddr, const void *saddr,
95c96174 2716 unsigned int len)
0c4e8581 2717{
f1ecfd5d 2718 if (!dev->header_ops || !dev->header_ops->create)
0c4e8581 2719 return 0;
3b04ddde
SH
2720
2721 return dev->header_ops->create(skb, dev, type, daddr, saddr, len);
0c4e8581
SH
2722}
2723
b95cce35
SH
2724static inline int dev_parse_header(const struct sk_buff *skb,
2725 unsigned char *haddr)
2726{
2727 const struct net_device *dev = skb->dev;
2728
1b83336b 2729 if (!dev->header_ops || !dev->header_ops->parse)
b95cce35 2730 return 0;
3b04ddde 2731 return dev->header_ops->parse(skb, haddr);
b95cce35
SH
2732}
2733
2793a23a
WB
2734/* ll_header must have at least hard_header_len allocated */
2735static inline bool dev_validate_header(const struct net_device *dev,
2736 char *ll_header, int len)
2737{
2738 if (likely(len >= dev->hard_header_len))
2739 return true;
217e6fa2
WB
2740 if (len < dev->min_header_len)
2741 return false;
2793a23a
WB
2742
2743 if (capable(CAP_SYS_RAWIO)) {
2744 memset(ll_header + len, 0, dev->hard_header_len - len);
2745 return true;
2746 }
2747
2748 if (dev->header_ops && dev->header_ops->validate)
2749 return dev->header_ops->validate(ll_header, len);
2750
2751 return false;
2752}
2753
1da177e4 2754typedef int gifconf_func_t(struct net_device * dev, char __user * bufptr, int len);
f629d208 2755int register_gifconf(unsigned int family, gifconf_func_t *gifconf);
1da177e4
LT
2756static inline int unregister_gifconf(unsigned int family)
2757{
2758 return register_gifconf(family, NULL);
2759}
2760
99bbc707 2761#ifdef CONFIG_NET_FLOW_LIMIT
5f121b9a 2762#define FLOW_LIMIT_HISTORY (1 << 7) /* must be ^2 and !overflow buckets */
99bbc707
WB
2763struct sd_flow_limit {
2764 u64 count;
2765 unsigned int num_buckets;
2766 unsigned int history_head;
2767 u16 history[FLOW_LIMIT_HISTORY];
2768 u8 buckets[];
2769};
2770
2771extern int netdev_flow_limit_table_len;
2772#endif /* CONFIG_NET_FLOW_LIMIT */
2773
1da177e4 2774/*
5e82b4b2 2775 * Incoming packets are placed on per-CPU queues
1da177e4 2776 */
d94d9fee 2777struct softnet_data {
1da177e4 2778 struct list_head poll_list;
6e7676c1 2779 struct sk_buff_head process_queue;
1da177e4 2780
dee42870 2781 /* stats */
cd7b5396
DM
2782 unsigned int processed;
2783 unsigned int time_squeeze;
cd7b5396 2784 unsigned int received_rps;
fd793d89 2785#ifdef CONFIG_RPS
88751275 2786 struct softnet_data *rps_ipi_list;
4cdb1e2e
ED
2787#endif
2788#ifdef CONFIG_NET_FLOW_LIMIT
2789 struct sd_flow_limit __rcu *flow_limit;
2790#endif
2791 struct Qdisc *output_queue;
2792 struct Qdisc **output_queue_tailp;
2793 struct sk_buff *completion_queue;
88751275 2794
4cdb1e2e 2795#ifdef CONFIG_RPS
501e7ef5
ED
2796 /* input_queue_head should be written by cpu owning this struct,
2797 * and only read by other cpus. Worth using a cache line.
2798 */
2799 unsigned int input_queue_head ____cacheline_aligned_in_smp;
2800
2801 /* Elements below can be accessed between CPUs for RPS/RFS */
966a9671 2802 call_single_data_t csd ____cacheline_aligned_in_smp;
88751275
ED
2803 struct softnet_data *rps_ipi_next;
2804 unsigned int cpu;
76cc8b13 2805 unsigned int input_queue_tail;
1e94d72f 2806#endif
95c96174 2807 unsigned int dropped;
0a9627f2 2808 struct sk_buff_head input_pkt_queue;
bea3348e 2809 struct napi_struct backlog;
99bbc707 2810
1da177e4
LT
2811};
2812
76cc8b13 2813static inline void input_queue_head_incr(struct softnet_data *sd)
fec5e652
TH
2814{
2815#ifdef CONFIG_RPS
76cc8b13
TH
2816 sd->input_queue_head++;
2817#endif
2818}
2819
2820static inline void input_queue_tail_incr_save(struct softnet_data *sd,
2821 unsigned int *qtail)
2822{
2823#ifdef CONFIG_RPS
2824 *qtail = ++sd->input_queue_tail;
fec5e652
TH
2825#endif
2826}
2827
0a9627f2 2828DECLARE_PER_CPU_ALIGNED(struct softnet_data, softnet_data);
1da177e4 2829
f629d208 2830void __netif_schedule(struct Qdisc *q);
46e5da40 2831void netif_schedule_queue(struct netdev_queue *txq);
86d804e1 2832
fd2ea0a7
DM
2833static inline void netif_tx_schedule_all(struct net_device *dev)
2834{
2835 unsigned int i;
2836
2837 for (i = 0; i < dev->num_tx_queues; i++)
2838 netif_schedule_queue(netdev_get_tx_queue(dev, i));
2839}
2840
f9a7cbbf 2841static __always_inline void netif_tx_start_queue(struct netdev_queue *dev_queue)
d29f749e 2842{
73466498 2843 clear_bit(__QUEUE_STATE_DRV_XOFF, &dev_queue->state);
d29f749e
DJ
2844}
2845
bea3348e
SH
2846/**
2847 * netif_start_queue - allow transmit
2848 * @dev: network device
2849 *
2850 * Allow upper layers to call the device hard_start_xmit routine.
2851 */
1da177e4
LT
2852static inline void netif_start_queue(struct net_device *dev)
2853{
e8a0464c 2854 netif_tx_start_queue(netdev_get_tx_queue(dev, 0));
1da177e4
LT
2855}
2856
fd2ea0a7
DM
2857static inline void netif_tx_start_all_queues(struct net_device *dev)
2858{
2859 unsigned int i;
2860
2861 for (i = 0; i < dev->num_tx_queues; i++) {
2862 struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
2863 netif_tx_start_queue(txq);
2864 }
2865}
2866
46e5da40 2867void netif_tx_wake_queue(struct netdev_queue *dev_queue);
79d16385 2868
d29f749e
DJ
2869/**
2870 * netif_wake_queue - restart transmit
2871 * @dev: network device
2872 *
2873 * Allow upper layers to call the device hard_start_xmit routine.
2874 * Used for flow control when transmit resources are available.
2875 */
79d16385
DM
2876static inline void netif_wake_queue(struct net_device *dev)
2877{
e8a0464c 2878 netif_tx_wake_queue(netdev_get_tx_queue(dev, 0));
1da177e4
LT
2879}
2880
fd2ea0a7
DM
2881static inline void netif_tx_wake_all_queues(struct net_device *dev)
2882{
2883 unsigned int i;
2884
2885 for (i = 0; i < dev->num_tx_queues; i++) {
2886 struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
2887 netif_tx_wake_queue(txq);
2888 }
2889}
2890
f9a7cbbf 2891static __always_inline void netif_tx_stop_queue(struct netdev_queue *dev_queue)
d29f749e 2892{
73466498 2893 set_bit(__QUEUE_STATE_DRV_XOFF, &dev_queue->state);
d29f749e
DJ
2894}
2895
bea3348e
SH
2896/**
2897 * netif_stop_queue - stop transmitted packets
2898 * @dev: network device
2899 *
2900 * Stop upper layers calling the device hard_start_xmit routine.
2901 * Used for flow control when transmit resources are unavailable.
2902 */
1da177e4
LT
2903static inline void netif_stop_queue(struct net_device *dev)
2904{
e8a0464c 2905 netif_tx_stop_queue(netdev_get_tx_queue(dev, 0));
1da177e4
LT
2906}
2907
a2029240 2908void netif_tx_stop_all_queues(struct net_device *dev);
fd2ea0a7 2909
4d29515f 2910static inline bool netif_tx_queue_stopped(const struct netdev_queue *dev_queue)
d29f749e 2911{
73466498 2912 return test_bit(__QUEUE_STATE_DRV_XOFF, &dev_queue->state);
d29f749e
DJ
2913}
2914
bea3348e
SH
2915/**
2916 * netif_queue_stopped - test if transmit queue is flowblocked
2917 * @dev: network device
2918 *
2919 * Test if transmit queue on device is currently unable to send.
2920 */
4d29515f 2921static inline bool netif_queue_stopped(const struct net_device *dev)
1da177e4 2922{
e8a0464c 2923 return netif_tx_queue_stopped(netdev_get_tx_queue(dev, 0));
1da177e4
LT
2924}
2925
4d29515f 2926static inline bool netif_xmit_stopped(const struct netdev_queue *dev_queue)
c3f26a26 2927{
73466498
TH
2928 return dev_queue->state & QUEUE_STATE_ANY_XOFF;
2929}
2930
8e2f1a63
DB
2931static inline bool
2932netif_xmit_frozen_or_stopped(const struct netdev_queue *dev_queue)
73466498
TH
2933{
2934 return dev_queue->state & QUEUE_STATE_ANY_XOFF_OR_FROZEN;
2935}
2936
8e2f1a63
DB
2937static inline bool
2938netif_xmit_frozen_or_drv_stopped(const struct netdev_queue *dev_queue)
2939{
2940 return dev_queue->state & QUEUE_STATE_DRV_XOFF_OR_FROZEN;
2941}
2942
53511453
ED
2943/**
2944 * netdev_txq_bql_enqueue_prefetchw - prefetch bql data for write
2945 * @dev_queue: pointer to transmit queue
2946 *
2947 * BQL enabled drivers might use this helper in their ndo_start_xmit(),
5e82b4b2 2948 * to give appropriate hint to the CPU.
53511453
ED
2949 */
2950static inline void netdev_txq_bql_enqueue_prefetchw(struct netdev_queue *dev_queue)
2951{
2952#ifdef CONFIG_BQL
2953 prefetchw(&dev_queue->dql.num_queued);
2954#endif
2955}
2956
2957/**
2958 * netdev_txq_bql_complete_prefetchw - prefetch bql data for write
2959 * @dev_queue: pointer to transmit queue
2960 *
2961 * BQL enabled drivers might use this helper in their TX completion path,
5e82b4b2 2962 * to give appropriate hint to the CPU.
53511453
ED
2963 */
2964static inline void netdev_txq_bql_complete_prefetchw(struct netdev_queue *dev_queue)
2965{
2966#ifdef CONFIG_BQL
2967 prefetchw(&dev_queue->dql.limit);
2968#endif
2969}
2970
c5d67bd7
TH
2971static inline void netdev_tx_sent_queue(struct netdev_queue *dev_queue,
2972 unsigned int bytes)
2973{
114cf580
TH
2974#ifdef CONFIG_BQL
2975 dql_queued(&dev_queue->dql, bytes);
b37c0fbe
AD
2976
2977 if (likely(dql_avail(&dev_queue->dql) >= 0))
2978 return;
2979
2980 set_bit(__QUEUE_STATE_STACK_XOFF, &dev_queue->state);
2981
2982 /*
2983 * The XOFF flag must be set before checking the dql_avail below,
2984 * because in netdev_tx_completed_queue we update the dql_completed
2985 * before checking the XOFF flag.
2986 */
2987 smp_mb();
2988
2989 /* check again in case another CPU has just made room avail */
2990 if (unlikely(dql_avail(&dev_queue->dql) >= 0))
2991 clear_bit(__QUEUE_STATE_STACK_XOFF, &dev_queue->state);
114cf580 2992#endif
c5d67bd7
TH
2993}
2994
0042d0c8
FF
2995/**
2996 * netdev_sent_queue - report the number of bytes queued to hardware
2997 * @dev: network device
2998 * @bytes: number of bytes queued to the hardware device queue
2999 *
3000 * Report the number of bytes queued for sending/completion to the network
3001 * device hardware queue. @bytes should be a good approximation and should
3002 * exactly match netdev_completed_queue() @bytes
3003 */
c5d67bd7
TH
3004static inline void netdev_sent_queue(struct net_device *dev, unsigned int bytes)
3005{
3006 netdev_tx_sent_queue(netdev_get_tx_queue(dev, 0), bytes);
3007}
3008
3009static inline void netdev_tx_completed_queue(struct netdev_queue *dev_queue,
95c96174 3010 unsigned int pkts, unsigned int bytes)
c5d67bd7 3011{
114cf580 3012#ifdef CONFIG_BQL
b37c0fbe
AD
3013 if (unlikely(!bytes))
3014 return;
3015
3016 dql_completed(&dev_queue->dql, bytes);
3017
3018 /*
3019 * Without the memory barrier there is a small possiblity that
3020 * netdev_tx_sent_queue will miss the update and cause the queue to
3021 * be stopped forever
3022 */
3023 smp_mb();
3024
3025 if (dql_avail(&dev_queue->dql) < 0)
3026 return;
3027
3028 if (test_and_clear_bit(__QUEUE_STATE_STACK_XOFF, &dev_queue->state))
3029 netif_schedule_queue(dev_queue);
114cf580 3030#endif
c5d67bd7
TH
3031}
3032
0042d0c8
FF
3033/**
3034 * netdev_completed_queue - report bytes and packets completed by device
3035 * @dev: network device
3036 * @pkts: actual number of packets sent over the medium
3037 * @bytes: actual number of bytes sent over the medium
3038 *
3039 * Report the number of bytes and packets transmitted by the network device
3040 * hardware queue over the physical medium, @bytes must exactly match the
3041 * @bytes amount passed to netdev_sent_queue()
3042 */
c5d67bd7 3043static inline void netdev_completed_queue(struct net_device *dev,
95c96174 3044 unsigned int pkts, unsigned int bytes)
c5d67bd7
TH
3045{
3046 netdev_tx_completed_queue(netdev_get_tx_queue(dev, 0), pkts, bytes);
3047}
3048
3049static inline void netdev_tx_reset_queue(struct netdev_queue *q)
3050{
114cf580 3051#ifdef CONFIG_BQL
5c490354 3052 clear_bit(__QUEUE_STATE_STACK_XOFF, &q->state);
114cf580
TH
3053 dql_reset(&q->dql);
3054#endif
c5d67bd7
TH
3055}
3056
0042d0c8
FF
3057/**
3058 * netdev_reset_queue - reset the packets and bytes count of a network device
3059 * @dev_queue: network device
3060 *
3061 * Reset the bytes and packet count of a network device and clear the
3062 * software flow control OFF bit for this network device
3063 */
c5d67bd7
TH
3064static inline void netdev_reset_queue(struct net_device *dev_queue)
3065{
3066 netdev_tx_reset_queue(netdev_get_tx_queue(dev_queue, 0));
c3f26a26
DM
3067}
3068
b9507bda
DB
3069/**
3070 * netdev_cap_txqueue - check if selected tx queue exceeds device queues
3071 * @dev: network device
3072 * @queue_index: given tx queue index
3073 *
3074 * Returns 0 if given tx queue index >= number of device tx queues,
3075 * otherwise returns the originally passed tx queue index.
3076 */
3077static inline u16 netdev_cap_txqueue(struct net_device *dev, u16 queue_index)
3078{
3079 if (unlikely(queue_index >= dev->real_num_tx_queues)) {
3080 net_warn_ratelimited("%s selects TX queue %d, but real number of TX queues is %d\n",
3081 dev->name, queue_index,
3082 dev->real_num_tx_queues);
3083 return 0;
3084 }
3085
3086 return queue_index;
3087}
3088
bea3348e
SH
3089/**
3090 * netif_running - test if up
3091 * @dev: network device
3092 *
3093 * Test if the device has been brought up.
3094 */
4d29515f 3095static inline bool netif_running(const struct net_device *dev)
1da177e4
LT
3096{
3097 return test_bit(__LINK_STATE_START, &dev->state);
3098}
3099
f25f4e44 3100/*
5e82b4b2 3101 * Routines to manage the subqueues on a device. We only need start,
f25f4e44
PWJ
3102 * stop, and a check if it's stopped. All other device management is
3103 * done at the overall netdevice level.
3104 * Also test the device if we're multiqueue.
3105 */
bea3348e
SH
3106
3107/**
3108 * netif_start_subqueue - allow sending packets on subqueue
3109 * @dev: network device
3110 * @queue_index: sub queue index
3111 *
3112 * Start individual transmit queue of a device with multiple transmit queues.
3113 */
f25f4e44
PWJ
3114static inline void netif_start_subqueue(struct net_device *dev, u16 queue_index)
3115{
fd2ea0a7 3116 struct netdev_queue *txq = netdev_get_tx_queue(dev, queue_index);
7b3d3e4f
KK
3117
3118 netif_tx_start_queue(txq);
f25f4e44
PWJ
3119}
3120
bea3348e
SH
3121/**
3122 * netif_stop_subqueue - stop sending packets on subqueue
3123 * @dev: network device
3124 * @queue_index: sub queue index
3125 *
3126 * Stop individual transmit queue of a device with multiple transmit queues.
3127 */
f25f4e44
PWJ
3128static inline void netif_stop_subqueue(struct net_device *dev, u16 queue_index)
3129{
fd2ea0a7 3130 struct netdev_queue *txq = netdev_get_tx_queue(dev, queue_index);
7b3d3e4f 3131 netif_tx_stop_queue(txq);
f25f4e44
PWJ
3132}
3133
bea3348e
SH
3134/**
3135 * netif_subqueue_stopped - test status of subqueue
3136 * @dev: network device
3137 * @queue_index: sub queue index
3138 *
3139 * Check individual transmit queue of a device with multiple transmit queues.
3140 */
4d29515f
DM
3141static inline bool __netif_subqueue_stopped(const struct net_device *dev,
3142 u16 queue_index)
f25f4e44 3143{
fd2ea0a7 3144 struct netdev_queue *txq = netdev_get_tx_queue(dev, queue_index);
7b3d3e4f
KK
3145
3146 return netif_tx_queue_stopped(txq);
f25f4e44
PWJ
3147}
3148
4d29515f
DM
3149static inline bool netif_subqueue_stopped(const struct net_device *dev,
3150 struct sk_buff *skb)
668f895a
PE
3151{
3152 return __netif_subqueue_stopped(dev, skb_get_queue_mapping(skb));
3153}
bea3348e 3154
738b35cc
FF
3155/**
3156 * netif_wake_subqueue - allow sending packets on subqueue
3157 * @dev: network device
3158 * @queue_index: sub queue index
3159 *
3160 * Resume individual transmit queue of a device with multiple transmit queues.
3161 */
3162static inline void netif_wake_subqueue(struct net_device *dev, u16 queue_index)
3163{
3164 struct netdev_queue *txq = netdev_get_tx_queue(dev, queue_index);
3165
3166 netif_tx_wake_queue(txq);
3167}
f25f4e44 3168
537c00de 3169#ifdef CONFIG_XPS
53af53ae 3170int netif_set_xps_queue(struct net_device *dev, const struct cpumask *mask,
f629d208 3171 u16 index);
537c00de
AD
3172#else
3173static inline int netif_set_xps_queue(struct net_device *dev,
3573540c 3174 const struct cpumask *mask,
537c00de
AD
3175 u16 index)
3176{
3177 return 0;
3178}
3179#endif
3180
5605c762
JP
3181u16 __skb_tx_hash(const struct net_device *dev, struct sk_buff *skb,
3182 unsigned int num_tx_queues);
3183
a3d22a68
VZ
3184/*
3185 * Returns a Tx hash for the given packet when dev->real_num_tx_queues is used
3186 * as a distribution range limit for the returned value.
3187 */
3188static inline u16 skb_tx_hash(const struct net_device *dev,
0e001614 3189 struct sk_buff *skb)
a3d22a68
VZ
3190{
3191 return __skb_tx_hash(dev, skb, dev->real_num_tx_queues);
3192}
3193
bea3348e
SH
3194/**
3195 * netif_is_multiqueue - test if device has multiple transmit queues
3196 * @dev: network device
3197 *
3198 * Check if device has multiple transmit queues
bea3348e 3199 */
4d29515f 3200static inline bool netif_is_multiqueue(const struct net_device *dev)
f25f4e44 3201{
a02cec21 3202 return dev->num_tx_queues > 1;
f25f4e44 3203}
1da177e4 3204
f629d208 3205int netif_set_real_num_tx_queues(struct net_device *dev, unsigned int txq);
f0796d5c 3206
a953be53 3207#ifdef CONFIG_SYSFS
f629d208 3208int netif_set_real_num_rx_queues(struct net_device *dev, unsigned int rxq);
62fe0b40
BH
3209#else
3210static inline int netif_set_real_num_rx_queues(struct net_device *dev,
3211 unsigned int rxq)
3212{
3213 return 0;
3214}
3215#endif
3216
a953be53
MD
3217#ifdef CONFIG_SYSFS
3218static inline unsigned int get_netdev_rx_queue_index(
3219 struct netdev_rx_queue *queue)
3220{
3221 struct net_device *dev = queue->dev;
3222 int index = queue - dev->_rx;
3223
3224 BUG_ON(index >= dev->num_rx_queues);
3225 return index;
3226}
3227#endif
3228
16917b87 3229#define DEFAULT_MAX_NUM_RSS_QUEUES (8)
f629d208 3230int netif_get_num_default_rss_queues(void);
16917b87 3231
e6247027
ED
3232enum skb_free_reason {
3233 SKB_REASON_CONSUMED,
3234 SKB_REASON_DROPPED,
3235};
3236
3237void __dev_kfree_skb_irq(struct sk_buff *skb, enum skb_free_reason reason);
3238void __dev_kfree_skb_any(struct sk_buff *skb, enum skb_free_reason reason);
1da177e4 3239
e6247027
ED
3240/*
3241 * It is not allowed to call kfree_skb() or consume_skb() from hardware
3242 * interrupt context or with hardware interrupts being disabled.
3243 * (in_irq() || irqs_disabled())
3244 *
3245 * We provide four helpers that can be used in following contexts :
3246 *
3247 * dev_kfree_skb_irq(skb) when caller drops a packet from irq context,
3248 * replacing kfree_skb(skb)
3249 *
3250 * dev_consume_skb_irq(skb) when caller consumes a packet from irq context.
3251 * Typically used in place of consume_skb(skb) in TX completion path
3252 *
3253 * dev_kfree_skb_any(skb) when caller doesn't know its current irq context,
3254 * replacing kfree_skb(skb)
3255 *
3256 * dev_consume_skb_any(skb) when caller doesn't know its current irq context,
3257 * and consumed a packet. Used in place of consume_skb(skb)
1da177e4 3258 */
e6247027
ED
3259static inline void dev_kfree_skb_irq(struct sk_buff *skb)
3260{
3261 __dev_kfree_skb_irq(skb, SKB_REASON_DROPPED);
3262}
3263
3264static inline void dev_consume_skb_irq(struct sk_buff *skb)
3265{
3266 __dev_kfree_skb_irq(skb, SKB_REASON_CONSUMED);
3267}
3268
3269static inline void dev_kfree_skb_any(struct sk_buff *skb)
3270{
3271 __dev_kfree_skb_any(skb, SKB_REASON_DROPPED);
3272}
3273
3274static inline void dev_consume_skb_any(struct sk_buff *skb)
3275{
3276 __dev_kfree_skb_any(skb, SKB_REASON_CONSUMED);
3277}
1da177e4 3278
7c497478
JW
3279void generic_xdp_tx(struct sk_buff *skb, struct bpf_prog *xdp_prog);
3280int do_xdp_generic(struct bpf_prog *xdp_prog, struct sk_buff *skb);
f629d208
JP
3281int netif_rx(struct sk_buff *skb);
3282int netif_rx_ni(struct sk_buff *skb);
04eb4489 3283int netif_receive_skb(struct sk_buff *skb);
1c601d82 3284int netif_receive_skb_core(struct sk_buff *skb);
f629d208
JP
3285gro_result_t napi_gro_receive(struct napi_struct *napi, struct sk_buff *skb);
3286void napi_gro_flush(struct napi_struct *napi, bool flush_old);
3287struct sk_buff *napi_get_frags(struct napi_struct *napi);
3288gro_result_t napi_gro_frags(struct napi_struct *napi);
bf5a755f
JC
3289struct packet_offload *gro_find_receive_by_type(__be16 type);
3290struct packet_offload *gro_find_complete_by_type(__be16 type);
76620aaf
HX
3291
3292static inline void napi_free_frags(struct napi_struct *napi)
3293{
3294 kfree_skb(napi->skb);
3295 napi->skb = NULL;
3296}
3297
24b27fc4 3298bool netdev_is_rx_handler_busy(struct net_device *dev);
f629d208
JP
3299int netdev_rx_handler_register(struct net_device *dev,
3300 rx_handler_func_t *rx_handler,
3301 void *rx_handler_data);
3302void netdev_rx_handler_unregister(struct net_device *dev);
3303
3304bool dev_valid_name(const char *name);
3305int dev_ioctl(struct net *net, unsigned int cmd, void __user *);
3306int dev_ethtool(struct net *net, struct ifreq *);
3307unsigned int dev_get_flags(const struct net_device *);
3308int __dev_change_flags(struct net_device *, unsigned int flags);
3309int dev_change_flags(struct net_device *, unsigned int);
cb178190
DM
3310void __dev_notify_flags(struct net_device *, unsigned int old_flags,
3311 unsigned int gchanges);
f629d208
JP
3312int dev_change_name(struct net_device *, const char *);
3313int dev_set_alias(struct net_device *, const char *, size_t);
6c557001 3314int dev_get_alias(const struct net_device *, char *, size_t);
f629d208 3315int dev_change_net_namespace(struct net_device *, struct net *, const char *);
f51048c3 3316int __dev_set_mtu(struct net_device *, int);
f629d208
JP
3317int dev_set_mtu(struct net_device *, int);
3318void dev_set_group(struct net_device *, int);
3319int dev_set_mac_address(struct net_device *, struct sockaddr *);
3320int dev_change_carrier(struct net_device *, bool new_carrier);
3321int dev_get_phys_port_id(struct net_device *dev,
02637fce 3322 struct netdev_phys_item_id *ppid);
db24a904
DA
3323int dev_get_phys_port_name(struct net_device *dev,
3324 char *name, size_t len);
d746d707 3325int dev_change_proto_down(struct net_device *dev, bool proto_down);
55a93b3e 3326struct sk_buff *validate_xmit_skb_list(struct sk_buff *skb, struct net_device *dev);
ce93718f
DM
3327struct sk_buff *dev_hard_start_xmit(struct sk_buff *skb, struct net_device *dev,
3328 struct netdev_queue *txq, int *ret);
d67b9cd2 3329
f4e63525 3330typedef int (*bpf_op_t)(struct net_device *dev, struct netdev_bpf *bpf);
d67b9cd2
DB
3331int dev_change_xdp_fd(struct net_device *dev, struct netlink_ext_ack *extack,
3332 int fd, u32 flags);
f4e63525 3333u8 __dev_xdp_attached(struct net_device *dev, bpf_op_t xdp_op, u32 *prog_id);
d67b9cd2 3334
a0265d28 3335int __dev_forward_skb(struct net_device *dev, struct sk_buff *skb);
f629d208 3336int dev_forward_skb(struct net_device *dev, struct sk_buff *skb);
f4b05d27
NA
3337bool is_skb_forwardable(const struct net_device *dev,
3338 const struct sk_buff *skb);
1da177e4 3339
4e3264d2
MKL
3340static __always_inline int ____dev_forward_skb(struct net_device *dev,
3341 struct sk_buff *skb)
3342{
3343 if (skb_orphan_frags(skb, GFP_ATOMIC) ||
3344 unlikely(!is_skb_forwardable(dev, skb))) {
3345 atomic_long_inc(&dev->rx_dropped);
3346 kfree_skb(skb);
3347 return NET_RX_DROP;
3348 }
3349
3350 skb_scrub_packet(skb, true);
3351 skb->priority = 0;
3352 return 0;
3353}
3354
74b20582
DA
3355void dev_queue_xmit_nit(struct sk_buff *skb, struct net_device *dev);
3356
20380731 3357extern int netdev_budget;
7acf8a1e 3358extern unsigned int netdev_budget_usecs;
1da177e4
LT
3359
3360/* Called by rtnetlink.c:rtnl_unlock() */
f629d208 3361void netdev_run_todo(void);
1da177e4 3362
bea3348e
SH
3363/**
3364 * dev_put - release reference to device
3365 * @dev: network device
3366 *
9ef4429b 3367 * Release reference to device to allow it to be freed.
bea3348e 3368 */
1da177e4
LT
3369static inline void dev_put(struct net_device *dev)
3370{
933393f5 3371 this_cpu_dec(*dev->pcpu_refcnt);
1da177e4
LT
3372}
3373
bea3348e
SH
3374/**
3375 * dev_hold - get reference to device
3376 * @dev: network device
3377 *
9ef4429b 3378 * Hold reference to device to keep it from being freed.
bea3348e 3379 */
15333061
SH
3380static inline void dev_hold(struct net_device *dev)
3381{
933393f5 3382 this_cpu_inc(*dev->pcpu_refcnt);
15333061 3383}
1da177e4
LT
3384
3385/* Carrier loss detection, dial on demand. The functions netif_carrier_on
3386 * and _off may be called from IRQ context, but it is caller
3387 * who is responsible for serialization of these calls.
b00055aa
SR
3388 *
3389 * The name carrier is inappropriate, these functions should really be
3390 * called netif_lowerlayer_*() because they represent the state of any
3391 * kind of lower layer not just hardware media.
1da177e4
LT
3392 */
3393
f629d208
JP
3394void linkwatch_init_dev(struct net_device *dev);
3395void linkwatch_fire_event(struct net_device *dev);
3396void linkwatch_forget_dev(struct net_device *dev);
1da177e4 3397
bea3348e
SH
3398/**
3399 * netif_carrier_ok - test if carrier present
3400 * @dev: network device
3401 *
3402 * Check if carrier is present on device
3403 */
4d29515f 3404static inline bool netif_carrier_ok(const struct net_device *dev)
1da177e4
LT
3405{
3406 return !test_bit(__LINK_STATE_NOCARRIER, &dev->state);
3407}
3408
f629d208 3409unsigned long dev_trans_start(struct net_device *dev);
9d21493b 3410
f629d208 3411void __netdev_watchdog_up(struct net_device *dev);
1da177e4 3412
f629d208 3413void netif_carrier_on(struct net_device *dev);
1da177e4 3414
f629d208 3415void netif_carrier_off(struct net_device *dev);
1da177e4 3416
bea3348e
SH
3417/**
3418 * netif_dormant_on - mark device as dormant.
3419 * @dev: network device
3420 *
3421 * Mark device as dormant (as per RFC2863).
3422 *
3423 * The dormant state indicates that the relevant interface is not
3424 * actually in a condition to pass packets (i.e., it is not 'up') but is
3425 * in a "pending" state, waiting for some external event. For "on-
3426 * demand" interfaces, this new state identifies the situation where the
3427 * interface is waiting for events to place it in the up state.
bea3348e 3428 */
b00055aa
SR
3429static inline void netif_dormant_on(struct net_device *dev)
3430{
3431 if (!test_and_set_bit(__LINK_STATE_DORMANT, &dev->state))
3432 linkwatch_fire_event(dev);
3433}
3434
bea3348e
SH
3435/**
3436 * netif_dormant_off - set device as not dormant.
3437 * @dev: network device
3438 *
3439 * Device is not in dormant state.
3440 */
b00055aa
SR
3441static inline void netif_dormant_off(struct net_device *dev)
3442{
3443 if (test_and_clear_bit(__LINK_STATE_DORMANT, &dev->state))
3444 linkwatch_fire_event(dev);
3445}
3446
bea3348e 3447/**
8ecbc40a 3448 * netif_dormant - test if device is dormant
bea3348e
SH
3449 * @dev: network device
3450 *
8ecbc40a 3451 * Check if device is dormant.
bea3348e 3452 */
4d29515f 3453static inline bool netif_dormant(const struct net_device *dev)
b00055aa
SR
3454{
3455 return test_bit(__LINK_STATE_DORMANT, &dev->state);
3456}
3457
3458
bea3348e
SH
3459/**
3460 * netif_oper_up - test if device is operational
3461 * @dev: network device
3462 *
3463 * Check if carrier is operational
3464 */
4d29515f 3465static inline bool netif_oper_up(const struct net_device *dev)
d94d9fee 3466{
b00055aa
SR
3467 return (dev->operstate == IF_OPER_UP ||
3468 dev->operstate == IF_OPER_UNKNOWN /* backward compat */);
3469}
3470
bea3348e
SH
3471/**
3472 * netif_device_present - is device available or removed
3473 * @dev: network device
3474 *
3475 * Check if device has not been removed from system.
3476 */
4d29515f 3477static inline bool netif_device_present(struct net_device *dev)
1da177e4
LT
3478{
3479 return test_bit(__LINK_STATE_PRESENT, &dev->state);
3480}
3481
f629d208 3482void netif_device_detach(struct net_device *dev);
1da177e4 3483
f629d208 3484void netif_device_attach(struct net_device *dev);
1da177e4
LT
3485
3486/*
3487 * Network interface message level settings
3488 */
1da177e4
LT
3489
3490enum {
3491 NETIF_MSG_DRV = 0x0001,
3492 NETIF_MSG_PROBE = 0x0002,
3493 NETIF_MSG_LINK = 0x0004,
3494 NETIF_MSG_TIMER = 0x0008,
3495 NETIF_MSG_IFDOWN = 0x0010,
3496 NETIF_MSG_IFUP = 0x0020,
3497 NETIF_MSG_RX_ERR = 0x0040,
3498 NETIF_MSG_TX_ERR = 0x0080,
3499 NETIF_MSG_TX_QUEUED = 0x0100,
3500 NETIF_MSG_INTR = 0x0200,
3501 NETIF_MSG_TX_DONE = 0x0400,
3502 NETIF_MSG_RX_STATUS = 0x0800,
3503 NETIF_MSG_PKTDATA = 0x1000,
3504 NETIF_MSG_HW = 0x2000,
3505 NETIF_MSG_WOL = 0x4000,
3506};
3507
3508#define netif_msg_drv(p) ((p)->msg_enable & NETIF_MSG_DRV)
3509#define netif_msg_probe(p) ((p)->msg_enable & NETIF_MSG_PROBE)
3510#define netif_msg_link(p) ((p)->msg_enable & NETIF_MSG_LINK)
3511#define netif_msg_timer(p) ((p)->msg_enable & NETIF_MSG_TIMER)
3512#define netif_msg_ifdown(p) ((p)->msg_enable & NETIF_MSG_IFDOWN)
3513#define netif_msg_ifup(p) ((p)->msg_enable & NETIF_MSG_IFUP)
3514#define netif_msg_rx_err(p) ((p)->msg_enable & NETIF_MSG_RX_ERR)
3515#define netif_msg_tx_err(p) ((p)->msg_enable & NETIF_MSG_TX_ERR)
3516#define netif_msg_tx_queued(p) ((p)->msg_enable & NETIF_MSG_TX_QUEUED)
3517#define netif_msg_intr(p) ((p)->msg_enable & NETIF_MSG_INTR)
3518#define netif_msg_tx_done(p) ((p)->msg_enable & NETIF_MSG_TX_DONE)
3519#define netif_msg_rx_status(p) ((p)->msg_enable & NETIF_MSG_RX_STATUS)
3520#define netif_msg_pktdata(p) ((p)->msg_enable & NETIF_MSG_PKTDATA)
3521#define netif_msg_hw(p) ((p)->msg_enable & NETIF_MSG_HW)
3522#define netif_msg_wol(p) ((p)->msg_enable & NETIF_MSG_WOL)
3523
3524static inline u32 netif_msg_init(int debug_value, int default_msg_enable_bits)
3525{
3526 /* use default */
3527 if (debug_value < 0 || debug_value >= (sizeof(u32) * 8))
3528 return default_msg_enable_bits;
3529 if (debug_value == 0) /* no output */
3530 return 0;
3531 /* set low N bits */
3532 return (1 << debug_value) - 1;
3533}
3534
c773e847 3535static inline void __netif_tx_lock(struct netdev_queue *txq, int cpu)
932ff279 3536{
c773e847
DM
3537 spin_lock(&txq->_xmit_lock);
3538 txq->xmit_lock_owner = cpu;
22dd7495
JHS
3539}
3540
5a717f4f
MT
3541static inline bool __netif_tx_acquire(struct netdev_queue *txq)
3542{
3543 __acquire(&txq->_xmit_lock);
3544 return true;
3545}
3546
3547static inline void __netif_tx_release(struct netdev_queue *txq)
3548{
3549 __release(&txq->_xmit_lock);
3550}
3551
fd2ea0a7
DM
3552static inline void __netif_tx_lock_bh(struct netdev_queue *txq)
3553{
3554 spin_lock_bh(&txq->_xmit_lock);
3555 txq->xmit_lock_owner = smp_processor_id();
3556}
3557
4d29515f 3558static inline bool __netif_tx_trylock(struct netdev_queue *txq)
c3f26a26 3559{
4d29515f 3560 bool ok = spin_trylock(&txq->_xmit_lock);
c3f26a26
DM
3561 if (likely(ok))
3562 txq->xmit_lock_owner = smp_processor_id();
3563 return ok;
3564}
3565
3566static inline void __netif_tx_unlock(struct netdev_queue *txq)
3567{
3568 txq->xmit_lock_owner = -1;
3569 spin_unlock(&txq->_xmit_lock);
3570}
3571
3572static inline void __netif_tx_unlock_bh(struct netdev_queue *txq)
3573{
3574 txq->xmit_lock_owner = -1;
3575 spin_unlock_bh(&txq->_xmit_lock);
3576}
3577
08baf561
ED
3578static inline void txq_trans_update(struct netdev_queue *txq)
3579{
3580 if (txq->xmit_lock_owner != -1)
3581 txq->trans_start = jiffies;
3582}
3583
ba162f8e
FW
3584/* legacy drivers only, netdev_start_xmit() sets txq->trans_start */
3585static inline void netif_trans_update(struct net_device *dev)
3586{
9b36627a
FW
3587 struct netdev_queue *txq = netdev_get_tx_queue(dev, 0);
3588
3589 if (txq->trans_start != jiffies)
3590 txq->trans_start = jiffies;
ba162f8e
FW
3591}
3592
d29f749e
DJ
3593/**
3594 * netif_tx_lock - grab network device transmit lock
3595 * @dev: network device
d29f749e
DJ
3596 *
3597 * Get network device transmit lock
3598 */
22dd7495
JHS
3599static inline void netif_tx_lock(struct net_device *dev)
3600{
e8a0464c 3601 unsigned int i;
c3f26a26 3602 int cpu;
c773e847 3603
c3f26a26
DM
3604 spin_lock(&dev->tx_global_lock);
3605 cpu = smp_processor_id();
e8a0464c
DM
3606 for (i = 0; i < dev->num_tx_queues; i++) {
3607 struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
c3f26a26
DM
3608
3609 /* We are the only thread of execution doing a
3610 * freeze, but we have to grab the _xmit_lock in
3611 * order to synchronize with threads which are in
3612 * the ->hard_start_xmit() handler and already
3613 * checked the frozen bit.
3614 */
e8a0464c 3615 __netif_tx_lock(txq, cpu);
c3f26a26
DM
3616 set_bit(__QUEUE_STATE_FROZEN, &txq->state);
3617 __netif_tx_unlock(txq);
e8a0464c 3618 }
932ff279
HX
3619}
3620
3621static inline void netif_tx_lock_bh(struct net_device *dev)
3622{
e8a0464c
DM
3623 local_bh_disable();
3624 netif_tx_lock(dev);
932ff279
HX
3625}
3626
932ff279
HX
3627static inline void netif_tx_unlock(struct net_device *dev)
3628{
e8a0464c
DM
3629 unsigned int i;
3630
3631 for (i = 0; i < dev->num_tx_queues; i++) {
3632 struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
c773e847 3633
c3f26a26
DM
3634 /* No need to grab the _xmit_lock here. If the
3635 * queue is not stopped for another reason, we
3636 * force a schedule.
3637 */
3638 clear_bit(__QUEUE_STATE_FROZEN, &txq->state);
7b3d3e4f 3639 netif_schedule_queue(txq);
c3f26a26
DM
3640 }
3641 spin_unlock(&dev->tx_global_lock);
932ff279
HX
3642}
3643
3644static inline void netif_tx_unlock_bh(struct net_device *dev)
3645{
e8a0464c
DM
3646 netif_tx_unlock(dev);
3647 local_bh_enable();
932ff279
HX
3648}
3649
c773e847 3650#define HARD_TX_LOCK(dev, txq, cpu) { \
22dd7495 3651 if ((dev->features & NETIF_F_LLTX) == 0) { \
c773e847 3652 __netif_tx_lock(txq, cpu); \
5a717f4f
MT
3653 } else { \
3654 __netif_tx_acquire(txq); \
22dd7495
JHS
3655 } \
3656}
3657
5efeac44
EB
3658#define HARD_TX_TRYLOCK(dev, txq) \
3659 (((dev->features & NETIF_F_LLTX) == 0) ? \
3660 __netif_tx_trylock(txq) : \
5a717f4f 3661 __netif_tx_acquire(txq))
5efeac44 3662
c773e847 3663#define HARD_TX_UNLOCK(dev, txq) { \
22dd7495 3664 if ((dev->features & NETIF_F_LLTX) == 0) { \
c773e847 3665 __netif_tx_unlock(txq); \
5a717f4f
MT
3666 } else { \
3667 __netif_tx_release(txq); \
22dd7495
JHS
3668 } \
3669}
3670
1da177e4
LT
3671static inline void netif_tx_disable(struct net_device *dev)
3672{
fd2ea0a7 3673 unsigned int i;
c3f26a26 3674 int cpu;
fd2ea0a7 3675
c3f26a26
DM
3676 local_bh_disable();
3677 cpu = smp_processor_id();
fd2ea0a7
DM
3678 for (i = 0; i < dev->num_tx_queues; i++) {
3679 struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
c3f26a26
DM
3680
3681 __netif_tx_lock(txq, cpu);
fd2ea0a7 3682 netif_tx_stop_queue(txq);
c3f26a26 3683 __netif_tx_unlock(txq);
fd2ea0a7 3684 }
c3f26a26 3685 local_bh_enable();
1da177e4
LT
3686}
3687
e308a5d8
DM
3688static inline void netif_addr_lock(struct net_device *dev)
3689{
3690 spin_lock(&dev->addr_list_lock);
3691}
3692
2429f7ac
JP
3693static inline void netif_addr_lock_nested(struct net_device *dev)
3694{
25175ba5
VY
3695 int subclass = SINGLE_DEPTH_NESTING;
3696
3697 if (dev->netdev_ops->ndo_get_lock_subclass)
3698 subclass = dev->netdev_ops->ndo_get_lock_subclass(dev);
3699
3700 spin_lock_nested(&dev->addr_list_lock, subclass);
2429f7ac
JP
3701}
3702
e308a5d8
DM
3703static inline void netif_addr_lock_bh(struct net_device *dev)
3704{
3705 spin_lock_bh(&dev->addr_list_lock);
3706}
3707
3708static inline void netif_addr_unlock(struct net_device *dev)
3709{
3710 spin_unlock(&dev->addr_list_lock);
3711}
3712
3713static inline void netif_addr_unlock_bh(struct net_device *dev)
3714{
3715 spin_unlock_bh(&dev->addr_list_lock);
3716}
3717
f001fde5 3718/*
31278e71 3719 * dev_addrs walker. Should be used only for read access. Call with
f001fde5
JP
3720 * rcu_read_lock held.
3721 */
3722#define for_each_dev_addr(dev, ha) \
31278e71 3723 list_for_each_entry_rcu(ha, &dev->dev_addrs.list, list)
f001fde5 3724
1da177e4
LT
3725/* These functions live elsewhere (drivers/net/net_init.c, but related) */
3726
f629d208 3727void ether_setup(struct net_device *dev);
1da177e4
LT
3728
3729/* Support for loadable net-drivers */
f629d208 3730struct net_device *alloc_netdev_mqs(int sizeof_priv, const char *name,
c835a677 3731 unsigned char name_assign_type,
f629d208
JP
3732 void (*setup)(struct net_device *),
3733 unsigned int txqs, unsigned int rxqs);
0ad646c8
CW
3734int dev_get_valid_name(struct net *net, struct net_device *dev,
3735 const char *name);
3736
c835a677
TG
3737#define alloc_netdev(sizeof_priv, name, name_assign_type, setup) \
3738 alloc_netdev_mqs(sizeof_priv, name, name_assign_type, setup, 1, 1)
36909ea4 3739
c835a677
TG
3740#define alloc_netdev_mq(sizeof_priv, name, name_assign_type, setup, count) \
3741 alloc_netdev_mqs(sizeof_priv, name, name_assign_type, setup, count, \
3742 count)
36909ea4 3743
f629d208
JP
3744int register_netdev(struct net_device *dev);
3745void unregister_netdev(struct net_device *dev);
f001fde5 3746
22bedad3 3747/* General hardware address lists handling functions */
f629d208
JP
3748int __hw_addr_sync(struct netdev_hw_addr_list *to_list,
3749 struct netdev_hw_addr_list *from_list, int addr_len);
3750void __hw_addr_unsync(struct netdev_hw_addr_list *to_list,
3751 struct netdev_hw_addr_list *from_list, int addr_len);
670e5b8e
AD
3752int __hw_addr_sync_dev(struct netdev_hw_addr_list *list,
3753 struct net_device *dev,
3754 int (*sync)(struct net_device *, const unsigned char *),
3755 int (*unsync)(struct net_device *,
3756 const unsigned char *));
3757void __hw_addr_unsync_dev(struct netdev_hw_addr_list *list,
3758 struct net_device *dev,
3759 int (*unsync)(struct net_device *,
3760 const unsigned char *));
f629d208 3761void __hw_addr_init(struct netdev_hw_addr_list *list);
22bedad3 3762
f001fde5 3763/* Functions used for device addresses handling */
f629d208
JP
3764int dev_addr_add(struct net_device *dev, const unsigned char *addr,
3765 unsigned char addr_type);
3766int dev_addr_del(struct net_device *dev, const unsigned char *addr,
3767 unsigned char addr_type);
f629d208
JP
3768void dev_addr_flush(struct net_device *dev);
3769int dev_addr_init(struct net_device *dev);
a748ee24
JP
3770
3771/* Functions used for unicast addresses handling */
f629d208
JP
3772int dev_uc_add(struct net_device *dev, const unsigned char *addr);
3773int dev_uc_add_excl(struct net_device *dev, const unsigned char *addr);
3774int dev_uc_del(struct net_device *dev, const unsigned char *addr);
3775int dev_uc_sync(struct net_device *to, struct net_device *from);
3776int dev_uc_sync_multiple(struct net_device *to, struct net_device *from);
3777void dev_uc_unsync(struct net_device *to, struct net_device *from);
3778void dev_uc_flush(struct net_device *dev);
3779void dev_uc_init(struct net_device *dev);
f001fde5 3780
670e5b8e
AD
3781/**
3782 * __dev_uc_sync - Synchonize device's unicast list
3783 * @dev: device to sync
3784 * @sync: function to call if address should be added
3785 * @unsync: function to call if address should be removed
3786 *
3787 * Add newly added addresses to the interface, and release
3788 * addresses that have been deleted.
5e82b4b2 3789 */
670e5b8e
AD
3790static inline int __dev_uc_sync(struct net_device *dev,
3791 int (*sync)(struct net_device *,
3792 const unsigned char *),
3793 int (*unsync)(struct net_device *,
3794 const unsigned char *))
3795{
3796 return __hw_addr_sync_dev(&dev->uc, dev, sync, unsync);
3797}
3798
3799/**
e793c0f7 3800 * __dev_uc_unsync - Remove synchronized addresses from device
670e5b8e
AD
3801 * @dev: device to sync
3802 * @unsync: function to call if address should be removed
3803 *
3804 * Remove all addresses that were added to the device by dev_uc_sync().
5e82b4b2 3805 */
670e5b8e
AD
3806static inline void __dev_uc_unsync(struct net_device *dev,
3807 int (*unsync)(struct net_device *,
3808 const unsigned char *))
3809{
3810 __hw_addr_unsync_dev(&dev->uc, dev, unsync);
3811}
3812
22bedad3 3813/* Functions used for multicast addresses handling */
f629d208
JP
3814int dev_mc_add(struct net_device *dev, const unsigned char *addr);
3815int dev_mc_add_global(struct net_device *dev, const unsigned char *addr);
3816int dev_mc_add_excl(struct net_device *dev, const unsigned char *addr);
3817int dev_mc_del(struct net_device *dev, const unsigned char *addr);
3818int dev_mc_del_global(struct net_device *dev, const unsigned char *addr);
3819int dev_mc_sync(struct net_device *to, struct net_device *from);
3820int dev_mc_sync_multiple(struct net_device *to, struct net_device *from);
3821void dev_mc_unsync(struct net_device *to, struct net_device *from);
3822void dev_mc_flush(struct net_device *dev);
3823void dev_mc_init(struct net_device *dev);
f001fde5 3824
670e5b8e
AD
3825/**
3826 * __dev_mc_sync - Synchonize device's multicast list
3827 * @dev: device to sync
3828 * @sync: function to call if address should be added
3829 * @unsync: function to call if address should be removed
3830 *
3831 * Add newly added addresses to the interface, and release
3832 * addresses that have been deleted.
5e82b4b2 3833 */
670e5b8e
AD
3834static inline int __dev_mc_sync(struct net_device *dev,
3835 int (*sync)(struct net_device *,
3836 const unsigned char *),
3837 int (*unsync)(struct net_device *,
3838 const unsigned char *))
3839{
3840 return __hw_addr_sync_dev(&dev->mc, dev, sync, unsync);
3841}
3842
3843/**
e793c0f7 3844 * __dev_mc_unsync - Remove synchronized addresses from device
670e5b8e
AD
3845 * @dev: device to sync
3846 * @unsync: function to call if address should be removed
3847 *
3848 * Remove all addresses that were added to the device by dev_mc_sync().
5e82b4b2 3849 */
670e5b8e
AD
3850static inline void __dev_mc_unsync(struct net_device *dev,
3851 int (*unsync)(struct net_device *,
3852 const unsigned char *))
3853{
3854 __hw_addr_unsync_dev(&dev->mc, dev, unsync);
3855}
3856
4417da66 3857/* Functions used for secondary unicast and multicast support */
f629d208
JP
3858void dev_set_rx_mode(struct net_device *dev);
3859void __dev_set_rx_mode(struct net_device *dev);
3860int dev_set_promiscuity(struct net_device *dev, int inc);
3861int dev_set_allmulti(struct net_device *dev, int inc);
3862void netdev_state_change(struct net_device *dev);
3863void netdev_notify_peers(struct net_device *dev);
3864void netdev_features_change(struct net_device *dev);
1da177e4 3865/* Load a device via the kmod */
f629d208
JP
3866void dev_load(struct net *net, const char *name);
3867struct rtnl_link_stats64 *dev_get_stats(struct net_device *dev,
3868 struct rtnl_link_stats64 *storage);
3869void netdev_stats_to_stats64(struct rtnl_link_stats64 *stats64,
3870 const struct net_device_stats *netdev_stats);
eeda3fd6 3871
1da177e4 3872extern int netdev_max_backlog;
3b098e2d 3873extern int netdev_tstamp_prequeue;
1da177e4 3874extern int weight_p;
3d48b53f
MT
3875extern int dev_weight_rx_bias;
3876extern int dev_weight_tx_bias;
3877extern int dev_rx_weight;
3878extern int dev_tx_weight;
9ff162a8 3879
f629d208 3880bool netdev_has_upper_dev(struct net_device *dev, struct net_device *upper_dev);
44a40855
VY
3881struct net_device *netdev_upper_get_next_dev_rcu(struct net_device *dev,
3882 struct list_head **iter);
f629d208
JP
3883struct net_device *netdev_all_upper_get_next_dev_rcu(struct net_device *dev,
3884 struct list_head **iter);
8b5be856 3885
44a40855
VY
3886/* iterate through upper list, must be called under RCU read lock */
3887#define netdev_for_each_upper_dev_rcu(dev, updev, iter) \
3888 for (iter = &(dev)->adj_list.upper, \
3889 updev = netdev_upper_get_next_dev_rcu(dev, &(iter)); \
3890 updev; \
3891 updev = netdev_upper_get_next_dev_rcu(dev, &(iter)))
3892
1a3f060c
DA
3893int netdev_walk_all_upper_dev_rcu(struct net_device *dev,
3894 int (*fn)(struct net_device *upper_dev,
3895 void *data),
3896 void *data);
3897
3898bool netdev_has_upper_dev_all_rcu(struct net_device *dev,
3899 struct net_device *upper_dev);
3900
25cc72a3
IS
3901bool netdev_has_any_upper_dev(struct net_device *dev);
3902
f629d208
JP
3903void *netdev_lower_get_next_private(struct net_device *dev,
3904 struct list_head **iter);
3905void *netdev_lower_get_next_private_rcu(struct net_device *dev,
3906 struct list_head **iter);
31088a11
VF
3907
3908#define netdev_for_each_lower_private(dev, priv, iter) \
3909 for (iter = (dev)->adj_list.lower.next, \
3910 priv = netdev_lower_get_next_private(dev, &(iter)); \
3911 priv; \
3912 priv = netdev_lower_get_next_private(dev, &(iter)))
3913
3914#define netdev_for_each_lower_private_rcu(dev, priv, iter) \
3915 for (iter = &(dev)->adj_list.lower, \
3916 priv = netdev_lower_get_next_private_rcu(dev, &(iter)); \
3917 priv; \
3918 priv = netdev_lower_get_next_private_rcu(dev, &(iter)))
3919
4085ebe8
VY
3920void *netdev_lower_get_next(struct net_device *dev,
3921 struct list_head **iter);
7ce856aa 3922
4085ebe8 3923#define netdev_for_each_lower_dev(dev, ldev, iter) \
cfdd28be 3924 for (iter = (dev)->adj_list.lower.next, \
4085ebe8
VY
3925 ldev = netdev_lower_get_next(dev, &(iter)); \
3926 ldev; \
3927 ldev = netdev_lower_get_next(dev, &(iter)))
3928
7ce856aa
JP
3929struct net_device *netdev_all_lower_get_next(struct net_device *dev,
3930 struct list_head **iter);
3931struct net_device *netdev_all_lower_get_next_rcu(struct net_device *dev,
3932 struct list_head **iter);
3933
1a3f060c
DA
3934int netdev_walk_all_lower_dev(struct net_device *dev,
3935 int (*fn)(struct net_device *lower_dev,
3936 void *data),
3937 void *data);
3938int netdev_walk_all_lower_dev_rcu(struct net_device *dev,
3939 int (*fn)(struct net_device *lower_dev,
3940 void *data),
3941 void *data);
3942
f629d208 3943void *netdev_adjacent_get_private(struct list_head *adj_list);
e001bfad 3944void *netdev_lower_get_first_private_rcu(struct net_device *dev);
f629d208
JP
3945struct net_device *netdev_master_upper_dev_get(struct net_device *dev);
3946struct net_device *netdev_master_upper_dev_get_rcu(struct net_device *dev);
42ab19ee
DA
3947int netdev_upper_dev_link(struct net_device *dev, struct net_device *upper_dev,
3948 struct netlink_ext_ack *extack);
f629d208 3949int netdev_master_upper_dev_link(struct net_device *dev,
6dffb044 3950 struct net_device *upper_dev,
42ab19ee
DA
3951 void *upper_priv, void *upper_info,
3952 struct netlink_ext_ack *extack);
f629d208
JP
3953void netdev_upper_dev_unlink(struct net_device *dev,
3954 struct net_device *upper_dev);
5bb025fa 3955void netdev_adjacent_rename_links(struct net_device *dev, char *oldname);
f629d208
JP
3956void *netdev_lower_dev_get_private(struct net_device *dev,
3957 struct net_device *lower_dev);
04d48266
JP
3958void netdev_lower_state_changed(struct net_device *lower_dev,
3959 void *lower_state_info);
960fb622
ED
3960
3961/* RSS keys are 40 or 52 bytes long */
3962#define NETDEV_RSS_KEY_LEN 52
ba905f5e 3963extern u8 netdev_rss_key[NETDEV_RSS_KEY_LEN] __read_mostly;
960fb622
ED
3964void netdev_rss_key_fill(void *buffer, size_t len);
3965
952fcfd0 3966int dev_get_nest_level(struct net_device *dev);
f629d208 3967int skb_checksum_help(struct sk_buff *skb);
b72b5bf6 3968int skb_crc32c_csum_help(struct sk_buff *skb);
43c26a1a
DC
3969int skb_csum_hwoffload_help(struct sk_buff *skb,
3970 const netdev_features_t features);
3971
f629d208
JP
3972struct sk_buff *__skb_gso_segment(struct sk_buff *skb,
3973 netdev_features_t features, bool tx_path);
3974struct sk_buff *skb_mac_gso_segment(struct sk_buff *skb,
3975 netdev_features_t features);
12b0004d 3976
61bd3857
MS
3977struct netdev_bonding_info {
3978 ifslave slave;
3979 ifbond master;
3980};
3981
3982struct netdev_notifier_bonding_info {
3983 struct netdev_notifier_info info; /* must be first */
3984 struct netdev_bonding_info bonding_info;
3985};
3986
3987void netdev_bonding_info_change(struct net_device *dev,
3988 struct netdev_bonding_info *bonding_info);
3989
12b0004d
CW
3990static inline
3991struct sk_buff *skb_gso_segment(struct sk_buff *skb, netdev_features_t features)
3992{
3993 return __skb_gso_segment(skb, features, true);
3994}
53d6471c 3995__be16 skb_network_protocol(struct sk_buff *skb, int *depth);
ec5f0615
PS
3996
3997static inline bool can_checksum_protocol(netdev_features_t features,
3998 __be16 protocol)
3999{
c8cd0989
TH
4000 if (protocol == htons(ETH_P_FCOE))
4001 return !!(features & NETIF_F_FCOE_CRC);
4002
4003 /* Assume this is an IP checksum (not SCTP CRC) */
4004
4005 if (features & NETIF_F_HW_CSUM) {
4006 /* Can checksum everything */
4007 return true;
4008 }
4009
4010 switch (protocol) {
4011 case htons(ETH_P_IP):
4012 return !!(features & NETIF_F_IP_CSUM);
4013 case htons(ETH_P_IPV6):
4014 return !!(features & NETIF_F_IPV6_CSUM);
4015 default:
4016 return false;
4017 }
ec5f0615 4018}
12b0004d 4019
fb286bb2 4020#ifdef CONFIG_BUG
f629d208 4021void netdev_rx_csum_fault(struct net_device *dev);
fb286bb2
HX
4022#else
4023static inline void netdev_rx_csum_fault(struct net_device *dev)
4024{
4025}
4026#endif
1da177e4 4027/* rx skb timestamps */
f629d208
JP
4028void net_enable_timestamp(void);
4029void net_disable_timestamp(void);
1da177e4 4030
20380731 4031#ifdef CONFIG_PROC_FS
f629d208 4032int __init dev_proc_init(void);
900ff8c6
CW
4033#else
4034#define dev_proc_init() 0
20380731
ACM
4035#endif
4036
4798248e 4037static inline netdev_tx_t __netdev_start_xmit(const struct net_device_ops *ops,
fa2dbdc2
DM
4038 struct sk_buff *skb, struct net_device *dev,
4039 bool more)
4798248e 4040{
fa2dbdc2 4041 skb->xmit_more = more ? 1 : 0;
0b725a2c 4042 return ops->ndo_start_xmit(skb, dev);
4798248e
DM
4043}
4044
10b3ad8c 4045static inline netdev_tx_t netdev_start_xmit(struct sk_buff *skb, struct net_device *dev,
fa2dbdc2 4046 struct netdev_queue *txq, bool more)
4798248e
DM
4047{
4048 const struct net_device_ops *ops = dev->netdev_ops;
10b3ad8c 4049 int rc;
4798248e 4050
fa2dbdc2 4051 rc = __netdev_start_xmit(ops, skb, dev, more);
10b3ad8c
DM
4052 if (rc == NETDEV_TX_OK)
4053 txq_trans_update(txq);
4054
4055 return rc;
4798248e
DM
4056}
4057
b793dc5c 4058int netdev_class_create_file_ns(const struct class_attribute *class_attr,
42a2d923 4059 const void *ns);
b793dc5c 4060void netdev_class_remove_file_ns(const struct class_attribute *class_attr,
42a2d923 4061 const void *ns);
58292cbe 4062
b793dc5c 4063static inline int netdev_class_create_file(const struct class_attribute *class_attr)
58292cbe
TH
4064{
4065 return netdev_class_create_file_ns(class_attr, NULL);
4066}
4067
b793dc5c 4068static inline void netdev_class_remove_file(const struct class_attribute *class_attr)
58292cbe
TH
4069{
4070 netdev_class_remove_file_ns(class_attr, NULL);
4071}
b8a9787e 4072
737aec57 4073extern const struct kobj_ns_type_operations net_ns_type_operations;
04600794 4074
f629d208 4075const char *netdev_drivername(const struct net_device *dev);
6579e57b 4076
f629d208 4077void linkwatch_run_queue(void);
20380731 4078
da08143b
MK
4079static inline netdev_features_t netdev_intersect_features(netdev_features_t f1,
4080 netdev_features_t f2)
4081{
c8cd0989
TH
4082 if ((f1 ^ f2) & NETIF_F_HW_CSUM) {
4083 if (f1 & NETIF_F_HW_CSUM)
b6a0e72a 4084 f1 |= (NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM);
c8cd0989 4085 else
b6a0e72a 4086 f2 |= (NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM);
c8cd0989 4087 }
da08143b 4088
c8cd0989 4089 return f1 & f2;
da08143b
MK
4090}
4091
c8f44aff
MM
4092static inline netdev_features_t netdev_get_wanted_features(
4093 struct net_device *dev)
5455c699
MM
4094{
4095 return (dev->features & ~dev->hw_features) | dev->wanted_features;
4096}
c8f44aff
MM
4097netdev_features_t netdev_increment_features(netdev_features_t all,
4098 netdev_features_t one, netdev_features_t mask);
b0ce3508
ED
4099
4100/* Allow TSO being used on stacked device :
4101 * Performing the GSO segmentation before last device
4102 * is a performance improvement.
4103 */
4104static inline netdev_features_t netdev_add_tso_features(netdev_features_t features,
4105 netdev_features_t mask)
4106{
4107 return netdev_increment_features(features, NETIF_F_ALL_TSO, mask);
4108}
4109
6cb6a27c 4110int __netdev_update_features(struct net_device *dev);
5455c699 4111void netdev_update_features(struct net_device *dev);
afe12cc8 4112void netdev_change_features(struct net_device *dev);
7f353bf2 4113
fc4a7489
PM
4114void netif_stacked_transfer_operstate(const struct net_device *rootdev,
4115 struct net_device *dev);
4116
e38f3025
TM
4117netdev_features_t passthru_features_check(struct sk_buff *skb,
4118 struct net_device *dev,
4119 netdev_features_t features);
c1e756bf 4120netdev_features_t netif_skb_features(struct sk_buff *skb);
58e998c6 4121
4d29515f 4122static inline bool net_gso_ok(netdev_features_t features, int gso_type)
576a30eb 4123{
7b748340 4124 netdev_features_t feature = (netdev_features_t)gso_type << NETIF_F_GSO_SHIFT;
0345e186
MM
4125
4126 /* check flags correspondence */
4127 BUILD_BUG_ON(SKB_GSO_TCPV4 != (NETIF_F_TSO >> NETIF_F_GSO_SHIFT));
0345e186
MM
4128 BUILD_BUG_ON(SKB_GSO_DODGY != (NETIF_F_GSO_ROBUST >> NETIF_F_GSO_SHIFT));
4129 BUILD_BUG_ON(SKB_GSO_TCP_ECN != (NETIF_F_TSO_ECN >> NETIF_F_GSO_SHIFT));
cbc53e08 4130 BUILD_BUG_ON(SKB_GSO_TCP_FIXEDID != (NETIF_F_TSO_MANGLEID >> NETIF_F_GSO_SHIFT));
0345e186
MM
4131 BUILD_BUG_ON(SKB_GSO_TCPV6 != (NETIF_F_TSO6 >> NETIF_F_GSO_SHIFT));
4132 BUILD_BUG_ON(SKB_GSO_FCOE != (NETIF_F_FSO >> NETIF_F_GSO_SHIFT));
4b28252c
TH
4133 BUILD_BUG_ON(SKB_GSO_GRE != (NETIF_F_GSO_GRE >> NETIF_F_GSO_SHIFT));
4134 BUILD_BUG_ON(SKB_GSO_GRE_CSUM != (NETIF_F_GSO_GRE_CSUM >> NETIF_F_GSO_SHIFT));
7e13318d
TH
4135 BUILD_BUG_ON(SKB_GSO_IPXIP4 != (NETIF_F_GSO_IPXIP4 >> NETIF_F_GSO_SHIFT));
4136 BUILD_BUG_ON(SKB_GSO_IPXIP6 != (NETIF_F_GSO_IPXIP6 >> NETIF_F_GSO_SHIFT));
4b28252c
TH
4137 BUILD_BUG_ON(SKB_GSO_UDP_TUNNEL != (NETIF_F_GSO_UDP_TUNNEL >> NETIF_F_GSO_SHIFT));
4138 BUILD_BUG_ON(SKB_GSO_UDP_TUNNEL_CSUM != (NETIF_F_GSO_UDP_TUNNEL_CSUM >> NETIF_F_GSO_SHIFT));
802ab55a 4139 BUILD_BUG_ON(SKB_GSO_PARTIAL != (NETIF_F_GSO_PARTIAL >> NETIF_F_GSO_SHIFT));
e585f236 4140 BUILD_BUG_ON(SKB_GSO_TUNNEL_REMCSUM != (NETIF_F_GSO_TUNNEL_REMCSUM >> NETIF_F_GSO_SHIFT));
90017acc 4141 BUILD_BUG_ON(SKB_GSO_SCTP != (NETIF_F_GSO_SCTP >> NETIF_F_GSO_SHIFT));
c7ef8f0c 4142 BUILD_BUG_ON(SKB_GSO_ESP != (NETIF_F_GSO_ESP >> NETIF_F_GSO_SHIFT));
0345e186 4143
d6b4991a 4144 return (features & feature) == feature;
576a30eb
HX
4145}
4146
4d29515f 4147static inline bool skb_gso_ok(struct sk_buff *skb, netdev_features_t features)
bcd76111 4148{
278b2513 4149 return net_gso_ok(features, skb_shinfo(skb)->gso_type) &&
21dc3301 4150 (!skb_has_frag_list(skb) || (features & NETIF_F_FRAGLIST));
bcd76111
HX
4151}
4152
8b86a61d 4153static inline bool netif_needs_gso(struct sk_buff *skb,
4d29515f 4154 netdev_features_t features)
7967168c 4155{
fc741216 4156 return skb_is_gso(skb) && (!skb_gso_ok(skb, features) ||
cdbee74c
YZ
4157 unlikely((skb->ip_summed != CHECKSUM_PARTIAL) &&
4158 (skb->ip_summed != CHECKSUM_UNNECESSARY)));
7967168c
HX
4159}
4160
82cc1a7a
PWJ
4161static inline void netif_set_gso_max_size(struct net_device *dev,
4162 unsigned int size)
4163{
4164 dev->gso_max_size = size;
4165}
4166
7a7ffbab
WCC
4167static inline void skb_gso_error_unwind(struct sk_buff *skb, __be16 protocol,
4168 int pulled_hlen, u16 mac_offset,
4169 int mac_len)
4170{
4171 skb->protocol = protocol;
4172 skb->encapsulation = 1;
4173 skb_push(skb, pulled_hlen);
4174 skb_reset_transport_header(skb);
4175 skb->mac_header = mac_offset;
4176 skb->network_header = skb->mac_header + mac_len;
4177 skb->mac_len = mac_len;
4178}
4179
3c175784
SD
4180static inline bool netif_is_macsec(const struct net_device *dev)
4181{
4182 return dev->priv_flags & IFF_MACSEC;
4183}
4184
b618aaa9 4185static inline bool netif_is_macvlan(const struct net_device *dev)
a6cc0cfa
JF
4186{
4187 return dev->priv_flags & IFF_MACVLAN;
4188}
4189
b618aaa9 4190static inline bool netif_is_macvlan_port(const struct net_device *dev)
2f33e7d5
MB
4191{
4192 return dev->priv_flags & IFF_MACVLAN_PORT;
4193}
4194
b618aaa9 4195static inline bool netif_is_ipvlan(const struct net_device *dev)
5933fea7
MB
4196{
4197 return dev->priv_flags & IFF_IPVLAN_SLAVE;
4198}
4199
b618aaa9 4200static inline bool netif_is_ipvlan_port(const struct net_device *dev)
5933fea7
MB
4201{
4202 return dev->priv_flags & IFF_IPVLAN_MASTER;
4203}
4204
b618aaa9 4205static inline bool netif_is_bond_master(const struct net_device *dev)
8a7fbfab 4206{
4207 return dev->flags & IFF_MASTER && dev->priv_flags & IFF_BONDING;
4208}
4209
b618aaa9 4210static inline bool netif_is_bond_slave(const struct net_device *dev)
1765a575
JP
4211{
4212 return dev->flags & IFF_SLAVE && dev->priv_flags & IFF_BONDING;
4213}
4214
3bdc0eba
BG
4215static inline bool netif_supports_nofcs(struct net_device *dev)
4216{
4217 return dev->priv_flags & IFF_SUPP_NOFCS;
4218}
4219
007979ea 4220static inline bool netif_is_l3_master(const struct net_device *dev)
4e3c8992 4221{
007979ea 4222 return dev->priv_flags & IFF_L3MDEV_MASTER;
4e3c8992
DA
4223}
4224
fee6d4c7
DA
4225static inline bool netif_is_l3_slave(const struct net_device *dev)
4226{
4227 return dev->priv_flags & IFF_L3MDEV_SLAVE;
4228}
4229
0894ae3f
JP
4230static inline bool netif_is_bridge_master(const struct net_device *dev)
4231{
4232 return dev->priv_flags & IFF_EBRIDGE;
4233}
4234
28f9ee22
VY
4235static inline bool netif_is_bridge_port(const struct net_device *dev)
4236{
4237 return dev->priv_flags & IFF_BRIDGE_PORT;
4238}
4239
35d4e172
JP
4240static inline bool netif_is_ovs_master(const struct net_device *dev)
4241{
4242 return dev->priv_flags & IFF_OPENVSWITCH;
4243}
4244
5be66141
JP
4245static inline bool netif_is_ovs_port(const struct net_device *dev)
4246{
4247 return dev->priv_flags & IFF_OVS_DATAPATH;
4248}
4249
b618aaa9 4250static inline bool netif_is_team_master(const struct net_device *dev)
c981e421
JP
4251{
4252 return dev->priv_flags & IFF_TEAM;
4253}
4254
b618aaa9 4255static inline bool netif_is_team_port(const struct net_device *dev)
f7f019ee
JP
4256{
4257 return dev->priv_flags & IFF_TEAM_PORT;
4258}
4259
b618aaa9 4260static inline bool netif_is_lag_master(const struct net_device *dev)
7be61833
JP
4261{
4262 return netif_is_bond_master(dev) || netif_is_team_master(dev);
4263}
4264
b618aaa9 4265static inline bool netif_is_lag_port(const struct net_device *dev)
e0ba1414
JP
4266{
4267 return netif_is_bond_slave(dev) || netif_is_team_port(dev);
4268}
4269
d4ab4286
KJ
4270static inline bool netif_is_rxfh_configured(const struct net_device *dev)
4271{
4272 return dev->priv_flags & IFF_RXFH_CONFIGURED;
4273}
4274
02875878
ED
4275/* This device needs to keep skb dst for qdisc enqueue or ndo_start_xmit() */
4276static inline void netif_keep_dst(struct net_device *dev)
4277{
4278 dev->priv_flags &= ~(IFF_XMIT_DST_RELEASE | IFF_XMIT_DST_RELEASE_PERM);
4279}
4280
18d3df3e
PA
4281/* return true if dev can't cope with mtu frames that need vlan tag insertion */
4282static inline bool netif_reduces_vlan_mtu(struct net_device *dev)
4283{
4284 /* TODO: reserve and use an additional IFF bit, if we get more users */
4285 return dev->priv_flags & IFF_MACSEC;
4286}
4287
505d4f73 4288extern struct pernet_operations __net_initdata loopback_net_ops;
b1b67dd4 4289
571ba423
JP
4290/* Logging, debugging and troubleshooting/diagnostic helpers. */
4291
4292/* netdev_printk helpers, similar to dev_printk */
4293
4294static inline const char *netdev_name(const struct net_device *dev)
4295{
c6f854d5
VF
4296 if (!dev->name[0] || strchr(dev->name, '%'))
4297 return "(unnamed net_device)";
571ba423
JP
4298 return dev->name;
4299}
4300
8397ed36
DA
4301static inline bool netdev_unregistering(const struct net_device *dev)
4302{
4303 return dev->reg_state == NETREG_UNREGISTERING;
4304}
4305
ccc7f496
VF
4306static inline const char *netdev_reg_state(const struct net_device *dev)
4307{
4308 switch (dev->reg_state) {
4309 case NETREG_UNINITIALIZED: return " (uninitialized)";
4310 case NETREG_REGISTERED: return "";
4311 case NETREG_UNREGISTERING: return " (unregistering)";
4312 case NETREG_UNREGISTERED: return " (unregistered)";
4313 case NETREG_RELEASED: return " (released)";
4314 case NETREG_DUMMY: return " (dummy)";
4315 }
4316
4317 WARN_ONCE(1, "%s: unknown reg_state %d\n", dev->name, dev->reg_state);
4318 return " (unknown)";
4319}
4320
f629d208 4321__printf(3, 4)
6ea754eb
JP
4322void netdev_printk(const char *level, const struct net_device *dev,
4323 const char *format, ...);
f629d208 4324__printf(2, 3)
6ea754eb 4325void netdev_emerg(const struct net_device *dev, const char *format, ...);
f629d208 4326__printf(2, 3)
6ea754eb 4327void netdev_alert(const struct net_device *dev, const char *format, ...);
f629d208 4328__printf(2, 3)
6ea754eb 4329void netdev_crit(const struct net_device *dev, const char *format, ...);
f629d208 4330__printf(2, 3)
6ea754eb 4331void netdev_err(const struct net_device *dev, const char *format, ...);
f629d208 4332__printf(2, 3)
6ea754eb 4333void netdev_warn(const struct net_device *dev, const char *format, ...);
f629d208 4334__printf(2, 3)
6ea754eb 4335void netdev_notice(const struct net_device *dev, const char *format, ...);
f629d208 4336__printf(2, 3)
6ea754eb 4337void netdev_info(const struct net_device *dev, const char *format, ...);
571ba423 4338
8909c9ad
VK
4339#define MODULE_ALIAS_NETDEV(device) \
4340 MODULE_ALIAS("netdev-" device)
4341
b558c96f 4342#if defined(CONFIG_DYNAMIC_DEBUG)
571ba423
JP
4343#define netdev_dbg(__dev, format, args...) \
4344do { \
ffa10cb4 4345 dynamic_netdev_dbg(__dev, format, ##args); \
571ba423 4346} while (0)
b558c96f
JC
4347#elif defined(DEBUG)
4348#define netdev_dbg(__dev, format, args...) \
4349 netdev_printk(KERN_DEBUG, __dev, format, ##args)
571ba423
JP
4350#else
4351#define netdev_dbg(__dev, format, args...) \
4352({ \
4353 if (0) \
4354 netdev_printk(KERN_DEBUG, __dev, format, ##args); \
571ba423
JP
4355})
4356#endif
4357
4358#if defined(VERBOSE_DEBUG)
4359#define netdev_vdbg netdev_dbg
4360#else
4361
4362#define netdev_vdbg(dev, format, args...) \
4363({ \
4364 if (0) \
4365 netdev_printk(KERN_DEBUG, dev, format, ##args); \
4366 0; \
4367})
4368#endif
4369
4370/*
4371 * netdev_WARN() acts like dev_printk(), but with the key difference
4372 * of using a WARN/WARN_ON to get the message out, including the
4373 * file/line information and a backtrace.
4374 */
4375#define netdev_WARN(dev, format, args...) \
ccc7f496
VF
4376 WARN(1, "netdevice: %s%s\n" format, netdev_name(dev), \
4377 netdev_reg_state(dev), ##args)
571ba423 4378
b3d95c5c
JP
4379/* netif printk helpers, similar to netdev_printk */
4380
4381#define netif_printk(priv, type, level, dev, fmt, args...) \
4382do { \
4383 if (netif_msg_##type(priv)) \
4384 netdev_printk(level, (dev), fmt, ##args); \
4385} while (0)
4386
f45f4321
JP
4387#define netif_level(level, priv, type, dev, fmt, args...) \
4388do { \
4389 if (netif_msg_##type(priv)) \
4390 netdev_##level(dev, fmt, ##args); \
4391} while (0)
4392
b3d95c5c 4393#define netif_emerg(priv, type, dev, fmt, args...) \
f45f4321 4394 netif_level(emerg, priv, type, dev, fmt, ##args)
b3d95c5c 4395#define netif_alert(priv, type, dev, fmt, args...) \
f45f4321 4396 netif_level(alert, priv, type, dev, fmt, ##args)
b3d95c5c 4397#define netif_crit(priv, type, dev, fmt, args...) \
f45f4321 4398 netif_level(crit, priv, type, dev, fmt, ##args)
b3d95c5c 4399#define netif_err(priv, type, dev, fmt, args...) \
f45f4321 4400 netif_level(err, priv, type, dev, fmt, ##args)
b3d95c5c 4401#define netif_warn(priv, type, dev, fmt, args...) \
f45f4321 4402 netif_level(warn, priv, type, dev, fmt, ##args)
b3d95c5c 4403#define netif_notice(priv, type, dev, fmt, args...) \
f45f4321 4404 netif_level(notice, priv, type, dev, fmt, ##args)
b3d95c5c 4405#define netif_info(priv, type, dev, fmt, args...) \
f45f4321 4406 netif_level(info, priv, type, dev, fmt, ##args)
b3d95c5c 4407
0053ea9c 4408#if defined(CONFIG_DYNAMIC_DEBUG)
b3d95c5c
JP
4409#define netif_dbg(priv, type, netdev, format, args...) \
4410do { \
4411 if (netif_msg_##type(priv)) \
b5fb0a03 4412 dynamic_netdev_dbg(netdev, format, ##args); \
b3d95c5c 4413} while (0)
0053ea9c
JP
4414#elif defined(DEBUG)
4415#define netif_dbg(priv, type, dev, format, args...) \
4416 netif_printk(priv, type, KERN_DEBUG, dev, format, ##args)
b3d95c5c
JP
4417#else
4418#define netif_dbg(priv, type, dev, format, args...) \
4419({ \
4420 if (0) \
4421 netif_printk(priv, type, KERN_DEBUG, dev, format, ##args); \
4422 0; \
4423})
4424#endif
4425
f617f276
EC
4426/* if @cond then downgrade to debug, else print at @level */
4427#define netif_cond_dbg(priv, type, netdev, cond, level, fmt, args...) \
4428 do { \
4429 if (cond) \
4430 netif_dbg(priv, type, netdev, fmt, ##args); \
4431 else \
4432 netif_ ## level(priv, type, netdev, fmt, ##args); \
4433 } while (0)
4434
b3d95c5c 4435#if defined(VERBOSE_DEBUG)
bcfcc450 4436#define netif_vdbg netif_dbg
b3d95c5c
JP
4437#else
4438#define netif_vdbg(priv, type, dev, format, args...) \
4439({ \
4440 if (0) \
a4ed89cb 4441 netif_printk(priv, type, KERN_DEBUG, dev, format, ##args); \
b3d95c5c
JP
4442 0; \
4443})
4444#endif
571ba423 4445
900ff8c6
CW
4446/*
4447 * The list of packet types we will receive (as opposed to discard)
4448 * and the routines to invoke.
4449 *
4450 * Why 16. Because with 16 the only overlap we get on a hash of the
4451 * low nibble of the protocol value is RARP/SNAP/X.25.
4452 *
4453 * NOTE: That is no longer true with the addition of VLAN tags. Not
4454 * sure which should go first, but I bet it won't make much
4455 * difference if we are running VLANs. The good news is that
4456 * this protocol won't be in the list unless compiled in, so
4457 * the average user (w/out VLANs) will not be adversely affected.
4458 * --BLG
4459 *
4460 * 0800 IP
4461 * 8100 802.1Q VLAN
4462 * 0001 802.3
4463 * 0002 AX.25
4464 * 0004 802.2
4465 * 8035 RARP
4466 * 0005 SNAP
4467 * 0805 X.25
4468 * 0806 ARP
4469 * 8137 IPX
4470 * 0009 Localtalk
4471 * 86DD IPv6
4472 */
4473#define PTYPE_HASH_SIZE (16)
4474#define PTYPE_HASH_MASK (PTYPE_HASH_SIZE - 1)
4475
385a154c 4476#endif /* _LINUX_NETDEVICE_H */