1	/* SPDX-License-Identifier: GPL-2.0-or-later */
2	/*
3	* INET An implementation of the TCP/IP protocol suite for the LINUX
4	* operating system. INET is implemented using the BSD Socket
5	* interface as the means of communication with the user level.
6	*
7	* Definitions for the Interfaces handler.
8	*
9	* Version: @(#)dev.h 1.0.10 08/12/93
10	*
11	* Authors: Ross Biro
12	* Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
13	* Corey Minyard <wf-rch!minyard@relay.EU.net>
14	* Donald J. Becker, <becker@cesdis.gsfc.nasa.gov>
15	* Alan Cox, <alan@lxorguk.ukuu.org.uk>
16	* Bjorn Ekwall. <bj0rn@blox.se>
17	* Pekka Riikonen <priikone@poseidon.pspt.fi>
18	*
19	* Moved to /usr/include/linux for NET3
20	*/
21	#ifndef _LINUX_NETDEVICE_H
22	#define _LINUX_NETDEVICE_H
23
24	#include <linux/timer.h>
25	#include <linux/bug.h>
26	#include <linux/delay.h>
27	#include <linux/atomic.h>
28	#include <linux/prefetch.h>
29	#include <asm/cache.h>
30	#include <asm/byteorder.h>
31	#include <asm/local.h>
32
33	#include <linux/percpu.h>
34	#include <linux/rculist.h>
35	#include <linux/workqueue.h>
36	#include <linux/dynamic_queue_limits.h>
37
38	#include <net/net_namespace.h>
39	#ifdef CONFIG_DCB
40	#include <net/dcbnl.h>
41	#endif
42	#include <net/netprio_cgroup.h>
43
44	#include <linux/netdev_features.h>
45	#include <linux/neighbour.h>
46	#include <uapi/linux/netdevice.h>
47	#include <uapi/linux/if_bonding.h>
48	#include <uapi/linux/pkt_cls.h>
49	#include <uapi/linux/netdev.h>
50	#include <linux/hashtable.h>
51	#include <linux/rbtree.h>
52	#include <net/net_trackers.h>
53	#include <net/net_debug.h>
54	#include <net/dropreason-core.h>
55
56	struct netpoll_info;
57	struct device;
58	struct ethtool_ops;
59	struct kernel_hwtstamp_config;
60	struct phy_device;
61	struct dsa_port;
62	struct ip_tunnel_parm;
63	struct macsec_context;
64	struct macsec_ops;
65	struct netdev_name_node;
66	struct sd_flow_limit;
67	struct sfp_bus;
68	/* 802.11 specific */
69	struct wireless_dev;
70	/* 802.15.4 specific */
71	struct wpan_dev;
72	struct mpls_dev;
73	/* UDP Tunnel offloads */
74	struct udp_tunnel_info;
75	struct udp_tunnel_nic_info;
76	struct udp_tunnel_nic;
77	struct bpf_prog;
78	struct xdp_buff;
79	struct xdp_frame;
80	struct xdp_metadata_ops;
81	struct xdp_md;
82
83	typedef u32 xdp_features_t;
84
85	void synchronize_net(void);
86	void netdev_set_default_ethtool_ops(struct net_device *dev,
87	const struct ethtool_ops *ops);
88	void netdev_sw_irq_coalesce_default_on(struct net_device *dev);
89
90	/* Backlog congestion levels */
91	#define NET_RX_SUCCESS 0 /* keep 'em coming, baby */
92	#define NET_RX_DROP 1 /* packet dropped */
93
94	#define MAX_NEST_DEV 8
95
96	/*
97	* Transmit return codes: transmit return codes originate from three different
98	* namespaces:
99	*
100	* - qdisc return codes
101	* - driver transmit return codes
102	* - errno values
103	*
104	* Drivers are allowed to return any one of those in their hard_start_xmit()
105	* function. Real network devices commonly used with qdiscs should only return
106	* the driver transmit return codes though - when qdiscs are used, the actual
107	* transmission happens asynchronously, so the value is not propagated to
108	* higher layers. Virtual network devices transmit synchronously; in this case
109	* the driver transmit return codes are consumed by dev_queue_xmit(), and all
110	* others are propagated to higher layers.
111	*/
112
113	/* qdisc ->enqueue() return codes. */
114	#define NET_XMIT_SUCCESS 0x00
115	#define NET_XMIT_DROP 0x01 /* skb dropped */
116	#define NET_XMIT_CN 0x02 /* congestion notification */
117	#define NET_XMIT_MASK 0x0f /* qdisc flags in net/sch_generic.h */
118
119	/* NET_XMIT_CN is special. It does not guarantee that this packet is lost. It
120	* indicates that the device will soon be dropping packets, or already drops
121	* some packets of the same priority; prompting us to send less aggressively. */
122	#define net_xmit_eval(e) ((e) == NET_XMIT_CN ? 0 : (e))
123	#define net_xmit_errno(e) ((e) != NET_XMIT_CN ? -ENOBUFS : 0)
124
125	/* Driver transmit return codes */
126	#define NETDEV_TX_MASK 0xf0
127
128	enum netdev_tx {
129	__NETDEV_TX_MIN = INT_MIN, /* make sure enum is signed */
130	NETDEV_TX_OK = 0x00, /* driver took care of packet */
131	NETDEV_TX_BUSY = 0x10, /* driver tx path was busy*/
132	};
133	typedef enum netdev_tx netdev_tx_t;
134
135	/*
136	* Current order: NETDEV_TX_MASK > NET_XMIT_MASK >= 0 is significant;
137	* hard_start_xmit() return < NET_XMIT_MASK means skb was consumed.
138	*/
139	static inline bool dev_xmit_complete(int rc)
140	{
141	/*
142	* Positive cases with an skb consumed by a driver:
143	* - successful transmission (rc == NETDEV_TX_OK)
144	* - error while transmitting (rc < 0)
145	* - error while queueing to a different device (rc & NET_XMIT_MASK)
146	*/
147	if (likely(rc < NET_XMIT_MASK))
148	return true;
149
150	return false;
151	}
152
153	/*
154	* Compute the worst-case header length according to the protocols
155	* used.
156	*/
157
158	#if defined(CONFIG_HYPERV_NET)
159	# define LL_MAX_HEADER 128
160	#elif defined(CONFIG_WLAN) || IS_ENABLED(CONFIG_AX25)
161	# if defined(CONFIG_MAC80211_MESH)
162	# define LL_MAX_HEADER 128
163	# else
164	# define LL_MAX_HEADER 96
165	# endif
166	#else
167	# define LL_MAX_HEADER 32
168	#endif
169
170	#if !IS_ENABLED(CONFIG_NET_IPIP) && !IS_ENABLED(CONFIG_NET_IPGRE) && \
171	!IS_ENABLED(CONFIG_IPV6_SIT) && !IS_ENABLED(CONFIG_IPV6_TUNNEL)
172	#define MAX_HEADER LL_MAX_HEADER
173	#else
174	#define MAX_HEADER (LL_MAX_HEADER + 48)
175	#endif
176
177	/*
178	* Old network device statistics. Fields are native words
179	* (unsigned long) so they can be read and written atomically.
180	*/
181
182	#define NET_DEV_STAT(FIELD) \
183	union { \
184	unsigned long FIELD; \
185	atomic_long_t __##FIELD; \
186	}
187
188	struct net_device_stats {
189	NET_DEV_STAT(rx_packets);
190	NET_DEV_STAT(tx_packets);
191	NET_DEV_STAT(rx_bytes);
192	NET_DEV_STAT(tx_bytes);
193	NET_DEV_STAT(rx_errors);
194	NET_DEV_STAT(tx_errors);
195	NET_DEV_STAT(rx_dropped);
196	NET_DEV_STAT(tx_dropped);
197	NET_DEV_STAT(multicast);
198	NET_DEV_STAT(collisions);
199	NET_DEV_STAT(rx_length_errors);
200	NET_DEV_STAT(rx_over_errors);
201	NET_DEV_STAT(rx_crc_errors);
202	NET_DEV_STAT(rx_frame_errors);
203	NET_DEV_STAT(rx_fifo_errors);
204	NET_DEV_STAT(rx_missed_errors);
205	NET_DEV_STAT(tx_aborted_errors);
206	NET_DEV_STAT(tx_carrier_errors);
207	NET_DEV_STAT(tx_fifo_errors);
208	NET_DEV_STAT(tx_heartbeat_errors);
209	NET_DEV_STAT(tx_window_errors);
210	NET_DEV_STAT(rx_compressed);
211	NET_DEV_STAT(tx_compressed);
212	};
213	#undef NET_DEV_STAT
214
215	/* per-cpu stats, allocated on demand.
216	* Try to fit them in a single cache line, for dev_get_stats() sake.
217	*/
218	struct net_device_core_stats {
219	unsigned long rx_dropped;
220	unsigned long tx_dropped;
221	unsigned long rx_nohandler;
222	unsigned long rx_otherhost_dropped;
223	} __aligned(4 * sizeof(unsigned long));
224
225	#include <linux/cache.h>
226	#include <linux/skbuff.h>
227
228	struct neighbour;
229	struct neigh_parms;
230	struct sk_buff;
231
232	struct netdev_hw_addr {
233	struct list_head list;
234	struct rb_node node;
235	unsigned char addr[MAX_ADDR_LEN];
236	unsigned char type;
237	#define NETDEV_HW_ADDR_T_LAN 1
238	#define NETDEV_HW_ADDR_T_SAN 2
239	#define NETDEV_HW_ADDR_T_UNICAST 3
240	#define NETDEV_HW_ADDR_T_MULTICAST 4
241	bool global_use;
242	int sync_cnt;
243	int refcount;
244	int synced;
245	struct rcu_head rcu_head;
246	};
247
248	struct netdev_hw_addr_list {
249	struct list_head list;
250	int count;
251
252	/* Auxiliary tree for faster lookup on addition and deletion */
253	struct rb_root tree;
254	};
255
256	#define netdev_hw_addr_list_count(l) ((l)->count)
257	#define netdev_hw_addr_list_empty(l) (netdev_hw_addr_list_count(l) == 0)
258	#define netdev_hw_addr_list_for_each(ha, l) \
259	list_for_each_entry(ha, &(l)->list, list)
260
261	#define netdev_uc_count(dev) netdev_hw_addr_list_count(&(dev)->uc)
262	#define netdev_uc_empty(dev) netdev_hw_addr_list_empty(&(dev)->uc)
263	#define netdev_for_each_uc_addr(ha, dev) \
264	netdev_hw_addr_list_for_each(ha, &(dev)->uc)
265	#define netdev_for_each_synced_uc_addr(_ha, _dev) \
266	netdev_for_each_uc_addr((_ha), (_dev)) \
267	if ((_ha)->sync_cnt)
268
269	#define netdev_mc_count(dev) netdev_hw_addr_list_count(&(dev)->mc)
270	#define netdev_mc_empty(dev) netdev_hw_addr_list_empty(&(dev)->mc)
271	#define netdev_for_each_mc_addr(ha, dev) \
272	netdev_hw_addr_list_for_each(ha, &(dev)->mc)
273	#define netdev_for_each_synced_mc_addr(_ha, _dev) \
274	netdev_for_each_mc_addr((_ha), (_dev)) \
275	if ((_ha)->sync_cnt)
276
277	struct hh_cache {
278	unsigned int hh_len;
279	seqlock_t hh_lock;
280
281	/* cached hardware header; allow for machine alignment needs. */
282	#define HH_DATA_MOD 16
283	#define HH_DATA_OFF(__len) \
284	(HH_DATA_MOD - (((__len - 1) & (HH_DATA_MOD - 1)) + 1))
285	#define HH_DATA_ALIGN(__len) \
286	(((__len)+(HH_DATA_MOD-1))&~(HH_DATA_MOD - 1))
287	unsigned long hh_data[HH_DATA_ALIGN(LL_MAX_HEADER) / sizeof(long)];
288	};
289
290	/* Reserve HH_DATA_MOD byte-aligned hard_header_len, but at least that much.
291	* Alternative is:
292	* dev->hard_header_len ? (dev->hard_header_len +
293	* (HH_DATA_MOD - 1)) & ~(HH_DATA_MOD - 1) : 0
294	*
295	* We could use other alignment values, but we must maintain the
296	* relationship HH alignment <= LL alignment.
297	*/
298	#define LL_RESERVED_SPACE(dev) \
299	((((dev)->hard_header_len + READ_ONCE((dev)->needed_headroom)) \
300	& ~(HH_DATA_MOD - 1)) + HH_DATA_MOD)
301	#define LL_RESERVED_SPACE_EXTRA(dev,extra) \
302	((((dev)->hard_header_len + READ_ONCE((dev)->needed_headroom) + (extra)) \
303	& ~(HH_DATA_MOD - 1)) + HH_DATA_MOD)
304
305	struct header_ops {
306	int (*create) (struct sk_buff *skb, struct net_device *dev,
307	unsigned short type, const void *daddr,
308	const void *saddr, unsigned int len);
309	int (*parse)(const struct sk_buff *skb, unsigned char *haddr);
310	int (*cache)(const struct neighbour *neigh, struct hh_cache *hh, __be16 type);
311	void (*cache_update)(struct hh_cache *hh,
312	const struct net_device *dev,
313	const unsigned char *haddr);
314	bool (*validate)(const char *ll_header, unsigned int len);
315	__be16 (*parse_protocol)(const struct sk_buff *skb);
316	};
317
318	/* These flag bits are private to the generic network queueing
319	* layer; they may not be explicitly referenced by any other
320	* code.
321	*/
322
323	enum netdev_state_t {
324	__LINK_STATE_START,
325	__LINK_STATE_PRESENT,
326	__LINK_STATE_NOCARRIER,
327	__LINK_STATE_LINKWATCH_PENDING,
328	__LINK_STATE_DORMANT,
329	__LINK_STATE_TESTING,
330	};
331
332	struct gro_list {
333	struct list_head list;
334	int count;
335	};
336
337	/*
338	* size of gro hash buckets, must less than bit number of
339	* napi_struct::gro_bitmask
340	*/
341	#define GRO_HASH_BUCKETS 8
342
343	/*
344	* Structure for NAPI scheduling similar to tasklet but with weighting
345	*/
346	struct napi_struct {
347	/* The poll_list must only be managed by the entity which
348	* changes the state of the NAPI_STATE_SCHED bit. This means
349	* whoever atomically sets that bit can add this napi_struct
350	* to the per-CPU poll_list, and whoever clears that bit
351	* can remove from the list right before clearing the bit.
352	*/
353	struct list_head poll_list;
354
355	unsigned long state;
356	int weight;
357	int defer_hard_irqs_count;
358	unsigned long gro_bitmask;
359	int (*poll)(struct napi_struct *, int);
360	#ifdef CONFIG_NETPOLL
361	/* CPU actively polling if netpoll is configured */
362	int poll_owner;
363	#endif
364	/* CPU on which NAPI has been scheduled for processing */
365	int list_owner;
366	struct net_device *dev;
367	struct gro_list gro_hash[GRO_HASH_BUCKETS];
368	struct sk_buff *skb;
369	struct list_head rx_list; /* Pending GRO_NORMAL skbs */
370	int rx_count; /* length of rx_list */
371	unsigned int napi_id;
372	struct hrtimer timer;
373	struct task_struct *thread;
374	/* control-path-only fields follow */
375	struct list_head dev_list;
376	struct hlist_node napi_hash_node;
377	int irq;
378	};
379
380	enum {
381	NAPI_STATE_SCHED, /* Poll is scheduled */
382	NAPI_STATE_MISSED, /* reschedule a napi */
383	NAPI_STATE_DISABLE, /* Disable pending */
384	NAPI_STATE_NPSVC, /* Netpoll - don't dequeue from poll_list */
385	NAPI_STATE_LISTED, /* NAPI added to system lists */
386	NAPI_STATE_NO_BUSY_POLL, /* Do not add in napi_hash, no busy polling */
387	NAPI_STATE_IN_BUSY_POLL, /* sk_busy_loop() owns this NAPI */
388	NAPI_STATE_PREFER_BUSY_POLL, /* prefer busy-polling over softirq processing*/
389	NAPI_STATE_THREADED, /* The poll is performed inside its own thread*/
390	NAPI_STATE_SCHED_THREADED, /* Napi is currently scheduled in threaded mode */
391	};
392
393	enum {
394	NAPIF_STATE_SCHED = BIT(NAPI_STATE_SCHED),
395	NAPIF_STATE_MISSED = BIT(NAPI_STATE_MISSED),
396	NAPIF_STATE_DISABLE = BIT(NAPI_STATE_DISABLE),
397	NAPIF_STATE_NPSVC = BIT(NAPI_STATE_NPSVC),
398	NAPIF_STATE_LISTED = BIT(NAPI_STATE_LISTED),
399	NAPIF_STATE_NO_BUSY_POLL = BIT(NAPI_STATE_NO_BUSY_POLL),
400	NAPIF_STATE_IN_BUSY_POLL = BIT(NAPI_STATE_IN_BUSY_POLL),
401	NAPIF_STATE_PREFER_BUSY_POLL = BIT(NAPI_STATE_PREFER_BUSY_POLL),
402	NAPIF_STATE_THREADED = BIT(NAPI_STATE_THREADED),
403	NAPIF_STATE_SCHED_THREADED = BIT(NAPI_STATE_SCHED_THREADED),
404	};
405
406	enum gro_result {
407	GRO_MERGED,
408	GRO_MERGED_FREE,
409	GRO_HELD,
410	GRO_NORMAL,
411	GRO_CONSUMED,
412	};
413	typedef enum gro_result gro_result_t;
414
415	/*
416	* enum rx_handler_result - Possible return values for rx_handlers.
417	* @RX_HANDLER_CONSUMED: skb was consumed by rx_handler, do not process it
418	* further.
419	* @RX_HANDLER_ANOTHER: Do another round in receive path. This is indicated in
420	* case skb->dev was changed by rx_handler.
421	* @RX_HANDLER_EXACT: Force exact delivery, no wildcard.
422	* @RX_HANDLER_PASS: Do nothing, pass the skb as if no rx_handler was called.
423	*
424	* rx_handlers are functions called from inside __netif_receive_skb(), to do
425	* special processing of the skb, prior to delivery to protocol handlers.
426	*
427	* Currently, a net_device can only have a single rx_handler registered. Trying
428	* to register a second rx_handler will return -EBUSY.
429	*
430	* To register a rx_handler on a net_device, use netdev_rx_handler_register().
431	* To unregister a rx_handler on a net_device, use
432	* netdev_rx_handler_unregister().
433	*
434	* Upon return, rx_handler is expected to tell __netif_receive_skb() what to
435	* do with the skb.
436	*
437	* If the rx_handler consumed the skb in some way, it should return
438	* RX_HANDLER_CONSUMED. This is appropriate when the rx_handler arranged for
439	* the skb to be delivered in some other way.
440	*
441	* If the rx_handler changed skb->dev, to divert the skb to another
442	* net_device, it should return RX_HANDLER_ANOTHER. The rx_handler for the
443	* new device will be called if it exists.
444	*
445	* If the rx_handler decides the skb should be ignored, it should return
446	* RX_HANDLER_EXACT. The skb will only be delivered to protocol handlers that
447	* are registered on exact device (ptype->dev == skb->dev).
448	*
449	* If the rx_handler didn't change skb->dev, but wants the skb to be normally
450	* delivered, it should return RX_HANDLER_PASS.
451	*
452	* A device without a registered rx_handler will behave as if rx_handler
453	* returned RX_HANDLER_PASS.
454	*/
455
456	enum rx_handler_result {
457	RX_HANDLER_CONSUMED,
458	RX_HANDLER_ANOTHER,
459	RX_HANDLER_EXACT,
460	RX_HANDLER_PASS,
461	};
462	typedef enum rx_handler_result rx_handler_result_t;
463	typedef rx_handler_result_t rx_handler_func_t(struct sk_buff **pskb);
464
465	void __napi_schedule(struct napi_struct *n);
466	void __napi_schedule_irqoff(struct napi_struct *n);
467
468	static inline bool napi_disable_pending(struct napi_struct *n)
469	{
470	return test_bit(NAPI_STATE_DISABLE, &n->state);
471	}
472
473	static inline bool napi_prefer_busy_poll(struct napi_struct *n)
474	{
475	return test_bit(NAPI_STATE_PREFER_BUSY_POLL, &n->state);
476	}
477
478	/**
479	* napi_is_scheduled - test if NAPI is scheduled
480	* @n: NAPI context
481	*
482	* This check is "best-effort". With no locking implemented,
483	* a NAPI can be scheduled or terminate right after this check
484	* and produce not precise results.
485	*
486	* NAPI_STATE_SCHED is an internal state, napi_is_scheduled
487	* should not be used normally and napi_schedule should be
488	* used instead.
489	*
490	* Use only if the driver really needs to check if a NAPI
491	* is scheduled for example in the context of delayed timer
492	* that can be skipped if a NAPI is already scheduled.
493	*
494	* Return True if NAPI is scheduled, False otherwise.
495	*/
496	static inline bool napi_is_scheduled(struct napi_struct *n)
497	{
498	return test_bit(NAPI_STATE_SCHED, &n->state);
499	}
500
501	bool napi_schedule_prep(struct napi_struct *n);
502
503	/**
504	* napi_schedule - schedule NAPI poll
505	* @n: NAPI context
506	*
507	* Schedule NAPI poll routine to be called if it is not already
508	* running.
509	* Return true if we schedule a NAPI or false if not.
510	* Refer to napi_schedule_prep() for additional reason on why
511	* a NAPI might not be scheduled.
512	*/
513	static inline bool napi_schedule(struct napi_struct *n)
514	{
515	if (napi_schedule_prep(n)) {
516	__napi_schedule(n);
517	return true;
518	}
519
520	return false;
521	}
522
523	/**
524	* napi_schedule_irqoff - schedule NAPI poll
525	* @n: NAPI context
526	*
527	* Variant of napi_schedule(), assuming hard irqs are masked.
528	*/
529	static inline void napi_schedule_irqoff(struct napi_struct *n)
530	{
531	if (napi_schedule_prep(n))
532	__napi_schedule_irqoff(n);
533	}
534
535	/**
536	* napi_complete_done - NAPI processing complete
537	* @n: NAPI context
538	* @work_done: number of packets processed
539	*
540	* Mark NAPI processing as complete. Should only be called if poll budget
541	* has not been completely consumed.
542	* Prefer over napi_complete().
543	* Return false if device should avoid rearming interrupts.
544	*/
545	bool napi_complete_done(struct napi_struct *n, int work_done);
546
547	static inline bool napi_complete(struct napi_struct *n)
548	{
549	return napi_complete_done(n, work_done: 0);
550	}
551
552	int dev_set_threaded(struct net_device *dev, bool threaded);
553
554	/**
555	* napi_disable - prevent NAPI from scheduling
556	* @n: NAPI context
557	*
558	* Stop NAPI from being scheduled on this context.
559	* Waits till any outstanding processing completes.
560	*/
561	void napi_disable(struct napi_struct *n);
562
563	void napi_enable(struct napi_struct *n);
564
565	/**
566	* napi_synchronize - wait until NAPI is not running
567	* @n: NAPI context
568	*
569	* Wait until NAPI is done being scheduled on this context.
570	* Waits till any outstanding processing completes but
571	* does not disable future activations.
572	*/
573	static inline void napi_synchronize(const struct napi_struct *n)
574	{
575	if (IS_ENABLED(CONFIG_SMP))
576	while (test_bit(NAPI_STATE_SCHED, &n->state))
577	msleep(msecs: 1);
578	else
579	barrier();
580	}
581
582	/**
583	* napi_if_scheduled_mark_missed - if napi is running, set the
584	* NAPIF_STATE_MISSED
585	* @n: NAPI context
586	*
587	* If napi is running, set the NAPIF_STATE_MISSED, and return true if
588	* NAPI is scheduled.
589	**/
590	static inline bool napi_if_scheduled_mark_missed(struct napi_struct *n)
591	{
592	unsigned long val, new;
593
594	val = READ_ONCE(n->state);
595	do {
596	if (val & NAPIF_STATE_DISABLE)
597	return true;
598
599	if (!(val & NAPIF_STATE_SCHED))
600	return false;
601
602	new = val | NAPIF_STATE_MISSED;
603	} while (!try_cmpxchg(&n->state, &val, new));
604
605	return true;
606	}
607
608	enum netdev_queue_state_t {
609	__QUEUE_STATE_DRV_XOFF,
610	__QUEUE_STATE_STACK_XOFF,
611	__QUEUE_STATE_FROZEN,
612	};
613
614	#define QUEUE_STATE_DRV_XOFF (1 << __QUEUE_STATE_DRV_XOFF)
615	#define QUEUE_STATE_STACK_XOFF (1 << __QUEUE_STATE_STACK_XOFF)
616	#define QUEUE_STATE_FROZEN (1 << __QUEUE_STATE_FROZEN)
617
618	#define QUEUE_STATE_ANY_XOFF (QUEUE_STATE_DRV_XOFF | QUEUE_STATE_STACK_XOFF)
619	#define QUEUE_STATE_ANY_XOFF_OR_FROZEN (QUEUE_STATE_ANY_XOFF | \
620	QUEUE_STATE_FROZEN)
621	#define QUEUE_STATE_DRV_XOFF_OR_FROZEN (QUEUE_STATE_DRV_XOFF | \
622	QUEUE_STATE_FROZEN)
623
624	/*
625	* __QUEUE_STATE_DRV_XOFF is used by drivers to stop the transmit queue. The
626	* netif_tx_* functions below are used to manipulate this flag. The
627	* __QUEUE_STATE_STACK_XOFF flag is used by the stack to stop the transmit
628	* queue independently. The netif_xmit_*stopped functions below are called
629	* to check if the queue has been stopped by the driver or stack (either
630	* of the XOFF bits are set in the state). Drivers should not need to call
631	* netif_xmit*stopped functions, they should only be using netif_tx_*.
632	*/
633
634	struct netdev_queue {
635	/*
636	* read-mostly part
637	*/
638	struct net_device *dev;
639	netdevice_tracker dev_tracker;
640
641	struct Qdisc __rcu *qdisc;
642	struct Qdisc __rcu *qdisc_sleeping;
643	#ifdef CONFIG_SYSFS
644	struct kobject kobj;
645	#endif
646	#if defined(CONFIG_XPS) && defined(CONFIG_NUMA)
647	int numa_node;
648	#endif
649	unsigned long tx_maxrate;
650	/*
651	* Number of TX timeouts for this queue
652	* (/sys/class/net/DEV/Q/trans_timeout)
653	*/
654	atomic_long_t trans_timeout;
655
656	/* Subordinate device that the queue has been assigned to */
657	struct net_device *sb_dev;
658	#ifdef CONFIG_XDP_SOCKETS
659	struct xsk_buff_pool *pool;
660	#endif
661	/* NAPI instance for the queue
662	* Readers and writers must hold RTNL
663	*/
664	struct napi_struct *napi;
665	/*
666	* write-mostly part
667	*/
668	spinlock_t _xmit_lock ____cacheline_aligned_in_smp;
669	int xmit_lock_owner;
670	/*
671	* Time (in jiffies) of last Tx
672	*/
673	unsigned long trans_start;
674
675	unsigned long state;
676
677	#ifdef CONFIG_BQL
678	struct dql dql;
679	#endif
680	} ____cacheline_aligned_in_smp;
681
682	extern int sysctl_fb_tunnels_only_for_init_net;
683	extern int sysctl_devconf_inherit_init_net;
684
685	/*
686	* sysctl_fb_tunnels_only_for_init_net == 0 : For all netns
687	* == 1 : For initns only
688	* == 2 : For none.
689	*/
690	static inline bool net_has_fallback_tunnels(const struct net *net)
691	{
692	#if IS_ENABLED(CONFIG_SYSCTL)
693	int fb_tunnels_only_for_init_net = READ_ONCE(sysctl_fb_tunnels_only_for_init_net);
694
695	return !fb_tunnels_only_for_init_net ||
696	(net_eq(net1: net, net2: &init_net) && fb_tunnels_only_for_init_net == 1);
697	#else
698	return true;
699	#endif
700	}
701
702	static inline int net_inherit_devconf(void)
703	{
704	#if IS_ENABLED(CONFIG_SYSCTL)
705	return READ_ONCE(sysctl_devconf_inherit_init_net);
706	#else
707	return 0;
708	#endif
709	}
710
711	static inline int netdev_queue_numa_node_read(const struct netdev_queue *q)
712	{
713	#if defined(CONFIG_XPS) && defined(CONFIG_NUMA)
714	return q->numa_node;
715	#else
716	return NUMA_NO_NODE;
717	#endif
718	}
719
720	static inline void netdev_queue_numa_node_write(struct netdev_queue *q, int node)
721	{
722	#if defined(CONFIG_XPS) && defined(CONFIG_NUMA)
723	q->numa_node = node;
724	#endif
725	}
726
727	#ifdef CONFIG_RFS_ACCEL
728	bool rps_may_expire_flow(struct net_device *dev, u16 rxq_index, u32 flow_id,
729	u16 filter_id);
730	#endif
731
732	/* XPS map type and offset of the xps map within net_device->xps_maps[]. */
733	enum xps_map_type {
734	XPS_CPUS = 0,
735	XPS_RXQS,
736	XPS_MAPS_MAX,
737	};
738
739	#ifdef CONFIG_XPS
740	/*
741	* This structure holds an XPS map which can be of variable length. The
742	* map is an array of queues.
743	*/
744	struct xps_map {
745	unsigned int len;
746	unsigned int alloc_len;
747	struct rcu_head rcu;
748	u16 queues[];
749	};
750	#define XPS_MAP_SIZE(_num) (sizeof(struct xps_map) + ((_num) * sizeof(u16)))
751	#define XPS_MIN_MAP_ALLOC ((L1_CACHE_ALIGN(offsetof(struct xps_map, queues[1])) \
752	- sizeof(struct xps_map)) / sizeof(u16))
753
754	/*
755	* This structure holds all XPS maps for device. Maps are indexed by CPU.
756	*
757	* We keep track of the number of cpus/rxqs used when the struct is allocated,
758	* in nr_ids. This will help not accessing out-of-bound memory.
759	*
760	* We keep track of the number of traffic classes used when the struct is
761	* allocated, in num_tc. This will be used to navigate the maps, to ensure we're
762	* not crossing its upper bound, as the original dev->num_tc can be updated in
763	* the meantime.
764	*/
765	struct xps_dev_maps {
766	struct rcu_head rcu;
767	unsigned int nr_ids;
768	s16 num_tc;
769	struct xps_map __rcu *attr_map[]; /* Either CPUs map or RXQs map */
770	};
771
772	#define XPS_CPU_DEV_MAPS_SIZE(_tcs) (sizeof(struct xps_dev_maps) + \
773	(nr_cpu_ids * (_tcs) * sizeof(struct xps_map *)))
774
775	#define XPS_RXQ_DEV_MAPS_SIZE(_tcs, _rxqs) (sizeof(struct xps_dev_maps) +\
776	(_rxqs * (_tcs) * sizeof(struct xps_map *)))
777
778	#endif /* CONFIG_XPS */
779
780	#define TC_MAX_QUEUE 16
781	#define TC_BITMASK 15
782	/* HW offloaded queuing disciplines txq count and offset maps */
783	struct netdev_tc_txq {
784	u16 count;
785	u16 offset;
786	};
787
788	#if defined(CONFIG_FCOE) || defined(CONFIG_FCOE_MODULE)
789	/*
790	* This structure is to hold information about the device
791	* configured to run FCoE protocol stack.
792	*/
793	struct netdev_fcoe_hbainfo {
794	char manufacturer[64];
795	char serial_number[64];
796	char hardware_version[64];
797	char driver_version[64];
798	char optionrom_version[64];
799	char firmware_version[64];
800	char model[256];
801	char model_description[256];
802	};
803	#endif
804
805	#define MAX_PHYS_ITEM_ID_LEN 32
806
807	/* This structure holds a unique identifier to identify some
808	* physical item (port for example) used by a netdevice.
809	*/
810	struct netdev_phys_item_id {
811	unsigned char id[MAX_PHYS_ITEM_ID_LEN];
812	unsigned char id_len;
813	};
814
815	static inline bool netdev_phys_item_id_same(struct netdev_phys_item_id *a,
816	struct netdev_phys_item_id *b)
817	{
818	return a->id_len == b->id_len &&
819	memcmp(p: a->id, q: b->id, size: a->id_len) == 0;
820	}
821
822	typedef u16 (*select_queue_fallback_t)(struct net_device *dev,
823	struct sk_buff *skb,
824	struct net_device *sb_dev);
825
826	enum net_device_path_type {
827	DEV_PATH_ETHERNET = 0,
828	DEV_PATH_VLAN,
829	DEV_PATH_BRIDGE,
830	DEV_PATH_PPPOE,
831	DEV_PATH_DSA,
832	DEV_PATH_MTK_WDMA,
833	};
834
835	struct net_device_path {
836	enum net_device_path_type type;
837	const struct net_device *dev;
838	union {
839	struct {
840	u16 id;
841	__be16 proto;
842	u8 h_dest[ETH_ALEN];
843	} encap;
844	struct {
845	enum {
846	DEV_PATH_BR_VLAN_KEEP,
847	DEV_PATH_BR_VLAN_TAG,
848	DEV_PATH_BR_VLAN_UNTAG,
849	DEV_PATH_BR_VLAN_UNTAG_HW,
850	} vlan_mode;
851	u16 vlan_id;
852	__be16 vlan_proto;
853	} bridge;
854	struct {
855	int port;
856	u16 proto;
857	} dsa;
858	struct {
859	u8 wdma_idx;
860	u8 queue;
861	u16 wcid;
862	u8 bss;
863	u8 amsdu;
864	} mtk_wdma;
865	};
866	};
867
868	#define NET_DEVICE_PATH_STACK_MAX 5
869	#define NET_DEVICE_PATH_VLAN_MAX 2
870
871	struct net_device_path_stack {
872	int num_paths;
873	struct net_device_path path[NET_DEVICE_PATH_STACK_MAX];
874	};
875
876	struct net_device_path_ctx {
877	const struct net_device *dev;
878	u8 daddr[ETH_ALEN];
879
880	int num_vlans;
881	struct {
882	u16 id;
883	__be16 proto;
884	} vlan[NET_DEVICE_PATH_VLAN_MAX];
885	};
886
887	enum tc_setup_type {
888	TC_QUERY_CAPS,
889	TC_SETUP_QDISC_MQPRIO,
890	TC_SETUP_CLSU32,
891	TC_SETUP_CLSFLOWER,
892	TC_SETUP_CLSMATCHALL,
893	TC_SETUP_CLSBPF,
894	TC_SETUP_BLOCK,
895	TC_SETUP_QDISC_CBS,
896	TC_SETUP_QDISC_RED,
897	TC_SETUP_QDISC_PRIO,
898	TC_SETUP_QDISC_MQ,
899	TC_SETUP_QDISC_ETF,
900	TC_SETUP_ROOT_QDISC,
901	TC_SETUP_QDISC_GRED,
902	TC_SETUP_QDISC_TAPRIO,
903	TC_SETUP_FT,
904	TC_SETUP_QDISC_ETS,
905	TC_SETUP_QDISC_TBF,
906	TC_SETUP_QDISC_FIFO,
907	TC_SETUP_QDISC_HTB,
908	TC_SETUP_ACT,
909	};
910
911	/* These structures hold the attributes of bpf state that are being passed
912	* to the netdevice through the bpf op.
913	*/
914	enum bpf_netdev_command {
915	/* Set or clear a bpf program used in the earliest stages of packet
916	* rx. The prog will have been loaded as BPF_PROG_TYPE_XDP. The callee
917	* is responsible for calling bpf_prog_put on any old progs that are
918	* stored. In case of error, the callee need not release the new prog
919	* reference, but on success it takes ownership and must bpf_prog_put
920	* when it is no longer used.
921	*/
922	XDP_SETUP_PROG,
923	XDP_SETUP_PROG_HW,
924	/* BPF program for offload callbacks, invoked at program load time. */
925	BPF_OFFLOAD_MAP_ALLOC,
926	BPF_OFFLOAD_MAP_FREE,
927	XDP_SETUP_XSK_POOL,
928	};
929
930	struct bpf_prog_offload_ops;
931	struct netlink_ext_ack;
932	struct xdp_umem;
933	struct xdp_dev_bulk_queue;
934	struct bpf_xdp_link;
935
936	enum bpf_xdp_mode {
937	XDP_MODE_SKB = 0,
938	XDP_MODE_DRV = 1,
939	XDP_MODE_HW = 2,
940	__MAX_XDP_MODE
941	};
942
943	struct bpf_xdp_entity {
944	struct bpf_prog *prog;
945	struct bpf_xdp_link *link;
946	};
947
948	struct netdev_bpf {
949	enum bpf_netdev_command command;
950	union {
951	/* XDP_SETUP_PROG */
952	struct {
953	u32 flags;
954	struct bpf_prog *prog;
955	struct netlink_ext_ack *extack;
956	};
957	/* BPF_OFFLOAD_MAP_ALLOC, BPF_OFFLOAD_MAP_FREE */
958	struct {
959	struct bpf_offloaded_map *offmap;
960	};
961	/* XDP_SETUP_XSK_POOL */
962	struct {
963	struct xsk_buff_pool *pool;
964	u16 queue_id;
965	} xsk;
966	};
967	};
968
969	/* Flags for ndo_xsk_wakeup. */
970	#define XDP_WAKEUP_RX (1 << 0)
971	#define XDP_WAKEUP_TX (1 << 1)
972
973	#ifdef CONFIG_XFRM_OFFLOAD
974	struct xfrmdev_ops {
975	int (*xdo_dev_state_add) (struct xfrm_state *x, struct netlink_ext_ack *extack);
976	void (*xdo_dev_state_delete) (struct xfrm_state *x);
977	void (*xdo_dev_state_free) (struct xfrm_state *x);
978	bool (*xdo_dev_offload_ok) (struct sk_buff *skb,
979	struct xfrm_state *x);
980	void (*xdo_dev_state_advance_esn) (struct xfrm_state *x);
981	void (*xdo_dev_state_update_stats) (struct xfrm_state *x);
982	int (*xdo_dev_policy_add) (struct xfrm_policy *x, struct netlink_ext_ack *extack);
983	void (*xdo_dev_policy_delete) (struct xfrm_policy *x);
984	void (*xdo_dev_policy_free) (struct xfrm_policy *x);
985	};
986	#endif
987
988	struct dev_ifalias {
989	struct rcu_head rcuhead;
990	char ifalias[];
991	};
992
993	struct devlink;
994	struct tlsdev_ops;
995
996	struct netdev_net_notifier {
997	struct list_head list;
998	struct notifier_block *nb;
999	};
1000
1001	/*
1002	* This structure defines the management hooks for network devices.
1003	* The following hooks can be defined; unless noted otherwise, they are
1004	* optional and can be filled with a null pointer.
1005	*
1006	* int (*ndo_init)(struct net_device *dev);
1007	* This function is called once when a network device is registered.
1008	* The network device can use this for any late stage initialization
1009	* or semantic validation. It can fail with an error code which will
1010	* be propagated back to register_netdev.
1011	*
1012	* void (*ndo_uninit)(struct net_device *dev);
1013	* This function is called when device is unregistered or when registration
1014	* fails. It is not called if init fails.
1015	*
1016	* int (*ndo_open)(struct net_device *dev);
1017	* This function is called when a network device transitions to the up
1018	* state.
1019	*
1020	* int (*ndo_stop)(struct net_device *dev);
1021	* This function is called when a network device transitions to the down
1022	* state.
1023	*
1024	* netdev_tx_t (*ndo_start_xmit)(struct sk_buff *skb,
1025	* struct net_device *dev);
1026	* Called when a packet needs to be transmitted.
1027	* Returns NETDEV_TX_OK. Can return NETDEV_TX_BUSY, but you should stop
1028	* the queue before that can happen; it's for obsolete devices and weird
1029	* corner cases, but the stack really does a non-trivial amount
1030	* of useless work if you return NETDEV_TX_BUSY.
1031	* Required; cannot be NULL.
1032	*
1033	* netdev_features_t (*ndo_features_check)(struct sk_buff *skb,
1034	* struct net_device *dev
1035	* netdev_features_t features);
1036	* Called by core transmit path to determine if device is capable of
1037	* performing offload operations on a given packet. This is to give
1038	* the device an opportunity to implement any restrictions that cannot
1039	* be otherwise expressed by feature flags. The check is called with
1040	* the set of features that the stack has calculated and it returns
1041	* those the driver believes to be appropriate.
1042	*
1043	* u16 (*ndo_select_queue)(struct net_device *dev, struct sk_buff *skb,
1044	* struct net_device *sb_dev);
1045	* Called to decide which queue to use when device supports multiple
1046	* transmit queues.
1047	*
1048	* void (*ndo_change_rx_flags)(struct net_device *dev, int flags);
1049	* This function is called to allow device receiver to make
1050	* changes to configuration when multicast or promiscuous is enabled.
1051	*
1052	* void (*ndo_set_rx_mode)(struct net_device *dev);
1053	* This function is called device changes address list filtering.
1054	* If driver handles unicast address filtering, it should set
1055	* IFF_UNICAST_FLT in its priv_flags.
1056	*
1057	* int (*ndo_set_mac_address)(struct net_device *dev, void *addr);
1058	* This function is called when the Media Access Control address
1059	* needs to be changed. If this interface is not defined, the
1060	* MAC address can not be changed.
1061	*
1062	* int (*ndo_validate_addr)(struct net_device *dev);
1063	* Test if Media Access Control address is valid for the device.
1064	*
1065	* int (*ndo_do_ioctl)(struct net_device *dev, struct ifreq *ifr, int cmd);
1066	* Old-style ioctl entry point. This is used internally by the
1067	* appletalk and ieee802154 subsystems but is no longer called by
1068	* the device ioctl handler.
1069	*
1070	* int (*ndo_siocbond)(struct net_device *dev, struct ifreq *ifr, int cmd);
1071	* Used by the bonding driver for its device specific ioctls:
1072	* SIOCBONDENSLAVE, SIOCBONDRELEASE, SIOCBONDSETHWADDR, SIOCBONDCHANGEACTIVE,
1073	* SIOCBONDSLAVEINFOQUERY, and SIOCBONDINFOQUERY
1074	*
1075	* * int (*ndo_eth_ioctl)(struct net_device *dev, struct ifreq *ifr, int cmd);
1076	* Called for ethernet specific ioctls: SIOCGMIIPHY, SIOCGMIIREG,
1077	* SIOCSMIIREG, SIOCSHWTSTAMP and SIOCGHWTSTAMP.
1078	*
1079	* int (*ndo_set_config)(struct net_device *dev, struct ifmap *map);
1080	* Used to set network devices bus interface parameters. This interface
1081	* is retained for legacy reasons; new devices should use the bus
1082	* interface (PCI) for low level management.
1083	*
1084	* int (*ndo_change_mtu)(struct net_device *dev, int new_mtu);
1085	* Called when a user wants to change the Maximum Transfer Unit
1086	* of a device.
1087	*
1088	* void (*ndo_tx_timeout)(struct net_device *dev, unsigned int txqueue);
1089	* Callback used when the transmitter has not made any progress
1090	* for dev->watchdog ticks.
1091	*
1092	* void (*ndo_get_stats64)(struct net_device *dev,
1093	* struct rtnl_link_stats64 *storage);
1094	* struct net_device_stats* (*ndo_get_stats)(struct net_device *dev);
1095	* Called when a user wants to get the network device usage
1096	* statistics. Drivers must do one of the following:
1097	* 1. Define @ndo_get_stats64 to fill in a zero-initialised
1098	* rtnl_link_stats64 structure passed by the caller.
1099	* 2. Define @ndo_get_stats to update a net_device_stats structure
1100	* (which should normally be dev->stats) and return a pointer to
1101	* it. The structure may be changed asynchronously only if each
1102	* field is written atomically.
1103	* 3. Update dev->stats asynchronously and atomically, and define
1104	* neither operation.
1105	*
1106	* bool (*ndo_has_offload_stats)(const struct net_device *dev, int attr_id)
1107	* Return true if this device supports offload stats of this attr_id.
1108	*
1109	* int (*ndo_get_offload_stats)(int attr_id, const struct net_device *dev,
1110	* void *attr_data)
1111	* Get statistics for offload operations by attr_id. Write it into the
1112	* attr_data pointer.
1113	*
1114	* int (*ndo_vlan_rx_add_vid)(struct net_device *dev, __be16 proto, u16 vid);
1115	* If device supports VLAN filtering this function is called when a
1116	* VLAN id is registered.
1117	*
1118	* int (*ndo_vlan_rx_kill_vid)(struct net_device *dev, __be16 proto, u16 vid);
1119	* If device supports VLAN filtering this function is called when a
1120	* VLAN id is unregistered.
1121	*
1122	* void (*ndo_poll_controller)(struct net_device *dev);
1123	*
1124	* SR-IOV management functions.
1125	* int (*ndo_set_vf_mac)(struct net_device *dev, int vf, u8* mac);
1126	* int (*ndo_set_vf_vlan)(struct net_device *dev, int vf, u16 vlan,
1127	* u8 qos, __be16 proto);
1128	* int (*ndo_set_vf_rate)(struct net_device *dev, int vf, int min_tx_rate,
1129	* int max_tx_rate);
1130	* int (*ndo_set_vf_spoofchk)(struct net_device *dev, int vf, bool setting);
1131	* int (*ndo_set_vf_trust)(struct net_device *dev, int vf, bool setting);
1132	* int (*ndo_get_vf_config)(struct net_device *dev,
1133	* int vf, struct ifla_vf_info *ivf);
1134	* int (*ndo_set_vf_link_state)(struct net_device *dev, int vf, int link_state);
1135	* int (*ndo_set_vf_port)(struct net_device *dev, int vf,
1136	* struct nlattr *port[]);
1137	*
1138	* Enable or disable the VF ability to query its RSS Redirection Table and
1139	* Hash Key. This is needed since on some devices VF share this information
1140	* with PF and querying it may introduce a theoretical security risk.
1141	* int (*ndo_set_vf_rss_query_en)(struct net_device *dev, int vf, bool setting);
1142	* int (*ndo_get_vf_port)(struct net_device *dev, int vf, struct sk_buff *skb);
1143	* int (*ndo_setup_tc)(struct net_device *dev, enum tc_setup_type type,
1144	* void *type_data);
1145	* Called to setup any 'tc' scheduler, classifier or action on @dev.
1146	* This is always called from the stack with the rtnl lock held and netif
1147	* tx queues stopped. This allows the netdevice to perform queue
1148	* management safely.
1149	*
1150	* Fiber Channel over Ethernet (FCoE) offload functions.
1151	* int (*ndo_fcoe_enable)(struct net_device *dev);
1152	* Called when the FCoE protocol stack wants to start using LLD for FCoE
1153	* so the underlying device can perform whatever needed configuration or
1154	* initialization to support acceleration of FCoE traffic.
1155	*
1156	* int (*ndo_fcoe_disable)(struct net_device *dev);
1157	* Called when the FCoE protocol stack wants to stop using LLD for FCoE
1158	* so the underlying device can perform whatever needed clean-ups to
1159	* stop supporting acceleration of FCoE traffic.
1160	*
1161	* int (*ndo_fcoe_ddp_setup)(struct net_device *dev, u16 xid,
1162	* struct scatterlist *sgl, unsigned int sgc);
1163	* Called when the FCoE Initiator wants to initialize an I/O that
1164	* is a possible candidate for Direct Data Placement (DDP). The LLD can
1165	* perform necessary setup and returns 1 to indicate the device is set up
1166	* successfully to perform DDP on this I/O, otherwise this returns 0.
1167	*
1168	* int (*ndo_fcoe_ddp_done)(struct net_device *dev, u16 xid);
1169	* Called when the FCoE Initiator/Target is done with the DDPed I/O as
1170	* indicated by the FC exchange id 'xid', so the underlying device can
1171	* clean up and reuse resources for later DDP requests.
1172	*
1173	* int (*ndo_fcoe_ddp_target)(struct net_device *dev, u16 xid,
1174	* struct scatterlist *sgl, unsigned int sgc);
1175	* Called when the FCoE Target wants to initialize an I/O that
1176	* is a possible candidate for Direct Data Placement (DDP). The LLD can
1177	* perform necessary setup and returns 1 to indicate the device is set up
1178	* successfully to perform DDP on this I/O, otherwise this returns 0.
1179	*
1180	* int (*ndo_fcoe_get_hbainfo)(struct net_device *dev,
1181	* struct netdev_fcoe_hbainfo *hbainfo);
1182	* Called when the FCoE Protocol stack wants information on the underlying
1183	* device. This information is utilized by the FCoE protocol stack to
1184	* register attributes with Fiber Channel management service as per the
1185	* FC-GS Fabric Device Management Information(FDMI) specification.
1186	*
1187	* int (*ndo_fcoe_get_wwn)(struct net_device *dev, u64 *wwn, int type);
1188	* Called when the underlying device wants to override default World Wide
1189	* Name (WWN) generation mechanism in FCoE protocol stack to pass its own
1190	* World Wide Port Name (WWPN) or World Wide Node Name (WWNN) to the FCoE
1191	* protocol stack to use.
1192	*
1193	* RFS acceleration.
1194	* int (*ndo_rx_flow_steer)(struct net_device *dev, const struct sk_buff *skb,
1195	* u16 rxq_index, u32 flow_id);
1196	* Set hardware filter for RFS. rxq_index is the target queue index;
1197	* flow_id is a flow ID to be passed to rps_may_expire_flow() later.
1198	* Return the filter ID on success, or a negative error code.
1199	*
1200	* Slave management functions (for bridge, bonding, etc).
1201	* int (*ndo_add_slave)(struct net_device *dev, struct net_device *slave_dev);
1202	* Called to make another netdev an underling.
1203	*
1204	* int (*ndo_del_slave)(struct net_device *dev, struct net_device *slave_dev);
1205	* Called to release previously enslaved netdev.
1206	*
1207	* struct net_device *(*ndo_get_xmit_slave)(struct net_device *dev,
1208	* struct sk_buff *skb,
1209	* bool all_slaves);
1210	* Get the xmit slave of master device. If all_slaves is true, function
1211	* assume all the slaves can transmit.
1212	*
1213	* Feature/offload setting functions.
1214	* netdev_features_t (*ndo_fix_features)(struct net_device *dev,
1215	* netdev_features_t features);
1216	* Adjusts the requested feature flags according to device-specific
1217	* constraints, and returns the resulting flags. Must not modify
1218	* the device state.
1219	*
1220	* int (*ndo_set_features)(struct net_device *dev, netdev_features_t features);
1221	* Called to update device configuration to new features. Passed
1222	* feature set might be less than what was returned by ndo_fix_features()).
1223	* Must return >0 or -errno if it changed dev->features itself.
1224	*
1225	* int (*ndo_fdb_add)(struct ndmsg *ndm, struct nlattr *tb[],
1226	* struct net_device *dev,
1227	* const unsigned char *addr, u16 vid, u16 flags,
1228	* struct netlink_ext_ack *extack);
1229	* Adds an FDB entry to dev for addr.
1230	* int (*ndo_fdb_del)(struct ndmsg *ndm, struct nlattr *tb[],
1231	* struct net_device *dev,
1232	* const unsigned char *addr, u16 vid)
1233	* Deletes the FDB entry from dev coresponding to addr.
1234	* int (*ndo_fdb_del_bulk)(struct nlmsghdr *nlh, struct net_device *dev,
1235	* struct netlink_ext_ack *extack);
1236	* int (*ndo_fdb_dump)(struct sk_buff *skb, struct netlink_callback *cb,
1237	* struct net_device *dev, struct net_device *filter_dev,
1238	* int *idx)
1239	* Used to add FDB entries to dump requests. Implementers should add
1240	* entries to skb and update idx with the number of entries.
1241	*
1242	* int (*ndo_mdb_add)(struct net_device *dev, struct nlattr *tb[],
1243	* u16 nlmsg_flags, struct netlink_ext_ack *extack);
1244	* Adds an MDB entry to dev.
1245	* int (*ndo_mdb_del)(struct net_device *dev, struct nlattr *tb[],
1246	* struct netlink_ext_ack *extack);
1247	* Deletes the MDB entry from dev.
1248	* int (*ndo_mdb_del_bulk)(struct net_device *dev, struct nlattr *tb[],
1249	* struct netlink_ext_ack *extack);
1250	* Bulk deletes MDB entries from dev.
1251	* int (*ndo_mdb_dump)(struct net_device *dev, struct sk_buff *skb,
1252	* struct netlink_callback *cb);
1253	* Dumps MDB entries from dev. The first argument (marker) in the netlink
1254	* callback is used by core rtnetlink code.
1255	*
1256	* int (*ndo_bridge_setlink)(struct net_device *dev, struct nlmsghdr *nlh,
1257	* u16 flags, struct netlink_ext_ack *extack)
1258	* int (*ndo_bridge_getlink)(struct sk_buff *skb, u32 pid, u32 seq,
1259	* struct net_device *dev, u32 filter_mask,
1260	* int nlflags)
1261	* int (*ndo_bridge_dellink)(struct net_device *dev, struct nlmsghdr *nlh,
1262	* u16 flags);
1263	*
1264	* int (*ndo_change_carrier)(struct net_device *dev, bool new_carrier);
1265	* Called to change device carrier. Soft-devices (like dummy, team, etc)
1266	* which do not represent real hardware may define this to allow their
1267	* userspace components to manage their virtual carrier state. Devices
1268	* that determine carrier state from physical hardware properties (eg
1269	* network cables) or protocol-dependent mechanisms (eg
1270	* USB_CDC_NOTIFY_NETWORK_CONNECTION) should NOT implement this function.
1271	*
1272	* int (*ndo_get_phys_port_id)(struct net_device *dev,
1273	* struct netdev_phys_item_id *ppid);
1274	* Called to get ID of physical port of this device. If driver does
1275	* not implement this, it is assumed that the hw is not able to have
1276	* multiple net devices on single physical port.
1277	*
1278	* int (*ndo_get_port_parent_id)(struct net_device *dev,
1279	* struct netdev_phys_item_id *ppid)
1280	* Called to get the parent ID of the physical port of this device.
1281	*
1282	* void* (*ndo_dfwd_add_station)(struct net_device *pdev,
1283	* struct net_device *dev)
1284	* Called by upper layer devices to accelerate switching or other
1285	* station functionality into hardware. 'pdev is the lowerdev
1286	* to use for the offload and 'dev' is the net device that will
1287	* back the offload. Returns a pointer to the private structure
1288	* the upper layer will maintain.
1289	* void (*ndo_dfwd_del_station)(struct net_device *pdev, void *priv)
1290	* Called by upper layer device to delete the station created
1291	* by 'ndo_dfwd_add_station'. 'pdev' is the net device backing
1292	* the station and priv is the structure returned by the add
1293	* operation.
1294	* int (*ndo_set_tx_maxrate)(struct net_device *dev,
1295	* int queue_index, u32 maxrate);
1296	* Called when a user wants to set a max-rate limitation of specific
1297	* TX queue.
1298	* int (*ndo_get_iflink)(const struct net_device *dev);
1299	* Called to get the iflink value of this device.
1300	* int (*ndo_fill_metadata_dst)(struct net_device *dev, struct sk_buff *skb);
1301	* This function is used to get egress tunnel information for given skb.
1302	* This is useful for retrieving outer tunnel header parameters while
1303	* sampling packet.
1304	* void (*ndo_set_rx_headroom)(struct net_device *dev, int needed_headroom);
1305	* This function is used to specify the headroom that the skb must
1306	* consider when allocation skb during packet reception. Setting
1307	* appropriate rx headroom value allows avoiding skb head copy on
1308	* forward. Setting a negative value resets the rx headroom to the
1309	* default value.
1310	* int (*ndo_bpf)(struct net_device *dev, struct netdev_bpf *bpf);
1311	* This function is used to set or query state related to XDP on the
1312	* netdevice and manage BPF offload. See definition of
1313	* enum bpf_netdev_command for details.
1314	* int (*ndo_xdp_xmit)(struct net_device *dev, int n, struct xdp_frame **xdp,
1315	* u32 flags);
1316	* This function is used to submit @n XDP packets for transmit on a
1317	* netdevice. Returns number of frames successfully transmitted, frames
1318	* that got dropped are freed/returned via xdp_return_frame().
1319	* Returns negative number, means general error invoking ndo, meaning
1320	* no frames were xmit'ed and core-caller will free all frames.
1321	* struct net_device *(*ndo_xdp_get_xmit_slave)(struct net_device *dev,
1322	* struct xdp_buff *xdp);
1323	* Get the xmit slave of master device based on the xdp_buff.
1324	* int (*ndo_xsk_wakeup)(struct net_device *dev, u32 queue_id, u32 flags);
1325	* This function is used to wake up the softirq, ksoftirqd or kthread
1326	* responsible for sending and/or receiving packets on a specific
1327	* queue id bound to an AF_XDP socket. The flags field specifies if
1328	* only RX, only Tx, or both should be woken up using the flags
1329	* XDP_WAKEUP_RX and XDP_WAKEUP_TX.
1330	* int (*ndo_tunnel_ctl)(struct net_device *dev, struct ip_tunnel_parm *p,
1331	* int cmd);
1332	* Add, change, delete or get information on an IPv4 tunnel.
1333	* struct net_device *(*ndo_get_peer_dev)(struct net_device *dev);
1334	* If a device is paired with a peer device, return the peer instance.
1335	* The caller must be under RCU read context.
1336	* int (*ndo_fill_forward_path)(struct net_device_path_ctx *ctx, struct net_device_path *path);
1337	* Get the forwarding path to reach the real device from the HW destination address
1338	* ktime_t (*ndo_get_tstamp)(struct net_device *dev,
1339	* const struct skb_shared_hwtstamps *hwtstamps,
1340	* bool cycles);
1341	* Get hardware timestamp based on normal/adjustable time or free running
1342	* cycle counter. This function is required if physical clock supports a
1343	* free running cycle counter.
1344	*
1345	* int (*ndo_hwtstamp_get)(struct net_device *dev,
1346	* struct kernel_hwtstamp_config *kernel_config);
1347	* Get the currently configured hardware timestamping parameters for the
1348	* NIC device.
1349	*
1350	* int (*ndo_hwtstamp_set)(struct net_device *dev,
1351	* struct kernel_hwtstamp_config *kernel_config,
1352	* struct netlink_ext_ack *extack);
1353	* Change the hardware timestamping parameters for NIC device.
1354	*/
1355	struct net_device_ops {
1356	int (*ndo_init)(struct net_device *dev);
1357	void (*ndo_uninit)(struct net_device *dev);
1358	int (*ndo_open)(struct net_device *dev);
1359	int (*ndo_stop)(struct net_device *dev);
1360	netdev_tx_t (*ndo_start_xmit)(struct sk_buff *skb,
1361	struct net_device *dev);
1362	netdev_features_t (*ndo_features_check)(struct sk_buff *skb,
1363	struct net_device *dev,
1364	netdev_features_t features);
1365	u16 (*ndo_select_queue)(struct net_device *dev,
1366	struct sk_buff *skb,
1367	struct net_device *sb_dev);
1368	void (*ndo_change_rx_flags)(struct net_device *dev,
1369	int flags);
1370	void (*ndo_set_rx_mode)(struct net_device *dev);
1371	int (*ndo_set_mac_address)(struct net_device *dev,
1372	void *addr);
1373	int (*ndo_validate_addr)(struct net_device *dev);
1374	int (*ndo_do_ioctl)(struct net_device *dev,
1375	struct ifreq *ifr, int cmd);
1376	int (*ndo_eth_ioctl)(struct net_device *dev,
1377	struct ifreq *ifr, int cmd);
1378	int (*ndo_siocbond)(struct net_device *dev,
1379	struct ifreq *ifr, int cmd);
1380	int (*ndo_siocwandev)(struct net_device *dev,
1381	struct if_settings *ifs);
1382	int (*ndo_siocdevprivate)(struct net_device *dev,
1383	struct ifreq *ifr,
1384	void __user *data, int cmd);
1385	int (*ndo_set_config)(struct net_device *dev,
1386	struct ifmap *map);
1387	int (*ndo_change_mtu)(struct net_device *dev,
1388	int new_mtu);
1389	int (*ndo_neigh_setup)(struct net_device *dev,
1390	struct neigh_parms *);
1391	void (*ndo_tx_timeout) (struct net_device *dev,
1392	unsigned int txqueue);
1393
1394	void (*ndo_get_stats64)(struct net_device *dev,
1395	struct rtnl_link_stats64 *storage);
1396	bool (*ndo_has_offload_stats)(const struct net_device *dev, int attr_id);
1397	int (*ndo_get_offload_stats)(int attr_id,
1398	const struct net_device *dev,
1399	void *attr_data);
1400	struct net_device_stats* (*ndo_get_stats)(struct net_device *dev);
1401
1402	int (*ndo_vlan_rx_add_vid)(struct net_device *dev,
1403	__be16 proto, u16 vid);
1404	int (*ndo_vlan_rx_kill_vid)(struct net_device *dev,
1405	__be16 proto, u16 vid);
1406	#ifdef CONFIG_NET_POLL_CONTROLLER
1407	void (*ndo_poll_controller)(struct net_device *dev);
1408	int (*ndo_netpoll_setup)(struct net_device *dev,
1409	struct netpoll_info *info);
1410	void (*ndo_netpoll_cleanup)(struct net_device *dev);
1411	#endif
1412	int (*ndo_set_vf_mac)(struct net_device *dev,
1413	int queue, u8 *mac);
1414	int (*ndo_set_vf_vlan)(struct net_device *dev,
1415	int queue, u16 vlan,
1416	u8 qos, __be16 proto);
1417	int (*ndo_set_vf_rate)(struct net_device *dev,
1418	int vf, int min_tx_rate,
1419	int max_tx_rate);
1420	int (*ndo_set_vf_spoofchk)(struct net_device *dev,
1421	int vf, bool setting);
1422	int (*ndo_set_vf_trust)(struct net_device *dev,
1423	int vf, bool setting);
1424	int (*ndo_get_vf_config)(struct net_device *dev,
1425	int vf,
1426	struct ifla_vf_info *ivf);
1427	int (*ndo_set_vf_link_state)(struct net_device *dev,
1428	int vf, int link_state);
1429	int (*ndo_get_vf_stats)(struct net_device *dev,
1430	int vf,
1431	struct ifla_vf_stats
1432	*vf_stats);
1433	int (*ndo_set_vf_port)(struct net_device *dev,
1434	int vf,
1435	struct nlattr *port[]);
1436	int (*ndo_get_vf_port)(struct net_device *dev,
1437	int vf, struct sk_buff *skb);
1438	int (*ndo_get_vf_guid)(struct net_device *dev,
1439	int vf,
1440	struct ifla_vf_guid *node_guid,
1441	struct ifla_vf_guid *port_guid);
1442	int (*ndo_set_vf_guid)(struct net_device *dev,
1443	int vf, u64 guid,
1444	int guid_type);
1445	int (*ndo_set_vf_rss_query_en)(
1446	struct net_device *dev,
1447	int vf, bool setting);
1448	int (*ndo_setup_tc)(struct net_device *dev,
1449	enum tc_setup_type type,
1450	void *type_data);
1451	#if IS_ENABLED(CONFIG_FCOE)
1452	int (*ndo_fcoe_enable)(struct net_device *dev);
1453	int (*ndo_fcoe_disable)(struct net_device *dev);
1454	int (*ndo_fcoe_ddp_setup)(struct net_device *dev,
1455	u16 xid,
1456	struct scatterlist *sgl,
1457	unsigned int sgc);
1458	int (*ndo_fcoe_ddp_done)(struct net_device *dev,
1459	u16 xid);
1460	int (*ndo_fcoe_ddp_target)(struct net_device *dev,
1461	u16 xid,
1462	struct scatterlist *sgl,
1463	unsigned int sgc);
1464	int (*ndo_fcoe_get_hbainfo)(struct net_device *dev,
1465	struct netdev_fcoe_hbainfo *hbainfo);
1466	#endif
1467
1468	#if IS_ENABLED(CONFIG_LIBFCOE)
1469	#define NETDEV_FCOE_WWNN 0
1470	#define NETDEV_FCOE_WWPN 1
1471	int (*ndo_fcoe_get_wwn)(struct net_device *dev,
1472	u64 *wwn, int type);
1473	#endif
1474
1475	#ifdef CONFIG_RFS_ACCEL
1476	int (*ndo_rx_flow_steer)(struct net_device *dev,
1477	const struct sk_buff *skb,
1478	u16 rxq_index,
1479	u32 flow_id);
1480	#endif
1481	int (*ndo_add_slave)(struct net_device *dev,
1482	struct net_device *slave_dev,
1483	struct netlink_ext_ack *extack);
1484	int (*ndo_del_slave)(struct net_device *dev,
1485	struct net_device *slave_dev);
1486	struct net_device* (*ndo_get_xmit_slave)(struct net_device *dev,
1487	struct sk_buff *skb,
1488	bool all_slaves);
1489	struct net_device* (*ndo_sk_get_lower_dev)(struct net_device *dev,
1490	struct sock *sk);
1491	netdev_features_t (*ndo_fix_features)(struct net_device *dev,
1492	netdev_features_t features);
1493	int (*ndo_set_features)(struct net_device *dev,
1494	netdev_features_t features);
1495	int (*ndo_neigh_construct)(struct net_device *dev,
1496	struct neighbour *n);
1497	void (*ndo_neigh_destroy)(struct net_device *dev,
1498	struct neighbour *n);
1499
1500	int (*ndo_fdb_add)(struct ndmsg *ndm,
1501	struct nlattr *tb[],
1502	struct net_device *dev,
1503	const unsigned char *addr,
1504	u16 vid,
1505	u16 flags,
1506	struct netlink_ext_ack *extack);
1507	int (*ndo_fdb_del)(struct ndmsg *ndm,
1508	struct nlattr *tb[],
1509	struct net_device *dev,
1510	const unsigned char *addr,
1511	u16 vid, struct netlink_ext_ack *extack);
1512	int (*ndo_fdb_del_bulk)(struct nlmsghdr *nlh,
1513	struct net_device *dev,
1514	struct netlink_ext_ack *extack);
1515	int (*ndo_fdb_dump)(struct sk_buff *skb,
1516	struct netlink_callback *cb,
1517	struct net_device *dev,
1518	struct net_device *filter_dev,
1519	int *idx);
1520	int (*ndo_fdb_get)(struct sk_buff *skb,
1521	struct nlattr *tb[],
1522	struct net_device *dev,
1523	const unsigned char *addr,
1524	u16 vid, u32 portid, u32 seq,
1525	struct netlink_ext_ack *extack);
1526	int (*ndo_mdb_add)(struct net_device *dev,
1527	struct nlattr *tb[],
1528	u16 nlmsg_flags,
1529	struct netlink_ext_ack *extack);
1530	int (*ndo_mdb_del)(struct net_device *dev,
1531	struct nlattr *tb[],
1532	struct netlink_ext_ack *extack);
1533	int (*ndo_mdb_del_bulk)(struct net_device *dev,
1534	struct nlattr *tb[],
1535	struct netlink_ext_ack *extack);
1536	int (*ndo_mdb_dump)(struct net_device *dev,
1537	struct sk_buff *skb,
1538	struct netlink_callback *cb);
1539	int (*ndo_mdb_get)(struct net_device *dev,
1540	struct nlattr *tb[], u32 portid,
1541	u32 seq,
1542	struct netlink_ext_ack *extack);
1543	int (*ndo_bridge_setlink)(struct net_device *dev,
1544	struct nlmsghdr *nlh,
1545	u16 flags,
1546	struct netlink_ext_ack *extack);
1547	int (*ndo_bridge_getlink)(struct sk_buff *skb,
1548	u32 pid, u32 seq,
1549	struct net_device *dev,
1550	u32 filter_mask,
1551	int nlflags);
1552	int (*ndo_bridge_dellink)(struct net_device *dev,
1553	struct nlmsghdr *nlh,
1554	u16 flags);
1555	int (*ndo_change_carrier)(struct net_device *dev,
1556	bool new_carrier);
1557	int (*ndo_get_phys_port_id)(struct net_device *dev,
1558	struct netdev_phys_item_id *ppid);
1559	int (*ndo_get_port_parent_id)(struct net_device *dev,
1560	struct netdev_phys_item_id *ppid);
1561	int (*ndo_get_phys_port_name)(struct net_device *dev,
1562	char *name, size_t len);
1563	void* (*ndo_dfwd_add_station)(struct net_device *pdev,
1564	struct net_device *dev);
1565	void (*ndo_dfwd_del_station)(struct net_device *pdev,
1566	void *priv);
1567
1568	int (*ndo_set_tx_maxrate)(struct net_device *dev,
1569	int queue_index,
1570	u32 maxrate);
1571	int (*ndo_get_iflink)(const struct net_device *dev);
1572	int (*ndo_fill_metadata_dst)(struct net_device *dev,
1573	struct sk_buff *skb);
1574	void (*ndo_set_rx_headroom)(struct net_device *dev,
1575	int needed_headroom);
1576	int (*ndo_bpf)(struct net_device *dev,
1577	struct netdev_bpf *bpf);
1578	int (*ndo_xdp_xmit)(struct net_device *dev, int n,
1579	struct xdp_frame **xdp,
1580	u32 flags);
1581	struct net_device * (*ndo_xdp_get_xmit_slave)(struct net_device *dev,
1582	struct xdp_buff *xdp);
1583	int (*ndo_xsk_wakeup)(struct net_device *dev,
1584	u32 queue_id, u32 flags);
1585	int (*ndo_tunnel_ctl)(struct net_device *dev,
1586	struct ip_tunnel_parm *p, int cmd);
1587	struct net_device * (*ndo_get_peer_dev)(struct net_device *dev);
1588	int (*ndo_fill_forward_path)(struct net_device_path_ctx *ctx,
1589	struct net_device_path *path);
1590	ktime_t (*ndo_get_tstamp)(struct net_device *dev,
1591	const struct skb_shared_hwtstamps *hwtstamps,
1592	bool cycles);
1593	int (*ndo_hwtstamp_get)(struct net_device *dev,
1594	struct kernel_hwtstamp_config *kernel_config);
1595	int (*ndo_hwtstamp_set)(struct net_device *dev,
1596	struct kernel_hwtstamp_config *kernel_config,
1597	struct netlink_ext_ack *extack);
1598	};
1599
1600	/**
1601	* enum netdev_priv_flags - &struct net_device priv_flags
1602	*
1603	* These are the &struct net_device, they are only set internally
1604	* by drivers and used in the kernel. These flags are invisible to
1605	* userspace; this means that the order of these flags can change
1606	* during any kernel release.
1607	*
1608	* You should have a pretty good reason to be extending these flags.
1609	*
1610	* @IFF_802_1Q_VLAN: 802.1Q VLAN device
1611	* @IFF_EBRIDGE: Ethernet bridging device
1612	* @IFF_BONDING: bonding master or slave
1613	* @IFF_ISATAP: ISATAP interface (RFC4214)
1614	* @IFF_WAN_HDLC: WAN HDLC device
1615	* @IFF_XMIT_DST_RELEASE: dev_hard_start_xmit() is allowed to
1616	* release skb->dst
1617	* @IFF_DONT_BRIDGE: disallow bridging this ether dev
1618	* @IFF_DISABLE_NETPOLL: disable netpoll at run-time
1619	* @IFF_MACVLAN_PORT: device used as macvlan port
1620	* @IFF_BRIDGE_PORT: device used as bridge port
1621	* @IFF_OVS_DATAPATH: device used as Open vSwitch datapath port
1622	* @IFF_TX_SKB_SHARING: The interface supports sharing skbs on transmit
1623	* @IFF_UNICAST_FLT: Supports unicast filtering
1624	* @IFF_TEAM_PORT: device used as team port
1625	* @IFF_SUPP_NOFCS: device supports sending custom FCS
1626	* @IFF_LIVE_ADDR_CHANGE: device supports hardware address
1627	* change when it's running
1628	* @IFF_MACVLAN: Macvlan device
1629	* @IFF_XMIT_DST_RELEASE_PERM: IFF_XMIT_DST_RELEASE not taking into account
1630	* underlying stacked devices
1631	* @IFF_L3MDEV_MASTER: device is an L3 master device
1632	* @IFF_NO_QUEUE: device can run without qdisc attached
1633	* @IFF_OPENVSWITCH: device is a Open vSwitch master
1634	* @IFF_L3MDEV_SLAVE: device is enslaved to an L3 master device
1635	* @IFF_TEAM: device is a team device
1636	* @IFF_RXFH_CONFIGURED: device has had Rx Flow indirection table configured
1637	* @IFF_PHONY_HEADROOM: the headroom value is controlled by an external
1638	* entity (i.e. the master device for bridged veth)
1639	* @IFF_MACSEC: device is a MACsec device
1640	* @IFF_NO_RX_HANDLER: device doesn't support the rx_handler hook
1641	* @IFF_FAILOVER: device is a failover master device
1642	* @IFF_FAILOVER_SLAVE: device is lower dev of a failover master device
1643	* @IFF_L3MDEV_RX_HANDLER: only invoke the rx handler of L3 master device
1644	* @IFF_NO_ADDRCONF: prevent ipv6 addrconf
1645	* @IFF_TX_SKB_NO_LINEAR: device/driver is capable of xmitting frames with
1646	* skb_headlen(skb) == 0 (data starts from frag0)
1647	* @IFF_CHANGE_PROTO_DOWN: device supports setting carrier via IFLA_PROTO_DOWN
1648	* @IFF_SEE_ALL_HWTSTAMP_REQUESTS: device wants to see calls to
1649	* ndo_hwtstamp_set() for all timestamp requests regardless of source,
1650	* even if those aren't HWTSTAMP_SOURCE_NETDEV.
1651	*/
1652	enum netdev_priv_flags {
1653	IFF_802_1Q_VLAN = 1<<0,
1654	IFF_EBRIDGE = 1<<1,
1655	IFF_BONDING = 1<<2,
1656	IFF_ISATAP = 1<<3,
1657	IFF_WAN_HDLC = 1<<4,
1658	IFF_XMIT_DST_RELEASE = 1<<5,
1659	IFF_DONT_BRIDGE = 1<<6,
1660	IFF_DISABLE_NETPOLL = 1<<7,
1661	IFF_MACVLAN_PORT = 1<<8,
1662	IFF_BRIDGE_PORT = 1<<9,
1663	IFF_OVS_DATAPATH = 1<<10,
1664	IFF_TX_SKB_SHARING = 1<<11,
1665	IFF_UNICAST_FLT = 1<<12,
1666	IFF_TEAM_PORT = 1<<13,
1667	IFF_SUPP_NOFCS = 1<<14,
1668	IFF_LIVE_ADDR_CHANGE = 1<<15,
1669	IFF_MACVLAN = 1<<16,
1670	IFF_XMIT_DST_RELEASE_PERM = 1<<17,
1671	IFF_L3MDEV_MASTER = 1<<18,
1672	IFF_NO_QUEUE = 1<<19,
1673	IFF_OPENVSWITCH = 1<<20,
1674	IFF_L3MDEV_SLAVE = 1<<21,
1675	IFF_TEAM = 1<<22,
1676	IFF_RXFH_CONFIGURED = 1<<23,
1677	IFF_PHONY_HEADROOM = 1<<24,
1678	IFF_MACSEC = 1<<25,
1679	IFF_NO_RX_HANDLER = 1<<26,
1680	IFF_FAILOVER = 1<<27,
1681	IFF_FAILOVER_SLAVE = 1<<28,
1682	IFF_L3MDEV_RX_HANDLER = 1<<29,
1683	IFF_NO_ADDRCONF = BIT_ULL(30),
1684	IFF_TX_SKB_NO_LINEAR = BIT_ULL(31),
1685	IFF_CHANGE_PROTO_DOWN = BIT_ULL(32),
1686	IFF_SEE_ALL_HWTSTAMP_REQUESTS = BIT_ULL(33),
1687	};
1688
1689	#define IFF_802_1Q_VLAN IFF_802_1Q_VLAN
1690	#define IFF_EBRIDGE IFF_EBRIDGE
1691	#define IFF_BONDING IFF_BONDING
1692	#define IFF_ISATAP IFF_ISATAP
1693	#define IFF_WAN_HDLC IFF_WAN_HDLC
1694	#define IFF_XMIT_DST_RELEASE IFF_XMIT_DST_RELEASE
1695	#define IFF_DONT_BRIDGE IFF_DONT_BRIDGE
1696	#define IFF_DISABLE_NETPOLL IFF_DISABLE_NETPOLL
1697	#define IFF_MACVLAN_PORT IFF_MACVLAN_PORT
1698	#define IFF_BRIDGE_PORT IFF_BRIDGE_PORT
1699	#define IFF_OVS_DATAPATH IFF_OVS_DATAPATH
1700	#define IFF_TX_SKB_SHARING IFF_TX_SKB_SHARING
1701	#define IFF_UNICAST_FLT IFF_UNICAST_FLT
1702	#define IFF_TEAM_PORT IFF_TEAM_PORT
1703	#define IFF_SUPP_NOFCS IFF_SUPP_NOFCS
1704	#define IFF_LIVE_ADDR_CHANGE IFF_LIVE_ADDR_CHANGE
1705	#define IFF_MACVLAN IFF_MACVLAN
1706	#define IFF_XMIT_DST_RELEASE_PERM IFF_XMIT_DST_RELEASE_PERM
1707	#define IFF_L3MDEV_MASTER IFF_L3MDEV_MASTER
1708	#define IFF_NO_QUEUE IFF_NO_QUEUE
1709	#define IFF_OPENVSWITCH IFF_OPENVSWITCH
1710	#define IFF_L3MDEV_SLAVE IFF_L3MDEV_SLAVE
1711	#define IFF_TEAM IFF_TEAM
1712	#define IFF_RXFH_CONFIGURED IFF_RXFH_CONFIGURED
1713	#define IFF_PHONY_HEADROOM IFF_PHONY_HEADROOM
1714	#define IFF_MACSEC IFF_MACSEC
1715	#define IFF_NO_RX_HANDLER IFF_NO_RX_HANDLER
1716	#define IFF_FAILOVER IFF_FAILOVER
1717	#define IFF_FAILOVER_SLAVE IFF_FAILOVER_SLAVE
1718	#define IFF_L3MDEV_RX_HANDLER IFF_L3MDEV_RX_HANDLER
1719	#define IFF_TX_SKB_NO_LINEAR IFF_TX_SKB_NO_LINEAR
1720
1721	/* Specifies the type of the struct net_device::ml_priv pointer */
1722	enum netdev_ml_priv_type {
1723	ML_PRIV_NONE,
1724	ML_PRIV_CAN,
1725	};
1726
1727	enum netdev_stat_type {
1728	NETDEV_PCPU_STAT_NONE,
1729	NETDEV_PCPU_STAT_LSTATS, /* struct pcpu_lstats */
1730	NETDEV_PCPU_STAT_TSTATS, /* struct pcpu_sw_netstats */
1731	NETDEV_PCPU_STAT_DSTATS, /* struct pcpu_dstats */
1732	};
1733
1734	enum netdev_reg_state {
1735	NETREG_UNINITIALIZED = 0,
1736	NETREG_REGISTERED, /* completed register_netdevice */
1737	NETREG_UNREGISTERING, /* called unregister_netdevice */
1738	NETREG_UNREGISTERED, /* completed unregister todo */
1739	NETREG_RELEASED, /* called free_netdev */
1740	NETREG_DUMMY, /* dummy device for NAPI poll */
1741	};
1742
1743	/**
1744	* struct net_device - The DEVICE structure.
1745	*
1746	* Actually, this whole structure is a big mistake. It mixes I/O
1747	* data with strictly "high-level" data, and it has to know about
1748	* almost every data structure used in the INET module.
1749	*
1750	* @name: This is the first field of the "visible" part of this structure
1751	* (i.e. as seen by users in the "Space.c" file). It is the name
1752	* of the interface.
1753	*
1754	* @name_node: Name hashlist node
1755	* @ifalias: SNMP alias
1756	* @mem_end: Shared memory end
1757	* @mem_start: Shared memory start
1758	* @base_addr: Device I/O address
1759	* @irq: Device IRQ number
1760	*
1761	* @state: Generic network queuing layer state, see netdev_state_t
1762	* @dev_list: The global list of network devices
1763	* @napi_list: List entry used for polling NAPI devices
1764	* @unreg_list: List entry when we are unregistering the
1765	* device; see the function unregister_netdev
1766	* @close_list: List entry used when we are closing the device
1767	* @ptype_all: Device-specific packet handlers for all protocols
1768	* @ptype_specific: Device-specific, protocol-specific packet handlers
1769	*
1770	* @adj_list: Directly linked devices, like slaves for bonding
1771	* @features: Currently active device features
1772	* @hw_features: User-changeable features
1773	*
1774	* @wanted_features: User-requested features
1775	* @vlan_features: Mask of features inheritable by VLAN devices
1776	*
1777	* @hw_enc_features: Mask of features inherited by encapsulating devices
1778	* This field indicates what encapsulation
1779	* offloads the hardware is capable of doing,
1780	* and drivers will need to set them appropriately.
1781	*
1782	* @mpls_features: Mask of features inheritable by MPLS
1783	* @gso_partial_features: value(s) from NETIF_F_GSO\*
1784	*
1785	* @ifindex: interface index
1786	* @group: The group the device belongs to
1787	*
1788	* @stats: Statistics struct, which was left as a legacy, use
1789	* rtnl_link_stats64 instead
1790	*
1791	* @core_stats: core networking counters,
1792	* do not use this in drivers
1793	* @carrier_up_count: Number of times the carrier has been up
1794	* @carrier_down_count: Number of times the carrier has been down
1795	*
1796	* @wireless_handlers: List of functions to handle Wireless Extensions,
1797	* instead of ioctl,
1798	* see <net/iw_handler.h> for details.
1799	* @wireless_data: Instance data managed by the core of wireless extensions
1800	*
1801	* @netdev_ops: Includes several pointers to callbacks,
1802	* if one wants to override the ndo_*() functions
1803	* @xdp_metadata_ops: Includes pointers to XDP metadata callbacks.
1804	* @xsk_tx_metadata_ops: Includes pointers to AF_XDP TX metadata callbacks.
1805	* @ethtool_ops: Management operations
1806	* @l3mdev_ops: Layer 3 master device operations
1807	* @ndisc_ops: Includes callbacks for different IPv6 neighbour
1808	* discovery handling. Necessary for e.g. 6LoWPAN.
1809	* @xfrmdev_ops: Transformation offload operations
1810	* @tlsdev_ops: Transport Layer Security offload operations
1811	* @header_ops: Includes callbacks for creating,parsing,caching,etc
1812	* of Layer 2 headers.
1813	*
1814	* @flags: Interface flags (a la BSD)
1815	* @xdp_features: XDP capability supported by the device
1816	* @priv_flags: Like 'flags' but invisible to userspace,
1817	* see if.h for the definitions
1818	* @gflags: Global flags ( kept as legacy )
1819	* @padded: How much padding added by alloc_netdev()
1820	* @operstate: RFC2863 operstate
1821	* @link_mode: Mapping policy to operstate
1822	* @if_port: Selectable AUI, TP, ...
1823	* @dma: DMA channel
1824	* @mtu: Interface MTU value
1825	* @min_mtu: Interface Minimum MTU value
1826	* @max_mtu: Interface Maximum MTU value
1827	* @type: Interface hardware type
1828	* @hard_header_len: Maximum hardware header length.
1829	* @min_header_len: Minimum hardware header length
1830	*
1831	* @needed_headroom: Extra headroom the hardware may need, but not in all
1832	* cases can this be guaranteed
1833	* @needed_tailroom: Extra tailroom the hardware may need, but not in all
1834	* cases can this be guaranteed. Some cases also use
1835	* LL_MAX_HEADER instead to allocate the skb
1836	*
1837	* interface address info:
1838	*
1839	* @perm_addr: Permanent hw address
1840	* @addr_assign_type: Hw address assignment type
1841	* @addr_len: Hardware address length
1842	* @upper_level: Maximum depth level of upper devices.
1843	* @lower_level: Maximum depth level of lower devices.
1844	* @neigh_priv_len: Used in neigh_alloc()
1845	* @dev_id: Used to differentiate devices that share
1846	* the same link layer address
1847	* @dev_port: Used to differentiate devices that share
1848	* the same function
1849	* @addr_list_lock: XXX: need comments on this one
1850	* @name_assign_type: network interface name assignment type
1851	* @uc_promisc: Counter that indicates promiscuous mode
1852	* has been enabled due to the need to listen to
1853	* additional unicast addresses in a device that
1854	* does not implement ndo_set_rx_mode()
1855	* @uc: unicast mac addresses
1856	* @mc: multicast mac addresses
1857	* @dev_addrs: list of device hw addresses
1858	* @queues_kset: Group of all Kobjects in the Tx and RX queues
1859	* @promiscuity: Number of times the NIC is told to work in
1860	* promiscuous mode; if it becomes 0 the NIC will
1861	* exit promiscuous mode
1862	* @allmulti: Counter, enables or disables allmulticast mode
1863	*
1864	* @vlan_info: VLAN info
1865	* @dsa_ptr: dsa specific data
1866	* @tipc_ptr: TIPC specific data
1867	* @atalk_ptr: AppleTalk link
1868	* @ip_ptr: IPv4 specific data
1869	* @ip6_ptr: IPv6 specific data
1870	* @ax25_ptr: AX.25 specific data
1871	* @ieee80211_ptr: IEEE 802.11 specific data, assign before registering
1872	* @ieee802154_ptr: IEEE 802.15.4 low-rate Wireless Personal Area Network
1873	* device struct
1874	* @mpls_ptr: mpls_dev struct pointer
1875	* @mctp_ptr: MCTP specific data
1876	*
1877	* @dev_addr: Hw address (before bcast,
1878	* because most packets are unicast)
1879	*
1880	* @_rx: Array of RX queues
1881	* @num_rx_queues: Number of RX queues
1882	* allocated at register_netdev() time
1883	* @real_num_rx_queues: Number of RX queues currently active in device
1884	* @xdp_prog: XDP sockets filter program pointer
1885	* @gro_flush_timeout: timeout for GRO layer in NAPI
1886	* @napi_defer_hard_irqs: If not zero, provides a counter that would
1887	* allow to avoid NIC hard IRQ, on busy queues.
1888	*
1889	* @rx_handler: handler for received packets
1890	* @rx_handler_data: XXX: need comments on this one
1891	* @tcx_ingress: BPF & clsact qdisc specific data for ingress processing
1892	* @ingress_queue: XXX: need comments on this one
1893	* @nf_hooks_ingress: netfilter hooks executed for ingress packets
1894	* @broadcast: hw bcast address
1895	*
1896	* @rx_cpu_rmap: CPU reverse-mapping for RX completion interrupts,
1897	* indexed by RX queue number. Assigned by driver.
1898	* This must only be set if the ndo_rx_flow_steer
1899	* operation is defined
1900	* @index_hlist: Device index hash chain
1901	*
1902	* @_tx: Array of TX queues
1903	* @num_tx_queues: Number of TX queues allocated at alloc_netdev_mq() time
1904	* @real_num_tx_queues: Number of TX queues currently active in device
1905	* @qdisc: Root qdisc from userspace point of view
1906	* @tx_queue_len: Max frames per queue allowed
1907	* @tx_global_lock: XXX: need comments on this one
1908	* @xdp_bulkq: XDP device bulk queue
1909	* @xps_maps: all CPUs/RXQs maps for XPS device
1910	*
1911	* @xps_maps: XXX: need comments on this one
1912	* @tcx_egress: BPF & clsact qdisc specific data for egress processing
1913	* @nf_hooks_egress: netfilter hooks executed for egress packets
1914	* @qdisc_hash: qdisc hash table
1915	* @watchdog_timeo: Represents the timeout that is used by
1916	* the watchdog (see dev_watchdog())
1917	* @watchdog_timer: List of timers
1918	*
1919	* @proto_down_reason: reason a netdev interface is held down
1920	* @pcpu_refcnt: Number of references to this device
1921	* @dev_refcnt: Number of references to this device
1922	* @refcnt_tracker: Tracker directory for tracked references to this device
1923	* @todo_list: Delayed register/unregister
1924	* @link_watch_list: XXX: need comments on this one
1925	*
1926	* @reg_state: Register/unregister state machine
1927	* @dismantle: Device is going to be freed
1928	* @rtnl_link_state: This enum represents the phases of creating
1929	* a new link
1930	*
1931	* @needs_free_netdev: Should unregister perform free_netdev?
1932	* @priv_destructor: Called from unregister
1933	* @npinfo: XXX: need comments on this one
1934	* @nd_net: Network namespace this network device is inside
1935	*
1936	* @ml_priv: Mid-layer private
1937	* @ml_priv_type: Mid-layer private type
1938	*
1939	* @pcpu_stat_type: Type of device statistics which the core should
1940	* allocate/free: none, lstats, tstats, dstats. none
1941	* means the driver is handling statistics allocation/
1942	* freeing internally.
1943	* @lstats: Loopback statistics: packets, bytes
1944	* @tstats: Tunnel statistics: RX/TX packets, RX/TX bytes
1945	* @dstats: Dummy statistics: RX/TX/drop packets, RX/TX bytes
1946	*
1947	* @garp_port: GARP
1948	* @mrp_port: MRP
1949	*
1950	* @dm_private: Drop monitor private
1951	*
1952	* @dev: Class/net/name entry
1953	* @sysfs_groups: Space for optional device, statistics and wireless
1954	* sysfs groups
1955	*
1956	* @sysfs_rx_queue_group: Space for optional per-rx queue attributes
1957	* @rtnl_link_ops: Rtnl_link_ops
1958	* @stat_ops: Optional ops for queue-aware statistics
1959	*
1960	* @gso_max_size: Maximum size of generic segmentation offload
1961	* @tso_max_size: Device (as in HW) limit on the max TSO request size
1962	* @gso_max_segs: Maximum number of segments that can be passed to the
1963	* NIC for GSO
1964	* @tso_max_segs: Device (as in HW) limit on the max TSO segment count
1965	* @gso_ipv4_max_size: Maximum size of generic segmentation offload,
1966	* for IPv4.
1967	*
1968	* @dcbnl_ops: Data Center Bridging netlink ops
1969	* @num_tc: Number of traffic classes in the net device
1970	* @tc_to_txq: XXX: need comments on this one
1971	* @prio_tc_map: XXX: need comments on this one
1972	*
1973	* @fcoe_ddp_xid: Max exchange id for FCoE LRO by ddp
1974	*
1975	* @priomap: XXX: need comments on this one
1976	* @phydev: Physical device may attach itself
1977	* for hardware timestamping
1978	* @sfp_bus: attached &struct sfp_bus structure.
1979	*
1980	* @qdisc_tx_busylock: lockdep class annotating Qdisc->busylock spinlock
1981	*
1982	* @proto_down: protocol port state information can be sent to the
1983	* switch driver and used to set the phys state of the
1984	* switch port.
1985	*
1986	* @wol_enabled: Wake-on-LAN is enabled
1987	*
1988	* @threaded: napi threaded mode is enabled
1989	*
1990	* @net_notifier_list: List of per-net netdev notifier block
1991	* that follow this device when it is moved
1992	* to another network namespace.
1993	*
1994	* @macsec_ops: MACsec offloading ops
1995	*
1996	* @udp_tunnel_nic_info: static structure describing the UDP tunnel
1997	* offload capabilities of the device
1998	* @udp_tunnel_nic: UDP tunnel offload state
1999	* @xdp_state: stores info on attached XDP BPF programs
2000	*
2001	* @nested_level: Used as a parameter of spin_lock_nested() of
2002	* dev->addr_list_lock.
2003	* @unlink_list: As netif_addr_lock() can be called recursively,
2004	* keep a list of interfaces to be deleted.
2005	* @gro_max_size: Maximum size of aggregated packet in generic
2006	* receive offload (GRO)
2007	* @gro_ipv4_max_size: Maximum size of aggregated packet in generic
2008	* receive offload (GRO), for IPv4.
2009	* @xdp_zc_max_segs: Maximum number of segments supported by AF_XDP
2010	* zero copy driver
2011	*
2012	* @dev_addr_shadow: Copy of @dev_addr to catch direct writes.
2013	* @linkwatch_dev_tracker: refcount tracker used by linkwatch.
2014	* @watchdog_dev_tracker: refcount tracker used by watchdog.
2015	* @dev_registered_tracker: tracker for reference held while
2016	* registered
2017	* @offload_xstats_l3: L3 HW stats for this netdevice.
2018	*
2019	* @devlink_port: Pointer to related devlink port structure.
2020	* Assigned by a driver before netdev registration using
2021	* SET_NETDEV_DEVLINK_PORT macro. This pointer is static
2022	* during the time netdevice is registered.
2023	*
2024	* @dpll_pin: Pointer to the SyncE source pin of a DPLL subsystem,
2025	* where the clock is recovered.
2026	*
2027	* FIXME: cleanup struct net_device such that network protocol info
2028	* moves out.
2029	*/
2030
2031	struct net_device {
2032	/* Cacheline organization can be found documented in
2033	* Documentation/networking/net_cachelines/net_device.rst.
2034	* Please update the document when adding new fields.
2035	*/
2036
2037	/* TX read-mostly hotpath */
2038	__cacheline_group_begin(net_device_read_tx);
2039	unsigned long long priv_flags;
2040	const struct net_device_ops *netdev_ops;
2041	const struct header_ops *header_ops;
2042	struct netdev_queue *_tx;
2043	netdev_features_t gso_partial_features;
2044	unsigned int real_num_tx_queues;
2045	unsigned int gso_max_size;
2046	unsigned int gso_ipv4_max_size;
2047	u16 gso_max_segs;
2048	s16 num_tc;
2049	/* Note : dev->mtu is often read without holding a lock.
2050	* Writers usually hold RTNL.
2051	* It is recommended to use READ_ONCE() to annotate the reads,
2052	* and to use WRITE_ONCE() to annotate the writes.
2053	*/
2054	unsigned int mtu;
2055	unsigned short needed_headroom;
2056	struct netdev_tc_txq tc_to_txq[TC_MAX_QUEUE];
2057	#ifdef CONFIG_XPS
2058	struct xps_dev_maps __rcu *xps_maps[XPS_MAPS_MAX];
2059	#endif
2060	#ifdef CONFIG_NETFILTER_EGRESS
2061	struct nf_hook_entries __rcu *nf_hooks_egress;
2062	#endif
2063	#ifdef CONFIG_NET_XGRESS
2064	struct bpf_mprog_entry __rcu *tcx_egress;
2065	#endif
2066	__cacheline_group_end(net_device_read_tx);
2067
2068	/* TXRX read-mostly hotpath */
2069	__cacheline_group_begin(net_device_read_txrx);
2070	union {
2071	struct pcpu_lstats __percpu *lstats;
2072	struct pcpu_sw_netstats __percpu *tstats;
2073	struct pcpu_dstats __percpu *dstats;
2074	};
2075	unsigned long state;
2076	unsigned int flags;
2077	unsigned short hard_header_len;
2078	netdev_features_t features;
2079	struct inet6_dev __rcu *ip6_ptr;
2080	__cacheline_group_end(net_device_read_txrx);
2081
2082	/* RX read-mostly hotpath */
2083	__cacheline_group_begin(net_device_read_rx);
2084	struct bpf_prog __rcu *xdp_prog;
2085	struct list_head ptype_specific;
2086	int ifindex;
2087	unsigned int real_num_rx_queues;
2088	struct netdev_rx_queue *_rx;
2089	unsigned long gro_flush_timeout;
2090	int napi_defer_hard_irqs;
2091	unsigned int gro_max_size;
2092	unsigned int gro_ipv4_max_size;
2093	rx_handler_func_t __rcu *rx_handler;
2094	void __rcu *rx_handler_data;
2095	possible_net_t nd_net;
2096	#ifdef CONFIG_NETPOLL
2097	struct netpoll_info __rcu *npinfo;
2098	#endif
2099	#ifdef CONFIG_NET_XGRESS
2100	struct bpf_mprog_entry __rcu *tcx_ingress;
2101	#endif
2102	__cacheline_group_end(net_device_read_rx);
2103
2104	char name[IFNAMSIZ];
2105	struct netdev_name_node *name_node;
2106	struct dev_ifalias __rcu *ifalias;
2107	/*
2108	* I/O specific fields
2109	* FIXME: Merge these and struct ifmap into one
2110	*/
2111	unsigned long mem_end;
2112	unsigned long mem_start;
2113	unsigned long base_addr;
2114
2115	/*
2116	* Some hardware also needs these fields (state,dev_list,
2117	* napi_list,unreg_list,close_list) but they are not
2118	* part of the usual set specified in Space.c.
2119	*/
2120
2121
2122	struct list_head dev_list;
2123	struct list_head napi_list;
2124	struct list_head unreg_list;
2125	struct list_head close_list;
2126	struct list_head ptype_all;
2127
2128	struct {
2129	struct list_head upper;
2130	struct list_head lower;
2131	} adj_list;
2132
2133	/* Read-mostly cache-line for fast-path access */
2134	xdp_features_t xdp_features;
2135	const struct xdp_metadata_ops *xdp_metadata_ops;
2136	const struct xsk_tx_metadata_ops *xsk_tx_metadata_ops;
2137	unsigned short gflags;
2138
2139	unsigned short needed_tailroom;
2140
2141	netdev_features_t hw_features;
2142	netdev_features_t wanted_features;
2143	netdev_features_t vlan_features;
2144	netdev_features_t hw_enc_features;
2145	netdev_features_t mpls_features;
2146
2147	unsigned int min_mtu;
2148	unsigned int max_mtu;
2149	unsigned short type;
2150	unsigned char min_header_len;
2151	unsigned char name_assign_type;
2152
2153	int group;
2154
2155	struct net_device_stats stats; /* not used by modern drivers */
2156
2157	struct net_device_core_stats __percpu *core_stats;
2158
2159	/* Stats to monitor link on/off, flapping */
2160	atomic_t carrier_up_count;
2161	atomic_t carrier_down_count;
2162
2163	#ifdef CONFIG_WIRELESS_EXT
2164	const struct iw_handler_def *wireless_handlers;
2165	struct iw_public_data *wireless_data;
2166	#endif
2167	const struct ethtool_ops *ethtool_ops;
2168	#ifdef CONFIG_NET_L3_MASTER_DEV
2169	const struct l3mdev_ops *l3mdev_ops;
2170	#endif
2171	#if IS_ENABLED(CONFIG_IPV6)
2172	const struct ndisc_ops *ndisc_ops;
2173	#endif
2174
2175	#ifdef CONFIG_XFRM_OFFLOAD
2176	const struct xfrmdev_ops *xfrmdev_ops;
2177	#endif
2178
2179	#if IS_ENABLED(CONFIG_TLS_DEVICE)
2180	const struct tlsdev_ops *tlsdev_ops;
2181	#endif
2182
2183	unsigned int operstate;
2184	unsigned char link_mode;
2185
2186	unsigned char if_port;
2187	unsigned char dma;
2188
2189	/* Interface address info. */
2190	unsigned char perm_addr[MAX_ADDR_LEN];
2191	unsigned char addr_assign_type;
2192	unsigned char addr_len;
2193	unsigned char upper_level;
2194	unsigned char lower_level;
2195
2196	unsigned short neigh_priv_len;
2197	unsigned short dev_id;
2198	unsigned short dev_port;
2199	unsigned short padded;
2200
2201	spinlock_t addr_list_lock;
2202	int irq;
2203
2204	struct netdev_hw_addr_list uc;
2205	struct netdev_hw_addr_list mc;
2206	struct netdev_hw_addr_list dev_addrs;
2207
2208	#ifdef CONFIG_SYSFS
2209	struct kset *queues_kset;
2210	#endif
2211	#ifdef CONFIG_LOCKDEP
2212	struct list_head unlink_list;
2213	#endif
2214	unsigned int promiscuity;
2215	unsigned int allmulti;
2216	bool uc_promisc;
2217	#ifdef CONFIG_LOCKDEP
2218	unsigned char nested_level;
2219	#endif
2220
2221
2222	/* Protocol-specific pointers */
2223	struct in_device __rcu *ip_ptr;
2224	#if IS_ENABLED(CONFIG_VLAN_8021Q)
2225	struct vlan_info __rcu *vlan_info;
2226	#endif
2227	#if IS_ENABLED(CONFIG_NET_DSA)
2228	struct dsa_port *dsa_ptr;
2229	#endif
2230	#if IS_ENABLED(CONFIG_TIPC)
2231	struct tipc_bearer __rcu *tipc_ptr;
2232	#endif
2233	#if IS_ENABLED(CONFIG_ATALK)
2234	void *atalk_ptr;
2235	#endif
2236	#if IS_ENABLED(CONFIG_AX25)
2237	void *ax25_ptr;
2238	#endif
2239	#if IS_ENABLED(CONFIG_CFG80211)
2240	struct wireless_dev *ieee80211_ptr;
2241	#endif
2242	#if IS_ENABLED(CONFIG_IEEE802154) || IS_ENABLED(CONFIG_6LOWPAN)
2243	struct wpan_dev *ieee802154_ptr;
2244	#endif
2245	#if IS_ENABLED(CONFIG_MPLS_ROUTING)
2246	struct mpls_dev __rcu *mpls_ptr;
2247	#endif
2248	#if IS_ENABLED(CONFIG_MCTP)
2249	struct mctp_dev __rcu *mctp_ptr;
2250	#endif
2251
2252	/*
2253	* Cache lines mostly used on receive path (including eth_type_trans())
2254	*/
2255	/* Interface address info used in eth_type_trans() */
2256	const unsigned char *dev_addr;
2257
2258	unsigned int num_rx_queues;
2259	#define GRO_LEGACY_MAX_SIZE 65536u
2260	/* TCP minimal MSS is 8 (TCP_MIN_GSO_SIZE),
2261	* and shinfo->gso_segs is a 16bit field.
2262	*/
2263	#define GRO_MAX_SIZE (8 * 65535u)
2264	unsigned int xdp_zc_max_segs;
2265	struct netdev_queue __rcu *ingress_queue;
2266	#ifdef CONFIG_NETFILTER_INGRESS
2267	struct nf_hook_entries __rcu *nf_hooks_ingress;
2268	#endif
2269
2270	unsigned char broadcast[MAX_ADDR_LEN];
2271	#ifdef CONFIG_RFS_ACCEL
2272	struct cpu_rmap *rx_cpu_rmap;
2273	#endif
2274	struct hlist_node index_hlist;
2275
2276	/*
2277	* Cache lines mostly used on transmit path
2278	*/
2279	unsigned int num_tx_queues;
2280	struct Qdisc __rcu *qdisc;
2281	unsigned int tx_queue_len;
2282	spinlock_t tx_global_lock;
2283
2284	struct xdp_dev_bulk_queue __percpu *xdp_bulkq;
2285
2286	#ifdef CONFIG_NET_SCHED
2287	DECLARE_HASHTABLE (qdisc_hash, 4);
2288	#endif
2289	/* These may be needed for future network-power-down code. */
2290	struct timer_list watchdog_timer;
2291	int watchdog_timeo;
2292
2293	u32 proto_down_reason;
2294
2295	struct list_head todo_list;
2296
2297	#ifdef CONFIG_PCPU_DEV_REFCNT
2298	int __percpu *pcpu_refcnt;
2299	#else
2300	refcount_t dev_refcnt;
2301	#endif
2302	struct ref_tracker_dir refcnt_tracker;
2303
2304	struct list_head link_watch_list;
2305
2306	u8 reg_state;
2307
2308	bool dismantle;
2309
2310	enum {
2311	RTNL_LINK_INITIALIZED,
2312	RTNL_LINK_INITIALIZING,
2313	} rtnl_link_state:16;
2314
2315	bool needs_free_netdev;
2316	void (*priv_destructor)(struct net_device *dev);
2317
2318	/* mid-layer private */
2319	void *ml_priv;
2320	enum netdev_ml_priv_type ml_priv_type;
2321
2322	enum netdev_stat_type pcpu_stat_type:8;
2323
2324	#if IS_ENABLED(CONFIG_GARP)
2325	struct garp_port __rcu *garp_port;
2326	#endif
2327	#if IS_ENABLED(CONFIG_MRP)
2328	struct mrp_port __rcu *mrp_port;
2329	#endif
2330	#if IS_ENABLED(CONFIG_NET_DROP_MONITOR)
2331	struct dm_hw_stat_delta __rcu *dm_private;
2332	#endif
2333	struct device dev;
2334	const struct attribute_group *sysfs_groups[4];
2335	const struct attribute_group *sysfs_rx_queue_group;
2336
2337	const struct rtnl_link_ops *rtnl_link_ops;
2338
2339	const struct netdev_stat_ops *stat_ops;
2340
2341	/* for setting kernel sock attribute on TCP connection setup */
2342	#define GSO_MAX_SEGS 65535u
2343	#define GSO_LEGACY_MAX_SIZE 65536u
2344	/* TCP minimal MSS is 8 (TCP_MIN_GSO_SIZE),
2345	* and shinfo->gso_segs is a 16bit field.
2346	*/
2347	#define GSO_MAX_SIZE (8 * GSO_MAX_SEGS)
2348
2349	#define TSO_LEGACY_MAX_SIZE 65536
2350	#define TSO_MAX_SIZE UINT_MAX
2351	unsigned int tso_max_size;
2352	#define TSO_MAX_SEGS U16_MAX
2353	u16 tso_max_segs;
2354
2355	#ifdef CONFIG_DCB
2356	const struct dcbnl_rtnl_ops *dcbnl_ops;
2357	#endif
2358	u8 prio_tc_map[TC_BITMASK + 1];
2359
2360	#if IS_ENABLED(CONFIG_FCOE)
2361	unsigned int fcoe_ddp_xid;
2362	#endif
2363	#if IS_ENABLED(CONFIG_CGROUP_NET_PRIO)
2364	struct netprio_map __rcu *priomap;
2365	#endif
2366	struct phy_device *phydev;
2367	struct sfp_bus *sfp_bus;
2368	struct lock_class_key *qdisc_tx_busylock;
2369	bool proto_down;
2370	unsigned wol_enabled:1;
2371	unsigned threaded:1;
2372
2373	struct list_head net_notifier_list;
2374
2375	#if IS_ENABLED(CONFIG_MACSEC)
2376	/* MACsec management functions */
2377	const struct macsec_ops *macsec_ops;
2378	#endif
2379	const struct udp_tunnel_nic_info *udp_tunnel_nic_info;
2380	struct udp_tunnel_nic *udp_tunnel_nic;
2381
2382	/* protected by rtnl_lock */
2383	struct bpf_xdp_entity xdp_state[__MAX_XDP_MODE];
2384
2385	u8 dev_addr_shadow[MAX_ADDR_LEN];
2386	netdevice_tracker linkwatch_dev_tracker;
2387	netdevice_tracker watchdog_dev_tracker;
2388	netdevice_tracker dev_registered_tracker;
2389	struct rtnl_hw_stats64 *offload_xstats_l3;
2390
2391	struct devlink_port *devlink_port;
2392
2393	#if IS_ENABLED(CONFIG_DPLL)
2394	struct dpll_pin __rcu *dpll_pin;
2395	#endif
2396	#if IS_ENABLED(CONFIG_PAGE_POOL)
2397	/** @page_pools: page pools created for this netdevice */
2398	struct hlist_head page_pools;
2399	#endif
2400	};
2401	#define to_net_dev(d) container_of(d, struct net_device, dev)
2402
2403	/*
2404	* Driver should use this to assign devlink port instance to a netdevice
2405	* before it registers the netdevice. Therefore devlink_port is static
2406	* during the netdev lifetime after it is registered.
2407	*/
2408	#define SET_NETDEV_DEVLINK_PORT(dev, port) \
2409	({ \
2410	WARN_ON((dev)->reg_state != NETREG_UNINITIALIZED); \
2411	((dev)->devlink_port = (port)); \
2412	})
2413
2414	static inline bool netif_elide_gro(const struct net_device *dev)
2415	{
2416	if (!(dev->features & NETIF_F_GRO) || dev->xdp_prog)
2417	return true;
2418	return false;
2419	}
2420
2421	#define NETDEV_ALIGN 32
2422
2423	static inline
2424	int netdev_get_prio_tc_map(const struct net_device *dev, u32 prio)
2425	{
2426	return dev->prio_tc_map[prio & TC_BITMASK];
2427	}
2428
2429	static inline
2430	int netdev_set_prio_tc_map(struct net_device *dev, u8 prio, u8 tc)
2431	{
2432	if (tc >= dev->num_tc)
2433	return -EINVAL;
2434
2435	dev->prio_tc_map[prio & TC_BITMASK] = tc & TC_BITMASK;
2436	return 0;
2437	}
2438
2439	int netdev_txq_to_tc(struct net_device *dev, unsigned int txq);
2440	void netdev_reset_tc(struct net_device *dev);
2441	int netdev_set_tc_queue(struct net_device *dev, u8 tc, u16 count, u16 offset);
2442	int netdev_set_num_tc(struct net_device *dev, u8 num_tc);
2443
2444	static inline
2445	int netdev_get_num_tc(struct net_device *dev)
2446	{
2447	return dev->num_tc;
2448	}
2449
2450	static inline void net_prefetch(void *p)
2451	{
2452	prefetch(p);
2453	#if L1_CACHE_BYTES < 128
2454	prefetch((u8 *)p + L1_CACHE_BYTES);
2455	#endif
2456	}
2457
2458	static inline void net_prefetchw(void *p)
2459	{
2460	prefetchw(x: p);
2461	#if L1_CACHE_BYTES < 128
2462	prefetchw(x: (u8 *)p + L1_CACHE_BYTES);
2463	#endif
2464	}
2465
2466	void netdev_unbind_sb_channel(struct net_device *dev,
2467	struct net_device *sb_dev);
2468	int netdev_bind_sb_channel_queue(struct net_device *dev,
2469	struct net_device *sb_dev,
2470	u8 tc, u16 count, u16 offset);
2471	int netdev_set_sb_channel(struct net_device *dev, u16 channel);
2472	static inline int netdev_get_sb_channel(struct net_device *dev)
2473	{
2474	return max_t(int, -dev->num_tc, 0);
2475	}
2476
2477	static inline
2478	struct netdev_queue *netdev_get_tx_queue(const struct net_device *dev,
2479	unsigned int index)
2480	{
2481	DEBUG_NET_WARN_ON_ONCE(index >= dev->num_tx_queues);
2482	return &dev->_tx[index];
2483	}
2484
2485	static inline struct netdev_queue *skb_get_tx_queue(const struct net_device *dev,
2486	const struct sk_buff *skb)
2487	{
2488	return netdev_get_tx_queue(dev, index: skb_get_queue_mapping(skb));
2489	}
2490
2491	static inline void netdev_for_each_tx_queue(struct net_device *dev,
2492	void (*f)(struct net_device *,
2493	struct netdev_queue *,
2494	void *),
2495	void *arg)
2496	{
2497	unsigned int i;
2498
2499	for (i = 0; i < dev->num_tx_queues; i++)
2500	f(dev, &dev->_tx[i], arg);
2501	}
2502
2503	#define netdev_lockdep_set_classes(dev) \
2504	{ \
2505	static struct lock_class_key qdisc_tx_busylock_key; \
2506	static struct lock_class_key qdisc_xmit_lock_key; \
2507	static struct lock_class_key dev_addr_list_lock_key; \
2508	unsigned int i; \
2509	\
2510	(dev)->qdisc_tx_busylock = &qdisc_tx_busylock_key; \
2511	lockdep_set_class(&(dev)->addr_list_lock, \
2512	&dev_addr_list_lock_key); \
2513	for (i = 0; i < (dev)->num_tx_queues; i++) \
2514	lockdep_set_class(&(dev)->_tx[i]._xmit_lock, \
2515	&qdisc_xmit_lock_key); \
2516	}
2517
2518	u16 netdev_pick_tx(struct net_device *dev, struct sk_buff *skb,
2519	struct net_device *sb_dev);
2520	struct netdev_queue *netdev_core_pick_tx(struct net_device *dev,
2521	struct sk_buff *skb,
2522	struct net_device *sb_dev);
2523
2524	/* returns the headroom that the master device needs to take in account
2525	* when forwarding to this dev
2526	*/
2527	static inline unsigned netdev_get_fwd_headroom(struct net_device *dev)
2528	{
2529	return dev->priv_flags & IFF_PHONY_HEADROOM ? 0 : dev->needed_headroom;
2530	}
2531
2532	static inline void netdev_set_rx_headroom(struct net_device *dev, int new_hr)
2533	{
2534	if (dev->netdev_ops->ndo_set_rx_headroom)
2535	dev->netdev_ops->ndo_set_rx_headroom(dev, new_hr);
2536	}
2537
2538	/* set the device rx headroom to the dev's default */
2539	static inline void netdev_reset_rx_headroom(struct net_device *dev)
2540	{
2541	netdev_set_rx_headroom(dev, new_hr: -1);
2542	}
2543
2544	static inline void *netdev_get_ml_priv(struct net_device *dev,
2545	enum netdev_ml_priv_type type)
2546	{
2547	if (dev->ml_priv_type != type)
2548	return NULL;
2549
2550	return dev->ml_priv;
2551	}
2552
2553	static inline void netdev_set_ml_priv(struct net_device *dev,
2554	void *ml_priv,
2555	enum netdev_ml_priv_type type)
2556	{
2557	WARN(dev->ml_priv_type && dev->ml_priv_type != type,
2558	"Overwriting already set ml_priv_type (%u) with different ml_priv_type (%u)!\n",
2559	dev->ml_priv_type, type);
2560	WARN(!dev->ml_priv_type && dev->ml_priv,
2561	"Overwriting already set ml_priv and ml_priv_type is ML_PRIV_NONE!\n");
2562
2563	dev->ml_priv = ml_priv;
2564	dev->ml_priv_type = type;
2565	}
2566
2567	/*
2568	* Net namespace inlines
2569	*/
2570	static inline
2571	struct net *dev_net(const struct net_device *dev)
2572	{
2573	return read_pnet(pnet: &dev->nd_net);
2574	}
2575
2576	static inline
2577	void dev_net_set(struct net_device *dev, struct net *net)
2578	{
2579	write_pnet(pnet: &dev->nd_net, net);
2580	}
2581
2582	/**
2583	* netdev_priv - access network device private data
2584	* @dev: network device
2585	*
2586	* Get network device private data
2587	*/
2588	static inline void *netdev_priv(const struct net_device *dev)
2589	{
2590	return (char *)dev + ALIGN(sizeof(struct net_device), NETDEV_ALIGN);
2591	}
2592
2593	/* Set the sysfs physical device reference for the network logical device
2594	* if set prior to registration will cause a symlink during initialization.
2595	*/
2596	#define SET_NETDEV_DEV(net, pdev) ((net)->dev.parent = (pdev))
2597
2598	/* Set the sysfs device type for the network logical device to allow
2599	* fine-grained identification of different network device types. For
2600	* example Ethernet, Wireless LAN, Bluetooth, WiMAX etc.
2601	*/
2602	#define SET_NETDEV_DEVTYPE(net, devtype) ((net)->dev.type = (devtype))
2603
2604	void netif_queue_set_napi(struct net_device *dev, unsigned int queue_index,
2605	enum netdev_queue_type type,
2606	struct napi_struct *napi);
2607
2608	static inline void netif_napi_set_irq(struct napi_struct *napi, int irq)
2609	{
2610	napi->irq = irq;
2611	}
2612
2613	/* Default NAPI poll() weight
2614	* Device drivers are strongly advised to not use bigger value
2615	*/
2616	#define NAPI_POLL_WEIGHT 64
2617
2618	void netif_napi_add_weight(struct net_device *dev, struct napi_struct *napi,
2619	int (*poll)(struct napi_struct *, int), int weight);
2620
2621	/**
2622	* netif_napi_add() - initialize a NAPI context
2623	* @dev: network device
2624	* @napi: NAPI context
2625	* @poll: polling function
2626	*
2627	* netif_napi_add() must be used to initialize a NAPI context prior to calling
2628	* *any* of the other NAPI-related functions.
2629	*/
2630	static inline void
2631	netif_napi_add(struct net_device *dev, struct napi_struct *napi,
2632	int (*poll)(struct napi_struct *, int))
2633	{
2634	netif_napi_add_weight(dev, napi, poll, NAPI_POLL_WEIGHT);
2635	}
2636
2637	static inline void
2638	netif_napi_add_tx_weight(struct net_device *dev,
2639	struct napi_struct *napi,
2640	int (*poll)(struct napi_struct *, int),
2641	int weight)
2642	{
2643	set_bit(nr: NAPI_STATE_NO_BUSY_POLL, addr: &napi->state);
2644	netif_napi_add_weight(dev, napi, poll, weight);
2645	}
2646
2647	/**
2648	* netif_napi_add_tx() - initialize a NAPI context to be used for Tx only
2649	* @dev: network device
2650	* @napi: NAPI context
2651	* @poll: polling function
2652	*
2653	* This variant of netif_napi_add() should be used from drivers using NAPI
2654	* to exclusively poll a TX queue.
2655	* This will avoid we add it into napi_hash[], thus polluting this hash table.
2656	*/
2657	static inline void netif_napi_add_tx(struct net_device *dev,
2658	struct napi_struct *napi,
2659	int (*poll)(struct napi_struct *, int))
2660	{
2661	netif_napi_add_tx_weight(dev, napi, poll, NAPI_POLL_WEIGHT);
2662	}
2663
2664	/**
2665	* __netif_napi_del - remove a NAPI context
2666	* @napi: NAPI context
2667	*
2668	* Warning: caller must observe RCU grace period before freeing memory
2669	* containing @napi. Drivers might want to call this helper to combine
2670	* all the needed RCU grace periods into a single one.
2671	*/
2672	void __netif_napi_del(struct napi_struct *napi);
2673
2674	/**
2675	* netif_napi_del - remove a NAPI context
2676	* @napi: NAPI context
2677	*
2678	* netif_napi_del() removes a NAPI context from the network device NAPI list
2679	*/
2680	static inline void netif_napi_del(struct napi_struct *napi)
2681	{
2682	__netif_napi_del(napi);
2683	synchronize_net();
2684	}
2685
2686	struct packet_type {
2687	__be16 type; /* This is really htons(ether_type). */
2688	bool ignore_outgoing;
2689	struct net_device *dev; /* NULL is wildcarded here */
2690	netdevice_tracker dev_tracker;
2691	int (*func) (struct sk_buff *,
2692	struct net_device *,
2693	struct packet_type *,
2694	struct net_device *);
2695	void (*list_func) (struct list_head *,
2696	struct packet_type *,
2697	struct net_device *);
2698	bool (*id_match)(struct packet_type *ptype,
2699	struct sock *sk);
2700	struct net *af_packet_net;
2701	void *af_packet_priv;
2702	struct list_head list;
2703	};
2704
2705	struct offload_callbacks {
2706	struct sk_buff *(*gso_segment)(struct sk_buff *skb,
2707	netdev_features_t features);
2708	struct sk_buff *(*gro_receive)(struct list_head *head,
2709	struct sk_buff *skb);
2710	int (*gro_complete)(struct sk_buff *skb, int nhoff);
2711	};
2712
2713	struct packet_offload {
2714	__be16 type; /* This is really htons(ether_type). */
2715	u16 priority;
2716	struct offload_callbacks callbacks;
2717	struct list_head list;
2718	};
2719
2720	/* often modified stats are per-CPU, other are shared (netdev->stats) */
2721	struct pcpu_sw_netstats {
2722	u64_stats_t rx_packets;
2723	u64_stats_t rx_bytes;
2724	u64_stats_t tx_packets;
2725	u64_stats_t tx_bytes;
2726	struct u64_stats_sync syncp;
2727	} __aligned(4 * sizeof(u64));
2728
2729	struct pcpu_dstats {
2730	u64 rx_packets;
2731	u64 rx_bytes;
2732	u64 rx_drops;
2733	u64 tx_packets;
2734	u64 tx_bytes;
2735	u64 tx_drops;
2736	struct u64_stats_sync syncp;
2737	} __aligned(8 * sizeof(u64));
2738
2739	struct pcpu_lstats {
2740	u64_stats_t packets;
2741	u64_stats_t bytes;
2742	struct u64_stats_sync syncp;
2743	} __aligned(2 * sizeof(u64));
2744
2745	void dev_lstats_read(struct net_device *dev, u64 *packets, u64 *bytes);
2746
2747	static inline void dev_sw_netstats_rx_add(struct net_device *dev, unsigned int len)
2748	{
2749	struct pcpu_sw_netstats *tstats = this_cpu_ptr(dev->tstats);
2750
2751	u64_stats_update_begin(syncp: &tstats->syncp);
2752	u64_stats_add(p: &tstats->rx_bytes, val: len);
2753	u64_stats_inc(p: &tstats->rx_packets);
2754	u64_stats_update_end(syncp: &tstats->syncp);
2755	}
2756
2757	static inline void dev_sw_netstats_tx_add(struct net_device *dev,
2758	unsigned int packets,
2759	unsigned int len)
2760	{
2761	struct pcpu_sw_netstats *tstats = this_cpu_ptr(dev->tstats);
2762
2763	u64_stats_update_begin(syncp: &tstats->syncp);
2764	u64_stats_add(p: &tstats->tx_bytes, val: len);
2765	u64_stats_add(p: &tstats->tx_packets, val: packets);
2766	u64_stats_update_end(syncp: &tstats->syncp);
2767	}
2768
2769	static inline void dev_lstats_add(struct net_device *dev, unsigned int len)
2770	{
2771	struct pcpu_lstats *lstats = this_cpu_ptr(dev->lstats);
2772
2773	u64_stats_update_begin(syncp: &lstats->syncp);
2774	u64_stats_add(p: &lstats->bytes, val: len);
2775	u64_stats_inc(p: &lstats->packets);
2776	u64_stats_update_end(syncp: &lstats->syncp);
2777	}
2778
2779	#define __netdev_alloc_pcpu_stats(type, gfp) \
2780	({ \
2781	typeof(type) __percpu *pcpu_stats = alloc_percpu_gfp(type, gfp);\
2782	if (pcpu_stats) { \
2783	int __cpu; \
2784	for_each_possible_cpu(__cpu) { \
2785	typeof(type) *stat; \
2786	stat = per_cpu_ptr(pcpu_stats, __cpu); \
2787	u64_stats_init(&stat->syncp); \
2788	} \
2789	} \
2790	pcpu_stats; \
2791	})
2792
2793	#define netdev_alloc_pcpu_stats(type) \
2794	__netdev_alloc_pcpu_stats(type, GFP_KERNEL)
2795
2796	#define devm_netdev_alloc_pcpu_stats(dev, type) \
2797	({ \
2798	typeof(type) __percpu *pcpu_stats = devm_alloc_percpu(dev, type);\
2799	if (pcpu_stats) { \
2800	int __cpu; \
2801	for_each_possible_cpu(__cpu) { \
2802	typeof(type) *stat; \
2803	stat = per_cpu_ptr(pcpu_stats, __cpu); \
2804	u64_stats_init(&stat->syncp); \
2805	} \
2806	} \
2807	pcpu_stats; \
2808	})
2809
2810	enum netdev_lag_tx_type {
2811	NETDEV_LAG_TX_TYPE_UNKNOWN,
2812	NETDEV_LAG_TX_TYPE_RANDOM,
2813	NETDEV_LAG_TX_TYPE_BROADCAST,
2814	NETDEV_LAG_TX_TYPE_ROUNDROBIN,
2815	NETDEV_LAG_TX_TYPE_ACTIVEBACKUP,
2816	NETDEV_LAG_TX_TYPE_HASH,
2817	};
2818
2819	enum netdev_lag_hash {
2820	NETDEV_LAG_HASH_NONE,
2821	NETDEV_LAG_HASH_L2,
2822	NETDEV_LAG_HASH_L34,
2823	NETDEV_LAG_HASH_L23,
2824	NETDEV_LAG_HASH_E23,
2825	NETDEV_LAG_HASH_E34,
2826	NETDEV_LAG_HASH_VLAN_SRCMAC,
2827	NETDEV_LAG_HASH_UNKNOWN,
2828	};
2829
2830	struct netdev_lag_upper_info {
2831	enum netdev_lag_tx_type tx_type;
2832	enum netdev_lag_hash hash_type;
2833	};
2834
2835	struct netdev_lag_lower_state_info {
2836	u8 link_up : 1,
2837	tx_enabled : 1;
2838	};
2839
2840	#include <linux/notifier.h>
2841
2842	/* netdevice notifier chain. Please remember to update netdev_cmd_to_name()
2843	* and the rtnetlink notification exclusion list in rtnetlink_event() when
2844	* adding new types.
2845	*/
2846	enum netdev_cmd {
2847	NETDEV_UP = 1, /* For now you can't veto a device up/down */
2848	NETDEV_DOWN,
2849	NETDEV_REBOOT, /* Tell a protocol stack a network interface
2850	detected a hardware crash and restarted
2851	- we can use this eg to kick tcp sessions
2852	once done */
2853	NETDEV_CHANGE, /* Notify device state change */
2854	NETDEV_REGISTER,
2855	NETDEV_UNREGISTER,
2856	NETDEV_CHANGEMTU, /* notify after mtu change happened */
2857	NETDEV_CHANGEADDR, /* notify after the address change */
2858	NETDEV_PRE_CHANGEADDR, /* notify before the address change */
2859	NETDEV_GOING_DOWN,
2860	NETDEV_CHANGENAME,
2861	NETDEV_FEAT_CHANGE,
2862	NETDEV_BONDING_FAILOVER,
2863	NETDEV_PRE_UP,
2864	NETDEV_PRE_TYPE_CHANGE,
2865	NETDEV_POST_TYPE_CHANGE,
2866	NETDEV_POST_INIT,
2867	NETDEV_PRE_UNINIT,
2868	NETDEV_RELEASE,
2869	NETDEV_NOTIFY_PEERS,
2870	NETDEV_JOIN,
2871	NETDEV_CHANGEUPPER,
2872	NETDEV_RESEND_IGMP,
2873	NETDEV_PRECHANGEMTU, /* notify before mtu change happened */
2874	NETDEV_CHANGEINFODATA,
2875	NETDEV_BONDING_INFO,
2876	NETDEV_PRECHANGEUPPER,
2877	NETDEV_CHANGELOWERSTATE,
2878	NETDEV_UDP_TUNNEL_PUSH_INFO,
2879	NETDEV_UDP_TUNNEL_DROP_INFO,
2880	NETDEV_CHANGE_TX_QUEUE_LEN,
2881	NETDEV_CVLAN_FILTER_PUSH_INFO,
2882	NETDEV_CVLAN_FILTER_DROP_INFO,
2883	NETDEV_SVLAN_FILTER_PUSH_INFO,
2884	NETDEV_SVLAN_FILTER_DROP_INFO,
2885	NETDEV_OFFLOAD_XSTATS_ENABLE,
2886	NETDEV_OFFLOAD_XSTATS_DISABLE,
2887	NETDEV_OFFLOAD_XSTATS_REPORT_USED,
2888	NETDEV_OFFLOAD_XSTATS_REPORT_DELTA,
2889	NETDEV_XDP_FEAT_CHANGE,
2890	};
2891	const char *netdev_cmd_to_name(enum netdev_cmd cmd);
2892
2893	int register_netdevice_notifier(struct notifier_block *nb);
2894	int unregister_netdevice_notifier(struct notifier_block *nb);
2895	int register_netdevice_notifier_net(struct net *net, struct notifier_block *nb);
2896	int unregister_netdevice_notifier_net(struct net *net,
2897	struct notifier_block *nb);
2898	int register_netdevice_notifier_dev_net(struct net_device *dev,
2899	struct notifier_block *nb,
2900	struct netdev_net_notifier *nn);
2901	int unregister_netdevice_notifier_dev_net(struct net_device *dev,
2902	struct notifier_block *nb,
2903	struct netdev_net_notifier *nn);
2904
2905	struct netdev_notifier_info {
2906	struct net_device *dev;
2907	struct netlink_ext_ack *extack;
2908	};
2909
2910	struct netdev_notifier_info_ext {
2911	struct netdev_notifier_info info; /* must be first */
2912	union {
2913	u32 mtu;
2914	} ext;
2915	};
2916
2917	struct netdev_notifier_change_info {
2918	struct netdev_notifier_info info; /* must be first */
2919	unsigned int flags_changed;
2920	};
2921
2922	struct netdev_notifier_changeupper_info {
2923	struct netdev_notifier_info info; /* must be first */
2924	struct net_device *upper_dev; /* new upper dev */
2925	bool master; /* is upper dev master */
2926	bool linking; /* is the notification for link or unlink */
2927	void *upper_info; /* upper dev info */
2928	};
2929
2930	struct netdev_notifier_changelowerstate_info {
2931	struct netdev_notifier_info info; /* must be first */
2932	void *lower_state_info; /* is lower dev state */
2933	};
2934
2935	struct netdev_notifier_pre_changeaddr_info {
2936	struct netdev_notifier_info info; /* must be first */
2937	const unsigned char *dev_addr;
2938	};
2939
2940	enum netdev_offload_xstats_type {
2941	NETDEV_OFFLOAD_XSTATS_TYPE_L3 = 1,
2942	};
2943
2944	struct netdev_notifier_offload_xstats_info {
2945	struct netdev_notifier_info info; /* must be first */
2946	enum netdev_offload_xstats_type type;
2947
2948	union {
2949	/* NETDEV_OFFLOAD_XSTATS_REPORT_DELTA */
2950	struct netdev_notifier_offload_xstats_rd *report_delta;
2951	/* NETDEV_OFFLOAD_XSTATS_REPORT_USED */
2952	struct netdev_notifier_offload_xstats_ru *report_used;
2953	};
2954	};
2955
2956	int netdev_offload_xstats_enable(struct net_device *dev,
2957	enum netdev_offload_xstats_type type,
2958	struct netlink_ext_ack *extack);
2959	int netdev_offload_xstats_disable(struct net_device *dev,
2960	enum netdev_offload_xstats_type type);
2961	bool netdev_offload_xstats_enabled(const struct net_device *dev,
2962	enum netdev_offload_xstats_type type);
2963	int netdev_offload_xstats_get(struct net_device *dev,
2964	enum netdev_offload_xstats_type type,
2965	struct rtnl_hw_stats64 *stats, bool *used,
2966	struct netlink_ext_ack *extack);
2967	void
2968	netdev_offload_xstats_report_delta(struct netdev_notifier_offload_xstats_rd *rd,
2969	const struct rtnl_hw_stats64 *stats);
2970	void
2971	netdev_offload_xstats_report_used(struct netdev_notifier_offload_xstats_ru *ru);
2972	void netdev_offload_xstats_push_delta(struct net_device *dev,
2973	enum netdev_offload_xstats_type type,
2974	const struct rtnl_hw_stats64 *stats);
2975
2976	static inline void netdev_notifier_info_init(struct netdev_notifier_info *info,
2977	struct net_device *dev)
2978	{
2979	info->dev = dev;
2980	info->extack = NULL;
2981	}
2982
2983	static inline struct net_device *
2984	netdev_notifier_info_to_dev(const struct netdev_notifier_info *info)
2985	{
2986	return info->dev;
2987	}
2988
2989	static inline struct netlink_ext_ack *
2990	netdev_notifier_info_to_extack(const struct netdev_notifier_info *info)
2991	{
2992	return info->extack;
2993	}
2994
2995	int call_netdevice_notifiers(unsigned long val, struct net_device *dev);
2996	int call_netdevice_notifiers_info(unsigned long val,
2997	struct netdev_notifier_info *info);
2998
2999	#define for_each_netdev(net, d) \
3000	list_for_each_entry(d, &(net)->dev_base_head, dev_list)
3001	#define for_each_netdev_reverse(net, d) \
3002	list_for_each_entry_reverse(d, &(net)->dev_base_head, dev_list)
3003	#define for_each_netdev_rcu(net, d) \
3004	list_for_each_entry_rcu(d, &(net)->dev_base_head, dev_list)
3005	#define for_each_netdev_safe(net, d, n) \
3006	list_for_each_entry_safe(d, n, &(net)->dev_base_head, dev_list)
3007	#define for_each_netdev_continue(net, d) \
3008	list_for_each_entry_continue(d, &(net)->dev_base_head, dev_list)
3009	#define for_each_netdev_continue_reverse(net, d) \
3010	list_for_each_entry_continue_reverse(d, &(net)->dev_base_head, \
3011	dev_list)
3012	#define for_each_netdev_continue_rcu(net, d) \
3013	list_for_each_entry_continue_rcu(d, &(net)->dev_base_head, dev_list)
3014	#define for_each_netdev_in_bond_rcu(bond, slave) \
3015	for_each_netdev_rcu(&init_net, slave) \
3016	if (netdev_master_upper_dev_get_rcu(slave) == (bond))
3017	#define net_device_entry(lh) list_entry(lh, struct net_device, dev_list)
3018
3019	#define for_each_netdev_dump(net, d, ifindex) \
3020	xa_for_each_start(&(net)->dev_by_index, (ifindex), (d), (ifindex))
3021
3022	static inline struct net_device *next_net_device(struct net_device *dev)
3023	{
3024	struct list_head *lh;
3025	struct net *net;
3026
3027	net = dev_net(dev);
3028	lh = dev->dev_list.next;
3029	return lh == &net->dev_base_head ? NULL : net_device_entry(lh);
3030	}
3031
3032	static inline struct net_device *next_net_device_rcu(struct net_device *dev)
3033	{
3034	struct list_head *lh;
3035	struct net *net;
3036
3037	net = dev_net(dev);
3038	lh = rcu_dereference(list_next_rcu(&dev->dev_list));
3039	return lh == &net->dev_base_head ? NULL : net_device_entry(lh);
3040	}
3041
3042	static inline struct net_device *first_net_device(struct net *net)
3043	{
3044	return list_empty(head: &net->dev_base_head) ? NULL :
3045	net_device_entry(net->dev_base_head.next);
3046	}
3047
3048	static inline struct net_device *first_net_device_rcu(struct net *net)
3049	{
3050	struct list_head *lh = rcu_dereference(list_next_rcu(&net->dev_base_head));
3051
3052	return lh == &net->dev_base_head ? NULL : net_device_entry(lh);
3053	}
3054
3055	int netdev_boot_setup_check(struct net_device *dev);
3056	struct net_device *dev_getbyhwaddr_rcu(struct net *net, unsigned short type,
3057	const char *hwaddr);
3058	struct net_device *dev_getfirstbyhwtype(struct net *net, unsigned short type);
3059	void dev_add_pack(struct packet_type *pt);
3060	void dev_remove_pack(struct packet_type *pt);
3061	void __dev_remove_pack(struct packet_type *pt);
3062	void dev_add_offload(struct packet_offload *po);
3063	void dev_remove_offload(struct packet_offload *po);
3064
3065	int dev_get_iflink(const struct net_device *dev);
3066	int dev_fill_metadata_dst(struct net_device *dev, struct sk_buff *skb);
3067	int dev_fill_forward_path(const struct net_device *dev, const u8 *daddr,
3068	struct net_device_path_stack *stack);
3069	struct net_device *__dev_get_by_flags(struct net *net, unsigned short flags,
3070	unsigned short mask);
3071	struct net_device *dev_get_by_name(struct net *net, const char *name);
3072	struct net_device *dev_get_by_name_rcu(struct net *net, const char *name);
3073	struct net_device *__dev_get_by_name(struct net *net, const char *name);
3074	bool netdev_name_in_use(struct net *net, const char *name);
3075	int dev_alloc_name(struct net_device *dev, const char *name);
3076	int dev_open(struct net_device *dev, struct netlink_ext_ack *extack);
3077	void dev_close(struct net_device *dev);
3078	void dev_close_many(struct list_head *head, bool unlink);
3079	void dev_disable_lro(struct net_device *dev);
3080	int dev_loopback_xmit(struct net *net, struct sock *sk, struct sk_buff *newskb);
3081	u16 dev_pick_tx_zero(struct net_device *dev, struct sk_buff *skb,
3082	struct net_device *sb_dev);
3083	u16 dev_pick_tx_cpu_id(struct net_device *dev, struct sk_buff *skb,
3084	struct net_device *sb_dev);
3085
3086	int __dev_queue_xmit(struct sk_buff *skb, struct net_device *sb_dev);
3087	int __dev_direct_xmit(struct sk_buff *skb, u16 queue_id);
3088
3089	static inline int dev_queue_xmit(struct sk_buff *skb)
3090	{
3091	return __dev_queue_xmit(skb, NULL);
3092	}
3093
3094	static inline int dev_queue_xmit_accel(struct sk_buff *skb,
3095	struct net_device *sb_dev)
3096	{
3097	return __dev_queue_xmit(skb, sb_dev);
3098	}
3099
3100	static inline int dev_direct_xmit(struct sk_buff *skb, u16 queue_id)
3101	{
3102	int ret;
3103
3104	ret = __dev_direct_xmit(skb, queue_id);
3105	if (!dev_xmit_complete(rc: ret))
3106	kfree_skb(skb);
3107	return ret;
3108	}
3109
3110	int register_netdevice(struct net_device *dev);
3111	void unregister_netdevice_queue(struct net_device *dev, struct list_head *head);
3112	void unregister_netdevice_many(struct list_head *head);
3113	static inline void unregister_netdevice(struct net_device *dev)
3114	{
3115	unregister_netdevice_queue(dev, NULL);
3116	}
3117
3118	int netdev_refcnt_read(const struct net_device *dev);
3119	void free_netdev(struct net_device *dev);
3120	void netdev_freemem(struct net_device *dev);
3121	void init_dummy_netdev(struct net_device *dev);
3122
3123	struct net_device *netdev_get_xmit_slave(struct net_device *dev,
3124	struct sk_buff *skb,
3125	bool all_slaves);
3126	struct net_device *netdev_sk_get_lowest_dev(struct net_device *dev,
3127	struct sock *sk);
3128	struct net_device *dev_get_by_index(struct net *net, int ifindex);
3129	struct net_device *__dev_get_by_index(struct net *net, int ifindex);
3130	struct net_device *netdev_get_by_index(struct net *net, int ifindex,
3131	netdevice_tracker *tracker, gfp_t gfp);
3132	struct net_device *netdev_get_by_name(struct net *net, const char *name,
3133	netdevice_tracker *tracker, gfp_t gfp);
3134	struct net_device *dev_get_by_index_rcu(struct net *net, int ifindex);
3135	struct net_device *dev_get_by_napi_id(unsigned int napi_id);
3136
3137	static inline int dev_hard_header(struct sk_buff *skb, struct net_device *dev,
3138	unsigned short type,
3139	const void *daddr, const void *saddr,
3140	unsigned int len)
3141	{
3142	if (!dev->header_ops || !dev->header_ops->create)
3143	return 0;
3144
3145	return dev->header_ops->create(skb, dev, type, daddr, saddr, len);
3146	}
3147
3148	static inline int dev_parse_header(const struct sk_buff *skb,
3149	unsigned char *haddr)
3150	{
3151	const struct net_device *dev = skb->dev;
3152
3153	if (!dev->header_ops || !dev->header_ops->parse)
3154	return 0;
3155	return dev->header_ops->parse(skb, haddr);
3156	}
3157
3158	static inline __be16 dev_parse_header_protocol(const struct sk_buff *skb)
3159	{
3160	const struct net_device *dev = skb->dev;
3161
3162	if (!dev->header_ops || !dev->header_ops->parse_protocol)
3163	return 0;
3164	return dev->header_ops->parse_protocol(skb);
3165	}
3166
3167	/* ll_header must have at least hard_header_len allocated */
3168	static inline bool dev_validate_header(const struct net_device *dev,
3169	char *ll_header, int len)
3170	{
3171	if (likely(len >= dev->hard_header_len))
3172	return true;
3173	if (len < dev->min_header_len)
3174	return false;
3175
3176	if (capable(CAP_SYS_RAWIO)) {
3177	memset(ll_header + len, 0, dev->hard_header_len - len);
3178	return true;
3179	}
3180
3181	if (dev->header_ops && dev->header_ops->validate)
3182	return dev->header_ops->validate(ll_header, len);
3183
3184	return false;
3185	}
3186
3187	static inline bool dev_has_header(const struct net_device *dev)
3188	{
3189	return dev->header_ops && dev->header_ops->create;
3190	}
3191
3192	/*
3193	* Incoming packets are placed on per-CPU queues
3194	*/
3195	struct softnet_data {
3196	struct list_head poll_list;
3197	struct sk_buff_head process_queue;
3198
3199	/* stats */
3200	unsigned int processed;
3201	unsigned int time_squeeze;
3202	#ifdef CONFIG_RPS
3203	struct softnet_data *rps_ipi_list;
3204	#endif
3205
3206	bool in_net_rx_action;
3207	bool in_napi_threaded_poll;
3208
3209	#ifdef CONFIG_NET_FLOW_LIMIT
3210	struct sd_flow_limit __rcu *flow_limit;
3211	#endif
3212	struct Qdisc *output_queue;
3213	struct Qdisc **output_queue_tailp;
3214	struct sk_buff *completion_queue;
3215	#ifdef CONFIG_XFRM_OFFLOAD
3216	struct sk_buff_head xfrm_backlog;
3217	#endif
3218	/* written and read only by owning cpu: */
3219	struct {
3220	u16 recursion;
3221	u8 more;
3222	#ifdef CONFIG_NET_EGRESS
3223	u8 skip_txqueue;
3224	#endif
3225	} xmit;
3226	#ifdef CONFIG_RPS
3227	/* input_queue_head should be written by cpu owning this struct,
3228	* and only read by other cpus. Worth using a cache line.
3229	*/
3230	unsigned int input_queue_head ____cacheline_aligned_in_smp;
3231
3232	/* Elements below can be accessed between CPUs for RPS/RFS */
3233	call_single_data_t csd ____cacheline_aligned_in_smp;
3234	struct softnet_data *rps_ipi_next;
3235	unsigned int cpu;
3236	unsigned int input_queue_tail;
3237	#endif
3238	unsigned int received_rps;
3239	unsigned int dropped;
3240	struct sk_buff_head input_pkt_queue;
3241	struct napi_struct backlog;
3242
3243	/* Another possibly contended cache line */
3244	spinlock_t defer_lock ____cacheline_aligned_in_smp;
3245	int defer_count;
3246	int defer_ipi_scheduled;
3247	struct sk_buff *defer_list;
3248	call_single_data_t defer_csd;
3249	};
3250
3251	static inline void input_queue_head_incr(struct softnet_data *sd)
3252	{
3253	#ifdef CONFIG_RPS
3254	sd->input_queue_head++;
3255	#endif
3256	}
3257
3258	static inline void input_queue_tail_incr_save(struct softnet_data *sd,
3259	unsigned int *qtail)
3260	{
3261	#ifdef CONFIG_RPS
3262	*qtail = ++sd->input_queue_tail;
3263	#endif
3264	}
3265
3266	DECLARE_PER_CPU_ALIGNED(struct softnet_data, softnet_data);
3267
3268	static inline int dev_recursion_level(void)
3269	{
3270	return this_cpu_read(softnet_data.xmit.recursion);
3271	}
3272
3273	#define XMIT_RECURSION_LIMIT 8
3274	static inline bool dev_xmit_recursion(void)
3275	{
3276	return unlikely(__this_cpu_read(softnet_data.xmit.recursion) >
3277	XMIT_RECURSION_LIMIT);
3278	}
3279
3280	static inline void dev_xmit_recursion_inc(void)
3281	{
3282	__this_cpu_inc(softnet_data.xmit.recursion);
3283	}
3284
3285	static inline void dev_xmit_recursion_dec(void)
3286	{
3287	__this_cpu_dec(softnet_data.xmit.recursion);
3288	}
3289
3290	void __netif_schedule(struct Qdisc *q);
3291	void netif_schedule_queue(struct netdev_queue *txq);
3292
3293	static inline void netif_tx_schedule_all(struct net_device *dev)
3294	{
3295	unsigned int i;
3296
3297	for (i = 0; i < dev->num_tx_queues; i++)
3298	netif_schedule_queue(txq: netdev_get_tx_queue(dev, index: i));
3299	}
3300
3301	static __always_inline void netif_tx_start_queue(struct netdev_queue *dev_queue)
3302	{
3303	clear_bit(nr: __QUEUE_STATE_DRV_XOFF, addr: &dev_queue->state);
3304	}
3305
3306	/**
3307	* netif_start_queue - allow transmit
3308	* @dev: network device
3309	*
3310	* Allow upper layers to call the device hard_start_xmit routine.
3311	*/
3312	static inline void netif_start_queue(struct net_device *dev)
3313	{
3314	netif_tx_start_queue(dev_queue: netdev_get_tx_queue(dev, index: 0));
3315	}
3316
3317	static inline void netif_tx_start_all_queues(struct net_device *dev)
3318	{
3319	unsigned int i;
3320
3321	for (i = 0; i < dev->num_tx_queues; i++) {
3322	struct netdev_queue *txq = netdev_get_tx_queue(dev, index: i);
3323	netif_tx_start_queue(dev_queue: txq);
3324	}
3325	}
3326
3327	void netif_tx_wake_queue(struct netdev_queue *dev_queue);
3328
3329	/**
3330	* netif_wake_queue - restart transmit
3331	* @dev: network device
3332	*
3333	* Allow upper layers to call the device hard_start_xmit routine.
3334	* Used for flow control when transmit resources are available.
3335	*/
3336	static inline void netif_wake_queue(struct net_device *dev)
3337	{
3338	netif_tx_wake_queue(dev_queue: netdev_get_tx_queue(dev, index: 0));
3339	}
3340
3341	static inline void netif_tx_wake_all_queues(struct net_device *dev)
3342	{
3343	unsigned int i;
3344
3345	for (i = 0; i < dev->num_tx_queues; i++) {
3346	struct netdev_queue *txq = netdev_get_tx_queue(dev, index: i);
3347	netif_tx_wake_queue(dev_queue: txq);
3348	}
3349	}
3350
3351	static __always_inline void netif_tx_stop_queue(struct netdev_queue *dev_queue)
3352	{
3353	/* Must be an atomic op see netif_txq_try_stop() */
3354	set_bit(nr: __QUEUE_STATE_DRV_XOFF, addr: &dev_queue->state);
3355	}
3356
3357	/**
3358	* netif_stop_queue - stop transmitted packets
3359	* @dev: network device
3360	*
3361	* Stop upper layers calling the device hard_start_xmit routine.
3362	* Used for flow control when transmit resources are unavailable.
3363	*/
3364	static inline void netif_stop_queue(struct net_device *dev)
3365	{
3366	netif_tx_stop_queue(dev_queue: netdev_get_tx_queue(dev, index: 0));
3367	}
3368
3369	void netif_tx_stop_all_queues(struct net_device *dev);
3370
3371	static inline bool netif_tx_queue_stopped(const struct netdev_queue *dev_queue)
3372	{
3373	return test_bit(__QUEUE_STATE_DRV_XOFF, &dev_queue->state);
3374	}
3375
3376	/**
3377	* netif_queue_stopped - test if transmit queue is flowblocked
3378	* @dev: network device
3379	*
3380	* Test if transmit queue on device is currently unable to send.
3381	*/
3382	static inline bool netif_queue_stopped(const struct net_device *dev)
3383	{
3384	return netif_tx_queue_stopped(dev_queue: netdev_get_tx_queue(dev, index: 0));
3385	}
3386
3387	static inline bool netif_xmit_stopped(const struct netdev_queue *dev_queue)
3388	{
3389	return dev_queue->state & QUEUE_STATE_ANY_XOFF;
3390	}
3391
3392	static inline bool
3393	netif_xmit_frozen_or_stopped(const struct netdev_queue *dev_queue)
3394	{
3395	return dev_queue->state & QUEUE_STATE_ANY_XOFF_OR_FROZEN;
3396	}
3397
3398	static inline bool
3399	netif_xmit_frozen_or_drv_stopped(const struct netdev_queue *dev_queue)
3400	{
3401	return dev_queue->state & QUEUE_STATE_DRV_XOFF_OR_FROZEN;
3402	}
3403
3404	/**
3405	* netdev_queue_set_dql_min_limit - set dql minimum limit
3406	* @dev_queue: pointer to transmit queue
3407	* @min_limit: dql minimum limit
3408	*
3409	* Forces xmit_more() to return true until the minimum threshold
3410	* defined by @min_limit is reached (or until the tx queue is
3411	* empty). Warning: to be use with care, misuse will impact the
3412	* latency.
3413	*/
3414	static inline void netdev_queue_set_dql_min_limit(struct netdev_queue *dev_queue,
3415	unsigned int min_limit)
3416	{
3417	#ifdef CONFIG_BQL
3418	dev_queue->dql.min_limit = min_limit;
3419	#endif
3420	}
3421
3422	static inline int netdev_queue_dql_avail(const struct netdev_queue *txq)
3423	{
3424	#ifdef CONFIG_BQL
3425	/* Non-BQL migrated drivers will return 0, too. */
3426	return dql_avail(dql: &txq->dql);
3427	#else
3428	return 0;
3429	#endif
3430	}
3431
3432	/**
3433	* netdev_txq_bql_enqueue_prefetchw - prefetch bql data for write
3434	* @dev_queue: pointer to transmit queue
3435	*
3436	* BQL enabled drivers might use this helper in their ndo_start_xmit(),
3437	* to give appropriate hint to the CPU.
3438	*/
3439	static inline void netdev_txq_bql_enqueue_prefetchw(struct netdev_queue *dev_queue)
3440	{
3441	#ifdef CONFIG_BQL
3442	prefetchw(x: &dev_queue->dql.num_queued);
3443	#endif
3444	}
3445
3446	/**
3447	* netdev_txq_bql_complete_prefetchw - prefetch bql data for write
3448	* @dev_queue: pointer to transmit queue
3449	*
3450	* BQL enabled drivers might use this helper in their TX completion path,
3451	* to give appropriate hint to the CPU.
3452	*/
3453	static inline void netdev_txq_bql_complete_prefetchw(struct netdev_queue *dev_queue)
3454	{
3455	#ifdef CONFIG_BQL
3456	prefetchw(x: &dev_queue->dql.limit);
3457	#endif
3458	}
3459
3460	/**
3461	* netdev_tx_sent_queue - report the number of bytes queued to a given tx queue
3462	* @dev_queue: network device queue
3463	* @bytes: number of bytes queued to the device queue
3464	*
3465	* Report the number of bytes queued for sending/completion to the network
3466	* device hardware queue. @bytes should be a good approximation and should
3467	* exactly match netdev_completed_queue() @bytes.
3468	* This is typically called once per packet, from ndo_start_xmit().
3469	*/
3470	static inline void netdev_tx_sent_queue(struct netdev_queue *dev_queue,
3471	unsigned int bytes)
3472	{
3473	#ifdef CONFIG_BQL
3474	dql_queued(dql: &dev_queue->dql, count: bytes);
3475
3476	if (likely(dql_avail(&dev_queue->dql) >= 0))
3477	return;
3478
3479	set_bit(nr: __QUEUE_STATE_STACK_XOFF, addr: &dev_queue->state);
3480
3481	/*
3482	* The XOFF flag must be set before checking the dql_avail below,
3483	* because in netdev_tx_completed_queue we update the dql_completed
3484	* before checking the XOFF flag.
3485	*/
3486	smp_mb();
3487
3488	/* check again in case another CPU has just made room avail */
3489	if (unlikely(dql_avail(&dev_queue->dql) >= 0))
3490	clear_bit(nr: __QUEUE_STATE_STACK_XOFF, addr: &dev_queue->state);
3491	#endif
3492	}
3493
3494	/* Variant of netdev_tx_sent_queue() for drivers that are aware
3495	* that they should not test BQL status themselves.
3496	* We do want to change __QUEUE_STATE_STACK_XOFF only for the last
3497	* skb of a batch.
3498	* Returns true if the doorbell must be used to kick the NIC.
3499	*/
3500	static inline bool __netdev_tx_sent_queue(struct netdev_queue *dev_queue,
3501	unsigned int bytes,
3502	bool xmit_more)
3503	{
3504	if (xmit_more) {
3505	#ifdef CONFIG_BQL
3506	dql_queued(dql: &dev_queue->dql, count: bytes);
3507	#endif
3508	return netif_tx_queue_stopped(dev_queue);
3509	}
3510	netdev_tx_sent_queue(dev_queue, bytes);
3511	return true;
3512	}
3513
3514	/**
3515	* netdev_sent_queue - report the number of bytes queued to hardware
3516	* @dev: network device
3517	* @bytes: number of bytes queued to the hardware device queue
3518	*
3519	* Report the number of bytes queued for sending/completion to the network
3520	* device hardware queue#0. @bytes should be a good approximation and should
3521	* exactly match netdev_completed_queue() @bytes.
3522	* This is typically called once per packet, from ndo_start_xmit().
3523	*/
3524	static inline void netdev_sent_queue(struct net_device *dev, unsigned int bytes)
3525	{
3526	netdev_tx_sent_queue(dev_queue: netdev_get_tx_queue(dev, index: 0), bytes);
3527	}
3528
3529	static inline bool __netdev_sent_queue(struct net_device *dev,
3530	unsigned int bytes,
3531	bool xmit_more)
3532	{
3533	return __netdev_tx_sent_queue(dev_queue: netdev_get_tx_queue(dev, index: 0), bytes,
3534	xmit_more);
3535	}
3536
3537	/**
3538	* netdev_tx_completed_queue - report number of packets/bytes at TX completion.
3539	* @dev_queue: network device queue
3540	* @pkts: number of packets (currently ignored)
3541	* @bytes: number of bytes dequeued from the device queue
3542	*
3543	* Must be called at most once per TX completion round (and not per
3544	* individual packet), so that BQL can adjust its limits appropriately.
3545	*/
3546	static inline void netdev_tx_completed_queue(struct netdev_queue *dev_queue,
3547	unsigned int pkts, unsigned int bytes)
3548	{
3549	#ifdef CONFIG_BQL
3550	if (unlikely(!bytes))
3551	return;
3552
3553	dql_completed(dql: &dev_queue->dql, count: bytes);
3554
3555	/*
3556	* Without the memory barrier there is a small possiblity that
3557	* netdev_tx_sent_queue will miss the update and cause the queue to
3558	* be stopped forever
3559	*/
3560	smp_mb(); /* NOTE: netdev_txq_completed_mb() assumes this exists */
3561
3562	if (unlikely(dql_avail(&dev_queue->dql) < 0))
3563	return;
3564
3565	if (test_and_clear_bit(nr: __QUEUE_STATE_STACK_XOFF, addr: &dev_queue->state))
3566	netif_schedule_queue(txq: dev_queue);
3567	#endif
3568	}
3569
3570	/**
3571	* netdev_completed_queue - report bytes and packets completed by device
3572	* @dev: network device
3573	* @pkts: actual number of packets sent over the medium
3574	* @bytes: actual number of bytes sent over the medium
3575	*
3576	* Report the number of bytes and packets transmitted by the network device
3577	* hardware queue over the physical medium, @bytes must exactly match the
3578	* @bytes amount passed to netdev_sent_queue()
3579	*/
3580	static inline void netdev_completed_queue(struct net_device *dev,
3581	unsigned int pkts, unsigned int bytes)
3582	{
3583	netdev_tx_completed_queue(dev_queue: netdev_get_tx_queue(dev, index: 0), pkts, bytes);
3584	}
3585
3586	static inline void netdev_tx_reset_queue(struct netdev_queue *q)
3587	{
3588	#ifdef CONFIG_BQL
3589	clear_bit(nr: __QUEUE_STATE_STACK_XOFF, addr: &q->state);
3590	dql_reset(dql: &q->dql);
3591	#endif
3592	}
3593
3594	/**
3595	* netdev_reset_queue - reset the packets and bytes count of a network device
3596	* @dev_queue: network device
3597	*
3598	* Reset the bytes and packet count of a network device and clear the
3599	* software flow control OFF bit for this network device
3600	*/
3601	static inline void netdev_reset_queue(struct net_device *dev_queue)
3602	{
3603	netdev_tx_reset_queue(q: netdev_get_tx_queue(dev: dev_queue, index: 0));
3604	}
3605
3606	/**
3607	* netdev_cap_txqueue - check if selected tx queue exceeds device queues
3608	* @dev: network device
3609	* @queue_index: given tx queue index
3610	*
3611	* Returns 0 if given tx queue index >= number of device tx queues,
3612	* otherwise returns the originally passed tx queue index.
3613	*/
3614	static inline u16 netdev_cap_txqueue(struct net_device *dev, u16 queue_index)
3615	{
3616	if (unlikely(queue_index >= dev->real_num_tx_queues)) {
3617	net_warn_ratelimited("%s selects TX queue %d, but real number of TX queues is %d\n",
3618	dev->name, queue_index,
3619	dev->real_num_tx_queues);
3620	return 0;
3621	}
3622
3623	return queue_index;
3624	}
3625
3626	/**
3627	* netif_running - test if up
3628	* @dev: network device
3629	*
3630	* Test if the device has been brought up.
3631	*/
3632	static inline bool netif_running(const struct net_device *dev)
3633	{
3634	return test_bit(__LINK_STATE_START, &dev->state);
3635	}
3636
3637	/*
3638	* Routines to manage the subqueues on a device. We only need start,
3639	* stop, and a check if it's stopped. All other device management is
3640	* done at the overall netdevice level.
3641	* Also test the device if we're multiqueue.
3642	*/
3643
3644	/**
3645	* netif_start_subqueue - allow sending packets on subqueue
3646	* @dev: network device
3647	* @queue_index: sub queue index
3648	*
3649	* Start individual transmit queue of a device with multiple transmit queues.
3650	*/
3651	static inline void netif_start_subqueue(struct net_device *dev, u16 queue_index)
3652	{
3653	struct netdev_queue *txq = netdev_get_tx_queue(dev, index: queue_index);
3654
3655	netif_tx_start_queue(dev_queue: txq);
3656	}
3657
3658	/**
3659	* netif_stop_subqueue - stop sending packets on subqueue
3660	* @dev: network device
3661	* @queue_index: sub queue index
3662	*
3663	* Stop individual transmit queue of a device with multiple transmit queues.
3664	*/
3665	static inline void netif_stop_subqueue(struct net_device *dev, u16 queue_index)
3666	{
3667	struct netdev_queue *txq = netdev_get_tx_queue(dev, index: queue_index);
3668	netif_tx_stop_queue(dev_queue: txq);
3669	}
3670
3671	/**
3672	* __netif_subqueue_stopped - test status of subqueue
3673	* @dev: network device
3674	* @queue_index: sub queue index
3675	*
3676	* Check individual transmit queue of a device with multiple transmit queues.
3677	*/
3678	static inline bool __netif_subqueue_stopped(const struct net_device *dev,
3679	u16 queue_index)
3680	{
3681	struct netdev_queue *txq = netdev_get_tx_queue(dev, index: queue_index);
3682
3683	return netif_tx_queue_stopped(dev_queue: txq);
3684	}
3685
3686	/**
3687	* netif_subqueue_stopped - test status of subqueue
3688	* @dev: network device
3689	* @skb: sub queue buffer pointer
3690	*
3691	* Check individual transmit queue of a device with multiple transmit queues.
3692	*/
3693	static inline bool netif_subqueue_stopped(const struct net_device *dev,
3694	struct sk_buff *skb)
3695	{
3696	return __netif_subqueue_stopped(dev, queue_index: skb_get_queue_mapping(skb));
3697	}
3698
3699	/**
3700	* netif_wake_subqueue - allow sending packets on subqueue
3701	* @dev: network device
3702	* @queue_index: sub queue index
3703	*
3704	* Resume individual transmit queue of a device with multiple transmit queues.
3705	*/
3706	static inline void netif_wake_subqueue(struct net_device *dev, u16 queue_index)
3707	{
3708	struct netdev_queue *txq = netdev_get_tx_queue(dev, index: queue_index);
3709
3710	netif_tx_wake_queue(dev_queue: txq);
3711	}
3712
3713	#ifdef CONFIG_XPS
3714	int netif_set_xps_queue(struct net_device *dev, const struct cpumask *mask,
3715	u16 index);
3716	int __netif_set_xps_queue(struct net_device *dev, const unsigned long *mask,
3717	u16 index, enum xps_map_type type);
3718
3719	/**
3720	* netif_attr_test_mask - Test a CPU or Rx queue set in a mask
3721	* @j: CPU/Rx queue index
3722	* @mask: bitmask of all cpus/rx queues
3723	* @nr_bits: number of bits in the bitmask
3724	*
3725	* Test if a CPU or Rx queue index is set in a mask of all CPU/Rx queues.
3726	*/
3727	static inline bool netif_attr_test_mask(unsigned long j,
3728	const unsigned long *mask,
3729	unsigned int nr_bits)
3730	{
3731	cpu_max_bits_warn(cpu: j, bits: nr_bits);
3732	return test_bit(j, mask);
3733	}
3734
3735	/**
3736	* netif_attr_test_online - Test for online CPU/Rx queue
3737	* @j: CPU/Rx queue index
3738	* @online_mask: bitmask for CPUs/Rx queues that are online
3739	* @nr_bits: number of bits in the bitmask
3740	*
3741	* Returns true if a CPU/Rx queue is online.
3742	*/
3743	static inline bool netif_attr_test_online(unsigned long j,
3744	const unsigned long *online_mask,
3745	unsigned int nr_bits)
3746	{
3747	cpu_max_bits_warn(cpu: j, bits: nr_bits);
3748
3749	if (online_mask)
3750	return test_bit(j, online_mask);
3751
3752	return (j < nr_bits);
3753	}
3754
3755	/**
3756	* netif_attrmask_next - get the next CPU/Rx queue in a cpu/Rx queues mask
3757	* @n: CPU/Rx queue index
3758	* @srcp: the cpumask/Rx queue mask pointer
3759	* @nr_bits: number of bits in the bitmask
3760	*
3761	* Returns >= nr_bits if no further CPUs/Rx queues set.
3762	*/
3763	static inline unsigned int netif_attrmask_next(int n, const unsigned long *srcp,
3764	unsigned int nr_bits)
3765	{
3766	/* -1 is a legal arg here. */
3767	if (n != -1)
3768	cpu_max_bits_warn(cpu: n, bits: nr_bits);
3769
3770	if (srcp)
3771	return find_next_bit(addr: srcp, size: nr_bits, offset: n + 1);
3772
3773	return n + 1;
3774	}
3775
3776	/**
3777	* netif_attrmask_next_and - get the next CPU/Rx queue in \*src1p & \*src2p
3778	* @n: CPU/Rx queue index
3779	* @src1p: the first CPUs/Rx queues mask pointer
3780	* @src2p: the second CPUs/Rx queues mask pointer
3781	* @nr_bits: number of bits in the bitmask
3782	*
3783	* Returns >= nr_bits if no further CPUs/Rx queues set in both.
3784	*/
3785	static inline int netif_attrmask_next_and(int n, const unsigned long *src1p,
3786	const unsigned long *src2p,
3787	unsigned int nr_bits)
3788	{
3789	/* -1 is a legal arg here. */
3790	if (n != -1)
3791	cpu_max_bits_warn(cpu: n, bits: nr_bits);
3792
3793	if (src1p && src2p)
3794	return find_next_and_bit(addr1: src1p, addr2: src2p, size: nr_bits, offset: n + 1);
3795	else if (src1p)
3796	return find_next_bit(addr: src1p, size: nr_bits, offset: n + 1);
3797	else if (src2p)
3798	return find_next_bit(addr: src2p, size: nr_bits, offset: n + 1);
3799
3800	return n + 1;
3801	}
3802	#else
3803	static inline int netif_set_xps_queue(struct net_device *dev,
3804	const struct cpumask *mask,
3805	u16 index)
3806	{
3807	return 0;
3808	}
3809
3810	static inline int __netif_set_xps_queue(struct net_device *dev,
3811	const unsigned long *mask,
3812	u16 index, enum xps_map_type type)
3813	{
3814	return 0;
3815	}
3816	#endif
3817
3818	/**
3819	* netif_is_multiqueue - test if device has multiple transmit queues
3820	* @dev: network device
3821	*
3822	* Check if device has multiple transmit queues
3823	*/
3824	static inline bool netif_is_multiqueue(const struct net_device *dev)
3825	{
3826	return dev->num_tx_queues > 1;
3827	}
3828
3829	int netif_set_real_num_tx_queues(struct net_device *dev, unsigned int txq);
3830
3831	#ifdef CONFIG_SYSFS
3832	int netif_set_real_num_rx_queues(struct net_device *dev, unsigned int rxq);
3833	#else
3834	static inline int netif_set_real_num_rx_queues(struct net_device *dev,
3835	unsigned int rxqs)
3836	{
3837	dev->real_num_rx_queues = rxqs;
3838	return 0;
3839	}
3840	#endif
3841	int netif_set_real_num_queues(struct net_device *dev,
3842	unsigned int txq, unsigned int rxq);
3843
3844	int netif_get_num_default_rss_queues(void);
3845
3846	void dev_kfree_skb_irq_reason(struct sk_buff *skb, enum skb_drop_reason reason);
3847	void dev_kfree_skb_any_reason(struct sk_buff *skb, enum skb_drop_reason reason);
3848
3849	/*
3850	* It is not allowed to call kfree_skb() or consume_skb() from hardware
3851	* interrupt context or with hardware interrupts being disabled.
3852	* (in_hardirq() || irqs_disabled())
3853	*
3854	* We provide four helpers that can be used in following contexts :
3855	*
3856	* dev_kfree_skb_irq(skb) when caller drops a packet from irq context,
3857	* replacing kfree_skb(skb)
3858	*
3859	* dev_consume_skb_irq(skb) when caller consumes a packet from irq context.
3860	* Typically used in place of consume_skb(skb) in TX completion path
3861	*
3862	* dev_kfree_skb_any(skb) when caller doesn't know its current irq context,
3863	* replacing kfree_skb(skb)
3864	*
3865	* dev_consume_skb_any(skb) when caller doesn't know its current irq context,
3866	* and consumed a packet. Used in place of consume_skb(skb)
3867	*/
3868	static inline void dev_kfree_skb_irq(struct sk_buff *skb)
3869	{
3870	dev_kfree_skb_irq_reason(skb, reason: SKB_DROP_REASON_NOT_SPECIFIED);
3871	}
3872
3873	static inline void dev_consume_skb_irq(struct sk_buff *skb)
3874	{
3875	dev_kfree_skb_irq_reason(skb, reason: SKB_CONSUMED);
3876	}
3877
3878	static inline void dev_kfree_skb_any(struct sk_buff *skb)
3879	{
3880	dev_kfree_skb_any_reason(skb, reason: SKB_DROP_REASON_NOT_SPECIFIED);
3881	}
3882
3883	static inline void dev_consume_skb_any(struct sk_buff *skb)
3884	{
3885	dev_kfree_skb_any_reason(skb, reason: SKB_CONSUMED);
3886	}
3887
3888	u32 bpf_prog_run_generic_xdp(struct sk_buff *skb, struct xdp_buff *xdp,
3889	struct bpf_prog *xdp_prog);
3890	void generic_xdp_tx(struct sk_buff *skb, struct bpf_prog *xdp_prog);
3891	int do_xdp_generic(struct bpf_prog *xdp_prog, struct sk_buff **pskb);
3892	int netif_rx(struct sk_buff *skb);
3893	int __netif_rx(struct sk_buff *skb);
3894
3895	int netif_receive_skb(struct sk_buff *skb);
3896	int netif_receive_skb_core(struct sk_buff *skb);
3897	void netif_receive_skb_list_internal(struct list_head *head);
3898	void netif_receive_skb_list(struct list_head *head);
3899	gro_result_t napi_gro_receive(struct napi_struct *napi, struct sk_buff *skb);
3900	void napi_gro_flush(struct napi_struct *napi, bool flush_old);
3901	struct sk_buff *napi_get_frags(struct napi_struct *napi);
3902	void napi_get_frags_check(struct napi_struct *napi);
3903	gro_result_t napi_gro_frags(struct napi_struct *napi);
3904
3905	static inline void napi_free_frags(struct napi_struct *napi)
3906	{
3907	kfree_skb(skb: napi->skb);
3908	napi->skb = NULL;
3909	}
3910
3911	bool netdev_is_rx_handler_busy(struct net_device *dev);
3912	int netdev_rx_handler_register(struct net_device *dev,
3913	rx_handler_func_t *rx_handler,
3914	void *rx_handler_data);
3915	void netdev_rx_handler_unregister(struct net_device *dev);
3916
3917	bool dev_valid_name(const char *name);
3918	static inline bool is_socket_ioctl_cmd(unsigned int cmd)
3919	{
3920	return _IOC_TYPE(cmd) == SOCK_IOC_TYPE;
3921	}
3922	int get_user_ifreq(struct ifreq *ifr, void __user **ifrdata, void __user *arg);
3923	int put_user_ifreq(struct ifreq *ifr, void __user *arg);
3924	int dev_ioctl(struct net *net, unsigned int cmd, struct ifreq *ifr,
3925	void __user *data, bool *need_copyout);
3926	int dev_ifconf(struct net *net, struct ifconf __user *ifc);
3927	int generic_hwtstamp_get_lower(struct net_device *dev,
3928	struct kernel_hwtstamp_config *kernel_cfg);
3929	int generic_hwtstamp_set_lower(struct net_device *dev,
3930	struct kernel_hwtstamp_config *kernel_cfg,
3931	struct netlink_ext_ack *extack);
3932	int dev_set_hwtstamp_phylib(struct net_device *dev,
3933	struct kernel_hwtstamp_config *cfg,
3934	struct netlink_ext_ack *extack);
3935	int dev_ethtool(struct net *net, struct ifreq *ifr, void __user *userdata);
3936	unsigned int dev_get_flags(const struct net_device *);
3937	int __dev_change_flags(struct net_device *dev, unsigned int flags,
3938	struct netlink_ext_ack *extack);
3939	int dev_change_flags(struct net_device *dev, unsigned int flags,
3940	struct netlink_ext_ack *extack);
3941	int dev_set_alias(struct net_device *, const char *, size_t);
3942	int dev_get_alias(const struct net_device *, char *, size_t);
3943	int __dev_change_net_namespace(struct net_device *dev, struct net *net,
3944	const char *pat, int new_ifindex);
3945	static inline
3946	int dev_change_net_namespace(struct net_device *dev, struct net *net,
3947	const char *pat)
3948	{
3949	return __dev_change_net_namespace(dev, net, pat, new_ifindex: 0);
3950	}
3951	int __dev_set_mtu(struct net_device *, int);
3952	int dev_set_mtu(struct net_device *, int);
3953	int dev_pre_changeaddr_notify(struct net_device *dev, const char *addr,
3954	struct netlink_ext_ack *extack);
3955	int dev_set_mac_address(struct net_device *dev, struct sockaddr *sa,
3956	struct netlink_ext_ack *extack);
3957	int dev_set_mac_address_user(struct net_device *dev, struct sockaddr *sa,
3958	struct netlink_ext_ack *extack);
3959	int dev_get_mac_address(struct sockaddr *sa, struct net *net, char *dev_name);
3960	int dev_get_port_parent_id(struct net_device *dev,
3961	struct netdev_phys_item_id *ppid, bool recurse);
3962	bool netdev_port_same_parent_id(struct net_device *a, struct net_device *b);
3963
3964	struct sk_buff *validate_xmit_skb_list(struct sk_buff *skb, struct net_device *dev, bool *again);
3965	struct sk_buff *dev_hard_start_xmit(struct sk_buff *skb, struct net_device *dev,
3966	struct netdev_queue *txq, int *ret);
3967
3968	int bpf_xdp_link_attach(const union bpf_attr *attr, struct bpf_prog *prog);
3969	u8 dev_xdp_prog_count(struct net_device *dev);
3970	u32 dev_xdp_prog_id(struct net_device *dev, enum bpf_xdp_mode mode);
3971
3972	int __dev_forward_skb(struct net_device *dev, struct sk_buff *skb);
3973	int dev_forward_skb(struct net_device *dev, struct sk_buff *skb);
3974	int dev_forward_skb_nomtu(struct net_device *dev, struct sk_buff *skb);
3975	bool is_skb_forwardable(const struct net_device *dev,
3976	const struct sk_buff *skb);
3977
3978	static __always_inline bool __is_skb_forwardable(const struct net_device *dev,
3979	const struct sk_buff *skb,
3980	const bool check_mtu)
3981	{
3982	const u32 vlan_hdr_len = 4; /* VLAN_HLEN */
3983	unsigned int len;
3984
3985	if (!(dev->flags & IFF_UP))
3986	return false;
3987
3988	if (!check_mtu)
3989	return true;
3990
3991	len = dev->mtu + dev->hard_header_len + vlan_hdr_len;
3992	if (skb->len <= len)
3993	return true;
3994
3995	/* if TSO is enabled, we don't care about the length as the packet
3996	* could be forwarded without being segmented before
3997	*/
3998	if (skb_is_gso(skb))
3999	return true;
4000
4001	return false;
4002	}
4003
4004	void netdev_core_stats_inc(struct net_device *dev, u32 offset);
4005
4006	#define DEV_CORE_STATS_INC(FIELD) \
4007	static inline void dev_core_stats_##FIELD##_inc(struct net_device *dev) \
4008	{ \
4009	netdev_core_stats_inc(dev, \
4010	offsetof(struct net_device_core_stats, FIELD)); \
4011	}
4012	DEV_CORE_STATS_INC(rx_dropped)
4013	DEV_CORE_STATS_INC(tx_dropped)
4014	DEV_CORE_STATS_INC(rx_nohandler)
4015	DEV_CORE_STATS_INC(rx_otherhost_dropped)
4016	#undef DEV_CORE_STATS_INC
4017
4018	static __always_inline int ____dev_forward_skb(struct net_device *dev,
4019	struct sk_buff *skb,
4020	const bool check_mtu)
4021	{
4022	if (skb_orphan_frags(skb, GFP_ATOMIC) ||
4023	unlikely(!__is_skb_forwardable(dev, skb, check_mtu))) {
4024	dev_core_stats_rx_dropped_inc(dev);
4025	kfree_skb(skb);
4026	return NET_RX_DROP;
4027	}
4028
4029	skb_scrub_packet(skb, xnet: !net_eq(net1: dev_net(dev), net2: dev_net(dev: skb->dev)));
4030	skb->priority = 0;
4031	return 0;
4032	}
4033
4034	bool dev_nit_active(struct net_device *dev);
4035	void dev_queue_xmit_nit(struct sk_buff *skb, struct net_device *dev);
4036
4037	static inline void __dev_put(struct net_device *dev)
4038	{
4039	if (dev) {
4040	#ifdef CONFIG_PCPU_DEV_REFCNT
4041	this_cpu_dec(*dev->pcpu_refcnt);
4042	#else
4043	refcount_dec(&dev->dev_refcnt);
4044	#endif
4045	}
4046	}
4047
4048	static inline void __dev_hold(struct net_device *dev)
4049	{
4050	if (dev) {
4051	#ifdef CONFIG_PCPU_DEV_REFCNT
4052	this_cpu_inc(*dev->pcpu_refcnt);
4053	#else
4054	refcount_inc(&dev->dev_refcnt);
4055	#endif
4056	}
4057	}
4058
4059	static inline void __netdev_tracker_alloc(struct net_device *dev,
4060	netdevice_tracker *tracker,
4061	gfp_t gfp)
4062	{
4063	#ifdef CONFIG_NET_DEV_REFCNT_TRACKER
4064	ref_tracker_alloc(dir: &dev->refcnt_tracker, trackerp: tracker, gfp);
4065	#endif
4066	}
4067
4068	/* netdev_tracker_alloc() can upgrade a prior untracked reference
4069	* taken by dev_get_by_name()/dev_get_by_index() to a tracked one.
4070	*/
4071	static inline void netdev_tracker_alloc(struct net_device *dev,
4072	netdevice_tracker *tracker, gfp_t gfp)
4073	{
4074	#ifdef CONFIG_NET_DEV_REFCNT_TRACKER
4075	refcount_dec(r: &dev->refcnt_tracker.no_tracker);
4076	__netdev_tracker_alloc(dev, tracker, gfp);
4077	#endif
4078	}
4079
4080	static inline void netdev_tracker_free(struct net_device *dev,
4081	netdevice_tracker *tracker)
4082	{
4083	#ifdef CONFIG_NET_DEV_REFCNT_TRACKER
4084	ref_tracker_free(dir: &dev->refcnt_tracker, trackerp: tracker);
4085	#endif
4086	}
4087
4088	static inline void netdev_hold(struct net_device *dev,
4089	netdevice_tracker *tracker, gfp_t gfp)
4090	{
4091	if (dev) {
4092	__dev_hold(dev);
4093	__netdev_tracker_alloc(dev, tracker, gfp);
4094	}
4095	}
4096
4097	static inline void netdev_put(struct net_device *dev,
4098	netdevice_tracker *tracker)
4099	{
4100	if (dev) {
4101	netdev_tracker_free(dev, tracker);
4102	__dev_put(dev);
4103	}
4104	}
4105
4106	/**
4107	* dev_hold - get reference to device
4108	* @dev: network device
4109	*
4110	* Hold reference to device to keep it from being freed.
4111	* Try using netdev_hold() instead.
4112	*/
4113	static inline void dev_hold(struct net_device *dev)
4114	{
4115	netdev_hold(dev, NULL, GFP_ATOMIC);
4116	}
4117
4118	/**
4119	* dev_put - release reference to device
4120	* @dev: network device
4121	*
4122	* Release reference to device to allow it to be freed.
4123	* Try using netdev_put() instead.
4124	*/
4125	static inline void dev_put(struct net_device *dev)
4126	{
4127	netdev_put(dev, NULL);
4128	}
4129
4130	static inline void netdev_ref_replace(struct net_device *odev,
4131	struct net_device *ndev,
4132	netdevice_tracker *tracker,
4133	gfp_t gfp)
4134	{
4135	if (odev)
4136	netdev_tracker_free(dev: odev, tracker);
4137
4138	__dev_hold(dev: ndev);
4139	__dev_put(dev: odev);
4140
4141	if (ndev)
4142	__netdev_tracker_alloc(dev: ndev, tracker, gfp);
4143	}
4144
4145	/* Carrier loss detection, dial on demand. The functions netif_carrier_on
4146	* and _off may be called from IRQ context, but it is caller
4147	* who is responsible for serialization of these calls.
4148	*
4149	* The name carrier is inappropriate, these functions should really be
4150	* called netif_lowerlayer_*() because they represent the state of any
4151	* kind of lower layer not just hardware media.
4152	*/
4153	void linkwatch_fire_event(struct net_device *dev);
4154
4155	/**
4156	* linkwatch_sync_dev - sync linkwatch for the given device
4157	* @dev: network device to sync linkwatch for
4158	*
4159	* Sync linkwatch for the given device, removing it from the
4160	* pending work list (if queued).
4161	*/
4162	void linkwatch_sync_dev(struct net_device *dev);
4163
4164	/**
4165	* netif_carrier_ok - test if carrier present
4166	* @dev: network device
4167	*
4168	* Check if carrier is present on device
4169	*/
4170	static inline bool netif_carrier_ok(const struct net_device *dev)
4171	{
4172	return !test_bit(__LINK_STATE_NOCARRIER, &dev->state);
4173	}
4174
4175	unsigned long dev_trans_start(struct net_device *dev);
4176
4177	void __netdev_watchdog_up(struct net_device *dev);
4178
4179	void netif_carrier_on(struct net_device *dev);
4180	void netif_carrier_off(struct net_device *dev);
4181	void netif_carrier_event(struct net_device *dev);
4182
4183	/**
4184	* netif_dormant_on - mark device as dormant.
4185	* @dev: network device
4186	*
4187	* Mark device as dormant (as per RFC2863).
4188	*
4189	* The dormant state indicates that the relevant interface is not
4190	* actually in a condition to pass packets (i.e., it is not 'up') but is
4191	* in a "pending" state, waiting for some external event. For "on-
4192	* demand" interfaces, this new state identifies the situation where the
4193	* interface is waiting for events to place it in the up state.
4194	*/
4195	static inline void netif_dormant_on(struct net_device *dev)
4196	{
4197	if (!test_and_set_bit(nr: __LINK_STATE_DORMANT, addr: &dev->state))
4198	linkwatch_fire_event(dev);
4199	}
4200
4201	/**
4202	* netif_dormant_off - set device as not dormant.
4203	* @dev: network device
4204	*
4205	* Device is not in dormant state.
4206	*/
4207	static inline void netif_dormant_off(struct net_device *dev)
4208	{
4209	if (test_and_clear_bit(nr: __LINK_STATE_DORMANT, addr: &dev->state))
4210	linkwatch_fire_event(dev);
4211	}
4212
4213	/**
4214	* netif_dormant - test if device is dormant
4215	* @dev: network device
4216	*
4217	* Check if device is dormant.
4218	*/
4219	static inline bool netif_dormant(const struct net_device *dev)
4220	{
4221	return test_bit(__LINK_STATE_DORMANT, &dev->state);
4222	}
4223
4224
4225	/**
4226	* netif_testing_on - mark device as under test.
4227	* @dev: network device
4228	*
4229	* Mark device as under test (as per RFC2863).
4230	*
4231	* The testing state indicates that some test(s) must be performed on
4232	* the interface. After completion, of the test, the interface state
4233	* will change to up, dormant, or down, as appropriate.
4234	*/
4235	static inline void netif_testing_on(struct net_device *dev)
4236	{
4237	if (!test_and_set_bit(nr: __LINK_STATE_TESTING, addr: &dev->state))
4238	linkwatch_fire_event(dev);
4239	}
4240
4241	/**
4242	* netif_testing_off - set device as not under test.
4243	* @dev: network device
4244	*
4245	* Device is not in testing state.
4246	*/
4247	static inline void netif_testing_off(struct net_device *dev)
4248	{
4249	if (test_and_clear_bit(nr: __LINK_STATE_TESTING, addr: &dev->state))
4250	linkwatch_fire_event(dev);
4251	}
4252
4253	/**
4254	* netif_testing - test if device is under test
4255	* @dev: network device
4256	*
4257	* Check if device is under test
4258	*/
4259	static inline bool netif_testing(const struct net_device *dev)
4260	{
4261	return test_bit(__LINK_STATE_TESTING, &dev->state);
4262	}
4263
4264
4265	/**
4266	* netif_oper_up - test if device is operational
4267	* @dev: network device
4268	*
4269	* Check if carrier is operational
4270	*/
4271	static inline bool netif_oper_up(const struct net_device *dev)
4272	{
4273	unsigned int operstate = READ_ONCE(dev->operstate);
4274
4275	return operstate == IF_OPER_UP ||
4276	operstate == IF_OPER_UNKNOWN /* backward compat */;
4277	}
4278
4279	/**
4280	* netif_device_present - is device available or removed
4281	* @dev: network device
4282	*
4283	* Check if device has not been removed from system.
4284	*/
4285	static inline bool netif_device_present(const struct net_device *dev)
4286	{
4287	return test_bit(__LINK_STATE_PRESENT, &dev->state);
4288	}
4289
4290	void netif_device_detach(struct net_device *dev);
4291
4292	void netif_device_attach(struct net_device *dev);
4293
4294	/*
4295	* Network interface message level settings
4296	*/
4297
4298	enum {
4299	NETIF_MSG_DRV_BIT,
4300	NETIF_MSG_PROBE_BIT,
4301	NETIF_MSG_LINK_BIT,
4302	NETIF_MSG_TIMER_BIT,
4303	NETIF_MSG_IFDOWN_BIT,
4304	NETIF_MSG_IFUP_BIT,
4305	NETIF_MSG_RX_ERR_BIT,
4306	NETIF_MSG_TX_ERR_BIT,
4307	NETIF_MSG_TX_QUEUED_BIT,
4308	NETIF_MSG_INTR_BIT,
4309	NETIF_MSG_TX_DONE_BIT,
4310	NETIF_MSG_RX_STATUS_BIT,
4311	NETIF_MSG_PKTDATA_BIT,
4312	NETIF_MSG_HW_BIT,
4313	NETIF_MSG_WOL_BIT,
4314
4315	/* When you add a new bit above, update netif_msg_class_names array
4316	* in net/ethtool/common.c
4317	*/
4318	NETIF_MSG_CLASS_COUNT,
4319	};
4320	/* Both ethtool_ops interface and internal driver implementation use u32 */
4321	static_assert(NETIF_MSG_CLASS_COUNT <= 32);
4322
4323	#define __NETIF_MSG_BIT(bit) ((u32)1 << (bit))
4324	#define __NETIF_MSG(name) __NETIF_MSG_BIT(NETIF_MSG_ ## name ## _BIT)
4325
4326	#define NETIF_MSG_DRV __NETIF_MSG(DRV)
4327	#define NETIF_MSG_PROBE __NETIF_MSG(PROBE)
4328	#define NETIF_MSG_LINK __NETIF_MSG(LINK)
4329	#define NETIF_MSG_TIMER __NETIF_MSG(TIMER)
4330	#define NETIF_MSG_IFDOWN __NETIF_MSG(IFDOWN)
4331	#define NETIF_MSG_IFUP __NETIF_MSG(IFUP)
4332	#define NETIF_MSG_RX_ERR __NETIF_MSG(RX_ERR)
4333	#define NETIF_MSG_TX_ERR __NETIF_MSG(TX_ERR)
4334	#define NETIF_MSG_TX_QUEUED __NETIF_MSG(TX_QUEUED)
4335	#define NETIF_MSG_INTR __NETIF_MSG(INTR)
4336	#define NETIF_MSG_TX_DONE __NETIF_MSG(TX_DONE)
4337	#define NETIF_MSG_RX_STATUS __NETIF_MSG(RX_STATUS)
4338	#define NETIF_MSG_PKTDATA __NETIF_MSG(PKTDATA)
4339	#define NETIF_MSG_HW __NETIF_MSG(HW)
4340	#define NETIF_MSG_WOL __NETIF_MSG(WOL)
4341
4342	#define netif_msg_drv(p) ((p)->msg_enable & NETIF_MSG_DRV)
4343	#define netif_msg_probe(p) ((p)->msg_enable & NETIF_MSG_PROBE)
4344	#define netif_msg_link(p) ((p)->msg_enable & NETIF_MSG_LINK)
4345	#define netif_msg_timer(p) ((p)->msg_enable & NETIF_MSG_TIMER)
4346	#define netif_msg_ifdown(p) ((p)->msg_enable & NETIF_MSG_IFDOWN)
4347	#define netif_msg_ifup(p) ((p)->msg_enable & NETIF_MSG_IFUP)
4348	#define netif_msg_rx_err(p) ((p)->msg_enable & NETIF_MSG_RX_ERR)
4349	#define netif_msg_tx_err(p) ((p)->msg_enable & NETIF_MSG_TX_ERR)
4350	#define netif_msg_tx_queued(p) ((p)->msg_enable & NETIF_MSG_TX_QUEUED)
4351	#define netif_msg_intr(p) ((p)->msg_enable & NETIF_MSG_INTR)
4352	#define netif_msg_tx_done(p) ((p)->msg_enable & NETIF_MSG_TX_DONE)
4353	#define netif_msg_rx_status(p) ((p)->msg_enable & NETIF_MSG_RX_STATUS)
4354	#define netif_msg_pktdata(p) ((p)->msg_enable & NETIF_MSG_PKTDATA)
4355	#define netif_msg_hw(p) ((p)->msg_enable & NETIF_MSG_HW)
4356	#define netif_msg_wol(p) ((p)->msg_enable & NETIF_MSG_WOL)
4357
4358	static inline u32 netif_msg_init(int debug_value, int default_msg_enable_bits)
4359	{
4360	/* use default */
4361	if (debug_value < 0 || debug_value >= (sizeof(u32) * 8))
4362	return default_msg_enable_bits;
4363	if (debug_value == 0) /* no output */
4364	return 0;
4365	/* set low N bits */
4366	return (1U << debug_value) - 1;
4367	}
4368
4369	static inline void __netif_tx_lock(struct netdev_queue *txq, int cpu)
4370	{
4371	spin_lock(lock: &txq->_xmit_lock);
4372	/* Pairs with READ_ONCE() in __dev_queue_xmit() */
4373	WRITE_ONCE(txq->xmit_lock_owner, cpu);
4374	}
4375
4376	static inline bool __netif_tx_acquire(struct netdev_queue *txq)
4377	{
4378	__acquire(&txq->_xmit_lock);
4379	return true;
4380	}
4381
4382	static inline void __netif_tx_release(struct netdev_queue *txq)
4383	{
4384	__release(&txq->_xmit_lock);
4385	}
4386
4387	static inline void __netif_tx_lock_bh(struct netdev_queue *txq)
4388	{
4389	spin_lock_bh(lock: &txq->_xmit_lock);
4390	/* Pairs with READ_ONCE() in __dev_queue_xmit() */
4391	WRITE_ONCE(txq->xmit_lock_owner, smp_processor_id());
4392	}
4393
4394	static inline bool __netif_tx_trylock(struct netdev_queue *txq)
4395	{
4396	bool ok = spin_trylock(lock: &txq->_xmit_lock);
4397
4398	if (likely(ok)) {
4399	/* Pairs with READ_ONCE() in __dev_queue_xmit() */
4400	WRITE_ONCE(txq->xmit_lock_owner, smp_processor_id());
4401	}
4402	return ok;
4403	}
4404
4405	static inline void __netif_tx_unlock(struct netdev_queue *txq)
4406	{
4407	/* Pairs with READ_ONCE() in __dev_queue_xmit() */
4408	WRITE_ONCE(txq->xmit_lock_owner, -1);
4409	spin_unlock(lock: &txq->_xmit_lock);
4410	}
4411
4412	static inline void __netif_tx_unlock_bh(struct netdev_queue *txq)
4413	{
4414	/* Pairs with READ_ONCE() in __dev_queue_xmit() */
4415	WRITE_ONCE(txq->xmit_lock_owner, -1);
4416	spin_unlock_bh(lock: &txq->_xmit_lock);
4417	}
4418
4419	/*
4420	* txq->trans_start can be read locklessly from dev_watchdog()
4421	*/
4422	static inline void txq_trans_update(struct netdev_queue *txq)
4423	{
4424	if (txq->xmit_lock_owner != -1)
4425	WRITE_ONCE(txq->trans_start, jiffies);
4426	}
4427
4428	static inline void txq_trans_cond_update(struct netdev_queue *txq)
4429	{
4430	unsigned long now = jiffies;
4431
4432	if (READ_ONCE(txq->trans_start) != now)
4433	WRITE_ONCE(txq->trans_start, now);
4434	}
4435
4436	/* legacy drivers only, netdev_start_xmit() sets txq->trans_start */
4437	static inline void netif_trans_update(struct net_device *dev)
4438	{
4439	struct netdev_queue *txq = netdev_get_tx_queue(dev, index: 0);
4440
4441	txq_trans_cond_update(txq);
4442	}
4443
4444	/**
4445	* netif_tx_lock - grab network device transmit lock
4446	* @dev: network device
4447	*
4448	* Get network device transmit lock
4449	*/
4450	void netif_tx_lock(struct net_device *dev);
4451
4452	static inline void netif_tx_lock_bh(struct net_device *dev)
4453	{
4454	local_bh_disable();
4455	netif_tx_lock(dev);
4456	}
4457
4458	void netif_tx_unlock(struct net_device *dev);
4459
4460	static inline void netif_tx_unlock_bh(struct net_device *dev)
4461	{
4462	netif_tx_unlock(dev);
4463	local_bh_enable();
4464	}
4465
4466	#define HARD_TX_LOCK(dev, txq, cpu) { \
4467	if ((dev->features & NETIF_F_LLTX) == 0) { \
4468	__netif_tx_lock(txq, cpu); \
4469	} else { \
4470	__netif_tx_acquire(txq); \
4471	} \
4472	}
4473
4474	#define HARD_TX_TRYLOCK(dev, txq) \
4475	(((dev->features & NETIF_F_LLTX) == 0) ? \
4476	__netif_tx_trylock(txq) : \
4477	__netif_tx_acquire(txq))
4478
4479	#define HARD_TX_UNLOCK(dev, txq) { \
4480	if ((dev->features & NETIF_F_LLTX) == 0) { \
4481	__netif_tx_unlock(txq); \
4482	} else { \
4483	__netif_tx_release(txq); \
4484	} \
4485	}
4486
4487	static inline void netif_tx_disable(struct net_device *dev)
4488	{
4489	unsigned int i;
4490	int cpu;
4491
4492	local_bh_disable();
4493	cpu = smp_processor_id();
4494	spin_lock(lock: &dev->tx_global_lock);
4495	for (i = 0; i < dev->num_tx_queues; i++) {
4496	struct netdev_queue *txq = netdev_get_tx_queue(dev, index: i);
4497
4498	__netif_tx_lock(txq, cpu);
4499	netif_tx_stop_queue(dev_queue: txq);
4500	__netif_tx_unlock(txq);
4501	}
4502	spin_unlock(lock: &dev->tx_global_lock);
4503	local_bh_enable();
4504	}
4505
4506	static inline void netif_addr_lock(struct net_device *dev)
4507	{
4508	unsigned char nest_level = 0;
4509
4510	#ifdef CONFIG_LOCKDEP
4511	nest_level = dev->nested_level;
4512	#endif
4513	spin_lock_nested(&dev->addr_list_lock, nest_level);
4514	}
4515
4516	static inline void netif_addr_lock_bh(struct net_device *dev)
4517	{
4518	unsigned char nest_level = 0;
4519
4520	#ifdef CONFIG_LOCKDEP
4521	nest_level = dev->nested_level;
4522	#endif
4523	local_bh_disable();
4524	spin_lock_nested(&dev->addr_list_lock, nest_level);
4525	}
4526
4527	static inline void netif_addr_unlock(struct net_device *dev)
4528	{
4529	spin_unlock(lock: &dev->addr_list_lock);
4530	}
4531
4532	static inline void netif_addr_unlock_bh(struct net_device *dev)
4533	{
4534	spin_unlock_bh(lock: &dev->addr_list_lock);
4535	}
4536
4537	/*
4538	* dev_addrs walker. Should be used only for read access. Call with
4539	* rcu_read_lock held.
4540	*/
4541	#define for_each_dev_addr(dev, ha) \
4542	list_for_each_entry_rcu(ha, &dev->dev_addrs.list, list)
4543
4544	/* These functions live elsewhere (drivers/net/net_init.c, but related) */
4545
4546	void ether_setup(struct net_device *dev);
4547
4548	/* Support for loadable net-drivers */
4549	struct net_device *alloc_netdev_mqs(int sizeof_priv, const char *name,
4550	unsigned char name_assign_type,
4551	void (*setup)(struct net_device *),
4552	unsigned int txqs, unsigned int rxqs);
4553	#define alloc_netdev(sizeof_priv, name, name_assign_type, setup) \
4554	alloc_netdev_mqs(sizeof_priv, name, name_assign_type, setup, 1, 1)
4555
4556	#define alloc_netdev_mq(sizeof_priv, name, name_assign_type, setup, count) \
4557	alloc_netdev_mqs(sizeof_priv, name, name_assign_type, setup, count, \
4558	count)
4559
4560	int register_netdev(struct net_device *dev);
4561	void unregister_netdev(struct net_device *dev);
4562
4563	int devm_register_netdev(struct device *dev, struct net_device *ndev);
4564
4565	/* General hardware address lists handling functions */
4566	int __hw_addr_sync(struct netdev_hw_addr_list *to_list,
4567	struct netdev_hw_addr_list *from_list, int addr_len);
4568	void __hw_addr_unsync(struct netdev_hw_addr_list *to_list,
4569	struct netdev_hw_addr_list *from_list, int addr_len);
4570	int __hw_addr_sync_dev(struct netdev_hw_addr_list *list,
4571	struct net_device *dev,
4572	int (*sync)(struct net_device *, const unsigned char *),
4573	int (*unsync)(struct net_device *,
4574	const unsigned char *));
4575	int __hw_addr_ref_sync_dev(struct netdev_hw_addr_list *list,
4576	struct net_device *dev,
4577	int (*sync)(struct net_device *,
4578	const unsigned char *, int),
4579	int (*unsync)(struct net_device *,
4580	const unsigned char *, int));
4581	void __hw_addr_ref_unsync_dev(struct netdev_hw_addr_list *list,
4582	struct net_device *dev,
4583	int (*unsync)(struct net_device *,
4584	const unsigned char *, int));
4585	void __hw_addr_unsync_dev(struct netdev_hw_addr_list *list,
4586	struct net_device *dev,
4587	int (*unsync)(struct net_device *,
4588	const unsigned char *));
4589	void __hw_addr_init(struct netdev_hw_addr_list *list);
4590
4591	/* Functions used for device addresses handling */
4592	void dev_addr_mod(struct net_device *dev, unsigned int offset,
4593	const void *addr, size_t len);
4594
4595	static inline void
4596	__dev_addr_set(struct net_device *dev, const void *addr, size_t len)
4597	{
4598	dev_addr_mod(dev, offset: 0, addr, len);
4599	}
4600
4601	static inline void dev_addr_set(struct net_device *dev, const u8 *addr)
4602	{
4603	__dev_addr_set(dev, addr, len: dev->addr_len);
4604	}
4605
4606	int dev_addr_add(struct net_device *dev, const unsigned char *addr,
4607	unsigned char addr_type);
4608	int dev_addr_del(struct net_device *dev, const unsigned char *addr,
4609	unsigned char addr_type);
4610
4611	/* Functions used for unicast addresses handling */
4612	int dev_uc_add(struct net_device *dev, const unsigned char *addr);
4613	int dev_uc_add_excl(struct net_device *dev, const unsigned char *addr);
4614	int dev_uc_del(struct net_device *dev, const unsigned char *addr);
4615	int dev_uc_sync(struct net_device *to, struct net_device *from);
4616	int dev_uc_sync_multiple(struct net_device *to, struct net_device *from);
4617	void dev_uc_unsync(struct net_device *to, struct net_device *from);
4618	void dev_uc_flush(struct net_device *dev);
4619	void dev_uc_init(struct net_device *dev);
4620
4621	/**
4622	* __dev_uc_sync - Synchonize device's unicast list
4623	* @dev: device to sync
4624	* @sync: function to call if address should be added
4625	* @unsync: function to call if address should be removed
4626	*
4627	* Add newly added addresses to the interface, and release
4628	* addresses that have been deleted.
4629	*/
4630	static inline int __dev_uc_sync(struct net_device *dev,
4631	int (*sync)(struct net_device *,
4632	const unsigned char *),
4633	int (*unsync)(struct net_device *,
4634	const unsigned char *))
4635	{
4636	return __hw_addr_sync_dev(list: &dev->uc, dev, sync, unsync);
4637	}
4638
4639	/**
4640	* __dev_uc_unsync - Remove synchronized addresses from device
4641	* @dev: device to sync
4642	* @unsync: function to call if address should be removed
4643	*
4644	* Remove all addresses that were added to the device by dev_uc_sync().
4645	*/
4646	static inline void __dev_uc_unsync(struct net_device *dev,
4647	int (*unsync)(struct net_device *,
4648	const unsigned char *))
4649	{
4650	__hw_addr_unsync_dev(list: &dev->uc, dev, unsync);
4651	}
4652
4653	/* Functions used for multicast addresses handling */
4654	int dev_mc_add(struct net_device *dev, const unsigned char *addr);
4655	int dev_mc_add_global(struct net_device *dev, const unsigned char *addr);
4656	int dev_mc_add_excl(struct net_device *dev, const unsigned char *addr);
4657	int dev_mc_del(struct net_device *dev, const unsigned char *addr);
4658	int dev_mc_del_global(struct net_device *dev, const unsigned char *addr);
4659	int dev_mc_sync(struct net_device *to, struct net_device *from);
4660	int dev_mc_sync_multiple(struct net_device *to, struct net_device *from);
4661	void dev_mc_unsync(struct net_device *to, struct net_device *from);
4662	void dev_mc_flush(struct net_device *dev);
4663	void dev_mc_init(struct net_device *dev);
4664
4665	/**
4666	* __dev_mc_sync - Synchonize device's multicast list
4667	* @dev: device to sync
4668	* @sync: function to call if address should be added
4669	* @unsync: function to call if address should be removed
4670	*
4671	* Add newly added addresses to the interface, and release
4672	* addresses that have been deleted.
4673	*/
4674	static inline int __dev_mc_sync(struct net_device *dev,
4675	int (*sync)(struct net_device *,
4676	const unsigned char *),
4677	int (*unsync)(struct net_device *,
4678	const unsigned char *))
4679	{
4680	return __hw_addr_sync_dev(list: &dev->mc, dev, sync, unsync);
4681	}
4682
4683	/**
4684	* __dev_mc_unsync - Remove synchronized addresses from device
4685	* @dev: device to sync
4686	* @unsync: function to call if address should be removed
4687	*
4688	* Remove all addresses that were added to the device by dev_mc_sync().
4689	*/
4690	static inline void __dev_mc_unsync(struct net_device *dev,
4691	int (*unsync)(struct net_device *,
4692	const unsigned char *))
4693	{
4694	__hw_addr_unsync_dev(list: &dev->mc, dev, unsync);
4695	}
4696
4697	/* Functions used for secondary unicast and multicast support */
4698	void dev_set_rx_mode(struct net_device *dev);
4699	int dev_set_promiscuity(struct net_device *dev, int inc);
4700	int dev_set_allmulti(struct net_device *dev, int inc);
4701	void netdev_state_change(struct net_device *dev);
4702	void __netdev_notify_peers(struct net_device *dev);
4703	void netdev_notify_peers(struct net_device *dev);
4704	void netdev_features_change(struct net_device *dev);
4705	/* Load a device via the kmod */
4706	void dev_load(struct net *net, const char *name);
4707	struct rtnl_link_stats64 *dev_get_stats(struct net_device *dev,
4708	struct rtnl_link_stats64 *storage);
4709	void netdev_stats_to_stats64(struct rtnl_link_stats64 *stats64,
4710	const struct net_device_stats *netdev_stats);
4711	void dev_fetch_sw_netstats(struct rtnl_link_stats64 *s,
4712	const struct pcpu_sw_netstats __percpu *netstats);
4713	void dev_get_tstats64(struct net_device *dev, struct rtnl_link_stats64 *s);
4714
4715	enum {
4716	NESTED_SYNC_IMM_BIT,
4717	NESTED_SYNC_TODO_BIT,
4718	};
4719
4720	#define __NESTED_SYNC_BIT(bit) ((u32)1 << (bit))
4721	#define __NESTED_SYNC(name) __NESTED_SYNC_BIT(NESTED_SYNC_ ## name ## _BIT)
4722
4723	#define NESTED_SYNC_IMM __NESTED_SYNC(IMM)
4724	#define NESTED_SYNC_TODO __NESTED_SYNC(TODO)
4725
4726	struct netdev_nested_priv {
4727	unsigned char flags;
4728	void *data;
4729	};
4730
4731	bool netdev_has_upper_dev(struct net_device *dev, struct net_device *upper_dev);
4732	struct net_device *netdev_upper_get_next_dev_rcu(struct net_device *dev,
4733	struct list_head **iter);
4734
4735	/* iterate through upper list, must be called under RCU read lock */
4736	#define netdev_for_each_upper_dev_rcu(dev, updev, iter) \
4737	for (iter = &(dev)->adj_list.upper, \
4738	updev = netdev_upper_get_next_dev_rcu(dev, &(iter)); \
4739	updev; \
4740	updev = netdev_upper_get_next_dev_rcu(dev, &(iter)))
4741
4742	int netdev_walk_all_upper_dev_rcu(struct net_device *dev,
4743	int (*fn)(struct net_device *upper_dev,
4744	struct netdev_nested_priv *priv),
4745	struct netdev_nested_priv *priv);
4746
4747	bool netdev_has_upper_dev_all_rcu(struct net_device *dev,
4748	struct net_device *upper_dev);
4749
4750	bool netdev_has_any_upper_dev(struct net_device *dev);
4751
4752	void *netdev_lower_get_next_private(struct net_device *dev,
4753	struct list_head **iter);
4754	void *netdev_lower_get_next_private_rcu(struct net_device *dev,
4755	struct list_head **iter);
4756
4757	#define netdev_for_each_lower_private(dev, priv, iter) \
4758	for (iter = (dev)->adj_list.lower.next, \
4759	priv = netdev_lower_get_next_private(dev, &(iter)); \
4760	priv; \
4761	priv = netdev_lower_get_next_private(dev, &(iter)))
4762
4763	#define netdev_for_each_lower_private_rcu(dev, priv, iter) \
4764	for (iter = &(dev)->adj_list.lower, \
4765	priv = netdev_lower_get_next_private_rcu(dev, &(iter)); \
4766	priv; \
4767	priv = netdev_lower_get_next_private_rcu(dev, &(iter)))
4768
4769	void *netdev_lower_get_next(struct net_device *dev,
4770	struct list_head **iter);
4771
4772	#define netdev_for_each_lower_dev(dev, ldev, iter) \
4773	for (iter = (dev)->adj_list.lower.next, \
4774	ldev = netdev_lower_get_next(dev, &(iter)); \
4775	ldev; \
4776	ldev = netdev_lower_get_next(dev, &(iter)))
4777
4778	struct net_device *netdev_next_lower_dev_rcu(struct net_device *dev,
4779	struct list_head **iter);
4780	int netdev_walk_all_lower_dev(struct net_device *dev,
4781	int (*fn)(struct net_device *lower_dev,
4782	struct netdev_nested_priv *priv),
4783	struct netdev_nested_priv *priv);
4784	int netdev_walk_all_lower_dev_rcu(struct net_device *dev,
4785	int (*fn)(struct net_device *lower_dev,
4786	struct netdev_nested_priv *priv),
4787	struct netdev_nested_priv *priv);
4788
4789	void *netdev_adjacent_get_private(struct list_head *adj_list);
4790	void *netdev_lower_get_first_private_rcu(struct net_device *dev);
4791	struct net_device *netdev_master_upper_dev_get(struct net_device *dev);
4792	struct net_device *netdev_master_upper_dev_get_rcu(struct net_device *dev);
4793	int netdev_upper_dev_link(struct net_device *dev, struct net_device *upper_dev,
4794	struct netlink_ext_ack *extack);
4795	int netdev_master_upper_dev_link(struct net_device *dev,
4796	struct net_device *upper_dev,
4797	void *upper_priv, void *upper_info,
4798	struct netlink_ext_ack *extack);
4799	void netdev_upper_dev_unlink(struct net_device *dev,
4800	struct net_device *upper_dev);
4801	int netdev_adjacent_change_prepare(struct net_device *old_dev,
4802	struct net_device *new_dev,
4803	struct net_device *dev,
4804	struct netlink_ext_ack *extack);
4805	void netdev_adjacent_change_commit(struct net_device *old_dev,
4806	struct net_device *new_dev,
4807	struct net_device *dev);
4808	void netdev_adjacent_change_abort(struct net_device *old_dev,
4809	struct net_device *new_dev,
4810	struct net_device *dev);
4811	void netdev_adjacent_rename_links(struct net_device *dev, char *oldname);
4812	void *netdev_lower_dev_get_private(struct net_device *dev,
4813	struct net_device *lower_dev);
4814	void netdev_lower_state_changed(struct net_device *lower_dev,
4815	void *lower_state_info);
4816
4817	/* RSS keys are 40 or 52 bytes long */
4818	#define NETDEV_RSS_KEY_LEN 52
4819	extern u8 netdev_rss_key[NETDEV_RSS_KEY_LEN] __read_mostly;
4820	void netdev_rss_key_fill(void *buffer, size_t len);
4821
4822	int skb_checksum_help(struct sk_buff *skb);
4823	int skb_crc32c_csum_help(struct sk_buff *skb);
4824	int skb_csum_hwoffload_help(struct sk_buff *skb,
4825	const netdev_features_t features);
4826
4827	struct netdev_bonding_info {
4828	ifslave slave;
4829	ifbond master;
4830	};
4831
4832	struct netdev_notifier_bonding_info {
4833	struct netdev_notifier_info info; /* must be first */
4834	struct netdev_bonding_info bonding_info;
4835	};
4836
4837	void netdev_bonding_info_change(struct net_device *dev,
4838	struct netdev_bonding_info *bonding_info);
4839
4840	#if IS_ENABLED(CONFIG_ETHTOOL_NETLINK)
4841	void ethtool_notify(struct net_device *dev, unsigned int cmd, const void *data);
4842	#else
4843	static inline void ethtool_notify(struct net_device *dev, unsigned int cmd,
4844	const void *data)
4845	{
4846	}
4847	#endif
4848
4849	__be16 skb_network_protocol(struct sk_buff *skb, int *depth);
4850
4851	static inline bool can_checksum_protocol(netdev_features_t features,
4852	__be16 protocol)
4853	{
4854	if (protocol == htons(ETH_P_FCOE))
4855	return !!(features & NETIF_F_FCOE_CRC);
4856
4857	/* Assume this is an IP checksum (not SCTP CRC) */
4858
4859	if (features & NETIF_F_HW_CSUM) {
4860	/* Can checksum everything */
4861	return true;
4862	}
4863
4864	switch (protocol) {
4865	case htons(ETH_P_IP):
4866	return !!(features & NETIF_F_IP_CSUM);
4867	case htons(ETH_P_IPV6):
4868	return !!(features & NETIF_F_IPV6_CSUM);
4869	default:
4870	return false;
4871	}
4872	}
4873
4874	#ifdef CONFIG_BUG
4875	void netdev_rx_csum_fault(struct net_device *dev, struct sk_buff *skb);
4876	#else
4877	static inline void netdev_rx_csum_fault(struct net_device *dev,
4878	struct sk_buff *skb)
4879	{
4880	}
4881	#endif
4882	/* rx skb timestamps */
4883	void net_enable_timestamp(void);
4884	void net_disable_timestamp(void);
4885
4886	static inline ktime_t netdev_get_tstamp(struct net_device *dev,
4887	const struct skb_shared_hwtstamps *hwtstamps,
4888	bool cycles)
4889	{
4890	const struct net_device_ops *ops = dev->netdev_ops;
4891
4892	if (ops->ndo_get_tstamp)
4893	return ops->ndo_get_tstamp(dev, hwtstamps, cycles);
4894
4895	return hwtstamps->hwtstamp;
4896	}
4897
4898	static inline netdev_tx_t __netdev_start_xmit(const struct net_device_ops *ops,
4899	struct sk_buff *skb, struct net_device *dev,
4900	bool more)
4901	{
4902	__this_cpu_write(softnet_data.xmit.more, more);
4903	return ops->ndo_start_xmit(skb, dev);
4904	}
4905
4906	static inline bool netdev_xmit_more(void)
4907	{
4908	return __this_cpu_read(softnet_data.xmit.more);
4909	}
4910
4911	static inline netdev_tx_t netdev_start_xmit(struct sk_buff *skb, struct net_device *dev,
4912	struct netdev_queue *txq, bool more)
4913	{
4914	const struct net_device_ops *ops = dev->netdev_ops;
4915	netdev_tx_t rc;
4916
4917	rc = __netdev_start_xmit(ops, skb, dev, more);
4918	if (rc == NETDEV_TX_OK)
4919	txq_trans_update(txq);
4920
4921	return rc;
4922	}
4923
4924	int netdev_class_create_file_ns(const struct class_attribute *class_attr,
4925	const void *ns);
4926	void netdev_class_remove_file_ns(const struct class_attribute *class_attr,
4927	const void *ns);
4928
4929	extern const struct kobj_ns_type_operations net_ns_type_operations;
4930
4931	const char *netdev_drivername(const struct net_device *dev);
4932
4933	static inline netdev_features_t netdev_intersect_features(netdev_features_t f1,
4934	netdev_features_t f2)
4935	{
4936	if ((f1 ^ f2) & NETIF_F_HW_CSUM) {
4937	if (f1 & NETIF_F_HW_CSUM)
4938	f1 |= (NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM);
4939	else
4940	f2 |= (NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM);
4941	}
4942
4943	return f1 & f2;
4944	}
4945
4946	static inline netdev_features_t netdev_get_wanted_features(
4947	struct net_device *dev)
4948	{
4949	return (dev->features & ~dev->hw_features) | dev->wanted_features;
4950	}
4951	netdev_features_t netdev_increment_features(netdev_features_t all,
4952	netdev_features_t one, netdev_features_t mask);
4953
4954	/* Allow TSO being used on stacked device :
4955	* Performing the GSO segmentation before last device
4956	* is a performance improvement.
4957	*/
4958	static inline netdev_features_t netdev_add_tso_features(netdev_features_t features,
4959	netdev_features_t mask)
4960	{
4961	return netdev_increment_features(all: features, NETIF_F_ALL_TSO, mask);
4962	}
4963
4964	int __netdev_update_features(struct net_device *dev);
4965	void netdev_update_features(struct net_device *dev);
4966	void netdev_change_features(struct net_device *dev);
4967
4968	void netif_stacked_transfer_operstate(const struct net_device *rootdev,
4969	struct net_device *dev);
4970
4971	netdev_features_t passthru_features_check(struct sk_buff *skb,
4972	struct net_device *dev,
4973	netdev_features_t features);
4974	netdev_features_t netif_skb_features(struct sk_buff *skb);
4975	void skb_warn_bad_offload(const struct sk_buff *skb);
4976
4977	static inline bool net_gso_ok(netdev_features_t features, int gso_type)
4978	{
4979	netdev_features_t feature = (netdev_features_t)gso_type << NETIF_F_GSO_SHIFT;
4980
4981	/* check flags correspondence */
4982	BUILD_BUG_ON(SKB_GSO_TCPV4 != (NETIF_F_TSO >> NETIF_F_GSO_SHIFT));
4983	BUILD_BUG_ON(SKB_GSO_DODGY != (NETIF_F_GSO_ROBUST >> NETIF_F_GSO_SHIFT));
4984	BUILD_BUG_ON(SKB_GSO_TCP_ECN != (NETIF_F_TSO_ECN >> NETIF_F_GSO_SHIFT));
4985	BUILD_BUG_ON(SKB_GSO_TCP_FIXEDID != (NETIF_F_TSO_MANGLEID >> NETIF_F_GSO_SHIFT));
4986	BUILD_BUG_ON(SKB_GSO_TCPV6 != (NETIF_F_TSO6 >> NETIF_F_GSO_SHIFT));
4987	BUILD_BUG_ON(SKB_GSO_FCOE != (NETIF_F_FSO >> NETIF_F_GSO_SHIFT));
4988	BUILD_BUG_ON(SKB_GSO_GRE != (NETIF_F_GSO_GRE >> NETIF_F_GSO_SHIFT));
4989	BUILD_BUG_ON(SKB_GSO_GRE_CSUM != (NETIF_F_GSO_GRE_CSUM >> NETIF_F_GSO_SHIFT));
4990	BUILD_BUG_ON(SKB_GSO_IPXIP4 != (NETIF_F_GSO_IPXIP4 >> NETIF_F_GSO_SHIFT));
4991	BUILD_BUG_ON(SKB_GSO_IPXIP6 != (NETIF_F_GSO_IPXIP6 >> NETIF_F_GSO_SHIFT));
4992	BUILD_BUG_ON(SKB_GSO_UDP_TUNNEL != (NETIF_F_GSO_UDP_TUNNEL >> NETIF_F_GSO_SHIFT));
4993	BUILD_BUG_ON(SKB_GSO_UDP_TUNNEL_CSUM != (NETIF_F_GSO_UDP_TUNNEL_CSUM >> NETIF_F_GSO_SHIFT));
4994	BUILD_BUG_ON(SKB_GSO_PARTIAL != (NETIF_F_GSO_PARTIAL >> NETIF_F_GSO_SHIFT));
4995	BUILD_BUG_ON(SKB_GSO_TUNNEL_REMCSUM != (NETIF_F_GSO_TUNNEL_REMCSUM >> NETIF_F_GSO_SHIFT));
4996	BUILD_BUG_ON(SKB_GSO_SCTP != (NETIF_F_GSO_SCTP >> NETIF_F_GSO_SHIFT));
4997	BUILD_BUG_ON(SKB_GSO_ESP != (NETIF_F_GSO_ESP >> NETIF_F_GSO_SHIFT));
4998	BUILD_BUG_ON(SKB_GSO_UDP != (NETIF_F_GSO_UDP >> NETIF_F_GSO_SHIFT));
4999	BUILD_BUG_ON(SKB_GSO_UDP_L4 != (NETIF_F_GSO_UDP_L4 >> NETIF_F_GSO_SHIFT));
5000	BUILD_BUG_ON(SKB_GSO_FRAGLIST != (NETIF_F_GSO_FRAGLIST >> NETIF_F_GSO_SHIFT));
5001
5002	return (features & feature) == feature;
5003	}
5004
5005	static inline bool skb_gso_ok(struct sk_buff *skb, netdev_features_t features)
5006	{
5007	return net_gso_ok(features, skb_shinfo(skb)->gso_type) &&
5008	(!skb_has_frag_list(skb) || (features & NETIF_F_FRAGLIST));
5009	}
5010
5011	static inline bool netif_needs_gso(struct sk_buff *skb,
5012	netdev_features_t features)
5013	{
5014	return skb_is_gso(skb) && (!skb_gso_ok(skb, features) ||
5015	unlikely((skb->ip_summed != CHECKSUM_PARTIAL) &&
5016	(skb->ip_summed != CHECKSUM_UNNECESSARY)));
5017	}
5018
5019	void netif_set_tso_max_size(struct net_device *dev, unsigned int size);
5020	void netif_set_tso_max_segs(struct net_device *dev, unsigned int segs);
5021	void netif_inherit_tso_max(struct net_device *to,
5022	const struct net_device *from);
5023
5024	static inline bool netif_is_macsec(const struct net_device *dev)
5025	{
5026	return dev->priv_flags & IFF_MACSEC;
5027	}
5028
5029	static inline bool netif_is_macvlan(const struct net_device *dev)
5030	{
5031	return dev->priv_flags & IFF_MACVLAN;
5032	}
5033
5034	static inline bool netif_is_macvlan_port(const struct net_device *dev)
5035	{
5036	return dev->priv_flags & IFF_MACVLAN_PORT;
5037	}
5038
5039	static inline bool netif_is_bond_master(const struct net_device *dev)
5040	{
5041	return dev->flags & IFF_MASTER && dev->priv_flags & IFF_BONDING;
5042	}
5043
5044	static inline bool netif_is_bond_slave(const struct net_device *dev)
5045	{
5046	return dev->flags & IFF_SLAVE && dev->priv_flags & IFF_BONDING;
5047	}
5048
5049	static inline bool netif_supports_nofcs(struct net_device *dev)
5050	{
5051	return dev->priv_flags & IFF_SUPP_NOFCS;
5052	}
5053
5054	static inline bool netif_has_l3_rx_handler(const struct net_device *dev)
5055	{
5056	return dev->priv_flags & IFF_L3MDEV_RX_HANDLER;
5057	}
5058
5059	static inline bool netif_is_l3_master(const struct net_device *dev)
5060	{
5061	return dev->priv_flags & IFF_L3MDEV_MASTER;
5062	}
5063
5064	static inline bool netif_is_l3_slave(const struct net_device *dev)
5065	{
5066	return dev->priv_flags & IFF_L3MDEV_SLAVE;
5067	}
5068
5069	static inline int dev_sdif(const struct net_device *dev)
5070	{
5071	#ifdef CONFIG_NET_L3_MASTER_DEV
5072	if (netif_is_l3_slave(dev))
5073	return dev->ifindex;
5074	#endif
5075	return 0;
5076	}
5077
5078	static inline bool netif_is_bridge_master(const struct net_device *dev)
5079	{
5080	return dev->priv_flags & IFF_EBRIDGE;
5081	}
5082
5083	static inline bool netif_is_bridge_port(const struct net_device *dev)
5084	{
5085	return dev->priv_flags & IFF_BRIDGE_PORT;
5086	}
5087
5088	static inline bool netif_is_ovs_master(const struct net_device *dev)
5089	{
5090	return dev->priv_flags & IFF_OPENVSWITCH;
5091	}
5092
5093	static inline bool netif_is_ovs_port(const struct net_device *dev)
5094	{
5095	return dev->priv_flags & IFF_OVS_DATAPATH;
5096	}
5097
5098	static inline bool netif_is_any_bridge_master(const struct net_device *dev)
5099	{
5100	return netif_is_bridge_master(dev) || netif_is_ovs_master(dev);
5101	}
5102
5103	static inline bool netif_is_any_bridge_port(const struct net_device *dev)
5104	{
5105	return netif_is_bridge_port(dev) || netif_is_ovs_port(dev);
5106	}
5107
5108	static inline bool netif_is_team_master(const struct net_device *dev)
5109	{
5110	return dev->priv_flags & IFF_TEAM;
5111	}
5112
5113	static inline bool netif_is_team_port(const struct net_device *dev)
5114	{
5115	return dev->priv_flags & IFF_TEAM_PORT;
5116	}
5117
5118	static inline bool netif_is_lag_master(const struct net_device *dev)
5119	{
5120	return netif_is_bond_master(dev) || netif_is_team_master(dev);
5121	}
5122
5123	static inline bool netif_is_lag_port(const struct net_device *dev)
5124	{
5125	return netif_is_bond_slave(dev) || netif_is_team_port(dev);
5126	}
5127
5128	static inline bool netif_is_rxfh_configured(const struct net_device *dev)
5129	{
5130	return dev->priv_flags & IFF_RXFH_CONFIGURED;
5131	}
5132
5133	static inline bool netif_is_failover(const struct net_device *dev)
5134	{
5135	return dev->priv_flags & IFF_FAILOVER;
5136	}
5137
5138	static inline bool netif_is_failover_slave(const struct net_device *dev)
5139	{
5140	return dev->priv_flags & IFF_FAILOVER_SLAVE;
5141	}
5142
5143	/* This device needs to keep skb dst for qdisc enqueue or ndo_start_xmit() */
5144	static inline void netif_keep_dst(struct net_device *dev)
5145	{
5146	dev->priv_flags &= ~(IFF_XMIT_DST_RELEASE | IFF_XMIT_DST_RELEASE_PERM);
5147	}
5148
5149	/* return true if dev can't cope with mtu frames that need vlan tag insertion */
5150	static inline bool netif_reduces_vlan_mtu(struct net_device *dev)
5151	{
5152	/* TODO: reserve and use an additional IFF bit, if we get more users */
5153	return netif_is_macsec(dev);
5154	}
5155
5156	extern struct pernet_operations __net_initdata loopback_net_ops;
5157
5158	/* Logging, debugging and troubleshooting/diagnostic helpers. */
5159
5160	/* netdev_printk helpers, similar to dev_printk */
5161
5162	static inline const char *netdev_name(const struct net_device *dev)
5163	{
5164	if (!dev->name[0] || strchr(dev->name, '%'))
5165	return "(unnamed net_device)";
5166	return dev->name;
5167	}
5168
5169	static inline const char *netdev_reg_state(const struct net_device *dev)
5170	{
5171	u8 reg_state = READ_ONCE(dev->reg_state);
5172
5173	switch (reg_state) {
5174	case NETREG_UNINITIALIZED: return " (uninitialized)";
5175	case NETREG_REGISTERED: return "";
5176	case NETREG_UNREGISTERING: return " (unregistering)";
5177	case NETREG_UNREGISTERED: return " (unregistered)";
5178	case NETREG_RELEASED: return " (released)";
5179	case NETREG_DUMMY: return " (dummy)";
5180	}
5181
5182	WARN_ONCE(1, "%s: unknown reg_state %d\n", dev->name, reg_state);
5183	return " (unknown)";
5184	}
5185
5186	#define MODULE_ALIAS_NETDEV(device) \
5187	MODULE_ALIAS("netdev-" device)
5188
5189	/*
5190	* netdev_WARN() acts like dev_printk(), but with the key difference
5191	* of using a WARN/WARN_ON to get the message out, including the
5192	* file/line information and a backtrace.
5193	*/
5194	#define netdev_WARN(dev, format, args...) \
5195	WARN(1, "netdevice: %s%s: " format, netdev_name(dev), \
5196	netdev_reg_state(dev), ##args)
5197
5198	#define netdev_WARN_ONCE(dev, format, args...) \
5199	WARN_ONCE(1, "netdevice: %s%s: " format, netdev_name(dev), \
5200	netdev_reg_state(dev), ##args)
5201
5202	/*
5203	* The list of packet types we will receive (as opposed to discard)
5204	* and the routines to invoke.
5205	*
5206	* Why 16. Because with 16 the only overlap we get on a hash of the
5207	* low nibble of the protocol value is RARP/SNAP/X.25.
5208	*
5209	* 0800 IP
5210	* 0001 802.3
5211	* 0002 AX.25
5212	* 0004 802.2
5213	* 8035 RARP
5214	* 0005 SNAP
5215	* 0805 X.25
5216	* 0806 ARP
5217	* 8137 IPX
5218	* 0009 Localtalk
5219	* 86DD IPv6
5220	*/
5221	#define PTYPE_HASH_SIZE (16)
5222	#define PTYPE_HASH_MASK (PTYPE_HASH_SIZE - 1)
5223
5224	extern struct list_head ptype_base[PTYPE_HASH_SIZE] __read_mostly;
5225
5226	extern struct net_device *blackhole_netdev;
5227
5228	/* Note: Avoid these macros in fast path, prefer per-cpu or per-queue counters. */
5229	#define DEV_STATS_INC(DEV, FIELD) atomic_long_inc(&(DEV)->stats.__##FIELD)
5230	#define DEV_STATS_ADD(DEV, FIELD, VAL) \
5231	atomic_long_add((VAL), &(DEV)->stats.__##FIELD)
5232	#define DEV_STATS_READ(DEV, FIELD) atomic_long_read(&(DEV)->stats.__##FIELD)
5233
5234	#endif /* _LINUX_NETDEVICE_H */
5235