xref: /linux/net/core/dev.c (revision 981368e1440b76f68b1ac8f5fb14e739f80ecc4e)
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  *      NET3    Protocol independent device support routines.
4  *
5  *	Derived from the non IP parts of dev.c 1.0.19
6  *              Authors:	Ross Biro
7  *				Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
8  *				Mark Evans, <evansmp@uhura.aston.ac.uk>
9  *
10  *	Additional Authors:
11  *		Florian la Roche <rzsfl@rz.uni-sb.de>
12  *		Alan Cox <gw4pts@gw4pts.ampr.org>
13  *		David Hinds <dahinds@users.sourceforge.net>
14  *		Alexey Kuznetsov <kuznet@ms2.inr.ac.ru>
15  *		Adam Sulmicki <adam@cfar.umd.edu>
16  *              Pekka Riikonen <priikone@poesidon.pspt.fi>
17  *
18  *	Changes:
19  *              D.J. Barrow     :       Fixed bug where dev->refcnt gets set
20  *                                      to 2 if register_netdev gets called
21  *                                      before net_dev_init & also removed a
22  *                                      few lines of code in the process.
23  *		Alan Cox	:	device private ioctl copies fields back.
24  *		Alan Cox	:	Transmit queue code does relevant
25  *					stunts to keep the queue safe.
26  *		Alan Cox	:	Fixed double lock.
27  *		Alan Cox	:	Fixed promisc NULL pointer trap
28  *		????????	:	Support the full private ioctl range
29  *		Alan Cox	:	Moved ioctl permission check into
30  *					drivers
31  *		Tim Kordas	:	SIOCADDMULTI/SIOCDELMULTI
32  *		Alan Cox	:	100 backlog just doesn't cut it when
33  *					you start doing multicast video 8)
34  *		Alan Cox	:	Rewrote net_bh and list manager.
35  *              Alan Cox        :       Fix ETH_P_ALL echoback lengths.
36  *		Alan Cox	:	Took out transmit every packet pass
37  *					Saved a few bytes in the ioctl handler
38  *		Alan Cox	:	Network driver sets packet type before
39  *					calling netif_rx. Saves a function
40  *					call a packet.
41  *		Alan Cox	:	Hashed net_bh()
42  *		Richard Kooijman:	Timestamp fixes.
43  *		Alan Cox	:	Wrong field in SIOCGIFDSTADDR
44  *		Alan Cox	:	Device lock protection.
45  *              Alan Cox        :       Fixed nasty side effect of device close
46  *					changes.
47  *		Rudi Cilibrasi	:	Pass the right thing to
48  *					set_mac_address()
49  *		Dave Miller	:	32bit quantity for the device lock to
50  *					make it work out on a Sparc.
51  *		Bjorn Ekwall	:	Added KERNELD hack.
52  *		Alan Cox	:	Cleaned up the backlog initialise.
53  *		Craig Metz	:	SIOCGIFCONF fix if space for under
54  *					1 device.
55  *	    Thomas Bogendoerfer :	Return ENODEV for dev_open, if there
56  *					is no device open function.
57  *		Andi Kleen	:	Fix error reporting for SIOCGIFCONF
58  *	    Michael Chastain	:	Fix signed/unsigned for SIOCGIFCONF
59  *		Cyrus Durgin	:	Cleaned for KMOD
60  *		Adam Sulmicki   :	Bug Fix : Network Device Unload
61  *					A network device unload needs to purge
62  *					the backlog queue.
63  *	Paul Rusty Russell	:	SIOCSIFNAME
64  *              Pekka Riikonen  :	Netdev boot-time settings code
65  *              Andrew Morton   :       Make unregister_netdevice wait
66  *                                      indefinitely on dev->refcnt
67  *              J Hadi Salim    :       - Backlog queue sampling
68  *				        - netif_rx() feedback
69  */
70 
71 #include <linux/uaccess.h>
72 #include <linux/bitops.h>
73 #include <linux/capability.h>
74 #include <linux/cpu.h>
75 #include <linux/types.h>
76 #include <linux/kernel.h>
77 #include <linux/hash.h>
78 #include <linux/slab.h>
79 #include <linux/sched.h>
80 #include <linux/sched/mm.h>
81 #include <linux/mutex.h>
82 #include <linux/rwsem.h>
83 #include <linux/string.h>
84 #include <linux/mm.h>
85 #include <linux/socket.h>
86 #include <linux/sockios.h>
87 #include <linux/errno.h>
88 #include <linux/interrupt.h>
89 #include <linux/if_ether.h>
90 #include <linux/netdevice.h>
91 #include <linux/etherdevice.h>
92 #include <linux/ethtool.h>
93 #include <linux/skbuff.h>
94 #include <linux/kthread.h>
95 #include <linux/bpf.h>
96 #include <linux/bpf_trace.h>
97 #include <net/net_namespace.h>
98 #include <net/sock.h>
99 #include <net/busy_poll.h>
100 #include <linux/rtnetlink.h>
101 #include <linux/stat.h>
102 #include <net/dsa.h>
103 #include <net/dst.h>
104 #include <net/dst_metadata.h>
105 #include <net/gro.h>
106 #include <net/pkt_sched.h>
107 #include <net/pkt_cls.h>
108 #include <net/checksum.h>
109 #include <net/xfrm.h>
110 #include <net/tcx.h>
111 #include <linux/highmem.h>
112 #include <linux/init.h>
113 #include <linux/module.h>
114 #include <linux/netpoll.h>
115 #include <linux/rcupdate.h>
116 #include <linux/delay.h>
117 #include <net/iw_handler.h>
118 #include <asm/current.h>
119 #include <linux/audit.h>
120 #include <linux/dmaengine.h>
121 #include <linux/err.h>
122 #include <linux/ctype.h>
123 #include <linux/if_arp.h>
124 #include <linux/if_vlan.h>
125 #include <linux/ip.h>
126 #include <net/ip.h>
127 #include <net/mpls.h>
128 #include <linux/ipv6.h>
129 #include <linux/in.h>
130 #include <linux/jhash.h>
131 #include <linux/random.h>
132 #include <trace/events/napi.h>
133 #include <trace/events/net.h>
134 #include <trace/events/skb.h>
135 #include <trace/events/qdisc.h>
136 #include <trace/events/xdp.h>
137 #include <linux/inetdevice.h>
138 #include <linux/cpu_rmap.h>
139 #include <linux/static_key.h>
140 #include <linux/hashtable.h>
141 #include <linux/vmalloc.h>
142 #include <linux/if_macvlan.h>
143 #include <linux/errqueue.h>
144 #include <linux/hrtimer.h>
145 #include <linux/netfilter_netdev.h>
146 #include <linux/crash_dump.h>
147 #include <linux/sctp.h>
148 #include <net/udp_tunnel.h>
149 #include <linux/net_namespace.h>
150 #include <linux/indirect_call_wrapper.h>
151 #include <net/devlink.h>
152 #include <linux/pm_runtime.h>
153 #include <linux/prandom.h>
154 #include <linux/once_lite.h>
155 #include <net/netdev_rx_queue.h>
156 
157 #include "dev.h"
158 #include "net-sysfs.h"
159 
160 static DEFINE_SPINLOCK(ptype_lock);
161 struct list_head ptype_base[PTYPE_HASH_SIZE] __read_mostly;
162 struct list_head ptype_all __read_mostly;	/* Taps */
163 
164 static int netif_rx_internal(struct sk_buff *skb);
165 static int call_netdevice_notifiers_extack(unsigned long val,
166 					   struct net_device *dev,
167 					   struct netlink_ext_ack *extack);
168 static struct napi_struct *napi_by_id(unsigned int napi_id);
169 
170 /*
171  * The @dev_base_head list is protected by @dev_base_lock and the rtnl
172  * semaphore.
173  *
174  * Pure readers hold dev_base_lock for reading, or rcu_read_lock()
175  *
176  * Writers must hold the rtnl semaphore while they loop through the
177  * dev_base_head list, and hold dev_base_lock for writing when they do the
178  * actual updates.  This allows pure readers to access the list even
179  * while a writer is preparing to update it.
180  *
181  * To put it another way, dev_base_lock is held for writing only to
182  * protect against pure readers; the rtnl semaphore provides the
183  * protection against other writers.
184  *
185  * See, for example usages, register_netdevice() and
186  * unregister_netdevice(), which must be called with the rtnl
187  * semaphore held.
188  */
189 DEFINE_RWLOCK(dev_base_lock);
190 EXPORT_SYMBOL(dev_base_lock);
191 
192 static DEFINE_MUTEX(ifalias_mutex);
193 
194 /* protects napi_hash addition/deletion and napi_gen_id */
195 static DEFINE_SPINLOCK(napi_hash_lock);
196 
197 static unsigned int napi_gen_id = NR_CPUS;
198 static DEFINE_READ_MOSTLY_HASHTABLE(napi_hash, 8);
199 
200 static DECLARE_RWSEM(devnet_rename_sem);
201 
202 static inline void dev_base_seq_inc(struct net *net)
203 {
204 	while (++net->dev_base_seq == 0)
205 		;
206 }
207 
208 static inline struct hlist_head *dev_name_hash(struct net *net, const char *name)
209 {
210 	unsigned int hash = full_name_hash(net, name, strnlen(name, IFNAMSIZ));
211 
212 	return &net->dev_name_head[hash_32(hash, NETDEV_HASHBITS)];
213 }
214 
215 static inline struct hlist_head *dev_index_hash(struct net *net, int ifindex)
216 {
217 	return &net->dev_index_head[ifindex & (NETDEV_HASHENTRIES - 1)];
218 }
219 
220 static inline void rps_lock_irqsave(struct softnet_data *sd,
221 				    unsigned long *flags)
222 {
223 	if (IS_ENABLED(CONFIG_RPS))
224 		spin_lock_irqsave(&sd->input_pkt_queue.lock, *flags);
225 	else if (!IS_ENABLED(CONFIG_PREEMPT_RT))
226 		local_irq_save(*flags);
227 }
228 
229 static inline void rps_lock_irq_disable(struct softnet_data *sd)
230 {
231 	if (IS_ENABLED(CONFIG_RPS))
232 		spin_lock_irq(&sd->input_pkt_queue.lock);
233 	else if (!IS_ENABLED(CONFIG_PREEMPT_RT))
234 		local_irq_disable();
235 }
236 
237 static inline void rps_unlock_irq_restore(struct softnet_data *sd,
238 					  unsigned long *flags)
239 {
240 	if (IS_ENABLED(CONFIG_RPS))
241 		spin_unlock_irqrestore(&sd->input_pkt_queue.lock, *flags);
242 	else if (!IS_ENABLED(CONFIG_PREEMPT_RT))
243 		local_irq_restore(*flags);
244 }
245 
246 static inline void rps_unlock_irq_enable(struct softnet_data *sd)
247 {
248 	if (IS_ENABLED(CONFIG_RPS))
249 		spin_unlock_irq(&sd->input_pkt_queue.lock);
250 	else if (!IS_ENABLED(CONFIG_PREEMPT_RT))
251 		local_irq_enable();
252 }
253 
254 static struct netdev_name_node *netdev_name_node_alloc(struct net_device *dev,
255 						       const char *name)
256 {
257 	struct netdev_name_node *name_node;
258 
259 	name_node = kmalloc(sizeof(*name_node), GFP_KERNEL);
260 	if (!name_node)
261 		return NULL;
262 	INIT_HLIST_NODE(&name_node->hlist);
263 	name_node->dev = dev;
264 	name_node->name = name;
265 	return name_node;
266 }
267 
268 static struct netdev_name_node *
269 netdev_name_node_head_alloc(struct net_device *dev)
270 {
271 	struct netdev_name_node *name_node;
272 
273 	name_node = netdev_name_node_alloc(dev, dev->name);
274 	if (!name_node)
275 		return NULL;
276 	INIT_LIST_HEAD(&name_node->list);
277 	return name_node;
278 }
279 
280 static void netdev_name_node_free(struct netdev_name_node *name_node)
281 {
282 	kfree(name_node);
283 }
284 
285 static void netdev_name_node_add(struct net *net,
286 				 struct netdev_name_node *name_node)
287 {
288 	hlist_add_head_rcu(&name_node->hlist,
289 			   dev_name_hash(net, name_node->name));
290 }
291 
292 static void netdev_name_node_del(struct netdev_name_node *name_node)
293 {
294 	hlist_del_rcu(&name_node->hlist);
295 }
296 
297 static struct netdev_name_node *netdev_name_node_lookup(struct net *net,
298 							const char *name)
299 {
300 	struct hlist_head *head = dev_name_hash(net, name);
301 	struct netdev_name_node *name_node;
302 
303 	hlist_for_each_entry(name_node, head, hlist)
304 		if (!strcmp(name_node->name, name))
305 			return name_node;
306 	return NULL;
307 }
308 
309 static struct netdev_name_node *netdev_name_node_lookup_rcu(struct net *net,
310 							    const char *name)
311 {
312 	struct hlist_head *head = dev_name_hash(net, name);
313 	struct netdev_name_node *name_node;
314 
315 	hlist_for_each_entry_rcu(name_node, head, hlist)
316 		if (!strcmp(name_node->name, name))
317 			return name_node;
318 	return NULL;
319 }
320 
321 bool netdev_name_in_use(struct net *net, const char *name)
322 {
323 	return netdev_name_node_lookup(net, name);
324 }
325 EXPORT_SYMBOL(netdev_name_in_use);
326 
327 int netdev_name_node_alt_create(struct net_device *dev, const char *name)
328 {
329 	struct netdev_name_node *name_node;
330 	struct net *net = dev_net(dev);
331 
332 	name_node = netdev_name_node_lookup(net, name);
333 	if (name_node)
334 		return -EEXIST;
335 	name_node = netdev_name_node_alloc(dev, name);
336 	if (!name_node)
337 		return -ENOMEM;
338 	netdev_name_node_add(net, name_node);
339 	/* The node that holds dev->name acts as a head of per-device list. */
340 	list_add_tail(&name_node->list, &dev->name_node->list);
341 
342 	return 0;
343 }
344 
345 static void __netdev_name_node_alt_destroy(struct netdev_name_node *name_node)
346 {
347 	list_del(&name_node->list);
348 	netdev_name_node_del(name_node);
349 	kfree(name_node->name);
350 	netdev_name_node_free(name_node);
351 }
352 
353 int netdev_name_node_alt_destroy(struct net_device *dev, const char *name)
354 {
355 	struct netdev_name_node *name_node;
356 	struct net *net = dev_net(dev);
357 
358 	name_node = netdev_name_node_lookup(net, name);
359 	if (!name_node)
360 		return -ENOENT;
361 	/* lookup might have found our primary name or a name belonging
362 	 * to another device.
363 	 */
364 	if (name_node == dev->name_node || name_node->dev != dev)
365 		return -EINVAL;
366 
367 	__netdev_name_node_alt_destroy(name_node);
368 
369 	return 0;
370 }
371 
372 static void netdev_name_node_alt_flush(struct net_device *dev)
373 {
374 	struct netdev_name_node *name_node, *tmp;
375 
376 	list_for_each_entry_safe(name_node, tmp, &dev->name_node->list, list)
377 		__netdev_name_node_alt_destroy(name_node);
378 }
379 
380 /* Device list insertion */
381 static void list_netdevice(struct net_device *dev)
382 {
383 	struct net *net = dev_net(dev);
384 
385 	ASSERT_RTNL();
386 
387 	write_lock(&dev_base_lock);
388 	list_add_tail_rcu(&dev->dev_list, &net->dev_base_head);
389 	netdev_name_node_add(net, dev->name_node);
390 	hlist_add_head_rcu(&dev->index_hlist,
391 			   dev_index_hash(net, dev->ifindex));
392 	write_unlock(&dev_base_lock);
393 	/* We reserved the ifindex, this can't fail */
394 	WARN_ON(xa_store(&net->dev_by_index, dev->ifindex, dev, GFP_KERNEL));
395 
396 	dev_base_seq_inc(net);
397 }
398 
399 /* Device list removal
400  * caller must respect a RCU grace period before freeing/reusing dev
401  */
402 static void unlist_netdevice(struct net_device *dev, bool lock)
403 {
404 	struct net *net = dev_net(dev);
405 
406 	ASSERT_RTNL();
407 
408 	xa_erase(&net->dev_by_index, dev->ifindex);
409 
410 	/* Unlink dev from the device chain */
411 	if (lock)
412 		write_lock(&dev_base_lock);
413 	list_del_rcu(&dev->dev_list);
414 	netdev_name_node_del(dev->name_node);
415 	hlist_del_rcu(&dev->index_hlist);
416 	if (lock)
417 		write_unlock(&dev_base_lock);
418 
419 	dev_base_seq_inc(dev_net(dev));
420 }
421 
422 /*
423  *	Our notifier list
424  */
425 
426 static RAW_NOTIFIER_HEAD(netdev_chain);
427 
428 /*
429  *	Device drivers call our routines to queue packets here. We empty the
430  *	queue in the local softnet handler.
431  */
432 
433 DEFINE_PER_CPU_ALIGNED(struct softnet_data, softnet_data);
434 EXPORT_PER_CPU_SYMBOL(softnet_data);
435 
436 #ifdef CONFIG_LOCKDEP
437 /*
438  * register_netdevice() inits txq->_xmit_lock and sets lockdep class
439  * according to dev->type
440  */
441 static const unsigned short netdev_lock_type[] = {
442 	 ARPHRD_NETROM, ARPHRD_ETHER, ARPHRD_EETHER, ARPHRD_AX25,
443 	 ARPHRD_PRONET, ARPHRD_CHAOS, ARPHRD_IEEE802, ARPHRD_ARCNET,
444 	 ARPHRD_APPLETLK, ARPHRD_DLCI, ARPHRD_ATM, ARPHRD_METRICOM,
445 	 ARPHRD_IEEE1394, ARPHRD_EUI64, ARPHRD_INFINIBAND, ARPHRD_SLIP,
446 	 ARPHRD_CSLIP, ARPHRD_SLIP6, ARPHRD_CSLIP6, ARPHRD_RSRVD,
447 	 ARPHRD_ADAPT, ARPHRD_ROSE, ARPHRD_X25, ARPHRD_HWX25,
448 	 ARPHRD_PPP, ARPHRD_CISCO, ARPHRD_LAPB, ARPHRD_DDCMP,
449 	 ARPHRD_RAWHDLC, ARPHRD_TUNNEL, ARPHRD_TUNNEL6, ARPHRD_FRAD,
450 	 ARPHRD_SKIP, ARPHRD_LOOPBACK, ARPHRD_LOCALTLK, ARPHRD_FDDI,
451 	 ARPHRD_BIF, ARPHRD_SIT, ARPHRD_IPDDP, ARPHRD_IPGRE,
452 	 ARPHRD_PIMREG, ARPHRD_HIPPI, ARPHRD_ASH, ARPHRD_ECONET,
453 	 ARPHRD_IRDA, ARPHRD_FCPP, ARPHRD_FCAL, ARPHRD_FCPL,
454 	 ARPHRD_FCFABRIC, ARPHRD_IEEE80211, ARPHRD_IEEE80211_PRISM,
455 	 ARPHRD_IEEE80211_RADIOTAP, ARPHRD_PHONET, ARPHRD_PHONET_PIPE,
456 	 ARPHRD_IEEE802154, ARPHRD_VOID, ARPHRD_NONE};
457 
458 static const char *const netdev_lock_name[] = {
459 	"_xmit_NETROM", "_xmit_ETHER", "_xmit_EETHER", "_xmit_AX25",
460 	"_xmit_PRONET", "_xmit_CHAOS", "_xmit_IEEE802", "_xmit_ARCNET",
461 	"_xmit_APPLETLK", "_xmit_DLCI", "_xmit_ATM", "_xmit_METRICOM",
462 	"_xmit_IEEE1394", "_xmit_EUI64", "_xmit_INFINIBAND", "_xmit_SLIP",
463 	"_xmit_CSLIP", "_xmit_SLIP6", "_xmit_CSLIP6", "_xmit_RSRVD",
464 	"_xmit_ADAPT", "_xmit_ROSE", "_xmit_X25", "_xmit_HWX25",
465 	"_xmit_PPP", "_xmit_CISCO", "_xmit_LAPB", "_xmit_DDCMP",
466 	"_xmit_RAWHDLC", "_xmit_TUNNEL", "_xmit_TUNNEL6", "_xmit_FRAD",
467 	"_xmit_SKIP", "_xmit_LOOPBACK", "_xmit_LOCALTLK", "_xmit_FDDI",
468 	"_xmit_BIF", "_xmit_SIT", "_xmit_IPDDP", "_xmit_IPGRE",
469 	"_xmit_PIMREG", "_xmit_HIPPI", "_xmit_ASH", "_xmit_ECONET",
470 	"_xmit_IRDA", "_xmit_FCPP", "_xmit_FCAL", "_xmit_FCPL",
471 	"_xmit_FCFABRIC", "_xmit_IEEE80211", "_xmit_IEEE80211_PRISM",
472 	"_xmit_IEEE80211_RADIOTAP", "_xmit_PHONET", "_xmit_PHONET_PIPE",
473 	"_xmit_IEEE802154", "_xmit_VOID", "_xmit_NONE"};
474 
475 static struct lock_class_key netdev_xmit_lock_key[ARRAY_SIZE(netdev_lock_type)];
476 static struct lock_class_key netdev_addr_lock_key[ARRAY_SIZE(netdev_lock_type)];
477 
478 static inline unsigned short netdev_lock_pos(unsigned short dev_type)
479 {
480 	int i;
481 
482 	for (i = 0; i < ARRAY_SIZE(netdev_lock_type); i++)
483 		if (netdev_lock_type[i] == dev_type)
484 			return i;
485 	/* the last key is used by default */
486 	return ARRAY_SIZE(netdev_lock_type) - 1;
487 }
488 
489 static inline void netdev_set_xmit_lockdep_class(spinlock_t *lock,
490 						 unsigned short dev_type)
491 {
492 	int i;
493 
494 	i = netdev_lock_pos(dev_type);
495 	lockdep_set_class_and_name(lock, &netdev_xmit_lock_key[i],
496 				   netdev_lock_name[i]);
497 }
498 
499 static inline void netdev_set_addr_lockdep_class(struct net_device *dev)
500 {
501 	int i;
502 
503 	i = netdev_lock_pos(dev->type);
504 	lockdep_set_class_and_name(&dev->addr_list_lock,
505 				   &netdev_addr_lock_key[i],
506 				   netdev_lock_name[i]);
507 }
508 #else
509 static inline void netdev_set_xmit_lockdep_class(spinlock_t *lock,
510 						 unsigned short dev_type)
511 {
512 }
513 
514 static inline void netdev_set_addr_lockdep_class(struct net_device *dev)
515 {
516 }
517 #endif
518 
519 /*******************************************************************************
520  *
521  *		Protocol management and registration routines
522  *
523  *******************************************************************************/
524 
525 
526 /*
527  *	Add a protocol ID to the list. Now that the input handler is
528  *	smarter we can dispense with all the messy stuff that used to be
529  *	here.
530  *
531  *	BEWARE!!! Protocol handlers, mangling input packets,
532  *	MUST BE last in hash buckets and checking protocol handlers
533  *	MUST start from promiscuous ptype_all chain in net_bh.
534  *	It is true now, do not change it.
535  *	Explanation follows: if protocol handler, mangling packet, will
536  *	be the first on list, it is not able to sense, that packet
537  *	is cloned and should be copied-on-write, so that it will
538  *	change it and subsequent readers will get broken packet.
539  *							--ANK (980803)
540  */
541 
542 static inline struct list_head *ptype_head(const struct packet_type *pt)
543 {
544 	if (pt->type == htons(ETH_P_ALL))
545 		return pt->dev ? &pt->dev->ptype_all : &ptype_all;
546 	else
547 		return pt->dev ? &pt->dev->ptype_specific :
548 				 &ptype_base[ntohs(pt->type) & PTYPE_HASH_MASK];
549 }
550 
551 /**
552  *	dev_add_pack - add packet handler
553  *	@pt: packet type declaration
554  *
555  *	Add a protocol handler to the networking stack. The passed &packet_type
556  *	is linked into kernel lists and may not be freed until it has been
557  *	removed from the kernel lists.
558  *
559  *	This call does not sleep therefore it can not
560  *	guarantee all CPU's that are in middle of receiving packets
561  *	will see the new packet type (until the next received packet).
562  */
563 
564 void dev_add_pack(struct packet_type *pt)
565 {
566 	struct list_head *head = ptype_head(pt);
567 
568 	spin_lock(&ptype_lock);
569 	list_add_rcu(&pt->list, head);
570 	spin_unlock(&ptype_lock);
571 }
572 EXPORT_SYMBOL(dev_add_pack);
573 
574 /**
575  *	__dev_remove_pack	 - remove packet handler
576  *	@pt: packet type declaration
577  *
578  *	Remove a protocol handler that was previously added to the kernel
579  *	protocol handlers by dev_add_pack(). The passed &packet_type is removed
580  *	from the kernel lists and can be freed or reused once this function
581  *	returns.
582  *
583  *      The packet type might still be in use by receivers
584  *	and must not be freed until after all the CPU's have gone
585  *	through a quiescent state.
586  */
587 void __dev_remove_pack(struct packet_type *pt)
588 {
589 	struct list_head *head = ptype_head(pt);
590 	struct packet_type *pt1;
591 
592 	spin_lock(&ptype_lock);
593 
594 	list_for_each_entry(pt1, head, list) {
595 		if (pt == pt1) {
596 			list_del_rcu(&pt->list);
597 			goto out;
598 		}
599 	}
600 
601 	pr_warn("dev_remove_pack: %p not found\n", pt);
602 out:
603 	spin_unlock(&ptype_lock);
604 }
605 EXPORT_SYMBOL(__dev_remove_pack);
606 
607 /**
608  *	dev_remove_pack	 - remove packet handler
609  *	@pt: packet type declaration
610  *
611  *	Remove a protocol handler that was previously added to the kernel
612  *	protocol handlers by dev_add_pack(). The passed &packet_type is removed
613  *	from the kernel lists and can be freed or reused once this function
614  *	returns.
615  *
616  *	This call sleeps to guarantee that no CPU is looking at the packet
617  *	type after return.
618  */
619 void dev_remove_pack(struct packet_type *pt)
620 {
621 	__dev_remove_pack(pt);
622 
623 	synchronize_net();
624 }
625 EXPORT_SYMBOL(dev_remove_pack);
626 
627 
628 /*******************************************************************************
629  *
630  *			    Device Interface Subroutines
631  *
632  *******************************************************************************/
633 
634 /**
635  *	dev_get_iflink	- get 'iflink' value of a interface
636  *	@dev: targeted interface
637  *
638  *	Indicates the ifindex the interface is linked to.
639  *	Physical interfaces have the same 'ifindex' and 'iflink' values.
640  */
641 
642 int dev_get_iflink(const struct net_device *dev)
643 {
644 	if (dev->netdev_ops && dev->netdev_ops->ndo_get_iflink)
645 		return dev->netdev_ops->ndo_get_iflink(dev);
646 
647 	return dev->ifindex;
648 }
649 EXPORT_SYMBOL(dev_get_iflink);
650 
651 /**
652  *	dev_fill_metadata_dst - Retrieve tunnel egress information.
653  *	@dev: targeted interface
654  *	@skb: The packet.
655  *
656  *	For better visibility of tunnel traffic OVS needs to retrieve
657  *	egress tunnel information for a packet. Following API allows
658  *	user to get this info.
659  */
660 int dev_fill_metadata_dst(struct net_device *dev, struct sk_buff *skb)
661 {
662 	struct ip_tunnel_info *info;
663 
664 	if (!dev->netdev_ops  || !dev->netdev_ops->ndo_fill_metadata_dst)
665 		return -EINVAL;
666 
667 	info = skb_tunnel_info_unclone(skb);
668 	if (!info)
669 		return -ENOMEM;
670 	if (unlikely(!(info->mode & IP_TUNNEL_INFO_TX)))
671 		return -EINVAL;
672 
673 	return dev->netdev_ops->ndo_fill_metadata_dst(dev, skb);
674 }
675 EXPORT_SYMBOL_GPL(dev_fill_metadata_dst);
676 
677 static struct net_device_path *dev_fwd_path(struct net_device_path_stack *stack)
678 {
679 	int k = stack->num_paths++;
680 
681 	if (WARN_ON_ONCE(k >= NET_DEVICE_PATH_STACK_MAX))
682 		return NULL;
683 
684 	return &stack->path[k];
685 }
686 
687 int dev_fill_forward_path(const struct net_device *dev, const u8 *daddr,
688 			  struct net_device_path_stack *stack)
689 {
690 	const struct net_device *last_dev;
691 	struct net_device_path_ctx ctx = {
692 		.dev	= dev,
693 	};
694 	struct net_device_path *path;
695 	int ret = 0;
696 
697 	memcpy(ctx.daddr, daddr, sizeof(ctx.daddr));
698 	stack->num_paths = 0;
699 	while (ctx.dev && ctx.dev->netdev_ops->ndo_fill_forward_path) {
700 		last_dev = ctx.dev;
701 		path = dev_fwd_path(stack);
702 		if (!path)
703 			return -1;
704 
705 		memset(path, 0, sizeof(struct net_device_path));
706 		ret = ctx.dev->netdev_ops->ndo_fill_forward_path(&ctx, path);
707 		if (ret < 0)
708 			return -1;
709 
710 		if (WARN_ON_ONCE(last_dev == ctx.dev))
711 			return -1;
712 	}
713 
714 	if (!ctx.dev)
715 		return ret;
716 
717 	path = dev_fwd_path(stack);
718 	if (!path)
719 		return -1;
720 	path->type = DEV_PATH_ETHERNET;
721 	path->dev = ctx.dev;
722 
723 	return ret;
724 }
725 EXPORT_SYMBOL_GPL(dev_fill_forward_path);
726 
727 /**
728  *	__dev_get_by_name	- find a device by its name
729  *	@net: the applicable net namespace
730  *	@name: name to find
731  *
732  *	Find an interface by name. Must be called under RTNL semaphore
733  *	or @dev_base_lock. If the name is found a pointer to the device
734  *	is returned. If the name is not found then %NULL is returned. The
735  *	reference counters are not incremented so the caller must be
736  *	careful with locks.
737  */
738 
739 struct net_device *__dev_get_by_name(struct net *net, const char *name)
740 {
741 	struct netdev_name_node *node_name;
742 
743 	node_name = netdev_name_node_lookup(net, name);
744 	return node_name ? node_name->dev : NULL;
745 }
746 EXPORT_SYMBOL(__dev_get_by_name);
747 
748 /**
749  * dev_get_by_name_rcu	- find a device by its name
750  * @net: the applicable net namespace
751  * @name: name to find
752  *
753  * Find an interface by name.
754  * If the name is found a pointer to the device is returned.
755  * If the name is not found then %NULL is returned.
756  * The reference counters are not incremented so the caller must be
757  * careful with locks. The caller must hold RCU lock.
758  */
759 
760 struct net_device *dev_get_by_name_rcu(struct net *net, const char *name)
761 {
762 	struct netdev_name_node *node_name;
763 
764 	node_name = netdev_name_node_lookup_rcu(net, name);
765 	return node_name ? node_name->dev : NULL;
766 }
767 EXPORT_SYMBOL(dev_get_by_name_rcu);
768 
769 /* Deprecated for new users, call netdev_get_by_name() instead */
770 struct net_device *dev_get_by_name(struct net *net, const char *name)
771 {
772 	struct net_device *dev;
773 
774 	rcu_read_lock();
775 	dev = dev_get_by_name_rcu(net, name);
776 	dev_hold(dev);
777 	rcu_read_unlock();
778 	return dev;
779 }
780 EXPORT_SYMBOL(dev_get_by_name);
781 
782 /**
783  *	netdev_get_by_name() - find a device by its name
784  *	@net: the applicable net namespace
785  *	@name: name to find
786  *	@tracker: tracking object for the acquired reference
787  *	@gfp: allocation flags for the tracker
788  *
789  *	Find an interface by name. This can be called from any
790  *	context and does its own locking. The returned handle has
791  *	the usage count incremented and the caller must use netdev_put() to
792  *	release it when it is no longer needed. %NULL is returned if no
793  *	matching device is found.
794  */
795 struct net_device *netdev_get_by_name(struct net *net, const char *name,
796 				      netdevice_tracker *tracker, gfp_t gfp)
797 {
798 	struct net_device *dev;
799 
800 	dev = dev_get_by_name(net, name);
801 	if (dev)
802 		netdev_tracker_alloc(dev, tracker, gfp);
803 	return dev;
804 }
805 EXPORT_SYMBOL(netdev_get_by_name);
806 
807 /**
808  *	__dev_get_by_index - find a device by its ifindex
809  *	@net: the applicable net namespace
810  *	@ifindex: index of device
811  *
812  *	Search for an interface by index. Returns %NULL if the device
813  *	is not found or a pointer to the device. The device has not
814  *	had its reference counter increased so the caller must be careful
815  *	about locking. The caller must hold either the RTNL semaphore
816  *	or @dev_base_lock.
817  */
818 
819 struct net_device *__dev_get_by_index(struct net *net, int ifindex)
820 {
821 	struct net_device *dev;
822 	struct hlist_head *head = dev_index_hash(net, ifindex);
823 
824 	hlist_for_each_entry(dev, head, index_hlist)
825 		if (dev->ifindex == ifindex)
826 			return dev;
827 
828 	return NULL;
829 }
830 EXPORT_SYMBOL(__dev_get_by_index);
831 
832 /**
833  *	dev_get_by_index_rcu - find a device by its ifindex
834  *	@net: the applicable net namespace
835  *	@ifindex: index of device
836  *
837  *	Search for an interface by index. Returns %NULL if the device
838  *	is not found or a pointer to the device. The device has not
839  *	had its reference counter increased so the caller must be careful
840  *	about locking. The caller must hold RCU lock.
841  */
842 
843 struct net_device *dev_get_by_index_rcu(struct net *net, int ifindex)
844 {
845 	struct net_device *dev;
846 	struct hlist_head *head = dev_index_hash(net, ifindex);
847 
848 	hlist_for_each_entry_rcu(dev, head, index_hlist)
849 		if (dev->ifindex == ifindex)
850 			return dev;
851 
852 	return NULL;
853 }
854 EXPORT_SYMBOL(dev_get_by_index_rcu);
855 
856 /* Deprecated for new users, call netdev_get_by_index() instead */
857 struct net_device *dev_get_by_index(struct net *net, int ifindex)
858 {
859 	struct net_device *dev;
860 
861 	rcu_read_lock();
862 	dev = dev_get_by_index_rcu(net, ifindex);
863 	dev_hold(dev);
864 	rcu_read_unlock();
865 	return dev;
866 }
867 EXPORT_SYMBOL(dev_get_by_index);
868 
869 /**
870  *	netdev_get_by_index() - find a device by its ifindex
871  *	@net: the applicable net namespace
872  *	@ifindex: index of device
873  *	@tracker: tracking object for the acquired reference
874  *	@gfp: allocation flags for the tracker
875  *
876  *	Search for an interface by index. Returns NULL if the device
877  *	is not found or a pointer to the device. The device returned has
878  *	had a reference added and the pointer is safe until the user calls
879  *	netdev_put() to indicate they have finished with it.
880  */
881 struct net_device *netdev_get_by_index(struct net *net, int ifindex,
882 				       netdevice_tracker *tracker, gfp_t gfp)
883 {
884 	struct net_device *dev;
885 
886 	dev = dev_get_by_index(net, ifindex);
887 	if (dev)
888 		netdev_tracker_alloc(dev, tracker, gfp);
889 	return dev;
890 }
891 EXPORT_SYMBOL(netdev_get_by_index);
892 
893 /**
894  *	dev_get_by_napi_id - find a device by napi_id
895  *	@napi_id: ID of the NAPI struct
896  *
897  *	Search for an interface by NAPI ID. Returns %NULL if the device
898  *	is not found or a pointer to the device. The device has not had
899  *	its reference counter increased so the caller must be careful
900  *	about locking. The caller must hold RCU lock.
901  */
902 
903 struct net_device *dev_get_by_napi_id(unsigned int napi_id)
904 {
905 	struct napi_struct *napi;
906 
907 	WARN_ON_ONCE(!rcu_read_lock_held());
908 
909 	if (napi_id < MIN_NAPI_ID)
910 		return NULL;
911 
912 	napi = napi_by_id(napi_id);
913 
914 	return napi ? napi->dev : NULL;
915 }
916 EXPORT_SYMBOL(dev_get_by_napi_id);
917 
918 /**
919  *	netdev_get_name - get a netdevice name, knowing its ifindex.
920  *	@net: network namespace
921  *	@name: a pointer to the buffer where the name will be stored.
922  *	@ifindex: the ifindex of the interface to get the name from.
923  */
924 int netdev_get_name(struct net *net, char *name, int ifindex)
925 {
926 	struct net_device *dev;
927 	int ret;
928 
929 	down_read(&devnet_rename_sem);
930 	rcu_read_lock();
931 
932 	dev = dev_get_by_index_rcu(net, ifindex);
933 	if (!dev) {
934 		ret = -ENODEV;
935 		goto out;
936 	}
937 
938 	strcpy(name, dev->name);
939 
940 	ret = 0;
941 out:
942 	rcu_read_unlock();
943 	up_read(&devnet_rename_sem);
944 	return ret;
945 }
946 
947 /**
948  *	dev_getbyhwaddr_rcu - find a device by its hardware address
949  *	@net: the applicable net namespace
950  *	@type: media type of device
951  *	@ha: hardware address
952  *
953  *	Search for an interface by MAC address. Returns NULL if the device
954  *	is not found or a pointer to the device.
955  *	The caller must hold RCU or RTNL.
956  *	The returned device has not had its ref count increased
957  *	and the caller must therefore be careful about locking
958  *
959  */
960 
961 struct net_device *dev_getbyhwaddr_rcu(struct net *net, unsigned short type,
962 				       const char *ha)
963 {
964 	struct net_device *dev;
965 
966 	for_each_netdev_rcu(net, dev)
967 		if (dev->type == type &&
968 		    !memcmp(dev->dev_addr, ha, dev->addr_len))
969 			return dev;
970 
971 	return NULL;
972 }
973 EXPORT_SYMBOL(dev_getbyhwaddr_rcu);
974 
975 struct net_device *dev_getfirstbyhwtype(struct net *net, unsigned short type)
976 {
977 	struct net_device *dev, *ret = NULL;
978 
979 	rcu_read_lock();
980 	for_each_netdev_rcu(net, dev)
981 		if (dev->type == type) {
982 			dev_hold(dev);
983 			ret = dev;
984 			break;
985 		}
986 	rcu_read_unlock();
987 	return ret;
988 }
989 EXPORT_SYMBOL(dev_getfirstbyhwtype);
990 
991 /**
992  *	__dev_get_by_flags - find any device with given flags
993  *	@net: the applicable net namespace
994  *	@if_flags: IFF_* values
995  *	@mask: bitmask of bits in if_flags to check
996  *
997  *	Search for any interface with the given flags. Returns NULL if a device
998  *	is not found or a pointer to the device. Must be called inside
999  *	rtnl_lock(), and result refcount is unchanged.
1000  */
1001 
1002 struct net_device *__dev_get_by_flags(struct net *net, unsigned short if_flags,
1003 				      unsigned short mask)
1004 {
1005 	struct net_device *dev, *ret;
1006 
1007 	ASSERT_RTNL();
1008 
1009 	ret = NULL;
1010 	for_each_netdev(net, dev) {
1011 		if (((dev->flags ^ if_flags) & mask) == 0) {
1012 			ret = dev;
1013 			break;
1014 		}
1015 	}
1016 	return ret;
1017 }
1018 EXPORT_SYMBOL(__dev_get_by_flags);
1019 
1020 /**
1021  *	dev_valid_name - check if name is okay for network device
1022  *	@name: name string
1023  *
1024  *	Network device names need to be valid file names to
1025  *	allow sysfs to work.  We also disallow any kind of
1026  *	whitespace.
1027  */
1028 bool dev_valid_name(const char *name)
1029 {
1030 	if (*name == '\0')
1031 		return false;
1032 	if (strnlen(name, IFNAMSIZ) == IFNAMSIZ)
1033 		return false;
1034 	if (!strcmp(name, ".") || !strcmp(name, ".."))
1035 		return false;
1036 
1037 	while (*name) {
1038 		if (*name == '/' || *name == ':' || isspace(*name))
1039 			return false;
1040 		name++;
1041 	}
1042 	return true;
1043 }
1044 EXPORT_SYMBOL(dev_valid_name);
1045 
1046 /**
1047  *	__dev_alloc_name - allocate a name for a device
1048  *	@net: network namespace to allocate the device name in
1049  *	@name: name format string
1050  *	@buf:  scratch buffer and result name string
1051  *
1052  *	Passed a format string - eg "lt%d" it will try and find a suitable
1053  *	id. It scans list of devices to build up a free map, then chooses
1054  *	the first empty slot. The caller must hold the dev_base or rtnl lock
1055  *	while allocating the name and adding the device in order to avoid
1056  *	duplicates.
1057  *	Limited to bits_per_byte * page size devices (ie 32K on most platforms).
1058  *	Returns the number of the unit assigned or a negative errno code.
1059  */
1060 
1061 static int __dev_alloc_name(struct net *net, const char *name, char *buf)
1062 {
1063 	int i = 0;
1064 	const char *p;
1065 	const int max_netdevices = 8*PAGE_SIZE;
1066 	unsigned long *inuse;
1067 	struct net_device *d;
1068 
1069 	if (!dev_valid_name(name))
1070 		return -EINVAL;
1071 
1072 	p = strchr(name, '%');
1073 	if (p) {
1074 		/*
1075 		 * Verify the string as this thing may have come from
1076 		 * the user.  There must be either one "%d" and no other "%"
1077 		 * characters.
1078 		 */
1079 		if (p[1] != 'd' || strchr(p + 2, '%'))
1080 			return -EINVAL;
1081 
1082 		/* Use one page as a bit array of possible slots */
1083 		inuse = (unsigned long *) get_zeroed_page(GFP_ATOMIC);
1084 		if (!inuse)
1085 			return -ENOMEM;
1086 
1087 		for_each_netdev(net, d) {
1088 			struct netdev_name_node *name_node;
1089 			list_for_each_entry(name_node, &d->name_node->list, list) {
1090 				if (!sscanf(name_node->name, name, &i))
1091 					continue;
1092 				if (i < 0 || i >= max_netdevices)
1093 					continue;
1094 
1095 				/*  avoid cases where sscanf is not exact inverse of printf */
1096 				snprintf(buf, IFNAMSIZ, name, i);
1097 				if (!strncmp(buf, name_node->name, IFNAMSIZ))
1098 					__set_bit(i, inuse);
1099 			}
1100 			if (!sscanf(d->name, name, &i))
1101 				continue;
1102 			if (i < 0 || i >= max_netdevices)
1103 				continue;
1104 
1105 			/*  avoid cases where sscanf is not exact inverse of printf */
1106 			snprintf(buf, IFNAMSIZ, name, i);
1107 			if (!strncmp(buf, d->name, IFNAMSIZ))
1108 				__set_bit(i, inuse);
1109 		}
1110 
1111 		i = find_first_zero_bit(inuse, max_netdevices);
1112 		free_page((unsigned long) inuse);
1113 	}
1114 
1115 	snprintf(buf, IFNAMSIZ, name, i);
1116 	if (!netdev_name_in_use(net, buf))
1117 		return i;
1118 
1119 	/* It is possible to run out of possible slots
1120 	 * when the name is long and there isn't enough space left
1121 	 * for the digits, or if all bits are used.
1122 	 */
1123 	return -ENFILE;
1124 }
1125 
1126 static int dev_alloc_name_ns(struct net *net,
1127 			     struct net_device *dev,
1128 			     const char *name)
1129 {
1130 	char buf[IFNAMSIZ];
1131 	int ret;
1132 
1133 	BUG_ON(!net);
1134 	ret = __dev_alloc_name(net, name, buf);
1135 	if (ret >= 0)
1136 		strscpy(dev->name, buf, IFNAMSIZ);
1137 	return ret;
1138 }
1139 
1140 /**
1141  *	dev_alloc_name - allocate a name for a device
1142  *	@dev: device
1143  *	@name: name format string
1144  *
1145  *	Passed a format string - eg "lt%d" it will try and find a suitable
1146  *	id. It scans list of devices to build up a free map, then chooses
1147  *	the first empty slot. The caller must hold the dev_base or rtnl lock
1148  *	while allocating the name and adding the device in order to avoid
1149  *	duplicates.
1150  *	Limited to bits_per_byte * page size devices (ie 32K on most platforms).
1151  *	Returns the number of the unit assigned or a negative errno code.
1152  */
1153 
1154 int dev_alloc_name(struct net_device *dev, const char *name)
1155 {
1156 	return dev_alloc_name_ns(dev_net(dev), dev, name);
1157 }
1158 EXPORT_SYMBOL(dev_alloc_name);
1159 
1160 static int dev_get_valid_name(struct net *net, struct net_device *dev,
1161 			      const char *name)
1162 {
1163 	BUG_ON(!net);
1164 
1165 	if (!dev_valid_name(name))
1166 		return -EINVAL;
1167 
1168 	if (strchr(name, '%'))
1169 		return dev_alloc_name_ns(net, dev, name);
1170 	else if (netdev_name_in_use(net, name))
1171 		return -EEXIST;
1172 	else if (dev->name != name)
1173 		strscpy(dev->name, name, IFNAMSIZ);
1174 
1175 	return 0;
1176 }
1177 
1178 /**
1179  *	dev_change_name - change name of a device
1180  *	@dev: device
1181  *	@newname: name (or format string) must be at least IFNAMSIZ
1182  *
1183  *	Change name of a device, can pass format strings "eth%d".
1184  *	for wildcarding.
1185  */
1186 int dev_change_name(struct net_device *dev, const char *newname)
1187 {
1188 	unsigned char old_assign_type;
1189 	char oldname[IFNAMSIZ];
1190 	int err = 0;
1191 	int ret;
1192 	struct net *net;
1193 
1194 	ASSERT_RTNL();
1195 	BUG_ON(!dev_net(dev));
1196 
1197 	net = dev_net(dev);
1198 
1199 	down_write(&devnet_rename_sem);
1200 
1201 	if (strncmp(newname, dev->name, IFNAMSIZ) == 0) {
1202 		up_write(&devnet_rename_sem);
1203 		return 0;
1204 	}
1205 
1206 	memcpy(oldname, dev->name, IFNAMSIZ);
1207 
1208 	err = dev_get_valid_name(net, dev, newname);
1209 	if (err < 0) {
1210 		up_write(&devnet_rename_sem);
1211 		return err;
1212 	}
1213 
1214 	if (oldname[0] && !strchr(oldname, '%'))
1215 		netdev_info(dev, "renamed from %s%s\n", oldname,
1216 			    dev->flags & IFF_UP ? " (while UP)" : "");
1217 
1218 	old_assign_type = dev->name_assign_type;
1219 	dev->name_assign_type = NET_NAME_RENAMED;
1220 
1221 rollback:
1222 	ret = device_rename(&dev->dev, dev->name);
1223 	if (ret) {
1224 		memcpy(dev->name, oldname, IFNAMSIZ);
1225 		dev->name_assign_type = old_assign_type;
1226 		up_write(&devnet_rename_sem);
1227 		return ret;
1228 	}
1229 
1230 	up_write(&devnet_rename_sem);
1231 
1232 	netdev_adjacent_rename_links(dev, oldname);
1233 
1234 	write_lock(&dev_base_lock);
1235 	netdev_name_node_del(dev->name_node);
1236 	write_unlock(&dev_base_lock);
1237 
1238 	synchronize_rcu();
1239 
1240 	write_lock(&dev_base_lock);
1241 	netdev_name_node_add(net, dev->name_node);
1242 	write_unlock(&dev_base_lock);
1243 
1244 	ret = call_netdevice_notifiers(NETDEV_CHANGENAME, dev);
1245 	ret = notifier_to_errno(ret);
1246 
1247 	if (ret) {
1248 		/* err >= 0 after dev_alloc_name() or stores the first errno */
1249 		if (err >= 0) {
1250 			err = ret;
1251 			down_write(&devnet_rename_sem);
1252 			memcpy(dev->name, oldname, IFNAMSIZ);
1253 			memcpy(oldname, newname, IFNAMSIZ);
1254 			dev->name_assign_type = old_assign_type;
1255 			old_assign_type = NET_NAME_RENAMED;
1256 			goto rollback;
1257 		} else {
1258 			netdev_err(dev, "name change rollback failed: %d\n",
1259 				   ret);
1260 		}
1261 	}
1262 
1263 	return err;
1264 }
1265 
1266 /**
1267  *	dev_set_alias - change ifalias of a device
1268  *	@dev: device
1269  *	@alias: name up to IFALIASZ
1270  *	@len: limit of bytes to copy from info
1271  *
1272  *	Set ifalias for a device,
1273  */
1274 int dev_set_alias(struct net_device *dev, const char *alias, size_t len)
1275 {
1276 	struct dev_ifalias *new_alias = NULL;
1277 
1278 	if (len >= IFALIASZ)
1279 		return -EINVAL;
1280 
1281 	if (len) {
1282 		new_alias = kmalloc(sizeof(*new_alias) + len + 1, GFP_KERNEL);
1283 		if (!new_alias)
1284 			return -ENOMEM;
1285 
1286 		memcpy(new_alias->ifalias, alias, len);
1287 		new_alias->ifalias[len] = 0;
1288 	}
1289 
1290 	mutex_lock(&ifalias_mutex);
1291 	new_alias = rcu_replace_pointer(dev->ifalias, new_alias,
1292 					mutex_is_locked(&ifalias_mutex));
1293 	mutex_unlock(&ifalias_mutex);
1294 
1295 	if (new_alias)
1296 		kfree_rcu(new_alias, rcuhead);
1297 
1298 	return len;
1299 }
1300 EXPORT_SYMBOL(dev_set_alias);
1301 
1302 /**
1303  *	dev_get_alias - get ifalias of a device
1304  *	@dev: device
1305  *	@name: buffer to store name of ifalias
1306  *	@len: size of buffer
1307  *
1308  *	get ifalias for a device.  Caller must make sure dev cannot go
1309  *	away,  e.g. rcu read lock or own a reference count to device.
1310  */
1311 int dev_get_alias(const struct net_device *dev, char *name, size_t len)
1312 {
1313 	const struct dev_ifalias *alias;
1314 	int ret = 0;
1315 
1316 	rcu_read_lock();
1317 	alias = rcu_dereference(dev->ifalias);
1318 	if (alias)
1319 		ret = snprintf(name, len, "%s", alias->ifalias);
1320 	rcu_read_unlock();
1321 
1322 	return ret;
1323 }
1324 
1325 /**
1326  *	netdev_features_change - device changes features
1327  *	@dev: device to cause notification
1328  *
1329  *	Called to indicate a device has changed features.
1330  */
1331 void netdev_features_change(struct net_device *dev)
1332 {
1333 	call_netdevice_notifiers(NETDEV_FEAT_CHANGE, dev);
1334 }
1335 EXPORT_SYMBOL(netdev_features_change);
1336 
1337 /**
1338  *	netdev_state_change - device changes state
1339  *	@dev: device to cause notification
1340  *
1341  *	Called to indicate a device has changed state. This function calls
1342  *	the notifier chains for netdev_chain and sends a NEWLINK message
1343  *	to the routing socket.
1344  */
1345 void netdev_state_change(struct net_device *dev)
1346 {
1347 	if (dev->flags & IFF_UP) {
1348 		struct netdev_notifier_change_info change_info = {
1349 			.info.dev = dev,
1350 		};
1351 
1352 		call_netdevice_notifiers_info(NETDEV_CHANGE,
1353 					      &change_info.info);
1354 		rtmsg_ifinfo(RTM_NEWLINK, dev, 0, GFP_KERNEL, 0, NULL);
1355 	}
1356 }
1357 EXPORT_SYMBOL(netdev_state_change);
1358 
1359 /**
1360  * __netdev_notify_peers - notify network peers about existence of @dev,
1361  * to be called when rtnl lock is already held.
1362  * @dev: network device
1363  *
1364  * Generate traffic such that interested network peers are aware of
1365  * @dev, such as by generating a gratuitous ARP. This may be used when
1366  * a device wants to inform the rest of the network about some sort of
1367  * reconfiguration such as a failover event or virtual machine
1368  * migration.
1369  */
1370 void __netdev_notify_peers(struct net_device *dev)
1371 {
1372 	ASSERT_RTNL();
1373 	call_netdevice_notifiers(NETDEV_NOTIFY_PEERS, dev);
1374 	call_netdevice_notifiers(NETDEV_RESEND_IGMP, dev);
1375 }
1376 EXPORT_SYMBOL(__netdev_notify_peers);
1377 
1378 /**
1379  * netdev_notify_peers - notify network peers about existence of @dev
1380  * @dev: network device
1381  *
1382  * Generate traffic such that interested network peers are aware of
1383  * @dev, such as by generating a gratuitous ARP. This may be used when
1384  * a device wants to inform the rest of the network about some sort of
1385  * reconfiguration such as a failover event or virtual machine
1386  * migration.
1387  */
1388 void netdev_notify_peers(struct net_device *dev)
1389 {
1390 	rtnl_lock();
1391 	__netdev_notify_peers(dev);
1392 	rtnl_unlock();
1393 }
1394 EXPORT_SYMBOL(netdev_notify_peers);
1395 
1396 static int napi_threaded_poll(void *data);
1397 
1398 static int napi_kthread_create(struct napi_struct *n)
1399 {
1400 	int err = 0;
1401 
1402 	/* Create and wake up the kthread once to put it in
1403 	 * TASK_INTERRUPTIBLE mode to avoid the blocked task
1404 	 * warning and work with loadavg.
1405 	 */
1406 	n->thread = kthread_run(napi_threaded_poll, n, "napi/%s-%d",
1407 				n->dev->name, n->napi_id);
1408 	if (IS_ERR(n->thread)) {
1409 		err = PTR_ERR(n->thread);
1410 		pr_err("kthread_run failed with err %d\n", err);
1411 		n->thread = NULL;
1412 	}
1413 
1414 	return err;
1415 }
1416 
1417 static int __dev_open(struct net_device *dev, struct netlink_ext_ack *extack)
1418 {
1419 	const struct net_device_ops *ops = dev->netdev_ops;
1420 	int ret;
1421 
1422 	ASSERT_RTNL();
1423 	dev_addr_check(dev);
1424 
1425 	if (!netif_device_present(dev)) {
1426 		/* may be detached because parent is runtime-suspended */
1427 		if (dev->dev.parent)
1428 			pm_runtime_resume(dev->dev.parent);
1429 		if (!netif_device_present(dev))
1430 			return -ENODEV;
1431 	}
1432 
1433 	/* Block netpoll from trying to do any rx path servicing.
1434 	 * If we don't do this there is a chance ndo_poll_controller
1435 	 * or ndo_poll may be running while we open the device
1436 	 */
1437 	netpoll_poll_disable(dev);
1438 
1439 	ret = call_netdevice_notifiers_extack(NETDEV_PRE_UP, dev, extack);
1440 	ret = notifier_to_errno(ret);
1441 	if (ret)
1442 		return ret;
1443 
1444 	set_bit(__LINK_STATE_START, &dev->state);
1445 
1446 	if (ops->ndo_validate_addr)
1447 		ret = ops->ndo_validate_addr(dev);
1448 
1449 	if (!ret && ops->ndo_open)
1450 		ret = ops->ndo_open(dev);
1451 
1452 	netpoll_poll_enable(dev);
1453 
1454 	if (ret)
1455 		clear_bit(__LINK_STATE_START, &dev->state);
1456 	else {
1457 		dev->flags |= IFF_UP;
1458 		dev_set_rx_mode(dev);
1459 		dev_activate(dev);
1460 		add_device_randomness(dev->dev_addr, dev->addr_len);
1461 	}
1462 
1463 	return ret;
1464 }
1465 
1466 /**
1467  *	dev_open	- prepare an interface for use.
1468  *	@dev: device to open
1469  *	@extack: netlink extended ack
1470  *
1471  *	Takes a device from down to up state. The device's private open
1472  *	function is invoked and then the multicast lists are loaded. Finally
1473  *	the device is moved into the up state and a %NETDEV_UP message is
1474  *	sent to the netdev notifier chain.
1475  *
1476  *	Calling this function on an active interface is a nop. On a failure
1477  *	a negative errno code is returned.
1478  */
1479 int dev_open(struct net_device *dev, struct netlink_ext_ack *extack)
1480 {
1481 	int ret;
1482 
1483 	if (dev->flags & IFF_UP)
1484 		return 0;
1485 
1486 	ret = __dev_open(dev, extack);
1487 	if (ret < 0)
1488 		return ret;
1489 
1490 	rtmsg_ifinfo(RTM_NEWLINK, dev, IFF_UP | IFF_RUNNING, GFP_KERNEL, 0, NULL);
1491 	call_netdevice_notifiers(NETDEV_UP, dev);
1492 
1493 	return ret;
1494 }
1495 EXPORT_SYMBOL(dev_open);
1496 
1497 static void __dev_close_many(struct list_head *head)
1498 {
1499 	struct net_device *dev;
1500 
1501 	ASSERT_RTNL();
1502 	might_sleep();
1503 
1504 	list_for_each_entry(dev, head, close_list) {
1505 		/* Temporarily disable netpoll until the interface is down */
1506 		netpoll_poll_disable(dev);
1507 
1508 		call_netdevice_notifiers(NETDEV_GOING_DOWN, dev);
1509 
1510 		clear_bit(__LINK_STATE_START, &dev->state);
1511 
1512 		/* Synchronize to scheduled poll. We cannot touch poll list, it
1513 		 * can be even on different cpu. So just clear netif_running().
1514 		 *
1515 		 * dev->stop() will invoke napi_disable() on all of it's
1516 		 * napi_struct instances on this device.
1517 		 */
1518 		smp_mb__after_atomic(); /* Commit netif_running(). */
1519 	}
1520 
1521 	dev_deactivate_many(head);
1522 
1523 	list_for_each_entry(dev, head, close_list) {
1524 		const struct net_device_ops *ops = dev->netdev_ops;
1525 
1526 		/*
1527 		 *	Call the device specific close. This cannot fail.
1528 		 *	Only if device is UP
1529 		 *
1530 		 *	We allow it to be called even after a DETACH hot-plug
1531 		 *	event.
1532 		 */
1533 		if (ops->ndo_stop)
1534 			ops->ndo_stop(dev);
1535 
1536 		dev->flags &= ~IFF_UP;
1537 		netpoll_poll_enable(dev);
1538 	}
1539 }
1540 
1541 static void __dev_close(struct net_device *dev)
1542 {
1543 	LIST_HEAD(single);
1544 
1545 	list_add(&dev->close_list, &single);
1546 	__dev_close_many(&single);
1547 	list_del(&single);
1548 }
1549 
1550 void dev_close_many(struct list_head *head, bool unlink)
1551 {
1552 	struct net_device *dev, *tmp;
1553 
1554 	/* Remove the devices that don't need to be closed */
1555 	list_for_each_entry_safe(dev, tmp, head, close_list)
1556 		if (!(dev->flags & IFF_UP))
1557 			list_del_init(&dev->close_list);
1558 
1559 	__dev_close_many(head);
1560 
1561 	list_for_each_entry_safe(dev, tmp, head, close_list) {
1562 		rtmsg_ifinfo(RTM_NEWLINK, dev, IFF_UP | IFF_RUNNING, GFP_KERNEL, 0, NULL);
1563 		call_netdevice_notifiers(NETDEV_DOWN, dev);
1564 		if (unlink)
1565 			list_del_init(&dev->close_list);
1566 	}
1567 }
1568 EXPORT_SYMBOL(dev_close_many);
1569 
1570 /**
1571  *	dev_close - shutdown an interface.
1572  *	@dev: device to shutdown
1573  *
1574  *	This function moves an active device into down state. A
1575  *	%NETDEV_GOING_DOWN is sent to the netdev notifier chain. The device
1576  *	is then deactivated and finally a %NETDEV_DOWN is sent to the notifier
1577  *	chain.
1578  */
1579 void dev_close(struct net_device *dev)
1580 {
1581 	if (dev->flags & IFF_UP) {
1582 		LIST_HEAD(single);
1583 
1584 		list_add(&dev->close_list, &single);
1585 		dev_close_many(&single, true);
1586 		list_del(&single);
1587 	}
1588 }
1589 EXPORT_SYMBOL(dev_close);
1590 
1591 
1592 /**
1593  *	dev_disable_lro - disable Large Receive Offload on a device
1594  *	@dev: device
1595  *
1596  *	Disable Large Receive Offload (LRO) on a net device.  Must be
1597  *	called under RTNL.  This is needed if received packets may be
1598  *	forwarded to another interface.
1599  */
1600 void dev_disable_lro(struct net_device *dev)
1601 {
1602 	struct net_device *lower_dev;
1603 	struct list_head *iter;
1604 
1605 	dev->wanted_features &= ~NETIF_F_LRO;
1606 	netdev_update_features(dev);
1607 
1608 	if (unlikely(dev->features & NETIF_F_LRO))
1609 		netdev_WARN(dev, "failed to disable LRO!\n");
1610 
1611 	netdev_for_each_lower_dev(dev, lower_dev, iter)
1612 		dev_disable_lro(lower_dev);
1613 }
1614 EXPORT_SYMBOL(dev_disable_lro);
1615 
1616 /**
1617  *	dev_disable_gro_hw - disable HW Generic Receive Offload on a device
1618  *	@dev: device
1619  *
1620  *	Disable HW Generic Receive Offload (GRO_HW) on a net device.  Must be
1621  *	called under RTNL.  This is needed if Generic XDP is installed on
1622  *	the device.
1623  */
1624 static void dev_disable_gro_hw(struct net_device *dev)
1625 {
1626 	dev->wanted_features &= ~NETIF_F_GRO_HW;
1627 	netdev_update_features(dev);
1628 
1629 	if (unlikely(dev->features & NETIF_F_GRO_HW))
1630 		netdev_WARN(dev, "failed to disable GRO_HW!\n");
1631 }
1632 
1633 const char *netdev_cmd_to_name(enum netdev_cmd cmd)
1634 {
1635 #define N(val) 						\
1636 	case NETDEV_##val:				\
1637 		return "NETDEV_" __stringify(val);
1638 	switch (cmd) {
1639 	N(UP) N(DOWN) N(REBOOT) N(CHANGE) N(REGISTER) N(UNREGISTER)
1640 	N(CHANGEMTU) N(CHANGEADDR) N(GOING_DOWN) N(CHANGENAME) N(FEAT_CHANGE)
1641 	N(BONDING_FAILOVER) N(PRE_UP) N(PRE_TYPE_CHANGE) N(POST_TYPE_CHANGE)
1642 	N(POST_INIT) N(PRE_UNINIT) N(RELEASE) N(NOTIFY_PEERS) N(JOIN)
1643 	N(CHANGEUPPER) N(RESEND_IGMP) N(PRECHANGEMTU) N(CHANGEINFODATA)
1644 	N(BONDING_INFO) N(PRECHANGEUPPER) N(CHANGELOWERSTATE)
1645 	N(UDP_TUNNEL_PUSH_INFO) N(UDP_TUNNEL_DROP_INFO) N(CHANGE_TX_QUEUE_LEN)
1646 	N(CVLAN_FILTER_PUSH_INFO) N(CVLAN_FILTER_DROP_INFO)
1647 	N(SVLAN_FILTER_PUSH_INFO) N(SVLAN_FILTER_DROP_INFO)
1648 	N(PRE_CHANGEADDR) N(OFFLOAD_XSTATS_ENABLE) N(OFFLOAD_XSTATS_DISABLE)
1649 	N(OFFLOAD_XSTATS_REPORT_USED) N(OFFLOAD_XSTATS_REPORT_DELTA)
1650 	N(XDP_FEAT_CHANGE)
1651 	}
1652 #undef N
1653 	return "UNKNOWN_NETDEV_EVENT";
1654 }
1655 EXPORT_SYMBOL_GPL(netdev_cmd_to_name);
1656 
1657 static int call_netdevice_notifier(struct notifier_block *nb, unsigned long val,
1658 				   struct net_device *dev)
1659 {
1660 	struct netdev_notifier_info info = {
1661 		.dev = dev,
1662 	};
1663 
1664 	return nb->notifier_call(nb, val, &info);
1665 }
1666 
1667 static int call_netdevice_register_notifiers(struct notifier_block *nb,
1668 					     struct net_device *dev)
1669 {
1670 	int err;
1671 
1672 	err = call_netdevice_notifier(nb, NETDEV_REGISTER, dev);
1673 	err = notifier_to_errno(err);
1674 	if (err)
1675 		return err;
1676 
1677 	if (!(dev->flags & IFF_UP))
1678 		return 0;
1679 
1680 	call_netdevice_notifier(nb, NETDEV_UP, dev);
1681 	return 0;
1682 }
1683 
1684 static void call_netdevice_unregister_notifiers(struct notifier_block *nb,
1685 						struct net_device *dev)
1686 {
1687 	if (dev->flags & IFF_UP) {
1688 		call_netdevice_notifier(nb, NETDEV_GOING_DOWN,
1689 					dev);
1690 		call_netdevice_notifier(nb, NETDEV_DOWN, dev);
1691 	}
1692 	call_netdevice_notifier(nb, NETDEV_UNREGISTER, dev);
1693 }
1694 
1695 static int call_netdevice_register_net_notifiers(struct notifier_block *nb,
1696 						 struct net *net)
1697 {
1698 	struct net_device *dev;
1699 	int err;
1700 
1701 	for_each_netdev(net, dev) {
1702 		err = call_netdevice_register_notifiers(nb, dev);
1703 		if (err)
1704 			goto rollback;
1705 	}
1706 	return 0;
1707 
1708 rollback:
1709 	for_each_netdev_continue_reverse(net, dev)
1710 		call_netdevice_unregister_notifiers(nb, dev);
1711 	return err;
1712 }
1713 
1714 static void call_netdevice_unregister_net_notifiers(struct notifier_block *nb,
1715 						    struct net *net)
1716 {
1717 	struct net_device *dev;
1718 
1719 	for_each_netdev(net, dev)
1720 		call_netdevice_unregister_notifiers(nb, dev);
1721 }
1722 
1723 static int dev_boot_phase = 1;
1724 
1725 /**
1726  * register_netdevice_notifier - register a network notifier block
1727  * @nb: notifier
1728  *
1729  * Register a notifier to be called when network device events occur.
1730  * The notifier passed is linked into the kernel structures and must
1731  * not be reused until it has been unregistered. A negative errno code
1732  * is returned on a failure.
1733  *
1734  * When registered all registration and up events are replayed
1735  * to the new notifier to allow device to have a race free
1736  * view of the network device list.
1737  */
1738 
1739 int register_netdevice_notifier(struct notifier_block *nb)
1740 {
1741 	struct net *net;
1742 	int err;
1743 
1744 	/* Close race with setup_net() and cleanup_net() */
1745 	down_write(&pernet_ops_rwsem);
1746 	rtnl_lock();
1747 	err = raw_notifier_chain_register(&netdev_chain, nb);
1748 	if (err)
1749 		goto unlock;
1750 	if (dev_boot_phase)
1751 		goto unlock;
1752 	for_each_net(net) {
1753 		err = call_netdevice_register_net_notifiers(nb, net);
1754 		if (err)
1755 			goto rollback;
1756 	}
1757 
1758 unlock:
1759 	rtnl_unlock();
1760 	up_write(&pernet_ops_rwsem);
1761 	return err;
1762 
1763 rollback:
1764 	for_each_net_continue_reverse(net)
1765 		call_netdevice_unregister_net_notifiers(nb, net);
1766 
1767 	raw_notifier_chain_unregister(&netdev_chain, nb);
1768 	goto unlock;
1769 }
1770 EXPORT_SYMBOL(register_netdevice_notifier);
1771 
1772 /**
1773  * unregister_netdevice_notifier - unregister a network notifier block
1774  * @nb: notifier
1775  *
1776  * Unregister a notifier previously registered by
1777  * register_netdevice_notifier(). The notifier is unlinked into the
1778  * kernel structures and may then be reused. A negative errno code
1779  * is returned on a failure.
1780  *
1781  * After unregistering unregister and down device events are synthesized
1782  * for all devices on the device list to the removed notifier to remove
1783  * the need for special case cleanup code.
1784  */
1785 
1786 int unregister_netdevice_notifier(struct notifier_block *nb)
1787 {
1788 	struct net *net;
1789 	int err;
1790 
1791 	/* Close race with setup_net() and cleanup_net() */
1792 	down_write(&pernet_ops_rwsem);
1793 	rtnl_lock();
1794 	err = raw_notifier_chain_unregister(&netdev_chain, nb);
1795 	if (err)
1796 		goto unlock;
1797 
1798 	for_each_net(net)
1799 		call_netdevice_unregister_net_notifiers(nb, net);
1800 
1801 unlock:
1802 	rtnl_unlock();
1803 	up_write(&pernet_ops_rwsem);
1804 	return err;
1805 }
1806 EXPORT_SYMBOL(unregister_netdevice_notifier);
1807 
1808 static int __register_netdevice_notifier_net(struct net *net,
1809 					     struct notifier_block *nb,
1810 					     bool ignore_call_fail)
1811 {
1812 	int err;
1813 
1814 	err = raw_notifier_chain_register(&net->netdev_chain, nb);
1815 	if (err)
1816 		return err;
1817 	if (dev_boot_phase)
1818 		return 0;
1819 
1820 	err = call_netdevice_register_net_notifiers(nb, net);
1821 	if (err && !ignore_call_fail)
1822 		goto chain_unregister;
1823 
1824 	return 0;
1825 
1826 chain_unregister:
1827 	raw_notifier_chain_unregister(&net->netdev_chain, nb);
1828 	return err;
1829 }
1830 
1831 static int __unregister_netdevice_notifier_net(struct net *net,
1832 					       struct notifier_block *nb)
1833 {
1834 	int err;
1835 
1836 	err = raw_notifier_chain_unregister(&net->netdev_chain, nb);
1837 	if (err)
1838 		return err;
1839 
1840 	call_netdevice_unregister_net_notifiers(nb, net);
1841 	return 0;
1842 }
1843 
1844 /**
1845  * register_netdevice_notifier_net - register a per-netns network notifier block
1846  * @net: network namespace
1847  * @nb: notifier
1848  *
1849  * Register a notifier to be called when network device events occur.
1850  * The notifier passed is linked into the kernel structures and must
1851  * not be reused until it has been unregistered. A negative errno code
1852  * is returned on a failure.
1853  *
1854  * When registered all registration and up events are replayed
1855  * to the new notifier to allow device to have a race free
1856  * view of the network device list.
1857  */
1858 
1859 int register_netdevice_notifier_net(struct net *net, struct notifier_block *nb)
1860 {
1861 	int err;
1862 
1863 	rtnl_lock();
1864 	err = __register_netdevice_notifier_net(net, nb, false);
1865 	rtnl_unlock();
1866 	return err;
1867 }
1868 EXPORT_SYMBOL(register_netdevice_notifier_net);
1869 
1870 /**
1871  * unregister_netdevice_notifier_net - unregister a per-netns
1872  *                                     network notifier block
1873  * @net: network namespace
1874  * @nb: notifier
1875  *
1876  * Unregister a notifier previously registered by
1877  * register_netdevice_notifier_net(). The notifier is unlinked from the
1878  * kernel structures and may then be reused. A negative errno code
1879  * is returned on a failure.
1880  *
1881  * After unregistering unregister and down device events are synthesized
1882  * for all devices on the device list to the removed notifier to remove
1883  * the need for special case cleanup code.
1884  */
1885 
1886 int unregister_netdevice_notifier_net(struct net *net,
1887 				      struct notifier_block *nb)
1888 {
1889 	int err;
1890 
1891 	rtnl_lock();
1892 	err = __unregister_netdevice_notifier_net(net, nb);
1893 	rtnl_unlock();
1894 	return err;
1895 }
1896 EXPORT_SYMBOL(unregister_netdevice_notifier_net);
1897 
1898 static void __move_netdevice_notifier_net(struct net *src_net,
1899 					  struct net *dst_net,
1900 					  struct notifier_block *nb)
1901 {
1902 	__unregister_netdevice_notifier_net(src_net, nb);
1903 	__register_netdevice_notifier_net(dst_net, nb, true);
1904 }
1905 
1906 int register_netdevice_notifier_dev_net(struct net_device *dev,
1907 					struct notifier_block *nb,
1908 					struct netdev_net_notifier *nn)
1909 {
1910 	int err;
1911 
1912 	rtnl_lock();
1913 	err = __register_netdevice_notifier_net(dev_net(dev), nb, false);
1914 	if (!err) {
1915 		nn->nb = nb;
1916 		list_add(&nn->list, &dev->net_notifier_list);
1917 	}
1918 	rtnl_unlock();
1919 	return err;
1920 }
1921 EXPORT_SYMBOL(register_netdevice_notifier_dev_net);
1922 
1923 int unregister_netdevice_notifier_dev_net(struct net_device *dev,
1924 					  struct notifier_block *nb,
1925 					  struct netdev_net_notifier *nn)
1926 {
1927 	int err;
1928 
1929 	rtnl_lock();
1930 	list_del(&nn->list);
1931 	err = __unregister_netdevice_notifier_net(dev_net(dev), nb);
1932 	rtnl_unlock();
1933 	return err;
1934 }
1935 EXPORT_SYMBOL(unregister_netdevice_notifier_dev_net);
1936 
1937 static void move_netdevice_notifiers_dev_net(struct net_device *dev,
1938 					     struct net *net)
1939 {
1940 	struct netdev_net_notifier *nn;
1941 
1942 	list_for_each_entry(nn, &dev->net_notifier_list, list)
1943 		__move_netdevice_notifier_net(dev_net(dev), net, nn->nb);
1944 }
1945 
1946 /**
1947  *	call_netdevice_notifiers_info - call all network notifier blocks
1948  *	@val: value passed unmodified to notifier function
1949  *	@info: notifier information data
1950  *
1951  *	Call all network notifier blocks.  Parameters and return value
1952  *	are as for raw_notifier_call_chain().
1953  */
1954 
1955 int call_netdevice_notifiers_info(unsigned long val,
1956 				  struct netdev_notifier_info *info)
1957 {
1958 	struct net *net = dev_net(info->dev);
1959 	int ret;
1960 
1961 	ASSERT_RTNL();
1962 
1963 	/* Run per-netns notifier block chain first, then run the global one.
1964 	 * Hopefully, one day, the global one is going to be removed after
1965 	 * all notifier block registrators get converted to be per-netns.
1966 	 */
1967 	ret = raw_notifier_call_chain(&net->netdev_chain, val, info);
1968 	if (ret & NOTIFY_STOP_MASK)
1969 		return ret;
1970 	return raw_notifier_call_chain(&netdev_chain, val, info);
1971 }
1972 
1973 /**
1974  *	call_netdevice_notifiers_info_robust - call per-netns notifier blocks
1975  *	                                       for and rollback on error
1976  *	@val_up: value passed unmodified to notifier function
1977  *	@val_down: value passed unmodified to the notifier function when
1978  *	           recovering from an error on @val_up
1979  *	@info: notifier information data
1980  *
1981  *	Call all per-netns network notifier blocks, but not notifier blocks on
1982  *	the global notifier chain. Parameters and return value are as for
1983  *	raw_notifier_call_chain_robust().
1984  */
1985 
1986 static int
1987 call_netdevice_notifiers_info_robust(unsigned long val_up,
1988 				     unsigned long val_down,
1989 				     struct netdev_notifier_info *info)
1990 {
1991 	struct net *net = dev_net(info->dev);
1992 
1993 	ASSERT_RTNL();
1994 
1995 	return raw_notifier_call_chain_robust(&net->netdev_chain,
1996 					      val_up, val_down, info);
1997 }
1998 
1999 static int call_netdevice_notifiers_extack(unsigned long val,
2000 					   struct net_device *dev,
2001 					   struct netlink_ext_ack *extack)
2002 {
2003 	struct netdev_notifier_info info = {
2004 		.dev = dev,
2005 		.extack = extack,
2006 	};
2007 
2008 	return call_netdevice_notifiers_info(val, &info);
2009 }
2010 
2011 /**
2012  *	call_netdevice_notifiers - call all network notifier blocks
2013  *      @val: value passed unmodified to notifier function
2014  *      @dev: net_device pointer passed unmodified to notifier function
2015  *
2016  *	Call all network notifier blocks.  Parameters and return value
2017  *	are as for raw_notifier_call_chain().
2018  */
2019 
2020 int call_netdevice_notifiers(unsigned long val, struct net_device *dev)
2021 {
2022 	return call_netdevice_notifiers_extack(val, dev, NULL);
2023 }
2024 EXPORT_SYMBOL(call_netdevice_notifiers);
2025 
2026 /**
2027  *	call_netdevice_notifiers_mtu - call all network notifier blocks
2028  *	@val: value passed unmodified to notifier function
2029  *	@dev: net_device pointer passed unmodified to notifier function
2030  *	@arg: additional u32 argument passed to the notifier function
2031  *
2032  *	Call all network notifier blocks.  Parameters and return value
2033  *	are as for raw_notifier_call_chain().
2034  */
2035 static int call_netdevice_notifiers_mtu(unsigned long val,
2036 					struct net_device *dev, u32 arg)
2037 {
2038 	struct netdev_notifier_info_ext info = {
2039 		.info.dev = dev,
2040 		.ext.mtu = arg,
2041 	};
2042 
2043 	BUILD_BUG_ON(offsetof(struct netdev_notifier_info_ext, info) != 0);
2044 
2045 	return call_netdevice_notifiers_info(val, &info.info);
2046 }
2047 
2048 #ifdef CONFIG_NET_INGRESS
2049 static DEFINE_STATIC_KEY_FALSE(ingress_needed_key);
2050 
2051 void net_inc_ingress_queue(void)
2052 {
2053 	static_branch_inc(&ingress_needed_key);
2054 }
2055 EXPORT_SYMBOL_GPL(net_inc_ingress_queue);
2056 
2057 void net_dec_ingress_queue(void)
2058 {
2059 	static_branch_dec(&ingress_needed_key);
2060 }
2061 EXPORT_SYMBOL_GPL(net_dec_ingress_queue);
2062 #endif
2063 
2064 #ifdef CONFIG_NET_EGRESS
2065 static DEFINE_STATIC_KEY_FALSE(egress_needed_key);
2066 
2067 void net_inc_egress_queue(void)
2068 {
2069 	static_branch_inc(&egress_needed_key);
2070 }
2071 EXPORT_SYMBOL_GPL(net_inc_egress_queue);
2072 
2073 void net_dec_egress_queue(void)
2074 {
2075 	static_branch_dec(&egress_needed_key);
2076 }
2077 EXPORT_SYMBOL_GPL(net_dec_egress_queue);
2078 #endif
2079 
2080 DEFINE_STATIC_KEY_FALSE(netstamp_needed_key);
2081 EXPORT_SYMBOL(netstamp_needed_key);
2082 #ifdef CONFIG_JUMP_LABEL
2083 static atomic_t netstamp_needed_deferred;
2084 static atomic_t netstamp_wanted;
2085 static void netstamp_clear(struct work_struct *work)
2086 {
2087 	int deferred = atomic_xchg(&netstamp_needed_deferred, 0);
2088 	int wanted;
2089 
2090 	wanted = atomic_add_return(deferred, &netstamp_wanted);
2091 	if (wanted > 0)
2092 		static_branch_enable(&netstamp_needed_key);
2093 	else
2094 		static_branch_disable(&netstamp_needed_key);
2095 }
2096 static DECLARE_WORK(netstamp_work, netstamp_clear);
2097 #endif
2098 
2099 void net_enable_timestamp(void)
2100 {
2101 #ifdef CONFIG_JUMP_LABEL
2102 	int wanted = atomic_read(&netstamp_wanted);
2103 
2104 	while (wanted > 0) {
2105 		if (atomic_try_cmpxchg(&netstamp_wanted, &wanted, wanted + 1))
2106 			return;
2107 	}
2108 	atomic_inc(&netstamp_needed_deferred);
2109 	schedule_work(&netstamp_work);
2110 #else
2111 	static_branch_inc(&netstamp_needed_key);
2112 #endif
2113 }
2114 EXPORT_SYMBOL(net_enable_timestamp);
2115 
2116 void net_disable_timestamp(void)
2117 {
2118 #ifdef CONFIG_JUMP_LABEL
2119 	int wanted = atomic_read(&netstamp_wanted);
2120 
2121 	while (wanted > 1) {
2122 		if (atomic_try_cmpxchg(&netstamp_wanted, &wanted, wanted - 1))
2123 			return;
2124 	}
2125 	atomic_dec(&netstamp_needed_deferred);
2126 	schedule_work(&netstamp_work);
2127 #else
2128 	static_branch_dec(&netstamp_needed_key);
2129 #endif
2130 }
2131 EXPORT_SYMBOL(net_disable_timestamp);
2132 
2133 static inline void net_timestamp_set(struct sk_buff *skb)
2134 {
2135 	skb->tstamp = 0;
2136 	skb->mono_delivery_time = 0;
2137 	if (static_branch_unlikely(&netstamp_needed_key))
2138 		skb->tstamp = ktime_get_real();
2139 }
2140 
2141 #define net_timestamp_check(COND, SKB)				\
2142 	if (static_branch_unlikely(&netstamp_needed_key)) {	\
2143 		if ((COND) && !(SKB)->tstamp)			\
2144 			(SKB)->tstamp = ktime_get_real();	\
2145 	}							\
2146 
2147 bool is_skb_forwardable(const struct net_device *dev, const struct sk_buff *skb)
2148 {
2149 	return __is_skb_forwardable(dev, skb, true);
2150 }
2151 EXPORT_SYMBOL_GPL(is_skb_forwardable);
2152 
2153 static int __dev_forward_skb2(struct net_device *dev, struct sk_buff *skb,
2154 			      bool check_mtu)
2155 {
2156 	int ret = ____dev_forward_skb(dev, skb, check_mtu);
2157 
2158 	if (likely(!ret)) {
2159 		skb->protocol = eth_type_trans(skb, dev);
2160 		skb_postpull_rcsum(skb, eth_hdr(skb), ETH_HLEN);
2161 	}
2162 
2163 	return ret;
2164 }
2165 
2166 int __dev_forward_skb(struct net_device *dev, struct sk_buff *skb)
2167 {
2168 	return __dev_forward_skb2(dev, skb, true);
2169 }
2170 EXPORT_SYMBOL_GPL(__dev_forward_skb);
2171 
2172 /**
2173  * dev_forward_skb - loopback an skb to another netif
2174  *
2175  * @dev: destination network device
2176  * @skb: buffer to forward
2177  *
2178  * return values:
2179  *	NET_RX_SUCCESS	(no congestion)
2180  *	NET_RX_DROP     (packet was dropped, but freed)
2181  *
2182  * dev_forward_skb can be used for injecting an skb from the
2183  * start_xmit function of one device into the receive queue
2184  * of another device.
2185  *
2186  * The receiving device may be in another namespace, so
2187  * we have to clear all information in the skb that could
2188  * impact namespace isolation.
2189  */
2190 int dev_forward_skb(struct net_device *dev, struct sk_buff *skb)
2191 {
2192 	return __dev_forward_skb(dev, skb) ?: netif_rx_internal(skb);
2193 }
2194 EXPORT_SYMBOL_GPL(dev_forward_skb);
2195 
2196 int dev_forward_skb_nomtu(struct net_device *dev, struct sk_buff *skb)
2197 {
2198 	return __dev_forward_skb2(dev, skb, false) ?: netif_rx_internal(skb);
2199 }
2200 
2201 static inline int deliver_skb(struct sk_buff *skb,
2202 			      struct packet_type *pt_prev,
2203 			      struct net_device *orig_dev)
2204 {
2205 	if (unlikely(skb_orphan_frags_rx(skb, GFP_ATOMIC)))
2206 		return -ENOMEM;
2207 	refcount_inc(&skb->users);
2208 	return pt_prev->func(skb, skb->dev, pt_prev, orig_dev);
2209 }
2210 
2211 static inline void deliver_ptype_list_skb(struct sk_buff *skb,
2212 					  struct packet_type **pt,
2213 					  struct net_device *orig_dev,
2214 					  __be16 type,
2215 					  struct list_head *ptype_list)
2216 {
2217 	struct packet_type *ptype, *pt_prev = *pt;
2218 
2219 	list_for_each_entry_rcu(ptype, ptype_list, list) {
2220 		if (ptype->type != type)
2221 			continue;
2222 		if (pt_prev)
2223 			deliver_skb(skb, pt_prev, orig_dev);
2224 		pt_prev = ptype;
2225 	}
2226 	*pt = pt_prev;
2227 }
2228 
2229 static inline bool skb_loop_sk(struct packet_type *ptype, struct sk_buff *skb)
2230 {
2231 	if (!ptype->af_packet_priv || !skb->sk)
2232 		return false;
2233 
2234 	if (ptype->id_match)
2235 		return ptype->id_match(ptype, skb->sk);
2236 	else if ((struct sock *)ptype->af_packet_priv == skb->sk)
2237 		return true;
2238 
2239 	return false;
2240 }
2241 
2242 /**
2243  * dev_nit_active - return true if any network interface taps are in use
2244  *
2245  * @dev: network device to check for the presence of taps
2246  */
2247 bool dev_nit_active(struct net_device *dev)
2248 {
2249 	return !list_empty(&ptype_all) || !list_empty(&dev->ptype_all);
2250 }
2251 EXPORT_SYMBOL_GPL(dev_nit_active);
2252 
2253 /*
2254  *	Support routine. Sends outgoing frames to any network
2255  *	taps currently in use.
2256  */
2257 
2258 void dev_queue_xmit_nit(struct sk_buff *skb, struct net_device *dev)
2259 {
2260 	struct packet_type *ptype;
2261 	struct sk_buff *skb2 = NULL;
2262 	struct packet_type *pt_prev = NULL;
2263 	struct list_head *ptype_list = &ptype_all;
2264 
2265 	rcu_read_lock();
2266 again:
2267 	list_for_each_entry_rcu(ptype, ptype_list, list) {
2268 		if (ptype->ignore_outgoing)
2269 			continue;
2270 
2271 		/* Never send packets back to the socket
2272 		 * they originated from - MvS (miquels@drinkel.ow.org)
2273 		 */
2274 		if (skb_loop_sk(ptype, skb))
2275 			continue;
2276 
2277 		if (pt_prev) {
2278 			deliver_skb(skb2, pt_prev, skb->dev);
2279 			pt_prev = ptype;
2280 			continue;
2281 		}
2282 
2283 		/* need to clone skb, done only once */
2284 		skb2 = skb_clone(skb, GFP_ATOMIC);
2285 		if (!skb2)
2286 			goto out_unlock;
2287 
2288 		net_timestamp_set(skb2);
2289 
2290 		/* skb->nh should be correctly
2291 		 * set by sender, so that the second statement is
2292 		 * just protection against buggy protocols.
2293 		 */
2294 		skb_reset_mac_header(skb2);
2295 
2296 		if (skb_network_header(skb2) < skb2->data ||
2297 		    skb_network_header(skb2) > skb_tail_pointer(skb2)) {
2298 			net_crit_ratelimited("protocol %04x is buggy, dev %s\n",
2299 					     ntohs(skb2->protocol),
2300 					     dev->name);
2301 			skb_reset_network_header(skb2);
2302 		}
2303 
2304 		skb2->transport_header = skb2->network_header;
2305 		skb2->pkt_type = PACKET_OUTGOING;
2306 		pt_prev = ptype;
2307 	}
2308 
2309 	if (ptype_list == &ptype_all) {
2310 		ptype_list = &dev->ptype_all;
2311 		goto again;
2312 	}
2313 out_unlock:
2314 	if (pt_prev) {
2315 		if (!skb_orphan_frags_rx(skb2, GFP_ATOMIC))
2316 			pt_prev->func(skb2, skb->dev, pt_prev, skb->dev);
2317 		else
2318 			kfree_skb(skb2);
2319 	}
2320 	rcu_read_unlock();
2321 }
2322 EXPORT_SYMBOL_GPL(dev_queue_xmit_nit);
2323 
2324 /**
2325  * netif_setup_tc - Handle tc mappings on real_num_tx_queues change
2326  * @dev: Network device
2327  * @txq: number of queues available
2328  *
2329  * If real_num_tx_queues is changed the tc mappings may no longer be
2330  * valid. To resolve this verify the tc mapping remains valid and if
2331  * not NULL the mapping. With no priorities mapping to this
2332  * offset/count pair it will no longer be used. In the worst case TC0
2333  * is invalid nothing can be done so disable priority mappings. If is
2334  * expected that drivers will fix this mapping if they can before
2335  * calling netif_set_real_num_tx_queues.
2336  */
2337 static void netif_setup_tc(struct net_device *dev, unsigned int txq)
2338 {
2339 	int i;
2340 	struct netdev_tc_txq *tc = &dev->tc_to_txq[0];
2341 
2342 	/* If TC0 is invalidated disable TC mapping */
2343 	if (tc->offset + tc->count > txq) {
2344 		netdev_warn(dev, "Number of in use tx queues changed invalidating tc mappings. Priority traffic classification disabled!\n");
2345 		dev->num_tc = 0;
2346 		return;
2347 	}
2348 
2349 	/* Invalidated prio to tc mappings set to TC0 */
2350 	for (i = 1; i < TC_BITMASK + 1; i++) {
2351 		int q = netdev_get_prio_tc_map(dev, i);
2352 
2353 		tc = &dev->tc_to_txq[q];
2354 		if (tc->offset + tc->count > txq) {
2355 			netdev_warn(dev, "Number of in use tx queues changed. Priority %i to tc mapping %i is no longer valid. Setting map to 0\n",
2356 				    i, q);
2357 			netdev_set_prio_tc_map(dev, i, 0);
2358 		}
2359 	}
2360 }
2361 
2362 int netdev_txq_to_tc(struct net_device *dev, unsigned int txq)
2363 {
2364 	if (dev->num_tc) {
2365 		struct netdev_tc_txq *tc = &dev->tc_to_txq[0];
2366 		int i;
2367 
2368 		/* walk through the TCs and see if it falls into any of them */
2369 		for (i = 0; i < TC_MAX_QUEUE; i++, tc++) {
2370 			if ((txq - tc->offset) < tc->count)
2371 				return i;
2372 		}
2373 
2374 		/* didn't find it, just return -1 to indicate no match */
2375 		return -1;
2376 	}
2377 
2378 	return 0;
2379 }
2380 EXPORT_SYMBOL(netdev_txq_to_tc);
2381 
2382 #ifdef CONFIG_XPS
2383 static struct static_key xps_needed __read_mostly;
2384 static struct static_key xps_rxqs_needed __read_mostly;
2385 static DEFINE_MUTEX(xps_map_mutex);
2386 #define xmap_dereference(P)		\
2387 	rcu_dereference_protected((P), lockdep_is_held(&xps_map_mutex))
2388 
2389 static bool remove_xps_queue(struct xps_dev_maps *dev_maps,
2390 			     struct xps_dev_maps *old_maps, int tci, u16 index)
2391 {
2392 	struct xps_map *map = NULL;
2393 	int pos;
2394 
2395 	map = xmap_dereference(dev_maps->attr_map[tci]);
2396 	if (!map)
2397 		return false;
2398 
2399 	for (pos = map->len; pos--;) {
2400 		if (map->queues[pos] != index)
2401 			continue;
2402 
2403 		if (map->len > 1) {
2404 			map->queues[pos] = map->queues[--map->len];
2405 			break;
2406 		}
2407 
2408 		if (old_maps)
2409 			RCU_INIT_POINTER(old_maps->attr_map[tci], NULL);
2410 		RCU_INIT_POINTER(dev_maps->attr_map[tci], NULL);
2411 		kfree_rcu(map, rcu);
2412 		return false;
2413 	}
2414 
2415 	return true;
2416 }
2417 
2418 static bool remove_xps_queue_cpu(struct net_device *dev,
2419 				 struct xps_dev_maps *dev_maps,
2420 				 int cpu, u16 offset, u16 count)
2421 {
2422 	int num_tc = dev_maps->num_tc;
2423 	bool active = false;
2424 	int tci;
2425 
2426 	for (tci = cpu * num_tc; num_tc--; tci++) {
2427 		int i, j;
2428 
2429 		for (i = count, j = offset; i--; j++) {
2430 			if (!remove_xps_queue(dev_maps, NULL, tci, j))
2431 				break;
2432 		}
2433 
2434 		active |= i < 0;
2435 	}
2436 
2437 	return active;
2438 }
2439 
2440 static void reset_xps_maps(struct net_device *dev,
2441 			   struct xps_dev_maps *dev_maps,
2442 			   enum xps_map_type type)
2443 {
2444 	static_key_slow_dec_cpuslocked(&xps_needed);
2445 	if (type == XPS_RXQS)
2446 		static_key_slow_dec_cpuslocked(&xps_rxqs_needed);
2447 
2448 	RCU_INIT_POINTER(dev->xps_maps[type], NULL);
2449 
2450 	kfree_rcu(dev_maps, rcu);
2451 }
2452 
2453 static void clean_xps_maps(struct net_device *dev, enum xps_map_type type,
2454 			   u16 offset, u16 count)
2455 {
2456 	struct xps_dev_maps *dev_maps;
2457 	bool active = false;
2458 	int i, j;
2459 
2460 	dev_maps = xmap_dereference(dev->xps_maps[type]);
2461 	if (!dev_maps)
2462 		return;
2463 
2464 	for (j = 0; j < dev_maps->nr_ids; j++)
2465 		active |= remove_xps_queue_cpu(dev, dev_maps, j, offset, count);
2466 	if (!active)
2467 		reset_xps_maps(dev, dev_maps, type);
2468 
2469 	if (type == XPS_CPUS) {
2470 		for (i = offset + (count - 1); count--; i--)
2471 			netdev_queue_numa_node_write(
2472 				netdev_get_tx_queue(dev, i), NUMA_NO_NODE);
2473 	}
2474 }
2475 
2476 static void netif_reset_xps_queues(struct net_device *dev, u16 offset,
2477 				   u16 count)
2478 {
2479 	if (!static_key_false(&xps_needed))
2480 		return;
2481 
2482 	cpus_read_lock();
2483 	mutex_lock(&xps_map_mutex);
2484 
2485 	if (static_key_false(&xps_rxqs_needed))
2486 		clean_xps_maps(dev, XPS_RXQS, offset, count);
2487 
2488 	clean_xps_maps(dev, XPS_CPUS, offset, count);
2489 
2490 	mutex_unlock(&xps_map_mutex);
2491 	cpus_read_unlock();
2492 }
2493 
2494 static void netif_reset_xps_queues_gt(struct net_device *dev, u16 index)
2495 {
2496 	netif_reset_xps_queues(dev, index, dev->num_tx_queues - index);
2497 }
2498 
2499 static struct xps_map *expand_xps_map(struct xps_map *map, int attr_index,
2500 				      u16 index, bool is_rxqs_map)
2501 {
2502 	struct xps_map *new_map;
2503 	int alloc_len = XPS_MIN_MAP_ALLOC;
2504 	int i, pos;
2505 
2506 	for (pos = 0; map && pos < map->len; pos++) {
2507 		if (map->queues[pos] != index)
2508 			continue;
2509 		return map;
2510 	}
2511 
2512 	/* Need to add tx-queue to this CPU's/rx-queue's existing map */
2513 	if (map) {
2514 		if (pos < map->alloc_len)
2515 			return map;
2516 
2517 		alloc_len = map->alloc_len * 2;
2518 	}
2519 
2520 	/* Need to allocate new map to store tx-queue on this CPU's/rx-queue's
2521 	 *  map
2522 	 */
2523 	if (is_rxqs_map)
2524 		new_map = kzalloc(XPS_MAP_SIZE(alloc_len), GFP_KERNEL);
2525 	else
2526 		new_map = kzalloc_node(XPS_MAP_SIZE(alloc_len), GFP_KERNEL,
2527 				       cpu_to_node(attr_index));
2528 	if (!new_map)
2529 		return NULL;
2530 
2531 	for (i = 0; i < pos; i++)
2532 		new_map->queues[i] = map->queues[i];
2533 	new_map->alloc_len = alloc_len;
2534 	new_map->len = pos;
2535 
2536 	return new_map;
2537 }
2538 
2539 /* Copy xps maps at a given index */
2540 static void xps_copy_dev_maps(struct xps_dev_maps *dev_maps,
2541 			      struct xps_dev_maps *new_dev_maps, int index,
2542 			      int tc, bool skip_tc)
2543 {
2544 	int i, tci = index * dev_maps->num_tc;
2545 	struct xps_map *map;
2546 
2547 	/* copy maps belonging to foreign traffic classes */
2548 	for (i = 0; i < dev_maps->num_tc; i++, tci++) {
2549 		if (i == tc && skip_tc)
2550 			continue;
2551 
2552 		/* fill in the new device map from the old device map */
2553 		map = xmap_dereference(dev_maps->attr_map[tci]);
2554 		RCU_INIT_POINTER(new_dev_maps->attr_map[tci], map);
2555 	}
2556 }
2557 
2558 /* Must be called under cpus_read_lock */
2559 int __netif_set_xps_queue(struct net_device *dev, const unsigned long *mask,
2560 			  u16 index, enum xps_map_type type)
2561 {
2562 	struct xps_dev_maps *dev_maps, *new_dev_maps = NULL, *old_dev_maps = NULL;
2563 	const unsigned long *online_mask = NULL;
2564 	bool active = false, copy = false;
2565 	int i, j, tci, numa_node_id = -2;
2566 	int maps_sz, num_tc = 1, tc = 0;
2567 	struct xps_map *map, *new_map;
2568 	unsigned int nr_ids;
2569 
2570 	WARN_ON_ONCE(index >= dev->num_tx_queues);
2571 
2572 	if (dev->num_tc) {
2573 		/* Do not allow XPS on subordinate device directly */
2574 		num_tc = dev->num_tc;
2575 		if (num_tc < 0)
2576 			return -EINVAL;
2577 
2578 		/* If queue belongs to subordinate dev use its map */
2579 		dev = netdev_get_tx_queue(dev, index)->sb_dev ? : dev;
2580 
2581 		tc = netdev_txq_to_tc(dev, index);
2582 		if (tc < 0)
2583 			return -EINVAL;
2584 	}
2585 
2586 	mutex_lock(&xps_map_mutex);
2587 
2588 	dev_maps = xmap_dereference(dev->xps_maps[type]);
2589 	if (type == XPS_RXQS) {
2590 		maps_sz = XPS_RXQ_DEV_MAPS_SIZE(num_tc, dev->num_rx_queues);
2591 		nr_ids = dev->num_rx_queues;
2592 	} else {
2593 		maps_sz = XPS_CPU_DEV_MAPS_SIZE(num_tc);
2594 		if (num_possible_cpus() > 1)
2595 			online_mask = cpumask_bits(cpu_online_mask);
2596 		nr_ids = nr_cpu_ids;
2597 	}
2598 
2599 	if (maps_sz < L1_CACHE_BYTES)
2600 		maps_sz = L1_CACHE_BYTES;
2601 
2602 	/* The old dev_maps could be larger or smaller than the one we're
2603 	 * setting up now, as dev->num_tc or nr_ids could have been updated in
2604 	 * between. We could try to be smart, but let's be safe instead and only
2605 	 * copy foreign traffic classes if the two map sizes match.
2606 	 */
2607 	if (dev_maps &&
2608 	    dev_maps->num_tc == num_tc && dev_maps->nr_ids == nr_ids)
2609 		copy = true;
2610 
2611 	/* allocate memory for queue storage */
2612 	for (j = -1; j = netif_attrmask_next_and(j, online_mask, mask, nr_ids),
2613 	     j < nr_ids;) {
2614 		if (!new_dev_maps) {
2615 			new_dev_maps = kzalloc(maps_sz, GFP_KERNEL);
2616 			if (!new_dev_maps) {
2617 				mutex_unlock(&xps_map_mutex);
2618 				return -ENOMEM;
2619 			}
2620 
2621 			new_dev_maps->nr_ids = nr_ids;
2622 			new_dev_maps->num_tc = num_tc;
2623 		}
2624 
2625 		tci = j * num_tc + tc;
2626 		map = copy ? xmap_dereference(dev_maps->attr_map[tci]) : NULL;
2627 
2628 		map = expand_xps_map(map, j, index, type == XPS_RXQS);
2629 		if (!map)
2630 			goto error;
2631 
2632 		RCU_INIT_POINTER(new_dev_maps->attr_map[tci], map);
2633 	}
2634 
2635 	if (!new_dev_maps)
2636 		goto out_no_new_maps;
2637 
2638 	if (!dev_maps) {
2639 		/* Increment static keys at most once per type */
2640 		static_key_slow_inc_cpuslocked(&xps_needed);
2641 		if (type == XPS_RXQS)
2642 			static_key_slow_inc_cpuslocked(&xps_rxqs_needed);
2643 	}
2644 
2645 	for (j = 0; j < nr_ids; j++) {
2646 		bool skip_tc = false;
2647 
2648 		tci = j * num_tc + tc;
2649 		if (netif_attr_test_mask(j, mask, nr_ids) &&
2650 		    netif_attr_test_online(j, online_mask, nr_ids)) {
2651 			/* add tx-queue to CPU/rx-queue maps */
2652 			int pos = 0;
2653 
2654 			skip_tc = true;
2655 
2656 			map = xmap_dereference(new_dev_maps->attr_map[tci]);
2657 			while ((pos < map->len) && (map->queues[pos] != index))
2658 				pos++;
2659 
2660 			if (pos == map->len)
2661 				map->queues[map->len++] = index;
2662 #ifdef CONFIG_NUMA
2663 			if (type == XPS_CPUS) {
2664 				if (numa_node_id == -2)
2665 					numa_node_id = cpu_to_node(j);
2666 				else if (numa_node_id != cpu_to_node(j))
2667 					numa_node_id = -1;
2668 			}
2669 #endif
2670 		}
2671 
2672 		if (copy)
2673 			xps_copy_dev_maps(dev_maps, new_dev_maps, j, tc,
2674 					  skip_tc);
2675 	}
2676 
2677 	rcu_assign_pointer(dev->xps_maps[type], new_dev_maps);
2678 
2679 	/* Cleanup old maps */
2680 	if (!dev_maps)
2681 		goto out_no_old_maps;
2682 
2683 	for (j = 0; j < dev_maps->nr_ids; j++) {
2684 		for (i = num_tc, tci = j * dev_maps->num_tc; i--; tci++) {
2685 			map = xmap_dereference(dev_maps->attr_map[tci]);
2686 			if (!map)
2687 				continue;
2688 
2689 			if (copy) {
2690 				new_map = xmap_dereference(new_dev_maps->attr_map[tci]);
2691 				if (map == new_map)
2692 					continue;
2693 			}
2694 
2695 			RCU_INIT_POINTER(dev_maps->attr_map[tci], NULL);
2696 			kfree_rcu(map, rcu);
2697 		}
2698 	}
2699 
2700 	old_dev_maps = dev_maps;
2701 
2702 out_no_old_maps:
2703 	dev_maps = new_dev_maps;
2704 	active = true;
2705 
2706 out_no_new_maps:
2707 	if (type == XPS_CPUS)
2708 		/* update Tx queue numa node */
2709 		netdev_queue_numa_node_write(netdev_get_tx_queue(dev, index),
2710 					     (numa_node_id >= 0) ?
2711 					     numa_node_id : NUMA_NO_NODE);
2712 
2713 	if (!dev_maps)
2714 		goto out_no_maps;
2715 
2716 	/* removes tx-queue from unused CPUs/rx-queues */
2717 	for (j = 0; j < dev_maps->nr_ids; j++) {
2718 		tci = j * dev_maps->num_tc;
2719 
2720 		for (i = 0; i < dev_maps->num_tc; i++, tci++) {
2721 			if (i == tc &&
2722 			    netif_attr_test_mask(j, mask, dev_maps->nr_ids) &&
2723 			    netif_attr_test_online(j, online_mask, dev_maps->nr_ids))
2724 				continue;
2725 
2726 			active |= remove_xps_queue(dev_maps,
2727 						   copy ? old_dev_maps : NULL,
2728 						   tci, index);
2729 		}
2730 	}
2731 
2732 	if (old_dev_maps)
2733 		kfree_rcu(old_dev_maps, rcu);
2734 
2735 	/* free map if not active */
2736 	if (!active)
2737 		reset_xps_maps(dev, dev_maps, type);
2738 
2739 out_no_maps:
2740 	mutex_unlock(&xps_map_mutex);
2741 
2742 	return 0;
2743 error:
2744 	/* remove any maps that we added */
2745 	for (j = 0; j < nr_ids; j++) {
2746 		for (i = num_tc, tci = j * num_tc; i--; tci++) {
2747 			new_map = xmap_dereference(new_dev_maps->attr_map[tci]);
2748 			map = copy ?
2749 			      xmap_dereference(dev_maps->attr_map[tci]) :
2750 			      NULL;
2751 			if (new_map && new_map != map)
2752 				kfree(new_map);
2753 		}
2754 	}
2755 
2756 	mutex_unlock(&xps_map_mutex);
2757 
2758 	kfree(new_dev_maps);
2759 	return -ENOMEM;
2760 }
2761 EXPORT_SYMBOL_GPL(__netif_set_xps_queue);
2762 
2763 int netif_set_xps_queue(struct net_device *dev, const struct cpumask *mask,
2764 			u16 index)
2765 {
2766 	int ret;
2767 
2768 	cpus_read_lock();
2769 	ret =  __netif_set_xps_queue(dev, cpumask_bits(mask), index, XPS_CPUS);
2770 	cpus_read_unlock();
2771 
2772 	return ret;
2773 }
2774 EXPORT_SYMBOL(netif_set_xps_queue);
2775 
2776 #endif
2777 static void netdev_unbind_all_sb_channels(struct net_device *dev)
2778 {
2779 	struct netdev_queue *txq = &dev->_tx[dev->num_tx_queues];
2780 
2781 	/* Unbind any subordinate channels */
2782 	while (txq-- != &dev->_tx[0]) {
2783 		if (txq->sb_dev)
2784 			netdev_unbind_sb_channel(dev, txq->sb_dev);
2785 	}
2786 }
2787 
2788 void netdev_reset_tc(struct net_device *dev)
2789 {
2790 #ifdef CONFIG_XPS
2791 	netif_reset_xps_queues_gt(dev, 0);
2792 #endif
2793 	netdev_unbind_all_sb_channels(dev);
2794 
2795 	/* Reset TC configuration of device */
2796 	dev->num_tc = 0;
2797 	memset(dev->tc_to_txq, 0, sizeof(dev->tc_to_txq));
2798 	memset(dev->prio_tc_map, 0, sizeof(dev->prio_tc_map));
2799 }
2800 EXPORT_SYMBOL(netdev_reset_tc);
2801 
2802 int netdev_set_tc_queue(struct net_device *dev, u8 tc, u16 count, u16 offset)
2803 {
2804 	if (tc >= dev->num_tc)
2805 		return -EINVAL;
2806 
2807 #ifdef CONFIG_XPS
2808 	netif_reset_xps_queues(dev, offset, count);
2809 #endif
2810 	dev->tc_to_txq[tc].count = count;
2811 	dev->tc_to_txq[tc].offset = offset;
2812 	return 0;
2813 }
2814 EXPORT_SYMBOL(netdev_set_tc_queue);
2815 
2816 int netdev_set_num_tc(struct net_device *dev, u8 num_tc)
2817 {
2818 	if (num_tc > TC_MAX_QUEUE)
2819 		return -EINVAL;
2820 
2821 #ifdef CONFIG_XPS
2822 	netif_reset_xps_queues_gt(dev, 0);
2823 #endif
2824 	netdev_unbind_all_sb_channels(dev);
2825 
2826 	dev->num_tc = num_tc;
2827 	return 0;
2828 }
2829 EXPORT_SYMBOL(netdev_set_num_tc);
2830 
2831 void netdev_unbind_sb_channel(struct net_device *dev,
2832 			      struct net_device *sb_dev)
2833 {
2834 	struct netdev_queue *txq = &dev->_tx[dev->num_tx_queues];
2835 
2836 #ifdef CONFIG_XPS
2837 	netif_reset_xps_queues_gt(sb_dev, 0);
2838 #endif
2839 	memset(sb_dev->tc_to_txq, 0, sizeof(sb_dev->tc_to_txq));
2840 	memset(sb_dev->prio_tc_map, 0, sizeof(sb_dev->prio_tc_map));
2841 
2842 	while (txq-- != &dev->_tx[0]) {
2843 		if (txq->sb_dev == sb_dev)
2844 			txq->sb_dev = NULL;
2845 	}
2846 }
2847 EXPORT_SYMBOL(netdev_unbind_sb_channel);
2848 
2849 int netdev_bind_sb_channel_queue(struct net_device *dev,
2850 				 struct net_device *sb_dev,
2851 				 u8 tc, u16 count, u16 offset)
2852 {
2853 	/* Make certain the sb_dev and dev are already configured */
2854 	if (sb_dev->num_tc >= 0 || tc >= dev->num_tc)
2855 		return -EINVAL;
2856 
2857 	/* We cannot hand out queues we don't have */
2858 	if ((offset + count) > dev->real_num_tx_queues)
2859 		return -EINVAL;
2860 
2861 	/* Record the mapping */
2862 	sb_dev->tc_to_txq[tc].count = count;
2863 	sb_dev->tc_to_txq[tc].offset = offset;
2864 
2865 	/* Provide a way for Tx queue to find the tc_to_txq map or
2866 	 * XPS map for itself.
2867 	 */
2868 	while (count--)
2869 		netdev_get_tx_queue(dev, count + offset)->sb_dev = sb_dev;
2870 
2871 	return 0;
2872 }
2873 EXPORT_SYMBOL(netdev_bind_sb_channel_queue);
2874 
2875 int netdev_set_sb_channel(struct net_device *dev, u16 channel)
2876 {
2877 	/* Do not use a multiqueue device to represent a subordinate channel */
2878 	if (netif_is_multiqueue(dev))
2879 		return -ENODEV;
2880 
2881 	/* We allow channels 1 - 32767 to be used for subordinate channels.
2882 	 * Channel 0 is meant to be "native" mode and used only to represent
2883 	 * the main root device. We allow writing 0 to reset the device back
2884 	 * to normal mode after being used as a subordinate channel.
2885 	 */
2886 	if (channel > S16_MAX)
2887 		return -EINVAL;
2888 
2889 	dev->num_tc = -channel;
2890 
2891 	return 0;
2892 }
2893 EXPORT_SYMBOL(netdev_set_sb_channel);
2894 
2895 /*
2896  * Routine to help set real_num_tx_queues. To avoid skbs mapped to queues
2897  * greater than real_num_tx_queues stale skbs on the qdisc must be flushed.
2898  */
2899 int netif_set_real_num_tx_queues(struct net_device *dev, unsigned int txq)
2900 {
2901 	bool disabling;
2902 	int rc;
2903 
2904 	disabling = txq < dev->real_num_tx_queues;
2905 
2906 	if (txq < 1 || txq > dev->num_tx_queues)
2907 		return -EINVAL;
2908 
2909 	if (dev->reg_state == NETREG_REGISTERED ||
2910 	    dev->reg_state == NETREG_UNREGISTERING) {
2911 		ASSERT_RTNL();
2912 
2913 		rc = netdev_queue_update_kobjects(dev, dev->real_num_tx_queues,
2914 						  txq);
2915 		if (rc)
2916 			return rc;
2917 
2918 		if (dev->num_tc)
2919 			netif_setup_tc(dev, txq);
2920 
2921 		dev_qdisc_change_real_num_tx(dev, txq);
2922 
2923 		dev->real_num_tx_queues = txq;
2924 
2925 		if (disabling) {
2926 			synchronize_net();
2927 			qdisc_reset_all_tx_gt(dev, txq);
2928 #ifdef CONFIG_XPS
2929 			netif_reset_xps_queues_gt(dev, txq);
2930 #endif
2931 		}
2932 	} else {
2933 		dev->real_num_tx_queues = txq;
2934 	}
2935 
2936 	return 0;
2937 }
2938 EXPORT_SYMBOL(netif_set_real_num_tx_queues);
2939 
2940 #ifdef CONFIG_SYSFS
2941 /**
2942  *	netif_set_real_num_rx_queues - set actual number of RX queues used
2943  *	@dev: Network device
2944  *	@rxq: Actual number of RX queues
2945  *
2946  *	This must be called either with the rtnl_lock held or before
2947  *	registration of the net device.  Returns 0 on success, or a
2948  *	negative error code.  If called before registration, it always
2949  *	succeeds.
2950  */
2951 int netif_set_real_num_rx_queues(struct net_device *dev, unsigned int rxq)
2952 {
2953 	int rc;
2954 
2955 	if (rxq < 1 || rxq > dev->num_rx_queues)
2956 		return -EINVAL;
2957 
2958 	if (dev->reg_state == NETREG_REGISTERED) {
2959 		ASSERT_RTNL();
2960 
2961 		rc = net_rx_queue_update_kobjects(dev, dev->real_num_rx_queues,
2962 						  rxq);
2963 		if (rc)
2964 			return rc;
2965 	}
2966 
2967 	dev->real_num_rx_queues = rxq;
2968 	return 0;
2969 }
2970 EXPORT_SYMBOL(netif_set_real_num_rx_queues);
2971 #endif
2972 
2973 /**
2974  *	netif_set_real_num_queues - set actual number of RX and TX queues used
2975  *	@dev: Network device
2976  *	@txq: Actual number of TX queues
2977  *	@rxq: Actual number of RX queues
2978  *
2979  *	Set the real number of both TX and RX queues.
2980  *	Does nothing if the number of queues is already correct.
2981  */
2982 int netif_set_real_num_queues(struct net_device *dev,
2983 			      unsigned int txq, unsigned int rxq)
2984 {
2985 	unsigned int old_rxq = dev->real_num_rx_queues;
2986 	int err;
2987 
2988 	if (txq < 1 || txq > dev->num_tx_queues ||
2989 	    rxq < 1 || rxq > dev->num_rx_queues)
2990 		return -EINVAL;
2991 
2992 	/* Start from increases, so the error path only does decreases -
2993 	 * decreases can't fail.
2994 	 */
2995 	if (rxq > dev->real_num_rx_queues) {
2996 		err = netif_set_real_num_rx_queues(dev, rxq);
2997 		if (err)
2998 			return err;
2999 	}
3000 	if (txq > dev->real_num_tx_queues) {
3001 		err = netif_set_real_num_tx_queues(dev, txq);
3002 		if (err)
3003 			goto undo_rx;
3004 	}
3005 	if (rxq < dev->real_num_rx_queues)
3006 		WARN_ON(netif_set_real_num_rx_queues(dev, rxq));
3007 	if (txq < dev->real_num_tx_queues)
3008 		WARN_ON(netif_set_real_num_tx_queues(dev, txq));
3009 
3010 	return 0;
3011 undo_rx:
3012 	WARN_ON(netif_set_real_num_rx_queues(dev, old_rxq));
3013 	return err;
3014 }
3015 EXPORT_SYMBOL(netif_set_real_num_queues);
3016 
3017 /**
3018  * netif_set_tso_max_size() - set the max size of TSO frames supported
3019  * @dev:	netdev to update
3020  * @size:	max skb->len of a TSO frame
3021  *
3022  * Set the limit on the size of TSO super-frames the device can handle.
3023  * Unless explicitly set the stack will assume the value of
3024  * %GSO_LEGACY_MAX_SIZE.
3025  */
3026 void netif_set_tso_max_size(struct net_device *dev, unsigned int size)
3027 {
3028 	dev->tso_max_size = min(GSO_MAX_SIZE, size);
3029 	if (size < READ_ONCE(dev->gso_max_size))
3030 		netif_set_gso_max_size(dev, size);
3031 	if (size < READ_ONCE(dev->gso_ipv4_max_size))
3032 		netif_set_gso_ipv4_max_size(dev, size);
3033 }
3034 EXPORT_SYMBOL(netif_set_tso_max_size);
3035 
3036 /**
3037  * netif_set_tso_max_segs() - set the max number of segs supported for TSO
3038  * @dev:	netdev to update
3039  * @segs:	max number of TCP segments
3040  *
3041  * Set the limit on the number of TCP segments the device can generate from
3042  * a single TSO super-frame.
3043  * Unless explicitly set the stack will assume the value of %GSO_MAX_SEGS.
3044  */
3045 void netif_set_tso_max_segs(struct net_device *dev, unsigned int segs)
3046 {
3047 	dev->tso_max_segs = segs;
3048 	if (segs < READ_ONCE(dev->gso_max_segs))
3049 		netif_set_gso_max_segs(dev, segs);
3050 }
3051 EXPORT_SYMBOL(netif_set_tso_max_segs);
3052 
3053 /**
3054  * netif_inherit_tso_max() - copy all TSO limits from a lower device to an upper
3055  * @to:		netdev to update
3056  * @from:	netdev from which to copy the limits
3057  */
3058 void netif_inherit_tso_max(struct net_device *to, const struct net_device *from)
3059 {
3060 	netif_set_tso_max_size(to, from->tso_max_size);
3061 	netif_set_tso_max_segs(to, from->tso_max_segs);
3062 }
3063 EXPORT_SYMBOL(netif_inherit_tso_max);
3064 
3065 /**
3066  * netif_get_num_default_rss_queues - default number of RSS queues
3067  *
3068  * Default value is the number of physical cores if there are only 1 or 2, or
3069  * divided by 2 if there are more.
3070  */
3071 int netif_get_num_default_rss_queues(void)
3072 {
3073 	cpumask_var_t cpus;
3074 	int cpu, count = 0;
3075 
3076 	if (unlikely(is_kdump_kernel() || !zalloc_cpumask_var(&cpus, GFP_KERNEL)))
3077 		return 1;
3078 
3079 	cpumask_copy(cpus, cpu_online_mask);
3080 	for_each_cpu(cpu, cpus) {
3081 		++count;
3082 		cpumask_andnot(cpus, cpus, topology_sibling_cpumask(cpu));
3083 	}
3084 	free_cpumask_var(cpus);
3085 
3086 	return count > 2 ? DIV_ROUND_UP(count, 2) : count;
3087 }
3088 EXPORT_SYMBOL(netif_get_num_default_rss_queues);
3089 
3090 static void __netif_reschedule(struct Qdisc *q)
3091 {
3092 	struct softnet_data *sd;
3093 	unsigned long flags;
3094 
3095 	local_irq_save(flags);
3096 	sd = this_cpu_ptr(&softnet_data);
3097 	q->next_sched = NULL;
3098 	*sd->output_queue_tailp = q;
3099 	sd->output_queue_tailp = &q->next_sched;
3100 	raise_softirq_irqoff(NET_TX_SOFTIRQ);
3101 	local_irq_restore(flags);
3102 }
3103 
3104 void __netif_schedule(struct Qdisc *q)
3105 {
3106 	if (!test_and_set_bit(__QDISC_STATE_SCHED, &q->state))
3107 		__netif_reschedule(q);
3108 }
3109 EXPORT_SYMBOL(__netif_schedule);
3110 
3111 struct dev_kfree_skb_cb {
3112 	enum skb_drop_reason reason;
3113 };
3114 
3115 static struct dev_kfree_skb_cb *get_kfree_skb_cb(const struct sk_buff *skb)
3116 {
3117 	return (struct dev_kfree_skb_cb *)skb->cb;
3118 }
3119 
3120 void netif_schedule_queue(struct netdev_queue *txq)
3121 {
3122 	rcu_read_lock();
3123 	if (!netif_xmit_stopped(txq)) {
3124 		struct Qdisc *q = rcu_dereference(txq->qdisc);
3125 
3126 		__netif_schedule(q);
3127 	}
3128 	rcu_read_unlock();
3129 }
3130 EXPORT_SYMBOL(netif_schedule_queue);
3131 
3132 void netif_tx_wake_queue(struct netdev_queue *dev_queue)
3133 {
3134 	if (test_and_clear_bit(__QUEUE_STATE_DRV_XOFF, &dev_queue->state)) {
3135 		struct Qdisc *q;
3136 
3137 		rcu_read_lock();
3138 		q = rcu_dereference(dev_queue->qdisc);
3139 		__netif_schedule(q);
3140 		rcu_read_unlock();
3141 	}
3142 }
3143 EXPORT_SYMBOL(netif_tx_wake_queue);
3144 
3145 void dev_kfree_skb_irq_reason(struct sk_buff *skb, enum skb_drop_reason reason)
3146 {
3147 	unsigned long flags;
3148 
3149 	if (unlikely(!skb))
3150 		return;
3151 
3152 	if (likely(refcount_read(&skb->users) == 1)) {
3153 		smp_rmb();
3154 		refcount_set(&skb->users, 0);
3155 	} else if (likely(!refcount_dec_and_test(&skb->users))) {
3156 		return;
3157 	}
3158 	get_kfree_skb_cb(skb)->reason = reason;
3159 	local_irq_save(flags);
3160 	skb->next = __this_cpu_read(softnet_data.completion_queue);
3161 	__this_cpu_write(softnet_data.completion_queue, skb);
3162 	raise_softirq_irqoff(NET_TX_SOFTIRQ);
3163 	local_irq_restore(flags);
3164 }
3165 EXPORT_SYMBOL(dev_kfree_skb_irq_reason);
3166 
3167 void dev_kfree_skb_any_reason(struct sk_buff *skb, enum skb_drop_reason reason)
3168 {
3169 	if (in_hardirq() || irqs_disabled())
3170 		dev_kfree_skb_irq_reason(skb, reason);
3171 	else
3172 		kfree_skb_reason(skb, reason);
3173 }
3174 EXPORT_SYMBOL(dev_kfree_skb_any_reason);
3175 
3176 
3177 /**
3178  * netif_device_detach - mark device as removed
3179  * @dev: network device
3180  *
3181  * Mark device as removed from system and therefore no longer available.
3182  */
3183 void netif_device_detach(struct net_device *dev)
3184 {
3185 	if (test_and_clear_bit(__LINK_STATE_PRESENT, &dev->state) &&
3186 	    netif_running(dev)) {
3187 		netif_tx_stop_all_queues(dev);
3188 	}
3189 }
3190 EXPORT_SYMBOL(netif_device_detach);
3191 
3192 /**
3193  * netif_device_attach - mark device as attached
3194  * @dev: network device
3195  *
3196  * Mark device as attached from system and restart if needed.
3197  */
3198 void netif_device_attach(struct net_device *dev)
3199 {
3200 	if (!test_and_set_bit(__LINK_STATE_PRESENT, &dev->state) &&
3201 	    netif_running(dev)) {
3202 		netif_tx_wake_all_queues(dev);
3203 		__netdev_watchdog_up(dev);
3204 	}
3205 }
3206 EXPORT_SYMBOL(netif_device_attach);
3207 
3208 /*
3209  * Returns a Tx hash based on the given packet descriptor a Tx queues' number
3210  * to be used as a distribution range.
3211  */
3212 static u16 skb_tx_hash(const struct net_device *dev,
3213 		       const struct net_device *sb_dev,
3214 		       struct sk_buff *skb)
3215 {
3216 	u32 hash;
3217 	u16 qoffset = 0;
3218 	u16 qcount = dev->real_num_tx_queues;
3219 
3220 	if (dev->num_tc) {
3221 		u8 tc = netdev_get_prio_tc_map(dev, skb->priority);
3222 
3223 		qoffset = sb_dev->tc_to_txq[tc].offset;
3224 		qcount = sb_dev->tc_to_txq[tc].count;
3225 		if (unlikely(!qcount)) {
3226 			net_warn_ratelimited("%s: invalid qcount, qoffset %u for tc %u\n",
3227 					     sb_dev->name, qoffset, tc);
3228 			qoffset = 0;
3229 			qcount = dev->real_num_tx_queues;
3230 		}
3231 	}
3232 
3233 	if (skb_rx_queue_recorded(skb)) {
3234 		DEBUG_NET_WARN_ON_ONCE(qcount == 0);
3235 		hash = skb_get_rx_queue(skb);
3236 		if (hash >= qoffset)
3237 			hash -= qoffset;
3238 		while (unlikely(hash >= qcount))
3239 			hash -= qcount;
3240 		return hash + qoffset;
3241 	}
3242 
3243 	return (u16) reciprocal_scale(skb_get_hash(skb), qcount) + qoffset;
3244 }
3245 
3246 void skb_warn_bad_offload(const struct sk_buff *skb)
3247 {
3248 	static const netdev_features_t null_features;
3249 	struct net_device *dev = skb->dev;
3250 	const char *name = "";
3251 
3252 	if (!net_ratelimit())
3253 		return;
3254 
3255 	if (dev) {
3256 		if (dev->dev.parent)
3257 			name = dev_driver_string(dev->dev.parent);
3258 		else
3259 			name = netdev_name(dev);
3260 	}
3261 	skb_dump(KERN_WARNING, skb, false);
3262 	WARN(1, "%s: caps=(%pNF, %pNF)\n",
3263 	     name, dev ? &dev->features : &null_features,
3264 	     skb->sk ? &skb->sk->sk_route_caps : &null_features);
3265 }
3266 
3267 /*
3268  * Invalidate hardware checksum when packet is to be mangled, and
3269  * complete checksum manually on outgoing path.
3270  */
3271 int skb_checksum_help(struct sk_buff *skb)
3272 {
3273 	__wsum csum;
3274 	int ret = 0, offset;
3275 
3276 	if (skb->ip_summed == CHECKSUM_COMPLETE)
3277 		goto out_set_summed;
3278 
3279 	if (unlikely(skb_is_gso(skb))) {
3280 		skb_warn_bad_offload(skb);
3281 		return -EINVAL;
3282 	}
3283 
3284 	/* Before computing a checksum, we should make sure no frag could
3285 	 * be modified by an external entity : checksum could be wrong.
3286 	 */
3287 	if (skb_has_shared_frag(skb)) {
3288 		ret = __skb_linearize(skb);
3289 		if (ret)
3290 			goto out;
3291 	}
3292 
3293 	offset = skb_checksum_start_offset(skb);
3294 	ret = -EINVAL;
3295 	if (WARN_ON_ONCE(offset >= skb_headlen(skb))) {
3296 		DO_ONCE_LITE(skb_dump, KERN_ERR, skb, false);
3297 		goto out;
3298 	}
3299 	csum = skb_checksum(skb, offset, skb->len - offset, 0);
3300 
3301 	offset += skb->csum_offset;
3302 	if (WARN_ON_ONCE(offset + sizeof(__sum16) > skb_headlen(skb))) {
3303 		DO_ONCE_LITE(skb_dump, KERN_ERR, skb, false);
3304 		goto out;
3305 	}
3306 	ret = skb_ensure_writable(skb, offset + sizeof(__sum16));
3307 	if (ret)
3308 		goto out;
3309 
3310 	*(__sum16 *)(skb->data + offset) = csum_fold(csum) ?: CSUM_MANGLED_0;
3311 out_set_summed:
3312 	skb->ip_summed = CHECKSUM_NONE;
3313 out:
3314 	return ret;
3315 }
3316 EXPORT_SYMBOL(skb_checksum_help);
3317 
3318 int skb_crc32c_csum_help(struct sk_buff *skb)
3319 {
3320 	__le32 crc32c_csum;
3321 	int ret = 0, offset, start;
3322 
3323 	if (skb->ip_summed != CHECKSUM_PARTIAL)
3324 		goto out;
3325 
3326 	if (unlikely(skb_is_gso(skb)))
3327 		goto out;
3328 
3329 	/* Before computing a checksum, we should make sure no frag could
3330 	 * be modified by an external entity : checksum could be wrong.
3331 	 */
3332 	if (unlikely(skb_has_shared_frag(skb))) {
3333 		ret = __skb_linearize(skb);
3334 		if (ret)
3335 			goto out;
3336 	}
3337 	start = skb_checksum_start_offset(skb);
3338 	offset = start + offsetof(struct sctphdr, checksum);
3339 	if (WARN_ON_ONCE(offset >= skb_headlen(skb))) {
3340 		ret = -EINVAL;
3341 		goto out;
3342 	}
3343 
3344 	ret = skb_ensure_writable(skb, offset + sizeof(__le32));
3345 	if (ret)
3346 		goto out;
3347 
3348 	crc32c_csum = cpu_to_le32(~__skb_checksum(skb, start,
3349 						  skb->len - start, ~(__u32)0,
3350 						  crc32c_csum_stub));
3351 	*(__le32 *)(skb->data + offset) = crc32c_csum;
3352 	skb_reset_csum_not_inet(skb);
3353 out:
3354 	return ret;
3355 }
3356 
3357 __be16 skb_network_protocol(struct sk_buff *skb, int *depth)
3358 {
3359 	__be16 type = skb->protocol;
3360 
3361 	/* Tunnel gso handlers can set protocol to ethernet. */
3362 	if (type == htons(ETH_P_TEB)) {
3363 		struct ethhdr *eth;
3364 
3365 		if (unlikely(!pskb_may_pull(skb, sizeof(struct ethhdr))))
3366 			return 0;
3367 
3368 		eth = (struct ethhdr *)skb->data;
3369 		type = eth->h_proto;
3370 	}
3371 
3372 	return vlan_get_protocol_and_depth(skb, type, depth);
3373 }
3374 
3375 
3376 /* Take action when hardware reception checksum errors are detected. */
3377 #ifdef CONFIG_BUG
3378 static void do_netdev_rx_csum_fault(struct net_device *dev, struct sk_buff *skb)
3379 {
3380 	netdev_err(dev, "hw csum failure\n");
3381 	skb_dump(KERN_ERR, skb, true);
3382 	dump_stack();
3383 }
3384 
3385 void netdev_rx_csum_fault(struct net_device *dev, struct sk_buff *skb)
3386 {
3387 	DO_ONCE_LITE(do_netdev_rx_csum_fault, dev, skb);
3388 }
3389 EXPORT_SYMBOL(netdev_rx_csum_fault);
3390 #endif
3391 
3392 /* XXX: check that highmem exists at all on the given machine. */
3393 static int illegal_highdma(struct net_device *dev, struct sk_buff *skb)
3394 {
3395 #ifdef CONFIG_HIGHMEM
3396 	int i;
3397 
3398 	if (!(dev->features & NETIF_F_HIGHDMA)) {
3399 		for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
3400 			skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
3401 
3402 			if (PageHighMem(skb_frag_page(frag)))
3403 				return 1;
3404 		}
3405 	}
3406 #endif
3407 	return 0;
3408 }
3409 
3410 /* If MPLS offload request, verify we are testing hardware MPLS features
3411  * instead of standard features for the netdev.
3412  */
3413 #if IS_ENABLED(CONFIG_NET_MPLS_GSO)
3414 static netdev_features_t net_mpls_features(struct sk_buff *skb,
3415 					   netdev_features_t features,
3416 					   __be16 type)
3417 {
3418 	if (eth_p_mpls(type))
3419 		features &= skb->dev->mpls_features;
3420 
3421 	return features;
3422 }
3423 #else
3424 static netdev_features_t net_mpls_features(struct sk_buff *skb,
3425 					   netdev_features_t features,
3426 					   __be16 type)
3427 {
3428 	return features;
3429 }
3430 #endif
3431 
3432 static netdev_features_t harmonize_features(struct sk_buff *skb,
3433 	netdev_features_t features)
3434 {
3435 	__be16 type;
3436 
3437 	type = skb_network_protocol(skb, NULL);
3438 	features = net_mpls_features(skb, features, type);
3439 
3440 	if (skb->ip_summed != CHECKSUM_NONE &&
3441 	    !can_checksum_protocol(features, type)) {
3442 		features &= ~(NETIF_F_CSUM_MASK | NETIF_F_GSO_MASK);
3443 	}
3444 	if (illegal_highdma(skb->dev, skb))
3445 		features &= ~NETIF_F_SG;
3446 
3447 	return features;
3448 }
3449 
3450 netdev_features_t passthru_features_check(struct sk_buff *skb,
3451 					  struct net_device *dev,
3452 					  netdev_features_t features)
3453 {
3454 	return features;
3455 }
3456 EXPORT_SYMBOL(passthru_features_check);
3457 
3458 static netdev_features_t dflt_features_check(struct sk_buff *skb,
3459 					     struct net_device *dev,
3460 					     netdev_features_t features)
3461 {
3462 	return vlan_features_check(skb, features);
3463 }
3464 
3465 static netdev_features_t gso_features_check(const struct sk_buff *skb,
3466 					    struct net_device *dev,
3467 					    netdev_features_t features)
3468 {
3469 	u16 gso_segs = skb_shinfo(skb)->gso_segs;
3470 
3471 	if (gso_segs > READ_ONCE(dev->gso_max_segs))
3472 		return features & ~NETIF_F_GSO_MASK;
3473 
3474 	if (!skb_shinfo(skb)->gso_type) {
3475 		skb_warn_bad_offload(skb);
3476 		return features & ~NETIF_F_GSO_MASK;
3477 	}
3478 
3479 	/* Support for GSO partial features requires software
3480 	 * intervention before we can actually process the packets
3481 	 * so we need to strip support for any partial features now
3482 	 * and we can pull them back in after we have partially
3483 	 * segmented the frame.
3484 	 */
3485 	if (!(skb_shinfo(skb)->gso_type & SKB_GSO_PARTIAL))
3486 		features &= ~dev->gso_partial_features;
3487 
3488 	/* Make sure to clear the IPv4 ID mangling feature if the
3489 	 * IPv4 header has the potential to be fragmented.
3490 	 */
3491 	if (skb_shinfo(skb)->gso_type & SKB_GSO_TCPV4) {
3492 		struct iphdr *iph = skb->encapsulation ?
3493 				    inner_ip_hdr(skb) : ip_hdr(skb);
3494 
3495 		if (!(iph->frag_off & htons(IP_DF)))
3496 			features &= ~NETIF_F_TSO_MANGLEID;
3497 	}
3498 
3499 	return features;
3500 }
3501 
3502 netdev_features_t netif_skb_features(struct sk_buff *skb)
3503 {
3504 	struct net_device *dev = skb->dev;
3505 	netdev_features_t features = dev->features;
3506 
3507 	if (skb_is_gso(skb))
3508 		features = gso_features_check(skb, dev, features);
3509 
3510 	/* If encapsulation offload request, verify we are testing
3511 	 * hardware encapsulation features instead of standard
3512 	 * features for the netdev
3513 	 */
3514 	if (skb->encapsulation)
3515 		features &= dev->hw_enc_features;
3516 
3517 	if (skb_vlan_tagged(skb))
3518 		features = netdev_intersect_features(features,
3519 						     dev->vlan_features |
3520 						     NETIF_F_HW_VLAN_CTAG_TX |
3521 						     NETIF_F_HW_VLAN_STAG_TX);
3522 
3523 	if (dev->netdev_ops->ndo_features_check)
3524 		features &= dev->netdev_ops->ndo_features_check(skb, dev,
3525 								features);
3526 	else
3527 		features &= dflt_features_check(skb, dev, features);
3528 
3529 	return harmonize_features(skb, features);
3530 }
3531 EXPORT_SYMBOL(netif_skb_features);
3532 
3533 static int xmit_one(struct sk_buff *skb, struct net_device *dev,
3534 		    struct netdev_queue *txq, bool more)
3535 {
3536 	unsigned int len;
3537 	int rc;
3538 
3539 	if (dev_nit_active(dev))
3540 		dev_queue_xmit_nit(skb, dev);
3541 
3542 	len = skb->len;
3543 	trace_net_dev_start_xmit(skb, dev);
3544 	rc = netdev_start_xmit(skb, dev, txq, more);
3545 	trace_net_dev_xmit(skb, rc, dev, len);
3546 
3547 	return rc;
3548 }
3549 
3550 struct sk_buff *dev_hard_start_xmit(struct sk_buff *first, struct net_device *dev,
3551 				    struct netdev_queue *txq, int *ret)
3552 {
3553 	struct sk_buff *skb = first;
3554 	int rc = NETDEV_TX_OK;
3555 
3556 	while (skb) {
3557 		struct sk_buff *next = skb->next;
3558 
3559 		skb_mark_not_on_list(skb);
3560 		rc = xmit_one(skb, dev, txq, next != NULL);
3561 		if (unlikely(!dev_xmit_complete(rc))) {
3562 			skb->next = next;
3563 			goto out;
3564 		}
3565 
3566 		skb = next;
3567 		if (netif_tx_queue_stopped(txq) && skb) {
3568 			rc = NETDEV_TX_BUSY;
3569 			break;
3570 		}
3571 	}
3572 
3573 out:
3574 	*ret = rc;
3575 	return skb;
3576 }
3577 
3578 static struct sk_buff *validate_xmit_vlan(struct sk_buff *skb,
3579 					  netdev_features_t features)
3580 {
3581 	if (skb_vlan_tag_present(skb) &&
3582 	    !vlan_hw_offload_capable(features, skb->vlan_proto))
3583 		skb = __vlan_hwaccel_push_inside(skb);
3584 	return skb;
3585 }
3586 
3587 int skb_csum_hwoffload_help(struct sk_buff *skb,
3588 			    const netdev_features_t features)
3589 {
3590 	if (unlikely(skb_csum_is_sctp(skb)))
3591 		return !!(features & NETIF_F_SCTP_CRC) ? 0 :
3592 			skb_crc32c_csum_help(skb);
3593 
3594 	if (features & NETIF_F_HW_CSUM)
3595 		return 0;
3596 
3597 	if (features & (NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM)) {
3598 		switch (skb->csum_offset) {
3599 		case offsetof(struct tcphdr, check):
3600 		case offsetof(struct udphdr, check):
3601 			return 0;
3602 		}
3603 	}
3604 
3605 	return skb_checksum_help(skb);
3606 }
3607 EXPORT_SYMBOL(skb_csum_hwoffload_help);
3608 
3609 static struct sk_buff *validate_xmit_skb(struct sk_buff *skb, struct net_device *dev, bool *again)
3610 {
3611 	netdev_features_t features;
3612 
3613 	features = netif_skb_features(skb);
3614 	skb = validate_xmit_vlan(skb, features);
3615 	if (unlikely(!skb))
3616 		goto out_null;
3617 
3618 	skb = sk_validate_xmit_skb(skb, dev);
3619 	if (unlikely(!skb))
3620 		goto out_null;
3621 
3622 	if (netif_needs_gso(skb, features)) {
3623 		struct sk_buff *segs;
3624 
3625 		segs = skb_gso_segment(skb, features);
3626 		if (IS_ERR(segs)) {
3627 			goto out_kfree_skb;
3628 		} else if (segs) {
3629 			consume_skb(skb);
3630 			skb = segs;
3631 		}
3632 	} else {
3633 		if (skb_needs_linearize(skb, features) &&
3634 		    __skb_linearize(skb))
3635 			goto out_kfree_skb;
3636 
3637 		/* If packet is not checksummed and device does not
3638 		 * support checksumming for this protocol, complete
3639 		 * checksumming here.
3640 		 */
3641 		if (skb->ip_summed == CHECKSUM_PARTIAL) {
3642 			if (skb->encapsulation)
3643 				skb_set_inner_transport_header(skb,
3644 							       skb_checksum_start_offset(skb));
3645 			else
3646 				skb_set_transport_header(skb,
3647 							 skb_checksum_start_offset(skb));
3648 			if (skb_csum_hwoffload_help(skb, features))
3649 				goto out_kfree_skb;
3650 		}
3651 	}
3652 
3653 	skb = validate_xmit_xfrm(skb, features, again);
3654 
3655 	return skb;
3656 
3657 out_kfree_skb:
3658 	kfree_skb(skb);
3659 out_null:
3660 	dev_core_stats_tx_dropped_inc(dev);
3661 	return NULL;
3662 }
3663 
3664 struct sk_buff *validate_xmit_skb_list(struct sk_buff *skb, struct net_device *dev, bool *again)
3665 {
3666 	struct sk_buff *next, *head = NULL, *tail;
3667 
3668 	for (; skb != NULL; skb = next) {
3669 		next = skb->next;
3670 		skb_mark_not_on_list(skb);
3671 
3672 		/* in case skb wont be segmented, point to itself */
3673 		skb->prev = skb;
3674 
3675 		skb = validate_xmit_skb(skb, dev, again);
3676 		if (!skb)
3677 			continue;
3678 
3679 		if (!head)
3680 			head = skb;
3681 		else
3682 			tail->next = skb;
3683 		/* If skb was segmented, skb->prev points to
3684 		 * the last segment. If not, it still contains skb.
3685 		 */
3686 		tail = skb->prev;
3687 	}
3688 	return head;
3689 }
3690 EXPORT_SYMBOL_GPL(validate_xmit_skb_list);
3691 
3692 static void qdisc_pkt_len_init(struct sk_buff *skb)
3693 {
3694 	const struct skb_shared_info *shinfo = skb_shinfo(skb);
3695 
3696 	qdisc_skb_cb(skb)->pkt_len = skb->len;
3697 
3698 	/* To get more precise estimation of bytes sent on wire,
3699 	 * we add to pkt_len the headers size of all segments
3700 	 */
3701 	if (shinfo->gso_size && skb_transport_header_was_set(skb)) {
3702 		u16 gso_segs = shinfo->gso_segs;
3703 		unsigned int hdr_len;
3704 
3705 		/* mac layer + network layer */
3706 		hdr_len = skb_transport_offset(skb);
3707 
3708 		/* + transport layer */
3709 		if (likely(shinfo->gso_type & (SKB_GSO_TCPV4 | SKB_GSO_TCPV6))) {
3710 			const struct tcphdr *th;
3711 			struct tcphdr _tcphdr;
3712 
3713 			th = skb_header_pointer(skb, hdr_len,
3714 						sizeof(_tcphdr), &_tcphdr);
3715 			if (likely(th))
3716 				hdr_len += __tcp_hdrlen(th);
3717 		} else {
3718 			struct udphdr _udphdr;
3719 
3720 			if (skb_header_pointer(skb, hdr_len,
3721 					       sizeof(_udphdr), &_udphdr))
3722 				hdr_len += sizeof(struct udphdr);
3723 		}
3724 
3725 		if (shinfo->gso_type & SKB_GSO_DODGY)
3726 			gso_segs = DIV_ROUND_UP(skb->len - hdr_len,
3727 						shinfo->gso_size);
3728 
3729 		qdisc_skb_cb(skb)->pkt_len += (gso_segs - 1) * hdr_len;
3730 	}
3731 }
3732 
3733 static int dev_qdisc_enqueue(struct sk_buff *skb, struct Qdisc *q,
3734 			     struct sk_buff **to_free,
3735 			     struct netdev_queue *txq)
3736 {
3737 	int rc;
3738 
3739 	rc = q->enqueue(skb, q, to_free) & NET_XMIT_MASK;
3740 	if (rc == NET_XMIT_SUCCESS)
3741 		trace_qdisc_enqueue(q, txq, skb);
3742 	return rc;
3743 }
3744 
3745 static inline int __dev_xmit_skb(struct sk_buff *skb, struct Qdisc *q,
3746 				 struct net_device *dev,
3747 				 struct netdev_queue *txq)
3748 {
3749 	spinlock_t *root_lock = qdisc_lock(q);
3750 	struct sk_buff *to_free = NULL;
3751 	bool contended;
3752 	int rc;
3753 
3754 	qdisc_calculate_pkt_len(skb, q);
3755 
3756 	if (q->flags & TCQ_F_NOLOCK) {
3757 		if (q->flags & TCQ_F_CAN_BYPASS && nolock_qdisc_is_empty(q) &&
3758 		    qdisc_run_begin(q)) {
3759 			/* Retest nolock_qdisc_is_empty() within the protection
3760 			 * of q->seqlock to protect from racing with requeuing.
3761 			 */
3762 			if (unlikely(!nolock_qdisc_is_empty(q))) {
3763 				rc = dev_qdisc_enqueue(skb, q, &to_free, txq);
3764 				__qdisc_run(q);
3765 				qdisc_run_end(q);
3766 
3767 				goto no_lock_out;
3768 			}
3769 
3770 			qdisc_bstats_cpu_update(q, skb);
3771 			if (sch_direct_xmit(skb, q, dev, txq, NULL, true) &&
3772 			    !nolock_qdisc_is_empty(q))
3773 				__qdisc_run(q);
3774 
3775 			qdisc_run_end(q);
3776 			return NET_XMIT_SUCCESS;
3777 		}
3778 
3779 		rc = dev_qdisc_enqueue(skb, q, &to_free, txq);
3780 		qdisc_run(q);
3781 
3782 no_lock_out:
3783 		if (unlikely(to_free))
3784 			kfree_skb_list_reason(to_free,
3785 					      SKB_DROP_REASON_QDISC_DROP);
3786 		return rc;
3787 	}
3788 
3789 	/*
3790 	 * Heuristic to force contended enqueues to serialize on a
3791 	 * separate lock before trying to get qdisc main lock.
3792 	 * This permits qdisc->running owner to get the lock more
3793 	 * often and dequeue packets faster.
3794 	 * On PREEMPT_RT it is possible to preempt the qdisc owner during xmit
3795 	 * and then other tasks will only enqueue packets. The packets will be
3796 	 * sent after the qdisc owner is scheduled again. To prevent this
3797 	 * scenario the task always serialize on the lock.
3798 	 */
3799 	contended = qdisc_is_running(q) || IS_ENABLED(CONFIG_PREEMPT_RT);
3800 	if (unlikely(contended))
3801 		spin_lock(&q->busylock);
3802 
3803 	spin_lock(root_lock);
3804 	if (unlikely(test_bit(__QDISC_STATE_DEACTIVATED, &q->state))) {
3805 		__qdisc_drop(skb, &to_free);
3806 		rc = NET_XMIT_DROP;
3807 	} else if ((q->flags & TCQ_F_CAN_BYPASS) && !qdisc_qlen(q) &&
3808 		   qdisc_run_begin(q)) {
3809 		/*
3810 		 * This is a work-conserving queue; there are no old skbs
3811 		 * waiting to be sent out; and the qdisc is not running -
3812 		 * xmit the skb directly.
3813 		 */
3814 
3815 		qdisc_bstats_update(q, skb);
3816 
3817 		if (sch_direct_xmit(skb, q, dev, txq, root_lock, true)) {
3818 			if (unlikely(contended)) {
3819 				spin_unlock(&q->busylock);
3820 				contended = false;
3821 			}
3822 			__qdisc_run(q);
3823 		}
3824 
3825 		qdisc_run_end(q);
3826 		rc = NET_XMIT_SUCCESS;
3827 	} else {
3828 		rc = dev_qdisc_enqueue(skb, q, &to_free, txq);
3829 		if (qdisc_run_begin(q)) {
3830 			if (unlikely(contended)) {
3831 				spin_unlock(&q->busylock);
3832 				contended = false;
3833 			}
3834 			__qdisc_run(q);
3835 			qdisc_run_end(q);
3836 		}
3837 	}
3838 	spin_unlock(root_lock);
3839 	if (unlikely(to_free))
3840 		kfree_skb_list_reason(to_free, SKB_DROP_REASON_QDISC_DROP);
3841 	if (unlikely(contended))
3842 		spin_unlock(&q->busylock);
3843 	return rc;
3844 }
3845 
3846 #if IS_ENABLED(CONFIG_CGROUP_NET_PRIO)
3847 static void skb_update_prio(struct sk_buff *skb)
3848 {
3849 	const struct netprio_map *map;
3850 	const struct sock *sk;
3851 	unsigned int prioidx;
3852 
3853 	if (skb->priority)
3854 		return;
3855 	map = rcu_dereference_bh(skb->dev->priomap);
3856 	if (!map)
3857 		return;
3858 	sk = skb_to_full_sk(skb);
3859 	if (!sk)
3860 		return;
3861 
3862 	prioidx = sock_cgroup_prioidx(&sk->sk_cgrp_data);
3863 
3864 	if (prioidx < map->priomap_len)
3865 		skb->priority = map->priomap[prioidx];
3866 }
3867 #else
3868 #define skb_update_prio(skb)
3869 #endif
3870 
3871 /**
3872  *	dev_loopback_xmit - loop back @skb
3873  *	@net: network namespace this loopback is happening in
3874  *	@sk:  sk needed to be a netfilter okfn
3875  *	@skb: buffer to transmit
3876  */
3877 int dev_loopback_xmit(struct net *net, struct sock *sk, struct sk_buff *skb)
3878 {
3879 	skb_reset_mac_header(skb);
3880 	__skb_pull(skb, skb_network_offset(skb));
3881 	skb->pkt_type = PACKET_LOOPBACK;
3882 	if (skb->ip_summed == CHECKSUM_NONE)
3883 		skb->ip_summed = CHECKSUM_UNNECESSARY;
3884 	DEBUG_NET_WARN_ON_ONCE(!skb_dst(skb));
3885 	skb_dst_force(skb);
3886 	netif_rx(skb);
3887 	return 0;
3888 }
3889 EXPORT_SYMBOL(dev_loopback_xmit);
3890 
3891 #ifdef CONFIG_NET_EGRESS
3892 static struct netdev_queue *
3893 netdev_tx_queue_mapping(struct net_device *dev, struct sk_buff *skb)
3894 {
3895 	int qm = skb_get_queue_mapping(skb);
3896 
3897 	return netdev_get_tx_queue(dev, netdev_cap_txqueue(dev, qm));
3898 }
3899 
3900 static bool netdev_xmit_txqueue_skipped(void)
3901 {
3902 	return __this_cpu_read(softnet_data.xmit.skip_txqueue);
3903 }
3904 
3905 void netdev_xmit_skip_txqueue(bool skip)
3906 {
3907 	__this_cpu_write(softnet_data.xmit.skip_txqueue, skip);
3908 }
3909 EXPORT_SYMBOL_GPL(netdev_xmit_skip_txqueue);
3910 #endif /* CONFIG_NET_EGRESS */
3911 
3912 #ifdef CONFIG_NET_XGRESS
3913 static int tc_run(struct tcx_entry *entry, struct sk_buff *skb)
3914 {
3915 	int ret = TC_ACT_UNSPEC;
3916 #ifdef CONFIG_NET_CLS_ACT
3917 	struct mini_Qdisc *miniq = rcu_dereference_bh(entry->miniq);
3918 	struct tcf_result res;
3919 
3920 	if (!miniq)
3921 		return ret;
3922 
3923 	tc_skb_cb(skb)->mru = 0;
3924 	tc_skb_cb(skb)->post_ct = false;
3925 
3926 	mini_qdisc_bstats_cpu_update(miniq, skb);
3927 	ret = tcf_classify(skb, miniq->block, miniq->filter_list, &res, false);
3928 	/* Only tcf related quirks below. */
3929 	switch (ret) {
3930 	case TC_ACT_SHOT:
3931 		mini_qdisc_qstats_cpu_drop(miniq);
3932 		break;
3933 	case TC_ACT_OK:
3934 	case TC_ACT_RECLASSIFY:
3935 		skb->tc_index = TC_H_MIN(res.classid);
3936 		break;
3937 	}
3938 #endif /* CONFIG_NET_CLS_ACT */
3939 	return ret;
3940 }
3941 
3942 static DEFINE_STATIC_KEY_FALSE(tcx_needed_key);
3943 
3944 void tcx_inc(void)
3945 {
3946 	static_branch_inc(&tcx_needed_key);
3947 }
3948 
3949 void tcx_dec(void)
3950 {
3951 	static_branch_dec(&tcx_needed_key);
3952 }
3953 
3954 static __always_inline enum tcx_action_base
3955 tcx_run(const struct bpf_mprog_entry *entry, struct sk_buff *skb,
3956 	const bool needs_mac)
3957 {
3958 	const struct bpf_mprog_fp *fp;
3959 	const struct bpf_prog *prog;
3960 	int ret = TCX_NEXT;
3961 
3962 	if (needs_mac)
3963 		__skb_push(skb, skb->mac_len);
3964 	bpf_mprog_foreach_prog(entry, fp, prog) {
3965 		bpf_compute_data_pointers(skb);
3966 		ret = bpf_prog_run(prog, skb);
3967 		if (ret != TCX_NEXT)
3968 			break;
3969 	}
3970 	if (needs_mac)
3971 		__skb_pull(skb, skb->mac_len);
3972 	return tcx_action_code(skb, ret);
3973 }
3974 
3975 static __always_inline struct sk_buff *
3976 sch_handle_ingress(struct sk_buff *skb, struct packet_type **pt_prev, int *ret,
3977 		   struct net_device *orig_dev, bool *another)
3978 {
3979 	struct bpf_mprog_entry *entry = rcu_dereference_bh(skb->dev->tcx_ingress);
3980 	int sch_ret;
3981 
3982 	if (!entry)
3983 		return skb;
3984 	if (*pt_prev) {
3985 		*ret = deliver_skb(skb, *pt_prev, orig_dev);
3986 		*pt_prev = NULL;
3987 	}
3988 
3989 	qdisc_skb_cb(skb)->pkt_len = skb->len;
3990 	tcx_set_ingress(skb, true);
3991 
3992 	if (static_branch_unlikely(&tcx_needed_key)) {
3993 		sch_ret = tcx_run(entry, skb, true);
3994 		if (sch_ret != TC_ACT_UNSPEC)
3995 			goto ingress_verdict;
3996 	}
3997 	sch_ret = tc_run(tcx_entry(entry), skb);
3998 ingress_verdict:
3999 	switch (sch_ret) {
4000 	case TC_ACT_REDIRECT:
4001 		/* skb_mac_header check was done by BPF, so we can safely
4002 		 * push the L2 header back before redirecting to another
4003 		 * netdev.
4004 		 */
4005 		__skb_push(skb, skb->mac_len);
4006 		if (skb_do_redirect(skb) == -EAGAIN) {
4007 			__skb_pull(skb, skb->mac_len);
4008 			*another = true;
4009 			break;
4010 		}
4011 		*ret = NET_RX_SUCCESS;
4012 		return NULL;
4013 	case TC_ACT_SHOT:
4014 		kfree_skb_reason(skb, SKB_DROP_REASON_TC_INGRESS);
4015 		*ret = NET_RX_DROP;
4016 		return NULL;
4017 	/* used by tc_run */
4018 	case TC_ACT_STOLEN:
4019 	case TC_ACT_QUEUED:
4020 	case TC_ACT_TRAP:
4021 		consume_skb(skb);
4022 		fallthrough;
4023 	case TC_ACT_CONSUMED:
4024 		*ret = NET_RX_SUCCESS;
4025 		return NULL;
4026 	}
4027 
4028 	return skb;
4029 }
4030 
4031 static __always_inline struct sk_buff *
4032 sch_handle_egress(struct sk_buff *skb, int *ret, struct net_device *dev)
4033 {
4034 	struct bpf_mprog_entry *entry = rcu_dereference_bh(dev->tcx_egress);
4035 	int sch_ret;
4036 
4037 	if (!entry)
4038 		return skb;
4039 
4040 	/* qdisc_skb_cb(skb)->pkt_len & tcx_set_ingress() was
4041 	 * already set by the caller.
4042 	 */
4043 	if (static_branch_unlikely(&tcx_needed_key)) {
4044 		sch_ret = tcx_run(entry, skb, false);
4045 		if (sch_ret != TC_ACT_UNSPEC)
4046 			goto egress_verdict;
4047 	}
4048 	sch_ret = tc_run(tcx_entry(entry), skb);
4049 egress_verdict:
4050 	switch (sch_ret) {
4051 	case TC_ACT_REDIRECT:
4052 		/* No need to push/pop skb's mac_header here on egress! */
4053 		skb_do_redirect(skb);
4054 		*ret = NET_XMIT_SUCCESS;
4055 		return NULL;
4056 	case TC_ACT_SHOT:
4057 		kfree_skb_reason(skb, SKB_DROP_REASON_TC_EGRESS);
4058 		*ret = NET_XMIT_DROP;
4059 		return NULL;
4060 	/* used by tc_run */
4061 	case TC_ACT_STOLEN:
4062 	case TC_ACT_QUEUED:
4063 	case TC_ACT_TRAP:
4064 		consume_skb(skb);
4065 		fallthrough;
4066 	case TC_ACT_CONSUMED:
4067 		*ret = NET_XMIT_SUCCESS;
4068 		return NULL;
4069 	}
4070 
4071 	return skb;
4072 }
4073 #else
4074 static __always_inline struct sk_buff *
4075 sch_handle_ingress(struct sk_buff *skb, struct packet_type **pt_prev, int *ret,
4076 		   struct net_device *orig_dev, bool *another)
4077 {
4078 	return skb;
4079 }
4080 
4081 static __always_inline struct sk_buff *
4082 sch_handle_egress(struct sk_buff *skb, int *ret, struct net_device *dev)
4083 {
4084 	return skb;
4085 }
4086 #endif /* CONFIG_NET_XGRESS */
4087 
4088 #ifdef CONFIG_XPS
4089 static int __get_xps_queue_idx(struct net_device *dev, struct sk_buff *skb,
4090 			       struct xps_dev_maps *dev_maps, unsigned int tci)
4091 {
4092 	int tc = netdev_get_prio_tc_map(dev, skb->priority);
4093 	struct xps_map *map;
4094 	int queue_index = -1;
4095 
4096 	if (tc >= dev_maps->num_tc || tci >= dev_maps->nr_ids)
4097 		return queue_index;
4098 
4099 	tci *= dev_maps->num_tc;
4100 	tci += tc;
4101 
4102 	map = rcu_dereference(dev_maps->attr_map[tci]);
4103 	if (map) {
4104 		if (map->len == 1)
4105 			queue_index = map->queues[0];
4106 		else
4107 			queue_index = map->queues[reciprocal_scale(
4108 						skb_get_hash(skb), map->len)];
4109 		if (unlikely(queue_index >= dev->real_num_tx_queues))
4110 			queue_index = -1;
4111 	}
4112 	return queue_index;
4113 }
4114 #endif
4115 
4116 static int get_xps_queue(struct net_device *dev, struct net_device *sb_dev,
4117 			 struct sk_buff *skb)
4118 {
4119 #ifdef CONFIG_XPS
4120 	struct xps_dev_maps *dev_maps;
4121 	struct sock *sk = skb->sk;
4122 	int queue_index = -1;
4123 
4124 	if (!static_key_false(&xps_needed))
4125 		return -1;
4126 
4127 	rcu_read_lock();
4128 	if (!static_key_false(&xps_rxqs_needed))
4129 		goto get_cpus_map;
4130 
4131 	dev_maps = rcu_dereference(sb_dev->xps_maps[XPS_RXQS]);
4132 	if (dev_maps) {
4133 		int tci = sk_rx_queue_get(sk);
4134 
4135 		if (tci >= 0)
4136 			queue_index = __get_xps_queue_idx(dev, skb, dev_maps,
4137 							  tci);
4138 	}
4139 
4140 get_cpus_map:
4141 	if (queue_index < 0) {
4142 		dev_maps = rcu_dereference(sb_dev->xps_maps[XPS_CPUS]);
4143 		if (dev_maps) {
4144 			unsigned int tci = skb->sender_cpu - 1;
4145 
4146 			queue_index = __get_xps_queue_idx(dev, skb, dev_maps,
4147 							  tci);
4148 		}
4149 	}
4150 	rcu_read_unlock();
4151 
4152 	return queue_index;
4153 #else
4154 	return -1;
4155 #endif
4156 }
4157 
4158 u16 dev_pick_tx_zero(struct net_device *dev, struct sk_buff *skb,
4159 		     struct net_device *sb_dev)
4160 {
4161 	return 0;
4162 }
4163 EXPORT_SYMBOL(dev_pick_tx_zero);
4164 
4165 u16 dev_pick_tx_cpu_id(struct net_device *dev, struct sk_buff *skb,
4166 		       struct net_device *sb_dev)
4167 {
4168 	return (u16)raw_smp_processor_id() % dev->real_num_tx_queues;
4169 }
4170 EXPORT_SYMBOL(dev_pick_tx_cpu_id);
4171 
4172 u16 netdev_pick_tx(struct net_device *dev, struct sk_buff *skb,
4173 		     struct net_device *sb_dev)
4174 {
4175 	struct sock *sk = skb->sk;
4176 	int queue_index = sk_tx_queue_get(sk);
4177 
4178 	sb_dev = sb_dev ? : dev;
4179 
4180 	if (queue_index < 0 || skb->ooo_okay ||
4181 	    queue_index >= dev->real_num_tx_queues) {
4182 		int new_index = get_xps_queue(dev, sb_dev, skb);
4183 
4184 		if (new_index < 0)
4185 			new_index = skb_tx_hash(dev, sb_dev, skb);
4186 
4187 		if (queue_index != new_index && sk &&
4188 		    sk_fullsock(sk) &&
4189 		    rcu_access_pointer(sk->sk_dst_cache))
4190 			sk_tx_queue_set(sk, new_index);
4191 
4192 		queue_index = new_index;
4193 	}
4194 
4195 	return queue_index;
4196 }
4197 EXPORT_SYMBOL(netdev_pick_tx);
4198 
4199 struct netdev_queue *netdev_core_pick_tx(struct net_device *dev,
4200 					 struct sk_buff *skb,
4201 					 struct net_device *sb_dev)
4202 {
4203 	int queue_index = 0;
4204 
4205 #ifdef CONFIG_XPS
4206 	u32 sender_cpu = skb->sender_cpu - 1;
4207 
4208 	if (sender_cpu >= (u32)NR_CPUS)
4209 		skb->sender_cpu = raw_smp_processor_id() + 1;
4210 #endif
4211 
4212 	if (dev->real_num_tx_queues != 1) {
4213 		const struct net_device_ops *ops = dev->netdev_ops;
4214 
4215 		if (ops->ndo_select_queue)
4216 			queue_index = ops->ndo_select_queue(dev, skb, sb_dev);
4217 		else
4218 			queue_index = netdev_pick_tx(dev, skb, sb_dev);
4219 
4220 		queue_index = netdev_cap_txqueue(dev, queue_index);
4221 	}
4222 
4223 	skb_set_queue_mapping(skb, queue_index);
4224 	return netdev_get_tx_queue(dev, queue_index);
4225 }
4226 
4227 /**
4228  * __dev_queue_xmit() - transmit a buffer
4229  * @skb:	buffer to transmit
4230  * @sb_dev:	suboordinate device used for L2 forwarding offload
4231  *
4232  * Queue a buffer for transmission to a network device. The caller must
4233  * have set the device and priority and built the buffer before calling
4234  * this function. The function can be called from an interrupt.
4235  *
4236  * When calling this method, interrupts MUST be enabled. This is because
4237  * the BH enable code must have IRQs enabled so that it will not deadlock.
4238  *
4239  * Regardless of the return value, the skb is consumed, so it is currently
4240  * difficult to retry a send to this method. (You can bump the ref count
4241  * before sending to hold a reference for retry if you are careful.)
4242  *
4243  * Return:
4244  * * 0				- buffer successfully transmitted
4245  * * positive qdisc return code	- NET_XMIT_DROP etc.
4246  * * negative errno		- other errors
4247  */
4248 int __dev_queue_xmit(struct sk_buff *skb, struct net_device *sb_dev)
4249 {
4250 	struct net_device *dev = skb->dev;
4251 	struct netdev_queue *txq = NULL;
4252 	struct Qdisc *q;
4253 	int rc = -ENOMEM;
4254 	bool again = false;
4255 
4256 	skb_reset_mac_header(skb);
4257 	skb_assert_len(skb);
4258 
4259 	if (unlikely(skb_shinfo(skb)->tx_flags & SKBTX_SCHED_TSTAMP))
4260 		__skb_tstamp_tx(skb, NULL, NULL, skb->sk, SCM_TSTAMP_SCHED);
4261 
4262 	/* Disable soft irqs for various locks below. Also
4263 	 * stops preemption for RCU.
4264 	 */
4265 	rcu_read_lock_bh();
4266 
4267 	skb_update_prio(skb);
4268 
4269 	qdisc_pkt_len_init(skb);
4270 	tcx_set_ingress(skb, false);
4271 #ifdef CONFIG_NET_EGRESS
4272 	if (static_branch_unlikely(&egress_needed_key)) {
4273 		if (nf_hook_egress_active()) {
4274 			skb = nf_hook_egress(skb, &rc, dev);
4275 			if (!skb)
4276 				goto out;
4277 		}
4278 
4279 		netdev_xmit_skip_txqueue(false);
4280 
4281 		nf_skip_egress(skb, true);
4282 		skb = sch_handle_egress(skb, &rc, dev);
4283 		if (!skb)
4284 			goto out;
4285 		nf_skip_egress(skb, false);
4286 
4287 		if (netdev_xmit_txqueue_skipped())
4288 			txq = netdev_tx_queue_mapping(dev, skb);
4289 	}
4290 #endif
4291 	/* If device/qdisc don't need skb->dst, release it right now while
4292 	 * its hot in this cpu cache.
4293 	 */
4294 	if (dev->priv_flags & IFF_XMIT_DST_RELEASE)
4295 		skb_dst_drop(skb);
4296 	else
4297 		skb_dst_force(skb);
4298 
4299 	if (!txq)
4300 		txq = netdev_core_pick_tx(dev, skb, sb_dev);
4301 
4302 	q = rcu_dereference_bh(txq->qdisc);
4303 
4304 	trace_net_dev_queue(skb);
4305 	if (q->enqueue) {
4306 		rc = __dev_xmit_skb(skb, q, dev, txq);
4307 		goto out;
4308 	}
4309 
4310 	/* The device has no queue. Common case for software devices:
4311 	 * loopback, all the sorts of tunnels...
4312 
4313 	 * Really, it is unlikely that netif_tx_lock protection is necessary
4314 	 * here.  (f.e. loopback and IP tunnels are clean ignoring statistics
4315 	 * counters.)
4316 	 * However, it is possible, that they rely on protection
4317 	 * made by us here.
4318 
4319 	 * Check this and shot the lock. It is not prone from deadlocks.
4320 	 *Either shot noqueue qdisc, it is even simpler 8)
4321 	 */
4322 	if (dev->flags & IFF_UP) {
4323 		int cpu = smp_processor_id(); /* ok because BHs are off */
4324 
4325 		/* Other cpus might concurrently change txq->xmit_lock_owner
4326 		 * to -1 or to their cpu id, but not to our id.
4327 		 */
4328 		if (READ_ONCE(txq->xmit_lock_owner) != cpu) {
4329 			if (dev_xmit_recursion())
4330 				goto recursion_alert;
4331 
4332 			skb = validate_xmit_skb(skb, dev, &again);
4333 			if (!skb)
4334 				goto out;
4335 
4336 			HARD_TX_LOCK(dev, txq, cpu);
4337 
4338 			if (!netif_xmit_stopped(txq)) {
4339 				dev_xmit_recursion_inc();
4340 				skb = dev_hard_start_xmit(skb, dev, txq, &rc);
4341 				dev_xmit_recursion_dec();
4342 				if (dev_xmit_complete(rc)) {
4343 					HARD_TX_UNLOCK(dev, txq);
4344 					goto out;
4345 				}
4346 			}
4347 			HARD_TX_UNLOCK(dev, txq);
4348 			net_crit_ratelimited("Virtual device %s asks to queue packet!\n",
4349 					     dev->name);
4350 		} else {
4351 			/* Recursion is detected! It is possible,
4352 			 * unfortunately
4353 			 */
4354 recursion_alert:
4355 			net_crit_ratelimited("Dead loop on virtual device %s, fix it urgently!\n",
4356 					     dev->name);
4357 		}
4358 	}
4359 
4360 	rc = -ENETDOWN;
4361 	rcu_read_unlock_bh();
4362 
4363 	dev_core_stats_tx_dropped_inc(dev);
4364 	kfree_skb_list(skb);
4365 	return rc;
4366 out:
4367 	rcu_read_unlock_bh();
4368 	return rc;
4369 }
4370 EXPORT_SYMBOL(__dev_queue_xmit);
4371 
4372 int __dev_direct_xmit(struct sk_buff *skb, u16 queue_id)
4373 {
4374 	struct net_device *dev = skb->dev;
4375 	struct sk_buff *orig_skb = skb;
4376 	struct netdev_queue *txq;
4377 	int ret = NETDEV_TX_BUSY;
4378 	bool again = false;
4379 
4380 	if (unlikely(!netif_running(dev) ||
4381 		     !netif_carrier_ok(dev)))
4382 		goto drop;
4383 
4384 	skb = validate_xmit_skb_list(skb, dev, &again);
4385 	if (skb != orig_skb)
4386 		goto drop;
4387 
4388 	skb_set_queue_mapping(skb, queue_id);
4389 	txq = skb_get_tx_queue(dev, skb);
4390 
4391 	local_bh_disable();
4392 
4393 	dev_xmit_recursion_inc();
4394 	HARD_TX_LOCK(dev, txq, smp_processor_id());
4395 	if (!netif_xmit_frozen_or_drv_stopped(txq))
4396 		ret = netdev_start_xmit(skb, dev, txq, false);
4397 	HARD_TX_UNLOCK(dev, txq);
4398 	dev_xmit_recursion_dec();
4399 
4400 	local_bh_enable();
4401 	return ret;
4402 drop:
4403 	dev_core_stats_tx_dropped_inc(dev);
4404 	kfree_skb_list(skb);
4405 	return NET_XMIT_DROP;
4406 }
4407 EXPORT_SYMBOL(__dev_direct_xmit);
4408 
4409 /*************************************************************************
4410  *			Receiver routines
4411  *************************************************************************/
4412 
4413 int netdev_max_backlog __read_mostly = 1000;
4414 EXPORT_SYMBOL(netdev_max_backlog);
4415 
4416 int netdev_tstamp_prequeue __read_mostly = 1;
4417 unsigned int sysctl_skb_defer_max __read_mostly = 64;
4418 int netdev_budget __read_mostly = 300;
4419 /* Must be at least 2 jiffes to guarantee 1 jiffy timeout */
4420 unsigned int __read_mostly netdev_budget_usecs = 2 * USEC_PER_SEC / HZ;
4421 int weight_p __read_mostly = 64;           /* old backlog weight */
4422 int dev_weight_rx_bias __read_mostly = 1;  /* bias for backlog weight */
4423 int dev_weight_tx_bias __read_mostly = 1;  /* bias for output_queue quota */
4424 int dev_rx_weight __read_mostly = 64;
4425 int dev_tx_weight __read_mostly = 64;
4426 
4427 /* Called with irq disabled */
4428 static inline void ____napi_schedule(struct softnet_data *sd,
4429 				     struct napi_struct *napi)
4430 {
4431 	struct task_struct *thread;
4432 
4433 	lockdep_assert_irqs_disabled();
4434 
4435 	if (test_bit(NAPI_STATE_THREADED, &napi->state)) {
4436 		/* Paired with smp_mb__before_atomic() in
4437 		 * napi_enable()/dev_set_threaded().
4438 		 * Use READ_ONCE() to guarantee a complete
4439 		 * read on napi->thread. Only call
4440 		 * wake_up_process() when it's not NULL.
4441 		 */
4442 		thread = READ_ONCE(napi->thread);
4443 		if (thread) {
4444 			/* Avoid doing set_bit() if the thread is in
4445 			 * INTERRUPTIBLE state, cause napi_thread_wait()
4446 			 * makes sure to proceed with napi polling
4447 			 * if the thread is explicitly woken from here.
4448 			 */
4449 			if (READ_ONCE(thread->__state) != TASK_INTERRUPTIBLE)
4450 				set_bit(NAPI_STATE_SCHED_THREADED, &napi->state);
4451 			wake_up_process(thread);
4452 			return;
4453 		}
4454 	}
4455 
4456 	list_add_tail(&napi->poll_list, &sd->poll_list);
4457 	WRITE_ONCE(napi->list_owner, smp_processor_id());
4458 	/* If not called from net_rx_action()
4459 	 * we have to raise NET_RX_SOFTIRQ.
4460 	 */
4461 	if (!sd->in_net_rx_action)
4462 		__raise_softirq_irqoff(NET_RX_SOFTIRQ);
4463 }
4464 
4465 #ifdef CONFIG_RPS
4466 
4467 /* One global table that all flow-based protocols share. */
4468 struct rps_sock_flow_table __rcu *rps_sock_flow_table __read_mostly;
4469 EXPORT_SYMBOL(rps_sock_flow_table);
4470 u32 rps_cpu_mask __read_mostly;
4471 EXPORT_SYMBOL(rps_cpu_mask);
4472 
4473 struct static_key_false rps_needed __read_mostly;
4474 EXPORT_SYMBOL(rps_needed);
4475 struct static_key_false rfs_needed __read_mostly;
4476 EXPORT_SYMBOL(rfs_needed);
4477 
4478 static struct rps_dev_flow *
4479 set_rps_cpu(struct net_device *dev, struct sk_buff *skb,
4480 	    struct rps_dev_flow *rflow, u16 next_cpu)
4481 {
4482 	if (next_cpu < nr_cpu_ids) {
4483 #ifdef CONFIG_RFS_ACCEL
4484 		struct netdev_rx_queue *rxqueue;
4485 		struct rps_dev_flow_table *flow_table;
4486 		struct rps_dev_flow *old_rflow;
4487 		u32 flow_id;
4488 		u16 rxq_index;
4489 		int rc;
4490 
4491 		/* Should we steer this flow to a different hardware queue? */
4492 		if (!skb_rx_queue_recorded(skb) || !dev->rx_cpu_rmap ||
4493 		    !(dev->features & NETIF_F_NTUPLE))
4494 			goto out;
4495 		rxq_index = cpu_rmap_lookup_index(dev->rx_cpu_rmap, next_cpu);
4496 		if (rxq_index == skb_get_rx_queue(skb))
4497 			goto out;
4498 
4499 		rxqueue = dev->_rx + rxq_index;
4500 		flow_table = rcu_dereference(rxqueue->rps_flow_table);
4501 		if (!flow_table)
4502 			goto out;
4503 		flow_id = skb_get_hash(skb) & flow_table->mask;
4504 		rc = dev->netdev_ops->ndo_rx_flow_steer(dev, skb,
4505 							rxq_index, flow_id);
4506 		if (rc < 0)
4507 			goto out;
4508 		old_rflow = rflow;
4509 		rflow = &flow_table->flows[flow_id];
4510 		rflow->filter = rc;
4511 		if (old_rflow->filter == rflow->filter)
4512 			old_rflow->filter = RPS_NO_FILTER;
4513 	out:
4514 #endif
4515 		rflow->last_qtail =
4516 			per_cpu(softnet_data, next_cpu).input_queue_head;
4517 	}
4518 
4519 	rflow->cpu = next_cpu;
4520 	return rflow;
4521 }
4522 
4523 /*
4524  * get_rps_cpu is called from netif_receive_skb and returns the target
4525  * CPU from the RPS map of the receiving queue for a given skb.
4526  * rcu_read_lock must be held on entry.
4527  */
4528 static int get_rps_cpu(struct net_device *dev, struct sk_buff *skb,
4529 		       struct rps_dev_flow **rflowp)
4530 {
4531 	const struct rps_sock_flow_table *sock_flow_table;
4532 	struct netdev_rx_queue *rxqueue = dev->_rx;
4533 	struct rps_dev_flow_table *flow_table;
4534 	struct rps_map *map;
4535 	int cpu = -1;
4536 	u32 tcpu;
4537 	u32 hash;
4538 
4539 	if (skb_rx_queue_recorded(skb)) {
4540 		u16 index = skb_get_rx_queue(skb);
4541 
4542 		if (unlikely(index >= dev->real_num_rx_queues)) {
4543 			WARN_ONCE(dev->real_num_rx_queues > 1,
4544 				  "%s received packet on queue %u, but number "
4545 				  "of RX queues is %u\n",
4546 				  dev->name, index, dev->real_num_rx_queues);
4547 			goto done;
4548 		}
4549 		rxqueue += index;
4550 	}
4551 
4552 	/* Avoid computing hash if RFS/RPS is not active for this rxqueue */
4553 
4554 	flow_table = rcu_dereference(rxqueue->rps_flow_table);
4555 	map = rcu_dereference(rxqueue->rps_map);
4556 	if (!flow_table && !map)
4557 		goto done;
4558 
4559 	skb_reset_network_header(skb);
4560 	hash = skb_get_hash(skb);
4561 	if (!hash)
4562 		goto done;
4563 
4564 	sock_flow_table = rcu_dereference(rps_sock_flow_table);
4565 	if (flow_table && sock_flow_table) {
4566 		struct rps_dev_flow *rflow;
4567 		u32 next_cpu;
4568 		u32 ident;
4569 
4570 		/* First check into global flow table if there is a match.
4571 		 * This READ_ONCE() pairs with WRITE_ONCE() from rps_record_sock_flow().
4572 		 */
4573 		ident = READ_ONCE(sock_flow_table->ents[hash & sock_flow_table->mask]);
4574 		if ((ident ^ hash) & ~rps_cpu_mask)
4575 			goto try_rps;
4576 
4577 		next_cpu = ident & rps_cpu_mask;
4578 
4579 		/* OK, now we know there is a match,
4580 		 * we can look at the local (per receive queue) flow table
4581 		 */
4582 		rflow = &flow_table->flows[hash & flow_table->mask];
4583 		tcpu = rflow->cpu;
4584 
4585 		/*
4586 		 * If the desired CPU (where last recvmsg was done) is
4587 		 * different from current CPU (one in the rx-queue flow
4588 		 * table entry), switch if one of the following holds:
4589 		 *   - Current CPU is unset (>= nr_cpu_ids).
4590 		 *   - Current CPU is offline.
4591 		 *   - The current CPU's queue tail has advanced beyond the
4592 		 *     last packet that was enqueued using this table entry.
4593 		 *     This guarantees that all previous packets for the flow
4594 		 *     have been dequeued, thus preserving in order delivery.
4595 		 */
4596 		if (unlikely(tcpu != next_cpu) &&
4597 		    (tcpu >= nr_cpu_ids || !cpu_online(tcpu) ||
4598 		     ((int)(per_cpu(softnet_data, tcpu).input_queue_head -
4599 		      rflow->last_qtail)) >= 0)) {
4600 			tcpu = next_cpu;
4601 			rflow = set_rps_cpu(dev, skb, rflow, next_cpu);
4602 		}
4603 
4604 		if (tcpu < nr_cpu_ids && cpu_online(tcpu)) {
4605 			*rflowp = rflow;
4606 			cpu = tcpu;
4607 			goto done;
4608 		}
4609 	}
4610 
4611 try_rps:
4612 
4613 	if (map) {
4614 		tcpu = map->cpus[reciprocal_scale(hash, map->len)];
4615 		if (cpu_online(tcpu)) {
4616 			cpu = tcpu;
4617 			goto done;
4618 		}
4619 	}
4620 
4621 done:
4622 	return cpu;
4623 }
4624 
4625 #ifdef CONFIG_RFS_ACCEL
4626 
4627 /**
4628  * rps_may_expire_flow - check whether an RFS hardware filter may be removed
4629  * @dev: Device on which the filter was set
4630  * @rxq_index: RX queue index
4631  * @flow_id: Flow ID passed to ndo_rx_flow_steer()
4632  * @filter_id: Filter ID returned by ndo_rx_flow_steer()
4633  *
4634  * Drivers that implement ndo_rx_flow_steer() should periodically call
4635  * this function for each installed filter and remove the filters for
4636  * which it returns %true.
4637  */
4638 bool rps_may_expire_flow(struct net_device *dev, u16 rxq_index,
4639 			 u32 flow_id, u16 filter_id)
4640 {
4641 	struct netdev_rx_queue *rxqueue = dev->_rx + rxq_index;
4642 	struct rps_dev_flow_table *flow_table;
4643 	struct rps_dev_flow *rflow;
4644 	bool expire = true;
4645 	unsigned int cpu;
4646 
4647 	rcu_read_lock();
4648 	flow_table = rcu_dereference(rxqueue->rps_flow_table);
4649 	if (flow_table && flow_id <= flow_table->mask) {
4650 		rflow = &flow_table->flows[flow_id];
4651 		cpu = READ_ONCE(rflow->cpu);
4652 		if (rflow->filter == filter_id && cpu < nr_cpu_ids &&
4653 		    ((int)(per_cpu(softnet_data, cpu).input_queue_head -
4654 			   rflow->last_qtail) <
4655 		     (int)(10 * flow_table->mask)))
4656 			expire = false;
4657 	}
4658 	rcu_read_unlock();
4659 	return expire;
4660 }
4661 EXPORT_SYMBOL(rps_may_expire_flow);
4662 
4663 #endif /* CONFIG_RFS_ACCEL */
4664 
4665 /* Called from hardirq (IPI) context */
4666 static void rps_trigger_softirq(void *data)
4667 {
4668 	struct softnet_data *sd = data;
4669 
4670 	____napi_schedule(sd, &sd->backlog);
4671 	sd->received_rps++;
4672 }
4673 
4674 #endif /* CONFIG_RPS */
4675 
4676 /* Called from hardirq (IPI) context */
4677 static void trigger_rx_softirq(void *data)
4678 {
4679 	struct softnet_data *sd = data;
4680 
4681 	__raise_softirq_irqoff(NET_RX_SOFTIRQ);
4682 	smp_store_release(&sd->defer_ipi_scheduled, 0);
4683 }
4684 
4685 /*
4686  * After we queued a packet into sd->input_pkt_queue,
4687  * we need to make sure this queue is serviced soon.
4688  *
4689  * - If this is another cpu queue, link it to our rps_ipi_list,
4690  *   and make sure we will process rps_ipi_list from net_rx_action().
4691  *
4692  * - If this is our own queue, NAPI schedule our backlog.
4693  *   Note that this also raises NET_RX_SOFTIRQ.
4694  */
4695 static void napi_schedule_rps(struct softnet_data *sd)
4696 {
4697 	struct softnet_data *mysd = this_cpu_ptr(&softnet_data);
4698 
4699 #ifdef CONFIG_RPS
4700 	if (sd != mysd) {
4701 		sd->rps_ipi_next = mysd->rps_ipi_list;
4702 		mysd->rps_ipi_list = sd;
4703 
4704 		/* If not called from net_rx_action() or napi_threaded_poll()
4705 		 * we have to raise NET_RX_SOFTIRQ.
4706 		 */
4707 		if (!mysd->in_net_rx_action && !mysd->in_napi_threaded_poll)
4708 			__raise_softirq_irqoff(NET_RX_SOFTIRQ);
4709 		return;
4710 	}
4711 #endif /* CONFIG_RPS */
4712 	__napi_schedule_irqoff(&mysd->backlog);
4713 }
4714 
4715 #ifdef CONFIG_NET_FLOW_LIMIT
4716 int netdev_flow_limit_table_len __read_mostly = (1 << 12);
4717 #endif
4718 
4719 static bool skb_flow_limit(struct sk_buff *skb, unsigned int qlen)
4720 {
4721 #ifdef CONFIG_NET_FLOW_LIMIT
4722 	struct sd_flow_limit *fl;
4723 	struct softnet_data *sd;
4724 	unsigned int old_flow, new_flow;
4725 
4726 	if (qlen < (READ_ONCE(netdev_max_backlog) >> 1))
4727 		return false;
4728 
4729 	sd = this_cpu_ptr(&softnet_data);
4730 
4731 	rcu_read_lock();
4732 	fl = rcu_dereference(sd->flow_limit);
4733 	if (fl) {
4734 		new_flow = skb_get_hash(skb) & (fl->num_buckets - 1);
4735 		old_flow = fl->history[fl->history_head];
4736 		fl->history[fl->history_head] = new_flow;
4737 
4738 		fl->history_head++;
4739 		fl->history_head &= FLOW_LIMIT_HISTORY - 1;
4740 
4741 		if (likely(fl->buckets[old_flow]))
4742 			fl->buckets[old_flow]--;
4743 
4744 		if (++fl->buckets[new_flow] > (FLOW_LIMIT_HISTORY >> 1)) {
4745 			fl->count++;
4746 			rcu_read_unlock();
4747 			return true;
4748 		}
4749 	}
4750 	rcu_read_unlock();
4751 #endif
4752 	return false;
4753 }
4754 
4755 /*
4756  * enqueue_to_backlog is called to queue an skb to a per CPU backlog
4757  * queue (may be a remote CPU queue).
4758  */
4759 static int enqueue_to_backlog(struct sk_buff *skb, int cpu,
4760 			      unsigned int *qtail)
4761 {
4762 	enum skb_drop_reason reason;
4763 	struct softnet_data *sd;
4764 	unsigned long flags;
4765 	unsigned int qlen;
4766 
4767 	reason = SKB_DROP_REASON_NOT_SPECIFIED;
4768 	sd = &per_cpu(softnet_data, cpu);
4769 
4770 	rps_lock_irqsave(sd, &flags);
4771 	if (!netif_running(skb->dev))
4772 		goto drop;
4773 	qlen = skb_queue_len(&sd->input_pkt_queue);
4774 	if (qlen <= READ_ONCE(netdev_max_backlog) && !skb_flow_limit(skb, qlen)) {
4775 		if (qlen) {
4776 enqueue:
4777 			__skb_queue_tail(&sd->input_pkt_queue, skb);
4778 			input_queue_tail_incr_save(sd, qtail);
4779 			rps_unlock_irq_restore(sd, &flags);
4780 			return NET_RX_SUCCESS;
4781 		}
4782 
4783 		/* Schedule NAPI for backlog device
4784 		 * We can use non atomic operation since we own the queue lock
4785 		 */
4786 		if (!__test_and_set_bit(NAPI_STATE_SCHED, &sd->backlog.state))
4787 			napi_schedule_rps(sd);
4788 		goto enqueue;
4789 	}
4790 	reason = SKB_DROP_REASON_CPU_BACKLOG;
4791 
4792 drop:
4793 	sd->dropped++;
4794 	rps_unlock_irq_restore(sd, &flags);
4795 
4796 	dev_core_stats_rx_dropped_inc(skb->dev);
4797 	kfree_skb_reason(skb, reason);
4798 	return NET_RX_DROP;
4799 }
4800 
4801 static struct netdev_rx_queue *netif_get_rxqueue(struct sk_buff *skb)
4802 {
4803 	struct net_device *dev = skb->dev;
4804 	struct netdev_rx_queue *rxqueue;
4805 
4806 	rxqueue = dev->_rx;
4807 
4808 	if (skb_rx_queue_recorded(skb)) {
4809 		u16 index = skb_get_rx_queue(skb);
4810 
4811 		if (unlikely(index >= dev->real_num_rx_queues)) {
4812 			WARN_ONCE(dev->real_num_rx_queues > 1,
4813 				  "%s received packet on queue %u, but number "
4814 				  "of RX queues is %u\n",
4815 				  dev->name, index, dev->real_num_rx_queues);
4816 
4817 			return rxqueue; /* Return first rxqueue */
4818 		}
4819 		rxqueue += index;
4820 	}
4821 	return rxqueue;
4822 }
4823 
4824 u32 bpf_prog_run_generic_xdp(struct sk_buff *skb, struct xdp_buff *xdp,
4825 			     struct bpf_prog *xdp_prog)
4826 {
4827 	void *orig_data, *orig_data_end, *hard_start;
4828 	struct netdev_rx_queue *rxqueue;
4829 	bool orig_bcast, orig_host;
4830 	u32 mac_len, frame_sz;
4831 	__be16 orig_eth_type;
4832 	struct ethhdr *eth;
4833 	u32 metalen, act;
4834 	int off;
4835 
4836 	/* The XDP program wants to see the packet starting at the MAC
4837 	 * header.
4838 	 */
4839 	mac_len = skb->data - skb_mac_header(skb);
4840 	hard_start = skb->data - skb_headroom(skb);
4841 
4842 	/* SKB "head" area always have tailroom for skb_shared_info */
4843 	frame_sz = (void *)skb_end_pointer(skb) - hard_start;
4844 	frame_sz += SKB_DATA_ALIGN(sizeof(struct skb_shared_info));
4845 
4846 	rxqueue = netif_get_rxqueue(skb);
4847 	xdp_init_buff(xdp, frame_sz, &rxqueue->xdp_rxq);
4848 	xdp_prepare_buff(xdp, hard_start, skb_headroom(skb) - mac_len,
4849 			 skb_headlen(skb) + mac_len, true);
4850 
4851 	orig_data_end = xdp->data_end;
4852 	orig_data = xdp->data;
4853 	eth = (struct ethhdr *)xdp->data;
4854 	orig_host = ether_addr_equal_64bits(eth->h_dest, skb->dev->dev_addr);
4855 	orig_bcast = is_multicast_ether_addr_64bits(eth->h_dest);
4856 	orig_eth_type = eth->h_proto;
4857 
4858 	act = bpf_prog_run_xdp(xdp_prog, xdp);
4859 
4860 	/* check if bpf_xdp_adjust_head was used */
4861 	off = xdp->data - orig_data;
4862 	if (off) {
4863 		if (off > 0)
4864 			__skb_pull(skb, off);
4865 		else if (off < 0)
4866 			__skb_push(skb, -off);
4867 
4868 		skb->mac_header += off;
4869 		skb_reset_network_header(skb);
4870 	}
4871 
4872 	/* check if bpf_xdp_adjust_tail was used */
4873 	off = xdp->data_end - orig_data_end;
4874 	if (off != 0) {
4875 		skb_set_tail_pointer(skb, xdp->data_end - xdp->data);
4876 		skb->len += off; /* positive on grow, negative on shrink */
4877 	}
4878 
4879 	/* check if XDP changed eth hdr such SKB needs update */
4880 	eth = (struct ethhdr *)xdp->data;
4881 	if ((orig_eth_type != eth->h_proto) ||
4882 	    (orig_host != ether_addr_equal_64bits(eth->h_dest,
4883 						  skb->dev->dev_addr)) ||
4884 	    (orig_bcast != is_multicast_ether_addr_64bits(eth->h_dest))) {
4885 		__skb_push(skb, ETH_HLEN);
4886 		skb->pkt_type = PACKET_HOST;
4887 		skb->protocol = eth_type_trans(skb, skb->dev);
4888 	}
4889 
4890 	/* Redirect/Tx gives L2 packet, code that will reuse skb must __skb_pull
4891 	 * before calling us again on redirect path. We do not call do_redirect
4892 	 * as we leave that up to the caller.
4893 	 *
4894 	 * Caller is responsible for managing lifetime of skb (i.e. calling
4895 	 * kfree_skb in response to actions it cannot handle/XDP_DROP).
4896 	 */
4897 	switch (act) {
4898 	case XDP_REDIRECT:
4899 	case XDP_TX:
4900 		__skb_push(skb, mac_len);
4901 		break;
4902 	case XDP_PASS:
4903 		metalen = xdp->data - xdp->data_meta;
4904 		if (metalen)
4905 			skb_metadata_set(skb, metalen);
4906 		break;
4907 	}
4908 
4909 	return act;
4910 }
4911 
4912 static u32 netif_receive_generic_xdp(struct sk_buff *skb,
4913 				     struct xdp_buff *xdp,
4914 				     struct bpf_prog *xdp_prog)
4915 {
4916 	u32 act = XDP_DROP;
4917 
4918 	/* Reinjected packets coming from act_mirred or similar should
4919 	 * not get XDP generic processing.
4920 	 */
4921 	if (skb_is_redirected(skb))
4922 		return XDP_PASS;
4923 
4924 	/* XDP packets must be linear and must have sufficient headroom
4925 	 * of XDP_PACKET_HEADROOM bytes. This is the guarantee that also
4926 	 * native XDP provides, thus we need to do it here as well.
4927 	 */
4928 	if (skb_cloned(skb) || skb_is_nonlinear(skb) ||
4929 	    skb_headroom(skb) < XDP_PACKET_HEADROOM) {
4930 		int hroom = XDP_PACKET_HEADROOM - skb_headroom(skb);
4931 		int troom = skb->tail + skb->data_len - skb->end;
4932 
4933 		/* In case we have to go down the path and also linearize,
4934 		 * then lets do the pskb_expand_head() work just once here.
4935 		 */
4936 		if (pskb_expand_head(skb,
4937 				     hroom > 0 ? ALIGN(hroom, NET_SKB_PAD) : 0,
4938 				     troom > 0 ? troom + 128 : 0, GFP_ATOMIC))
4939 			goto do_drop;
4940 		if (skb_linearize(skb))
4941 			goto do_drop;
4942 	}
4943 
4944 	act = bpf_prog_run_generic_xdp(skb, xdp, xdp_prog);
4945 	switch (act) {
4946 	case XDP_REDIRECT:
4947 	case XDP_TX:
4948 	case XDP_PASS:
4949 		break;
4950 	default:
4951 		bpf_warn_invalid_xdp_action(skb->dev, xdp_prog, act);
4952 		fallthrough;
4953 	case XDP_ABORTED:
4954 		trace_xdp_exception(skb->dev, xdp_prog, act);
4955 		fallthrough;
4956 	case XDP_DROP:
4957 	do_drop:
4958 		kfree_skb(skb);
4959 		break;
4960 	}
4961 
4962 	return act;
4963 }
4964 
4965 /* When doing generic XDP we have to bypass the qdisc layer and the
4966  * network taps in order to match in-driver-XDP behavior. This also means
4967  * that XDP packets are able to starve other packets going through a qdisc,
4968  * and DDOS attacks will be more effective. In-driver-XDP use dedicated TX
4969  * queues, so they do not have this starvation issue.
4970  */
4971 void generic_xdp_tx(struct sk_buff *skb, struct bpf_prog *xdp_prog)
4972 {
4973 	struct net_device *dev = skb->dev;
4974 	struct netdev_queue *txq;
4975 	bool free_skb = true;
4976 	int cpu, rc;
4977 
4978 	txq = netdev_core_pick_tx(dev, skb, NULL);
4979 	cpu = smp_processor_id();
4980 	HARD_TX_LOCK(dev, txq, cpu);
4981 	if (!netif_xmit_frozen_or_drv_stopped(txq)) {
4982 		rc = netdev_start_xmit(skb, dev, txq, 0);
4983 		if (dev_xmit_complete(rc))
4984 			free_skb = false;
4985 	}
4986 	HARD_TX_UNLOCK(dev, txq);
4987 	if (free_skb) {
4988 		trace_xdp_exception(dev, xdp_prog, XDP_TX);
4989 		dev_core_stats_tx_dropped_inc(dev);
4990 		kfree_skb(skb);
4991 	}
4992 }
4993 
4994 static DEFINE_STATIC_KEY_FALSE(generic_xdp_needed_key);
4995 
4996 int do_xdp_generic(struct bpf_prog *xdp_prog, struct sk_buff *skb)
4997 {
4998 	if (xdp_prog) {
4999 		struct xdp_buff xdp;
5000 		u32 act;
5001 		int err;
5002 
5003 		act = netif_receive_generic_xdp(skb, &xdp, xdp_prog);
5004 		if (act != XDP_PASS) {
5005 			switch (act) {
5006 			case XDP_REDIRECT:
5007 				err = xdp_do_generic_redirect(skb->dev, skb,
5008 							      &xdp, xdp_prog);
5009 				if (err)
5010 					goto out_redir;
5011 				break;
5012 			case XDP_TX:
5013 				generic_xdp_tx(skb, xdp_prog);
5014 				break;
5015 			}
5016 			return XDP_DROP;
5017 		}
5018 	}
5019 	return XDP_PASS;
5020 out_redir:
5021 	kfree_skb_reason(skb, SKB_DROP_REASON_XDP);
5022 	return XDP_DROP;
5023 }
5024 EXPORT_SYMBOL_GPL(do_xdp_generic);
5025 
5026 static int netif_rx_internal(struct sk_buff *skb)
5027 {
5028 	int ret;
5029 
5030 	net_timestamp_check(READ_ONCE(netdev_tstamp_prequeue), skb);
5031 
5032 	trace_netif_rx(skb);
5033 
5034 #ifdef CONFIG_RPS
5035 	if (static_branch_unlikely(&rps_needed)) {
5036 		struct rps_dev_flow voidflow, *rflow = &voidflow;
5037 		int cpu;
5038 
5039 		rcu_read_lock();
5040 
5041 		cpu = get_rps_cpu(skb->dev, skb, &rflow);
5042 		if (cpu < 0)
5043 			cpu = smp_processor_id();
5044 
5045 		ret = enqueue_to_backlog(skb, cpu, &rflow->last_qtail);
5046 
5047 		rcu_read_unlock();
5048 	} else
5049 #endif
5050 	{
5051 		unsigned int qtail;
5052 
5053 		ret = enqueue_to_backlog(skb, smp_processor_id(), &qtail);
5054 	}
5055 	return ret;
5056 }
5057 
5058 /**
5059  *	__netif_rx	-	Slightly optimized version of netif_rx
5060  *	@skb: buffer to post
5061  *
5062  *	This behaves as netif_rx except that it does not disable bottom halves.
5063  *	As a result this function may only be invoked from the interrupt context
5064  *	(either hard or soft interrupt).
5065  */
5066 int __netif_rx(struct sk_buff *skb)
5067 {
5068 	int ret;
5069 
5070 	lockdep_assert_once(hardirq_count() | softirq_count());
5071 
5072 	trace_netif_rx_entry(skb);
5073 	ret = netif_rx_internal(skb);
5074 	trace_netif_rx_exit(ret);
5075 	return ret;
5076 }
5077 EXPORT_SYMBOL(__netif_rx);
5078 
5079 /**
5080  *	netif_rx	-	post buffer to the network code
5081  *	@skb: buffer to post
5082  *
5083  *	This function receives a packet from a device driver and queues it for
5084  *	the upper (protocol) levels to process via the backlog NAPI device. It
5085  *	always succeeds. The buffer may be dropped during processing for
5086  *	congestion control or by the protocol layers.
5087  *	The network buffer is passed via the backlog NAPI device. Modern NIC
5088  *	driver should use NAPI and GRO.
5089  *	This function can used from interrupt and from process context. The
5090  *	caller from process context must not disable interrupts before invoking
5091  *	this function.
5092  *
5093  *	return values:
5094  *	NET_RX_SUCCESS	(no congestion)
5095  *	NET_RX_DROP     (packet was dropped)
5096  *
5097  */
5098 int netif_rx(struct sk_buff *skb)
5099 {
5100 	bool need_bh_off = !(hardirq_count() | softirq_count());
5101 	int ret;
5102 
5103 	if (need_bh_off)
5104 		local_bh_disable();
5105 	trace_netif_rx_entry(skb);
5106 	ret = netif_rx_internal(skb);
5107 	trace_netif_rx_exit(ret);
5108 	if (need_bh_off)
5109 		local_bh_enable();
5110 	return ret;
5111 }
5112 EXPORT_SYMBOL(netif_rx);
5113 
5114 static __latent_entropy void net_tx_action(struct softirq_action *h)
5115 {
5116 	struct softnet_data *sd = this_cpu_ptr(&softnet_data);
5117 
5118 	if (sd->completion_queue) {
5119 		struct sk_buff *clist;
5120 
5121 		local_irq_disable();
5122 		clist = sd->completion_queue;
5123 		sd->completion_queue = NULL;
5124 		local_irq_enable();
5125 
5126 		while (clist) {
5127 			struct sk_buff *skb = clist;
5128 
5129 			clist = clist->next;
5130 
5131 			WARN_ON(refcount_read(&skb->users));
5132 			if (likely(get_kfree_skb_cb(skb)->reason == SKB_CONSUMED))
5133 				trace_consume_skb(skb, net_tx_action);
5134 			else
5135 				trace_kfree_skb(skb, net_tx_action,
5136 						get_kfree_skb_cb(skb)->reason);
5137 
5138 			if (skb->fclone != SKB_FCLONE_UNAVAILABLE)
5139 				__kfree_skb(skb);
5140 			else
5141 				__napi_kfree_skb(skb,
5142 						 get_kfree_skb_cb(skb)->reason);
5143 		}
5144 	}
5145 
5146 	if (sd->output_queue) {
5147 		struct Qdisc *head;
5148 
5149 		local_irq_disable();
5150 		head = sd->output_queue;
5151 		sd->output_queue = NULL;
5152 		sd->output_queue_tailp = &sd->output_queue;
5153 		local_irq_enable();
5154 
5155 		rcu_read_lock();
5156 
5157 		while (head) {
5158 			struct Qdisc *q = head;
5159 			spinlock_t *root_lock = NULL;
5160 
5161 			head = head->next_sched;
5162 
5163 			/* We need to make sure head->next_sched is read
5164 			 * before clearing __QDISC_STATE_SCHED
5165 			 */
5166 			smp_mb__before_atomic();
5167 
5168 			if (!(q->flags & TCQ_F_NOLOCK)) {
5169 				root_lock = qdisc_lock(q);
5170 				spin_lock(root_lock);
5171 			} else if (unlikely(test_bit(__QDISC_STATE_DEACTIVATED,
5172 						     &q->state))) {
5173 				/* There is a synchronize_net() between
5174 				 * STATE_DEACTIVATED flag being set and
5175 				 * qdisc_reset()/some_qdisc_is_busy() in
5176 				 * dev_deactivate(), so we can safely bail out
5177 				 * early here to avoid data race between
5178 				 * qdisc_deactivate() and some_qdisc_is_busy()
5179 				 * for lockless qdisc.
5180 				 */
5181 				clear_bit(__QDISC_STATE_SCHED, &q->state);
5182 				continue;
5183 			}
5184 
5185 			clear_bit(__QDISC_STATE_SCHED, &q->state);
5186 			qdisc_run(q);
5187 			if (root_lock)
5188 				spin_unlock(root_lock);
5189 		}
5190 
5191 		rcu_read_unlock();
5192 	}
5193 
5194 	xfrm_dev_backlog(sd);
5195 }
5196 
5197 #if IS_ENABLED(CONFIG_BRIDGE) && IS_ENABLED(CONFIG_ATM_LANE)
5198 /* This hook is defined here for ATM LANE */
5199 int (*br_fdb_test_addr_hook)(struct net_device *dev,
5200 			     unsigned char *addr) __read_mostly;
5201 EXPORT_SYMBOL_GPL(br_fdb_test_addr_hook);
5202 #endif
5203 
5204 /**
5205  *	netdev_is_rx_handler_busy - check if receive handler is registered
5206  *	@dev: device to check
5207  *
5208  *	Check if a receive handler is already registered for a given device.
5209  *	Return true if there one.
5210  *
5211  *	The caller must hold the rtnl_mutex.
5212  */
5213 bool netdev_is_rx_handler_busy(struct net_device *dev)
5214 {
5215 	ASSERT_RTNL();
5216 	return dev && rtnl_dereference(dev->rx_handler);
5217 }
5218 EXPORT_SYMBOL_GPL(netdev_is_rx_handler_busy);
5219 
5220 /**
5221  *	netdev_rx_handler_register - register receive handler
5222  *	@dev: device to register a handler for
5223  *	@rx_handler: receive handler to register
5224  *	@rx_handler_data: data pointer that is used by rx handler
5225  *
5226  *	Register a receive handler for a device. This handler will then be
5227  *	called from __netif_receive_skb. A negative errno code is returned
5228  *	on a failure.
5229  *
5230  *	The caller must hold the rtnl_mutex.
5231  *
5232  *	For a general description of rx_handler, see enum rx_handler_result.
5233  */
5234 int netdev_rx_handler_register(struct net_device *dev,
5235 			       rx_handler_func_t *rx_handler,
5236 			       void *rx_handler_data)
5237 {
5238 	if (netdev_is_rx_handler_busy(dev))
5239 		return -EBUSY;
5240 
5241 	if (dev->priv_flags & IFF_NO_RX_HANDLER)
5242 		return -EINVAL;
5243 
5244 	/* Note: rx_handler_data must be set before rx_handler */
5245 	rcu_assign_pointer(dev->rx_handler_data, rx_handler_data);
5246 	rcu_assign_pointer(dev->rx_handler, rx_handler);
5247 
5248 	return 0;
5249 }
5250 EXPORT_SYMBOL_GPL(netdev_rx_handler_register);
5251 
5252 /**
5253  *	netdev_rx_handler_unregister - unregister receive handler
5254  *	@dev: device to unregister a handler from
5255  *
5256  *	Unregister a receive handler from a device.
5257  *
5258  *	The caller must hold the rtnl_mutex.
5259  */
5260 void netdev_rx_handler_unregister(struct net_device *dev)
5261 {
5262 
5263 	ASSERT_RTNL();
5264 	RCU_INIT_POINTER(dev->rx_handler, NULL);
5265 	/* a reader seeing a non NULL rx_handler in a rcu_read_lock()
5266 	 * section has a guarantee to see a non NULL rx_handler_data
5267 	 * as well.
5268 	 */
5269 	synchronize_net();
5270 	RCU_INIT_POINTER(dev->rx_handler_data, NULL);
5271 }
5272 EXPORT_SYMBOL_GPL(netdev_rx_handler_unregister);
5273 
5274 /*
5275  * Limit the use of PFMEMALLOC reserves to those protocols that implement
5276  * the special handling of PFMEMALLOC skbs.
5277  */
5278 static bool skb_pfmemalloc_protocol(struct sk_buff *skb)
5279 {
5280 	switch (skb->protocol) {
5281 	case htons(ETH_P_ARP):
5282 	case htons(ETH_P_IP):
5283 	case htons(ETH_P_IPV6):
5284 	case htons(ETH_P_8021Q):
5285 	case htons(ETH_P_8021AD):
5286 		return true;
5287 	default:
5288 		return false;
5289 	}
5290 }
5291 
5292 static inline int nf_ingress(struct sk_buff *skb, struct packet_type **pt_prev,
5293 			     int *ret, struct net_device *orig_dev)
5294 {
5295 	if (nf_hook_ingress_active(skb)) {
5296 		int ingress_retval;
5297 
5298 		if (*pt_prev) {
5299 			*ret = deliver_skb(skb, *pt_prev, orig_dev);
5300 			*pt_prev = NULL;
5301 		}
5302 
5303 		rcu_read_lock();
5304 		ingress_retval = nf_hook_ingress(skb);
5305 		rcu_read_unlock();
5306 		return ingress_retval;
5307 	}
5308 	return 0;
5309 }
5310 
5311 static int __netif_receive_skb_core(struct sk_buff **pskb, bool pfmemalloc,
5312 				    struct packet_type **ppt_prev)
5313 {
5314 	struct packet_type *ptype, *pt_prev;
5315 	rx_handler_func_t *rx_handler;
5316 	struct sk_buff *skb = *pskb;
5317 	struct net_device *orig_dev;
5318 	bool deliver_exact = false;
5319 	int ret = NET_RX_DROP;
5320 	__be16 type;
5321 
5322 	net_timestamp_check(!READ_ONCE(netdev_tstamp_prequeue), skb);
5323 
5324 	trace_netif_receive_skb(skb);
5325 
5326 	orig_dev = skb->dev;
5327 
5328 	skb_reset_network_header(skb);
5329 	if (!skb_transport_header_was_set(skb))
5330 		skb_reset_transport_header(skb);
5331 	skb_reset_mac_len(skb);
5332 
5333 	pt_prev = NULL;
5334 
5335 another_round:
5336 	skb->skb_iif = skb->dev->ifindex;
5337 
5338 	__this_cpu_inc(softnet_data.processed);
5339 
5340 	if (static_branch_unlikely(&generic_xdp_needed_key)) {
5341 		int ret2;
5342 
5343 		migrate_disable();
5344 		ret2 = do_xdp_generic(rcu_dereference(skb->dev->xdp_prog), skb);
5345 		migrate_enable();
5346 
5347 		if (ret2 != XDP_PASS) {
5348 			ret = NET_RX_DROP;
5349 			goto out;
5350 		}
5351 	}
5352 
5353 	if (eth_type_vlan(skb->protocol)) {
5354 		skb = skb_vlan_untag(skb);
5355 		if (unlikely(!skb))
5356 			goto out;
5357 	}
5358 
5359 	if (skb_skip_tc_classify(skb))
5360 		goto skip_classify;
5361 
5362 	if (pfmemalloc)
5363 		goto skip_taps;
5364 
5365 	list_for_each_entry_rcu(ptype, &ptype_all, list) {
5366 		if (pt_prev)
5367 			ret = deliver_skb(skb, pt_prev, orig_dev);
5368 		pt_prev = ptype;
5369 	}
5370 
5371 	list_for_each_entry_rcu(ptype, &skb->dev->ptype_all, list) {
5372 		if (pt_prev)
5373 			ret = deliver_skb(skb, pt_prev, orig_dev);
5374 		pt_prev = ptype;
5375 	}
5376 
5377 skip_taps:
5378 #ifdef CONFIG_NET_INGRESS
5379 	if (static_branch_unlikely(&ingress_needed_key)) {
5380 		bool another = false;
5381 
5382 		nf_skip_egress(skb, true);
5383 		skb = sch_handle_ingress(skb, &pt_prev, &ret, orig_dev,
5384 					 &another);
5385 		if (another)
5386 			goto another_round;
5387 		if (!skb)
5388 			goto out;
5389 
5390 		nf_skip_egress(skb, false);
5391 		if (nf_ingress(skb, &pt_prev, &ret, orig_dev) < 0)
5392 			goto out;
5393 	}
5394 #endif
5395 	skb_reset_redirect(skb);
5396 skip_classify:
5397 	if (pfmemalloc && !skb_pfmemalloc_protocol(skb))
5398 		goto drop;
5399 
5400 	if (skb_vlan_tag_present(skb)) {
5401 		if (pt_prev) {
5402 			ret = deliver_skb(skb, pt_prev, orig_dev);
5403 			pt_prev = NULL;
5404 		}
5405 		if (vlan_do_receive(&skb))
5406 			goto another_round;
5407 		else if (unlikely(!skb))
5408 			goto out;
5409 	}
5410 
5411 	rx_handler = rcu_dereference(skb->dev->rx_handler);
5412 	if (rx_handler) {
5413 		if (pt_prev) {
5414 			ret = deliver_skb(skb, pt_prev, orig_dev);
5415 			pt_prev = NULL;
5416 		}
5417 		switch (rx_handler(&skb)) {
5418 		case RX_HANDLER_CONSUMED:
5419 			ret = NET_RX_SUCCESS;
5420 			goto out;
5421 		case RX_HANDLER_ANOTHER:
5422 			goto another_round;
5423 		case RX_HANDLER_EXACT:
5424 			deliver_exact = true;
5425 			break;
5426 		case RX_HANDLER_PASS:
5427 			break;
5428 		default:
5429 			BUG();
5430 		}
5431 	}
5432 
5433 	if (unlikely(skb_vlan_tag_present(skb)) && !netdev_uses_dsa(skb->dev)) {
5434 check_vlan_id:
5435 		if (skb_vlan_tag_get_id(skb)) {
5436 			/* Vlan id is non 0 and vlan_do_receive() above couldn't
5437 			 * find vlan device.
5438 			 */
5439 			skb->pkt_type = PACKET_OTHERHOST;
5440 		} else if (eth_type_vlan(skb->protocol)) {
5441 			/* Outer header is 802.1P with vlan 0, inner header is
5442 			 * 802.1Q or 802.1AD and vlan_do_receive() above could
5443 			 * not find vlan dev for vlan id 0.
5444 			 */
5445 			__vlan_hwaccel_clear_tag(skb);
5446 			skb = skb_vlan_untag(skb);
5447 			if (unlikely(!skb))
5448 				goto out;
5449 			if (vlan_do_receive(&skb))
5450 				/* After stripping off 802.1P header with vlan 0
5451 				 * vlan dev is found for inner header.
5452 				 */
5453 				goto another_round;
5454 			else if (unlikely(!skb))
5455 				goto out;
5456 			else
5457 				/* We have stripped outer 802.1P vlan 0 header.
5458 				 * But could not find vlan dev.
5459 				 * check again for vlan id to set OTHERHOST.
5460 				 */
5461 				goto check_vlan_id;
5462 		}
5463 		/* Note: we might in the future use prio bits
5464 		 * and set skb->priority like in vlan_do_receive()
5465 		 * For the time being, just ignore Priority Code Point
5466 		 */
5467 		__vlan_hwaccel_clear_tag(skb);
5468 	}
5469 
5470 	type = skb->protocol;
5471 
5472 	/* deliver only exact match when indicated */
5473 	if (likely(!deliver_exact)) {
5474 		deliver_ptype_list_skb(skb, &pt_prev, orig_dev, type,
5475 				       &ptype_base[ntohs(type) &
5476 						   PTYPE_HASH_MASK]);
5477 	}
5478 
5479 	deliver_ptype_list_skb(skb, &pt_prev, orig_dev, type,
5480 			       &orig_dev->ptype_specific);
5481 
5482 	if (unlikely(skb->dev != orig_dev)) {
5483 		deliver_ptype_list_skb(skb, &pt_prev, orig_dev, type,
5484 				       &skb->dev->ptype_specific);
5485 	}
5486 
5487 	if (pt_prev) {
5488 		if (unlikely(skb_orphan_frags_rx(skb, GFP_ATOMIC)))
5489 			goto drop;
5490 		*ppt_prev = pt_prev;
5491 	} else {
5492 drop:
5493 		if (!deliver_exact)
5494 			dev_core_stats_rx_dropped_inc(skb->dev);
5495 		else
5496 			dev_core_stats_rx_nohandler_inc(skb->dev);
5497 		kfree_skb_reason(skb, SKB_DROP_REASON_UNHANDLED_PROTO);
5498 		/* Jamal, now you will not able to escape explaining
5499 		 * me how you were going to use this. :-)
5500 		 */
5501 		ret = NET_RX_DROP;
5502 	}
5503 
5504 out:
5505 	/* The invariant here is that if *ppt_prev is not NULL
5506 	 * then skb should also be non-NULL.
5507 	 *
5508 	 * Apparently *ppt_prev assignment above holds this invariant due to
5509 	 * skb dereferencing near it.
5510 	 */
5511 	*pskb = skb;
5512 	return ret;
5513 }
5514 
5515 static int __netif_receive_skb_one_core(struct sk_buff *skb, bool pfmemalloc)
5516 {
5517 	struct net_device *orig_dev = skb->dev;
5518 	struct packet_type *pt_prev = NULL;
5519 	int ret;
5520 
5521 	ret = __netif_receive_skb_core(&skb, pfmemalloc, &pt_prev);
5522 	if (pt_prev)
5523 		ret = INDIRECT_CALL_INET(pt_prev->func, ipv6_rcv, ip_rcv, skb,
5524 					 skb->dev, pt_prev, orig_dev);
5525 	return ret;
5526 }
5527 
5528 /**
5529  *	netif_receive_skb_core - special purpose version of netif_receive_skb
5530  *	@skb: buffer to process
5531  *
5532  *	More direct receive version of netif_receive_skb().  It should
5533  *	only be used by callers that have a need to skip RPS and Generic XDP.
5534  *	Caller must also take care of handling if ``(page_is_)pfmemalloc``.
5535  *
5536  *	This function may only be called from softirq context and interrupts
5537  *	should be enabled.
5538  *
5539  *	Return values (usually ignored):
5540  *	NET_RX_SUCCESS: no congestion
5541  *	NET_RX_DROP: packet was dropped
5542  */
5543 int netif_receive_skb_core(struct sk_buff *skb)
5544 {
5545 	int ret;
5546 
5547 	rcu_read_lock();
5548 	ret = __netif_receive_skb_one_core(skb, false);
5549 	rcu_read_unlock();
5550 
5551 	return ret;
5552 }
5553 EXPORT_SYMBOL(netif_receive_skb_core);
5554 
5555 static inline void __netif_receive_skb_list_ptype(struct list_head *head,
5556 						  struct packet_type *pt_prev,
5557 						  struct net_device *orig_dev)
5558 {
5559 	struct sk_buff *skb, *next;
5560 
5561 	if (!pt_prev)
5562 		return;
5563 	if (list_empty(head))
5564 		return;
5565 	if (pt_prev->list_func != NULL)
5566 		INDIRECT_CALL_INET(pt_prev->list_func, ipv6_list_rcv,
5567 				   ip_list_rcv, head, pt_prev, orig_dev);
5568 	else
5569 		list_for_each_entry_safe(skb, next, head, list) {
5570 			skb_list_del_init(skb);
5571 			pt_prev->func(skb, skb->dev, pt_prev, orig_dev);
5572 		}
5573 }
5574 
5575 static void __netif_receive_skb_list_core(struct list_head *head, bool pfmemalloc)
5576 {
5577 	/* Fast-path assumptions:
5578 	 * - There is no RX handler.
5579 	 * - Only one packet_type matches.
5580 	 * If either of these fails, we will end up doing some per-packet
5581 	 * processing in-line, then handling the 'last ptype' for the whole
5582 	 * sublist.  This can't cause out-of-order delivery to any single ptype,
5583 	 * because the 'last ptype' must be constant across the sublist, and all
5584 	 * other ptypes are handled per-packet.
5585 	 */
5586 	/* Current (common) ptype of sublist */
5587 	struct packet_type *pt_curr = NULL;
5588 	/* Current (common) orig_dev of sublist */
5589 	struct net_device *od_curr = NULL;
5590 	struct list_head sublist;
5591 	struct sk_buff *skb, *next;
5592 
5593 	INIT_LIST_HEAD(&sublist);
5594 	list_for_each_entry_safe(skb, next, head, list) {
5595 		struct net_device *orig_dev = skb->dev;
5596 		struct packet_type *pt_prev = NULL;
5597 
5598 		skb_list_del_init(skb);
5599 		__netif_receive_skb_core(&skb, pfmemalloc, &pt_prev);
5600 		if (!pt_prev)
5601 			continue;
5602 		if (pt_curr != pt_prev || od_curr != orig_dev) {
5603 			/* dispatch old sublist */
5604 			__netif_receive_skb_list_ptype(&sublist, pt_curr, od_curr);
5605 			/* start new sublist */
5606 			INIT_LIST_HEAD(&sublist);
5607 			pt_curr = pt_prev;
5608 			od_curr = orig_dev;
5609 		}
5610 		list_add_tail(&skb->list, &sublist);
5611 	}
5612 
5613 	/* dispatch final sublist */
5614 	__netif_receive_skb_list_ptype(&sublist, pt_curr, od_curr);
5615 }
5616 
5617 static int __netif_receive_skb(struct sk_buff *skb)
5618 {
5619 	int ret;
5620 
5621 	if (sk_memalloc_socks() && skb_pfmemalloc(skb)) {
5622 		unsigned int noreclaim_flag;
5623 
5624 		/*
5625 		 * PFMEMALLOC skbs are special, they should
5626 		 * - be delivered to SOCK_MEMALLOC sockets only
5627 		 * - stay away from userspace
5628 		 * - have bounded memory usage
5629 		 *
5630 		 * Use PF_MEMALLOC as this saves us from propagating the allocation
5631 		 * context down to all allocation sites.
5632 		 */
5633 		noreclaim_flag = memalloc_noreclaim_save();
5634 		ret = __netif_receive_skb_one_core(skb, true);
5635 		memalloc_noreclaim_restore(noreclaim_flag);
5636 	} else
5637 		ret = __netif_receive_skb_one_core(skb, false);
5638 
5639 	return ret;
5640 }
5641 
5642 static void __netif_receive_skb_list(struct list_head *head)
5643 {
5644 	unsigned long noreclaim_flag = 0;
5645 	struct sk_buff *skb, *next;
5646 	bool pfmemalloc = false; /* Is current sublist PF_MEMALLOC? */
5647 
5648 	list_for_each_entry_safe(skb, next, head, list) {
5649 		if ((sk_memalloc_socks() && skb_pfmemalloc(skb)) != pfmemalloc) {
5650 			struct list_head sublist;
5651 
5652 			/* Handle the previous sublist */
5653 			list_cut_before(&sublist, head, &skb->list);
5654 			if (!list_empty(&sublist))
5655 				__netif_receive_skb_list_core(&sublist, pfmemalloc);
5656 			pfmemalloc = !pfmemalloc;
5657 			/* See comments in __netif_receive_skb */
5658 			if (pfmemalloc)
5659 				noreclaim_flag = memalloc_noreclaim_save();
5660 			else
5661 				memalloc_noreclaim_restore(noreclaim_flag);
5662 		}
5663 	}
5664 	/* Handle the remaining sublist */
5665 	if (!list_empty(head))
5666 		__netif_receive_skb_list_core(head, pfmemalloc);
5667 	/* Restore pflags */
5668 	if (pfmemalloc)
5669 		memalloc_noreclaim_restore(noreclaim_flag);
5670 }
5671 
5672 static int generic_xdp_install(struct net_device *dev, struct netdev_bpf *xdp)
5673 {
5674 	struct bpf_prog *old = rtnl_dereference(dev->xdp_prog);
5675 	struct bpf_prog *new = xdp->prog;
5676 	int ret = 0;
5677 
5678 	switch (xdp->command) {
5679 	case XDP_SETUP_PROG:
5680 		rcu_assign_pointer(dev->xdp_prog, new);
5681 		if (old)
5682 			bpf_prog_put(old);
5683 
5684 		if (old && !new) {
5685 			static_branch_dec(&generic_xdp_needed_key);
5686 		} else if (new && !old) {
5687 			static_branch_inc(&generic_xdp_needed_key);
5688 			dev_disable_lro(dev);
5689 			dev_disable_gro_hw(dev);
5690 		}
5691 		break;
5692 
5693 	default:
5694 		ret = -EINVAL;
5695 		break;
5696 	}
5697 
5698 	return ret;
5699 }
5700 
5701 static int netif_receive_skb_internal(struct sk_buff *skb)
5702 {
5703 	int ret;
5704 
5705 	net_timestamp_check(READ_ONCE(netdev_tstamp_prequeue), skb);
5706 
5707 	if (skb_defer_rx_timestamp(skb))
5708 		return NET_RX_SUCCESS;
5709 
5710 	rcu_read_lock();
5711 #ifdef CONFIG_RPS
5712 	if (static_branch_unlikely(&rps_needed)) {
5713 		struct rps_dev_flow voidflow, *rflow = &voidflow;
5714 		int cpu = get_rps_cpu(skb->dev, skb, &rflow);
5715 
5716 		if (cpu >= 0) {
5717 			ret = enqueue_to_backlog(skb, cpu, &rflow->last_qtail);
5718 			rcu_read_unlock();
5719 			return ret;
5720 		}
5721 	}
5722 #endif
5723 	ret = __netif_receive_skb(skb);
5724 	rcu_read_unlock();
5725 	return ret;
5726 }
5727 
5728 void netif_receive_skb_list_internal(struct list_head *head)
5729 {
5730 	struct sk_buff *skb, *next;
5731 	struct list_head sublist;
5732 
5733 	INIT_LIST_HEAD(&sublist);
5734 	list_for_each_entry_safe(skb, next, head, list) {
5735 		net_timestamp_check(READ_ONCE(netdev_tstamp_prequeue), skb);
5736 		skb_list_del_init(skb);
5737 		if (!skb_defer_rx_timestamp(skb))
5738 			list_add_tail(&skb->list, &sublist);
5739 	}
5740 	list_splice_init(&sublist, head);
5741 
5742 	rcu_read_lock();
5743 #ifdef CONFIG_RPS
5744 	if (static_branch_unlikely(&rps_needed)) {
5745 		list_for_each_entry_safe(skb, next, head, list) {
5746 			struct rps_dev_flow voidflow, *rflow = &voidflow;
5747 			int cpu = get_rps_cpu(skb->dev, skb, &rflow);
5748 
5749 			if (cpu >= 0) {
5750 				/* Will be handled, remove from list */
5751 				skb_list_del_init(skb);
5752 				enqueue_to_backlog(skb, cpu, &rflow->last_qtail);
5753 			}
5754 		}
5755 	}
5756 #endif
5757 	__netif_receive_skb_list(head);
5758 	rcu_read_unlock();
5759 }
5760 
5761 /**
5762  *	netif_receive_skb - process receive buffer from network
5763  *	@skb: buffer to process
5764  *
5765  *	netif_receive_skb() is the main receive data processing function.
5766  *	It always succeeds. The buffer may be dropped during processing
5767  *	for congestion control or by the protocol layers.
5768  *
5769  *	This function may only be called from softirq context and interrupts
5770  *	should be enabled.
5771  *
5772  *	Return values (usually ignored):
5773  *	NET_RX_SUCCESS: no congestion
5774  *	NET_RX_DROP: packet was dropped
5775  */
5776 int netif_receive_skb(struct sk_buff *skb)
5777 {
5778 	int ret;
5779 
5780 	trace_netif_receive_skb_entry(skb);
5781 
5782 	ret = netif_receive_skb_internal(skb);
5783 	trace_netif_receive_skb_exit(ret);
5784 
5785 	return ret;
5786 }
5787 EXPORT_SYMBOL(netif_receive_skb);
5788 
5789 /**
5790  *	netif_receive_skb_list - process many receive buffers from network
5791  *	@head: list of skbs to process.
5792  *
5793  *	Since return value of netif_receive_skb() is normally ignored, and
5794  *	wouldn't be meaningful for a list, this function returns void.
5795  *
5796  *	This function may only be called from softirq context and interrupts
5797  *	should be enabled.
5798  */
5799 void netif_receive_skb_list(struct list_head *head)
5800 {
5801 	struct sk_buff *skb;
5802 
5803 	if (list_empty(head))
5804 		return;
5805 	if (trace_netif_receive_skb_list_entry_enabled()) {
5806 		list_for_each_entry(skb, head, list)
5807 			trace_netif_receive_skb_list_entry(skb);
5808 	}
5809 	netif_receive_skb_list_internal(head);
5810 	trace_netif_receive_skb_list_exit(0);
5811 }
5812 EXPORT_SYMBOL(netif_receive_skb_list);
5813 
5814 static DEFINE_PER_CPU(struct work_struct, flush_works);
5815 
5816 /* Network device is going away, flush any packets still pending */
5817 static void flush_backlog(struct work_struct *work)
5818 {
5819 	struct sk_buff *skb, *tmp;
5820 	struct softnet_data *sd;
5821 
5822 	local_bh_disable();
5823 	sd = this_cpu_ptr(&softnet_data);
5824 
5825 	rps_lock_irq_disable(sd);
5826 	skb_queue_walk_safe(&sd->input_pkt_queue, skb, tmp) {
5827 		if (skb->dev->reg_state == NETREG_UNREGISTERING) {
5828 			__skb_unlink(skb, &sd->input_pkt_queue);
5829 			dev_kfree_skb_irq(skb);
5830 			input_queue_head_incr(sd);
5831 		}
5832 	}
5833 	rps_unlock_irq_enable(sd);
5834 
5835 	skb_queue_walk_safe(&sd->process_queue, skb, tmp) {
5836 		if (skb->dev->reg_state == NETREG_UNREGISTERING) {
5837 			__skb_unlink(skb, &sd->process_queue);
5838 			kfree_skb(skb);
5839 			input_queue_head_incr(sd);
5840 		}
5841 	}
5842 	local_bh_enable();
5843 }
5844 
5845 static bool flush_required(int cpu)
5846 {
5847 #if IS_ENABLED(CONFIG_RPS)
5848 	struct softnet_data *sd = &per_cpu(softnet_data, cpu);
5849 	bool do_flush;
5850 
5851 	rps_lock_irq_disable(sd);
5852 
5853 	/* as insertion into process_queue happens with the rps lock held,
5854 	 * process_queue access may race only with dequeue
5855 	 */
5856 	do_flush = !skb_queue_empty(&sd->input_pkt_queue) ||
5857 		   !skb_queue_empty_lockless(&sd->process_queue);
5858 	rps_unlock_irq_enable(sd);
5859 
5860 	return do_flush;
5861 #endif
5862 	/* without RPS we can't safely check input_pkt_queue: during a
5863 	 * concurrent remote skb_queue_splice() we can detect as empty both
5864 	 * input_pkt_queue and process_queue even if the latter could end-up
5865 	 * containing a lot of packets.
5866 	 */
5867 	return true;
5868 }
5869 
5870 static void flush_all_backlogs(void)
5871 {
5872 	static cpumask_t flush_cpus;
5873 	unsigned int cpu;
5874 
5875 	/* since we are under rtnl lock protection we can use static data
5876 	 * for the cpumask and avoid allocating on stack the possibly
5877 	 * large mask
5878 	 */
5879 	ASSERT_RTNL();
5880 
5881 	cpus_read_lock();
5882 
5883 	cpumask_clear(&flush_cpus);
5884 	for_each_online_cpu(cpu) {
5885 		if (flush_required(cpu)) {
5886 			queue_work_on(cpu, system_highpri_wq,
5887 				      per_cpu_ptr(&flush_works, cpu));
5888 			cpumask_set_cpu(cpu, &flush_cpus);
5889 		}
5890 	}
5891 
5892 	/* we can have in flight packet[s] on the cpus we are not flushing,
5893 	 * synchronize_net() in unregister_netdevice_many() will take care of
5894 	 * them
5895 	 */
5896 	for_each_cpu(cpu, &flush_cpus)
5897 		flush_work(per_cpu_ptr(&flush_works, cpu));
5898 
5899 	cpus_read_unlock();
5900 }
5901 
5902 static void net_rps_send_ipi(struct softnet_data *remsd)
5903 {
5904 #ifdef CONFIG_RPS
5905 	while (remsd) {
5906 		struct softnet_data *next = remsd->rps_ipi_next;
5907 
5908 		if (cpu_online(remsd->cpu))
5909 			smp_call_function_single_async(remsd->cpu, &remsd->csd);
5910 		remsd = next;
5911 	}
5912 #endif
5913 }
5914 
5915 /*
5916  * net_rps_action_and_irq_enable sends any pending IPI's for rps.
5917  * Note: called with local irq disabled, but exits with local irq enabled.
5918  */
5919 static void net_rps_action_and_irq_enable(struct softnet_data *sd)
5920 {
5921 #ifdef CONFIG_RPS
5922 	struct softnet_data *remsd = sd->rps_ipi_list;
5923 
5924 	if (remsd) {
5925 		sd->rps_ipi_list = NULL;
5926 
5927 		local_irq_enable();
5928 
5929 		/* Send pending IPI's to kick RPS processing on remote cpus. */
5930 		net_rps_send_ipi(remsd);
5931 	} else
5932 #endif
5933 		local_irq_enable();
5934 }
5935 
5936 static bool sd_has_rps_ipi_waiting(struct softnet_data *sd)
5937 {
5938 #ifdef CONFIG_RPS
5939 	return sd->rps_ipi_list != NULL;
5940 #else
5941 	return false;
5942 #endif
5943 }
5944 
5945 static int process_backlog(struct napi_struct *napi, int quota)
5946 {
5947 	struct softnet_data *sd = container_of(napi, struct softnet_data, backlog);
5948 	bool again = true;
5949 	int work = 0;
5950 
5951 	/* Check if we have pending ipi, its better to send them now,
5952 	 * not waiting net_rx_action() end.
5953 	 */
5954 	if (sd_has_rps_ipi_waiting(sd)) {
5955 		local_irq_disable();
5956 		net_rps_action_and_irq_enable(sd);
5957 	}
5958 
5959 	napi->weight = READ_ONCE(dev_rx_weight);
5960 	while (again) {
5961 		struct sk_buff *skb;
5962 
5963 		while ((skb = __skb_dequeue(&sd->process_queue))) {
5964 			rcu_read_lock();
5965 			__netif_receive_skb(skb);
5966 			rcu_read_unlock();
5967 			input_queue_head_incr(sd);
5968 			if (++work >= quota)
5969 				return work;
5970 
5971 		}
5972 
5973 		rps_lock_irq_disable(sd);
5974 		if (skb_queue_empty(&sd->input_pkt_queue)) {
5975 			/*
5976 			 * Inline a custom version of __napi_complete().
5977 			 * only current cpu owns and manipulates this napi,
5978 			 * and NAPI_STATE_SCHED is the only possible flag set
5979 			 * on backlog.
5980 			 * We can use a plain write instead of clear_bit(),
5981 			 * and we dont need an smp_mb() memory barrier.
5982 			 */
5983 			napi->state = 0;
5984 			again = false;
5985 		} else {
5986 			skb_queue_splice_tail_init(&sd->input_pkt_queue,
5987 						   &sd->process_queue);
5988 		}
5989 		rps_unlock_irq_enable(sd);
5990 	}
5991 
5992 	return work;
5993 }
5994 
5995 /**
5996  * __napi_schedule - schedule for receive
5997  * @n: entry to schedule
5998  *
5999  * The entry's receive function will be scheduled to run.
6000  * Consider using __napi_schedule_irqoff() if hard irqs are masked.
6001  */
6002 void __napi_schedule(struct napi_struct *n)
6003 {
6004 	unsigned long flags;
6005 
6006 	local_irq_save(flags);
6007 	____napi_schedule(this_cpu_ptr(&softnet_data), n);
6008 	local_irq_restore(flags);
6009 }
6010 EXPORT_SYMBOL(__napi_schedule);
6011 
6012 /**
6013  *	napi_schedule_prep - check if napi can be scheduled
6014  *	@n: napi context
6015  *
6016  * Test if NAPI routine is already running, and if not mark
6017  * it as running.  This is used as a condition variable to
6018  * insure only one NAPI poll instance runs.  We also make
6019  * sure there is no pending NAPI disable.
6020  */
6021 bool napi_schedule_prep(struct napi_struct *n)
6022 {
6023 	unsigned long new, val = READ_ONCE(n->state);
6024 
6025 	do {
6026 		if (unlikely(val & NAPIF_STATE_DISABLE))
6027 			return false;
6028 		new = val | NAPIF_STATE_SCHED;
6029 
6030 		/* Sets STATE_MISSED bit if STATE_SCHED was already set
6031 		 * This was suggested by Alexander Duyck, as compiler
6032 		 * emits better code than :
6033 		 * if (val & NAPIF_STATE_SCHED)
6034 		 *     new |= NAPIF_STATE_MISSED;
6035 		 */
6036 		new |= (val & NAPIF_STATE_SCHED) / NAPIF_STATE_SCHED *
6037 						   NAPIF_STATE_MISSED;
6038 	} while (!try_cmpxchg(&n->state, &val, new));
6039 
6040 	return !(val & NAPIF_STATE_SCHED);
6041 }
6042 EXPORT_SYMBOL(napi_schedule_prep);
6043 
6044 /**
6045  * __napi_schedule_irqoff - schedule for receive
6046  * @n: entry to schedule
6047  *
6048  * Variant of __napi_schedule() assuming hard irqs are masked.
6049  *
6050  * On PREEMPT_RT enabled kernels this maps to __napi_schedule()
6051  * because the interrupt disabled assumption might not be true
6052  * due to force-threaded interrupts and spinlock substitution.
6053  */
6054 void __napi_schedule_irqoff(struct napi_struct *n)
6055 {
6056 	if (!IS_ENABLED(CONFIG_PREEMPT_RT))
6057 		____napi_schedule(this_cpu_ptr(&softnet_data), n);
6058 	else
6059 		__napi_schedule(n);
6060 }
6061 EXPORT_SYMBOL(__napi_schedule_irqoff);
6062 
6063 bool napi_complete_done(struct napi_struct *n, int work_done)
6064 {
6065 	unsigned long flags, val, new, timeout = 0;
6066 	bool ret = true;
6067 
6068 	/*
6069 	 * 1) Don't let napi dequeue from the cpu poll list
6070 	 *    just in case its running on a different cpu.
6071 	 * 2) If we are busy polling, do nothing here, we have
6072 	 *    the guarantee we will be called later.
6073 	 */
6074 	if (unlikely(n->state & (NAPIF_STATE_NPSVC |
6075 				 NAPIF_STATE_IN_BUSY_POLL)))
6076 		return false;
6077 
6078 	if (work_done) {
6079 		if (n->gro_bitmask)
6080 			timeout = READ_ONCE(n->dev->gro_flush_timeout);
6081 		n->defer_hard_irqs_count = READ_ONCE(n->dev->napi_defer_hard_irqs);
6082 	}
6083 	if (n->defer_hard_irqs_count > 0) {
6084 		n->defer_hard_irqs_count--;
6085 		timeout = READ_ONCE(n->dev->gro_flush_timeout);
6086 		if (timeout)
6087 			ret = false;
6088 	}
6089 	if (n->gro_bitmask) {
6090 		/* When the NAPI instance uses a timeout and keeps postponing
6091 		 * it, we need to bound somehow the time packets are kept in
6092 		 * the GRO layer
6093 		 */
6094 		napi_gro_flush(n, !!timeout);
6095 	}
6096 
6097 	gro_normal_list(n);
6098 
6099 	if (unlikely(!list_empty(&n->poll_list))) {
6100 		/* If n->poll_list is not empty, we need to mask irqs */
6101 		local_irq_save(flags);
6102 		list_del_init(&n->poll_list);
6103 		local_irq_restore(flags);
6104 	}
6105 	WRITE_ONCE(n->list_owner, -1);
6106 
6107 	val = READ_ONCE(n->state);
6108 	do {
6109 		WARN_ON_ONCE(!(val & NAPIF_STATE_SCHED));
6110 
6111 		new = val & ~(NAPIF_STATE_MISSED | NAPIF_STATE_SCHED |
6112 			      NAPIF_STATE_SCHED_THREADED |
6113 			      NAPIF_STATE_PREFER_BUSY_POLL);
6114 
6115 		/* If STATE_MISSED was set, leave STATE_SCHED set,
6116 		 * because we will call napi->poll() one more time.
6117 		 * This C code was suggested by Alexander Duyck to help gcc.
6118 		 */
6119 		new |= (val & NAPIF_STATE_MISSED) / NAPIF_STATE_MISSED *
6120 						    NAPIF_STATE_SCHED;
6121 	} while (!try_cmpxchg(&n->state, &val, new));
6122 
6123 	if (unlikely(val & NAPIF_STATE_MISSED)) {
6124 		__napi_schedule(n);
6125 		return false;
6126 	}
6127 
6128 	if (timeout)
6129 		hrtimer_start(&n->timer, ns_to_ktime(timeout),
6130 			      HRTIMER_MODE_REL_PINNED);
6131 	return ret;
6132 }
6133 EXPORT_SYMBOL(napi_complete_done);
6134 
6135 /* must be called under rcu_read_lock(), as we dont take a reference */
6136 static struct napi_struct *napi_by_id(unsigned int napi_id)
6137 {
6138 	unsigned int hash = napi_id % HASH_SIZE(napi_hash);
6139 	struct napi_struct *napi;
6140 
6141 	hlist_for_each_entry_rcu(napi, &napi_hash[hash], napi_hash_node)
6142 		if (napi->napi_id == napi_id)
6143 			return napi;
6144 
6145 	return NULL;
6146 }
6147 
6148 #if defined(CONFIG_NET_RX_BUSY_POLL)
6149 
6150 static void __busy_poll_stop(struct napi_struct *napi, bool skip_schedule)
6151 {
6152 	if (!skip_schedule) {
6153 		gro_normal_list(napi);
6154 		__napi_schedule(napi);
6155 		return;
6156 	}
6157 
6158 	if (napi->gro_bitmask) {
6159 		/* flush too old packets
6160 		 * If HZ < 1000, flush all packets.
6161 		 */
6162 		napi_gro_flush(napi, HZ >= 1000);
6163 	}
6164 
6165 	gro_normal_list(napi);
6166 	clear_bit(NAPI_STATE_SCHED, &napi->state);
6167 }
6168 
6169 static void busy_poll_stop(struct napi_struct *napi, void *have_poll_lock, bool prefer_busy_poll,
6170 			   u16 budget)
6171 {
6172 	bool skip_schedule = false;
6173 	unsigned long timeout;
6174 	int rc;
6175 
6176 	/* Busy polling means there is a high chance device driver hard irq
6177 	 * could not grab NAPI_STATE_SCHED, and that NAPI_STATE_MISSED was
6178 	 * set in napi_schedule_prep().
6179 	 * Since we are about to call napi->poll() once more, we can safely
6180 	 * clear NAPI_STATE_MISSED.
6181 	 *
6182 	 * Note: x86 could use a single "lock and ..." instruction
6183 	 * to perform these two clear_bit()
6184 	 */
6185 	clear_bit(NAPI_STATE_MISSED, &napi->state);
6186 	clear_bit(NAPI_STATE_IN_BUSY_POLL, &napi->state);
6187 
6188 	local_bh_disable();
6189 
6190 	if (prefer_busy_poll) {
6191 		napi->defer_hard_irqs_count = READ_ONCE(napi->dev->napi_defer_hard_irqs);
6192 		timeout = READ_ONCE(napi->dev->gro_flush_timeout);
6193 		if (napi->defer_hard_irqs_count && timeout) {
6194 			hrtimer_start(&napi->timer, ns_to_ktime(timeout), HRTIMER_MODE_REL_PINNED);
6195 			skip_schedule = true;
6196 		}
6197 	}
6198 
6199 	/* All we really want here is to re-enable device interrupts.
6200 	 * Ideally, a new ndo_busy_poll_stop() could avoid another round.
6201 	 */
6202 	rc = napi->poll(napi, budget);
6203 	/* We can't gro_normal_list() here, because napi->poll() might have
6204 	 * rearmed the napi (napi_complete_done()) in which case it could
6205 	 * already be running on another CPU.
6206 	 */
6207 	trace_napi_poll(napi, rc, budget);
6208 	netpoll_poll_unlock(have_poll_lock);
6209 	if (rc == budget)
6210 		__busy_poll_stop(napi, skip_schedule);
6211 	local_bh_enable();
6212 }
6213 
6214 void napi_busy_loop(unsigned int napi_id,
6215 		    bool (*loop_end)(void *, unsigned long),
6216 		    void *loop_end_arg, bool prefer_busy_poll, u16 budget)
6217 {
6218 	unsigned long start_time = loop_end ? busy_loop_current_time() : 0;
6219 	int (*napi_poll)(struct napi_struct *napi, int budget);
6220 	void *have_poll_lock = NULL;
6221 	struct napi_struct *napi;
6222 
6223 restart:
6224 	napi_poll = NULL;
6225 
6226 	rcu_read_lock();
6227 
6228 	napi = napi_by_id(napi_id);
6229 	if (!napi)
6230 		goto out;
6231 
6232 	if (!IS_ENABLED(CONFIG_PREEMPT_RT))
6233 		preempt_disable();
6234 	for (;;) {
6235 		int work = 0;
6236 
6237 		local_bh_disable();
6238 		if (!napi_poll) {
6239 			unsigned long val = READ_ONCE(napi->state);
6240 
6241 			/* If multiple threads are competing for this napi,
6242 			 * we avoid dirtying napi->state as much as we can.
6243 			 */
6244 			if (val & (NAPIF_STATE_DISABLE | NAPIF_STATE_SCHED |
6245 				   NAPIF_STATE_IN_BUSY_POLL)) {
6246 				if (prefer_busy_poll)
6247 					set_bit(NAPI_STATE_PREFER_BUSY_POLL, &napi->state);
6248 				goto count;
6249 			}
6250 			if (cmpxchg(&napi->state, val,
6251 				    val | NAPIF_STATE_IN_BUSY_POLL |
6252 					  NAPIF_STATE_SCHED) != val) {
6253 				if (prefer_busy_poll)
6254 					set_bit(NAPI_STATE_PREFER_BUSY_POLL, &napi->state);
6255 				goto count;
6256 			}
6257 			have_poll_lock = netpoll_poll_lock(napi);
6258 			napi_poll = napi->poll;
6259 		}
6260 		work = napi_poll(napi, budget);
6261 		trace_napi_poll(napi, work, budget);
6262 		gro_normal_list(napi);
6263 count:
6264 		if (work > 0)
6265 			__NET_ADD_STATS(dev_net(napi->dev),
6266 					LINUX_MIB_BUSYPOLLRXPACKETS, work);
6267 		local_bh_enable();
6268 
6269 		if (!loop_end || loop_end(loop_end_arg, start_time))
6270 			break;
6271 
6272 		if (unlikely(need_resched())) {
6273 			if (napi_poll)
6274 				busy_poll_stop(napi, have_poll_lock, prefer_busy_poll, budget);
6275 			if (!IS_ENABLED(CONFIG_PREEMPT_RT))
6276 				preempt_enable();
6277 			rcu_read_unlock();
6278 			cond_resched();
6279 			if (loop_end(loop_end_arg, start_time))
6280 				return;
6281 			goto restart;
6282 		}
6283 		cpu_relax();
6284 	}
6285 	if (napi_poll)
6286 		busy_poll_stop(napi, have_poll_lock, prefer_busy_poll, budget);
6287 	if (!IS_ENABLED(CONFIG_PREEMPT_RT))
6288 		preempt_enable();
6289 out:
6290 	rcu_read_unlock();
6291 }
6292 EXPORT_SYMBOL(napi_busy_loop);
6293 
6294 #endif /* CONFIG_NET_RX_BUSY_POLL */
6295 
6296 static void napi_hash_add(struct napi_struct *napi)
6297 {
6298 	if (test_bit(NAPI_STATE_NO_BUSY_POLL, &napi->state))
6299 		return;
6300 
6301 	spin_lock(&napi_hash_lock);
6302 
6303 	/* 0..NR_CPUS range is reserved for sender_cpu use */
6304 	do {
6305 		if (unlikely(++napi_gen_id < MIN_NAPI_ID))
6306 			napi_gen_id = MIN_NAPI_ID;
6307 	} while (napi_by_id(napi_gen_id));
6308 	napi->napi_id = napi_gen_id;
6309 
6310 	hlist_add_head_rcu(&napi->napi_hash_node,
6311 			   &napi_hash[napi->napi_id % HASH_SIZE(napi_hash)]);
6312 
6313 	spin_unlock(&napi_hash_lock);
6314 }
6315 
6316 /* Warning : caller is responsible to make sure rcu grace period
6317  * is respected before freeing memory containing @napi
6318  */
6319 static void napi_hash_del(struct napi_struct *napi)
6320 {
6321 	spin_lock(&napi_hash_lock);
6322 
6323 	hlist_del_init_rcu(&napi->napi_hash_node);
6324 
6325 	spin_unlock(&napi_hash_lock);
6326 }
6327 
6328 static enum hrtimer_restart napi_watchdog(struct hrtimer *timer)
6329 {
6330 	struct napi_struct *napi;
6331 
6332 	napi = container_of(timer, struct napi_struct, timer);
6333 
6334 	/* Note : we use a relaxed variant of napi_schedule_prep() not setting
6335 	 * NAPI_STATE_MISSED, since we do not react to a device IRQ.
6336 	 */
6337 	if (!napi_disable_pending(napi) &&
6338 	    !test_and_set_bit(NAPI_STATE_SCHED, &napi->state)) {
6339 		clear_bit(NAPI_STATE_PREFER_BUSY_POLL, &napi->state);
6340 		__napi_schedule_irqoff(napi);
6341 	}
6342 
6343 	return HRTIMER_NORESTART;
6344 }
6345 
6346 static void init_gro_hash(struct napi_struct *napi)
6347 {
6348 	int i;
6349 
6350 	for (i = 0; i < GRO_HASH_BUCKETS; i++) {
6351 		INIT_LIST_HEAD(&napi->gro_hash[i].list);
6352 		napi->gro_hash[i].count = 0;
6353 	}
6354 	napi->gro_bitmask = 0;
6355 }
6356 
6357 int dev_set_threaded(struct net_device *dev, bool threaded)
6358 {
6359 	struct napi_struct *napi;
6360 	int err = 0;
6361 
6362 	if (dev->threaded == threaded)
6363 		return 0;
6364 
6365 	if (threaded) {
6366 		list_for_each_entry(napi, &dev->napi_list, dev_list) {
6367 			if (!napi->thread) {
6368 				err = napi_kthread_create(napi);
6369 				if (err) {
6370 					threaded = false;
6371 					break;
6372 				}
6373 			}
6374 		}
6375 	}
6376 
6377 	dev->threaded = threaded;
6378 
6379 	/* Make sure kthread is created before THREADED bit
6380 	 * is set.
6381 	 */
6382 	smp_mb__before_atomic();
6383 
6384 	/* Setting/unsetting threaded mode on a napi might not immediately
6385 	 * take effect, if the current napi instance is actively being
6386 	 * polled. In this case, the switch between threaded mode and
6387 	 * softirq mode will happen in the next round of napi_schedule().
6388 	 * This should not cause hiccups/stalls to the live traffic.
6389 	 */
6390 	list_for_each_entry(napi, &dev->napi_list, dev_list)
6391 		assign_bit(NAPI_STATE_THREADED, &napi->state, threaded);
6392 
6393 	return err;
6394 }
6395 EXPORT_SYMBOL(dev_set_threaded);
6396 
6397 void netif_napi_add_weight(struct net_device *dev, struct napi_struct *napi,
6398 			   int (*poll)(struct napi_struct *, int), int weight)
6399 {
6400 	if (WARN_ON(test_and_set_bit(NAPI_STATE_LISTED, &napi->state)))
6401 		return;
6402 
6403 	INIT_LIST_HEAD(&napi->poll_list);
6404 	INIT_HLIST_NODE(&napi->napi_hash_node);
6405 	hrtimer_init(&napi->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL_PINNED);
6406 	napi->timer.function = napi_watchdog;
6407 	init_gro_hash(napi);
6408 	napi->skb = NULL;
6409 	INIT_LIST_HEAD(&napi->rx_list);
6410 	napi->rx_count = 0;
6411 	napi->poll = poll;
6412 	if (weight > NAPI_POLL_WEIGHT)
6413 		netdev_err_once(dev, "%s() called with weight %d\n", __func__,
6414 				weight);
6415 	napi->weight = weight;
6416 	napi->dev = dev;
6417 #ifdef CONFIG_NETPOLL
6418 	napi->poll_owner = -1;
6419 #endif
6420 	napi->list_owner = -1;
6421 	set_bit(NAPI_STATE_SCHED, &napi->state);
6422 	set_bit(NAPI_STATE_NPSVC, &napi->state);
6423 	list_add_rcu(&napi->dev_list, &dev->napi_list);
6424 	napi_hash_add(napi);
6425 	napi_get_frags_check(napi);
6426 	/* Create kthread for this napi if dev->threaded is set.
6427 	 * Clear dev->threaded if kthread creation failed so that
6428 	 * threaded mode will not be enabled in napi_enable().
6429 	 */
6430 	if (dev->threaded && napi_kthread_create(napi))
6431 		dev->threaded = 0;
6432 }
6433 EXPORT_SYMBOL(netif_napi_add_weight);
6434 
6435 void napi_disable(struct napi_struct *n)
6436 {
6437 	unsigned long val, new;
6438 
6439 	might_sleep();
6440 	set_bit(NAPI_STATE_DISABLE, &n->state);
6441 
6442 	val = READ_ONCE(n->state);
6443 	do {
6444 		while (val & (NAPIF_STATE_SCHED | NAPIF_STATE_NPSVC)) {
6445 			usleep_range(20, 200);
6446 			val = READ_ONCE(n->state);
6447 		}
6448 
6449 		new = val | NAPIF_STATE_SCHED | NAPIF_STATE_NPSVC;
6450 		new &= ~(NAPIF_STATE_THREADED | NAPIF_STATE_PREFER_BUSY_POLL);
6451 	} while (!try_cmpxchg(&n->state, &val, new));
6452 
6453 	hrtimer_cancel(&n->timer);
6454 
6455 	clear_bit(NAPI_STATE_DISABLE, &n->state);
6456 }
6457 EXPORT_SYMBOL(napi_disable);
6458 
6459 /**
6460  *	napi_enable - enable NAPI scheduling
6461  *	@n: NAPI context
6462  *
6463  * Resume NAPI from being scheduled on this context.
6464  * Must be paired with napi_disable.
6465  */
6466 void napi_enable(struct napi_struct *n)
6467 {
6468 	unsigned long new, val = READ_ONCE(n->state);
6469 
6470 	do {
6471 		BUG_ON(!test_bit(NAPI_STATE_SCHED, &val));
6472 
6473 		new = val & ~(NAPIF_STATE_SCHED | NAPIF_STATE_NPSVC);
6474 		if (n->dev->threaded && n->thread)
6475 			new |= NAPIF_STATE_THREADED;
6476 	} while (!try_cmpxchg(&n->state, &val, new));
6477 }
6478 EXPORT_SYMBOL(napi_enable);
6479 
6480 static void flush_gro_hash(struct napi_struct *napi)
6481 {
6482 	int i;
6483 
6484 	for (i = 0; i < GRO_HASH_BUCKETS; i++) {
6485 		struct sk_buff *skb, *n;
6486 
6487 		list_for_each_entry_safe(skb, n, &napi->gro_hash[i].list, list)
6488 			kfree_skb(skb);
6489 		napi->gro_hash[i].count = 0;
6490 	}
6491 }
6492 
6493 /* Must be called in process context */
6494 void __netif_napi_del(struct napi_struct *napi)
6495 {
6496 	if (!test_and_clear_bit(NAPI_STATE_LISTED, &napi->state))
6497 		return;
6498 
6499 	napi_hash_del(napi);
6500 	list_del_rcu(&napi->dev_list);
6501 	napi_free_frags(napi);
6502 
6503 	flush_gro_hash(napi);
6504 	napi->gro_bitmask = 0;
6505 
6506 	if (napi->thread) {
6507 		kthread_stop(napi->thread);
6508 		napi->thread = NULL;
6509 	}
6510 }
6511 EXPORT_SYMBOL(__netif_napi_del);
6512 
6513 static int __napi_poll(struct napi_struct *n, bool *repoll)
6514 {
6515 	int work, weight;
6516 
6517 	weight = n->weight;
6518 
6519 	/* This NAPI_STATE_SCHED test is for avoiding a race
6520 	 * with netpoll's poll_napi().  Only the entity which
6521 	 * obtains the lock and sees NAPI_STATE_SCHED set will
6522 	 * actually make the ->poll() call.  Therefore we avoid
6523 	 * accidentally calling ->poll() when NAPI is not scheduled.
6524 	 */
6525 	work = 0;
6526 	if (test_bit(NAPI_STATE_SCHED, &n->state)) {
6527 		work = n->poll(n, weight);
6528 		trace_napi_poll(n, work, weight);
6529 	}
6530 
6531 	if (unlikely(work > weight))
6532 		netdev_err_once(n->dev, "NAPI poll function %pS returned %d, exceeding its budget of %d.\n",
6533 				n->poll, work, weight);
6534 
6535 	if (likely(work < weight))
6536 		return work;
6537 
6538 	/* Drivers must not modify the NAPI state if they
6539 	 * consume the entire weight.  In such cases this code
6540 	 * still "owns" the NAPI instance and therefore can
6541 	 * move the instance around on the list at-will.
6542 	 */
6543 	if (unlikely(napi_disable_pending(n))) {
6544 		napi_complete(n);
6545 		return work;
6546 	}
6547 
6548 	/* The NAPI context has more processing work, but busy-polling
6549 	 * is preferred. Exit early.
6550 	 */
6551 	if (napi_prefer_busy_poll(n)) {
6552 		if (napi_complete_done(n, work)) {
6553 			/* If timeout is not set, we need to make sure
6554 			 * that the NAPI is re-scheduled.
6555 			 */
6556 			napi_schedule(n);
6557 		}
6558 		return work;
6559 	}
6560 
6561 	if (n->gro_bitmask) {
6562 		/* flush too old packets
6563 		 * If HZ < 1000, flush all packets.
6564 		 */
6565 		napi_gro_flush(n, HZ >= 1000);
6566 	}
6567 
6568 	gro_normal_list(n);
6569 
6570 	/* Some drivers may have called napi_schedule
6571 	 * prior to exhausting their budget.
6572 	 */
6573 	if (unlikely(!list_empty(&n->poll_list))) {
6574 		pr_warn_once("%s: Budget exhausted after napi rescheduled\n",
6575 			     n->dev ? n->dev->name : "backlog");
6576 		return work;
6577 	}
6578 
6579 	*repoll = true;
6580 
6581 	return work;
6582 }
6583 
6584 static int napi_poll(struct napi_struct *n, struct list_head *repoll)
6585 {
6586 	bool do_repoll = false;
6587 	void *have;
6588 	int work;
6589 
6590 	list_del_init(&n->poll_list);
6591 
6592 	have = netpoll_poll_lock(n);
6593 
6594 	work = __napi_poll(n, &do_repoll);
6595 
6596 	if (do_repoll)
6597 		list_add_tail(&n->poll_list, repoll);
6598 
6599 	netpoll_poll_unlock(have);
6600 
6601 	return work;
6602 }
6603 
6604 static int napi_thread_wait(struct napi_struct *napi)
6605 {
6606 	bool woken = false;
6607 
6608 	set_current_state(TASK_INTERRUPTIBLE);
6609 
6610 	while (!kthread_should_stop()) {
6611 		/* Testing SCHED_THREADED bit here to make sure the current
6612 		 * kthread owns this napi and could poll on this napi.
6613 		 * Testing SCHED bit is not enough because SCHED bit might be
6614 		 * set by some other busy poll thread or by napi_disable().
6615 		 */
6616 		if (test_bit(NAPI_STATE_SCHED_THREADED, &napi->state) || woken) {
6617 			WARN_ON(!list_empty(&napi->poll_list));
6618 			__set_current_state(TASK_RUNNING);
6619 			return 0;
6620 		}
6621 
6622 		schedule();
6623 		/* woken being true indicates this thread owns this napi. */
6624 		woken = true;
6625 		set_current_state(TASK_INTERRUPTIBLE);
6626 	}
6627 	__set_current_state(TASK_RUNNING);
6628 
6629 	return -1;
6630 }
6631 
6632 static void skb_defer_free_flush(struct softnet_data *sd)
6633 {
6634 	struct sk_buff *skb, *next;
6635 
6636 	/* Paired with WRITE_ONCE() in skb_attempt_defer_free() */
6637 	if (!READ_ONCE(sd->defer_list))
6638 		return;
6639 
6640 	spin_lock(&sd->defer_lock);
6641 	skb = sd->defer_list;
6642 	sd->defer_list = NULL;
6643 	sd->defer_count = 0;
6644 	spin_unlock(&sd->defer_lock);
6645 
6646 	while (skb != NULL) {
6647 		next = skb->next;
6648 		napi_consume_skb(skb, 1);
6649 		skb = next;
6650 	}
6651 }
6652 
6653 static int napi_threaded_poll(void *data)
6654 {
6655 	struct napi_struct *napi = data;
6656 	struct softnet_data *sd;
6657 	void *have;
6658 
6659 	while (!napi_thread_wait(napi)) {
6660 		for (;;) {
6661 			bool repoll = false;
6662 
6663 			local_bh_disable();
6664 			sd = this_cpu_ptr(&softnet_data);
6665 			sd->in_napi_threaded_poll = true;
6666 
6667 			have = netpoll_poll_lock(napi);
6668 			__napi_poll(napi, &repoll);
6669 			netpoll_poll_unlock(have);
6670 
6671 			sd->in_napi_threaded_poll = false;
6672 			barrier();
6673 
6674 			if (sd_has_rps_ipi_waiting(sd)) {
6675 				local_irq_disable();
6676 				net_rps_action_and_irq_enable(sd);
6677 			}
6678 			skb_defer_free_flush(sd);
6679 			local_bh_enable();
6680 
6681 			if (!repoll)
6682 				break;
6683 
6684 			cond_resched();
6685 		}
6686 	}
6687 	return 0;
6688 }
6689 
6690 static __latent_entropy void net_rx_action(struct softirq_action *h)
6691 {
6692 	struct softnet_data *sd = this_cpu_ptr(&softnet_data);
6693 	unsigned long time_limit = jiffies +
6694 		usecs_to_jiffies(READ_ONCE(netdev_budget_usecs));
6695 	int budget = READ_ONCE(netdev_budget);
6696 	LIST_HEAD(list);
6697 	LIST_HEAD(repoll);
6698 
6699 start:
6700 	sd->in_net_rx_action = true;
6701 	local_irq_disable();
6702 	list_splice_init(&sd->poll_list, &list);
6703 	local_irq_enable();
6704 
6705 	for (;;) {
6706 		struct napi_struct *n;
6707 
6708 		skb_defer_free_flush(sd);
6709 
6710 		if (list_empty(&list)) {
6711 			if (list_empty(&repoll)) {
6712 				sd->in_net_rx_action = false;
6713 				barrier();
6714 				/* We need to check if ____napi_schedule()
6715 				 * had refilled poll_list while
6716 				 * sd->in_net_rx_action was true.
6717 				 */
6718 				if (!list_empty(&sd->poll_list))
6719 					goto start;
6720 				if (!sd_has_rps_ipi_waiting(sd))
6721 					goto end;
6722 			}
6723 			break;
6724 		}
6725 
6726 		n = list_first_entry(&list, struct napi_struct, poll_list);
6727 		budget -= napi_poll(n, &repoll);
6728 
6729 		/* If softirq window is exhausted then punt.
6730 		 * Allow this to run for 2 jiffies since which will allow
6731 		 * an average latency of 1.5/HZ.
6732 		 */
6733 		if (unlikely(budget <= 0 ||
6734 			     time_after_eq(jiffies, time_limit))) {
6735 			sd->time_squeeze++;
6736 			break;
6737 		}
6738 	}
6739 
6740 	local_irq_disable();
6741 
6742 	list_splice_tail_init(&sd->poll_list, &list);
6743 	list_splice_tail(&repoll, &list);
6744 	list_splice(&list, &sd->poll_list);
6745 	if (!list_empty(&sd->poll_list))
6746 		__raise_softirq_irqoff(NET_RX_SOFTIRQ);
6747 	else
6748 		sd->in_net_rx_action = false;
6749 
6750 	net_rps_action_and_irq_enable(sd);
6751 end:;
6752 }
6753 
6754 struct netdev_adjacent {
6755 	struct net_device *dev;
6756 	netdevice_tracker dev_tracker;
6757 
6758 	/* upper master flag, there can only be one master device per list */
6759 	bool master;
6760 
6761 	/* lookup ignore flag */
6762 	bool ignore;
6763 
6764 	/* counter for the number of times this device was added to us */
6765 	u16 ref_nr;
6766 
6767 	/* private field for the users */
6768 	void *private;
6769 
6770 	struct list_head list;
6771 	struct rcu_head rcu;
6772 };
6773 
6774 static struct netdev_adjacent *__netdev_find_adj(struct net_device *adj_dev,
6775 						 struct list_head *adj_list)
6776 {
6777 	struct netdev_adjacent *adj;
6778 
6779 	list_for_each_entry(adj, adj_list, list) {
6780 		if (adj->dev == adj_dev)
6781 			return adj;
6782 	}
6783 	return NULL;
6784 }
6785 
6786 static int ____netdev_has_upper_dev(struct net_device *upper_dev,
6787 				    struct netdev_nested_priv *priv)
6788 {
6789 	struct net_device *dev = (struct net_device *)priv->data;
6790 
6791 	return upper_dev == dev;
6792 }
6793 
6794 /**
6795  * netdev_has_upper_dev - Check if device is linked to an upper device
6796  * @dev: device
6797  * @upper_dev: upper device to check
6798  *
6799  * Find out if a device is linked to specified upper device and return true
6800  * in case it is. Note that this checks only immediate upper device,
6801  * not through a complete stack of devices. The caller must hold the RTNL lock.
6802  */
6803 bool netdev_has_upper_dev(struct net_device *dev,
6804 			  struct net_device *upper_dev)
6805 {
6806 	struct netdev_nested_priv priv = {
6807 		.data = (void *)upper_dev,
6808 	};
6809 
6810 	ASSERT_RTNL();
6811 
6812 	return netdev_walk_all_upper_dev_rcu(dev, ____netdev_has_upper_dev,
6813 					     &priv);
6814 }
6815 EXPORT_SYMBOL(netdev_has_upper_dev);
6816 
6817 /**
6818  * netdev_has_upper_dev_all_rcu - Check if device is linked to an upper device
6819  * @dev: device
6820  * @upper_dev: upper device to check
6821  *
6822  * Find out if a device is linked to specified upper device and return true
6823  * in case it is. Note that this checks the entire upper device chain.
6824  * The caller must hold rcu lock.
6825  */
6826 
6827 bool netdev_has_upper_dev_all_rcu(struct net_device *dev,
6828 				  struct net_device *upper_dev)
6829 {
6830 	struct netdev_nested_priv priv = {
6831 		.data = (void *)upper_dev,
6832 	};
6833 
6834 	return !!netdev_walk_all_upper_dev_rcu(dev, ____netdev_has_upper_dev,
6835 					       &priv);
6836 }
6837 EXPORT_SYMBOL(netdev_has_upper_dev_all_rcu);
6838 
6839 /**
6840  * netdev_has_any_upper_dev - Check if device is linked to some device
6841  * @dev: device
6842  *
6843  * Find out if a device is linked to an upper device and return true in case
6844  * it is. The caller must hold the RTNL lock.
6845  */
6846 bool netdev_has_any_upper_dev(struct net_device *dev)
6847 {
6848 	ASSERT_RTNL();
6849 
6850 	return !list_empty(&dev->adj_list.upper);
6851 }
6852 EXPORT_SYMBOL(netdev_has_any_upper_dev);
6853 
6854 /**
6855  * netdev_master_upper_dev_get - Get master upper device
6856  * @dev: device
6857  *
6858  * Find a master upper device and return pointer to it or NULL in case
6859  * it's not there. The caller must hold the RTNL lock.
6860  */
6861 struct net_device *netdev_master_upper_dev_get(struct net_device *dev)
6862 {
6863 	struct netdev_adjacent *upper;
6864 
6865 	ASSERT_RTNL();
6866 
6867 	if (list_empty(&dev->adj_list.upper))
6868 		return NULL;
6869 
6870 	upper = list_first_entry(&dev->adj_list.upper,
6871 				 struct netdev_adjacent, list);
6872 	if (likely(upper->master))
6873 		return upper->dev;
6874 	return NULL;
6875 }
6876 EXPORT_SYMBOL(netdev_master_upper_dev_get);
6877 
6878 static struct net_device *__netdev_master_upper_dev_get(struct net_device *dev)
6879 {
6880 	struct netdev_adjacent *upper;
6881 
6882 	ASSERT_RTNL();
6883 
6884 	if (list_empty(&dev->adj_list.upper))
6885 		return NULL;
6886 
6887 	upper = list_first_entry(&dev->adj_list.upper,
6888 				 struct netdev_adjacent, list);
6889 	if (likely(upper->master) && !upper->ignore)
6890 		return upper->dev;
6891 	return NULL;
6892 }
6893 
6894 /**
6895  * netdev_has_any_lower_dev - Check if device is linked to some device
6896  * @dev: device
6897  *
6898  * Find out if a device is linked to a lower device and return true in case
6899  * it is. The caller must hold the RTNL lock.
6900  */
6901 static bool netdev_has_any_lower_dev(struct net_device *dev)
6902 {
6903 	ASSERT_RTNL();
6904 
6905 	return !list_empty(&dev->adj_list.lower);
6906 }
6907 
6908 void *netdev_adjacent_get_private(struct list_head *adj_list)
6909 {
6910 	struct netdev_adjacent *adj;
6911 
6912 	adj = list_entry(adj_list, struct netdev_adjacent, list);
6913 
6914 	return adj->private;
6915 }
6916 EXPORT_SYMBOL(netdev_adjacent_get_private);
6917 
6918 /**
6919  * netdev_upper_get_next_dev_rcu - Get the next dev from upper list
6920  * @dev: device
6921  * @iter: list_head ** of the current position
6922  *
6923  * Gets the next device from the dev's upper list, starting from iter
6924  * position. The caller must hold RCU read lock.
6925  */
6926 struct net_device *netdev_upper_get_next_dev_rcu(struct net_device *dev,
6927 						 struct list_head **iter)
6928 {
6929 	struct netdev_adjacent *upper;
6930 
6931 	WARN_ON_ONCE(!rcu_read_lock_held() && !lockdep_rtnl_is_held());
6932 
6933 	upper = list_entry_rcu((*iter)->next, struct netdev_adjacent, list);
6934 
6935 	if (&upper->list == &dev->adj_list.upper)
6936 		return NULL;
6937 
6938 	*iter = &upper->list;
6939 
6940 	return upper->dev;
6941 }
6942 EXPORT_SYMBOL(netdev_upper_get_next_dev_rcu);
6943 
6944 static struct net_device *__netdev_next_upper_dev(struct net_device *dev,
6945 						  struct list_head **iter,
6946 						  bool *ignore)
6947 {
6948 	struct netdev_adjacent *upper;
6949 
6950 	upper = list_entry((*iter)->next, struct netdev_adjacent, list);
6951 
6952 	if (&upper->list == &dev->adj_list.upper)
6953 		return NULL;
6954 
6955 	*iter = &upper->list;
6956 	*ignore = upper->ignore;
6957 
6958 	return upper->dev;
6959 }
6960 
6961 static struct net_device *netdev_next_upper_dev_rcu(struct net_device *dev,
6962 						    struct list_head **iter)
6963 {
6964 	struct netdev_adjacent *upper;
6965 
6966 	WARN_ON_ONCE(!rcu_read_lock_held() && !lockdep_rtnl_is_held());
6967 
6968 	upper = list_entry_rcu((*iter)->next, struct netdev_adjacent, list);
6969 
6970 	if (&upper->list == &dev->adj_list.upper)
6971 		return NULL;
6972 
6973 	*iter = &upper->list;
6974 
6975 	return upper->dev;
6976 }
6977 
6978 static int __netdev_walk_all_upper_dev(struct net_device *dev,
6979 				       int (*fn)(struct net_device *dev,
6980 					 struct netdev_nested_priv *priv),
6981 				       struct netdev_nested_priv *priv)
6982 {
6983 	struct net_device *udev, *next, *now, *dev_stack[MAX_NEST_DEV + 1];
6984 	struct list_head *niter, *iter, *iter_stack[MAX_NEST_DEV + 1];
6985 	int ret, cur = 0;
6986 	bool ignore;
6987 
6988 	now = dev;
6989 	iter = &dev->adj_list.upper;
6990 
6991 	while (1) {
6992 		if (now != dev) {
6993 			ret = fn(now, priv);
6994 			if (ret)
6995 				return ret;
6996 		}
6997 
6998 		next = NULL;
6999 		while (1) {
7000 			udev = __netdev_next_upper_dev(now, &iter, &ignore);
7001 			if (!udev)
7002 				break;
7003 			if (ignore)
7004 				continue;
7005 
7006 			next = udev;
7007 			niter = &udev->adj_list.upper;
7008 			dev_stack[cur] = now;
7009 			iter_stack[cur++] = iter;
7010 			break;
7011 		}
7012 
7013 		if (!next) {
7014 			if (!cur)
7015 				return 0;
7016 			next = dev_stack[--cur];
7017 			niter = iter_stack[cur];
7018 		}
7019 
7020 		now = next;
7021 		iter = niter;
7022 	}
7023 
7024 	return 0;
7025 }
7026 
7027 int netdev_walk_all_upper_dev_rcu(struct net_device *dev,
7028 				  int (*fn)(struct net_device *dev,
7029 					    struct netdev_nested_priv *priv),
7030 				  struct netdev_nested_priv *priv)
7031 {
7032 	struct net_device *udev, *next, *now, *dev_stack[MAX_NEST_DEV + 1];
7033 	struct list_head *niter, *iter, *iter_stack[MAX_NEST_DEV + 1];
7034 	int ret, cur = 0;
7035 
7036 	now = dev;
7037 	iter = &dev->adj_list.upper;
7038 
7039 	while (1) {
7040 		if (now != dev) {
7041 			ret = fn(now, priv);
7042 			if (ret)
7043 				return ret;
7044 		}
7045 
7046 		next = NULL;
7047 		while (1) {
7048 			udev = netdev_next_upper_dev_rcu(now, &iter);
7049 			if (!udev)
7050 				break;
7051 
7052 			next = udev;
7053 			niter = &udev->adj_list.upper;
7054 			dev_stack[cur] = now;
7055 			iter_stack[cur++] = iter;
7056 			break;
7057 		}
7058 
7059 		if (!next) {
7060 			if (!cur)
7061 				return 0;
7062 			next = dev_stack[--cur];
7063 			niter = iter_stack[cur];
7064 		}
7065 
7066 		now = next;
7067 		iter = niter;
7068 	}
7069 
7070 	return 0;
7071 }
7072 EXPORT_SYMBOL_GPL(netdev_walk_all_upper_dev_rcu);
7073 
7074 static bool __netdev_has_upper_dev(struct net_device *dev,
7075 				   struct net_device *upper_dev)
7076 {
7077 	struct netdev_nested_priv priv = {
7078 		.flags = 0,
7079 		.data = (void *)upper_dev,
7080 	};
7081 
7082 	ASSERT_RTNL();
7083 
7084 	return __netdev_walk_all_upper_dev(dev, ____netdev_has_upper_dev,
7085 					   &priv);
7086 }
7087 
7088 /**
7089  * netdev_lower_get_next_private - Get the next ->private from the
7090  *				   lower neighbour list
7091  * @dev: device
7092  * @iter: list_head ** of the current position
7093  *
7094  * Gets the next netdev_adjacent->private from the dev's lower neighbour
7095  * list, starting from iter position. The caller must hold either hold the
7096  * RTNL lock or its own locking that guarantees that the neighbour lower
7097  * list will remain unchanged.
7098  */
7099 void *netdev_lower_get_next_private(struct net_device *dev,
7100 				    struct list_head **iter)
7101 {
7102 	struct netdev_adjacent *lower;
7103 
7104 	lower = list_entry(*iter, struct netdev_adjacent, list);
7105 
7106 	if (&lower->list == &dev->adj_list.lower)
7107 		return NULL;
7108 
7109 	*iter = lower->list.next;
7110 
7111 	return lower->private;
7112 }
7113 EXPORT_SYMBOL(netdev_lower_get_next_private);
7114 
7115 /**
7116  * netdev_lower_get_next_private_rcu - Get the next ->private from the
7117  *				       lower neighbour list, RCU
7118  *				       variant
7119  * @dev: device
7120  * @iter: list_head ** of the current position
7121  *
7122  * Gets the next netdev_adjacent->private from the dev's lower neighbour
7123  * list, starting from iter position. The caller must hold RCU read lock.
7124  */
7125 void *netdev_lower_get_next_private_rcu(struct net_device *dev,
7126 					struct list_head **iter)
7127 {
7128 	struct netdev_adjacent *lower;
7129 
7130 	WARN_ON_ONCE(!rcu_read_lock_held() && !rcu_read_lock_bh_held());
7131 
7132 	lower = list_entry_rcu((*iter)->next, struct netdev_adjacent, list);
7133 
7134 	if (&lower->list == &dev->adj_list.lower)
7135 		return NULL;
7136 
7137 	*iter = &lower->list;
7138 
7139 	return lower->private;
7140 }
7141 EXPORT_SYMBOL(netdev_lower_get_next_private_rcu);
7142 
7143 /**
7144  * netdev_lower_get_next - Get the next device from the lower neighbour
7145  *                         list
7146  * @dev: device
7147  * @iter: list_head ** of the current position
7148  *
7149  * Gets the next netdev_adjacent from the dev's lower neighbour
7150  * list, starting from iter position. The caller must hold RTNL lock or
7151  * its own locking that guarantees that the neighbour lower
7152  * list will remain unchanged.
7153  */
7154 void *netdev_lower_get_next(struct net_device *dev, struct list_head **iter)
7155 {
7156 	struct netdev_adjacent *lower;
7157 
7158 	lower = list_entry(*iter, struct netdev_adjacent, list);
7159 
7160 	if (&lower->list == &dev->adj_list.lower)
7161 		return NULL;
7162 
7163 	*iter = lower->list.next;
7164 
7165 	return lower->dev;
7166 }
7167 EXPORT_SYMBOL(netdev_lower_get_next);
7168 
7169 static struct net_device *netdev_next_lower_dev(struct net_device *dev,
7170 						struct list_head **iter)
7171 {
7172 	struct netdev_adjacent *lower;
7173 
7174 	lower = list_entry((*iter)->next, struct netdev_adjacent, list);
7175 
7176 	if (&lower->list == &dev->adj_list.lower)
7177 		return NULL;
7178 
7179 	*iter = &lower->list;
7180 
7181 	return lower->dev;
7182 }
7183 
7184 static struct net_device *__netdev_next_lower_dev(struct net_device *dev,
7185 						  struct list_head **iter,
7186 						  bool *ignore)
7187 {
7188 	struct netdev_adjacent *lower;
7189 
7190 	lower = list_entry((*iter)->next, struct netdev_adjacent, list);
7191 
7192 	if (&lower->list == &dev->adj_list.lower)
7193 		return NULL;
7194 
7195 	*iter = &lower->list;
7196 	*ignore = lower->ignore;
7197 
7198 	return lower->dev;
7199 }
7200 
7201 int netdev_walk_all_lower_dev(struct net_device *dev,
7202 			      int (*fn)(struct net_device *dev,
7203 					struct netdev_nested_priv *priv),
7204 			      struct netdev_nested_priv *priv)
7205 {
7206 	struct net_device *ldev, *next, *now, *dev_stack[MAX_NEST_DEV + 1];
7207 	struct list_head *niter, *iter, *iter_stack[MAX_NEST_DEV + 1];
7208 	int ret, cur = 0;
7209 
7210 	now = dev;
7211 	iter = &dev->adj_list.lower;
7212 
7213 	while (1) {
7214 		if (now != dev) {
7215 			ret = fn(now, priv);
7216 			if (ret)
7217 				return ret;
7218 		}
7219 
7220 		next = NULL;
7221 		while (1) {
7222 			ldev = netdev_next_lower_dev(now, &iter);
7223 			if (!ldev)
7224 				break;
7225 
7226 			next = ldev;
7227 			niter = &ldev->adj_list.lower;
7228 			dev_stack[cur] = now;
7229 			iter_stack[cur++] = iter;
7230 			break;
7231 		}
7232 
7233 		if (!next) {
7234 			if (!cur)
7235 				return 0;
7236 			next = dev_stack[--cur];
7237 			niter = iter_stack[cur];
7238 		}
7239 
7240 		now = next;
7241 		iter = niter;
7242 	}
7243 
7244 	return 0;
7245 }
7246 EXPORT_SYMBOL_GPL(netdev_walk_all_lower_dev);
7247 
7248 static int __netdev_walk_all_lower_dev(struct net_device *dev,
7249 				       int (*fn)(struct net_device *dev,
7250 					 struct netdev_nested_priv *priv),
7251 				       struct netdev_nested_priv *priv)
7252 {
7253 	struct net_device *ldev, *next, *now, *dev_stack[MAX_NEST_DEV + 1];
7254 	struct list_head *niter, *iter, *iter_stack[MAX_NEST_DEV + 1];
7255 	int ret, cur = 0;
7256 	bool ignore;
7257 
7258 	now = dev;
7259 	iter = &dev->adj_list.lower;
7260 
7261 	while (1) {
7262 		if (now != dev) {
7263 			ret = fn(now, priv);
7264 			if (ret)
7265 				return ret;
7266 		}
7267 
7268 		next = NULL;
7269 		while (1) {
7270 			ldev = __netdev_next_lower_dev(now, &iter, &ignore);
7271 			if (!ldev)
7272 				break;
7273 			if (ignore)
7274 				continue;
7275 
7276 			next = ldev;
7277 			niter = &ldev->adj_list.lower;
7278 			dev_stack[cur] = now;
7279 			iter_stack[cur++] = iter;
7280 			break;
7281 		}
7282 
7283 		if (!next) {
7284 			if (!cur)
7285 				return 0;
7286 			next = dev_stack[--cur];
7287 			niter = iter_stack[cur];
7288 		}
7289 
7290 		now = next;
7291 		iter = niter;
7292 	}
7293 
7294 	return 0;
7295 }
7296 
7297 struct net_device *netdev_next_lower_dev_rcu(struct net_device *dev,
7298 					     struct list_head **iter)
7299 {
7300 	struct netdev_adjacent *lower;
7301 
7302 	lower = list_entry_rcu((*iter)->next, struct netdev_adjacent, list);
7303 	if (&lower->list == &dev->adj_list.lower)
7304 		return NULL;
7305 
7306 	*iter = &lower->list;
7307 
7308 	return lower->dev;
7309 }
7310 EXPORT_SYMBOL(netdev_next_lower_dev_rcu);
7311 
7312 static u8 __netdev_upper_depth(struct net_device *dev)
7313 {
7314 	struct net_device *udev;
7315 	struct list_head *iter;
7316 	u8 max_depth = 0;
7317 	bool ignore;
7318 
7319 	for (iter = &dev->adj_list.upper,
7320 	     udev = __netdev_next_upper_dev(dev, &iter, &ignore);
7321 	     udev;
7322 	     udev = __netdev_next_upper_dev(dev, &iter, &ignore)) {
7323 		if (ignore)
7324 			continue;
7325 		if (max_depth < udev->upper_level)
7326 			max_depth = udev->upper_level;
7327 	}
7328 
7329 	return max_depth;
7330 }
7331 
7332 static u8 __netdev_lower_depth(struct net_device *dev)
7333 {
7334 	struct net_device *ldev;
7335 	struct list_head *iter;
7336 	u8 max_depth = 0;
7337 	bool ignore;
7338 
7339 	for (iter = &dev->adj_list.lower,
7340 	     ldev = __netdev_next_lower_dev(dev, &iter, &ignore);
7341 	     ldev;
7342 	     ldev = __netdev_next_lower_dev(dev, &iter, &ignore)) {
7343 		if (ignore)
7344 			continue;
7345 		if (max_depth < ldev->lower_level)
7346 			max_depth = ldev->lower_level;
7347 	}
7348 
7349 	return max_depth;
7350 }
7351 
7352 static int __netdev_update_upper_level(struct net_device *dev,
7353 				       struct netdev_nested_priv *__unused)
7354 {
7355 	dev->upper_level = __netdev_upper_depth(dev) + 1;
7356 	return 0;
7357 }
7358 
7359 #ifdef CONFIG_LOCKDEP
7360 static LIST_HEAD(net_unlink_list);
7361 
7362 static void net_unlink_todo(struct net_device *dev)
7363 {
7364 	if (list_empty(&dev->unlink_list))
7365 		list_add_tail(&dev->unlink_list, &net_unlink_list);
7366 }
7367 #endif
7368 
7369 static int __netdev_update_lower_level(struct net_device *dev,
7370 				       struct netdev_nested_priv *priv)
7371 {
7372 	dev->lower_level = __netdev_lower_depth(dev) + 1;
7373 
7374 #ifdef CONFIG_LOCKDEP
7375 	if (!priv)
7376 		return 0;
7377 
7378 	if (priv->flags & NESTED_SYNC_IMM)
7379 		dev->nested_level = dev->lower_level - 1;
7380 	if (priv->flags & NESTED_SYNC_TODO)
7381 		net_unlink_todo(dev);
7382 #endif
7383 	return 0;
7384 }
7385 
7386 int netdev_walk_all_lower_dev_rcu(struct net_device *dev,
7387 				  int (*fn)(struct net_device *dev,
7388 					    struct netdev_nested_priv *priv),
7389 				  struct netdev_nested_priv *priv)
7390 {
7391 	struct net_device *ldev, *next, *now, *dev_stack[MAX_NEST_DEV + 1];
7392 	struct list_head *niter, *iter, *iter_stack[MAX_NEST_DEV + 1];
7393 	int ret, cur = 0;
7394 
7395 	now = dev;
7396 	iter = &dev->adj_list.lower;
7397 
7398 	while (1) {
7399 		if (now != dev) {
7400 			ret = fn(now, priv);
7401 			if (ret)
7402 				return ret;
7403 		}
7404 
7405 		next = NULL;
7406 		while (1) {
7407 			ldev = netdev_next_lower_dev_rcu(now, &iter);
7408 			if (!ldev)
7409 				break;
7410 
7411 			next = ldev;
7412 			niter = &ldev->adj_list.lower;
7413 			dev_stack[cur] = now;
7414 			iter_stack[cur++] = iter;
7415 			break;
7416 		}
7417 
7418 		if (!next) {
7419 			if (!cur)
7420 				return 0;
7421 			next = dev_stack[--cur];
7422 			niter = iter_stack[cur];
7423 		}
7424 
7425 		now = next;
7426 		iter = niter;
7427 	}
7428 
7429 	return 0;
7430 }
7431 EXPORT_SYMBOL_GPL(netdev_walk_all_lower_dev_rcu);
7432 
7433 /**
7434  * netdev_lower_get_first_private_rcu - Get the first ->private from the
7435  *				       lower neighbour list, RCU
7436  *				       variant
7437  * @dev: device
7438  *
7439  * Gets the first netdev_adjacent->private from the dev's lower neighbour
7440  * list. The caller must hold RCU read lock.
7441  */
7442 void *netdev_lower_get_first_private_rcu(struct net_device *dev)
7443 {
7444 	struct netdev_adjacent *lower;
7445 
7446 	lower = list_first_or_null_rcu(&dev->adj_list.lower,
7447 			struct netdev_adjacent, list);
7448 	if (lower)
7449 		return lower->private;
7450 	return NULL;
7451 }
7452 EXPORT_SYMBOL(netdev_lower_get_first_private_rcu);
7453 
7454 /**
7455  * netdev_master_upper_dev_get_rcu - Get master upper device
7456  * @dev: device
7457  *
7458  * Find a master upper device and return pointer to it or NULL in case
7459  * it's not there. The caller must hold the RCU read lock.
7460  */
7461 struct net_device *netdev_master_upper_dev_get_rcu(struct net_device *dev)
7462 {
7463 	struct netdev_adjacent *upper;
7464 
7465 	upper = list_first_or_null_rcu(&dev->adj_list.upper,
7466 				       struct netdev_adjacent, list);
7467 	if (upper && likely(upper->master))
7468 		return upper->dev;
7469 	return NULL;
7470 }
7471 EXPORT_SYMBOL(netdev_master_upper_dev_get_rcu);
7472 
7473 static int netdev_adjacent_sysfs_add(struct net_device *dev,
7474 			      struct net_device *adj_dev,
7475 			      struct list_head *dev_list)
7476 {
7477 	char linkname[IFNAMSIZ+7];
7478 
7479 	sprintf(linkname, dev_list == &dev->adj_list.upper ?
7480 		"upper_%s" : "lower_%s", adj_dev->name);
7481 	return sysfs_create_link(&(dev->dev.kobj), &(adj_dev->dev.kobj),
7482 				 linkname);
7483 }
7484 static void netdev_adjacent_sysfs_del(struct net_device *dev,
7485 			       char *name,
7486 			       struct list_head *dev_list)
7487 {
7488 	char linkname[IFNAMSIZ+7];
7489 
7490 	sprintf(linkname, dev_list == &dev->adj_list.upper ?
7491 		"upper_%s" : "lower_%s", name);
7492 	sysfs_remove_link(&(dev->dev.kobj), linkname);
7493 }
7494 
7495 static inline bool netdev_adjacent_is_neigh_list(struct net_device *dev,
7496 						 struct net_device *adj_dev,
7497 						 struct list_head *dev_list)
7498 {
7499 	return (dev_list == &dev->adj_list.upper ||
7500 		dev_list == &dev->adj_list.lower) &&
7501 		net_eq(dev_net(dev), dev_net(adj_dev));
7502 }
7503 
7504 static int __netdev_adjacent_dev_insert(struct net_device *dev,
7505 					struct net_device *adj_dev,
7506 					struct list_head *dev_list,
7507 					void *private, bool master)
7508 {
7509 	struct netdev_adjacent *adj;
7510 	int ret;
7511 
7512 	adj = __netdev_find_adj(adj_dev, dev_list);
7513 
7514 	if (adj) {
7515 		adj->ref_nr += 1;
7516 		pr_debug("Insert adjacency: dev %s adj_dev %s adj->ref_nr %d\n",
7517 			 dev->name, adj_dev->name, adj->ref_nr);
7518 
7519 		return 0;
7520 	}
7521 
7522 	adj = kmalloc(sizeof(*adj), GFP_KERNEL);
7523 	if (!adj)
7524 		return -ENOMEM;
7525 
7526 	adj->dev = adj_dev;
7527 	adj->master = master;
7528 	adj->ref_nr = 1;
7529 	adj->private = private;
7530 	adj->ignore = false;
7531 	netdev_hold(adj_dev, &adj->dev_tracker, GFP_KERNEL);
7532 
7533 	pr_debug("Insert adjacency: dev %s adj_dev %s adj->ref_nr %d; dev_hold on %s\n",
7534 		 dev->name, adj_dev->name, adj->ref_nr, adj_dev->name);
7535 
7536 	if (netdev_adjacent_is_neigh_list(dev, adj_dev, dev_list)) {
7537 		ret = netdev_adjacent_sysfs_add(dev, adj_dev, dev_list);
7538 		if (ret)
7539 			goto free_adj;
7540 	}
7541 
7542 	/* Ensure that master link is always the first item in list. */
7543 	if (master) {
7544 		ret = sysfs_create_link(&(dev->dev.kobj),
7545 					&(adj_dev->dev.kobj), "master");
7546 		if (ret)
7547 			goto remove_symlinks;
7548 
7549 		list_add_rcu(&adj->list, dev_list);
7550 	} else {
7551 		list_add_tail_rcu(&adj->list, dev_list);
7552 	}
7553 
7554 	return 0;
7555 
7556 remove_symlinks:
7557 	if (netdev_adjacent_is_neigh_list(dev, adj_dev, dev_list))
7558 		netdev_adjacent_sysfs_del(dev, adj_dev->name, dev_list);
7559 free_adj:
7560 	netdev_put(adj_dev, &adj->dev_tracker);
7561 	kfree(adj);
7562 
7563 	return ret;
7564 }
7565 
7566 static void __netdev_adjacent_dev_remove(struct net_device *dev,
7567 					 struct net_device *adj_dev,
7568 					 u16 ref_nr,
7569 					 struct list_head *dev_list)
7570 {
7571 	struct netdev_adjacent *adj;
7572 
7573 	pr_debug("Remove adjacency: dev %s adj_dev %s ref_nr %d\n",
7574 		 dev->name, adj_dev->name, ref_nr);
7575 
7576 	adj = __netdev_find_adj(adj_dev, dev_list);
7577 
7578 	if (!adj) {
7579 		pr_err("Adjacency does not exist for device %s from %s\n",
7580 		       dev->name, adj_dev->name);
7581 		WARN_ON(1);
7582 		return;
7583 	}
7584 
7585 	if (adj->ref_nr > ref_nr) {
7586 		pr_debug("adjacency: %s to %s ref_nr - %d = %d\n",
7587 			 dev->name, adj_dev->name, ref_nr,
7588 			 adj->ref_nr - ref_nr);
7589 		adj->ref_nr -= ref_nr;
7590 		return;
7591 	}
7592 
7593 	if (adj->master)
7594 		sysfs_remove_link(&(dev->dev.kobj), "master");
7595 
7596 	if (netdev_adjacent_is_neigh_list(dev, adj_dev, dev_list))
7597 		netdev_adjacent_sysfs_del(dev, adj_dev->name, dev_list);
7598 
7599 	list_del_rcu(&adj->list);
7600 	pr_debug("adjacency: dev_put for %s, because link removed from %s to %s\n",
7601 		 adj_dev->name, dev->name, adj_dev->name);
7602 	netdev_put(adj_dev, &adj->dev_tracker);
7603 	kfree_rcu(adj, rcu);
7604 }
7605 
7606 static int __netdev_adjacent_dev_link_lists(struct net_device *dev,
7607 					    struct net_device *upper_dev,
7608 					    struct list_head *up_list,
7609 					    struct list_head *down_list,
7610 					    void *private, bool master)
7611 {
7612 	int ret;
7613 
7614 	ret = __netdev_adjacent_dev_insert(dev, upper_dev, up_list,
7615 					   private, master);
7616 	if (ret)
7617 		return ret;
7618 
7619 	ret = __netdev_adjacent_dev_insert(upper_dev, dev, down_list,
7620 					   private, false);
7621 	if (ret) {
7622 		__netdev_adjacent_dev_remove(dev, upper_dev, 1, up_list);
7623 		return ret;
7624 	}
7625 
7626 	return 0;
7627 }
7628 
7629 static void __netdev_adjacent_dev_unlink_lists(struct net_device *dev,
7630 					       struct net_device *upper_dev,
7631 					       u16 ref_nr,
7632 					       struct list_head *up_list,
7633 					       struct list_head *down_list)
7634 {
7635 	__netdev_adjacent_dev_remove(dev, upper_dev, ref_nr, up_list);
7636 	__netdev_adjacent_dev_remove(upper_dev, dev, ref_nr, down_list);
7637 }
7638 
7639 static int __netdev_adjacent_dev_link_neighbour(struct net_device *dev,
7640 						struct net_device *upper_dev,
7641 						void *private, bool master)
7642 {
7643 	return __netdev_adjacent_dev_link_lists(dev, upper_dev,
7644 						&dev->adj_list.upper,
7645 						&upper_dev->adj_list.lower,
7646 						private, master);
7647 }
7648 
7649 static void __netdev_adjacent_dev_unlink_neighbour(struct net_device *dev,
7650 						   struct net_device *upper_dev)
7651 {
7652 	__netdev_adjacent_dev_unlink_lists(dev, upper_dev, 1,
7653 					   &dev->adj_list.upper,
7654 					   &upper_dev->adj_list.lower);
7655 }
7656 
7657 static int __netdev_upper_dev_link(struct net_device *dev,
7658 				   struct net_device *upper_dev, bool master,
7659 				   void *upper_priv, void *upper_info,
7660 				   struct netdev_nested_priv *priv,
7661 				   struct netlink_ext_ack *extack)
7662 {
7663 	struct netdev_notifier_changeupper_info changeupper_info = {
7664 		.info = {
7665 			.dev = dev,
7666 			.extack = extack,
7667 		},
7668 		.upper_dev = upper_dev,
7669 		.master = master,
7670 		.linking = true,
7671 		.upper_info = upper_info,
7672 	};
7673 	struct net_device *master_dev;
7674 	int ret = 0;
7675 
7676 	ASSERT_RTNL();
7677 
7678 	if (dev == upper_dev)
7679 		return -EBUSY;
7680 
7681 	/* To prevent loops, check if dev is not upper device to upper_dev. */
7682 	if (__netdev_has_upper_dev(upper_dev, dev))
7683 		return -EBUSY;
7684 
7685 	if ((dev->lower_level + upper_dev->upper_level) > MAX_NEST_DEV)
7686 		return -EMLINK;
7687 
7688 	if (!master) {
7689 		if (__netdev_has_upper_dev(dev, upper_dev))
7690 			return -EEXIST;
7691 	} else {
7692 		master_dev = __netdev_master_upper_dev_get(dev);
7693 		if (master_dev)
7694 			return master_dev == upper_dev ? -EEXIST : -EBUSY;
7695 	}
7696 
7697 	ret = call_netdevice_notifiers_info(NETDEV_PRECHANGEUPPER,
7698 					    &changeupper_info.info);
7699 	ret = notifier_to_errno(ret);
7700 	if (ret)
7701 		return ret;
7702 
7703 	ret = __netdev_adjacent_dev_link_neighbour(dev, upper_dev, upper_priv,
7704 						   master);
7705 	if (ret)
7706 		return ret;
7707 
7708 	ret = call_netdevice_notifiers_info(NETDEV_CHANGEUPPER,
7709 					    &changeupper_info.info);
7710 	ret = notifier_to_errno(ret);
7711 	if (ret)
7712 		goto rollback;
7713 
7714 	__netdev_update_upper_level(dev, NULL);
7715 	__netdev_walk_all_lower_dev(dev, __netdev_update_upper_level, NULL);
7716 
7717 	__netdev_update_lower_level(upper_dev, priv);
7718 	__netdev_walk_all_upper_dev(upper_dev, __netdev_update_lower_level,
7719 				    priv);
7720 
7721 	return 0;
7722 
7723 rollback:
7724 	__netdev_adjacent_dev_unlink_neighbour(dev, upper_dev);
7725 
7726 	return ret;
7727 }
7728 
7729 /**
7730  * netdev_upper_dev_link - Add a link to the upper device
7731  * @dev: device
7732  * @upper_dev: new upper device
7733  * @extack: netlink extended ack
7734  *
7735  * Adds a link to device which is upper to this one. The caller must hold
7736  * the RTNL lock. On a failure a negative errno code is returned.
7737  * On success the reference counts are adjusted and the function
7738  * returns zero.
7739  */
7740 int netdev_upper_dev_link(struct net_device *dev,
7741 			  struct net_device *upper_dev,
7742 			  struct netlink_ext_ack *extack)
7743 {
7744 	struct netdev_nested_priv priv = {
7745 		.flags = NESTED_SYNC_IMM | NESTED_SYNC_TODO,
7746 		.data = NULL,
7747 	};
7748 
7749 	return __netdev_upper_dev_link(dev, upper_dev, false,
7750 				       NULL, NULL, &priv, extack);
7751 }
7752 EXPORT_SYMBOL(netdev_upper_dev_link);
7753 
7754 /**
7755  * netdev_master_upper_dev_link - Add a master link to the upper device
7756  * @dev: device
7757  * @upper_dev: new upper device
7758  * @upper_priv: upper device private
7759  * @upper_info: upper info to be passed down via notifier
7760  * @extack: netlink extended ack
7761  *
7762  * Adds a link to device which is upper to this one. In this case, only
7763  * one master upper device can be linked, although other non-master devices
7764  * might be linked as well. The caller must hold the RTNL lock.
7765  * On a failure a negative errno code is returned. On success the reference
7766  * counts are adjusted and the function returns zero.
7767  */
7768 int netdev_master_upper_dev_link(struct net_device *dev,
7769 				 struct net_device *upper_dev,
7770 				 void *upper_priv, void *upper_info,
7771 				 struct netlink_ext_ack *extack)
7772 {
7773 	struct netdev_nested_priv priv = {
7774 		.flags = NESTED_SYNC_IMM | NESTED_SYNC_TODO,
7775 		.data = NULL,
7776 	};
7777 
7778 	return __netdev_upper_dev_link(dev, upper_dev, true,
7779 				       upper_priv, upper_info, &priv, extack);
7780 }
7781 EXPORT_SYMBOL(netdev_master_upper_dev_link);
7782 
7783 static void __netdev_upper_dev_unlink(struct net_device *dev,
7784 				      struct net_device *upper_dev,
7785 				      struct netdev_nested_priv *priv)
7786 {
7787 	struct netdev_notifier_changeupper_info changeupper_info = {
7788 		.info = {
7789 			.dev = dev,
7790 		},
7791 		.upper_dev = upper_dev,
7792 		.linking = false,
7793 	};
7794 
7795 	ASSERT_RTNL();
7796 
7797 	changeupper_info.master = netdev_master_upper_dev_get(dev) == upper_dev;
7798 
7799 	call_netdevice_notifiers_info(NETDEV_PRECHANGEUPPER,
7800 				      &changeupper_info.info);
7801 
7802 	__netdev_adjacent_dev_unlink_neighbour(dev, upper_dev);
7803 
7804 	call_netdevice_notifiers_info(NETDEV_CHANGEUPPER,
7805 				      &changeupper_info.info);
7806 
7807 	__netdev_update_upper_level(dev, NULL);
7808 	__netdev_walk_all_lower_dev(dev, __netdev_update_upper_level, NULL);
7809 
7810 	__netdev_update_lower_level(upper_dev, priv);
7811 	__netdev_walk_all_upper_dev(upper_dev, __netdev_update_lower_level,
7812 				    priv);
7813 }
7814 
7815 /**
7816  * netdev_upper_dev_unlink - Removes a link to upper device
7817  * @dev: device
7818  * @upper_dev: new upper device
7819  *
7820  * Removes a link to device which is upper to this one. The caller must hold
7821  * the RTNL lock.
7822  */
7823 void netdev_upper_dev_unlink(struct net_device *dev,
7824 			     struct net_device *upper_dev)
7825 {
7826 	struct netdev_nested_priv priv = {
7827 		.flags = NESTED_SYNC_TODO,
7828 		.data = NULL,
7829 	};
7830 
7831 	__netdev_upper_dev_unlink(dev, upper_dev, &priv);
7832 }
7833 EXPORT_SYMBOL(netdev_upper_dev_unlink);
7834 
7835 static void __netdev_adjacent_dev_set(struct net_device *upper_dev,
7836 				      struct net_device *lower_dev,
7837 				      bool val)
7838 {
7839 	struct netdev_adjacent *adj;
7840 
7841 	adj = __netdev_find_adj(lower_dev, &upper_dev->adj_list.lower);
7842 	if (adj)
7843 		adj->ignore = val;
7844 
7845 	adj = __netdev_find_adj(upper_dev, &lower_dev->adj_list.upper);
7846 	if (adj)
7847 		adj->ignore = val;
7848 }
7849 
7850 static void netdev_adjacent_dev_disable(struct net_device *upper_dev,
7851 					struct net_device *lower_dev)
7852 {
7853 	__netdev_adjacent_dev_set(upper_dev, lower_dev, true);
7854 }
7855 
7856 static void netdev_adjacent_dev_enable(struct net_device *upper_dev,
7857 				       struct net_device *lower_dev)
7858 {
7859 	__netdev_adjacent_dev_set(upper_dev, lower_dev, false);
7860 }
7861 
7862 int netdev_adjacent_change_prepare(struct net_device *old_dev,
7863 				   struct net_device *new_dev,
7864 				   struct net_device *dev,
7865 				   struct netlink_ext_ack *extack)
7866 {
7867 	struct netdev_nested_priv priv = {
7868 		.flags = 0,
7869 		.data = NULL,
7870 	};
7871 	int err;
7872 
7873 	if (!new_dev)
7874 		return 0;
7875 
7876 	if (old_dev && new_dev != old_dev)
7877 		netdev_adjacent_dev_disable(dev, old_dev);
7878 	err = __netdev_upper_dev_link(new_dev, dev, false, NULL, NULL, &priv,
7879 				      extack);
7880 	if (err) {
7881 		if (old_dev && new_dev != old_dev)
7882 			netdev_adjacent_dev_enable(dev, old_dev);
7883 		return err;
7884 	}
7885 
7886 	return 0;
7887 }
7888 EXPORT_SYMBOL(netdev_adjacent_change_prepare);
7889 
7890 void netdev_adjacent_change_commit(struct net_device *old_dev,
7891 				   struct net_device *new_dev,
7892 				   struct net_device *dev)
7893 {
7894 	struct netdev_nested_priv priv = {
7895 		.flags = NESTED_SYNC_IMM | NESTED_SYNC_TODO,
7896 		.data = NULL,
7897 	};
7898 
7899 	if (!new_dev || !old_dev)
7900 		return;
7901 
7902 	if (new_dev == old_dev)
7903 		return;
7904 
7905 	netdev_adjacent_dev_enable(dev, old_dev);
7906 	__netdev_upper_dev_unlink(old_dev, dev, &priv);
7907 }
7908 EXPORT_SYMBOL(netdev_adjacent_change_commit);
7909 
7910 void netdev_adjacent_change_abort(struct net_device *old_dev,
7911 				  struct net_device *new_dev,
7912 				  struct net_device *dev)
7913 {
7914 	struct netdev_nested_priv priv = {
7915 		.flags = 0,
7916 		.data = NULL,
7917 	};
7918 
7919 	if (!new_dev)
7920 		return;
7921 
7922 	if (old_dev && new_dev != old_dev)
7923 		netdev_adjacent_dev_enable(dev, old_dev);
7924 
7925 	__netdev_upper_dev_unlink(new_dev, dev, &priv);
7926 }
7927 EXPORT_SYMBOL(netdev_adjacent_change_abort);
7928 
7929 /**
7930  * netdev_bonding_info_change - Dispatch event about slave change
7931  * @dev: device
7932  * @bonding_info: info to dispatch
7933  *
7934  * Send NETDEV_BONDING_INFO to netdev notifiers with info.
7935  * The caller must hold the RTNL lock.
7936  */
7937 void netdev_bonding_info_change(struct net_device *dev,
7938 				struct netdev_bonding_info *bonding_info)
7939 {
7940 	struct netdev_notifier_bonding_info info = {
7941 		.info.dev = dev,
7942 	};
7943 
7944 	memcpy(&info.bonding_info, bonding_info,
7945 	       sizeof(struct netdev_bonding_info));
7946 	call_netdevice_notifiers_info(NETDEV_BONDING_INFO,
7947 				      &info.info);
7948 }
7949 EXPORT_SYMBOL(netdev_bonding_info_change);
7950 
7951 static int netdev_offload_xstats_enable_l3(struct net_device *dev,
7952 					   struct netlink_ext_ack *extack)
7953 {
7954 	struct netdev_notifier_offload_xstats_info info = {
7955 		.info.dev = dev,
7956 		.info.extack = extack,
7957 		.type = NETDEV_OFFLOAD_XSTATS_TYPE_L3,
7958 	};
7959 	int err;
7960 	int rc;
7961 
7962 	dev->offload_xstats_l3 = kzalloc(sizeof(*dev->offload_xstats_l3),
7963 					 GFP_KERNEL);
7964 	if (!dev->offload_xstats_l3)
7965 		return -ENOMEM;
7966 
7967 	rc = call_netdevice_notifiers_info_robust(NETDEV_OFFLOAD_XSTATS_ENABLE,
7968 						  NETDEV_OFFLOAD_XSTATS_DISABLE,
7969 						  &info.info);
7970 	err = notifier_to_errno(rc);
7971 	if (err)
7972 		goto free_stats;
7973 
7974 	return 0;
7975 
7976 free_stats:
7977 	kfree(dev->offload_xstats_l3);
7978 	dev->offload_xstats_l3 = NULL;
7979 	return err;
7980 }
7981 
7982 int netdev_offload_xstats_enable(struct net_device *dev,
7983 				 enum netdev_offload_xstats_type type,
7984 				 struct netlink_ext_ack *extack)
7985 {
7986 	ASSERT_RTNL();
7987 
7988 	if (netdev_offload_xstats_enabled(dev, type))
7989 		return -EALREADY;
7990 
7991 	switch (type) {
7992 	case NETDEV_OFFLOAD_XSTATS_TYPE_L3:
7993 		return netdev_offload_xstats_enable_l3(dev, extack);
7994 	}
7995 
7996 	WARN_ON(1);
7997 	return -EINVAL;
7998 }
7999 EXPORT_SYMBOL(netdev_offload_xstats_enable);
8000 
8001 static void netdev_offload_xstats_disable_l3(struct net_device *dev)
8002 {
8003 	struct netdev_notifier_offload_xstats_info info = {
8004 		.info.dev = dev,
8005 		.type = NETDEV_OFFLOAD_XSTATS_TYPE_L3,
8006 	};
8007 
8008 	call_netdevice_notifiers_info(NETDEV_OFFLOAD_XSTATS_DISABLE,
8009 				      &info.info);
8010 	kfree(dev->offload_xstats_l3);
8011 	dev->offload_xstats_l3 = NULL;
8012 }
8013 
8014 int netdev_offload_xstats_disable(struct net_device *dev,
8015 				  enum netdev_offload_xstats_type type)
8016 {
8017 	ASSERT_RTNL();
8018 
8019 	if (!netdev_offload_xstats_enabled(dev, type))
8020 		return -EALREADY;
8021 
8022 	switch (type) {
8023 	case NETDEV_OFFLOAD_XSTATS_TYPE_L3:
8024 		netdev_offload_xstats_disable_l3(dev);
8025 		return 0;
8026 	}
8027 
8028 	WARN_ON(1);
8029 	return -EINVAL;
8030 }
8031 EXPORT_SYMBOL(netdev_offload_xstats_disable);
8032 
8033 static void netdev_offload_xstats_disable_all(struct net_device *dev)
8034 {
8035 	netdev_offload_xstats_disable(dev, NETDEV_OFFLOAD_XSTATS_TYPE_L3);
8036 }
8037 
8038 static struct rtnl_hw_stats64 *
8039 netdev_offload_xstats_get_ptr(const struct net_device *dev,
8040 			      enum netdev_offload_xstats_type type)
8041 {
8042 	switch (type) {
8043 	case NETDEV_OFFLOAD_XSTATS_TYPE_L3:
8044 		return dev->offload_xstats_l3;
8045 	}
8046 
8047 	WARN_ON(1);
8048 	return NULL;
8049 }
8050 
8051 bool netdev_offload_xstats_enabled(const struct net_device *dev,
8052 				   enum netdev_offload_xstats_type type)
8053 {
8054 	ASSERT_RTNL();
8055 
8056 	return netdev_offload_xstats_get_ptr(dev, type);
8057 }
8058 EXPORT_SYMBOL(netdev_offload_xstats_enabled);
8059 
8060 struct netdev_notifier_offload_xstats_ru {
8061 	bool used;
8062 };
8063 
8064 struct netdev_notifier_offload_xstats_rd {
8065 	struct rtnl_hw_stats64 stats;
8066 	bool used;
8067 };
8068 
8069 static void netdev_hw_stats64_add(struct rtnl_hw_stats64 *dest,
8070 				  const struct rtnl_hw_stats64 *src)
8071 {
8072 	dest->rx_packets	  += src->rx_packets;
8073 	dest->tx_packets	  += src->tx_packets;
8074 	dest->rx_bytes		  += src->rx_bytes;
8075 	dest->tx_bytes		  += src->tx_bytes;
8076 	dest->rx_errors		  += src->rx_errors;
8077 	dest->tx_errors		  += src->tx_errors;
8078 	dest->rx_dropped	  += src->rx_dropped;
8079 	dest->tx_dropped	  += src->tx_dropped;
8080 	dest->multicast		  += src->multicast;
8081 }
8082 
8083 static int netdev_offload_xstats_get_used(struct net_device *dev,
8084 					  enum netdev_offload_xstats_type type,
8085 					  bool *p_used,
8086 					  struct netlink_ext_ack *extack)
8087 {
8088 	struct netdev_notifier_offload_xstats_ru report_used = {};
8089 	struct netdev_notifier_offload_xstats_info info = {
8090 		.info.dev = dev,
8091 		.info.extack = extack,
8092 		.type = type,
8093 		.report_used = &report_used,
8094 	};
8095 	int rc;
8096 
8097 	WARN_ON(!netdev_offload_xstats_enabled(dev, type));
8098 	rc = call_netdevice_notifiers_info(NETDEV_OFFLOAD_XSTATS_REPORT_USED,
8099 					   &info.info);
8100 	*p_used = report_used.used;
8101 	return notifier_to_errno(rc);
8102 }
8103 
8104 static int netdev_offload_xstats_get_stats(struct net_device *dev,
8105 					   enum netdev_offload_xstats_type type,
8106 					   struct rtnl_hw_stats64 *p_stats,
8107 					   bool *p_used,
8108 					   struct netlink_ext_ack *extack)
8109 {
8110 	struct netdev_notifier_offload_xstats_rd report_delta = {};
8111 	struct netdev_notifier_offload_xstats_info info = {
8112 		.info.dev = dev,
8113 		.info.extack = extack,
8114 		.type = type,
8115 		.report_delta = &report_delta,
8116 	};
8117 	struct rtnl_hw_stats64 *stats;
8118 	int rc;
8119 
8120 	stats = netdev_offload_xstats_get_ptr(dev, type);
8121 	if (WARN_ON(!stats))
8122 		return -EINVAL;
8123 
8124 	rc = call_netdevice_notifiers_info(NETDEV_OFFLOAD_XSTATS_REPORT_DELTA,
8125 					   &info.info);
8126 
8127 	/* Cache whatever we got, even if there was an error, otherwise the
8128 	 * successful stats retrievals would get lost.
8129 	 */
8130 	netdev_hw_stats64_add(stats, &report_delta.stats);
8131 
8132 	if (p_stats)
8133 		*p_stats = *stats;
8134 	*p_used = report_delta.used;
8135 
8136 	return notifier_to_errno(rc);
8137 }
8138 
8139 int netdev_offload_xstats_get(struct net_device *dev,
8140 			      enum netdev_offload_xstats_type type,
8141 			      struct rtnl_hw_stats64 *p_stats, bool *p_used,
8142 			      struct netlink_ext_ack *extack)
8143 {
8144 	ASSERT_RTNL();
8145 
8146 	if (p_stats)
8147 		return netdev_offload_xstats_get_stats(dev, type, p_stats,
8148 						       p_used, extack);
8149 	else
8150 		return netdev_offload_xstats_get_used(dev, type, p_used,
8151 						      extack);
8152 }
8153 EXPORT_SYMBOL(netdev_offload_xstats_get);
8154 
8155 void
8156 netdev_offload_xstats_report_delta(struct netdev_notifier_offload_xstats_rd *report_delta,
8157 				   const struct rtnl_hw_stats64 *stats)
8158 {
8159 	report_delta->used = true;
8160 	netdev_hw_stats64_add(&report_delta->stats, stats);
8161 }
8162 EXPORT_SYMBOL(netdev_offload_xstats_report_delta);
8163 
8164 void
8165 netdev_offload_xstats_report_used(struct netdev_notifier_offload_xstats_ru *report_used)
8166 {
8167 	report_used->used = true;
8168 }
8169 EXPORT_SYMBOL(netdev_offload_xstats_report_used);
8170 
8171 void netdev_offload_xstats_push_delta(struct net_device *dev,
8172 				      enum netdev_offload_xstats_type type,
8173 				      const struct rtnl_hw_stats64 *p_stats)
8174 {
8175 	struct rtnl_hw_stats64 *stats;
8176 
8177 	ASSERT_RTNL();
8178 
8179 	stats = netdev_offload_xstats_get_ptr(dev, type);
8180 	if (WARN_ON(!stats))
8181 		return;
8182 
8183 	netdev_hw_stats64_add(stats, p_stats);
8184 }
8185 EXPORT_SYMBOL(netdev_offload_xstats_push_delta);
8186 
8187 /**
8188  * netdev_get_xmit_slave - Get the xmit slave of master device
8189  * @dev: device
8190  * @skb: The packet
8191  * @all_slaves: assume all the slaves are active
8192  *
8193  * The reference counters are not incremented so the caller must be
8194  * careful with locks. The caller must hold RCU lock.
8195  * %NULL is returned if no slave is found.
8196  */
8197 
8198 struct net_device *netdev_get_xmit_slave(struct net_device *dev,
8199 					 struct sk_buff *skb,
8200 					 bool all_slaves)
8201 {
8202 	const struct net_device_ops *ops = dev->netdev_ops;
8203 
8204 	if (!ops->ndo_get_xmit_slave)
8205 		return NULL;
8206 	return ops->ndo_get_xmit_slave(dev, skb, all_slaves);
8207 }
8208 EXPORT_SYMBOL(netdev_get_xmit_slave);
8209 
8210 static struct net_device *netdev_sk_get_lower_dev(struct net_device *dev,
8211 						  struct sock *sk)
8212 {
8213 	const struct net_device_ops *ops = dev->netdev_ops;
8214 
8215 	if (!ops->ndo_sk_get_lower_dev)
8216 		return NULL;
8217 	return ops->ndo_sk_get_lower_dev(dev, sk);
8218 }
8219 
8220 /**
8221  * netdev_sk_get_lowest_dev - Get the lowest device in chain given device and socket
8222  * @dev: device
8223  * @sk: the socket
8224  *
8225  * %NULL is returned if no lower device is found.
8226  */
8227 
8228 struct net_device *netdev_sk_get_lowest_dev(struct net_device *dev,
8229 					    struct sock *sk)
8230 {
8231 	struct net_device *lower;
8232 
8233 	lower = netdev_sk_get_lower_dev(dev, sk);
8234 	while (lower) {
8235 		dev = lower;
8236 		lower = netdev_sk_get_lower_dev(dev, sk);
8237 	}
8238 
8239 	return dev;
8240 }
8241 EXPORT_SYMBOL(netdev_sk_get_lowest_dev);
8242 
8243 static void netdev_adjacent_add_links(struct net_device *dev)
8244 {
8245 	struct netdev_adjacent *iter;
8246 
8247 	struct net *net = dev_net(dev);
8248 
8249 	list_for_each_entry(iter, &dev->adj_list.upper, list) {
8250 		if (!net_eq(net, dev_net(iter->dev)))
8251 			continue;
8252 		netdev_adjacent_sysfs_add(iter->dev, dev,
8253 					  &iter->dev->adj_list.lower);
8254 		netdev_adjacent_sysfs_add(dev, iter->dev,
8255 					  &dev->adj_list.upper);
8256 	}
8257 
8258 	list_for_each_entry(iter, &dev->adj_list.lower, list) {
8259 		if (!net_eq(net, dev_net(iter->dev)))
8260 			continue;
8261 		netdev_adjacent_sysfs_add(iter->dev, dev,
8262 					  &iter->dev->adj_list.upper);
8263 		netdev_adjacent_sysfs_add(dev, iter->dev,
8264 					  &dev->adj_list.lower);
8265 	}
8266 }
8267 
8268 static void netdev_adjacent_del_links(struct net_device *dev)
8269 {
8270 	struct netdev_adjacent *iter;
8271 
8272 	struct net *net = dev_net(dev);
8273 
8274 	list_for_each_entry(iter, &dev->adj_list.upper, list) {
8275 		if (!net_eq(net, dev_net(iter->dev)))
8276 			continue;
8277 		netdev_adjacent_sysfs_del(iter->dev, dev->name,
8278 					  &iter->dev->adj_list.lower);
8279 		netdev_adjacent_sysfs_del(dev, iter->dev->name,
8280 					  &dev->adj_list.upper);
8281 	}
8282 
8283 	list_for_each_entry(iter, &dev->adj_list.lower, list) {
8284 		if (!net_eq(net, dev_net(iter->dev)))
8285 			continue;
8286 		netdev_adjacent_sysfs_del(iter->dev, dev->name,
8287 					  &iter->dev->adj_list.upper);
8288 		netdev_adjacent_sysfs_del(dev, iter->dev->name,
8289 					  &dev->adj_list.lower);
8290 	}
8291 }
8292 
8293 void netdev_adjacent_rename_links(struct net_device *dev, char *oldname)
8294 {
8295 	struct netdev_adjacent *iter;
8296 
8297 	struct net *net = dev_net(dev);
8298 
8299 	list_for_each_entry(iter, &dev->adj_list.upper, list) {
8300 		if (!net_eq(net, dev_net(iter->dev)))
8301 			continue;
8302 		netdev_adjacent_sysfs_del(iter->dev, oldname,
8303 					  &iter->dev->adj_list.lower);
8304 		netdev_adjacent_sysfs_add(iter->dev, dev,
8305 					  &iter->dev->adj_list.lower);
8306 	}
8307 
8308 	list_for_each_entry(iter, &dev->adj_list.lower, list) {
8309 		if (!net_eq(net, dev_net(iter->dev)))
8310 			continue;
8311 		netdev_adjacent_sysfs_del(iter->dev, oldname,
8312 					  &iter->dev->adj_list.upper);
8313 		netdev_adjacent_sysfs_add(iter->dev, dev,
8314 					  &iter->dev->adj_list.upper);
8315 	}
8316 }
8317 
8318 void *netdev_lower_dev_get_private(struct net_device *dev,
8319 				   struct net_device *lower_dev)
8320 {
8321 	struct netdev_adjacent *lower;
8322 
8323 	if (!lower_dev)
8324 		return NULL;
8325 	lower = __netdev_find_adj(lower_dev, &dev->adj_list.lower);
8326 	if (!lower)
8327 		return NULL;
8328 
8329 	return lower->private;
8330 }
8331 EXPORT_SYMBOL(netdev_lower_dev_get_private);
8332 
8333 
8334 /**
8335  * netdev_lower_state_changed - Dispatch event about lower device state change
8336  * @lower_dev: device
8337  * @lower_state_info: state to dispatch
8338  *
8339  * Send NETDEV_CHANGELOWERSTATE to netdev notifiers with info.
8340  * The caller must hold the RTNL lock.
8341  */
8342 void netdev_lower_state_changed(struct net_device *lower_dev,
8343 				void *lower_state_info)
8344 {
8345 	struct netdev_notifier_changelowerstate_info changelowerstate_info = {
8346 		.info.dev = lower_dev,
8347 	};
8348 
8349 	ASSERT_RTNL();
8350 	changelowerstate_info.lower_state_info = lower_state_info;
8351 	call_netdevice_notifiers_info(NETDEV_CHANGELOWERSTATE,
8352 				      &changelowerstate_info.info);
8353 }
8354 EXPORT_SYMBOL(netdev_lower_state_changed);
8355 
8356 static void dev_change_rx_flags(struct net_device *dev, int flags)
8357 {
8358 	const struct net_device_ops *ops = dev->netdev_ops;
8359 
8360 	if (ops->ndo_change_rx_flags)
8361 		ops->ndo_change_rx_flags(dev, flags);
8362 }
8363 
8364 static int __dev_set_promiscuity(struct net_device *dev, int inc, bool notify)
8365 {
8366 	unsigned int old_flags = dev->flags;
8367 	kuid_t uid;
8368 	kgid_t gid;
8369 
8370 	ASSERT_RTNL();
8371 
8372 	dev->flags |= IFF_PROMISC;
8373 	dev->promiscuity += inc;
8374 	if (dev->promiscuity == 0) {
8375 		/*
8376 		 * Avoid overflow.
8377 		 * If inc causes overflow, untouch promisc and return error.
8378 		 */
8379 		if (inc < 0)
8380 			dev->flags &= ~IFF_PROMISC;
8381 		else {
8382 			dev->promiscuity -= inc;
8383 			netdev_warn(dev, "promiscuity touches roof, set promiscuity failed. promiscuity feature of device might be broken.\n");
8384 			return -EOVERFLOW;
8385 		}
8386 	}
8387 	if (dev->flags != old_flags) {
8388 		netdev_info(dev, "%s promiscuous mode\n",
8389 			    dev->flags & IFF_PROMISC ? "entered" : "left");
8390 		if (audit_enabled) {
8391 			current_uid_gid(&uid, &gid);
8392 			audit_log(audit_context(), GFP_ATOMIC,
8393 				  AUDIT_ANOM_PROMISCUOUS,
8394 				  "dev=%s prom=%d old_prom=%d auid=%u uid=%u gid=%u ses=%u",
8395 				  dev->name, (dev->flags & IFF_PROMISC),
8396 				  (old_flags & IFF_PROMISC),
8397 				  from_kuid(&init_user_ns, audit_get_loginuid(current)),
8398 				  from_kuid(&init_user_ns, uid),
8399 				  from_kgid(&init_user_ns, gid),
8400 				  audit_get_sessionid(current));
8401 		}
8402 
8403 		dev_change_rx_flags(dev, IFF_PROMISC);
8404 	}
8405 	if (notify)
8406 		__dev_notify_flags(dev, old_flags, IFF_PROMISC, 0, NULL);
8407 	return 0;
8408 }
8409 
8410 /**
8411  *	dev_set_promiscuity	- update promiscuity count on a device
8412  *	@dev: device
8413  *	@inc: modifier
8414  *
8415  *	Add or remove promiscuity from a device. While the count in the device
8416  *	remains above zero the interface remains promiscuous. Once it hits zero
8417  *	the device reverts back to normal filtering operation. A negative inc
8418  *	value is used to drop promiscuity on the device.
8419  *	Return 0 if successful or a negative errno code on error.
8420  */
8421 int dev_set_promiscuity(struct net_device *dev, int inc)
8422 {
8423 	unsigned int old_flags = dev->flags;
8424 	int err;
8425 
8426 	err = __dev_set_promiscuity(dev, inc, true);
8427 	if (err < 0)
8428 		return err;
8429 	if (dev->flags != old_flags)
8430 		dev_set_rx_mode(dev);
8431 	return err;
8432 }
8433 EXPORT_SYMBOL(dev_set_promiscuity);
8434 
8435 static int __dev_set_allmulti(struct net_device *dev, int inc, bool notify)
8436 {
8437 	unsigned int old_flags = dev->flags, old_gflags = dev->gflags;
8438 
8439 	ASSERT_RTNL();
8440 
8441 	dev->flags |= IFF_ALLMULTI;
8442 	dev->allmulti += inc;
8443 	if (dev->allmulti == 0) {
8444 		/*
8445 		 * Avoid overflow.
8446 		 * If inc causes overflow, untouch allmulti and return error.
8447 		 */
8448 		if (inc < 0)
8449 			dev->flags &= ~IFF_ALLMULTI;
8450 		else {
8451 			dev->allmulti -= inc;
8452 			netdev_warn(dev, "allmulti touches roof, set allmulti failed. allmulti feature of device might be broken.\n");
8453 			return -EOVERFLOW;
8454 		}
8455 	}
8456 	if (dev->flags ^ old_flags) {
8457 		netdev_info(dev, "%s allmulticast mode\n",
8458 			    dev->flags & IFF_ALLMULTI ? "entered" : "left");
8459 		dev_change_rx_flags(dev, IFF_ALLMULTI);
8460 		dev_set_rx_mode(dev);
8461 		if (notify)
8462 			__dev_notify_flags(dev, old_flags,
8463 					   dev->gflags ^ old_gflags, 0, NULL);
8464 	}
8465 	return 0;
8466 }
8467 
8468 /**
8469  *	dev_set_allmulti	- update allmulti count on a device
8470  *	@dev: device
8471  *	@inc: modifier
8472  *
8473  *	Add or remove reception of all multicast frames to a device. While the
8474  *	count in the device remains above zero the interface remains listening
8475  *	to all interfaces. Once it hits zero the device reverts back to normal
8476  *	filtering operation. A negative @inc value is used to drop the counter
8477  *	when releasing a resource needing all multicasts.
8478  *	Return 0 if successful or a negative errno code on error.
8479  */
8480 
8481 int dev_set_allmulti(struct net_device *dev, int inc)
8482 {
8483 	return __dev_set_allmulti(dev, inc, true);
8484 }
8485 EXPORT_SYMBOL(dev_set_allmulti);
8486 
8487 /*
8488  *	Upload unicast and multicast address lists to device and
8489  *	configure RX filtering. When the device doesn't support unicast
8490  *	filtering it is put in promiscuous mode while unicast addresses
8491  *	are present.
8492  */
8493 void __dev_set_rx_mode(struct net_device *dev)
8494 {
8495 	const struct net_device_ops *ops = dev->netdev_ops;
8496 
8497 	/* dev_open will call this function so the list will stay sane. */
8498 	if (!(dev->flags&IFF_UP))
8499 		return;
8500 
8501 	if (!netif_device_present(dev))
8502 		return;
8503 
8504 	if (!(dev->priv_flags & IFF_UNICAST_FLT)) {
8505 		/* Unicast addresses changes may only happen under the rtnl,
8506 		 * therefore calling __dev_set_promiscuity here is safe.
8507 		 */
8508 		if (!netdev_uc_empty(dev) && !dev->uc_promisc) {
8509 			__dev_set_promiscuity(dev, 1, false);
8510 			dev->uc_promisc = true;
8511 		} else if (netdev_uc_empty(dev) && dev->uc_promisc) {
8512 			__dev_set_promiscuity(dev, -1, false);
8513 			dev->uc_promisc = false;
8514 		}
8515 	}
8516 
8517 	if (ops->ndo_set_rx_mode)
8518 		ops->ndo_set_rx_mode(dev);
8519 }
8520 
8521 void dev_set_rx_mode(struct net_device *dev)
8522 {
8523 	netif_addr_lock_bh(dev);
8524 	__dev_set_rx_mode(dev);
8525 	netif_addr_unlock_bh(dev);
8526 }
8527 
8528 /**
8529  *	dev_get_flags - get flags reported to userspace
8530  *	@dev: device
8531  *
8532  *	Get the combination of flag bits exported through APIs to userspace.
8533  */
8534 unsigned int dev_get_flags(const struct net_device *dev)
8535 {
8536 	unsigned int flags;
8537 
8538 	flags = (dev->flags & ~(IFF_PROMISC |
8539 				IFF_ALLMULTI |
8540 				IFF_RUNNING |
8541 				IFF_LOWER_UP |
8542 				IFF_DORMANT)) |
8543 		(dev->gflags & (IFF_PROMISC |
8544 				IFF_ALLMULTI));
8545 
8546 	if (netif_running(dev)) {
8547 		if (netif_oper_up(dev))
8548 			flags |= IFF_RUNNING;
8549 		if (netif_carrier_ok(dev))
8550 			flags |= IFF_LOWER_UP;
8551 		if (netif_dormant(dev))
8552 			flags |= IFF_DORMANT;
8553 	}
8554 
8555 	return flags;
8556 }
8557 EXPORT_SYMBOL(dev_get_flags);
8558 
8559 int __dev_change_flags(struct net_device *dev, unsigned int flags,
8560 		       struct netlink_ext_ack *extack)
8561 {
8562 	unsigned int old_flags = dev->flags;
8563 	int ret;
8564 
8565 	ASSERT_RTNL();
8566 
8567 	/*
8568 	 *	Set the flags on our device.
8569 	 */
8570 
8571 	dev->flags = (flags & (IFF_DEBUG | IFF_NOTRAILERS | IFF_NOARP |
8572 			       IFF_DYNAMIC | IFF_MULTICAST | IFF_PORTSEL |
8573 			       IFF_AUTOMEDIA)) |
8574 		     (dev->flags & (IFF_UP | IFF_VOLATILE | IFF_PROMISC |
8575 				    IFF_ALLMULTI));
8576 
8577 	/*
8578 	 *	Load in the correct multicast list now the flags have changed.
8579 	 */
8580 
8581 	if ((old_flags ^ flags) & IFF_MULTICAST)
8582 		dev_change_rx_flags(dev, IFF_MULTICAST);
8583 
8584 	dev_set_rx_mode(dev);
8585 
8586 	/*
8587 	 *	Have we downed the interface. We handle IFF_UP ourselves
8588 	 *	according to user attempts to set it, rather than blindly
8589 	 *	setting it.
8590 	 */
8591 
8592 	ret = 0;
8593 	if ((old_flags ^ flags) & IFF_UP) {
8594 		if (old_flags & IFF_UP)
8595 			__dev_close(dev);
8596 		else
8597 			ret = __dev_open(dev, extack);
8598 	}
8599 
8600 	if ((flags ^ dev->gflags) & IFF_PROMISC) {
8601 		int inc = (flags & IFF_PROMISC) ? 1 : -1;
8602 		unsigned int old_flags = dev->flags;
8603 
8604 		dev->gflags ^= IFF_PROMISC;
8605 
8606 		if (__dev_set_promiscuity(dev, inc, false) >= 0)
8607 			if (dev->flags != old_flags)
8608 				dev_set_rx_mode(dev);
8609 	}
8610 
8611 	/* NOTE: order of synchronization of IFF_PROMISC and IFF_ALLMULTI
8612 	 * is important. Some (broken) drivers set IFF_PROMISC, when
8613 	 * IFF_ALLMULTI is requested not asking us and not reporting.
8614 	 */
8615 	if ((flags ^ dev->gflags) & IFF_ALLMULTI) {
8616 		int inc = (flags & IFF_ALLMULTI) ? 1 : -1;
8617 
8618 		dev->gflags ^= IFF_ALLMULTI;
8619 		__dev_set_allmulti(dev, inc, false);
8620 	}
8621 
8622 	return ret;
8623 }
8624 
8625 void __dev_notify_flags(struct net_device *dev, unsigned int old_flags,
8626 			unsigned int gchanges, u32 portid,
8627 			const struct nlmsghdr *nlh)
8628 {
8629 	unsigned int changes = dev->flags ^ old_flags;
8630 
8631 	if (gchanges)
8632 		rtmsg_ifinfo(RTM_NEWLINK, dev, gchanges, GFP_ATOMIC, portid, nlh);
8633 
8634 	if (changes & IFF_UP) {
8635 		if (dev->flags & IFF_UP)
8636 			call_netdevice_notifiers(NETDEV_UP, dev);
8637 		else
8638 			call_netdevice_notifiers(NETDEV_DOWN, dev);
8639 	}
8640 
8641 	if (dev->flags & IFF_UP &&
8642 	    (changes & ~(IFF_UP | IFF_PROMISC | IFF_ALLMULTI | IFF_VOLATILE))) {
8643 		struct netdev_notifier_change_info change_info = {
8644 			.info = {
8645 				.dev = dev,
8646 			},
8647 			.flags_changed = changes,
8648 		};
8649 
8650 		call_netdevice_notifiers_info(NETDEV_CHANGE, &change_info.info);
8651 	}
8652 }
8653 
8654 /**
8655  *	dev_change_flags - change device settings
8656  *	@dev: device
8657  *	@flags: device state flags
8658  *	@extack: netlink extended ack
8659  *
8660  *	Change settings on device based state flags. The flags are
8661  *	in the userspace exported format.
8662  */
8663 int dev_change_flags(struct net_device *dev, unsigned int flags,
8664 		     struct netlink_ext_ack *extack)
8665 {
8666 	int ret;
8667 	unsigned int changes, old_flags = dev->flags, old_gflags = dev->gflags;
8668 
8669 	ret = __dev_change_flags(dev, flags, extack);
8670 	if (ret < 0)
8671 		return ret;
8672 
8673 	changes = (old_flags ^ dev->flags) | (old_gflags ^ dev->gflags);
8674 	__dev_notify_flags(dev, old_flags, changes, 0, NULL);
8675 	return ret;
8676 }
8677 EXPORT_SYMBOL(dev_change_flags);
8678 
8679 int __dev_set_mtu(struct net_device *dev, int new_mtu)
8680 {
8681 	const struct net_device_ops *ops = dev->netdev_ops;
8682 
8683 	if (ops->ndo_change_mtu)
8684 		return ops->ndo_change_mtu(dev, new_mtu);
8685 
8686 	/* Pairs with all the lockless reads of dev->mtu in the stack */
8687 	WRITE_ONCE(dev->mtu, new_mtu);
8688 	return 0;
8689 }
8690 EXPORT_SYMBOL(__dev_set_mtu);
8691 
8692 int dev_validate_mtu(struct net_device *dev, int new_mtu,
8693 		     struct netlink_ext_ack *extack)
8694 {
8695 	/* MTU must be positive, and in range */
8696 	if (new_mtu < 0 || new_mtu < dev->min_mtu) {
8697 		NL_SET_ERR_MSG(extack, "mtu less than device minimum");
8698 		return -EINVAL;
8699 	}
8700 
8701 	if (dev->max_mtu > 0 && new_mtu > dev->max_mtu) {
8702 		NL_SET_ERR_MSG(extack, "mtu greater than device maximum");
8703 		return -EINVAL;
8704 	}
8705 	return 0;
8706 }
8707 
8708 /**
8709  *	dev_set_mtu_ext - Change maximum transfer unit
8710  *	@dev: device
8711  *	@new_mtu: new transfer unit
8712  *	@extack: netlink extended ack
8713  *
8714  *	Change the maximum transfer size of the network device.
8715  */
8716 int dev_set_mtu_ext(struct net_device *dev, int new_mtu,
8717 		    struct netlink_ext_ack *extack)
8718 {
8719 	int err, orig_mtu;
8720 
8721 	if (new_mtu == dev->mtu)
8722 		return 0;
8723 
8724 	err = dev_validate_mtu(dev, new_mtu, extack);
8725 	if (err)
8726 		return err;
8727 
8728 	if (!netif_device_present(dev))
8729 		return -ENODEV;
8730 
8731 	err = call_netdevice_notifiers(NETDEV_PRECHANGEMTU, dev);
8732 	err = notifier_to_errno(err);
8733 	if (err)
8734 		return err;
8735 
8736 	orig_mtu = dev->mtu;
8737 	err = __dev_set_mtu(dev, new_mtu);
8738 
8739 	if (!err) {
8740 		err = call_netdevice_notifiers_mtu(NETDEV_CHANGEMTU, dev,
8741 						   orig_mtu);
8742 		err = notifier_to_errno(err);
8743 		if (err) {
8744 			/* setting mtu back and notifying everyone again,
8745 			 * so that they have a chance to revert changes.
8746 			 */
8747 			__dev_set_mtu(dev, orig_mtu);
8748 			call_netdevice_notifiers_mtu(NETDEV_CHANGEMTU, dev,
8749 						     new_mtu);
8750 		}
8751 	}
8752 	return err;
8753 }
8754 
8755 int dev_set_mtu(struct net_device *dev, int new_mtu)
8756 {
8757 	struct netlink_ext_ack extack;
8758 	int err;
8759 
8760 	memset(&extack, 0, sizeof(extack));
8761 	err = dev_set_mtu_ext(dev, new_mtu, &extack);
8762 	if (err && extack._msg)
8763 		net_err_ratelimited("%s: %s\n", dev->name, extack._msg);
8764 	return err;
8765 }
8766 EXPORT_SYMBOL(dev_set_mtu);
8767 
8768 /**
8769  *	dev_change_tx_queue_len - Change TX queue length of a netdevice
8770  *	@dev: device
8771  *	@new_len: new tx queue length
8772  */
8773 int dev_change_tx_queue_len(struct net_device *dev, unsigned long new_len)
8774 {
8775 	unsigned int orig_len = dev->tx_queue_len;
8776 	int res;
8777 
8778 	if (new_len != (unsigned int)new_len)
8779 		return -ERANGE;
8780 
8781 	if (new_len != orig_len) {
8782 		dev->tx_queue_len = new_len;
8783 		res = call_netdevice_notifiers(NETDEV_CHANGE_TX_QUEUE_LEN, dev);
8784 		res = notifier_to_errno(res);
8785 		if (res)
8786 			goto err_rollback;
8787 		res = dev_qdisc_change_tx_queue_len(dev);
8788 		if (res)
8789 			goto err_rollback;
8790 	}
8791 
8792 	return 0;
8793 
8794 err_rollback:
8795 	netdev_err(dev, "refused to change device tx_queue_len\n");
8796 	dev->tx_queue_len = orig_len;
8797 	return res;
8798 }
8799 
8800 /**
8801  *	dev_set_group - Change group this device belongs to
8802  *	@dev: device
8803  *	@new_group: group this device should belong to
8804  */
8805 void dev_set_group(struct net_device *dev, int new_group)
8806 {
8807 	dev->group = new_group;
8808 }
8809 
8810 /**
8811  *	dev_pre_changeaddr_notify - Call NETDEV_PRE_CHANGEADDR.
8812  *	@dev: device
8813  *	@addr: new address
8814  *	@extack: netlink extended ack
8815  */
8816 int dev_pre_changeaddr_notify(struct net_device *dev, const char *addr,
8817 			      struct netlink_ext_ack *extack)
8818 {
8819 	struct netdev_notifier_pre_changeaddr_info info = {
8820 		.info.dev = dev,
8821 		.info.extack = extack,
8822 		.dev_addr = addr,
8823 	};
8824 	int rc;
8825 
8826 	rc = call_netdevice_notifiers_info(NETDEV_PRE_CHANGEADDR, &info.info);
8827 	return notifier_to_errno(rc);
8828 }
8829 EXPORT_SYMBOL(dev_pre_changeaddr_notify);
8830 
8831 /**
8832  *	dev_set_mac_address - Change Media Access Control Address
8833  *	@dev: device
8834  *	@sa: new address
8835  *	@extack: netlink extended ack
8836  *
8837  *	Change the hardware (MAC) address of the device
8838  */
8839 int dev_set_mac_address(struct net_device *dev, struct sockaddr *sa,
8840 			struct netlink_ext_ack *extack)
8841 {
8842 	const struct net_device_ops *ops = dev->netdev_ops;
8843 	int err;
8844 
8845 	if (!ops->ndo_set_mac_address)
8846 		return -EOPNOTSUPP;
8847 	if (sa->sa_family != dev->type)
8848 		return -EINVAL;
8849 	if (!netif_device_present(dev))
8850 		return -ENODEV;
8851 	err = dev_pre_changeaddr_notify(dev, sa->sa_data, extack);
8852 	if (err)
8853 		return err;
8854 	if (memcmp(dev->dev_addr, sa->sa_data, dev->addr_len)) {
8855 		err = ops->ndo_set_mac_address(dev, sa);
8856 		if (err)
8857 			return err;
8858 	}
8859 	dev->addr_assign_type = NET_ADDR_SET;
8860 	call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
8861 	add_device_randomness(dev->dev_addr, dev->addr_len);
8862 	return 0;
8863 }
8864 EXPORT_SYMBOL(dev_set_mac_address);
8865 
8866 static DECLARE_RWSEM(dev_addr_sem);
8867 
8868 int dev_set_mac_address_user(struct net_device *dev, struct sockaddr *sa,
8869 			     struct netlink_ext_ack *extack)
8870 {
8871 	int ret;
8872 
8873 	down_write(&dev_addr_sem);
8874 	ret = dev_set_mac_address(dev, sa, extack);
8875 	up_write(&dev_addr_sem);
8876 	return ret;
8877 }
8878 EXPORT_SYMBOL(dev_set_mac_address_user);
8879 
8880 int dev_get_mac_address(struct sockaddr *sa, struct net *net, char *dev_name)
8881 {
8882 	size_t size = sizeof(sa->sa_data_min);
8883 	struct net_device *dev;
8884 	int ret = 0;
8885 
8886 	down_read(&dev_addr_sem);
8887 	rcu_read_lock();
8888 
8889 	dev = dev_get_by_name_rcu(net, dev_name);
8890 	if (!dev) {
8891 		ret = -ENODEV;
8892 		goto unlock;
8893 	}
8894 	if (!dev->addr_len)
8895 		memset(sa->sa_data, 0, size);
8896 	else
8897 		memcpy(sa->sa_data, dev->dev_addr,
8898 		       min_t(size_t, size, dev->addr_len));
8899 	sa->sa_family = dev->type;
8900 
8901 unlock:
8902 	rcu_read_unlock();
8903 	up_read(&dev_addr_sem);
8904 	return ret;
8905 }
8906 EXPORT_SYMBOL(dev_get_mac_address);
8907 
8908 /**
8909  *	dev_change_carrier - Change device carrier
8910  *	@dev: device
8911  *	@new_carrier: new value
8912  *
8913  *	Change device carrier
8914  */
8915 int dev_change_carrier(struct net_device *dev, bool new_carrier)
8916 {
8917 	const struct net_device_ops *ops = dev->netdev_ops;
8918 
8919 	if (!ops->ndo_change_carrier)
8920 		return -EOPNOTSUPP;
8921 	if (!netif_device_present(dev))
8922 		return -ENODEV;
8923 	return ops->ndo_change_carrier(dev, new_carrier);
8924 }
8925 
8926 /**
8927  *	dev_get_phys_port_id - Get device physical port ID
8928  *	@dev: device
8929  *	@ppid: port ID
8930  *
8931  *	Get device physical port ID
8932  */
8933 int dev_get_phys_port_id(struct net_device *dev,
8934 			 struct netdev_phys_item_id *ppid)
8935 {
8936 	const struct net_device_ops *ops = dev->netdev_ops;
8937 
8938 	if (!ops->ndo_get_phys_port_id)
8939 		return -EOPNOTSUPP;
8940 	return ops->ndo_get_phys_port_id(dev, ppid);
8941 }
8942 
8943 /**
8944  *	dev_get_phys_port_name - Get device physical port name
8945  *	@dev: device
8946  *	@name: port name
8947  *	@len: limit of bytes to copy to name
8948  *
8949  *	Get device physical port name
8950  */
8951 int dev_get_phys_port_name(struct net_device *dev,
8952 			   char *name, size_t len)
8953 {
8954 	const struct net_device_ops *ops = dev->netdev_ops;
8955 	int err;
8956 
8957 	if (ops->ndo_get_phys_port_name) {
8958 		err = ops->ndo_get_phys_port_name(dev, name, len);
8959 		if (err != -EOPNOTSUPP)
8960 			return err;
8961 	}
8962 	return devlink_compat_phys_port_name_get(dev, name, len);
8963 }
8964 
8965 /**
8966  *	dev_get_port_parent_id - Get the device's port parent identifier
8967  *	@dev: network device
8968  *	@ppid: pointer to a storage for the port's parent identifier
8969  *	@recurse: allow/disallow recursion to lower devices
8970  *
8971  *	Get the devices's port parent identifier
8972  */
8973 int dev_get_port_parent_id(struct net_device *dev,
8974 			   struct netdev_phys_item_id *ppid,
8975 			   bool recurse)
8976 {
8977 	const struct net_device_ops *ops = dev->netdev_ops;
8978 	struct netdev_phys_item_id first = { };
8979 	struct net_device *lower_dev;
8980 	struct list_head *iter;
8981 	int err;
8982 
8983 	if (ops->ndo_get_port_parent_id) {
8984 		err = ops->ndo_get_port_parent_id(dev, ppid);
8985 		if (err != -EOPNOTSUPP)
8986 			return err;
8987 	}
8988 
8989 	err = devlink_compat_switch_id_get(dev, ppid);
8990 	if (!recurse || err != -EOPNOTSUPP)
8991 		return err;
8992 
8993 	netdev_for_each_lower_dev(dev, lower_dev, iter) {
8994 		err = dev_get_port_parent_id(lower_dev, ppid, true);
8995 		if (err)
8996 			break;
8997 		if (!first.id_len)
8998 			first = *ppid;
8999 		else if (memcmp(&first, ppid, sizeof(*ppid)))
9000 			return -EOPNOTSUPP;
9001 	}
9002 
9003 	return err;
9004 }
9005 EXPORT_SYMBOL(dev_get_port_parent_id);
9006 
9007 /**
9008  *	netdev_port_same_parent_id - Indicate if two network devices have
9009  *	the same port parent identifier
9010  *	@a: first network device
9011  *	@b: second network device
9012  */
9013 bool netdev_port_same_parent_id(struct net_device *a, struct net_device *b)
9014 {
9015 	struct netdev_phys_item_id a_id = { };
9016 	struct netdev_phys_item_id b_id = { };
9017 
9018 	if (dev_get_port_parent_id(a, &a_id, true) ||
9019 	    dev_get_port_parent_id(b, &b_id, true))
9020 		return false;
9021 
9022 	return netdev_phys_item_id_same(&a_id, &b_id);
9023 }
9024 EXPORT_SYMBOL(netdev_port_same_parent_id);
9025 
9026 /**
9027  *	dev_change_proto_down - set carrier according to proto_down.
9028  *
9029  *	@dev: device
9030  *	@proto_down: new value
9031  */
9032 int dev_change_proto_down(struct net_device *dev, bool proto_down)
9033 {
9034 	if (!(dev->priv_flags & IFF_CHANGE_PROTO_DOWN))
9035 		return -EOPNOTSUPP;
9036 	if (!netif_device_present(dev))
9037 		return -ENODEV;
9038 	if (proto_down)
9039 		netif_carrier_off(dev);
9040 	else
9041 		netif_carrier_on(dev);
9042 	dev->proto_down = proto_down;
9043 	return 0;
9044 }
9045 
9046 /**
9047  *	dev_change_proto_down_reason - proto down reason
9048  *
9049  *	@dev: device
9050  *	@mask: proto down mask
9051  *	@value: proto down value
9052  */
9053 void dev_change_proto_down_reason(struct net_device *dev, unsigned long mask,
9054 				  u32 value)
9055 {
9056 	int b;
9057 
9058 	if (!mask) {
9059 		dev->proto_down_reason = value;
9060 	} else {
9061 		for_each_set_bit(b, &mask, 32) {
9062 			if (value & (1 << b))
9063 				dev->proto_down_reason |= BIT(b);
9064 			else
9065 				dev->proto_down_reason &= ~BIT(b);
9066 		}
9067 	}
9068 }
9069 
9070 struct bpf_xdp_link {
9071 	struct bpf_link link;
9072 	struct net_device *dev; /* protected by rtnl_lock, no refcnt held */
9073 	int flags;
9074 };
9075 
9076 static enum bpf_xdp_mode dev_xdp_mode(struct net_device *dev, u32 flags)
9077 {
9078 	if (flags & XDP_FLAGS_HW_MODE)
9079 		return XDP_MODE_HW;
9080 	if (flags & XDP_FLAGS_DRV_MODE)
9081 		return XDP_MODE_DRV;
9082 	if (flags & XDP_FLAGS_SKB_MODE)
9083 		return XDP_MODE_SKB;
9084 	return dev->netdev_ops->ndo_bpf ? XDP_MODE_DRV : XDP_MODE_SKB;
9085 }
9086 
9087 static bpf_op_t dev_xdp_bpf_op(struct net_device *dev, enum bpf_xdp_mode mode)
9088 {
9089 	switch (mode) {
9090 	case XDP_MODE_SKB:
9091 		return generic_xdp_install;
9092 	case XDP_MODE_DRV:
9093 	case XDP_MODE_HW:
9094 		return dev->netdev_ops->ndo_bpf;
9095 	default:
9096 		return NULL;
9097 	}
9098 }
9099 
9100 static struct bpf_xdp_link *dev_xdp_link(struct net_device *dev,
9101 					 enum bpf_xdp_mode mode)
9102 {
9103 	return dev->xdp_state[mode].link;
9104 }
9105 
9106 static struct bpf_prog *dev_xdp_prog(struct net_device *dev,
9107 				     enum bpf_xdp_mode mode)
9108 {
9109 	struct bpf_xdp_link *link = dev_xdp_link(dev, mode);
9110 
9111 	if (link)
9112 		return link->link.prog;
9113 	return dev->xdp_state[mode].prog;
9114 }
9115 
9116 u8 dev_xdp_prog_count(struct net_device *dev)
9117 {
9118 	u8 count = 0;
9119 	int i;
9120 
9121 	for (i = 0; i < __MAX_XDP_MODE; i++)
9122 		if (dev->xdp_state[i].prog || dev->xdp_state[i].link)
9123 			count++;
9124 	return count;
9125 }
9126 EXPORT_SYMBOL_GPL(dev_xdp_prog_count);
9127 
9128 u32 dev_xdp_prog_id(struct net_device *dev, enum bpf_xdp_mode mode)
9129 {
9130 	struct bpf_prog *prog = dev_xdp_prog(dev, mode);
9131 
9132 	return prog ? prog->aux->id : 0;
9133 }
9134 
9135 static void dev_xdp_set_link(struct net_device *dev, enum bpf_xdp_mode mode,
9136 			     struct bpf_xdp_link *link)
9137 {
9138 	dev->xdp_state[mode].link = link;
9139 	dev->xdp_state[mode].prog = NULL;
9140 }
9141 
9142 static void dev_xdp_set_prog(struct net_device *dev, enum bpf_xdp_mode mode,
9143 			     struct bpf_prog *prog)
9144 {
9145 	dev->xdp_state[mode].link = NULL;
9146 	dev->xdp_state[mode].prog = prog;
9147 }
9148 
9149 static int dev_xdp_install(struct net_device *dev, enum bpf_xdp_mode mode,
9150 			   bpf_op_t bpf_op, struct netlink_ext_ack *extack,
9151 			   u32 flags, struct bpf_prog *prog)
9152 {
9153 	struct netdev_bpf xdp;
9154 	int err;
9155 
9156 	memset(&xdp, 0, sizeof(xdp));
9157 	xdp.command = mode == XDP_MODE_HW ? XDP_SETUP_PROG_HW : XDP_SETUP_PROG;
9158 	xdp.extack = extack;
9159 	xdp.flags = flags;
9160 	xdp.prog = prog;
9161 
9162 	/* Drivers assume refcnt is already incremented (i.e, prog pointer is
9163 	 * "moved" into driver), so they don't increment it on their own, but
9164 	 * they do decrement refcnt when program is detached or replaced.
9165 	 * Given net_device also owns link/prog, we need to bump refcnt here
9166 	 * to prevent drivers from underflowing it.
9167 	 */
9168 	if (prog)
9169 		bpf_prog_inc(prog);
9170 	err = bpf_op(dev, &xdp);
9171 	if (err) {
9172 		if (prog)
9173 			bpf_prog_put(prog);
9174 		return err;
9175 	}
9176 
9177 	if (mode != XDP_MODE_HW)
9178 		bpf_prog_change_xdp(dev_xdp_prog(dev, mode), prog);
9179 
9180 	return 0;
9181 }
9182 
9183 static void dev_xdp_uninstall(struct net_device *dev)
9184 {
9185 	struct bpf_xdp_link *link;
9186 	struct bpf_prog *prog;
9187 	enum bpf_xdp_mode mode;
9188 	bpf_op_t bpf_op;
9189 
9190 	ASSERT_RTNL();
9191 
9192 	for (mode = XDP_MODE_SKB; mode < __MAX_XDP_MODE; mode++) {
9193 		prog = dev_xdp_prog(dev, mode);
9194 		if (!prog)
9195 			continue;
9196 
9197 		bpf_op = dev_xdp_bpf_op(dev, mode);
9198 		if (!bpf_op)
9199 			continue;
9200 
9201 		WARN_ON(dev_xdp_install(dev, mode, bpf_op, NULL, 0, NULL));
9202 
9203 		/* auto-detach link from net device */
9204 		link = dev_xdp_link(dev, mode);
9205 		if (link)
9206 			link->dev = NULL;
9207 		else
9208 			bpf_prog_put(prog);
9209 
9210 		dev_xdp_set_link(dev, mode, NULL);
9211 	}
9212 }
9213 
9214 static int dev_xdp_attach(struct net_device *dev, struct netlink_ext_ack *extack,
9215 			  struct bpf_xdp_link *link, struct bpf_prog *new_prog,
9216 			  struct bpf_prog *old_prog, u32 flags)
9217 {
9218 	unsigned int num_modes = hweight32(flags & XDP_FLAGS_MODES);
9219 	struct bpf_prog *cur_prog;
9220 	struct net_device *upper;
9221 	struct list_head *iter;
9222 	enum bpf_xdp_mode mode;
9223 	bpf_op_t bpf_op;
9224 	int err;
9225 
9226 	ASSERT_RTNL();
9227 
9228 	/* either link or prog attachment, never both */
9229 	if (link && (new_prog || old_prog))
9230 		return -EINVAL;
9231 	/* link supports only XDP mode flags */
9232 	if (link && (flags & ~XDP_FLAGS_MODES)) {
9233 		NL_SET_ERR_MSG(extack, "Invalid XDP flags for BPF link attachment");
9234 		return -EINVAL;
9235 	}
9236 	/* just one XDP mode bit should be set, zero defaults to drv/skb mode */
9237 	if (num_modes > 1) {
9238 		NL_SET_ERR_MSG(extack, "Only one XDP mode flag can be set");
9239 		return -EINVAL;
9240 	}
9241 	/* avoid ambiguity if offload + drv/skb mode progs are both loaded */
9242 	if (!num_modes && dev_xdp_prog_count(dev) > 1) {
9243 		NL_SET_ERR_MSG(extack,
9244 			       "More than one program loaded, unset mode is ambiguous");
9245 		return -EINVAL;
9246 	}
9247 	/* old_prog != NULL implies XDP_FLAGS_REPLACE is set */
9248 	if (old_prog && !(flags & XDP_FLAGS_REPLACE)) {
9249 		NL_SET_ERR_MSG(extack, "XDP_FLAGS_REPLACE is not specified");
9250 		return -EINVAL;
9251 	}
9252 
9253 	mode = dev_xdp_mode(dev, flags);
9254 	/* can't replace attached link */
9255 	if (dev_xdp_link(dev, mode)) {
9256 		NL_SET_ERR_MSG(extack, "Can't replace active BPF XDP link");
9257 		return -EBUSY;
9258 	}
9259 
9260 	/* don't allow if an upper device already has a program */
9261 	netdev_for_each_upper_dev_rcu(dev, upper, iter) {
9262 		if (dev_xdp_prog_count(upper) > 0) {
9263 			NL_SET_ERR_MSG(extack, "Cannot attach when an upper device already has a program");
9264 			return -EEXIST;
9265 		}
9266 	}
9267 
9268 	cur_prog = dev_xdp_prog(dev, mode);
9269 	/* can't replace attached prog with link */
9270 	if (link && cur_prog) {
9271 		NL_SET_ERR_MSG(extack, "Can't replace active XDP program with BPF link");
9272 		return -EBUSY;
9273 	}
9274 	if ((flags & XDP_FLAGS_REPLACE) && cur_prog != old_prog) {
9275 		NL_SET_ERR_MSG(extack, "Active program does not match expected");
9276 		return -EEXIST;
9277 	}
9278 
9279 	/* put effective new program into new_prog */
9280 	if (link)
9281 		new_prog = link->link.prog;
9282 
9283 	if (new_prog) {
9284 		bool offload = mode == XDP_MODE_HW;
9285 		enum bpf_xdp_mode other_mode = mode == XDP_MODE_SKB
9286 					       ? XDP_MODE_DRV : XDP_MODE_SKB;
9287 
9288 		if ((flags & XDP_FLAGS_UPDATE_IF_NOEXIST) && cur_prog) {
9289 			NL_SET_ERR_MSG(extack, "XDP program already attached");
9290 			return -EBUSY;
9291 		}
9292 		if (!offload && dev_xdp_prog(dev, other_mode)) {
9293 			NL_SET_ERR_MSG(extack, "Native and generic XDP can't be active at the same time");
9294 			return -EEXIST;
9295 		}
9296 		if (!offload && bpf_prog_is_offloaded(new_prog->aux)) {
9297 			NL_SET_ERR_MSG(extack, "Using offloaded program without HW_MODE flag is not supported");
9298 			return -EINVAL;
9299 		}
9300 		if (bpf_prog_is_dev_bound(new_prog->aux) && !bpf_offload_dev_match(new_prog, dev)) {
9301 			NL_SET_ERR_MSG(extack, "Program bound to different device");
9302 			return -EINVAL;
9303 		}
9304 		if (new_prog->expected_attach_type == BPF_XDP_DEVMAP) {
9305 			NL_SET_ERR_MSG(extack, "BPF_XDP_DEVMAP programs can not be attached to a device");
9306 			return -EINVAL;
9307 		}
9308 		if (new_prog->expected_attach_type == BPF_XDP_CPUMAP) {
9309 			NL_SET_ERR_MSG(extack, "BPF_XDP_CPUMAP programs can not be attached to a device");
9310 			return -EINVAL;
9311 		}
9312 	}
9313 
9314 	/* don't call drivers if the effective program didn't change */
9315 	if (new_prog != cur_prog) {
9316 		bpf_op = dev_xdp_bpf_op(dev, mode);
9317 		if (!bpf_op) {
9318 			NL_SET_ERR_MSG(extack, "Underlying driver does not support XDP in native mode");
9319 			return -EOPNOTSUPP;
9320 		}
9321 
9322 		err = dev_xdp_install(dev, mode, bpf_op, extack, flags, new_prog);
9323 		if (err)
9324 			return err;
9325 	}
9326 
9327 	if (link)
9328 		dev_xdp_set_link(dev, mode, link);
9329 	else
9330 		dev_xdp_set_prog(dev, mode, new_prog);
9331 	if (cur_prog)
9332 		bpf_prog_put(cur_prog);
9333 
9334 	return 0;
9335 }
9336 
9337 static int dev_xdp_attach_link(struct net_device *dev,
9338 			       struct netlink_ext_ack *extack,
9339 			       struct bpf_xdp_link *link)
9340 {
9341 	return dev_xdp_attach(dev, extack, link, NULL, NULL, link->flags);
9342 }
9343 
9344 static int dev_xdp_detach_link(struct net_device *dev,
9345 			       struct netlink_ext_ack *extack,
9346 			       struct bpf_xdp_link *link)
9347 {
9348 	enum bpf_xdp_mode mode;
9349 	bpf_op_t bpf_op;
9350 
9351 	ASSERT_RTNL();
9352 
9353 	mode = dev_xdp_mode(dev, link->flags);
9354 	if (dev_xdp_link(dev, mode) != link)
9355 		return -EINVAL;
9356 
9357 	bpf_op = dev_xdp_bpf_op(dev, mode);
9358 	WARN_ON(dev_xdp_install(dev, mode, bpf_op, NULL, 0, NULL));
9359 	dev_xdp_set_link(dev, mode, NULL);
9360 	return 0;
9361 }
9362 
9363 static void bpf_xdp_link_release(struct bpf_link *link)
9364 {
9365 	struct bpf_xdp_link *xdp_link = container_of(link, struct bpf_xdp_link, link);
9366 
9367 	rtnl_lock();
9368 
9369 	/* if racing with net_device's tear down, xdp_link->dev might be
9370 	 * already NULL, in which case link was already auto-detached
9371 	 */
9372 	if (xdp_link->dev) {
9373 		WARN_ON(dev_xdp_detach_link(xdp_link->dev, NULL, xdp_link));
9374 		xdp_link->dev = NULL;
9375 	}
9376 
9377 	rtnl_unlock();
9378 }
9379 
9380 static int bpf_xdp_link_detach(struct bpf_link *link)
9381 {
9382 	bpf_xdp_link_release(link);
9383 	return 0;
9384 }
9385 
9386 static void bpf_xdp_link_dealloc(struct bpf_link *link)
9387 {
9388 	struct bpf_xdp_link *xdp_link = container_of(link, struct bpf_xdp_link, link);
9389 
9390 	kfree(xdp_link);
9391 }
9392 
9393 static void bpf_xdp_link_show_fdinfo(const struct bpf_link *link,
9394 				     struct seq_file *seq)
9395 {
9396 	struct bpf_xdp_link *xdp_link = container_of(link, struct bpf_xdp_link, link);
9397 	u32 ifindex = 0;
9398 
9399 	rtnl_lock();
9400 	if (xdp_link->dev)
9401 		ifindex = xdp_link->dev->ifindex;
9402 	rtnl_unlock();
9403 
9404 	seq_printf(seq, "ifindex:\t%u\n", ifindex);
9405 }
9406 
9407 static int bpf_xdp_link_fill_link_info(const struct bpf_link *link,
9408 				       struct bpf_link_info *info)
9409 {
9410 	struct bpf_xdp_link *xdp_link = container_of(link, struct bpf_xdp_link, link);
9411 	u32 ifindex = 0;
9412 
9413 	rtnl_lock();
9414 	if (xdp_link->dev)
9415 		ifindex = xdp_link->dev->ifindex;
9416 	rtnl_unlock();
9417 
9418 	info->xdp.ifindex = ifindex;
9419 	return 0;
9420 }
9421 
9422 static int bpf_xdp_link_update(struct bpf_link *link, struct bpf_prog *new_prog,
9423 			       struct bpf_prog *old_prog)
9424 {
9425 	struct bpf_xdp_link *xdp_link = container_of(link, struct bpf_xdp_link, link);
9426 	enum bpf_xdp_mode mode;
9427 	bpf_op_t bpf_op;
9428 	int err = 0;
9429 
9430 	rtnl_lock();
9431 
9432 	/* link might have been auto-released already, so fail */
9433 	if (!xdp_link->dev) {
9434 		err = -ENOLINK;
9435 		goto out_unlock;
9436 	}
9437 
9438 	if (old_prog && link->prog != old_prog) {
9439 		err = -EPERM;
9440 		goto out_unlock;
9441 	}
9442 	old_prog = link->prog;
9443 	if (old_prog->type != new_prog->type ||
9444 	    old_prog->expected_attach_type != new_prog->expected_attach_type) {
9445 		err = -EINVAL;
9446 		goto out_unlock;
9447 	}
9448 
9449 	if (old_prog == new_prog) {
9450 		/* no-op, don't disturb drivers */
9451 		bpf_prog_put(new_prog);
9452 		goto out_unlock;
9453 	}
9454 
9455 	mode = dev_xdp_mode(xdp_link->dev, xdp_link->flags);
9456 	bpf_op = dev_xdp_bpf_op(xdp_link->dev, mode);
9457 	err = dev_xdp_install(xdp_link->dev, mode, bpf_op, NULL,
9458 			      xdp_link->flags, new_prog);
9459 	if (err)
9460 		goto out_unlock;
9461 
9462 	old_prog = xchg(&link->prog, new_prog);
9463 	bpf_prog_put(old_prog);
9464 
9465 out_unlock:
9466 	rtnl_unlock();
9467 	return err;
9468 }
9469 
9470 static const struct bpf_link_ops bpf_xdp_link_lops = {
9471 	.release = bpf_xdp_link_release,
9472 	.dealloc = bpf_xdp_link_dealloc,
9473 	.detach = bpf_xdp_link_detach,
9474 	.show_fdinfo = bpf_xdp_link_show_fdinfo,
9475 	.fill_link_info = bpf_xdp_link_fill_link_info,
9476 	.update_prog = bpf_xdp_link_update,
9477 };
9478 
9479 int bpf_xdp_link_attach(const union bpf_attr *attr, struct bpf_prog *prog)
9480 {
9481 	struct net *net = current->nsproxy->net_ns;
9482 	struct bpf_link_primer link_primer;
9483 	struct netlink_ext_ack extack = {};
9484 	struct bpf_xdp_link *link;
9485 	struct net_device *dev;
9486 	int err, fd;
9487 
9488 	rtnl_lock();
9489 	dev = dev_get_by_index(net, attr->link_create.target_ifindex);
9490 	if (!dev) {
9491 		rtnl_unlock();
9492 		return -EINVAL;
9493 	}
9494 
9495 	link = kzalloc(sizeof(*link), GFP_USER);
9496 	if (!link) {
9497 		err = -ENOMEM;
9498 		goto unlock;
9499 	}
9500 
9501 	bpf_link_init(&link->link, BPF_LINK_TYPE_XDP, &bpf_xdp_link_lops, prog);
9502 	link->dev = dev;
9503 	link->flags = attr->link_create.flags;
9504 
9505 	err = bpf_link_prime(&link->link, &link_primer);
9506 	if (err) {
9507 		kfree(link);
9508 		goto unlock;
9509 	}
9510 
9511 	err = dev_xdp_attach_link(dev, &extack, link);
9512 	rtnl_unlock();
9513 
9514 	if (err) {
9515 		link->dev = NULL;
9516 		bpf_link_cleanup(&link_primer);
9517 		trace_bpf_xdp_link_attach_failed(extack._msg);
9518 		goto out_put_dev;
9519 	}
9520 
9521 	fd = bpf_link_settle(&link_primer);
9522 	/* link itself doesn't hold dev's refcnt to not complicate shutdown */
9523 	dev_put(dev);
9524 	return fd;
9525 
9526 unlock:
9527 	rtnl_unlock();
9528 
9529 out_put_dev:
9530 	dev_put(dev);
9531 	return err;
9532 }
9533 
9534 /**
9535  *	dev_change_xdp_fd - set or clear a bpf program for a device rx path
9536  *	@dev: device
9537  *	@extack: netlink extended ack
9538  *	@fd: new program fd or negative value to clear
9539  *	@expected_fd: old program fd that userspace expects to replace or clear
9540  *	@flags: xdp-related flags
9541  *
9542  *	Set or clear a bpf program for a device
9543  */
9544 int dev_change_xdp_fd(struct net_device *dev, struct netlink_ext_ack *extack,
9545 		      int fd, int expected_fd, u32 flags)
9546 {
9547 	enum bpf_xdp_mode mode = dev_xdp_mode(dev, flags);
9548 	struct bpf_prog *new_prog = NULL, *old_prog = NULL;
9549 	int err;
9550 
9551 	ASSERT_RTNL();
9552 
9553 	if (fd >= 0) {
9554 		new_prog = bpf_prog_get_type_dev(fd, BPF_PROG_TYPE_XDP,
9555 						 mode != XDP_MODE_SKB);
9556 		if (IS_ERR(new_prog))
9557 			return PTR_ERR(new_prog);
9558 	}
9559 
9560 	if (expected_fd >= 0) {
9561 		old_prog = bpf_prog_get_type_dev(expected_fd, BPF_PROG_TYPE_XDP,
9562 						 mode != XDP_MODE_SKB);
9563 		if (IS_ERR(old_prog)) {
9564 			err = PTR_ERR(old_prog);
9565 			old_prog = NULL;
9566 			goto err_out;
9567 		}
9568 	}
9569 
9570 	err = dev_xdp_attach(dev, extack, NULL, new_prog, old_prog, flags);
9571 
9572 err_out:
9573 	if (err && new_prog)
9574 		bpf_prog_put(new_prog);
9575 	if (old_prog)
9576 		bpf_prog_put(old_prog);
9577 	return err;
9578 }
9579 
9580 /**
9581  * dev_index_reserve() - allocate an ifindex in a namespace
9582  * @net: the applicable net namespace
9583  * @ifindex: requested ifindex, pass %0 to get one allocated
9584  *
9585  * Allocate a ifindex for a new device. Caller must either use the ifindex
9586  * to store the device (via list_netdevice()) or call dev_index_release()
9587  * to give the index up.
9588  *
9589  * Return: a suitable unique value for a new device interface number or -errno.
9590  */
9591 static int dev_index_reserve(struct net *net, u32 ifindex)
9592 {
9593 	int err;
9594 
9595 	if (ifindex > INT_MAX) {
9596 		DEBUG_NET_WARN_ON_ONCE(1);
9597 		return -EINVAL;
9598 	}
9599 
9600 	if (!ifindex)
9601 		err = xa_alloc_cyclic(&net->dev_by_index, &ifindex, NULL,
9602 				      xa_limit_31b, &net->ifindex, GFP_KERNEL);
9603 	else
9604 		err = xa_insert(&net->dev_by_index, ifindex, NULL, GFP_KERNEL);
9605 	if (err < 0)
9606 		return err;
9607 
9608 	return ifindex;
9609 }
9610 
9611 static void dev_index_release(struct net *net, int ifindex)
9612 {
9613 	/* Expect only unused indexes, unlist_netdevice() removes the used */
9614 	WARN_ON(xa_erase(&net->dev_by_index, ifindex));
9615 }
9616 
9617 /* Delayed registration/unregisteration */
9618 LIST_HEAD(net_todo_list);
9619 DECLARE_WAIT_QUEUE_HEAD(netdev_unregistering_wq);
9620 
9621 static void net_set_todo(struct net_device *dev)
9622 {
9623 	list_add_tail(&dev->todo_list, &net_todo_list);
9624 	atomic_inc(&dev_net(dev)->dev_unreg_count);
9625 }
9626 
9627 static netdev_features_t netdev_sync_upper_features(struct net_device *lower,
9628 	struct net_device *upper, netdev_features_t features)
9629 {
9630 	netdev_features_t upper_disables = NETIF_F_UPPER_DISABLES;
9631 	netdev_features_t feature;
9632 	int feature_bit;
9633 
9634 	for_each_netdev_feature(upper_disables, feature_bit) {
9635 		feature = __NETIF_F_BIT(feature_bit);
9636 		if (!(upper->wanted_features & feature)
9637 		    && (features & feature)) {
9638 			netdev_dbg(lower, "Dropping feature %pNF, upper dev %s has it off.\n",
9639 				   &feature, upper->name);
9640 			features &= ~feature;
9641 		}
9642 	}
9643 
9644 	return features;
9645 }
9646 
9647 static void netdev_sync_lower_features(struct net_device *upper,
9648 	struct net_device *lower, netdev_features_t features)
9649 {
9650 	netdev_features_t upper_disables = NETIF_F_UPPER_DISABLES;
9651 	netdev_features_t feature;
9652 	int feature_bit;
9653 
9654 	for_each_netdev_feature(upper_disables, feature_bit) {
9655 		feature = __NETIF_F_BIT(feature_bit);
9656 		if (!(features & feature) && (lower->features & feature)) {
9657 			netdev_dbg(upper, "Disabling feature %pNF on lower dev %s.\n",
9658 				   &feature, lower->name);
9659 			lower->wanted_features &= ~feature;
9660 			__netdev_update_features(lower);
9661 
9662 			if (unlikely(lower->features & feature))
9663 				netdev_WARN(upper, "failed to disable %pNF on %s!\n",
9664 					    &feature, lower->name);
9665 			else
9666 				netdev_features_change(lower);
9667 		}
9668 	}
9669 }
9670 
9671 static netdev_features_t netdev_fix_features(struct net_device *dev,
9672 	netdev_features_t features)
9673 {
9674 	/* Fix illegal checksum combinations */
9675 	if ((features & NETIF_F_HW_CSUM) &&
9676 	    (features & (NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM))) {
9677 		netdev_warn(dev, "mixed HW and IP checksum settings.\n");
9678 		features &= ~(NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM);
9679 	}
9680 
9681 	/* TSO requires that SG is present as well. */
9682 	if ((features & NETIF_F_ALL_TSO) && !(features & NETIF_F_SG)) {
9683 		netdev_dbg(dev, "Dropping TSO features since no SG feature.\n");
9684 		features &= ~NETIF_F_ALL_TSO;
9685 	}
9686 
9687 	if ((features & NETIF_F_TSO) && !(features & NETIF_F_HW_CSUM) &&
9688 					!(features & NETIF_F_IP_CSUM)) {
9689 		netdev_dbg(dev, "Dropping TSO features since no CSUM feature.\n");
9690 		features &= ~NETIF_F_TSO;
9691 		features &= ~NETIF_F_TSO_ECN;
9692 	}
9693 
9694 	if ((features & NETIF_F_TSO6) && !(features & NETIF_F_HW_CSUM) &&
9695 					 !(features & NETIF_F_IPV6_CSUM)) {
9696 		netdev_dbg(dev, "Dropping TSO6 features since no CSUM feature.\n");
9697 		features &= ~NETIF_F_TSO6;
9698 	}
9699 
9700 	/* TSO with IPv4 ID mangling requires IPv4 TSO be enabled */
9701 	if ((features & NETIF_F_TSO_MANGLEID) && !(features & NETIF_F_TSO))
9702 		features &= ~NETIF_F_TSO_MANGLEID;
9703 
9704 	/* TSO ECN requires that TSO is present as well. */
9705 	if ((features & NETIF_F_ALL_TSO) == NETIF_F_TSO_ECN)
9706 		features &= ~NETIF_F_TSO_ECN;
9707 
9708 	/* Software GSO depends on SG. */
9709 	if ((features & NETIF_F_GSO) && !(features & NETIF_F_SG)) {
9710 		netdev_dbg(dev, "Dropping NETIF_F_GSO since no SG feature.\n");
9711 		features &= ~NETIF_F_GSO;
9712 	}
9713 
9714 	/* GSO partial features require GSO partial be set */
9715 	if ((features & dev->gso_partial_features) &&
9716 	    !(features & NETIF_F_GSO_PARTIAL)) {
9717 		netdev_dbg(dev,
9718 			   "Dropping partially supported GSO features since no GSO partial.\n");
9719 		features &= ~dev->gso_partial_features;
9720 	}
9721 
9722 	if (!(features & NETIF_F_RXCSUM)) {
9723 		/* NETIF_F_GRO_HW implies doing RXCSUM since every packet
9724 		 * successfully merged by hardware must also have the
9725 		 * checksum verified by hardware.  If the user does not
9726 		 * want to enable RXCSUM, logically, we should disable GRO_HW.
9727 		 */
9728 		if (features & NETIF_F_GRO_HW) {
9729 			netdev_dbg(dev, "Dropping NETIF_F_GRO_HW since no RXCSUM feature.\n");
9730 			features &= ~NETIF_F_GRO_HW;
9731 		}
9732 	}
9733 
9734 	/* LRO/HW-GRO features cannot be combined with RX-FCS */
9735 	if (features & NETIF_F_RXFCS) {
9736 		if (features & NETIF_F_LRO) {
9737 			netdev_dbg(dev, "Dropping LRO feature since RX-FCS is requested.\n");
9738 			features &= ~NETIF_F_LRO;
9739 		}
9740 
9741 		if (features & NETIF_F_GRO_HW) {
9742 			netdev_dbg(dev, "Dropping HW-GRO feature since RX-FCS is requested.\n");
9743 			features &= ~NETIF_F_GRO_HW;
9744 		}
9745 	}
9746 
9747 	if ((features & NETIF_F_GRO_HW) && (features & NETIF_F_LRO)) {
9748 		netdev_dbg(dev, "Dropping LRO feature since HW-GRO is requested.\n");
9749 		features &= ~NETIF_F_LRO;
9750 	}
9751 
9752 	if (features & NETIF_F_HW_TLS_TX) {
9753 		bool ip_csum = (features & (NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM)) ==
9754 			(NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM);
9755 		bool hw_csum = features & NETIF_F_HW_CSUM;
9756 
9757 		if (!ip_csum && !hw_csum) {
9758 			netdev_dbg(dev, "Dropping TLS TX HW offload feature since no CSUM feature.\n");
9759 			features &= ~NETIF_F_HW_TLS_TX;
9760 		}
9761 	}
9762 
9763 	if ((features & NETIF_F_HW_TLS_RX) && !(features & NETIF_F_RXCSUM)) {
9764 		netdev_dbg(dev, "Dropping TLS RX HW offload feature since no RXCSUM feature.\n");
9765 		features &= ~NETIF_F_HW_TLS_RX;
9766 	}
9767 
9768 	return features;
9769 }
9770 
9771 int __netdev_update_features(struct net_device *dev)
9772 {
9773 	struct net_device *upper, *lower;
9774 	netdev_features_t features;
9775 	struct list_head *iter;
9776 	int err = -1;
9777 
9778 	ASSERT_RTNL();
9779 
9780 	features = netdev_get_wanted_features(dev);
9781 
9782 	if (dev->netdev_ops->ndo_fix_features)
9783 		features = dev->netdev_ops->ndo_fix_features(dev, features);
9784 
9785 	/* driver might be less strict about feature dependencies */
9786 	features = netdev_fix_features(dev, features);
9787 
9788 	/* some features can't be enabled if they're off on an upper device */
9789 	netdev_for_each_upper_dev_rcu(dev, upper, iter)
9790 		features = netdev_sync_upper_features(dev, upper, features);
9791 
9792 	if (dev->features == features)
9793 		goto sync_lower;
9794 
9795 	netdev_dbg(dev, "Features changed: %pNF -> %pNF\n",
9796 		&dev->features, &features);
9797 
9798 	if (dev->netdev_ops->ndo_set_features)
9799 		err = dev->netdev_ops->ndo_set_features(dev, features);
9800 	else
9801 		err = 0;
9802 
9803 	if (unlikely(err < 0)) {
9804 		netdev_err(dev,
9805 			"set_features() failed (%d); wanted %pNF, left %pNF\n",
9806 			err, &features, &dev->features);
9807 		/* return non-0 since some features might have changed and
9808 		 * it's better to fire a spurious notification than miss it
9809 		 */
9810 		return -1;
9811 	}
9812 
9813 sync_lower:
9814 	/* some features must be disabled on lower devices when disabled
9815 	 * on an upper device (think: bonding master or bridge)
9816 	 */
9817 	netdev_for_each_lower_dev(dev, lower, iter)
9818 		netdev_sync_lower_features(dev, lower, features);
9819 
9820 	if (!err) {
9821 		netdev_features_t diff = features ^ dev->features;
9822 
9823 		if (diff & NETIF_F_RX_UDP_TUNNEL_PORT) {
9824 			/* udp_tunnel_{get,drop}_rx_info both need
9825 			 * NETIF_F_RX_UDP_TUNNEL_PORT enabled on the
9826 			 * device, or they won't do anything.
9827 			 * Thus we need to update dev->features
9828 			 * *before* calling udp_tunnel_get_rx_info,
9829 			 * but *after* calling udp_tunnel_drop_rx_info.
9830 			 */
9831 			if (features & NETIF_F_RX_UDP_TUNNEL_PORT) {
9832 				dev->features = features;
9833 				udp_tunnel_get_rx_info(dev);
9834 			} else {
9835 				udp_tunnel_drop_rx_info(dev);
9836 			}
9837 		}
9838 
9839 		if (diff & NETIF_F_HW_VLAN_CTAG_FILTER) {
9840 			if (features & NETIF_F_HW_VLAN_CTAG_FILTER) {
9841 				dev->features = features;
9842 				err |= vlan_get_rx_ctag_filter_info(dev);
9843 			} else {
9844 				vlan_drop_rx_ctag_filter_info(dev);
9845 			}
9846 		}
9847 
9848 		if (diff & NETIF_F_HW_VLAN_STAG_FILTER) {
9849 			if (features & NETIF_F_HW_VLAN_STAG_FILTER) {
9850 				dev->features = features;
9851 				err |= vlan_get_rx_stag_filter_info(dev);
9852 			} else {
9853 				vlan_drop_rx_stag_filter_info(dev);
9854 			}
9855 		}
9856 
9857 		dev->features = features;
9858 	}
9859 
9860 	return err < 0 ? 0 : 1;
9861 }
9862 
9863 /**
9864  *	netdev_update_features - recalculate device features
9865  *	@dev: the device to check
9866  *
9867  *	Recalculate dev->features set and send notifications if it
9868  *	has changed. Should be called after driver or hardware dependent
9869  *	conditions might have changed that influence the features.
9870  */
9871 void netdev_update_features(struct net_device *dev)
9872 {
9873 	if (__netdev_update_features(dev))
9874 		netdev_features_change(dev);
9875 }
9876 EXPORT_SYMBOL(netdev_update_features);
9877 
9878 /**
9879  *	netdev_change_features - recalculate device features
9880  *	@dev: the device to check
9881  *
9882  *	Recalculate dev->features set and send notifications even
9883  *	if they have not changed. Should be called instead of
9884  *	netdev_update_features() if also dev->vlan_features might
9885  *	have changed to allow the changes to be propagated to stacked
9886  *	VLAN devices.
9887  */
9888 void netdev_change_features(struct net_device *dev)
9889 {
9890 	__netdev_update_features(dev);
9891 	netdev_features_change(dev);
9892 }
9893 EXPORT_SYMBOL(netdev_change_features);
9894 
9895 /**
9896  *	netif_stacked_transfer_operstate -	transfer operstate
9897  *	@rootdev: the root or lower level device to transfer state from
9898  *	@dev: the device to transfer operstate to
9899  *
9900  *	Transfer operational state from root to device. This is normally
9901  *	called when a stacking relationship exists between the root
9902  *	device and the device(a leaf device).
9903  */
9904 void netif_stacked_transfer_operstate(const struct net_device *rootdev,
9905 					struct net_device *dev)
9906 {
9907 	if (rootdev->operstate == IF_OPER_DORMANT)
9908 		netif_dormant_on(dev);
9909 	else
9910 		netif_dormant_off(dev);
9911 
9912 	if (rootdev->operstate == IF_OPER_TESTING)
9913 		netif_testing_on(dev);
9914 	else
9915 		netif_testing_off(dev);
9916 
9917 	if (netif_carrier_ok(rootdev))
9918 		netif_carrier_on(dev);
9919 	else
9920 		netif_carrier_off(dev);
9921 }
9922 EXPORT_SYMBOL(netif_stacked_transfer_operstate);
9923 
9924 static int netif_alloc_rx_queues(struct net_device *dev)
9925 {
9926 	unsigned int i, count = dev->num_rx_queues;
9927 	struct netdev_rx_queue *rx;
9928 	size_t sz = count * sizeof(*rx);
9929 	int err = 0;
9930 
9931 	BUG_ON(count < 1);
9932 
9933 	rx = kvzalloc(sz, GFP_KERNEL_ACCOUNT | __GFP_RETRY_MAYFAIL);
9934 	if (!rx)
9935 		return -ENOMEM;
9936 
9937 	dev->_rx = rx;
9938 
9939 	for (i = 0; i < count; i++) {
9940 		rx[i].dev = dev;
9941 
9942 		/* XDP RX-queue setup */
9943 		err = xdp_rxq_info_reg(&rx[i].xdp_rxq, dev, i, 0);
9944 		if (err < 0)
9945 			goto err_rxq_info;
9946 	}
9947 	return 0;
9948 
9949 err_rxq_info:
9950 	/* Rollback successful reg's and free other resources */
9951 	while (i--)
9952 		xdp_rxq_info_unreg(&rx[i].xdp_rxq);
9953 	kvfree(dev->_rx);
9954 	dev->_rx = NULL;
9955 	return err;
9956 }
9957 
9958 static void netif_free_rx_queues(struct net_device *dev)
9959 {
9960 	unsigned int i, count = dev->num_rx_queues;
9961 
9962 	/* netif_alloc_rx_queues alloc failed, resources have been unreg'ed */
9963 	if (!dev->_rx)
9964 		return;
9965 
9966 	for (i = 0; i < count; i++)
9967 		xdp_rxq_info_unreg(&dev->_rx[i].xdp_rxq);
9968 
9969 	kvfree(dev->_rx);
9970 }
9971 
9972 static void netdev_init_one_queue(struct net_device *dev,
9973 				  struct netdev_queue *queue, void *_unused)
9974 {
9975 	/* Initialize queue lock */
9976 	spin_lock_init(&queue->_xmit_lock);
9977 	netdev_set_xmit_lockdep_class(&queue->_xmit_lock, dev->type);
9978 	queue->xmit_lock_owner = -1;
9979 	netdev_queue_numa_node_write(queue, NUMA_NO_NODE);
9980 	queue->dev = dev;
9981 #ifdef CONFIG_BQL
9982 	dql_init(&queue->dql, HZ);
9983 #endif
9984 }
9985 
9986 static void netif_free_tx_queues(struct net_device *dev)
9987 {
9988 	kvfree(dev->_tx);
9989 }
9990 
9991 static int netif_alloc_netdev_queues(struct net_device *dev)
9992 {
9993 	unsigned int count = dev->num_tx_queues;
9994 	struct netdev_queue *tx;
9995 	size_t sz = count * sizeof(*tx);
9996 
9997 	if (count < 1 || count > 0xffff)
9998 		return -EINVAL;
9999 
10000 	tx = kvzalloc(sz, GFP_KERNEL_ACCOUNT | __GFP_RETRY_MAYFAIL);
10001 	if (!tx)
10002 		return -ENOMEM;
10003 
10004 	dev->_tx = tx;
10005 
10006 	netdev_for_each_tx_queue(dev, netdev_init_one_queue, NULL);
10007 	spin_lock_init(&dev->tx_global_lock);
10008 
10009 	return 0;
10010 }
10011 
10012 void netif_tx_stop_all_queues(struct net_device *dev)
10013 {
10014 	unsigned int i;
10015 
10016 	for (i = 0; i < dev->num_tx_queues; i++) {
10017 		struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
10018 
10019 		netif_tx_stop_queue(txq);
10020 	}
10021 }
10022 EXPORT_SYMBOL(netif_tx_stop_all_queues);
10023 
10024 /**
10025  * register_netdevice() - register a network device
10026  * @dev: device to register
10027  *
10028  * Take a prepared network device structure and make it externally accessible.
10029  * A %NETDEV_REGISTER message is sent to the netdev notifier chain.
10030  * Callers must hold the rtnl lock - you may want register_netdev()
10031  * instead of this.
10032  */
10033 int register_netdevice(struct net_device *dev)
10034 {
10035 	int ret;
10036 	struct net *net = dev_net(dev);
10037 
10038 	BUILD_BUG_ON(sizeof(netdev_features_t) * BITS_PER_BYTE <
10039 		     NETDEV_FEATURE_COUNT);
10040 	BUG_ON(dev_boot_phase);
10041 	ASSERT_RTNL();
10042 
10043 	might_sleep();
10044 
10045 	/* When net_device's are persistent, this will be fatal. */
10046 	BUG_ON(dev->reg_state != NETREG_UNINITIALIZED);
10047 	BUG_ON(!net);
10048 
10049 	ret = ethtool_check_ops(dev->ethtool_ops);
10050 	if (ret)
10051 		return ret;
10052 
10053 	spin_lock_init(&dev->addr_list_lock);
10054 	netdev_set_addr_lockdep_class(dev);
10055 
10056 	ret = dev_get_valid_name(net, dev, dev->name);
10057 	if (ret < 0)
10058 		goto out;
10059 
10060 	ret = -ENOMEM;
10061 	dev->name_node = netdev_name_node_head_alloc(dev);
10062 	if (!dev->name_node)
10063 		goto out;
10064 
10065 	/* Init, if this function is available */
10066 	if (dev->netdev_ops->ndo_init) {
10067 		ret = dev->netdev_ops->ndo_init(dev);
10068 		if (ret) {
10069 			if (ret > 0)
10070 				ret = -EIO;
10071 			goto err_free_name;
10072 		}
10073 	}
10074 
10075 	if (((dev->hw_features | dev->features) &
10076 	     NETIF_F_HW_VLAN_CTAG_FILTER) &&
10077 	    (!dev->netdev_ops->ndo_vlan_rx_add_vid ||
10078 	     !dev->netdev_ops->ndo_vlan_rx_kill_vid)) {
10079 		netdev_WARN(dev, "Buggy VLAN acceleration in driver!\n");
10080 		ret = -EINVAL;
10081 		goto err_uninit;
10082 	}
10083 
10084 	ret = dev_index_reserve(net, dev->ifindex);
10085 	if (ret < 0)
10086 		goto err_uninit;
10087 	dev->ifindex = ret;
10088 
10089 	/* Transfer changeable features to wanted_features and enable
10090 	 * software offloads (GSO and GRO).
10091 	 */
10092 	dev->hw_features |= (NETIF_F_SOFT_FEATURES | NETIF_F_SOFT_FEATURES_OFF);
10093 	dev->features |= NETIF_F_SOFT_FEATURES;
10094 
10095 	if (dev->udp_tunnel_nic_info) {
10096 		dev->features |= NETIF_F_RX_UDP_TUNNEL_PORT;
10097 		dev->hw_features |= NETIF_F_RX_UDP_TUNNEL_PORT;
10098 	}
10099 
10100 	dev->wanted_features = dev->features & dev->hw_features;
10101 
10102 	if (!(dev->flags & IFF_LOOPBACK))
10103 		dev->hw_features |= NETIF_F_NOCACHE_COPY;
10104 
10105 	/* If IPv4 TCP segmentation offload is supported we should also
10106 	 * allow the device to enable segmenting the frame with the option
10107 	 * of ignoring a static IP ID value.  This doesn't enable the
10108 	 * feature itself but allows the user to enable it later.
10109 	 */
10110 	if (dev->hw_features & NETIF_F_TSO)
10111 		dev->hw_features |= NETIF_F_TSO_MANGLEID;
10112 	if (dev->vlan_features & NETIF_F_TSO)
10113 		dev->vlan_features |= NETIF_F_TSO_MANGLEID;
10114 	if (dev->mpls_features & NETIF_F_TSO)
10115 		dev->mpls_features |= NETIF_F_TSO_MANGLEID;
10116 	if (dev->hw_enc_features & NETIF_F_TSO)
10117 		dev->hw_enc_features |= NETIF_F_TSO_MANGLEID;
10118 
10119 	/* Make NETIF_F_HIGHDMA inheritable to VLAN devices.
10120 	 */
10121 	dev->vlan_features |= NETIF_F_HIGHDMA;
10122 
10123 	/* Make NETIF_F_SG inheritable to tunnel devices.
10124 	 */
10125 	dev->hw_enc_features |= NETIF_F_SG | NETIF_F_GSO_PARTIAL;
10126 
10127 	/* Make NETIF_F_SG inheritable to MPLS.
10128 	 */
10129 	dev->mpls_features |= NETIF_F_SG;
10130 
10131 	ret = call_netdevice_notifiers(NETDEV_POST_INIT, dev);
10132 	ret = notifier_to_errno(ret);
10133 	if (ret)
10134 		goto err_ifindex_release;
10135 
10136 	ret = netdev_register_kobject(dev);
10137 	write_lock(&dev_base_lock);
10138 	dev->reg_state = ret ? NETREG_UNREGISTERED : NETREG_REGISTERED;
10139 	write_unlock(&dev_base_lock);
10140 	if (ret)
10141 		goto err_uninit_notify;
10142 
10143 	__netdev_update_features(dev);
10144 
10145 	/*
10146 	 *	Default initial state at registry is that the
10147 	 *	device is present.
10148 	 */
10149 
10150 	set_bit(__LINK_STATE_PRESENT, &dev->state);
10151 
10152 	linkwatch_init_dev(dev);
10153 
10154 	dev_init_scheduler(dev);
10155 
10156 	netdev_hold(dev, &dev->dev_registered_tracker, GFP_KERNEL);
10157 	list_netdevice(dev);
10158 
10159 	add_device_randomness(dev->dev_addr, dev->addr_len);
10160 
10161 	/* If the device has permanent device address, driver should
10162 	 * set dev_addr and also addr_assign_type should be set to
10163 	 * NET_ADDR_PERM (default value).
10164 	 */
10165 	if (dev->addr_assign_type == NET_ADDR_PERM)
10166 		memcpy(dev->perm_addr, dev->dev_addr, dev->addr_len);
10167 
10168 	/* Notify protocols, that a new device appeared. */
10169 	ret = call_netdevice_notifiers(NETDEV_REGISTER, dev);
10170 	ret = notifier_to_errno(ret);
10171 	if (ret) {
10172 		/* Expect explicit free_netdev() on failure */
10173 		dev->needs_free_netdev = false;
10174 		unregister_netdevice_queue(dev, NULL);
10175 		goto out;
10176 	}
10177 	/*
10178 	 *	Prevent userspace races by waiting until the network
10179 	 *	device is fully setup before sending notifications.
10180 	 */
10181 	if (!dev->rtnl_link_ops ||
10182 	    dev->rtnl_link_state == RTNL_LINK_INITIALIZED)
10183 		rtmsg_ifinfo(RTM_NEWLINK, dev, ~0U, GFP_KERNEL, 0, NULL);
10184 
10185 out:
10186 	return ret;
10187 
10188 err_uninit_notify:
10189 	call_netdevice_notifiers(NETDEV_PRE_UNINIT, dev);
10190 err_ifindex_release:
10191 	dev_index_release(net, dev->ifindex);
10192 err_uninit:
10193 	if (dev->netdev_ops->ndo_uninit)
10194 		dev->netdev_ops->ndo_uninit(dev);
10195 	if (dev->priv_destructor)
10196 		dev->priv_destructor(dev);
10197 err_free_name:
10198 	netdev_name_node_free(dev->name_node);
10199 	goto out;
10200 }
10201 EXPORT_SYMBOL(register_netdevice);
10202 
10203 /**
10204  *	init_dummy_netdev	- init a dummy network device for NAPI
10205  *	@dev: device to init
10206  *
10207  *	This takes a network device structure and initialize the minimum
10208  *	amount of fields so it can be used to schedule NAPI polls without
10209  *	registering a full blown interface. This is to be used by drivers
10210  *	that need to tie several hardware interfaces to a single NAPI
10211  *	poll scheduler due to HW limitations.
10212  */
10213 int init_dummy_netdev(struct net_device *dev)
10214 {
10215 	/* Clear everything. Note we don't initialize spinlocks
10216 	 * are they aren't supposed to be taken by any of the
10217 	 * NAPI code and this dummy netdev is supposed to be
10218 	 * only ever used for NAPI polls
10219 	 */
10220 	memset(dev, 0, sizeof(struct net_device));
10221 
10222 	/* make sure we BUG if trying to hit standard
10223 	 * register/unregister code path
10224 	 */
10225 	dev->reg_state = NETREG_DUMMY;
10226 
10227 	/* NAPI wants this */
10228 	INIT_LIST_HEAD(&dev->napi_list);
10229 
10230 	/* a dummy interface is started by default */
10231 	set_bit(__LINK_STATE_PRESENT, &dev->state);
10232 	set_bit(__LINK_STATE_START, &dev->state);
10233 
10234 	/* napi_busy_loop stats accounting wants this */
10235 	dev_net_set(dev, &init_net);
10236 
10237 	/* Note : We dont allocate pcpu_refcnt for dummy devices,
10238 	 * because users of this 'device' dont need to change
10239 	 * its refcount.
10240 	 */
10241 
10242 	return 0;
10243 }
10244 EXPORT_SYMBOL_GPL(init_dummy_netdev);
10245 
10246 
10247 /**
10248  *	register_netdev	- register a network device
10249  *	@dev: device to register
10250  *
10251  *	Take a completed network device structure and add it to the kernel
10252  *	interfaces. A %NETDEV_REGISTER message is sent to the netdev notifier
10253  *	chain. 0 is returned on success. A negative errno code is returned
10254  *	on a failure to set up the device, or if the name is a duplicate.
10255  *
10256  *	This is a wrapper around register_netdevice that takes the rtnl semaphore
10257  *	and expands the device name if you passed a format string to
10258  *	alloc_netdev.
10259  */
10260 int register_netdev(struct net_device *dev)
10261 {
10262 	int err;
10263 
10264 	if (rtnl_lock_killable())
10265 		return -EINTR;
10266 	err = register_netdevice(dev);
10267 	rtnl_unlock();
10268 	return err;
10269 }
10270 EXPORT_SYMBOL(register_netdev);
10271 
10272 int netdev_refcnt_read(const struct net_device *dev)
10273 {
10274 #ifdef CONFIG_PCPU_DEV_REFCNT
10275 	int i, refcnt = 0;
10276 
10277 	for_each_possible_cpu(i)
10278 		refcnt += *per_cpu_ptr(dev->pcpu_refcnt, i);
10279 	return refcnt;
10280 #else
10281 	return refcount_read(&dev->dev_refcnt);
10282 #endif
10283 }
10284 EXPORT_SYMBOL(netdev_refcnt_read);
10285 
10286 int netdev_unregister_timeout_secs __read_mostly = 10;
10287 
10288 #define WAIT_REFS_MIN_MSECS 1
10289 #define WAIT_REFS_MAX_MSECS 250
10290 /**
10291  * netdev_wait_allrefs_any - wait until all references are gone.
10292  * @list: list of net_devices to wait on
10293  *
10294  * This is called when unregistering network devices.
10295  *
10296  * Any protocol or device that holds a reference should register
10297  * for netdevice notification, and cleanup and put back the
10298  * reference if they receive an UNREGISTER event.
10299  * We can get stuck here if buggy protocols don't correctly
10300  * call dev_put.
10301  */
10302 static struct net_device *netdev_wait_allrefs_any(struct list_head *list)
10303 {
10304 	unsigned long rebroadcast_time, warning_time;
10305 	struct net_device *dev;
10306 	int wait = 0;
10307 
10308 	rebroadcast_time = warning_time = jiffies;
10309 
10310 	list_for_each_entry(dev, list, todo_list)
10311 		if (netdev_refcnt_read(dev) == 1)
10312 			return dev;
10313 
10314 	while (true) {
10315 		if (time_after(jiffies, rebroadcast_time + 1 * HZ)) {
10316 			rtnl_lock();
10317 
10318 			/* Rebroadcast unregister notification */
10319 			list_for_each_entry(dev, list, todo_list)
10320 				call_netdevice_notifiers(NETDEV_UNREGISTER, dev);
10321 
10322 			__rtnl_unlock();
10323 			rcu_barrier();
10324 			rtnl_lock();
10325 
10326 			list_for_each_entry(dev, list, todo_list)
10327 				if (test_bit(__LINK_STATE_LINKWATCH_PENDING,
10328 					     &dev->state)) {
10329 					/* We must not have linkwatch events
10330 					 * pending on unregister. If this
10331 					 * happens, we simply run the queue
10332 					 * unscheduled, resulting in a noop
10333 					 * for this device.
10334 					 */
10335 					linkwatch_run_queue();
10336 					break;
10337 				}
10338 
10339 			__rtnl_unlock();
10340 
10341 			rebroadcast_time = jiffies;
10342 		}
10343 
10344 		if (!wait) {
10345 			rcu_barrier();
10346 			wait = WAIT_REFS_MIN_MSECS;
10347 		} else {
10348 			msleep(wait);
10349 			wait = min(wait << 1, WAIT_REFS_MAX_MSECS);
10350 		}
10351 
10352 		list_for_each_entry(dev, list, todo_list)
10353 			if (netdev_refcnt_read(dev) == 1)
10354 				return dev;
10355 
10356 		if (time_after(jiffies, warning_time +
10357 			       READ_ONCE(netdev_unregister_timeout_secs) * HZ)) {
10358 			list_for_each_entry(dev, list, todo_list) {
10359 				pr_emerg("unregister_netdevice: waiting for %s to become free. Usage count = %d\n",
10360 					 dev->name, netdev_refcnt_read(dev));
10361 				ref_tracker_dir_print(&dev->refcnt_tracker, 10);
10362 			}
10363 
10364 			warning_time = jiffies;
10365 		}
10366 	}
10367 }
10368 
10369 /* The sequence is:
10370  *
10371  *	rtnl_lock();
10372  *	...
10373  *	register_netdevice(x1);
10374  *	register_netdevice(x2);
10375  *	...
10376  *	unregister_netdevice(y1);
10377  *	unregister_netdevice(y2);
10378  *      ...
10379  *	rtnl_unlock();
10380  *	free_netdev(y1);
10381  *	free_netdev(y2);
10382  *
10383  * We are invoked by rtnl_unlock().
10384  * This allows us to deal with problems:
10385  * 1) We can delete sysfs objects which invoke hotplug
10386  *    without deadlocking with linkwatch via keventd.
10387  * 2) Since we run with the RTNL semaphore not held, we can sleep
10388  *    safely in order to wait for the netdev refcnt to drop to zero.
10389  *
10390  * We must not return until all unregister events added during
10391  * the interval the lock was held have been completed.
10392  */
10393 void netdev_run_todo(void)
10394 {
10395 	struct net_device *dev, *tmp;
10396 	struct list_head list;
10397 #ifdef CONFIG_LOCKDEP
10398 	struct list_head unlink_list;
10399 
10400 	list_replace_init(&net_unlink_list, &unlink_list);
10401 
10402 	while (!list_empty(&unlink_list)) {
10403 		struct net_device *dev = list_first_entry(&unlink_list,
10404 							  struct net_device,
10405 							  unlink_list);
10406 		list_del_init(&dev->unlink_list);
10407 		dev->nested_level = dev->lower_level - 1;
10408 	}
10409 #endif
10410 
10411 	/* Snapshot list, allow later requests */
10412 	list_replace_init(&net_todo_list, &list);
10413 
10414 	__rtnl_unlock();
10415 
10416 	/* Wait for rcu callbacks to finish before next phase */
10417 	if (!list_empty(&list))
10418 		rcu_barrier();
10419 
10420 	list_for_each_entry_safe(dev, tmp, &list, todo_list) {
10421 		if (unlikely(dev->reg_state != NETREG_UNREGISTERING)) {
10422 			netdev_WARN(dev, "run_todo but not unregistering\n");
10423 			list_del(&dev->todo_list);
10424 			continue;
10425 		}
10426 
10427 		write_lock(&dev_base_lock);
10428 		dev->reg_state = NETREG_UNREGISTERED;
10429 		write_unlock(&dev_base_lock);
10430 		linkwatch_forget_dev(dev);
10431 	}
10432 
10433 	while (!list_empty(&list)) {
10434 		dev = netdev_wait_allrefs_any(&list);
10435 		list_del(&dev->todo_list);
10436 
10437 		/* paranoia */
10438 		BUG_ON(netdev_refcnt_read(dev) != 1);
10439 		BUG_ON(!list_empty(&dev->ptype_all));
10440 		BUG_ON(!list_empty(&dev->ptype_specific));
10441 		WARN_ON(rcu_access_pointer(dev->ip_ptr));
10442 		WARN_ON(rcu_access_pointer(dev->ip6_ptr));
10443 
10444 		if (dev->priv_destructor)
10445 			dev->priv_destructor(dev);
10446 		if (dev->needs_free_netdev)
10447 			free_netdev(dev);
10448 
10449 		if (atomic_dec_and_test(&dev_net(dev)->dev_unreg_count))
10450 			wake_up(&netdev_unregistering_wq);
10451 
10452 		/* Free network device */
10453 		kobject_put(&dev->dev.kobj);
10454 	}
10455 }
10456 
10457 /* Convert net_device_stats to rtnl_link_stats64. rtnl_link_stats64 has
10458  * all the same fields in the same order as net_device_stats, with only
10459  * the type differing, but rtnl_link_stats64 may have additional fields
10460  * at the end for newer counters.
10461  */
10462 void netdev_stats_to_stats64(struct rtnl_link_stats64 *stats64,
10463 			     const struct net_device_stats *netdev_stats)
10464 {
10465 	size_t i, n = sizeof(*netdev_stats) / sizeof(atomic_long_t);
10466 	const atomic_long_t *src = (atomic_long_t *)netdev_stats;
10467 	u64 *dst = (u64 *)stats64;
10468 
10469 	BUILD_BUG_ON(n > sizeof(*stats64) / sizeof(u64));
10470 	for (i = 0; i < n; i++)
10471 		dst[i] = (unsigned long)atomic_long_read(&src[i]);
10472 	/* zero out counters that only exist in rtnl_link_stats64 */
10473 	memset((char *)stats64 + n * sizeof(u64), 0,
10474 	       sizeof(*stats64) - n * sizeof(u64));
10475 }
10476 EXPORT_SYMBOL(netdev_stats_to_stats64);
10477 
10478 struct net_device_core_stats __percpu *netdev_core_stats_alloc(struct net_device *dev)
10479 {
10480 	struct net_device_core_stats __percpu *p;
10481 
10482 	p = alloc_percpu_gfp(struct net_device_core_stats,
10483 			     GFP_ATOMIC | __GFP_NOWARN);
10484 
10485 	if (p && cmpxchg(&dev->core_stats, NULL, p))
10486 		free_percpu(p);
10487 
10488 	/* This READ_ONCE() pairs with the cmpxchg() above */
10489 	return READ_ONCE(dev->core_stats);
10490 }
10491 EXPORT_SYMBOL(netdev_core_stats_alloc);
10492 
10493 /**
10494  *	dev_get_stats	- get network device statistics
10495  *	@dev: device to get statistics from
10496  *	@storage: place to store stats
10497  *
10498  *	Get network statistics from device. Return @storage.
10499  *	The device driver may provide its own method by setting
10500  *	dev->netdev_ops->get_stats64 or dev->netdev_ops->get_stats;
10501  *	otherwise the internal statistics structure is used.
10502  */
10503 struct rtnl_link_stats64 *dev_get_stats(struct net_device *dev,
10504 					struct rtnl_link_stats64 *storage)
10505 {
10506 	const struct net_device_ops *ops = dev->netdev_ops;
10507 	const struct net_device_core_stats __percpu *p;
10508 
10509 	if (ops->ndo_get_stats64) {
10510 		memset(storage, 0, sizeof(*storage));
10511 		ops->ndo_get_stats64(dev, storage);
10512 	} else if (ops->ndo_get_stats) {
10513 		netdev_stats_to_stats64(storage, ops->ndo_get_stats(dev));
10514 	} else {
10515 		netdev_stats_to_stats64(storage, &dev->stats);
10516 	}
10517 
10518 	/* This READ_ONCE() pairs with the write in netdev_core_stats_alloc() */
10519 	p = READ_ONCE(dev->core_stats);
10520 	if (p) {
10521 		const struct net_device_core_stats *core_stats;
10522 		int i;
10523 
10524 		for_each_possible_cpu(i) {
10525 			core_stats = per_cpu_ptr(p, i);
10526 			storage->rx_dropped += READ_ONCE(core_stats->rx_dropped);
10527 			storage->tx_dropped += READ_ONCE(core_stats->tx_dropped);
10528 			storage->rx_nohandler += READ_ONCE(core_stats->rx_nohandler);
10529 			storage->rx_otherhost_dropped += READ_ONCE(core_stats->rx_otherhost_dropped);
10530 		}
10531 	}
10532 	return storage;
10533 }
10534 EXPORT_SYMBOL(dev_get_stats);
10535 
10536 /**
10537  *	dev_fetch_sw_netstats - get per-cpu network device statistics
10538  *	@s: place to store stats
10539  *	@netstats: per-cpu network stats to read from
10540  *
10541  *	Read per-cpu network statistics and populate the related fields in @s.
10542  */
10543 void dev_fetch_sw_netstats(struct rtnl_link_stats64 *s,
10544 			   const struct pcpu_sw_netstats __percpu *netstats)
10545 {
10546 	int cpu;
10547 
10548 	for_each_possible_cpu(cpu) {
10549 		u64 rx_packets, rx_bytes, tx_packets, tx_bytes;
10550 		const struct pcpu_sw_netstats *stats;
10551 		unsigned int start;
10552 
10553 		stats = per_cpu_ptr(netstats, cpu);
10554 		do {
10555 			start = u64_stats_fetch_begin(&stats->syncp);
10556 			rx_packets = u64_stats_read(&stats->rx_packets);
10557 			rx_bytes   = u64_stats_read(&stats->rx_bytes);
10558 			tx_packets = u64_stats_read(&stats->tx_packets);
10559 			tx_bytes   = u64_stats_read(&stats->tx_bytes);
10560 		} while (u64_stats_fetch_retry(&stats->syncp, start));
10561 
10562 		s->rx_packets += rx_packets;
10563 		s->rx_bytes   += rx_bytes;
10564 		s->tx_packets += tx_packets;
10565 		s->tx_bytes   += tx_bytes;
10566 	}
10567 }
10568 EXPORT_SYMBOL_GPL(dev_fetch_sw_netstats);
10569 
10570 /**
10571  *	dev_get_tstats64 - ndo_get_stats64 implementation
10572  *	@dev: device to get statistics from
10573  *	@s: place to store stats
10574  *
10575  *	Populate @s from dev->stats and dev->tstats. Can be used as
10576  *	ndo_get_stats64() callback.
10577  */
10578 void dev_get_tstats64(struct net_device *dev, struct rtnl_link_stats64 *s)
10579 {
10580 	netdev_stats_to_stats64(s, &dev->stats);
10581 	dev_fetch_sw_netstats(s, dev->tstats);
10582 }
10583 EXPORT_SYMBOL_GPL(dev_get_tstats64);
10584 
10585 struct netdev_queue *dev_ingress_queue_create(struct net_device *dev)
10586 {
10587 	struct netdev_queue *queue = dev_ingress_queue(dev);
10588 
10589 #ifdef CONFIG_NET_CLS_ACT
10590 	if (queue)
10591 		return queue;
10592 	queue = kzalloc(sizeof(*queue), GFP_KERNEL);
10593 	if (!queue)
10594 		return NULL;
10595 	netdev_init_one_queue(dev, queue, NULL);
10596 	RCU_INIT_POINTER(queue->qdisc, &noop_qdisc);
10597 	RCU_INIT_POINTER(queue->qdisc_sleeping, &noop_qdisc);
10598 	rcu_assign_pointer(dev->ingress_queue, queue);
10599 #endif
10600 	return queue;
10601 }
10602 
10603 static const struct ethtool_ops default_ethtool_ops;
10604 
10605 void netdev_set_default_ethtool_ops(struct net_device *dev,
10606 				    const struct ethtool_ops *ops)
10607 {
10608 	if (dev->ethtool_ops == &default_ethtool_ops)
10609 		dev->ethtool_ops = ops;
10610 }
10611 EXPORT_SYMBOL_GPL(netdev_set_default_ethtool_ops);
10612 
10613 /**
10614  * netdev_sw_irq_coalesce_default_on() - enable SW IRQ coalescing by default
10615  * @dev: netdev to enable the IRQ coalescing on
10616  *
10617  * Sets a conservative default for SW IRQ coalescing. Users can use
10618  * sysfs attributes to override the default values.
10619  */
10620 void netdev_sw_irq_coalesce_default_on(struct net_device *dev)
10621 {
10622 	WARN_ON(dev->reg_state == NETREG_REGISTERED);
10623 
10624 	if (!IS_ENABLED(CONFIG_PREEMPT_RT)) {
10625 		dev->gro_flush_timeout = 20000;
10626 		dev->napi_defer_hard_irqs = 1;
10627 	}
10628 }
10629 EXPORT_SYMBOL_GPL(netdev_sw_irq_coalesce_default_on);
10630 
10631 void netdev_freemem(struct net_device *dev)
10632 {
10633 	char *addr = (char *)dev - dev->padded;
10634 
10635 	kvfree(addr);
10636 }
10637 
10638 /**
10639  * alloc_netdev_mqs - allocate network device
10640  * @sizeof_priv: size of private data to allocate space for
10641  * @name: device name format string
10642  * @name_assign_type: origin of device name
10643  * @setup: callback to initialize device
10644  * @txqs: the number of TX subqueues to allocate
10645  * @rxqs: the number of RX subqueues to allocate
10646  *
10647  * Allocates a struct net_device with private data area for driver use
10648  * and performs basic initialization.  Also allocates subqueue structs
10649  * for each queue on the device.
10650  */
10651 struct net_device *alloc_netdev_mqs(int sizeof_priv, const char *name,
10652 		unsigned char name_assign_type,
10653 		void (*setup)(struct net_device *),
10654 		unsigned int txqs, unsigned int rxqs)
10655 {
10656 	struct net_device *dev;
10657 	unsigned int alloc_size;
10658 	struct net_device *p;
10659 
10660 	BUG_ON(strlen(name) >= sizeof(dev->name));
10661 
10662 	if (txqs < 1) {
10663 		pr_err("alloc_netdev: Unable to allocate device with zero queues\n");
10664 		return NULL;
10665 	}
10666 
10667 	if (rxqs < 1) {
10668 		pr_err("alloc_netdev: Unable to allocate device with zero RX queues\n");
10669 		return NULL;
10670 	}
10671 
10672 	alloc_size = sizeof(struct net_device);
10673 	if (sizeof_priv) {
10674 		/* ensure 32-byte alignment of private area */
10675 		alloc_size = ALIGN(alloc_size, NETDEV_ALIGN);
10676 		alloc_size += sizeof_priv;
10677 	}
10678 	/* ensure 32-byte alignment of whole construct */
10679 	alloc_size += NETDEV_ALIGN - 1;
10680 
10681 	p = kvzalloc(alloc_size, GFP_KERNEL_ACCOUNT | __GFP_RETRY_MAYFAIL);
10682 	if (!p)
10683 		return NULL;
10684 
10685 	dev = PTR_ALIGN(p, NETDEV_ALIGN);
10686 	dev->padded = (char *)dev - (char *)p;
10687 
10688 	ref_tracker_dir_init(&dev->refcnt_tracker, 128, name);
10689 #ifdef CONFIG_PCPU_DEV_REFCNT
10690 	dev->pcpu_refcnt = alloc_percpu(int);
10691 	if (!dev->pcpu_refcnt)
10692 		goto free_dev;
10693 	__dev_hold(dev);
10694 #else
10695 	refcount_set(&dev->dev_refcnt, 1);
10696 #endif
10697 
10698 	if (dev_addr_init(dev))
10699 		goto free_pcpu;
10700 
10701 	dev_mc_init(dev);
10702 	dev_uc_init(dev);
10703 
10704 	dev_net_set(dev, &init_net);
10705 
10706 	dev->gso_max_size = GSO_LEGACY_MAX_SIZE;
10707 	dev->xdp_zc_max_segs = 1;
10708 	dev->gso_max_segs = GSO_MAX_SEGS;
10709 	dev->gro_max_size = GRO_LEGACY_MAX_SIZE;
10710 	dev->gso_ipv4_max_size = GSO_LEGACY_MAX_SIZE;
10711 	dev->gro_ipv4_max_size = GRO_LEGACY_MAX_SIZE;
10712 	dev->tso_max_size = TSO_LEGACY_MAX_SIZE;
10713 	dev->tso_max_segs = TSO_MAX_SEGS;
10714 	dev->upper_level = 1;
10715 	dev->lower_level = 1;
10716 #ifdef CONFIG_LOCKDEP
10717 	dev->nested_level = 0;
10718 	INIT_LIST_HEAD(&dev->unlink_list);
10719 #endif
10720 
10721 	INIT_LIST_HEAD(&dev->napi_list);
10722 	INIT_LIST_HEAD(&dev->unreg_list);
10723 	INIT_LIST_HEAD(&dev->close_list);
10724 	INIT_LIST_HEAD(&dev->link_watch_list);
10725 	INIT_LIST_HEAD(&dev->adj_list.upper);
10726 	INIT_LIST_HEAD(&dev->adj_list.lower);
10727 	INIT_LIST_HEAD(&dev->ptype_all);
10728 	INIT_LIST_HEAD(&dev->ptype_specific);
10729 	INIT_LIST_HEAD(&dev->net_notifier_list);
10730 #ifdef CONFIG_NET_SCHED
10731 	hash_init(dev->qdisc_hash);
10732 #endif
10733 	dev->priv_flags = IFF_XMIT_DST_RELEASE | IFF_XMIT_DST_RELEASE_PERM;
10734 	setup(dev);
10735 
10736 	if (!dev->tx_queue_len) {
10737 		dev->priv_flags |= IFF_NO_QUEUE;
10738 		dev->tx_queue_len = DEFAULT_TX_QUEUE_LEN;
10739 	}
10740 
10741 	dev->num_tx_queues = txqs;
10742 	dev->real_num_tx_queues = txqs;
10743 	if (netif_alloc_netdev_queues(dev))
10744 		goto free_all;
10745 
10746 	dev->num_rx_queues = rxqs;
10747 	dev->real_num_rx_queues = rxqs;
10748 	if (netif_alloc_rx_queues(dev))
10749 		goto free_all;
10750 
10751 	strcpy(dev->name, name);
10752 	dev->name_assign_type = name_assign_type;
10753 	dev->group = INIT_NETDEV_GROUP;
10754 	if (!dev->ethtool_ops)
10755 		dev->ethtool_ops = &default_ethtool_ops;
10756 
10757 	nf_hook_netdev_init(dev);
10758 
10759 	return dev;
10760 
10761 free_all:
10762 	free_netdev(dev);
10763 	return NULL;
10764 
10765 free_pcpu:
10766 #ifdef CONFIG_PCPU_DEV_REFCNT
10767 	free_percpu(dev->pcpu_refcnt);
10768 free_dev:
10769 #endif
10770 	netdev_freemem(dev);
10771 	return NULL;
10772 }
10773 EXPORT_SYMBOL(alloc_netdev_mqs);
10774 
10775 /**
10776  * free_netdev - free network device
10777  * @dev: device
10778  *
10779  * This function does the last stage of destroying an allocated device
10780  * interface. The reference to the device object is released. If this
10781  * is the last reference then it will be freed.Must be called in process
10782  * context.
10783  */
10784 void free_netdev(struct net_device *dev)
10785 {
10786 	struct napi_struct *p, *n;
10787 
10788 	might_sleep();
10789 
10790 	/* When called immediately after register_netdevice() failed the unwind
10791 	 * handling may still be dismantling the device. Handle that case by
10792 	 * deferring the free.
10793 	 */
10794 	if (dev->reg_state == NETREG_UNREGISTERING) {
10795 		ASSERT_RTNL();
10796 		dev->needs_free_netdev = true;
10797 		return;
10798 	}
10799 
10800 	netif_free_tx_queues(dev);
10801 	netif_free_rx_queues(dev);
10802 
10803 	kfree(rcu_dereference_protected(dev->ingress_queue, 1));
10804 
10805 	/* Flush device addresses */
10806 	dev_addr_flush(dev);
10807 
10808 	list_for_each_entry_safe(p, n, &dev->napi_list, dev_list)
10809 		netif_napi_del(p);
10810 
10811 	ref_tracker_dir_exit(&dev->refcnt_tracker);
10812 #ifdef CONFIG_PCPU_DEV_REFCNT
10813 	free_percpu(dev->pcpu_refcnt);
10814 	dev->pcpu_refcnt = NULL;
10815 #endif
10816 	free_percpu(dev->core_stats);
10817 	dev->core_stats = NULL;
10818 	free_percpu(dev->xdp_bulkq);
10819 	dev->xdp_bulkq = NULL;
10820 
10821 	/*  Compatibility with error handling in drivers */
10822 	if (dev->reg_state == NETREG_UNINITIALIZED) {
10823 		netdev_freemem(dev);
10824 		return;
10825 	}
10826 
10827 	BUG_ON(dev->reg_state != NETREG_UNREGISTERED);
10828 	dev->reg_state = NETREG_RELEASED;
10829 
10830 	/* will free via device release */
10831 	put_device(&dev->dev);
10832 }
10833 EXPORT_SYMBOL(free_netdev);
10834 
10835 /**
10836  *	synchronize_net -  Synchronize with packet receive processing
10837  *
10838  *	Wait for packets currently being received to be done.
10839  *	Does not block later packets from starting.
10840  */
10841 void synchronize_net(void)
10842 {
10843 	might_sleep();
10844 	if (rtnl_is_locked())
10845 		synchronize_rcu_expedited();
10846 	else
10847 		synchronize_rcu();
10848 }
10849 EXPORT_SYMBOL(synchronize_net);
10850 
10851 /**
10852  *	unregister_netdevice_queue - remove device from the kernel
10853  *	@dev: device
10854  *	@head: list
10855  *
10856  *	This function shuts down a device interface and removes it
10857  *	from the kernel tables.
10858  *	If head not NULL, device is queued to be unregistered later.
10859  *
10860  *	Callers must hold the rtnl semaphore.  You may want
10861  *	unregister_netdev() instead of this.
10862  */
10863 
10864 void unregister_netdevice_queue(struct net_device *dev, struct list_head *head)
10865 {
10866 	ASSERT_RTNL();
10867 
10868 	if (head) {
10869 		list_move_tail(&dev->unreg_list, head);
10870 	} else {
10871 		LIST_HEAD(single);
10872 
10873 		list_add(&dev->unreg_list, &single);
10874 		unregister_netdevice_many(&single);
10875 	}
10876 }
10877 EXPORT_SYMBOL(unregister_netdevice_queue);
10878 
10879 void unregister_netdevice_many_notify(struct list_head *head,
10880 				      u32 portid, const struct nlmsghdr *nlh)
10881 {
10882 	struct net_device *dev, *tmp;
10883 	LIST_HEAD(close_head);
10884 
10885 	BUG_ON(dev_boot_phase);
10886 	ASSERT_RTNL();
10887 
10888 	if (list_empty(head))
10889 		return;
10890 
10891 	list_for_each_entry_safe(dev, tmp, head, unreg_list) {
10892 		/* Some devices call without registering
10893 		 * for initialization unwind. Remove those
10894 		 * devices and proceed with the remaining.
10895 		 */
10896 		if (dev->reg_state == NETREG_UNINITIALIZED) {
10897 			pr_debug("unregister_netdevice: device %s/%p never was registered\n",
10898 				 dev->name, dev);
10899 
10900 			WARN_ON(1);
10901 			list_del(&dev->unreg_list);
10902 			continue;
10903 		}
10904 		dev->dismantle = true;
10905 		BUG_ON(dev->reg_state != NETREG_REGISTERED);
10906 	}
10907 
10908 	/* If device is running, close it first. */
10909 	list_for_each_entry(dev, head, unreg_list)
10910 		list_add_tail(&dev->close_list, &close_head);
10911 	dev_close_many(&close_head, true);
10912 
10913 	list_for_each_entry(dev, head, unreg_list) {
10914 		/* And unlink it from device chain. */
10915 		write_lock(&dev_base_lock);
10916 		unlist_netdevice(dev, false);
10917 		dev->reg_state = NETREG_UNREGISTERING;
10918 		write_unlock(&dev_base_lock);
10919 	}
10920 	flush_all_backlogs();
10921 
10922 	synchronize_net();
10923 
10924 	list_for_each_entry(dev, head, unreg_list) {
10925 		struct sk_buff *skb = NULL;
10926 
10927 		/* Shutdown queueing discipline. */
10928 		dev_shutdown(dev);
10929 		dev_tcx_uninstall(dev);
10930 		dev_xdp_uninstall(dev);
10931 		bpf_dev_bound_netdev_unregister(dev);
10932 
10933 		netdev_offload_xstats_disable_all(dev);
10934 
10935 		/* Notify protocols, that we are about to destroy
10936 		 * this device. They should clean all the things.
10937 		 */
10938 		call_netdevice_notifiers(NETDEV_UNREGISTER, dev);
10939 
10940 		if (!dev->rtnl_link_ops ||
10941 		    dev->rtnl_link_state == RTNL_LINK_INITIALIZED)
10942 			skb = rtmsg_ifinfo_build_skb(RTM_DELLINK, dev, ~0U, 0,
10943 						     GFP_KERNEL, NULL, 0,
10944 						     portid, nlh);
10945 
10946 		/*
10947 		 *	Flush the unicast and multicast chains
10948 		 */
10949 		dev_uc_flush(dev);
10950 		dev_mc_flush(dev);
10951 
10952 		netdev_name_node_alt_flush(dev);
10953 		netdev_name_node_free(dev->name_node);
10954 
10955 		call_netdevice_notifiers(NETDEV_PRE_UNINIT, dev);
10956 
10957 		if (dev->netdev_ops->ndo_uninit)
10958 			dev->netdev_ops->ndo_uninit(dev);
10959 
10960 		if (skb)
10961 			rtmsg_ifinfo_send(skb, dev, GFP_KERNEL, portid, nlh);
10962 
10963 		/* Notifier chain MUST detach us all upper devices. */
10964 		WARN_ON(netdev_has_any_upper_dev(dev));
10965 		WARN_ON(netdev_has_any_lower_dev(dev));
10966 
10967 		/* Remove entries from kobject tree */
10968 		netdev_unregister_kobject(dev);
10969 #ifdef CONFIG_XPS
10970 		/* Remove XPS queueing entries */
10971 		netif_reset_xps_queues_gt(dev, 0);
10972 #endif
10973 	}
10974 
10975 	synchronize_net();
10976 
10977 	list_for_each_entry(dev, head, unreg_list) {
10978 		netdev_put(dev, &dev->dev_registered_tracker);
10979 		net_set_todo(dev);
10980 	}
10981 
10982 	list_del(head);
10983 }
10984 
10985 /**
10986  *	unregister_netdevice_many - unregister many devices
10987  *	@head: list of devices
10988  *
10989  *  Note: As most callers use a stack allocated list_head,
10990  *  we force a list_del() to make sure stack wont be corrupted later.
10991  */
10992 void unregister_netdevice_many(struct list_head *head)
10993 {
10994 	unregister_netdevice_many_notify(head, 0, NULL);
10995 }
10996 EXPORT_SYMBOL(unregister_netdevice_many);
10997 
10998 /**
10999  *	unregister_netdev - remove device from the kernel
11000  *	@dev: device
11001  *
11002  *	This function shuts down a device interface and removes it
11003  *	from the kernel tables.
11004  *
11005  *	This is just a wrapper for unregister_netdevice that takes
11006  *	the rtnl semaphore.  In general you want to use this and not
11007  *	unregister_netdevice.
11008  */
11009 void unregister_netdev(struct net_device *dev)
11010 {
11011 	rtnl_lock();
11012 	unregister_netdevice(dev);
11013 	rtnl_unlock();
11014 }
11015 EXPORT_SYMBOL(unregister_netdev);
11016 
11017 /**
11018  *	__dev_change_net_namespace - move device to different nethost namespace
11019  *	@dev: device
11020  *	@net: network namespace
11021  *	@pat: If not NULL name pattern to try if the current device name
11022  *	      is already taken in the destination network namespace.
11023  *	@new_ifindex: If not zero, specifies device index in the target
11024  *	              namespace.
11025  *
11026  *	This function shuts down a device interface and moves it
11027  *	to a new network namespace. On success 0 is returned, on
11028  *	a failure a netagive errno code is returned.
11029  *
11030  *	Callers must hold the rtnl semaphore.
11031  */
11032 
11033 int __dev_change_net_namespace(struct net_device *dev, struct net *net,
11034 			       const char *pat, int new_ifindex)
11035 {
11036 	struct net *net_old = dev_net(dev);
11037 	int err, new_nsid;
11038 
11039 	ASSERT_RTNL();
11040 
11041 	/* Don't allow namespace local devices to be moved. */
11042 	err = -EINVAL;
11043 	if (dev->features & NETIF_F_NETNS_LOCAL)
11044 		goto out;
11045 
11046 	/* Ensure the device has been registrered */
11047 	if (dev->reg_state != NETREG_REGISTERED)
11048 		goto out;
11049 
11050 	/* Get out if there is nothing todo */
11051 	err = 0;
11052 	if (net_eq(net_old, net))
11053 		goto out;
11054 
11055 	/* Pick the destination device name, and ensure
11056 	 * we can use it in the destination network namespace.
11057 	 */
11058 	err = -EEXIST;
11059 	if (netdev_name_in_use(net, dev->name)) {
11060 		/* We get here if we can't use the current device name */
11061 		if (!pat)
11062 			goto out;
11063 		err = dev_get_valid_name(net, dev, pat);
11064 		if (err < 0)
11065 			goto out;
11066 	}
11067 
11068 	/* Check that new_ifindex isn't used yet. */
11069 	if (new_ifindex) {
11070 		err = dev_index_reserve(net, new_ifindex);
11071 		if (err < 0)
11072 			goto out;
11073 	} else {
11074 		/* If there is an ifindex conflict assign a new one */
11075 		err = dev_index_reserve(net, dev->ifindex);
11076 		if (err == -EBUSY)
11077 			err = dev_index_reserve(net, 0);
11078 		if (err < 0)
11079 			goto out;
11080 		new_ifindex = err;
11081 	}
11082 
11083 	/*
11084 	 * And now a mini version of register_netdevice unregister_netdevice.
11085 	 */
11086 
11087 	/* If device is running close it first. */
11088 	dev_close(dev);
11089 
11090 	/* And unlink it from device chain */
11091 	unlist_netdevice(dev, true);
11092 
11093 	synchronize_net();
11094 
11095 	/* Shutdown queueing discipline. */
11096 	dev_shutdown(dev);
11097 
11098 	/* Notify protocols, that we are about to destroy
11099 	 * this device. They should clean all the things.
11100 	 *
11101 	 * Note that dev->reg_state stays at NETREG_REGISTERED.
11102 	 * This is wanted because this way 8021q and macvlan know
11103 	 * the device is just moving and can keep their slaves up.
11104 	 */
11105 	call_netdevice_notifiers(NETDEV_UNREGISTER, dev);
11106 	rcu_barrier();
11107 
11108 	new_nsid = peernet2id_alloc(dev_net(dev), net, GFP_KERNEL);
11109 
11110 	rtmsg_ifinfo_newnet(RTM_DELLINK, dev, ~0U, GFP_KERNEL, &new_nsid,
11111 			    new_ifindex);
11112 
11113 	/*
11114 	 *	Flush the unicast and multicast chains
11115 	 */
11116 	dev_uc_flush(dev);
11117 	dev_mc_flush(dev);
11118 
11119 	/* Send a netdev-removed uevent to the old namespace */
11120 	kobject_uevent(&dev->dev.kobj, KOBJ_REMOVE);
11121 	netdev_adjacent_del_links(dev);
11122 
11123 	/* Move per-net netdevice notifiers that are following the netdevice */
11124 	move_netdevice_notifiers_dev_net(dev, net);
11125 
11126 	/* Actually switch the network namespace */
11127 	dev_net_set(dev, net);
11128 	dev->ifindex = new_ifindex;
11129 
11130 	/* Send a netdev-add uevent to the new namespace */
11131 	kobject_uevent(&dev->dev.kobj, KOBJ_ADD);
11132 	netdev_adjacent_add_links(dev);
11133 
11134 	/* Fixup kobjects */
11135 	err = device_rename(&dev->dev, dev->name);
11136 	WARN_ON(err);
11137 
11138 	/* Adapt owner in case owning user namespace of target network
11139 	 * namespace is different from the original one.
11140 	 */
11141 	err = netdev_change_owner(dev, net_old, net);
11142 	WARN_ON(err);
11143 
11144 	/* Add the device back in the hashes */
11145 	list_netdevice(dev);
11146 
11147 	/* Notify protocols, that a new device appeared. */
11148 	call_netdevice_notifiers(NETDEV_REGISTER, dev);
11149 
11150 	/*
11151 	 *	Prevent userspace races by waiting until the network
11152 	 *	device is fully setup before sending notifications.
11153 	 */
11154 	rtmsg_ifinfo(RTM_NEWLINK, dev, ~0U, GFP_KERNEL, 0, NULL);
11155 
11156 	synchronize_net();
11157 	err = 0;
11158 out:
11159 	return err;
11160 }
11161 EXPORT_SYMBOL_GPL(__dev_change_net_namespace);
11162 
11163 static int dev_cpu_dead(unsigned int oldcpu)
11164 {
11165 	struct sk_buff **list_skb;
11166 	struct sk_buff *skb;
11167 	unsigned int cpu;
11168 	struct softnet_data *sd, *oldsd, *remsd = NULL;
11169 
11170 	local_irq_disable();
11171 	cpu = smp_processor_id();
11172 	sd = &per_cpu(softnet_data, cpu);
11173 	oldsd = &per_cpu(softnet_data, oldcpu);
11174 
11175 	/* Find end of our completion_queue. */
11176 	list_skb = &sd->completion_queue;
11177 	while (*list_skb)
11178 		list_skb = &(*list_skb)->next;
11179 	/* Append completion queue from offline CPU. */
11180 	*list_skb = oldsd->completion_queue;
11181 	oldsd->completion_queue = NULL;
11182 
11183 	/* Append output queue from offline CPU. */
11184 	if (oldsd->output_queue) {
11185 		*sd->output_queue_tailp = oldsd->output_queue;
11186 		sd->output_queue_tailp = oldsd->output_queue_tailp;
11187 		oldsd->output_queue = NULL;
11188 		oldsd->output_queue_tailp = &oldsd->output_queue;
11189 	}
11190 	/* Append NAPI poll list from offline CPU, with one exception :
11191 	 * process_backlog() must be called by cpu owning percpu backlog.
11192 	 * We properly handle process_queue & input_pkt_queue later.
11193 	 */
11194 	while (!list_empty(&oldsd->poll_list)) {
11195 		struct napi_struct *napi = list_first_entry(&oldsd->poll_list,
11196 							    struct napi_struct,
11197 							    poll_list);
11198 
11199 		list_del_init(&napi->poll_list);
11200 		if (napi->poll == process_backlog)
11201 			napi->state = 0;
11202 		else
11203 			____napi_schedule(sd, napi);
11204 	}
11205 
11206 	raise_softirq_irqoff(NET_TX_SOFTIRQ);
11207 	local_irq_enable();
11208 
11209 #ifdef CONFIG_RPS
11210 	remsd = oldsd->rps_ipi_list;
11211 	oldsd->rps_ipi_list = NULL;
11212 #endif
11213 	/* send out pending IPI's on offline CPU */
11214 	net_rps_send_ipi(remsd);
11215 
11216 	/* Process offline CPU's input_pkt_queue */
11217 	while ((skb = __skb_dequeue(&oldsd->process_queue))) {
11218 		netif_rx(skb);
11219 		input_queue_head_incr(oldsd);
11220 	}
11221 	while ((skb = skb_dequeue(&oldsd->input_pkt_queue))) {
11222 		netif_rx(skb);
11223 		input_queue_head_incr(oldsd);
11224 	}
11225 
11226 	return 0;
11227 }
11228 
11229 /**
11230  *	netdev_increment_features - increment feature set by one
11231  *	@all: current feature set
11232  *	@one: new feature set
11233  *	@mask: mask feature set
11234  *
11235  *	Computes a new feature set after adding a device with feature set
11236  *	@one to the master device with current feature set @all.  Will not
11237  *	enable anything that is off in @mask. Returns the new feature set.
11238  */
11239 netdev_features_t netdev_increment_features(netdev_features_t all,
11240 	netdev_features_t one, netdev_features_t mask)
11241 {
11242 	if (mask & NETIF_F_HW_CSUM)
11243 		mask |= NETIF_F_CSUM_MASK;
11244 	mask |= NETIF_F_VLAN_CHALLENGED;
11245 
11246 	all |= one & (NETIF_F_ONE_FOR_ALL | NETIF_F_CSUM_MASK) & mask;
11247 	all &= one | ~NETIF_F_ALL_FOR_ALL;
11248 
11249 	/* If one device supports hw checksumming, set for all. */
11250 	if (all & NETIF_F_HW_CSUM)
11251 		all &= ~(NETIF_F_CSUM_MASK & ~NETIF_F_HW_CSUM);
11252 
11253 	return all;
11254 }
11255 EXPORT_SYMBOL(netdev_increment_features);
11256 
11257 static struct hlist_head * __net_init netdev_create_hash(void)
11258 {
11259 	int i;
11260 	struct hlist_head *hash;
11261 
11262 	hash = kmalloc_array(NETDEV_HASHENTRIES, sizeof(*hash), GFP_KERNEL);
11263 	if (hash != NULL)
11264 		for (i = 0; i < NETDEV_HASHENTRIES; i++)
11265 			INIT_HLIST_HEAD(&hash[i]);
11266 
11267 	return hash;
11268 }
11269 
11270 /* Initialize per network namespace state */
11271 static int __net_init netdev_init(struct net *net)
11272 {
11273 	BUILD_BUG_ON(GRO_HASH_BUCKETS >
11274 		     8 * sizeof_field(struct napi_struct, gro_bitmask));
11275 
11276 	INIT_LIST_HEAD(&net->dev_base_head);
11277 
11278 	net->dev_name_head = netdev_create_hash();
11279 	if (net->dev_name_head == NULL)
11280 		goto err_name;
11281 
11282 	net->dev_index_head = netdev_create_hash();
11283 	if (net->dev_index_head == NULL)
11284 		goto err_idx;
11285 
11286 	xa_init_flags(&net->dev_by_index, XA_FLAGS_ALLOC1);
11287 
11288 	RAW_INIT_NOTIFIER_HEAD(&net->netdev_chain);
11289 
11290 	return 0;
11291 
11292 err_idx:
11293 	kfree(net->dev_name_head);
11294 err_name:
11295 	return -ENOMEM;
11296 }
11297 
11298 /**
11299  *	netdev_drivername - network driver for the device
11300  *	@dev: network device
11301  *
11302  *	Determine network driver for device.
11303  */
11304 const char *netdev_drivername(const struct net_device *dev)
11305 {
11306 	const struct device_driver *driver;
11307 	const struct device *parent;
11308 	const char *empty = "";
11309 
11310 	parent = dev->dev.parent;
11311 	if (!parent)
11312 		return empty;
11313 
11314 	driver = parent->driver;
11315 	if (driver && driver->name)
11316 		return driver->name;
11317 	return empty;
11318 }
11319 
11320 static void __netdev_printk(const char *level, const struct net_device *dev,
11321 			    struct va_format *vaf)
11322 {
11323 	if (dev && dev->dev.parent) {
11324 		dev_printk_emit(level[1] - '0',
11325 				dev->dev.parent,
11326 				"%s %s %s%s: %pV",
11327 				dev_driver_string(dev->dev.parent),
11328 				dev_name(dev->dev.parent),
11329 				netdev_name(dev), netdev_reg_state(dev),
11330 				vaf);
11331 	} else if (dev) {
11332 		printk("%s%s%s: %pV",
11333 		       level, netdev_name(dev), netdev_reg_state(dev), vaf);
11334 	} else {
11335 		printk("%s(NULL net_device): %pV", level, vaf);
11336 	}
11337 }
11338 
11339 void netdev_printk(const char *level, const struct net_device *dev,
11340 		   const char *format, ...)
11341 {
11342 	struct va_format vaf;
11343 	va_list args;
11344 
11345 	va_start(args, format);
11346 
11347 	vaf.fmt = format;
11348 	vaf.va = &args;
11349 
11350 	__netdev_printk(level, dev, &vaf);
11351 
11352 	va_end(args);
11353 }
11354 EXPORT_SYMBOL(netdev_printk);
11355 
11356 #define define_netdev_printk_level(func, level)			\
11357 void func(const struct net_device *dev, const char *fmt, ...)	\
11358 {								\
11359 	struct va_format vaf;					\
11360 	va_list args;						\
11361 								\
11362 	va_start(args, fmt);					\
11363 								\
11364 	vaf.fmt = fmt;						\
11365 	vaf.va = &args;						\
11366 								\
11367 	__netdev_printk(level, dev, &vaf);			\
11368 								\
11369 	va_end(args);						\
11370 }								\
11371 EXPORT_SYMBOL(func);
11372 
11373 define_netdev_printk_level(netdev_emerg, KERN_EMERG);
11374 define_netdev_printk_level(netdev_alert, KERN_ALERT);
11375 define_netdev_printk_level(netdev_crit, KERN_CRIT);
11376 define_netdev_printk_level(netdev_err, KERN_ERR);
11377 define_netdev_printk_level(netdev_warn, KERN_WARNING);
11378 define_netdev_printk_level(netdev_notice, KERN_NOTICE);
11379 define_netdev_printk_level(netdev_info, KERN_INFO);
11380 
11381 static void __net_exit netdev_exit(struct net *net)
11382 {
11383 	kfree(net->dev_name_head);
11384 	kfree(net->dev_index_head);
11385 	xa_destroy(&net->dev_by_index);
11386 	if (net != &init_net)
11387 		WARN_ON_ONCE(!list_empty(&net->dev_base_head));
11388 }
11389 
11390 static struct pernet_operations __net_initdata netdev_net_ops = {
11391 	.init = netdev_init,
11392 	.exit = netdev_exit,
11393 };
11394 
11395 static void __net_exit default_device_exit_net(struct net *net)
11396 {
11397 	struct net_device *dev, *aux;
11398 	/*
11399 	 * Push all migratable network devices back to the
11400 	 * initial network namespace
11401 	 */
11402 	ASSERT_RTNL();
11403 	for_each_netdev_safe(net, dev, aux) {
11404 		int err;
11405 		char fb_name[IFNAMSIZ];
11406 
11407 		/* Ignore unmoveable devices (i.e. loopback) */
11408 		if (dev->features & NETIF_F_NETNS_LOCAL)
11409 			continue;
11410 
11411 		/* Leave virtual devices for the generic cleanup */
11412 		if (dev->rtnl_link_ops && !dev->rtnl_link_ops->netns_refund)
11413 			continue;
11414 
11415 		/* Push remaining network devices to init_net */
11416 		snprintf(fb_name, IFNAMSIZ, "dev%d", dev->ifindex);
11417 		if (netdev_name_in_use(&init_net, fb_name))
11418 			snprintf(fb_name, IFNAMSIZ, "dev%%d");
11419 		err = dev_change_net_namespace(dev, &init_net, fb_name);
11420 		if (err) {
11421 			pr_emerg("%s: failed to move %s to init_net: %d\n",
11422 				 __func__, dev->name, err);
11423 			BUG();
11424 		}
11425 	}
11426 }
11427 
11428 static void __net_exit default_device_exit_batch(struct list_head *net_list)
11429 {
11430 	/* At exit all network devices most be removed from a network
11431 	 * namespace.  Do this in the reverse order of registration.
11432 	 * Do this across as many network namespaces as possible to
11433 	 * improve batching efficiency.
11434 	 */
11435 	struct net_device *dev;
11436 	struct net *net;
11437 	LIST_HEAD(dev_kill_list);
11438 
11439 	rtnl_lock();
11440 	list_for_each_entry(net, net_list, exit_list) {
11441 		default_device_exit_net(net);
11442 		cond_resched();
11443 	}
11444 
11445 	list_for_each_entry(net, net_list, exit_list) {
11446 		for_each_netdev_reverse(net, dev) {
11447 			if (dev->rtnl_link_ops && dev->rtnl_link_ops->dellink)
11448 				dev->rtnl_link_ops->dellink(dev, &dev_kill_list);
11449 			else
11450 				unregister_netdevice_queue(dev, &dev_kill_list);
11451 		}
11452 	}
11453 	unregister_netdevice_many(&dev_kill_list);
11454 	rtnl_unlock();
11455 }
11456 
11457 static struct pernet_operations __net_initdata default_device_ops = {
11458 	.exit_batch = default_device_exit_batch,
11459 };
11460 
11461 /*
11462  *	Initialize the DEV module. At boot time this walks the device list and
11463  *	unhooks any devices that fail to initialise (normally hardware not
11464  *	present) and leaves us with a valid list of present and active devices.
11465  *
11466  */
11467 
11468 /*
11469  *       This is called single threaded during boot, so no need
11470  *       to take the rtnl semaphore.
11471  */
11472 static int __init net_dev_init(void)
11473 {
11474 	int i, rc = -ENOMEM;
11475 
11476 	BUG_ON(!dev_boot_phase);
11477 
11478 	if (dev_proc_init())
11479 		goto out;
11480 
11481 	if (netdev_kobject_init())
11482 		goto out;
11483 
11484 	INIT_LIST_HEAD(&ptype_all);
11485 	for (i = 0; i < PTYPE_HASH_SIZE; i++)
11486 		INIT_LIST_HEAD(&ptype_base[i]);
11487 
11488 	if (register_pernet_subsys(&netdev_net_ops))
11489 		goto out;
11490 
11491 	/*
11492 	 *	Initialise the packet receive queues.
11493 	 */
11494 
11495 	for_each_possible_cpu(i) {
11496 		struct work_struct *flush = per_cpu_ptr(&flush_works, i);
11497 		struct softnet_data *sd = &per_cpu(softnet_data, i);
11498 
11499 		INIT_WORK(flush, flush_backlog);
11500 
11501 		skb_queue_head_init(&sd->input_pkt_queue);
11502 		skb_queue_head_init(&sd->process_queue);
11503 #ifdef CONFIG_XFRM_OFFLOAD
11504 		skb_queue_head_init(&sd->xfrm_backlog);
11505 #endif
11506 		INIT_LIST_HEAD(&sd->poll_list);
11507 		sd->output_queue_tailp = &sd->output_queue;
11508 #ifdef CONFIG_RPS
11509 		INIT_CSD(&sd->csd, rps_trigger_softirq, sd);
11510 		sd->cpu = i;
11511 #endif
11512 		INIT_CSD(&sd->defer_csd, trigger_rx_softirq, sd);
11513 		spin_lock_init(&sd->defer_lock);
11514 
11515 		init_gro_hash(&sd->backlog);
11516 		sd->backlog.poll = process_backlog;
11517 		sd->backlog.weight = weight_p;
11518 	}
11519 
11520 	dev_boot_phase = 0;
11521 
11522 	/* The loopback device is special if any other network devices
11523 	 * is present in a network namespace the loopback device must
11524 	 * be present. Since we now dynamically allocate and free the
11525 	 * loopback device ensure this invariant is maintained by
11526 	 * keeping the loopback device as the first device on the
11527 	 * list of network devices.  Ensuring the loopback devices
11528 	 * is the first device that appears and the last network device
11529 	 * that disappears.
11530 	 */
11531 	if (register_pernet_device(&loopback_net_ops))
11532 		goto out;
11533 
11534 	if (register_pernet_device(&default_device_ops))
11535 		goto out;
11536 
11537 	open_softirq(NET_TX_SOFTIRQ, net_tx_action);
11538 	open_softirq(NET_RX_SOFTIRQ, net_rx_action);
11539 
11540 	rc = cpuhp_setup_state_nocalls(CPUHP_NET_DEV_DEAD, "net/dev:dead",
11541 				       NULL, dev_cpu_dead);
11542 	WARN_ON(rc < 0);
11543 	rc = 0;
11544 out:
11545 	return rc;
11546 }
11547 
11548 subsys_initcall(net_dev_init);
11549