Branch data Line data Source code
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/string.h>
83 : : #include <linux/mm.h>
84 : : #include <linux/socket.h>
85 : : #include <linux/sockios.h>
86 : : #include <linux/errno.h>
87 : : #include <linux/interrupt.h>
88 : : #include <linux/if_ether.h>
89 : : #include <linux/netdevice.h>
90 : : #include <linux/etherdevice.h>
91 : : #include <linux/ethtool.h>
92 : : #include <linux/skbuff.h>
93 : : #include <linux/bpf.h>
94 : : #include <linux/bpf_trace.h>
95 : : #include <net/net_namespace.h>
96 : : #include <net/sock.h>
97 : : #include <net/busy_poll.h>
98 : : #include <linux/rtnetlink.h>
99 : : #include <linux/stat.h>
100 : : #include <net/dst.h>
101 : : #include <net/dst_metadata.h>
102 : : #include <net/pkt_sched.h>
103 : : #include <net/pkt_cls.h>
104 : : #include <net/checksum.h>
105 : : #include <net/xfrm.h>
106 : : #include <linux/highmem.h>
107 : : #include <linux/init.h>
108 : : #include <linux/module.h>
109 : : #include <linux/netpoll.h>
110 : : #include <linux/rcupdate.h>
111 : : #include <linux/delay.h>
112 : : #include <net/iw_handler.h>
113 : : #include <asm/current.h>
114 : : #include <linux/audit.h>
115 : : #include <linux/dmaengine.h>
116 : : #include <linux/err.h>
117 : : #include <linux/ctype.h>
118 : : #include <linux/if_arp.h>
119 : : #include <linux/if_vlan.h>
120 : : #include <linux/ip.h>
121 : : #include <net/ip.h>
122 : : #include <net/mpls.h>
123 : : #include <linux/ipv6.h>
124 : : #include <linux/in.h>
125 : : #include <linux/jhash.h>
126 : : #include <linux/random.h>
127 : : #include <trace/events/napi.h>
128 : : #include <trace/events/net.h>
129 : : #include <trace/events/skb.h>
130 : : #include <linux/inetdevice.h>
131 : : #include <linux/cpu_rmap.h>
132 : : #include <linux/static_key.h>
133 : : #include <linux/hashtable.h>
134 : : #include <linux/vmalloc.h>
135 : : #include <linux/if_macvlan.h>
136 : : #include <linux/errqueue.h>
137 : : #include <linux/hrtimer.h>
138 : : #include <linux/netfilter_ingress.h>
139 : : #include <linux/crash_dump.h>
140 : : #include <linux/sctp.h>
141 : : #include <net/udp_tunnel.h>
142 : : #include <linux/net_namespace.h>
143 : : #include <linux/indirect_call_wrapper.h>
144 : : #include <net/devlink.h>
145 : :
146 : : #include "net-sysfs.h"
147 : :
148 : : #define MAX_GRO_SKBS 8
149 : :
150 : : /* This should be increased if a protocol with a bigger head is added. */
151 : : #define GRO_MAX_HEAD (MAX_HEADER + 128)
152 : :
153 : : static DEFINE_SPINLOCK(ptype_lock);
154 : : static DEFINE_SPINLOCK(offload_lock);
155 : : struct list_head ptype_base[PTYPE_HASH_SIZE] __read_mostly;
156 : : struct list_head ptype_all __read_mostly; /* Taps */
157 : : static struct list_head offload_base __read_mostly;
158 : :
159 : : static int netif_rx_internal(struct sk_buff *skb);
160 : : static int call_netdevice_notifiers_info(unsigned long val,
161 : : struct netdev_notifier_info *info);
162 : : static int call_netdevice_notifiers_extack(unsigned long val,
163 : : struct net_device *dev,
164 : : struct netlink_ext_ack *extack);
165 : : static struct napi_struct *napi_by_id(unsigned int napi_id);
166 : :
167 : : /*
168 : : * The @dev_base_head list is protected by @dev_base_lock and the rtnl
169 : : * semaphore.
170 : : *
171 : : * Pure readers hold dev_base_lock for reading, or rcu_read_lock()
172 : : *
173 : : * Writers must hold the rtnl semaphore while they loop through the
174 : : * dev_base_head list, and hold dev_base_lock for writing when they do the
175 : : * actual updates. This allows pure readers to access the list even
176 : : * while a writer is preparing to update it.
177 : : *
178 : : * To put it another way, dev_base_lock is held for writing only to
179 : : * protect against pure readers; the rtnl semaphore provides the
180 : : * protection against other writers.
181 : : *
182 : : * See, for example usages, register_netdevice() and
183 : : * unregister_netdevice(), which must be called with the rtnl
184 : : * semaphore held.
185 : : */
186 : : DEFINE_RWLOCK(dev_base_lock);
187 : : EXPORT_SYMBOL(dev_base_lock);
188 : :
189 : : static DEFINE_MUTEX(ifalias_mutex);
190 : :
191 : : /* protects napi_hash addition/deletion and napi_gen_id */
192 : : static DEFINE_SPINLOCK(napi_hash_lock);
193 : :
194 : : static unsigned int napi_gen_id = NR_CPUS;
195 : : static DEFINE_READ_MOSTLY_HASHTABLE(napi_hash, 8);
196 : :
197 : : static seqcount_t devnet_rename_seq;
198 : :
199 : 0 : static inline void dev_base_seq_inc(struct net *net)
200 : : {
201 : 9 : while (++net->dev_base_seq == 0)
202 [ - - - + ]: 9 : ;
203 : : }
204 : :
205 : 150 : static inline struct hlist_head *dev_name_hash(struct net *net, const char *name)
206 : : {
207 : 150 : unsigned int hash = full_name_hash(net, name, strnlen(name, IFNAMSIZ));
208 : :
209 : 150 : return &net->dev_name_head[hash_32(hash, NETDEV_HASHBITS)];
210 : : }
211 : :
212 : 72 : static inline struct hlist_head *dev_index_hash(struct net *net, int ifindex)
213 : : {
214 : 72 : return &net->dev_index_head[ifindex & (NETDEV_HASHENTRIES - 1)];
215 : : }
216 : :
217 : 0 : static inline void rps_lock(struct softnet_data *sd)
218 : : {
219 : : #ifdef CONFIG_RPS
220 : 0 : spin_lock(&sd->input_pkt_queue.lock);
221 : : #endif
222 : : }
223 : :
224 : 0 : static inline void rps_unlock(struct softnet_data *sd)
225 : : {
226 : : #ifdef CONFIG_RPS
227 : 0 : spin_unlock(&sd->input_pkt_queue.lock);
228 : : #endif
229 : : }
230 : :
231 : 9 : static struct netdev_name_node *netdev_name_node_alloc(struct net_device *dev,
232 : : const char *name)
233 : : {
234 : 9 : struct netdev_name_node *name_node;
235 : :
236 : 9 : name_node = kmalloc(sizeof(*name_node), GFP_KERNEL);
237 [ + - ]: 9 : if (!name_node)
238 : : return NULL;
239 : 9 : INIT_HLIST_NODE(&name_node->hlist);
240 : 9 : name_node->dev = dev;
241 : 9 : name_node->name = name;
242 : 9 : return name_node;
243 : : }
244 : :
245 : : static struct netdev_name_node *
246 : 9 : netdev_name_node_head_alloc(struct net_device *dev)
247 : : {
248 : 9 : struct netdev_name_node *name_node;
249 : :
250 : 9 : name_node = netdev_name_node_alloc(dev, dev->name);
251 [ + - ]: 9 : if (!name_node)
252 : : return NULL;
253 : 9 : INIT_LIST_HEAD(&name_node->list);
254 : 9 : return name_node;
255 : : }
256 : :
257 : 0 : static void netdev_name_node_free(struct netdev_name_node *name_node)
258 : : {
259 : 0 : kfree(name_node);
260 : : }
261 : :
262 : 9 : static void netdev_name_node_add(struct net *net,
263 : : struct netdev_name_node *name_node)
264 : : {
265 : 9 : hlist_add_head_rcu(&name_node->hlist,
266 : : dev_name_hash(net, name_node->name));
267 : 9 : }
268 : :
269 : 0 : static void netdev_name_node_del(struct netdev_name_node *name_node)
270 : : {
271 : 0 : hlist_del_rcu(&name_node->hlist);
272 : : }
273 : :
274 : 75 : static struct netdev_name_node *netdev_name_node_lookup(struct net *net,
275 : : const char *name)
276 : : {
277 : 75 : struct hlist_head *head = dev_name_hash(net, name);
278 : 75 : struct netdev_name_node *name_node;
279 : :
280 [ + + - - : 150 : hlist_for_each_entry(name_node, head, hlist)
+ + ]
281 [ + - ]: 39 : if (!strcmp(name_node->name, name))
282 : 39 : return name_node;
283 : : return NULL;
284 : : }
285 : :
286 : 66 : static struct netdev_name_node *netdev_name_node_lookup_rcu(struct net *net,
287 : : const char *name)
288 : : {
289 : 66 : struct hlist_head *head = dev_name_hash(net, name);
290 : 66 : struct netdev_name_node *name_node;
291 : :
292 [ + + - - : 132 : hlist_for_each_entry_rcu(name_node, head, hlist)
+ + ]
293 [ + - ]: 57 : if (!strcmp(name_node->name, name))
294 : 57 : return name_node;
295 : : return NULL;
296 : : }
297 : :
298 : 0 : int netdev_name_node_alt_create(struct net_device *dev, const char *name)
299 : : {
300 : 0 : struct netdev_name_node *name_node;
301 : 0 : struct net *net = dev_net(dev);
302 : :
303 : 0 : name_node = netdev_name_node_lookup(net, name);
304 [ # # ]: 0 : if (name_node)
305 : : return -EEXIST;
306 : 0 : name_node = netdev_name_node_alloc(dev, name);
307 [ # # ]: 0 : if (!name_node)
308 : : return -ENOMEM;
309 : 0 : netdev_name_node_add(net, name_node);
310 : : /* The node that holds dev->name acts as a head of per-device list. */
311 : 0 : list_add_tail(&name_node->list, &dev->name_node->list);
312 : :
313 : 0 : return 0;
314 : : }
315 : : EXPORT_SYMBOL(netdev_name_node_alt_create);
316 : :
317 : 0 : static void __netdev_name_node_alt_destroy(struct netdev_name_node *name_node)
318 : : {
319 [ # # ]: 0 : list_del(&name_node->list);
320 [ # # ]: 0 : netdev_name_node_del(name_node);
321 : 0 : kfree(name_node->name);
322 : 0 : netdev_name_node_free(name_node);
323 : 0 : }
324 : :
325 : 0 : int netdev_name_node_alt_destroy(struct net_device *dev, const char *name)
326 : : {
327 : 0 : struct netdev_name_node *name_node;
328 : 0 : struct net *net = dev_net(dev);
329 : :
330 : 0 : name_node = netdev_name_node_lookup(net, name);
331 [ # # ]: 0 : if (!name_node)
332 : : return -ENOENT;
333 : : /* lookup might have found our primary name or a name belonging
334 : : * to another device.
335 : : */
336 [ # # # # ]: 0 : if (name_node == dev->name_node || name_node->dev != dev)
337 : : return -EINVAL;
338 : :
339 : 0 : __netdev_name_node_alt_destroy(name_node);
340 : :
341 : 0 : return 0;
342 : : }
343 : : EXPORT_SYMBOL(netdev_name_node_alt_destroy);
344 : :
345 : : static void netdev_name_node_alt_flush(struct net_device *dev)
346 : : {
347 : : struct netdev_name_node *name_node, *tmp;
348 : :
349 : : list_for_each_entry_safe(name_node, tmp, &dev->name_node->list, list)
350 : : __netdev_name_node_alt_destroy(name_node);
351 : : }
352 : :
353 : : /* Device list insertion */
354 : 9 : static void list_netdevice(struct net_device *dev)
355 : : {
356 : 9 : struct net *net = dev_net(dev);
357 : :
358 [ - + - - ]: 9 : ASSERT_RTNL();
359 : :
360 : 9 : write_lock_bh(&dev_base_lock);
361 : 9 : list_add_tail_rcu(&dev->dev_list, &net->dev_base_head);
362 : 9 : netdev_name_node_add(net, dev->name_node);
363 : 9 : hlist_add_head_rcu(&dev->index_hlist,
364 : : dev_index_hash(net, dev->ifindex));
365 : 9 : write_unlock_bh(&dev_base_lock);
366 : :
367 : 9 : dev_base_seq_inc(net);
368 : 9 : }
369 : :
370 : : /* Device list removal
371 : : * caller must respect a RCU grace period before freeing/reusing dev
372 : : */
373 : 0 : static void unlist_netdevice(struct net_device *dev)
374 : : {
375 [ # # # # ]: 0 : ASSERT_RTNL();
376 : :
377 : : /* Unlink dev from the device chain */
378 : 0 : write_lock_bh(&dev_base_lock);
379 [ # # ]: 0 : list_del_rcu(&dev->dev_list);
380 [ # # ]: 0 : netdev_name_node_del(dev->name_node);
381 [ # # ]: 0 : hlist_del_rcu(&dev->index_hlist);
382 : 0 : write_unlock_bh(&dev_base_lock);
383 : :
384 : 0 : dev_base_seq_inc(dev_net(dev));
385 : 0 : }
386 : :
387 : : /*
388 : : * Our notifier list
389 : : */
390 : :
391 : : static RAW_NOTIFIER_HEAD(netdev_chain);
392 : :
393 : : /*
394 : : * Device drivers call our routines to queue packets here. We empty the
395 : : * queue in the local softnet handler.
396 : : */
397 : :
398 : : DEFINE_PER_CPU_ALIGNED(struct softnet_data, softnet_data);
399 : : EXPORT_PER_CPU_SYMBOL(softnet_data);
400 : :
401 : : /*******************************************************************************
402 : : *
403 : : * Protocol management and registration routines
404 : : *
405 : : *******************************************************************************/
406 : :
407 : :
408 : : /*
409 : : * Add a protocol ID to the list. Now that the input handler is
410 : : * smarter we can dispense with all the messy stuff that used to be
411 : : * here.
412 : : *
413 : : * BEWARE!!! Protocol handlers, mangling input packets,
414 : : * MUST BE last in hash buckets and checking protocol handlers
415 : : * MUST start from promiscuous ptype_all chain in net_bh.
416 : : * It is true now, do not change it.
417 : : * Explanation follows: if protocol handler, mangling packet, will
418 : : * be the first on list, it is not able to sense, that packet
419 : : * is cloned and should be copied-on-write, so that it will
420 : : * change it and subsequent readers will get broken packet.
421 : : * --ANK (980803)
422 : : */
423 : :
424 : 9 : static inline struct list_head *ptype_head(const struct packet_type *pt)
425 : : {
426 : 9 : if (pt->type == htons(ETH_P_ALL))
427 [ # # # # ]: 0 : return pt->dev ? &pt->dev->ptype_all : &ptype_all;
428 : : else
429 [ - - - + ]: 9 : return pt->dev ? &pt->dev->ptype_specific :
430 : 9 : &ptype_base[ntohs(pt->type) & PTYPE_HASH_MASK];
431 : : }
432 : :
433 : : /**
434 : : * dev_add_pack - add packet handler
435 : : * @pt: packet type declaration
436 : : *
437 : : * Add a protocol handler to the networking stack. The passed &packet_type
438 : : * is linked into kernel lists and may not be freed until it has been
439 : : * removed from the kernel lists.
440 : : *
441 : : * This call does not sleep therefore it can not
442 : : * guarantee all CPU's that are in middle of receiving packets
443 : : * will see the new packet type (until the next received packet).
444 : : */
445 : :
446 : 9 : void dev_add_pack(struct packet_type *pt)
447 : : {
448 [ - + ]: 9 : struct list_head *head = ptype_head(pt);
449 : :
450 : 9 : spin_lock(&ptype_lock);
451 : 9 : list_add_rcu(&pt->list, head);
452 : 9 : spin_unlock(&ptype_lock);
453 : 9 : }
454 : : EXPORT_SYMBOL(dev_add_pack);
455 : :
456 : : /**
457 : : * __dev_remove_pack - remove packet handler
458 : : * @pt: packet type declaration
459 : : *
460 : : * Remove a protocol handler that was previously added to the kernel
461 : : * protocol handlers by dev_add_pack(). The passed &packet_type is removed
462 : : * from the kernel lists and can be freed or reused once this function
463 : : * returns.
464 : : *
465 : : * The packet type might still be in use by receivers
466 : : * and must not be freed until after all the CPU's have gone
467 : : * through a quiescent state.
468 : : */
469 : 0 : void __dev_remove_pack(struct packet_type *pt)
470 : : {
471 [ # # ]: 0 : struct list_head *head = ptype_head(pt);
472 : 0 : struct packet_type *pt1;
473 : :
474 : 0 : spin_lock(&ptype_lock);
475 : :
476 [ # # ]: 0 : list_for_each_entry(pt1, head, list) {
477 [ # # ]: 0 : if (pt == pt1) {
478 : 0 : list_del_rcu(&pt->list);
479 : 0 : goto out;
480 : : }
481 : : }
482 : :
483 : 0 : pr_warn("dev_remove_pack: %p not found\n", pt);
484 : 0 : out:
485 : 0 : spin_unlock(&ptype_lock);
486 : 0 : }
487 : : EXPORT_SYMBOL(__dev_remove_pack);
488 : :
489 : : /**
490 : : * dev_remove_pack - remove packet handler
491 : : * @pt: packet type declaration
492 : : *
493 : : * Remove a protocol handler that was previously added to the kernel
494 : : * protocol handlers by dev_add_pack(). The passed &packet_type is removed
495 : : * from the kernel lists and can be freed or reused once this function
496 : : * returns.
497 : : *
498 : : * This call sleeps to guarantee that no CPU is looking at the packet
499 : : * type after return.
500 : : */
501 : 0 : void dev_remove_pack(struct packet_type *pt)
502 : : {
503 : 0 : __dev_remove_pack(pt);
504 : :
505 : 0 : synchronize_net();
506 : 0 : }
507 : : EXPORT_SYMBOL(dev_remove_pack);
508 : :
509 : :
510 : : /**
511 : : * dev_add_offload - register offload handlers
512 : : * @po: protocol offload declaration
513 : : *
514 : : * Add protocol offload handlers to the networking stack. The passed
515 : : * &proto_offload is linked into kernel lists and may not be freed until
516 : : * it has been removed from the kernel lists.
517 : : *
518 : : * This call does not sleep therefore it can not
519 : : * guarantee all CPU's that are in middle of receiving packets
520 : : * will see the new offload handlers (until the next received packet).
521 : : */
522 : 9 : void dev_add_offload(struct packet_offload *po)
523 : : {
524 : 9 : struct packet_offload *elem;
525 : :
526 : 9 : spin_lock(&offload_lock);
527 [ + + ]: 12 : list_for_each_entry(elem, &offload_base, list) {
528 [ + + ]: 9 : if (po->priority < elem->priority)
529 : : break;
530 : : }
531 : 9 : list_add_rcu(&po->list, elem->list.prev);
532 : 9 : spin_unlock(&offload_lock);
533 : 9 : }
534 : : EXPORT_SYMBOL(dev_add_offload);
535 : :
536 : : /**
537 : : * __dev_remove_offload - remove offload handler
538 : : * @po: packet offload declaration
539 : : *
540 : : * Remove a protocol offload handler that was previously added to the
541 : : * kernel offload handlers by dev_add_offload(). The passed &offload_type
542 : : * is removed from the kernel lists and can be freed or reused once this
543 : : * function returns.
544 : : *
545 : : * The packet type might still be in use by receivers
546 : : * and must not be freed until after all the CPU's have gone
547 : : * through a quiescent state.
548 : : */
549 : 0 : static void __dev_remove_offload(struct packet_offload *po)
550 : : {
551 : 0 : struct list_head *head = &offload_base;
552 : 0 : struct packet_offload *po1;
553 : :
554 : 0 : spin_lock(&offload_lock);
555 : :
556 [ # # ]: 0 : list_for_each_entry(po1, head, list) {
557 [ # # ]: 0 : if (po == po1) {
558 : 0 : list_del_rcu(&po->list);
559 : 0 : goto out;
560 : : }
561 : : }
562 : :
563 : 0 : pr_warn("dev_remove_offload: %p not found\n", po);
564 : 0 : out:
565 : 0 : spin_unlock(&offload_lock);
566 : 0 : }
567 : :
568 : : /**
569 : : * dev_remove_offload - remove packet offload handler
570 : : * @po: packet offload declaration
571 : : *
572 : : * Remove a packet offload handler that was previously added to the kernel
573 : : * offload handlers by dev_add_offload(). The passed &offload_type is
574 : : * removed from the kernel lists and can be freed or reused once this
575 : : * function returns.
576 : : *
577 : : * This call sleeps to guarantee that no CPU is looking at the packet
578 : : * type after return.
579 : : */
580 : 0 : void dev_remove_offload(struct packet_offload *po)
581 : : {
582 : 0 : __dev_remove_offload(po);
583 : :
584 : 0 : synchronize_net();
585 : 0 : }
586 : : EXPORT_SYMBOL(dev_remove_offload);
587 : :
588 : : /******************************************************************************
589 : : *
590 : : * Device Boot-time Settings Routines
591 : : *
592 : : ******************************************************************************/
593 : :
594 : : /* Boot time configuration table */
595 : : static struct netdev_boot_setup dev_boot_setup[NETDEV_BOOT_SETUP_MAX];
596 : :
597 : : /**
598 : : * netdev_boot_setup_add - add new setup entry
599 : : * @name: name of the device
600 : : * @map: configured settings for the device
601 : : *
602 : : * Adds new setup entry to the dev_boot_setup list. The function
603 : : * returns 0 on error and 1 on success. This is a generic routine to
604 : : * all netdevices.
605 : : */
606 : 0 : static int netdev_boot_setup_add(char *name, struct ifmap *map)
607 : : {
608 : 0 : struct netdev_boot_setup *s;
609 : 0 : int i;
610 : :
611 : 0 : s = dev_boot_setup;
612 [ # # ]: 0 : for (i = 0; i < NETDEV_BOOT_SETUP_MAX; i++) {
613 [ # # ]: 0 : if (s[i].name[0] == '\0' || s[i].name[0] == ' ') {
614 : 0 : memset(s[i].name, 0, sizeof(s[i].name));
615 : 0 : strlcpy(s[i].name, name, IFNAMSIZ);
616 : 0 : memcpy(&s[i].map, map, sizeof(s[i].map));
617 : 0 : break;
618 : : }
619 : : }
620 : :
621 : 0 : return i >= NETDEV_BOOT_SETUP_MAX ? 0 : 1;
622 : : }
623 : :
624 : : /**
625 : : * netdev_boot_setup_check - check boot time settings
626 : : * @dev: the netdevice
627 : : *
628 : : * Check boot time settings for the device.
629 : : * The found settings are set for the device to be used
630 : : * later in the device probing.
631 : : * Returns 0 if no settings found, 1 if they are.
632 : : */
633 : 0 : int netdev_boot_setup_check(struct net_device *dev)
634 : : {
635 : 0 : struct netdev_boot_setup *s = dev_boot_setup;
636 : 0 : int i;
637 : :
638 [ # # ]: 0 : for (i = 0; i < NETDEV_BOOT_SETUP_MAX; i++) {
639 [ # # ]: 0 : if (s[i].name[0] != '\0' && s[i].name[0] != ' ' &&
640 [ # # ]: 0 : !strcmp(dev->name, s[i].name)) {
641 : 0 : dev->irq = s[i].map.irq;
642 : 0 : dev->base_addr = s[i].map.base_addr;
643 : 0 : dev->mem_start = s[i].map.mem_start;
644 : 0 : dev->mem_end = s[i].map.mem_end;
645 : 0 : return 1;
646 : : }
647 : : }
648 : : return 0;
649 : : }
650 : : EXPORT_SYMBOL(netdev_boot_setup_check);
651 : :
652 : :
653 : : /**
654 : : * netdev_boot_base - get address from boot time settings
655 : : * @prefix: prefix for network device
656 : : * @unit: id for network device
657 : : *
658 : : * Check boot time settings for the base address of device.
659 : : * The found settings are set for the device to be used
660 : : * later in the device probing.
661 : : * Returns 0 if no settings found.
662 : : */
663 : 24 : unsigned long netdev_boot_base(const char *prefix, int unit)
664 : : {
665 : 24 : const struct netdev_boot_setup *s = dev_boot_setup;
666 : 24 : char name[IFNAMSIZ];
667 : 24 : int i;
668 : :
669 : 24 : sprintf(name, "%s%d", prefix, unit);
670 : :
671 : : /*
672 : : * If device already registered then return base of 1
673 : : * to indicate not to probe for this interface
674 : : */
675 : 24 : if (__dev_get_by_name(&init_net, name))
676 : : return 1;
677 : :
678 [ + + ]: 216 : for (i = 0; i < NETDEV_BOOT_SETUP_MAX; i++)
679 [ - + ]: 192 : if (!strcmp(name, s[i].name))
680 : 0 : return s[i].map.base_addr;
681 : : return 0;
682 : : }
683 : :
684 : : /*
685 : : * Saves at boot time configured settings for any netdevice.
686 : : */
687 : 0 : int __init netdev_boot_setup(char *str)
688 : : {
689 : 0 : int ints[5];
690 : 0 : struct ifmap map;
691 : :
692 : 0 : str = get_options(str, ARRAY_SIZE(ints), ints);
693 [ # # # # ]: 0 : if (!str || !*str)
694 : : return 0;
695 : :
696 : : /* Save settings */
697 : 0 : memset(&map, 0, sizeof(map));
698 [ # # ]: 0 : if (ints[0] > 0)
699 : 0 : map.irq = ints[1];
700 [ # # ]: 0 : if (ints[0] > 1)
701 : 0 : map.base_addr = ints[2];
702 [ # # ]: 0 : if (ints[0] > 2)
703 : 0 : map.mem_start = ints[3];
704 [ # # ]: 0 : if (ints[0] > 3)
705 : 0 : map.mem_end = ints[4];
706 : :
707 : : /* Add new entry to the list */
708 : 0 : return netdev_boot_setup_add(str, &map);
709 : : }
710 : :
711 : : __setup("netdev=", netdev_boot_setup);
712 : :
713 : : /*******************************************************************************
714 : : *
715 : : * Device Interface Subroutines
716 : : *
717 : : *******************************************************************************/
718 : :
719 : : /**
720 : : * dev_get_iflink - get 'iflink' value of a interface
721 : : * @dev: targeted interface
722 : : *
723 : : * Indicates the ifindex the interface is linked to.
724 : : * Physical interfaces have the same 'ifindex' and 'iflink' values.
725 : : */
726 : :
727 : 75 : int dev_get_iflink(const struct net_device *dev)
728 : : {
729 [ + - + + ]: 75 : if (dev->netdev_ops && dev->netdev_ops->ndo_get_iflink)
730 : 18 : return dev->netdev_ops->ndo_get_iflink(dev);
731 : :
732 : 57 : return dev->ifindex;
733 : : }
734 : : EXPORT_SYMBOL(dev_get_iflink);
735 : :
736 : : /**
737 : : * dev_fill_metadata_dst - Retrieve tunnel egress information.
738 : : * @dev: targeted interface
739 : : * @skb: The packet.
740 : : *
741 : : * For better visibility of tunnel traffic OVS needs to retrieve
742 : : * egress tunnel information for a packet. Following API allows
743 : : * user to get this info.
744 : : */
745 : 0 : int dev_fill_metadata_dst(struct net_device *dev, struct sk_buff *skb)
746 : : {
747 : 0 : struct ip_tunnel_info *info;
748 : :
749 [ # # # # ]: 0 : if (!dev->netdev_ops || !dev->netdev_ops->ndo_fill_metadata_dst)
750 : : return -EINVAL;
751 : :
752 : 0 : info = skb_tunnel_info_unclone(skb);
753 [ # # ]: 0 : if (!info)
754 : : return -ENOMEM;
755 [ # # ]: 0 : if (unlikely(!(info->mode & IP_TUNNEL_INFO_TX)))
756 : : return -EINVAL;
757 : :
758 : 0 : return dev->netdev_ops->ndo_fill_metadata_dst(dev, skb);
759 : : }
760 : : EXPORT_SYMBOL_GPL(dev_fill_metadata_dst);
761 : :
762 : : /**
763 : : * __dev_get_by_name - find a device by its name
764 : : * @net: the applicable net namespace
765 : : * @name: name to find
766 : : *
767 : : * Find an interface by name. Must be called under RTNL semaphore
768 : : * or @dev_base_lock. If the name is found a pointer to the device
769 : : * is returned. If the name is not found then %NULL is returned. The
770 : : * reference counters are not incremented so the caller must be
771 : : * careful with locks.
772 : : */
773 : :
774 : 75 : struct net_device *__dev_get_by_name(struct net *net, const char *name)
775 : : {
776 : 75 : struct netdev_name_node *node_name;
777 : :
778 : 66 : node_name = netdev_name_node_lookup(net, name);
779 [ - - - - : 75 : return node_name ? node_name->dev : NULL;
- + - + +
+ - + -
- ]
780 : : }
781 : : EXPORT_SYMBOL(__dev_get_by_name);
782 : :
783 : : /**
784 : : * dev_get_by_name_rcu - find a device by its name
785 : : * @net: the applicable net namespace
786 : : * @name: name to find
787 : : *
788 : : * Find an interface by name.
789 : : * If the name is found a pointer to the device is returned.
790 : : * If the name is not found then %NULL is returned.
791 : : * The reference counters are not incremented so the caller must be
792 : : * careful with locks. The caller must hold RCU lock.
793 : : */
794 : :
795 : 66 : struct net_device *dev_get_by_name_rcu(struct net *net, const char *name)
796 : : {
797 : 66 : struct netdev_name_node *node_name;
798 : :
799 : 66 : node_name = netdev_name_node_lookup_rcu(net, name);
800 [ - - + + ]: 66 : return node_name ? node_name->dev : NULL;
801 : : }
802 : : EXPORT_SYMBOL(dev_get_by_name_rcu);
803 : :
804 : : /**
805 : : * dev_get_by_name - find a device by its name
806 : : * @net: the applicable net namespace
807 : : * @name: name to find
808 : : *
809 : : * Find an interface by name. This can be called from any
810 : : * context and does its own locking. The returned handle has
811 : : * the usage count incremented and the caller must use dev_put() to
812 : : * release it when it is no longer needed. %NULL is returned if no
813 : : * matching device is found.
814 : : */
815 : :
816 : 0 : struct net_device *dev_get_by_name(struct net *net, const char *name)
817 : : {
818 : 0 : struct net_device *dev;
819 : :
820 : 0 : rcu_read_lock();
821 : 0 : dev = dev_get_by_name_rcu(net, name);
822 [ # # ]: 0 : if (dev)
823 : 0 : dev_hold(dev);
824 : 0 : rcu_read_unlock();
825 : 0 : return dev;
826 : : }
827 : : EXPORT_SYMBOL(dev_get_by_name);
828 : :
829 : : /**
830 : : * __dev_get_by_index - find a device by its ifindex
831 : : * @net: the applicable net namespace
832 : : * @ifindex: index of device
833 : : *
834 : : * Search for an interface by index. Returns %NULL if the device
835 : : * is not found or a pointer to the device. The device has not
836 : : * had its reference counter increased so the caller must be careful
837 : : * about locking. The caller must hold either the RTNL semaphore
838 : : * or @dev_base_lock.
839 : : */
840 : :
841 : 27 : struct net_device *__dev_get_by_index(struct net *net, int ifindex)
842 : : {
843 : 27 : struct net_device *dev;
844 : 27 : struct hlist_head *head = dev_index_hash(net, ifindex);
845 : :
846 [ - - - - : 45 : hlist_for_each_entry(dev, head, index_hlist)
- - - - -
- - + + -
- - + - ]
847 [ - - - - : 18 : if (dev->ifindex == ifindex)
- - + - ]
848 : 18 : return dev;
849 : :
850 : : return NULL;
851 : : }
852 : : EXPORT_SYMBOL(__dev_get_by_index);
853 : :
854 : : /**
855 : : * dev_get_by_index_rcu - find a device by its ifindex
856 : : * @net: the applicable net namespace
857 : : * @ifindex: index of device
858 : : *
859 : : * Search for an interface by index. Returns %NULL if the device
860 : : * is not found or a pointer to the device. The device has not
861 : : * had its reference counter increased so the caller must be careful
862 : : * about locking. The caller must hold RCU lock.
863 : : */
864 : :
865 : 36 : struct net_device *dev_get_by_index_rcu(struct net *net, int ifindex)
866 : : {
867 : 36 : struct net_device *dev;
868 : 36 : struct hlist_head *head = dev_index_hash(net, ifindex);
869 : :
870 [ - - - - : 72 : hlist_for_each_entry_rcu(dev, head, index_hlist)
- - + - +
- - - +
- ]
871 [ - - - + : 36 : if (dev->ifindex == ifindex)
+ - ]
872 : 6 : return dev;
873 : :
874 : : return NULL;
875 : : }
876 : : EXPORT_SYMBOL(dev_get_by_index_rcu);
877 : :
878 : :
879 : : /**
880 : : * dev_get_by_index - find a device by its ifindex
881 : : * @net: the applicable net namespace
882 : : * @ifindex: index of device
883 : : *
884 : : * Search for an interface by index. Returns NULL if the device
885 : : * is not found or a pointer to the device. The device returned has
886 : : * had a reference added and the pointer is safe until the user calls
887 : : * dev_put to indicate they have finished with it.
888 : : */
889 : :
890 : 30 : struct net_device *dev_get_by_index(struct net *net, int ifindex)
891 : : {
892 : 30 : struct net_device *dev;
893 : :
894 : 30 : rcu_read_lock();
895 [ + - ]: 30 : dev = dev_get_by_index_rcu(net, ifindex);
896 [ + - ]: 30 : if (dev)
897 : 30 : dev_hold(dev);
898 : 30 : rcu_read_unlock();
899 : 30 : return dev;
900 : : }
901 : : EXPORT_SYMBOL(dev_get_by_index);
902 : :
903 : : /**
904 : : * dev_get_by_napi_id - find a device by napi_id
905 : : * @napi_id: ID of the NAPI struct
906 : : *
907 : : * Search for an interface by NAPI ID. Returns %NULL if the device
908 : : * is not found or a pointer to the device. The device has not had
909 : : * its reference counter increased so the caller must be careful
910 : : * about locking. The caller must hold RCU lock.
911 : : */
912 : :
913 : 0 : struct net_device *dev_get_by_napi_id(unsigned int napi_id)
914 : : {
915 : 0 : struct napi_struct *napi;
916 : :
917 [ # # ]: 0 : WARN_ON_ONCE(!rcu_read_lock_held());
918 : :
919 [ # # ]: 0 : if (napi_id < MIN_NAPI_ID)
920 : : return NULL;
921 : :
922 : 0 : napi = napi_by_id(napi_id);
923 : :
924 [ # # ]: 0 : return napi ? napi->dev : NULL;
925 : : }
926 : : EXPORT_SYMBOL(dev_get_by_napi_id);
927 : :
928 : : /**
929 : : * netdev_get_name - get a netdevice name, knowing its ifindex.
930 : : * @net: network namespace
931 : : * @name: a pointer to the buffer where the name will be stored.
932 : : * @ifindex: the ifindex of the interface to get the name from.
933 : : *
934 : : * The use of raw_seqcount_begin() and cond_resched() before
935 : : * retrying is required as we want to give the writers a chance
936 : : * to complete when CONFIG_PREEMPTION is not set.
937 : : */
938 : 0 : int netdev_get_name(struct net *net, char *name, int ifindex)
939 : : {
940 : 0 : struct net_device *dev;
941 : 0 : unsigned int seq;
942 : :
943 : 0 : retry:
944 : 0 : seq = raw_seqcount_begin(&devnet_rename_seq);
945 : 0 : rcu_read_lock();
946 [ # # ]: 0 : dev = dev_get_by_index_rcu(net, ifindex);
947 [ # # ]: 0 : if (!dev) {
948 : 0 : rcu_read_unlock();
949 : 0 : return -ENODEV;
950 : : }
951 : :
952 : 0 : strcpy(name, dev->name);
953 : 0 : rcu_read_unlock();
954 [ # # ]: 0 : if (read_seqcount_retry(&devnet_rename_seq, seq)) {
955 : 0 : cond_resched();
956 : 0 : goto retry;
957 : : }
958 : :
959 : : return 0;
960 : : }
961 : :
962 : : /**
963 : : * dev_getbyhwaddr_rcu - find a device by its hardware address
964 : : * @net: the applicable net namespace
965 : : * @type: media type of device
966 : : * @ha: hardware address
967 : : *
968 : : * Search for an interface by MAC address. Returns NULL if the device
969 : : * is not found or a pointer to the device.
970 : : * The caller must hold RCU or RTNL.
971 : : * The returned device has not had its ref count increased
972 : : * and the caller must therefore be careful about locking
973 : : *
974 : : */
975 : :
976 : 0 : struct net_device *dev_getbyhwaddr_rcu(struct net *net, unsigned short type,
977 : : const char *ha)
978 : : {
979 : 0 : struct net_device *dev;
980 : :
981 [ # # ]: 0 : for_each_netdev_rcu(net, dev)
982 [ # # ]: 0 : if (dev->type == type &&
983 [ # # ]: 0 : !memcmp(dev->dev_addr, ha, dev->addr_len))
984 : 0 : return dev;
985 : :
986 : : return NULL;
987 : : }
988 : : EXPORT_SYMBOL(dev_getbyhwaddr_rcu);
989 : :
990 : 0 : struct net_device *__dev_getfirstbyhwtype(struct net *net, unsigned short type)
991 : : {
992 : 0 : struct net_device *dev;
993 : :
994 [ # # # # ]: 0 : ASSERT_RTNL();
995 [ # # ]: 0 : for_each_netdev(net, dev)
996 [ # # ]: 0 : if (dev->type == type)
997 : 0 : return dev;
998 : :
999 : : return NULL;
1000 : : }
1001 : : EXPORT_SYMBOL(__dev_getfirstbyhwtype);
1002 : :
1003 : 0 : struct net_device *dev_getfirstbyhwtype(struct net *net, unsigned short type)
1004 : : {
1005 : 0 : struct net_device *dev, *ret = NULL;
1006 : :
1007 : 0 : rcu_read_lock();
1008 [ # # ]: 0 : for_each_netdev_rcu(net, dev)
1009 [ # # ]: 0 : if (dev->type == type) {
1010 : 0 : dev_hold(dev);
1011 : 0 : ret = dev;
1012 : 0 : break;
1013 : : }
1014 : 0 : rcu_read_unlock();
1015 : 0 : return ret;
1016 : : }
1017 : : EXPORT_SYMBOL(dev_getfirstbyhwtype);
1018 : :
1019 : : /**
1020 : : * __dev_get_by_flags - find any device with given flags
1021 : : * @net: the applicable net namespace
1022 : : * @if_flags: IFF_* values
1023 : : * @mask: bitmask of bits in if_flags to check
1024 : : *
1025 : : * Search for any interface with the given flags. Returns NULL if a device
1026 : : * is not found or a pointer to the device. Must be called inside
1027 : : * rtnl_lock(), and result refcount is unchanged.
1028 : : */
1029 : :
1030 : 0 : struct net_device *__dev_get_by_flags(struct net *net, unsigned short if_flags,
1031 : : unsigned short mask)
1032 : : {
1033 : 0 : struct net_device *dev, *ret;
1034 : :
1035 [ # # # # ]: 0 : ASSERT_RTNL();
1036 : :
1037 : 0 : ret = NULL;
1038 [ # # ]: 0 : for_each_netdev(net, dev) {
1039 [ # # ]: 0 : if (((dev->flags ^ if_flags) & mask) == 0) {
1040 : : ret = dev;
1041 : : break;
1042 : : }
1043 : : }
1044 : 0 : return ret;
1045 : : }
1046 : : EXPORT_SYMBOL(__dev_get_by_flags);
1047 : :
1048 : : /**
1049 : : * dev_valid_name - check if name is okay for network device
1050 : : * @name: name string
1051 : : *
1052 : : * Network device names need to be valid file names to
1053 : : * to allow sysfs to work. We also disallow any kind of
1054 : : * whitespace.
1055 : : */
1056 : 12 : bool dev_valid_name(const char *name)
1057 : : {
1058 [ + - ]: 12 : if (*name == '\0')
1059 : : return false;
1060 [ + - ]: 12 : if (strnlen(name, IFNAMSIZ) == IFNAMSIZ)
1061 : : return false;
1062 [ + - + - ]: 12 : if (!strcmp(name, ".") || !strcmp(name, ".."))
1063 : : return false;
1064 : :
1065 [ + + ]: 60 : while (*name) {
1066 [ + - + - ]: 48 : if (*name == '/' || *name == ':' || isspace(*name))
1067 : : return false;
1068 : 48 : name++;
1069 : : }
1070 : : return true;
1071 : : }
1072 : : EXPORT_SYMBOL(dev_valid_name);
1073 : :
1074 : : /**
1075 : : * __dev_alloc_name - allocate a name for a device
1076 : : * @net: network namespace to allocate the device name in
1077 : : * @name: name format string
1078 : : * @buf: scratch buffer and result name string
1079 : : *
1080 : : * Passed a format string - eg "lt%d" it will try and find a suitable
1081 : : * id. It scans list of devices to build up a free map, then chooses
1082 : : * the first empty slot. The caller must hold the dev_base or rtnl lock
1083 : : * while allocating the name and adding the device in order to avoid
1084 : : * duplicates.
1085 : : * Limited to bits_per_byte * page size devices (ie 32K on most platforms).
1086 : : * Returns the number of the unit assigned or a negative errno code.
1087 : : */
1088 : :
1089 : 3 : static int __dev_alloc_name(struct net *net, const char *name, char *buf)
1090 : : {
1091 : 3 : int i = 0;
1092 : 3 : const char *p;
1093 : 3 : const int max_netdevices = 8*PAGE_SIZE;
1094 : 3 : unsigned long *inuse;
1095 : 3 : struct net_device *d;
1096 : :
1097 [ + - ]: 3 : if (!dev_valid_name(name))
1098 : : return -EINVAL;
1099 : :
1100 : 3 : p = strchr(name, '%');
1101 [ + - ]: 3 : if (p) {
1102 : : /*
1103 : : * Verify the string as this thing may have come from
1104 : : * the user. There must be either one "%d" and no other "%"
1105 : : * characters.
1106 : : */
1107 [ + - + - ]: 3 : if (p[1] != 'd' || strchr(p + 2, '%'))
1108 : : return -EINVAL;
1109 : :
1110 : : /* Use one page as a bit array of possible slots */
1111 : 3 : inuse = (unsigned long *) get_zeroed_page(GFP_ATOMIC);
1112 [ + - ]: 3 : if (!inuse)
1113 : : return -ENOMEM;
1114 : :
1115 [ + + ]: 9 : for_each_netdev(net, d) {
1116 [ + - ]: 6 : if (!sscanf(d->name, name, &i))
1117 : 6 : continue;
1118 [ # # ]: 0 : if (i < 0 || i >= max_netdevices)
1119 : 0 : continue;
1120 : :
1121 : : /* avoid cases where sscanf is not exact inverse of printf */
1122 : 0 : snprintf(buf, IFNAMSIZ, name, i);
1123 [ # # ]: 0 : if (!strncmp(buf, d->name, IFNAMSIZ))
1124 : 0 : set_bit(i, inuse);
1125 : : }
1126 : :
1127 : 3 : i = find_first_zero_bit(inuse, max_netdevices);
1128 : 3 : free_page((unsigned long) inuse);
1129 : : }
1130 : :
1131 : 3 : snprintf(buf, IFNAMSIZ, name, i);
1132 [ - - ]: 3 : if (!__dev_get_by_name(net, buf))
1133 : 3 : return i;
1134 : :
1135 : : /* It is possible to run out of possible slots
1136 : : * when the name is long and there isn't enough space left
1137 : : * for the digits, or if all bits are used.
1138 : : */
1139 : : return -ENFILE;
1140 : : }
1141 : :
1142 : 3 : static int dev_alloc_name_ns(struct net *net,
1143 : : struct net_device *dev,
1144 : : const char *name)
1145 : : {
1146 : 3 : char buf[IFNAMSIZ];
1147 : 3 : int ret;
1148 : :
1149 [ - + ]: 3 : BUG_ON(!net);
1150 : 3 : ret = __dev_alloc_name(net, name, buf);
1151 [ + - ]: 3 : if (ret >= 0)
1152 : 3 : strlcpy(dev->name, buf, IFNAMSIZ);
1153 : 3 : return ret;
1154 : : }
1155 : :
1156 : : /**
1157 : : * dev_alloc_name - allocate a name for a device
1158 : : * @dev: device
1159 : : * @name: name format string
1160 : : *
1161 : : * Passed a format string - eg "lt%d" it will try and find a suitable
1162 : : * id. It scans list of devices to build up a free map, then chooses
1163 : : * the first empty slot. The caller must hold the dev_base or rtnl lock
1164 : : * while allocating the name and adding the device in order to avoid
1165 : : * duplicates.
1166 : : * Limited to bits_per_byte * page size devices (ie 32K on most platforms).
1167 : : * Returns the number of the unit assigned or a negative errno code.
1168 : : */
1169 : :
1170 : 0 : int dev_alloc_name(struct net_device *dev, const char *name)
1171 : : {
1172 : 0 : return dev_alloc_name_ns(dev_net(dev), dev, name);
1173 : : }
1174 : : EXPORT_SYMBOL(dev_alloc_name);
1175 : :
1176 : 9 : static int dev_get_valid_name(struct net *net, struct net_device *dev,
1177 : : const char *name)
1178 : : {
1179 [ - + ]: 9 : BUG_ON(!net);
1180 : :
1181 [ + - ]: 9 : if (!dev_valid_name(name))
1182 : : return -EINVAL;
1183 : :
1184 [ + + ]: 9 : if (strchr(name, '%'))
1185 : 3 : return dev_alloc_name_ns(net, dev, name);
1186 [ - - ]: 6 : else if (__dev_get_by_name(net, name))
1187 : : return -EEXIST;
1188 [ - + ]: 6 : else if (dev->name != name)
1189 : 0 : strlcpy(dev->name, name, IFNAMSIZ);
1190 : :
1191 : : return 0;
1192 : : }
1193 : :
1194 : : /**
1195 : : * dev_change_name - change name of a device
1196 : : * @dev: device
1197 : : * @newname: name (or format string) must be at least IFNAMSIZ
1198 : : *
1199 : : * Change name of a device, can pass format strings "eth%d".
1200 : : * for wildcarding.
1201 : : */
1202 : 0 : int dev_change_name(struct net_device *dev, const char *newname)
1203 : : {
1204 : 0 : unsigned char old_assign_type;
1205 : 0 : char oldname[IFNAMSIZ];
1206 : 0 : int err = 0;
1207 : 0 : int ret;
1208 : 0 : struct net *net;
1209 : :
1210 [ # # # # ]: 0 : ASSERT_RTNL();
1211 [ # # ]: 0 : BUG_ON(!dev_net(dev));
1212 : :
1213 [ # # ]: 0 : net = dev_net(dev);
1214 : :
1215 : : /* Some auto-enslaved devices e.g. failover slaves are
1216 : : * special, as userspace might rename the device after
1217 : : * the interface had been brought up and running since
1218 : : * the point kernel initiated auto-enslavement. Allow
1219 : : * live name change even when these slave devices are
1220 : : * up and running.
1221 : : *
1222 : : * Typically, users of these auto-enslaving devices
1223 : : * don't actually care about slave name change, as
1224 : : * they are supposed to operate on master interface
1225 : : * directly.
1226 : : */
1227 [ # # ]: 0 : if (dev->flags & IFF_UP &&
1228 [ # # ]: 0 : likely(!(dev->priv_flags & IFF_LIVE_RENAME_OK)))
1229 : : return -EBUSY;
1230 : :
1231 : 0 : write_seqcount_begin(&devnet_rename_seq);
1232 : :
1233 [ # # ]: 0 : if (strncmp(newname, dev->name, IFNAMSIZ) == 0) {
1234 : 0 : write_seqcount_end(&devnet_rename_seq);
1235 : 0 : return 0;
1236 : : }
1237 : :
1238 : 0 : memcpy(oldname, dev->name, IFNAMSIZ);
1239 : :
1240 : 0 : err = dev_get_valid_name(net, dev, newname);
1241 [ # # ]: 0 : if (err < 0) {
1242 : 0 : write_seqcount_end(&devnet_rename_seq);
1243 : 0 : return err;
1244 : : }
1245 : :
1246 [ # # # # ]: 0 : if (oldname[0] && !strchr(oldname, '%'))
1247 : 0 : netdev_info(dev, "renamed from %s\n", oldname);
1248 : :
1249 : 0 : old_assign_type = dev->name_assign_type;
1250 : 0 : dev->name_assign_type = NET_NAME_RENAMED;
1251 : :
1252 : 0 : rollback:
1253 : 0 : ret = device_rename(&dev->dev, dev->name);
1254 [ # # ]: 0 : if (ret) {
1255 : 0 : memcpy(dev->name, oldname, IFNAMSIZ);
1256 : 0 : dev->name_assign_type = old_assign_type;
1257 : 0 : write_seqcount_end(&devnet_rename_seq);
1258 : 0 : return ret;
1259 : : }
1260 : :
1261 : 0 : write_seqcount_end(&devnet_rename_seq);
1262 : :
1263 : 0 : netdev_adjacent_rename_links(dev, oldname);
1264 : :
1265 : 0 : write_lock_bh(&dev_base_lock);
1266 [ # # ]: 0 : netdev_name_node_del(dev->name_node);
1267 : 0 : write_unlock_bh(&dev_base_lock);
1268 : :
1269 : 0 : synchronize_rcu();
1270 : :
1271 : 0 : write_lock_bh(&dev_base_lock);
1272 : 0 : netdev_name_node_add(net, dev->name_node);
1273 : 0 : write_unlock_bh(&dev_base_lock);
1274 : :
1275 : 0 : ret = call_netdevice_notifiers(NETDEV_CHANGENAME, dev);
1276 [ # # ]: 0 : ret = notifier_to_errno(ret);
1277 : :
1278 : 0 : if (ret) {
1279 : : /* err >= 0 after dev_alloc_name() or stores the first errno */
1280 [ # # ]: 0 : if (err >= 0) {
1281 : 0 : err = ret;
1282 : 0 : write_seqcount_begin(&devnet_rename_seq);
1283 : 0 : memcpy(dev->name, oldname, IFNAMSIZ);
1284 : 0 : memcpy(oldname, newname, IFNAMSIZ);
1285 : 0 : dev->name_assign_type = old_assign_type;
1286 : 0 : old_assign_type = NET_NAME_RENAMED;
1287 : 0 : goto rollback;
1288 : : } else {
1289 : 0 : pr_err("%s: name change rollback failed: %d\n",
1290 : : dev->name, ret);
1291 : : }
1292 : : }
1293 : :
1294 : : return err;
1295 : : }
1296 : :
1297 : : /**
1298 : : * dev_set_alias - change ifalias of a device
1299 : : * @dev: device
1300 : : * @alias: name up to IFALIASZ
1301 : : * @len: limit of bytes to copy from info
1302 : : *
1303 : : * Set ifalias for a device,
1304 : : */
1305 : 0 : int dev_set_alias(struct net_device *dev, const char *alias, size_t len)
1306 : : {
1307 : 0 : struct dev_ifalias *new_alias = NULL;
1308 : :
1309 [ # # ]: 0 : if (len >= IFALIASZ)
1310 : : return -EINVAL;
1311 : :
1312 [ # # ]: 0 : if (len) {
1313 [ # # ]: 0 : new_alias = kmalloc(sizeof(*new_alias) + len + 1, GFP_KERNEL);
1314 [ # # ]: 0 : if (!new_alias)
1315 : : return -ENOMEM;
1316 : :
1317 : 0 : memcpy(new_alias->ifalias, alias, len);
1318 : 0 : new_alias->ifalias[len] = 0;
1319 : : }
1320 : :
1321 : 0 : mutex_lock(&ifalias_mutex);
1322 : 0 : new_alias = rcu_replace_pointer(dev->ifalias, new_alias,
1323 : : mutex_is_locked(&ifalias_mutex));
1324 : 0 : mutex_unlock(&ifalias_mutex);
1325 : :
1326 [ # # ]: 0 : if (new_alias)
1327 : 0 : kfree_rcu(new_alias, rcuhead);
1328 : :
1329 : 0 : return len;
1330 : : }
1331 : : EXPORT_SYMBOL(dev_set_alias);
1332 : :
1333 : : /**
1334 : : * dev_get_alias - get ifalias of a device
1335 : : * @dev: device
1336 : : * @name: buffer to store name of ifalias
1337 : : * @len: size of buffer
1338 : : *
1339 : : * get ifalias for a device. Caller must make sure dev cannot go
1340 : : * away, e.g. rcu read lock or own a reference count to device.
1341 : : */
1342 : 60 : int dev_get_alias(const struct net_device *dev, char *name, size_t len)
1343 : : {
1344 : 60 : const struct dev_ifalias *alias;
1345 : 60 : int ret = 0;
1346 : :
1347 : 60 : rcu_read_lock();
1348 [ - + ]: 60 : alias = rcu_dereference(dev->ifalias);
1349 [ - + ]: 60 : if (alias)
1350 : 0 : ret = snprintf(name, len, "%s", alias->ifalias);
1351 : 60 : rcu_read_unlock();
1352 : :
1353 : 60 : return ret;
1354 : : }
1355 : :
1356 : : /**
1357 : : * netdev_features_change - device changes features
1358 : : * @dev: device to cause notification
1359 : : *
1360 : : * Called to indicate a device has changed features.
1361 : : */
1362 : 0 : void netdev_features_change(struct net_device *dev)
1363 : : {
1364 : 0 : call_netdevice_notifiers(NETDEV_FEAT_CHANGE, dev);
1365 : 0 : }
1366 : : EXPORT_SYMBOL(netdev_features_change);
1367 : :
1368 : : /**
1369 : : * netdev_state_change - device changes state
1370 : : * @dev: device to cause notification
1371 : : *
1372 : : * Called to indicate a device has changed state. This function calls
1373 : : * the notifier chains for netdev_chain and sends a NEWLINK message
1374 : : * to the routing socket.
1375 : : */
1376 : 3 : void netdev_state_change(struct net_device *dev)
1377 : : {
1378 [ + - ]: 3 : if (dev->flags & IFF_UP) {
1379 : 3 : struct netdev_notifier_change_info change_info = {
1380 : : .info.dev = dev,
1381 : : };
1382 : :
1383 : 3 : call_netdevice_notifiers_info(NETDEV_CHANGE,
1384 : : &change_info.info);
1385 : 3 : rtmsg_ifinfo(RTM_NEWLINK, dev, 0, GFP_KERNEL);
1386 : : }
1387 : 3 : }
1388 : : EXPORT_SYMBOL(netdev_state_change);
1389 : :
1390 : : /**
1391 : : * netdev_notify_peers - notify network peers about existence of @dev
1392 : : * @dev: network device
1393 : : *
1394 : : * Generate traffic such that interested network peers are aware of
1395 : : * @dev, such as by generating a gratuitous ARP. This may be used when
1396 : : * a device wants to inform the rest of the network about some sort of
1397 : : * reconfiguration such as a failover event or virtual machine
1398 : : * migration.
1399 : : */
1400 : 0 : void netdev_notify_peers(struct net_device *dev)
1401 : : {
1402 : 0 : rtnl_lock();
1403 : 0 : call_netdevice_notifiers(NETDEV_NOTIFY_PEERS, dev);
1404 : 0 : call_netdevice_notifiers(NETDEV_RESEND_IGMP, dev);
1405 : 0 : rtnl_unlock();
1406 : 0 : }
1407 : : EXPORT_SYMBOL(netdev_notify_peers);
1408 : :
1409 : 6 : static int __dev_open(struct net_device *dev, struct netlink_ext_ack *extack)
1410 : : {
1411 : 6 : const struct net_device_ops *ops = dev->netdev_ops;
1412 : 6 : int ret;
1413 : :
1414 [ - + - - ]: 6 : ASSERT_RTNL();
1415 : :
1416 [ + - ]: 6 : if (!netif_device_present(dev))
1417 : : return -ENODEV;
1418 : :
1419 : : /* Block netpoll from trying to do any rx path servicing.
1420 : : * If we don't do this there is a chance ndo_poll_controller
1421 : : * or ndo_poll may be running while we open the device
1422 : : */
1423 : 6 : netpoll_poll_disable(dev);
1424 : :
1425 : 6 : ret = call_netdevice_notifiers_extack(NETDEV_PRE_UP, dev, extack);
1426 [ - + ]: 6 : ret = notifier_to_errno(ret);
1427 : 0 : if (ret)
1428 : 0 : return ret;
1429 : :
1430 : 6 : set_bit(__LINK_STATE_START, &dev->state);
1431 : :
1432 [ + + ]: 6 : if (ops->ndo_validate_addr)
1433 : 3 : ret = ops->ndo_validate_addr(dev);
1434 : :
1435 [ + - + + ]: 6 : if (!ret && ops->ndo_open)
1436 : 3 : ret = ops->ndo_open(dev);
1437 : :
1438 : 6 : netpoll_poll_enable(dev);
1439 : :
1440 [ - + ]: 6 : if (ret)
1441 : 0 : clear_bit(__LINK_STATE_START, &dev->state);
1442 : : else {
1443 : 6 : dev->flags |= IFF_UP;
1444 : 6 : dev_set_rx_mode(dev);
1445 : 6 : dev_activate(dev);
1446 : 6 : add_device_randomness(dev->dev_addr, dev->addr_len);
1447 : : }
1448 : :
1449 : : return ret;
1450 : : }
1451 : :
1452 : : /**
1453 : : * dev_open - prepare an interface for use.
1454 : : * @dev: device to open
1455 : : * @extack: netlink extended ack
1456 : : *
1457 : : * Takes a device from down to up state. The device's private open
1458 : : * function is invoked and then the multicast lists are loaded. Finally
1459 : : * the device is moved into the up state and a %NETDEV_UP message is
1460 : : * sent to the netdev notifier chain.
1461 : : *
1462 : : * Calling this function on an active interface is a nop. On a failure
1463 : : * a negative errno code is returned.
1464 : : */
1465 : 0 : int dev_open(struct net_device *dev, struct netlink_ext_ack *extack)
1466 : : {
1467 : 0 : int ret;
1468 : :
1469 [ # # ]: 0 : if (dev->flags & IFF_UP)
1470 : : return 0;
1471 : :
1472 : 0 : ret = __dev_open(dev, extack);
1473 [ # # ]: 0 : if (ret < 0)
1474 : : return ret;
1475 : :
1476 : 0 : rtmsg_ifinfo(RTM_NEWLINK, dev, IFF_UP|IFF_RUNNING, GFP_KERNEL);
1477 : 0 : call_netdevice_notifiers(NETDEV_UP, dev);
1478 : :
1479 : 0 : return ret;
1480 : : }
1481 : : EXPORT_SYMBOL(dev_open);
1482 : :
1483 : 0 : static void __dev_close_many(struct list_head *head)
1484 : : {
1485 : 0 : struct net_device *dev;
1486 : :
1487 [ # # # # ]: 0 : ASSERT_RTNL();
1488 : 0 : might_sleep();
1489 : :
1490 [ # # ]: 0 : list_for_each_entry(dev, head, close_list) {
1491 : : /* Temporarily disable netpoll until the interface is down */
1492 : 0 : netpoll_poll_disable(dev);
1493 : :
1494 : 0 : call_netdevice_notifiers(NETDEV_GOING_DOWN, dev);
1495 : :
1496 : 0 : clear_bit(__LINK_STATE_START, &dev->state);
1497 : :
1498 : : /* Synchronize to scheduled poll. We cannot touch poll list, it
1499 : : * can be even on different cpu. So just clear netif_running().
1500 : : *
1501 : : * dev->stop() will invoke napi_disable() on all of it's
1502 : : * napi_struct instances on this device.
1503 : : */
1504 : 0 : smp_mb__after_atomic(); /* Commit netif_running(). */
1505 : : }
1506 : :
1507 : 0 : dev_deactivate_many(head);
1508 : :
1509 [ # # ]: 0 : list_for_each_entry(dev, head, close_list) {
1510 : 0 : const struct net_device_ops *ops = dev->netdev_ops;
1511 : :
1512 : : /*
1513 : : * Call the device specific close. This cannot fail.
1514 : : * Only if device is UP
1515 : : *
1516 : : * We allow it to be called even after a DETACH hot-plug
1517 : : * event.
1518 : : */
1519 [ # # ]: 0 : if (ops->ndo_stop)
1520 : 0 : ops->ndo_stop(dev);
1521 : :
1522 : 0 : dev->flags &= ~IFF_UP;
1523 : 0 : netpoll_poll_enable(dev);
1524 : : }
1525 : 0 : }
1526 : :
1527 : 0 : static void __dev_close(struct net_device *dev)
1528 : : {
1529 : 0 : LIST_HEAD(single);
1530 : :
1531 : 0 : list_add(&dev->close_list, &single);
1532 : 0 : __dev_close_many(&single);
1533 : 0 : list_del(&single);
1534 : 0 : }
1535 : :
1536 : 0 : void dev_close_many(struct list_head *head, bool unlink)
1537 : : {
1538 : 0 : struct net_device *dev, *tmp;
1539 : :
1540 : : /* Remove the devices that don't need to be closed */
1541 [ # # ]: 0 : list_for_each_entry_safe(dev, tmp, head, close_list)
1542 [ # # ]: 0 : if (!(dev->flags & IFF_UP))
1543 : 0 : list_del_init(&dev->close_list);
1544 : :
1545 : 0 : __dev_close_many(head);
1546 : :
1547 [ # # ]: 0 : list_for_each_entry_safe(dev, tmp, head, close_list) {
1548 : 0 : rtmsg_ifinfo(RTM_NEWLINK, dev, IFF_UP|IFF_RUNNING, GFP_KERNEL);
1549 : 0 : call_netdevice_notifiers(NETDEV_DOWN, dev);
1550 [ # # ]: 0 : if (unlink)
1551 : 0 : list_del_init(&dev->close_list);
1552 : : }
1553 : 0 : }
1554 : : EXPORT_SYMBOL(dev_close_many);
1555 : :
1556 : : /**
1557 : : * dev_close - shutdown an interface.
1558 : : * @dev: device to shutdown
1559 : : *
1560 : : * This function moves an active device into down state. A
1561 : : * %NETDEV_GOING_DOWN is sent to the netdev notifier chain. The device
1562 : : * is then deactivated and finally a %NETDEV_DOWN is sent to the notifier
1563 : : * chain.
1564 : : */
1565 : 0 : void dev_close(struct net_device *dev)
1566 : : {
1567 [ # # ]: 0 : if (dev->flags & IFF_UP) {
1568 : 0 : LIST_HEAD(single);
1569 : :
1570 : 0 : list_add(&dev->close_list, &single);
1571 : 0 : dev_close_many(&single, true);
1572 : 0 : list_del(&single);
1573 : : }
1574 : 0 : }
1575 : : EXPORT_SYMBOL(dev_close);
1576 : :
1577 : :
1578 : : /**
1579 : : * dev_disable_lro - disable Large Receive Offload on a device
1580 : : * @dev: device
1581 : : *
1582 : : * Disable Large Receive Offload (LRO) on a net device. Must be
1583 : : * called under RTNL. This is needed if received packets may be
1584 : : * forwarded to another interface.
1585 : : */
1586 : 0 : void dev_disable_lro(struct net_device *dev)
1587 : : {
1588 : 0 : struct net_device *lower_dev;
1589 : 0 : struct list_head *iter;
1590 : :
1591 : 0 : dev->wanted_features &= ~NETIF_F_LRO;
1592 : 0 : netdev_update_features(dev);
1593 : :
1594 [ # # ]: 0 : if (unlikely(dev->features & NETIF_F_LRO))
1595 : 0 : netdev_WARN(dev, "failed to disable LRO!\n");
1596 : :
1597 [ # # ]: 0 : netdev_for_each_lower_dev(dev, lower_dev, iter)
1598 : 0 : dev_disable_lro(lower_dev);
1599 : 0 : }
1600 : : EXPORT_SYMBOL(dev_disable_lro);
1601 : :
1602 : : /**
1603 : : * dev_disable_gro_hw - disable HW Generic Receive Offload on a device
1604 : : * @dev: device
1605 : : *
1606 : : * Disable HW Generic Receive Offload (GRO_HW) on a net device. Must be
1607 : : * called under RTNL. This is needed if Generic XDP is installed on
1608 : : * the device.
1609 : : */
1610 : 0 : static void dev_disable_gro_hw(struct net_device *dev)
1611 : : {
1612 : 0 : dev->wanted_features &= ~NETIF_F_GRO_HW;
1613 : 0 : netdev_update_features(dev);
1614 : :
1615 [ # # ]: 0 : if (unlikely(dev->features & NETIF_F_GRO_HW))
1616 : 0 : netdev_WARN(dev, "failed to disable GRO_HW!\n");
1617 : 0 : }
1618 : :
1619 : 0 : const char *netdev_cmd_to_name(enum netdev_cmd cmd)
1620 : : {
1621 : : #define N(val) \
1622 : : case NETDEV_##val: \
1623 : : return "NETDEV_" __stringify(val);
1624 [ # # ]: 0 : switch (cmd) {
1625 : : N(UP) N(DOWN) N(REBOOT) N(CHANGE) N(REGISTER) N(UNREGISTER)
1626 : : N(CHANGEMTU) N(CHANGEADDR) N(GOING_DOWN) N(CHANGENAME) N(FEAT_CHANGE)
1627 : : N(BONDING_FAILOVER) N(PRE_UP) N(PRE_TYPE_CHANGE) N(POST_TYPE_CHANGE)
1628 : : N(POST_INIT) N(RELEASE) N(NOTIFY_PEERS) N(JOIN) N(CHANGEUPPER)
1629 : : N(RESEND_IGMP) N(PRECHANGEMTU) N(CHANGEINFODATA) N(BONDING_INFO)
1630 : : N(PRECHANGEUPPER) N(CHANGELOWERSTATE) N(UDP_TUNNEL_PUSH_INFO)
1631 : : N(UDP_TUNNEL_DROP_INFO) N(CHANGE_TX_QUEUE_LEN)
1632 : : N(CVLAN_FILTER_PUSH_INFO) N(CVLAN_FILTER_DROP_INFO)
1633 : : N(SVLAN_FILTER_PUSH_INFO) N(SVLAN_FILTER_DROP_INFO)
1634 : : N(PRE_CHANGEADDR)
1635 : : }
1636 : : #undef N
1637 : : return "UNKNOWN_NETDEV_EVENT";
1638 : : }
1639 : : EXPORT_SYMBOL_GPL(netdev_cmd_to_name);
1640 : :
1641 : 66 : static int call_netdevice_notifier(struct notifier_block *nb, unsigned long val,
1642 : : struct net_device *dev)
1643 : : {
1644 : 66 : struct netdev_notifier_info info = {
1645 : : .dev = dev,
1646 : : };
1647 : :
1648 : 66 : return nb->notifier_call(nb, val, &info);
1649 : : }
1650 : :
1651 : 66 : static int call_netdevice_register_notifiers(struct notifier_block *nb,
1652 : : struct net_device *dev)
1653 : : {
1654 : 66 : int err;
1655 : :
1656 : 66 : err = call_netdevice_notifier(nb, NETDEV_REGISTER, dev);
1657 [ - + ]: 66 : err = notifier_to_errno(err);
1658 : 0 : if (err)
1659 : 0 : return err;
1660 : :
1661 [ - + ]: 66 : if (!(dev->flags & IFF_UP))
1662 : : return 0;
1663 : :
1664 : 0 : call_netdevice_notifier(nb, NETDEV_UP, dev);
1665 : 0 : return 0;
1666 : : }
1667 : :
1668 : 0 : static void call_netdevice_unregister_notifiers(struct notifier_block *nb,
1669 : : struct net_device *dev)
1670 : : {
1671 [ # # ]: 0 : if (dev->flags & IFF_UP) {
1672 : 0 : call_netdevice_notifier(nb, NETDEV_GOING_DOWN,
1673 : : dev);
1674 : 0 : call_netdevice_notifier(nb, NETDEV_DOWN, dev);
1675 : : }
1676 : 0 : call_netdevice_notifier(nb, NETDEV_UNREGISTER, dev);
1677 : 0 : }
1678 : :
1679 : 60 : static int call_netdevice_register_net_notifiers(struct notifier_block *nb,
1680 : : struct net *net)
1681 : : {
1682 : 60 : struct net_device *dev;
1683 : 60 : int err;
1684 : :
1685 [ + + ]: 126 : for_each_netdev(net, dev) {
1686 : 66 : err = call_netdevice_register_notifiers(nb, dev);
1687 [ - + ]: 66 : if (err)
1688 : 0 : goto rollback;
1689 : : }
1690 : : return 0;
1691 : :
1692 : : rollback:
1693 [ # # ]: 0 : for_each_netdev_continue_reverse(net, dev)
1694 : 0 : call_netdevice_unregister_notifiers(nb, dev);
1695 : : return err;
1696 : : }
1697 : :
1698 : 0 : static void call_netdevice_unregister_net_notifiers(struct notifier_block *nb,
1699 : : struct net *net)
1700 : : {
1701 : 0 : struct net_device *dev;
1702 : :
1703 [ # # # # : 0 : for_each_netdev(net, dev)
# # ]
1704 : 0 : call_netdevice_unregister_notifiers(nb, dev);
1705 : : }
1706 : :
1707 : : static int dev_boot_phase = 1;
1708 : :
1709 : : /**
1710 : : * register_netdevice_notifier - register a network notifier block
1711 : : * @nb: notifier
1712 : : *
1713 : : * Register a notifier to be called when network device events occur.
1714 : : * The notifier passed is linked into the kernel structures and must
1715 : : * not be reused until it has been unregistered. A negative errno code
1716 : : * is returned on a failure.
1717 : : *
1718 : : * When registered all registration and up events are replayed
1719 : : * to the new notifier to allow device to have a race free
1720 : : * view of the network device list.
1721 : : */
1722 : :
1723 : 63 : int register_netdevice_notifier(struct notifier_block *nb)
1724 : : {
1725 : 63 : struct net *net;
1726 : 63 : int err;
1727 : :
1728 : : /* Close race with setup_net() and cleanup_net() */
1729 : 63 : down_write(&pernet_ops_rwsem);
1730 : 63 : rtnl_lock();
1731 : 63 : err = raw_notifier_chain_register(&netdev_chain, nb);
1732 [ - + ]: 63 : if (err)
1733 : 0 : goto unlock;
1734 [ + + ]: 63 : if (dev_boot_phase)
1735 : 3 : goto unlock;
1736 [ + + ]: 120 : for_each_net(net) {
1737 : 60 : err = call_netdevice_register_net_notifiers(nb, net);
1738 [ - + ]: 60 : if (err)
1739 : 0 : goto rollback;
1740 : : }
1741 : :
1742 : 60 : unlock:
1743 : 63 : rtnl_unlock();
1744 : 63 : up_write(&pernet_ops_rwsem);
1745 : 63 : return err;
1746 : :
1747 : : rollback:
1748 [ # # ]: 0 : for_each_net_continue_reverse(net)
1749 : 0 : call_netdevice_unregister_net_notifiers(nb, net);
1750 : :
1751 : 0 : raw_notifier_chain_unregister(&netdev_chain, nb);
1752 : 0 : goto unlock;
1753 : : }
1754 : : EXPORT_SYMBOL(register_netdevice_notifier);
1755 : :
1756 : : /**
1757 : : * unregister_netdevice_notifier - unregister a network notifier block
1758 : : * @nb: notifier
1759 : : *
1760 : : * Unregister a notifier previously registered by
1761 : : * register_netdevice_notifier(). The notifier is unlinked into the
1762 : : * kernel structures and may then be reused. A negative errno code
1763 : : * is returned on a failure.
1764 : : *
1765 : : * After unregistering unregister and down device events are synthesized
1766 : : * for all devices on the device list to the removed notifier to remove
1767 : : * the need for special case cleanup code.
1768 : : */
1769 : :
1770 : 0 : int unregister_netdevice_notifier(struct notifier_block *nb)
1771 : : {
1772 : 0 : struct net *net;
1773 : 0 : int err;
1774 : :
1775 : : /* Close race with setup_net() and cleanup_net() */
1776 : 0 : down_write(&pernet_ops_rwsem);
1777 : 0 : rtnl_lock();
1778 : 0 : err = raw_notifier_chain_unregister(&netdev_chain, nb);
1779 [ # # ]: 0 : if (err)
1780 : 0 : goto unlock;
1781 : :
1782 [ # # ]: 0 : for_each_net(net)
1783 : 0 : call_netdevice_unregister_net_notifiers(nb, net);
1784 : :
1785 : 0 : unlock:
1786 : 0 : rtnl_unlock();
1787 : 0 : up_write(&pernet_ops_rwsem);
1788 : 0 : return err;
1789 : : }
1790 : : EXPORT_SYMBOL(unregister_netdevice_notifier);
1791 : :
1792 : 0 : static int __register_netdevice_notifier_net(struct net *net,
1793 : : struct notifier_block *nb,
1794 : : bool ignore_call_fail)
1795 : : {
1796 : 0 : int err;
1797 : :
1798 : 0 : err = raw_notifier_chain_register(&net->netdev_chain, nb);
1799 [ # # ]: 0 : if (err)
1800 : : return err;
1801 [ # # ]: 0 : if (dev_boot_phase)
1802 : : return 0;
1803 : :
1804 : 0 : err = call_netdevice_register_net_notifiers(nb, net);
1805 [ # # ]: 0 : if (err && !ignore_call_fail)
1806 : 0 : goto chain_unregister;
1807 : :
1808 : : return 0;
1809 : :
1810 : : chain_unregister:
1811 : 0 : raw_notifier_chain_unregister(&net->netdev_chain, nb);
1812 : 0 : return err;
1813 : : }
1814 : :
1815 : 0 : static int __unregister_netdevice_notifier_net(struct net *net,
1816 : : struct notifier_block *nb)
1817 : : {
1818 : 0 : int err;
1819 : :
1820 : 0 : err = raw_notifier_chain_unregister(&net->netdev_chain, nb);
1821 [ # # ]: 0 : if (err)
1822 : : return err;
1823 : :
1824 : 0 : call_netdevice_unregister_net_notifiers(nb, net);
1825 : : return 0;
1826 : : }
1827 : :
1828 : : /**
1829 : : * register_netdevice_notifier_net - register a per-netns network notifier block
1830 : : * @net: network namespace
1831 : : * @nb: notifier
1832 : : *
1833 : : * Register a notifier to be called when network device events occur.
1834 : : * The notifier passed is linked into the kernel structures and must
1835 : : * not be reused until it has been unregistered. A negative errno code
1836 : : * is returned on a failure.
1837 : : *
1838 : : * When registered all registration and up events are replayed
1839 : : * to the new notifier to allow device to have a race free
1840 : : * view of the network device list.
1841 : : */
1842 : :
1843 : 0 : int register_netdevice_notifier_net(struct net *net, struct notifier_block *nb)
1844 : : {
1845 : 0 : int err;
1846 : :
1847 : 0 : rtnl_lock();
1848 : 0 : err = __register_netdevice_notifier_net(net, nb, false);
1849 : 0 : rtnl_unlock();
1850 : 0 : return err;
1851 : : }
1852 : : EXPORT_SYMBOL(register_netdevice_notifier_net);
1853 : :
1854 : : /**
1855 : : * unregister_netdevice_notifier_net - unregister a per-netns
1856 : : * network notifier block
1857 : : * @net: network namespace
1858 : : * @nb: notifier
1859 : : *
1860 : : * Unregister a notifier previously registered by
1861 : : * register_netdevice_notifier(). The notifier is unlinked into the
1862 : : * kernel structures and may then be reused. A negative errno code
1863 : : * is returned on a failure.
1864 : : *
1865 : : * After unregistering unregister and down device events are synthesized
1866 : : * for all devices on the device list to the removed notifier to remove
1867 : : * the need for special case cleanup code.
1868 : : */
1869 : :
1870 : 0 : int unregister_netdevice_notifier_net(struct net *net,
1871 : : struct notifier_block *nb)
1872 : : {
1873 : 0 : int err;
1874 : :
1875 : 0 : rtnl_lock();
1876 : 0 : err = __unregister_netdevice_notifier_net(net, nb);
1877 : 0 : rtnl_unlock();
1878 : 0 : return err;
1879 : : }
1880 : : EXPORT_SYMBOL(unregister_netdevice_notifier_net);
1881 : :
1882 : 0 : int register_netdevice_notifier_dev_net(struct net_device *dev,
1883 : : struct notifier_block *nb,
1884 : : struct netdev_net_notifier *nn)
1885 : : {
1886 : 0 : int err;
1887 : :
1888 : 0 : rtnl_lock();
1889 : 0 : err = __register_netdevice_notifier_net(dev_net(dev), nb, false);
1890 [ # # ]: 0 : if (!err) {
1891 : 0 : nn->nb = nb;
1892 : 0 : list_add(&nn->list, &dev->net_notifier_list);
1893 : : }
1894 : 0 : rtnl_unlock();
1895 : 0 : return err;
1896 : : }
1897 : : EXPORT_SYMBOL(register_netdevice_notifier_dev_net);
1898 : :
1899 : 0 : int unregister_netdevice_notifier_dev_net(struct net_device *dev,
1900 : : struct notifier_block *nb,
1901 : : struct netdev_net_notifier *nn)
1902 : : {
1903 : 0 : int err;
1904 : :
1905 : 0 : rtnl_lock();
1906 : 0 : list_del(&nn->list);
1907 : 0 : err = __unregister_netdevice_notifier_net(dev_net(dev), nb);
1908 : 0 : rtnl_unlock();
1909 : 0 : return err;
1910 : : }
1911 : : EXPORT_SYMBOL(unregister_netdevice_notifier_dev_net);
1912 : :
1913 : 0 : static void move_netdevice_notifiers_dev_net(struct net_device *dev,
1914 : : struct net *net)
1915 : : {
1916 : 0 : struct netdev_net_notifier *nn;
1917 : :
1918 [ # # ]: 0 : list_for_each_entry(nn, &dev->net_notifier_list, list) {
1919 : 0 : __unregister_netdevice_notifier_net(dev_net(dev), nn->nb);
1920 : 0 : __register_netdevice_notifier_net(net, nn->nb, true);
1921 : : }
1922 : 0 : }
1923 : :
1924 : : /**
1925 : : * call_netdevice_notifiers_info - call all network notifier blocks
1926 : : * @val: value passed unmodified to notifier function
1927 : : * @info: notifier information data
1928 : : *
1929 : : * Call all network notifier blocks. Parameters and return value
1930 : : * are as for raw_notifier_call_chain().
1931 : : */
1932 : :
1933 : 33 : static int call_netdevice_notifiers_info(unsigned long val,
1934 : : struct netdev_notifier_info *info)
1935 : : {
1936 : 33 : struct net *net = dev_net(info->dev);
1937 : 33 : int ret;
1938 : :
1939 [ - + - - ]: 33 : ASSERT_RTNL();
1940 : :
1941 : : /* Run per-netns notifier block chain first, then run the global one.
1942 : : * Hopefully, one day, the global one is going to be removed after
1943 : : * all notifier block registrators get converted to be per-netns.
1944 : : */
1945 : 33 : ret = raw_notifier_call_chain(&net->netdev_chain, val, info);
1946 [ + - ]: 33 : if (ret & NOTIFY_STOP_MASK)
1947 : : return ret;
1948 : 33 : return raw_notifier_call_chain(&netdev_chain, val, info);
1949 : : }
1950 : :
1951 : 30 : static int call_netdevice_notifiers_extack(unsigned long val,
1952 : : struct net_device *dev,
1953 : : struct netlink_ext_ack *extack)
1954 : : {
1955 : 30 : struct netdev_notifier_info info = {
1956 : : .dev = dev,
1957 : : .extack = extack,
1958 : : };
1959 : :
1960 : 6 : return call_netdevice_notifiers_info(val, &info);
1961 : : }
1962 : :
1963 : : /**
1964 : : * call_netdevice_notifiers - call all network notifier blocks
1965 : : * @val: value passed unmodified to notifier function
1966 : : * @dev: net_device pointer passed unmodified to notifier function
1967 : : *
1968 : : * Call all network notifier blocks. Parameters and return value
1969 : : * are as for raw_notifier_call_chain().
1970 : : */
1971 : :
1972 : 24 : int call_netdevice_notifiers(unsigned long val, struct net_device *dev)
1973 : : {
1974 : 6 : return call_netdevice_notifiers_extack(val, dev, NULL);
1975 : : }
1976 : : EXPORT_SYMBOL(call_netdevice_notifiers);
1977 : :
1978 : : /**
1979 : : * call_netdevice_notifiers_mtu - call all network notifier blocks
1980 : : * @val: value passed unmodified to notifier function
1981 : : * @dev: net_device pointer passed unmodified to notifier function
1982 : : * @arg: additional u32 argument passed to the notifier function
1983 : : *
1984 : : * Call all network notifier blocks. Parameters and return value
1985 : : * are as for raw_notifier_call_chain().
1986 : : */
1987 : 0 : static int call_netdevice_notifiers_mtu(unsigned long val,
1988 : : struct net_device *dev, u32 arg)
1989 : : {
1990 : 0 : struct netdev_notifier_info_ext info = {
1991 : : .info.dev = dev,
1992 : : .ext.mtu = arg,
1993 : : };
1994 : :
1995 : 0 : BUILD_BUG_ON(offsetof(struct netdev_notifier_info_ext, info) != 0);
1996 : :
1997 : 0 : return call_netdevice_notifiers_info(val, &info.info);
1998 : : }
1999 : :
2000 : : #ifdef CONFIG_NET_INGRESS
2001 : : static DEFINE_STATIC_KEY_FALSE(ingress_needed_key);
2002 : :
2003 : 0 : void net_inc_ingress_queue(void)
2004 : : {
2005 : 0 : static_branch_inc(&ingress_needed_key);
2006 : 0 : }
2007 : : EXPORT_SYMBOL_GPL(net_inc_ingress_queue);
2008 : :
2009 : 0 : void net_dec_ingress_queue(void)
2010 : : {
2011 : 0 : static_branch_dec(&ingress_needed_key);
2012 : 0 : }
2013 : : EXPORT_SYMBOL_GPL(net_dec_ingress_queue);
2014 : : #endif
2015 : :
2016 : : #ifdef CONFIG_NET_EGRESS
2017 : : static DEFINE_STATIC_KEY_FALSE(egress_needed_key);
2018 : :
2019 : : void net_inc_egress_queue(void)
2020 : : {
2021 : : static_branch_inc(&egress_needed_key);
2022 : : }
2023 : : EXPORT_SYMBOL_GPL(net_inc_egress_queue);
2024 : :
2025 : : void net_dec_egress_queue(void)
2026 : : {
2027 : : static_branch_dec(&egress_needed_key);
2028 : : }
2029 : : EXPORT_SYMBOL_GPL(net_dec_egress_queue);
2030 : : #endif
2031 : :
2032 : : static DEFINE_STATIC_KEY_FALSE(netstamp_needed_key);
2033 : : #ifdef CONFIG_JUMP_LABEL
2034 : : static atomic_t netstamp_needed_deferred;
2035 : : static atomic_t netstamp_wanted;
2036 : 0 : static void netstamp_clear(struct work_struct *work)
2037 : : {
2038 : 0 : int deferred = atomic_xchg(&netstamp_needed_deferred, 0);
2039 : 0 : int wanted;
2040 : :
2041 : 0 : wanted = atomic_add_return(deferred, &netstamp_wanted);
2042 [ # # ]: 0 : if (wanted > 0)
2043 : 0 : static_branch_enable(&netstamp_needed_key);
2044 : : else
2045 : 0 : static_branch_disable(&netstamp_needed_key);
2046 : 0 : }
2047 : : static DECLARE_WORK(netstamp_work, netstamp_clear);
2048 : : #endif
2049 : :
2050 : 0 : void net_enable_timestamp(void)
2051 : : {
2052 : : #ifdef CONFIG_JUMP_LABEL
2053 : 0 : int wanted;
2054 : :
2055 : 0 : while (1) {
2056 : 0 : wanted = atomic_read(&netstamp_wanted);
2057 [ # # ]: 0 : if (wanted <= 0)
2058 : : break;
2059 [ # # ]: 0 : if (atomic_cmpxchg(&netstamp_wanted, wanted, wanted + 1) == wanted)
2060 : : return;
2061 : : }
2062 : 0 : atomic_inc(&netstamp_needed_deferred);
2063 : 0 : schedule_work(&netstamp_work);
2064 : : #else
2065 : : static_branch_inc(&netstamp_needed_key);
2066 : : #endif
2067 : : }
2068 : : EXPORT_SYMBOL(net_enable_timestamp);
2069 : :
2070 : 0 : void net_disable_timestamp(void)
2071 : : {
2072 : : #ifdef CONFIG_JUMP_LABEL
2073 : 0 : int wanted;
2074 : :
2075 : 0 : while (1) {
2076 : 0 : wanted = atomic_read(&netstamp_wanted);
2077 [ # # ]: 0 : if (wanted <= 1)
2078 : : break;
2079 [ # # ]: 0 : if (atomic_cmpxchg(&netstamp_wanted, wanted, wanted - 1) == wanted)
2080 : : return;
2081 : : }
2082 : 0 : atomic_dec(&netstamp_needed_deferred);
2083 : 0 : schedule_work(&netstamp_work);
2084 : : #else
2085 : : static_branch_dec(&netstamp_needed_key);
2086 : : #endif
2087 : : }
2088 : : EXPORT_SYMBOL(net_disable_timestamp);
2089 : :
2090 : 0 : static inline void net_timestamp_set(struct sk_buff *skb)
2091 : : {
2092 : 0 : skb->tstamp = 0;
2093 [ # # # # ]: 0 : if (static_branch_unlikely(&netstamp_needed_key))
2094 : 0 : __net_timestamp(skb);
2095 : 0 : }
2096 : :
2097 : : #define net_timestamp_check(COND, SKB) \
2098 : : if (static_branch_unlikely(&netstamp_needed_key)) { \
2099 : : if ((COND) && !(SKB)->tstamp) \
2100 : : __net_timestamp(SKB); \
2101 : : } \
2102 : :
2103 : 0 : bool is_skb_forwardable(const struct net_device *dev, const struct sk_buff *skb)
2104 : : {
2105 : 0 : unsigned int len;
2106 : :
2107 [ # # # # ]: 0 : if (!(dev->flags & IFF_UP))
2108 : : return false;
2109 : :
2110 : 0 : len = dev->mtu + dev->hard_header_len + VLAN_HLEN;
2111 [ # # # # ]: 0 : if (skb->len <= len)
2112 : : return true;
2113 : :
2114 : : /* if TSO is enabled, we don't care about the length as the packet
2115 : : * could be forwarded without being segmented before
2116 : : */
2117 [ # # # # ]: 0 : if (skb_is_gso(skb))
2118 : 0 : return true;
2119 : :
2120 : : return false;
2121 : : }
2122 : : EXPORT_SYMBOL_GPL(is_skb_forwardable);
2123 : :
2124 : 0 : int __dev_forward_skb(struct net_device *dev, struct sk_buff *skb)
2125 : : {
2126 : 0 : int ret = ____dev_forward_skb(dev, skb);
2127 : :
2128 [ # # ]: 0 : if (likely(!ret)) {
2129 : 0 : skb->protocol = eth_type_trans(skb, dev);
2130 : 0 : skb_postpull_rcsum(skb, eth_hdr(skb), ETH_HLEN);
2131 : : }
2132 : :
2133 : 0 : return ret;
2134 : : }
2135 : : EXPORT_SYMBOL_GPL(__dev_forward_skb);
2136 : :
2137 : : /**
2138 : : * dev_forward_skb - loopback an skb to another netif
2139 : : *
2140 : : * @dev: destination network device
2141 : : * @skb: buffer to forward
2142 : : *
2143 : : * return values:
2144 : : * NET_RX_SUCCESS (no congestion)
2145 : : * NET_RX_DROP (packet was dropped, but freed)
2146 : : *
2147 : : * dev_forward_skb can be used for injecting an skb from the
2148 : : * start_xmit function of one device into the receive queue
2149 : : * of another device.
2150 : : *
2151 : : * The receiving device may be in another namespace, so
2152 : : * we have to clear all information in the skb that could
2153 : : * impact namespace isolation.
2154 : : */
2155 : 0 : int dev_forward_skb(struct net_device *dev, struct sk_buff *skb)
2156 : : {
2157 [ # # ]: 0 : return __dev_forward_skb(dev, skb) ?: netif_rx_internal(skb);
2158 : : }
2159 : : EXPORT_SYMBOL_GPL(dev_forward_skb);
2160 : :
2161 : 0 : static inline int deliver_skb(struct sk_buff *skb,
2162 : : struct packet_type *pt_prev,
2163 : : struct net_device *orig_dev)
2164 : : {
2165 [ # # ]: 0 : if (unlikely(skb_orphan_frags_rx(skb, GFP_ATOMIC)))
2166 : : return -ENOMEM;
2167 : 0 : refcount_inc(&skb->users);
2168 : 0 : return pt_prev->func(skb, skb->dev, pt_prev, orig_dev);
2169 : : }
2170 : :
2171 : 0 : static inline void deliver_ptype_list_skb(struct sk_buff *skb,
2172 : : struct packet_type **pt,
2173 : : struct net_device *orig_dev,
2174 : : __be16 type,
2175 : : struct list_head *ptype_list)
2176 : : {
2177 : 0 : struct packet_type *ptype, *pt_prev = *pt;
2178 : :
2179 [ # # ]: 0 : list_for_each_entry_rcu(ptype, ptype_list, list) {
2180 [ # # ]: 0 : if (ptype->type != type)
2181 : 0 : continue;
2182 [ # # ]: 0 : if (pt_prev)
2183 : 0 : deliver_skb(skb, pt_prev, orig_dev);
2184 : : pt_prev = ptype;
2185 : : }
2186 : 0 : *pt = pt_prev;
2187 : 0 : }
2188 : :
2189 : 0 : static inline bool skb_loop_sk(struct packet_type *ptype, struct sk_buff *skb)
2190 : : {
2191 [ # # ]: 0 : if (!ptype->af_packet_priv || !skb->sk)
2192 : : return false;
2193 : :
2194 [ # # ]: 0 : if (ptype->id_match)
2195 : 0 : return ptype->id_match(ptype, skb->sk);
2196 [ # # ]: 0 : else if ((struct sock *)ptype->af_packet_priv == skb->sk)
2197 : : return true;
2198 : :
2199 : : return false;
2200 : : }
2201 : :
2202 : : /**
2203 : : * dev_nit_active - return true if any network interface taps are in use
2204 : : *
2205 : : * @dev: network device to check for the presence of taps
2206 : : */
2207 : 3 : bool dev_nit_active(struct net_device *dev)
2208 : : {
2209 [ - + - - : 3 : return !list_empty(&ptype_all) || !list_empty(&dev->ptype_all);
- - ]
2210 : : }
2211 : : EXPORT_SYMBOL_GPL(dev_nit_active);
2212 : :
2213 : : /*
2214 : : * Support routine. Sends outgoing frames to any network
2215 : : * taps currently in use.
2216 : : */
2217 : :
2218 : 0 : void dev_queue_xmit_nit(struct sk_buff *skb, struct net_device *dev)
2219 : : {
2220 : 0 : struct packet_type *ptype;
2221 : 0 : struct sk_buff *skb2 = NULL;
2222 : 0 : struct packet_type *pt_prev = NULL;
2223 : 0 : struct list_head *ptype_list = &ptype_all;
2224 : :
2225 : 0 : rcu_read_lock();
2226 : 0 : again:
2227 [ # # ]: 0 : list_for_each_entry_rcu(ptype, ptype_list, list) {
2228 [ # # ]: 0 : if (ptype->ignore_outgoing)
2229 : 0 : continue;
2230 : :
2231 : : /* Never send packets back to the socket
2232 : : * they originated from - MvS (miquels@drinkel.ow.org)
2233 : : */
2234 [ # # # # ]: 0 : if (skb_loop_sk(ptype, skb))
2235 : 0 : continue;
2236 : :
2237 [ # # ]: 0 : if (pt_prev) {
2238 : 0 : deliver_skb(skb2, pt_prev, skb->dev);
2239 : 0 : pt_prev = ptype;
2240 : 0 : continue;
2241 : : }
2242 : :
2243 : : /* need to clone skb, done only once */
2244 : 0 : skb2 = skb_clone(skb, GFP_ATOMIC);
2245 [ # # ]: 0 : if (!skb2)
2246 : 0 : goto out_unlock;
2247 : :
2248 : 0 : net_timestamp_set(skb2);
2249 : :
2250 : : /* skb->nh should be correctly
2251 : : * set by sender, so that the second statement is
2252 : : * just protection against buggy protocols.
2253 : : */
2254 [ # # ]: 0 : skb_reset_mac_header(skb2);
2255 : :
2256 [ # # # # ]: 0 : if (skb_network_header(skb2) < skb2->data ||
2257 [ # # ]: 0 : skb_network_header(skb2) > skb_tail_pointer(skb2)) {
2258 [ # # ]: 0 : net_crit_ratelimited("protocol %04x is buggy, dev %s\n",
2259 : : ntohs(skb2->protocol),
2260 : : dev->name);
2261 : 0 : skb_reset_network_header(skb2);
2262 : : }
2263 : :
2264 : 0 : skb2->transport_header = skb2->network_header;
2265 : 0 : skb2->pkt_type = PACKET_OUTGOING;
2266 : 0 : pt_prev = ptype;
2267 : : }
2268 : :
2269 [ # # ]: 0 : if (ptype_list == &ptype_all) {
2270 : 0 : ptype_list = &dev->ptype_all;
2271 : 0 : goto again;
2272 : : }
2273 : 0 : out_unlock:
2274 [ # # ]: 0 : if (pt_prev) {
2275 [ # # ]: 0 : if (!skb_orphan_frags_rx(skb2, GFP_ATOMIC))
2276 : 0 : pt_prev->func(skb2, skb->dev, pt_prev, skb->dev);
2277 : : else
2278 : 0 : kfree_skb(skb2);
2279 : : }
2280 : 0 : rcu_read_unlock();
2281 : 0 : }
2282 : : EXPORT_SYMBOL_GPL(dev_queue_xmit_nit);
2283 : :
2284 : : /**
2285 : : * netif_setup_tc - Handle tc mappings on real_num_tx_queues change
2286 : : * @dev: Network device
2287 : : * @txq: number of queues available
2288 : : *
2289 : : * If real_num_tx_queues is changed the tc mappings may no longer be
2290 : : * valid. To resolve this verify the tc mapping remains valid and if
2291 : : * not NULL the mapping. With no priorities mapping to this
2292 : : * offset/count pair it will no longer be used. In the worst case TC0
2293 : : * is invalid nothing can be done so disable priority mappings. If is
2294 : : * expected that drivers will fix this mapping if they can before
2295 : : * calling netif_set_real_num_tx_queues.
2296 : : */
2297 : 0 : static void netif_setup_tc(struct net_device *dev, unsigned int txq)
2298 : : {
2299 : 0 : int i;
2300 : 0 : struct netdev_tc_txq *tc = &dev->tc_to_txq[0];
2301 : :
2302 : : /* If TC0 is invalidated disable TC mapping */
2303 [ # # ]: 0 : if (tc->offset + tc->count > txq) {
2304 : 0 : pr_warn("Number of in use tx queues changed invalidating tc mappings. Priority traffic classification disabled!\n");
2305 : 0 : dev->num_tc = 0;
2306 : 0 : return;
2307 : : }
2308 : :
2309 : : /* Invalidated prio to tc mappings set to TC0 */
2310 [ # # ]: 0 : for (i = 1; i < TC_BITMASK + 1; i++) {
2311 [ # # ]: 0 : int q = netdev_get_prio_tc_map(dev, i);
2312 : :
2313 : 0 : tc = &dev->tc_to_txq[q];
2314 [ # # ]: 0 : if (tc->offset + tc->count > txq) {
2315 : 0 : pr_warn("Number of in use tx queues changed. Priority %i to tc mapping %i is no longer valid. Setting map to 0\n",
2316 : : i, q);
2317 [ # # ]: 0 : netdev_set_prio_tc_map(dev, i, 0);
2318 : : }
2319 : : }
2320 : : }
2321 : :
2322 : 0 : int netdev_txq_to_tc(struct net_device *dev, unsigned int txq)
2323 : : {
2324 [ # # ]: 0 : if (dev->num_tc) {
2325 : 0 : struct netdev_tc_txq *tc = &dev->tc_to_txq[0];
2326 : 0 : int i;
2327 : :
2328 : : /* walk through the TCs and see if it falls into any of them */
2329 [ # # # # ]: 0 : for (i = 0; i < TC_MAX_QUEUE; i++, tc++) {
2330 [ # # # # ]: 0 : if ((txq - tc->offset) < tc->count)
2331 : 0 : return i;
2332 : : }
2333 : :
2334 : : /* didn't find it, just return -1 to indicate no match */
2335 : : return -1;
2336 : : }
2337 : :
2338 : : return 0;
2339 : : }
2340 : : EXPORT_SYMBOL(netdev_txq_to_tc);
2341 : :
2342 : : #ifdef CONFIG_XPS
2343 : : struct static_key xps_needed __read_mostly;
2344 : : EXPORT_SYMBOL(xps_needed);
2345 : : struct static_key xps_rxqs_needed __read_mostly;
2346 : : EXPORT_SYMBOL(xps_rxqs_needed);
2347 : : static DEFINE_MUTEX(xps_map_mutex);
2348 : : #define xmap_dereference(P) \
2349 : : rcu_dereference_protected((P), lockdep_is_held(&xps_map_mutex))
2350 : :
2351 : 0 : static bool remove_xps_queue(struct xps_dev_maps *dev_maps,
2352 : : int tci, u16 index)
2353 : : {
2354 : 0 : struct xps_map *map = NULL;
2355 : 0 : int pos;
2356 : :
2357 [ # # ]: 0 : if (dev_maps)
2358 : 0 : map = xmap_dereference(dev_maps->attr_map[tci]);
2359 [ # # ]: 0 : if (!map)
2360 : : return false;
2361 : :
2362 [ # # ]: 0 : for (pos = map->len; pos--;) {
2363 [ # # ]: 0 : if (map->queues[pos] != index)
2364 : 0 : continue;
2365 : :
2366 [ # # ]: 0 : if (map->len > 1) {
2367 : 0 : map->queues[pos] = map->queues[--map->len];
2368 : 0 : break;
2369 : : }
2370 : :
2371 : 0 : RCU_INIT_POINTER(dev_maps->attr_map[tci], NULL);
2372 : 0 : kfree_rcu(map, rcu);
2373 : 0 : return false;
2374 : : }
2375 : :
2376 : : return true;
2377 : : }
2378 : :
2379 : 0 : static bool remove_xps_queue_cpu(struct net_device *dev,
2380 : : struct xps_dev_maps *dev_maps,
2381 : : int cpu, u16 offset, u16 count)
2382 : : {
2383 [ # # ]: 0 : int num_tc = dev->num_tc ? : 1;
2384 : 0 : bool active = false;
2385 : 0 : int tci;
2386 : :
2387 [ # # ]: 0 : for (tci = cpu * num_tc; num_tc--; tci++) {
2388 : 0 : int i, j;
2389 : :
2390 [ # # ]: 0 : for (i = count, j = offset; i--; j++) {
2391 [ # # ]: 0 : if (!remove_xps_queue(dev_maps, tci, j))
2392 : : break;
2393 : : }
2394 : :
2395 : 0 : active |= i < 0;
2396 : : }
2397 : :
2398 : 0 : return active;
2399 : : }
2400 : :
2401 : 0 : static void reset_xps_maps(struct net_device *dev,
2402 : : struct xps_dev_maps *dev_maps,
2403 : : bool is_rxqs_map)
2404 : : {
2405 [ # # ]: 0 : if (is_rxqs_map) {
2406 : 0 : static_key_slow_dec_cpuslocked(&xps_rxqs_needed);
2407 : 0 : RCU_INIT_POINTER(dev->xps_rxqs_map, NULL);
2408 : : } else {
2409 : 0 : RCU_INIT_POINTER(dev->xps_cpus_map, NULL);
2410 : : }
2411 : 0 : static_key_slow_dec_cpuslocked(&xps_needed);
2412 [ # # ]: 0 : kfree_rcu(dev_maps, rcu);
2413 : 0 : }
2414 : :
2415 : 0 : static void clean_xps_maps(struct net_device *dev, const unsigned long *mask,
2416 : : struct xps_dev_maps *dev_maps, unsigned int nr_ids,
2417 : : u16 offset, u16 count, bool is_rxqs_map)
2418 : : {
2419 : 0 : bool active = false;
2420 : 0 : int i, j;
2421 : :
2422 [ # # # # ]: 0 : for (j = -1; j = netif_attrmask_next(j, mask, nr_ids),
2423 : : j < nr_ids;)
2424 : 0 : active |= remove_xps_queue_cpu(dev, dev_maps, j, offset,
2425 : : count);
2426 [ # # ]: 0 : if (!active)
2427 : 0 : reset_xps_maps(dev, dev_maps, is_rxqs_map);
2428 : :
2429 [ # # ]: 0 : if (!is_rxqs_map) {
2430 [ # # ]: 0 : for (i = offset + (count - 1); count--; i--) {
2431 : 0 : netdev_queue_numa_node_write(
2432 : : netdev_get_tx_queue(dev, i),
2433 : : NUMA_NO_NODE);
2434 : : }
2435 : : }
2436 : 0 : }
2437 : :
2438 : 0 : static void netif_reset_xps_queues(struct net_device *dev, u16 offset,
2439 : : u16 count)
2440 : : {
2441 : 0 : const unsigned long *possible_mask = NULL;
2442 : 0 : struct xps_dev_maps *dev_maps;
2443 : 0 : unsigned int nr_ids;
2444 : :
2445 [ # # ]: 0 : if (!static_key_false(&xps_needed))
2446 : 0 : return;
2447 : :
2448 : 0 : cpus_read_lock();
2449 : 0 : mutex_lock(&xps_map_mutex);
2450 : :
2451 [ - - ]: 0 : if (static_key_false(&xps_rxqs_needed)) {
2452 : 0 : dev_maps = xmap_dereference(dev->xps_rxqs_map);
2453 [ - - ]: 0 : if (dev_maps) {
2454 : 0 : nr_ids = dev->num_rx_queues;
2455 : 0 : clean_xps_maps(dev, possible_mask, dev_maps, nr_ids,
2456 : : offset, count, true);
2457 : : }
2458 : : }
2459 : :
2460 : 0 : dev_maps = xmap_dereference(dev->xps_cpus_map);
2461 [ - - ]: 0 : if (!dev_maps)
2462 : 0 : goto out_no_maps;
2463 : :
2464 [ - - ]: 0 : if (num_possible_cpus() > 1)
2465 : 0 : possible_mask = cpumask_bits(cpu_possible_mask);
2466 : 0 : nr_ids = nr_cpu_ids;
2467 : 0 : clean_xps_maps(dev, possible_mask, dev_maps, nr_ids, offset, count,
2468 : : false);
2469 : :
2470 : 0 : out_no_maps:
2471 : 0 : mutex_unlock(&xps_map_mutex);
2472 : 0 : cpus_read_unlock();
2473 : : }
2474 : :
2475 : 0 : static void netif_reset_xps_queues_gt(struct net_device *dev, u16 index)
2476 : : {
2477 : 0 : netif_reset_xps_queues(dev, index, dev->num_tx_queues - index);
2478 : 0 : }
2479 : :
2480 : 0 : static struct xps_map *expand_xps_map(struct xps_map *map, int attr_index,
2481 : : u16 index, bool is_rxqs_map)
2482 : : {
2483 : 0 : struct xps_map *new_map;
2484 : 0 : int alloc_len = XPS_MIN_MAP_ALLOC;
2485 : 0 : int i, pos;
2486 : :
2487 [ # # # # ]: 0 : for (pos = 0; map && pos < map->len; pos++) {
2488 [ # # ]: 0 : if (map->queues[pos] != index)
2489 : 0 : continue;
2490 : : return map;
2491 : : }
2492 : :
2493 : : /* Need to add tx-queue to this CPU's/rx-queue's existing map */
2494 [ # # ]: 0 : if (map) {
2495 [ # # ]: 0 : if (pos < map->alloc_len)
2496 : : return map;
2497 : :
2498 : 0 : alloc_len = map->alloc_len * 2;
2499 : : }
2500 : :
2501 : : /* Need to allocate new map to store tx-queue on this CPU's/rx-queue's
2502 : : * map
2503 : : */
2504 [ # # ]: 0 : if (is_rxqs_map)
2505 : 0 : new_map = kzalloc(XPS_MAP_SIZE(alloc_len), GFP_KERNEL);
2506 : : else
2507 : 0 : new_map = kzalloc_node(XPS_MAP_SIZE(alloc_len), GFP_KERNEL,
2508 : : cpu_to_node(attr_index));
2509 [ # # ]: 0 : if (!new_map)
2510 : : return NULL;
2511 : :
2512 [ # # ]: 0 : for (i = 0; i < pos; i++)
2513 : 0 : new_map->queues[i] = map->queues[i];
2514 : 0 : new_map->alloc_len = alloc_len;
2515 : 0 : new_map->len = pos;
2516 : :
2517 : 0 : return new_map;
2518 : : }
2519 : :
2520 : : /* Must be called under cpus_read_lock */
2521 : 0 : int __netif_set_xps_queue(struct net_device *dev, const unsigned long *mask,
2522 : : u16 index, bool is_rxqs_map)
2523 : : {
2524 : 0 : const unsigned long *online_mask = NULL, *possible_mask = NULL;
2525 : 0 : struct xps_dev_maps *dev_maps, *new_dev_maps = NULL;
2526 : 0 : int i, j, tci, numa_node_id = -2;
2527 : 0 : int maps_sz, num_tc = 1, tc = 0;
2528 : 0 : struct xps_map *map, *new_map;
2529 : 0 : bool active = false;
2530 : 0 : unsigned int nr_ids;
2531 : :
2532 [ # # ]: 0 : if (dev->num_tc) {
2533 : : /* Do not allow XPS on subordinate device directly */
2534 : 0 : num_tc = dev->num_tc;
2535 [ # # ]: 0 : if (num_tc < 0)
2536 : : return -EINVAL;
2537 : :
2538 : : /* If queue belongs to subordinate dev use its map */
2539 [ # # ]: 0 : dev = netdev_get_tx_queue(dev, index)->sb_dev ? : dev;
2540 : :
2541 [ # # ]: 0 : tc = netdev_txq_to_tc(dev, index);
2542 [ # # ]: 0 : if (tc < 0)
2543 : : return -EINVAL;
2544 : : }
2545 : :
2546 : 0 : mutex_lock(&xps_map_mutex);
2547 [ # # ]: 0 : if (is_rxqs_map) {
2548 : 0 : maps_sz = XPS_RXQ_DEV_MAPS_SIZE(num_tc, dev->num_rx_queues);
2549 : 0 : dev_maps = xmap_dereference(dev->xps_rxqs_map);
2550 : 0 : nr_ids = dev->num_rx_queues;
2551 : : } else {
2552 : 0 : maps_sz = XPS_CPU_DEV_MAPS_SIZE(num_tc);
2553 [ # # ]: 0 : if (num_possible_cpus() > 1) {
2554 : 0 : online_mask = cpumask_bits(cpu_online_mask);
2555 : 0 : possible_mask = cpumask_bits(cpu_possible_mask);
2556 : : }
2557 : 0 : dev_maps = xmap_dereference(dev->xps_cpus_map);
2558 : 0 : nr_ids = nr_cpu_ids;
2559 : : }
2560 : :
2561 : 0 : if (maps_sz < L1_CACHE_BYTES)
2562 : : maps_sz = L1_CACHE_BYTES;
2563 : :
2564 : : /* allocate memory for queue storage */
2565 [ # # ]: 0 : for (j = -1; j = netif_attrmask_next_and(j, online_mask, mask, nr_ids),
2566 : : j < nr_ids;) {
2567 [ # # ]: 0 : if (!new_dev_maps)
2568 : 0 : new_dev_maps = kzalloc(maps_sz, GFP_KERNEL);
2569 [ # # ]: 0 : if (!new_dev_maps) {
2570 : 0 : mutex_unlock(&xps_map_mutex);
2571 : 0 : return -ENOMEM;
2572 : : }
2573 : :
2574 : 0 : tci = j * num_tc + tc;
2575 [ # # ]: 0 : map = dev_maps ? xmap_dereference(dev_maps->attr_map[tci]) :
2576 : : NULL;
2577 : :
2578 : 0 : map = expand_xps_map(map, j, index, is_rxqs_map);
2579 [ # # ]: 0 : if (!map)
2580 : 0 : goto error;
2581 : :
2582 : 0 : RCU_INIT_POINTER(new_dev_maps->attr_map[tci], map);
2583 : : }
2584 : :
2585 [ # # ]: 0 : if (!new_dev_maps)
2586 : 0 : goto out_no_new_maps;
2587 : :
2588 [ # # ]: 0 : if (!dev_maps) {
2589 : : /* Increment static keys at most once per type */
2590 : 0 : static_key_slow_inc_cpuslocked(&xps_needed);
2591 [ # # ]: 0 : if (is_rxqs_map)
2592 : 0 : static_key_slow_inc_cpuslocked(&xps_rxqs_needed);
2593 : : }
2594 : :
2595 [ # # # # ]: 0 : for (j = -1; j = netif_attrmask_next(j, possible_mask, nr_ids),
2596 : : j < nr_ids;) {
2597 : : /* copy maps belonging to foreign traffic classes */
2598 [ # # # # ]: 0 : for (i = tc, tci = j * num_tc; dev_maps && i--; tci++) {
2599 : : /* fill in the new device map from the old device map */
2600 : 0 : map = xmap_dereference(dev_maps->attr_map[tci]);
2601 : 0 : RCU_INIT_POINTER(new_dev_maps->attr_map[tci], map);
2602 : : }
2603 : :
2604 : : /* We need to explicitly update tci as prevous loop
2605 : : * could break out early if dev_maps is NULL.
2606 : : */
2607 : 0 : tci = j * num_tc + tc;
2608 : :
2609 [ # # # # ]: 0 : if (netif_attr_test_mask(j, mask, nr_ids) &&
2610 : : netif_attr_test_online(j, online_mask, nr_ids)) {
2611 : : /* add tx-queue to CPU/rx-queue maps */
2612 : 0 : int pos = 0;
2613 : :
2614 : 0 : map = xmap_dereference(new_dev_maps->attr_map[tci]);
2615 [ # # # # ]: 0 : while ((pos < map->len) && (map->queues[pos] != index))
2616 : 0 : pos++;
2617 : :
2618 [ # # ]: 0 : if (pos == map->len)
2619 : 0 : map->queues[map->len++] = index;
2620 : : #ifdef CONFIG_NUMA
2621 [ # # ]: 0 : if (!is_rxqs_map) {
2622 [ # # ]: 0 : if (numa_node_id == -2)
2623 : 0 : numa_node_id = cpu_to_node(j);
2624 [ # # ]: 0 : else if (numa_node_id != cpu_to_node(j))
2625 : 0 : numa_node_id = -1;
2626 : : }
2627 : : #endif
2628 [ # # ]: 0 : } else if (dev_maps) {
2629 : : /* fill in the new device map from the old device map */
2630 : 0 : map = xmap_dereference(dev_maps->attr_map[tci]);
2631 : 0 : RCU_INIT_POINTER(new_dev_maps->attr_map[tci], map);
2632 : : }
2633 : :
2634 : : /* copy maps belonging to foreign traffic classes */
2635 [ # # # # ]: 0 : for (i = num_tc - tc, tci++; dev_maps && --i; tci++) {
2636 : : /* fill in the new device map from the old device map */
2637 : 0 : map = xmap_dereference(dev_maps->attr_map[tci]);
2638 : 0 : RCU_INIT_POINTER(new_dev_maps->attr_map[tci], map);
2639 : : }
2640 : : }
2641 : :
2642 [ # # ]: 0 : if (is_rxqs_map)
2643 : 0 : rcu_assign_pointer(dev->xps_rxqs_map, new_dev_maps);
2644 : : else
2645 : 0 : rcu_assign_pointer(dev->xps_cpus_map, new_dev_maps);
2646 : :
2647 : : /* Cleanup old maps */
2648 [ # # ]: 0 : if (!dev_maps)
2649 : 0 : goto out_no_old_maps;
2650 : :
2651 [ # # # # ]: 0 : for (j = -1; j = netif_attrmask_next(j, possible_mask, nr_ids),
2652 : : j < nr_ids;) {
2653 [ # # ]: 0 : for (i = num_tc, tci = j * num_tc; i--; tci++) {
2654 : 0 : new_map = xmap_dereference(new_dev_maps->attr_map[tci]);
2655 : 0 : map = xmap_dereference(dev_maps->attr_map[tci]);
2656 [ # # ]: 0 : if (map && map != new_map)
2657 : 0 : kfree_rcu(map, rcu);
2658 : : }
2659 : : }
2660 : :
2661 : 0 : kfree_rcu(dev_maps, rcu);
2662 : :
2663 : : out_no_old_maps:
2664 : : dev_maps = new_dev_maps;
2665 : : active = true;
2666 : :
2667 : 0 : out_no_new_maps:
2668 [ # # ]: 0 : if (!is_rxqs_map) {
2669 : : /* update Tx queue numa node */
2670 : 0 : netdev_queue_numa_node_write(netdev_get_tx_queue(dev, index),
2671 : : (numa_node_id >= 0) ?
2672 : : numa_node_id : NUMA_NO_NODE);
2673 : : }
2674 : :
2675 [ # # ]: 0 : if (!dev_maps)
2676 : 0 : goto out_no_maps;
2677 : :
2678 : : /* removes tx-queue from unused CPUs/rx-queues */
2679 [ # # # # ]: 0 : for (j = -1; j = netif_attrmask_next(j, possible_mask, nr_ids),
2680 : : j < nr_ids;) {
2681 [ # # ]: 0 : for (i = tc, tci = j * num_tc; i--; tci++)
2682 : 0 : active |= remove_xps_queue(dev_maps, tci, index);
2683 [ # # # # ]: 0 : if (!netif_attr_test_mask(j, mask, nr_ids) ||
2684 : : !netif_attr_test_online(j, online_mask, nr_ids))
2685 : 0 : active |= remove_xps_queue(dev_maps, tci, index);
2686 [ # # ]: 0 : for (i = num_tc - tc, tci++; --i; tci++)
2687 : 0 : active |= remove_xps_queue(dev_maps, tci, index);
2688 : : }
2689 : :
2690 : : /* free map if not active */
2691 [ # # ]: 0 : if (!active)
2692 : 0 : reset_xps_maps(dev, dev_maps, is_rxqs_map);
2693 : :
2694 : 0 : out_no_maps:
2695 : 0 : mutex_unlock(&xps_map_mutex);
2696 : :
2697 : 0 : return 0;
2698 : : error:
2699 : : /* remove any maps that we added */
2700 [ # # # # ]: 0 : for (j = -1; j = netif_attrmask_next(j, possible_mask, nr_ids),
2701 : : j < nr_ids;) {
2702 [ # # ]: 0 : for (i = num_tc, tci = j * num_tc; i--; tci++) {
2703 : 0 : new_map = xmap_dereference(new_dev_maps->attr_map[tci]);
2704 : 0 : map = dev_maps ?
2705 [ # # ]: 0 : xmap_dereference(dev_maps->attr_map[tci]) :
2706 : : NULL;
2707 [ # # ]: 0 : if (new_map && new_map != map)
2708 : 0 : kfree(new_map);
2709 : : }
2710 : : }
2711 : :
2712 : 0 : mutex_unlock(&xps_map_mutex);
2713 : :
2714 : 0 : kfree(new_dev_maps);
2715 : 0 : return -ENOMEM;
2716 : : }
2717 : : EXPORT_SYMBOL_GPL(__netif_set_xps_queue);
2718 : :
2719 : 0 : int netif_set_xps_queue(struct net_device *dev, const struct cpumask *mask,
2720 : : u16 index)
2721 : : {
2722 : 0 : int ret;
2723 : :
2724 : 0 : cpus_read_lock();
2725 : 0 : ret = __netif_set_xps_queue(dev, cpumask_bits(mask), index, false);
2726 : 0 : cpus_read_unlock();
2727 : :
2728 : 0 : return ret;
2729 : : }
2730 : : EXPORT_SYMBOL(netif_set_xps_queue);
2731 : :
2732 : : #endif
2733 : 0 : static void netdev_unbind_all_sb_channels(struct net_device *dev)
2734 : : {
2735 : 0 : struct netdev_queue *txq = &dev->_tx[dev->num_tx_queues];
2736 : :
2737 : : /* Unbind any subordinate channels */
2738 [ # # ]: 0 : while (txq-- != &dev->_tx[0]) {
2739 [ # # ]: 0 : if (txq->sb_dev)
2740 : 0 : netdev_unbind_sb_channel(dev, txq->sb_dev);
2741 : : }
2742 : 0 : }
2743 : :
2744 : 0 : void netdev_reset_tc(struct net_device *dev)
2745 : : {
2746 : : #ifdef CONFIG_XPS
2747 : 0 : netif_reset_xps_queues_gt(dev, 0);
2748 : : #endif
2749 : 0 : netdev_unbind_all_sb_channels(dev);
2750 : :
2751 : : /* Reset TC configuration of device */
2752 : 0 : dev->num_tc = 0;
2753 : 0 : memset(dev->tc_to_txq, 0, sizeof(dev->tc_to_txq));
2754 : 0 : memset(dev->prio_tc_map, 0, sizeof(dev->prio_tc_map));
2755 : 0 : }
2756 : : EXPORT_SYMBOL(netdev_reset_tc);
2757 : :
2758 : 0 : int netdev_set_tc_queue(struct net_device *dev, u8 tc, u16 count, u16 offset)
2759 : : {
2760 [ # # ]: 0 : if (tc >= dev->num_tc)
2761 : : return -EINVAL;
2762 : :
2763 : : #ifdef CONFIG_XPS
2764 : 0 : netif_reset_xps_queues(dev, offset, count);
2765 : : #endif
2766 : 0 : dev->tc_to_txq[tc].count = count;
2767 : 0 : dev->tc_to_txq[tc].offset = offset;
2768 : 0 : return 0;
2769 : : }
2770 : : EXPORT_SYMBOL(netdev_set_tc_queue);
2771 : :
2772 : 0 : int netdev_set_num_tc(struct net_device *dev, u8 num_tc)
2773 : : {
2774 [ # # ]: 0 : if (num_tc > TC_MAX_QUEUE)
2775 : : return -EINVAL;
2776 : :
2777 : : #ifdef CONFIG_XPS
2778 : 0 : netif_reset_xps_queues_gt(dev, 0);
2779 : : #endif
2780 : 0 : netdev_unbind_all_sb_channels(dev);
2781 : :
2782 : 0 : dev->num_tc = num_tc;
2783 : 0 : return 0;
2784 : : }
2785 : : EXPORT_SYMBOL(netdev_set_num_tc);
2786 : :
2787 : 0 : void netdev_unbind_sb_channel(struct net_device *dev,
2788 : : struct net_device *sb_dev)
2789 : : {
2790 : 0 : struct netdev_queue *txq = &dev->_tx[dev->num_tx_queues];
2791 : :
2792 : : #ifdef CONFIG_XPS
2793 : 0 : netif_reset_xps_queues_gt(sb_dev, 0);
2794 : : #endif
2795 : 0 : memset(sb_dev->tc_to_txq, 0, sizeof(sb_dev->tc_to_txq));
2796 : 0 : memset(sb_dev->prio_tc_map, 0, sizeof(sb_dev->prio_tc_map));
2797 : :
2798 [ # # ]: 0 : while (txq-- != &dev->_tx[0]) {
2799 [ # # ]: 0 : if (txq->sb_dev == sb_dev)
2800 : 0 : txq->sb_dev = NULL;
2801 : : }
2802 : 0 : }
2803 : : EXPORT_SYMBOL(netdev_unbind_sb_channel);
2804 : :
2805 : 0 : int netdev_bind_sb_channel_queue(struct net_device *dev,
2806 : : struct net_device *sb_dev,
2807 : : u8 tc, u16 count, u16 offset)
2808 : : {
2809 : : /* Make certain the sb_dev and dev are already configured */
2810 [ # # # # ]: 0 : if (sb_dev->num_tc >= 0 || tc >= dev->num_tc)
2811 : : return -EINVAL;
2812 : :
2813 : : /* We cannot hand out queues we don't have */
2814 [ # # ]: 0 : if ((offset + count) > dev->real_num_tx_queues)
2815 : : return -EINVAL;
2816 : :
2817 : : /* Record the mapping */
2818 : 0 : sb_dev->tc_to_txq[tc].count = count;
2819 : 0 : sb_dev->tc_to_txq[tc].offset = offset;
2820 : :
2821 : : /* Provide a way for Tx queue to find the tc_to_txq map or
2822 : : * XPS map for itself.
2823 : : */
2824 [ # # ]: 0 : while (count--)
2825 : 0 : netdev_get_tx_queue(dev, count + offset)->sb_dev = sb_dev;
2826 : :
2827 : : return 0;
2828 : : }
2829 : : EXPORT_SYMBOL(netdev_bind_sb_channel_queue);
2830 : :
2831 : 0 : int netdev_set_sb_channel(struct net_device *dev, u16 channel)
2832 : : {
2833 : : /* Do not use a multiqueue device to represent a subordinate channel */
2834 [ # # ]: 0 : if (netif_is_multiqueue(dev))
2835 : : return -ENODEV;
2836 : :
2837 : : /* We allow channels 1 - 32767 to be used for subordinate channels.
2838 : : * Channel 0 is meant to be "native" mode and used only to represent
2839 : : * the main root device. We allow writing 0 to reset the device back
2840 : : * to normal mode after being used as a subordinate channel.
2841 : : */
2842 [ # # ]: 0 : if (channel > S16_MAX)
2843 : : return -EINVAL;
2844 : :
2845 : 0 : dev->num_tc = -channel;
2846 : :
2847 : 0 : return 0;
2848 : : }
2849 : : EXPORT_SYMBOL(netdev_set_sb_channel);
2850 : :
2851 : : /*
2852 : : * Routine to help set real_num_tx_queues. To avoid skbs mapped to queues
2853 : : * greater than real_num_tx_queues stale skbs on the qdisc must be flushed.
2854 : : */
2855 : 0 : int netif_set_real_num_tx_queues(struct net_device *dev, unsigned int txq)
2856 : : {
2857 : 0 : bool disabling;
2858 : 0 : int rc;
2859 : :
2860 : 0 : disabling = txq < dev->real_num_tx_queues;
2861 : :
2862 [ # # # # ]: 0 : if (txq < 1 || txq > dev->num_tx_queues)
2863 : : return -EINVAL;
2864 : :
2865 [ # # ]: 0 : if (dev->reg_state == NETREG_REGISTERED ||
2866 : : dev->reg_state == NETREG_UNREGISTERING) {
2867 [ # # # # ]: 0 : ASSERT_RTNL();
2868 : :
2869 : 0 : rc = netdev_queue_update_kobjects(dev, dev->real_num_tx_queues,
2870 : : txq);
2871 [ # # ]: 0 : if (rc)
2872 : : return rc;
2873 : :
2874 [ # # ]: 0 : if (dev->num_tc)
2875 : 0 : netif_setup_tc(dev, txq);
2876 : :
2877 : 0 : dev->real_num_tx_queues = txq;
2878 : :
2879 [ # # ]: 0 : if (disabling) {
2880 : 0 : synchronize_net();
2881 : 0 : qdisc_reset_all_tx_gt(dev, txq);
2882 : : #ifdef CONFIG_XPS
2883 : 0 : netif_reset_xps_queues_gt(dev, txq);
2884 : : #endif
2885 : : }
2886 : : } else {
2887 : 0 : dev->real_num_tx_queues = txq;
2888 : : }
2889 : :
2890 : : return 0;
2891 : : }
2892 : : EXPORT_SYMBOL(netif_set_real_num_tx_queues);
2893 : :
2894 : : #ifdef CONFIG_SYSFS
2895 : : /**
2896 : : * netif_set_real_num_rx_queues - set actual number of RX queues used
2897 : : * @dev: Network device
2898 : : * @rxq: Actual number of RX queues
2899 : : *
2900 : : * This must be called either with the rtnl_lock held or before
2901 : : * registration of the net device. Returns 0 on success, or a
2902 : : * negative error code. If called before registration, it always
2903 : : * succeeds.
2904 : : */
2905 : 0 : int netif_set_real_num_rx_queues(struct net_device *dev, unsigned int rxq)
2906 : : {
2907 : 0 : int rc;
2908 : :
2909 [ # # # # ]: 0 : if (rxq < 1 || rxq > dev->num_rx_queues)
2910 : : return -EINVAL;
2911 : :
2912 [ # # ]: 0 : if (dev->reg_state == NETREG_REGISTERED) {
2913 [ # # # # ]: 0 : ASSERT_RTNL();
2914 : :
2915 : 0 : rc = net_rx_queue_update_kobjects(dev, dev->real_num_rx_queues,
2916 : : rxq);
2917 [ # # ]: 0 : if (rc)
2918 : : return rc;
2919 : : }
2920 : :
2921 : 0 : dev->real_num_rx_queues = rxq;
2922 : 0 : return 0;
2923 : : }
2924 : : EXPORT_SYMBOL(netif_set_real_num_rx_queues);
2925 : : #endif
2926 : :
2927 : : /**
2928 : : * netif_get_num_default_rss_queues - default number of RSS queues
2929 : : *
2930 : : * This routine should set an upper limit on the number of RSS queues
2931 : : * used by default by multiqueue devices.
2932 : : */
2933 : 0 : int netif_get_num_default_rss_queues(void)
2934 : : {
2935 [ # # ]: 0 : return is_kdump_kernel() ?
2936 [ # # ]: 0 : 1 : min_t(int, DEFAULT_MAX_NUM_RSS_QUEUES, num_online_cpus());
2937 : : }
2938 : : EXPORT_SYMBOL(netif_get_num_default_rss_queues);
2939 : :
2940 : 0 : static void __netif_reschedule(struct Qdisc *q)
2941 : : {
2942 : 0 : struct softnet_data *sd;
2943 : 0 : unsigned long flags;
2944 : :
2945 : 0 : local_irq_save(flags);
2946 : 0 : sd = this_cpu_ptr(&softnet_data);
2947 : 0 : q->next_sched = NULL;
2948 : 0 : *sd->output_queue_tailp = q;
2949 : 0 : sd->output_queue_tailp = &q->next_sched;
2950 : 0 : raise_softirq_irqoff(NET_TX_SOFTIRQ);
2951 : 0 : local_irq_restore(flags);
2952 : 0 : }
2953 : :
2954 : 0 : void __netif_schedule(struct Qdisc *q)
2955 : : {
2956 [ # # ]: 0 : if (!test_and_set_bit(__QDISC_STATE_SCHED, &q->state))
2957 : 0 : __netif_reschedule(q);
2958 : 0 : }
2959 : : EXPORT_SYMBOL(__netif_schedule);
2960 : :
2961 : : struct dev_kfree_skb_cb {
2962 : : enum skb_free_reason reason;
2963 : : };
2964 : :
2965 : 0 : static struct dev_kfree_skb_cb *get_kfree_skb_cb(const struct sk_buff *skb)
2966 : : {
2967 : 0 : return (struct dev_kfree_skb_cb *)skb->cb;
2968 : : }
2969 : :
2970 : 0 : void netif_schedule_queue(struct netdev_queue *txq)
2971 : : {
2972 : 0 : rcu_read_lock();
2973 [ # # ]: 0 : if (!netif_xmit_stopped(txq)) {
2974 : 0 : struct Qdisc *q = rcu_dereference(txq->qdisc);
2975 : :
2976 : 0 : __netif_schedule(q);
2977 : : }
2978 : 0 : rcu_read_unlock();
2979 : 0 : }
2980 : : EXPORT_SYMBOL(netif_schedule_queue);
2981 : :
2982 : 3 : void netif_tx_wake_queue(struct netdev_queue *dev_queue)
2983 : : {
2984 [ - + ]: 3 : if (test_and_clear_bit(__QUEUE_STATE_DRV_XOFF, &dev_queue->state)) {
2985 : 0 : struct Qdisc *q;
2986 : :
2987 : 0 : rcu_read_lock();
2988 : 0 : q = rcu_dereference(dev_queue->qdisc);
2989 : 0 : __netif_schedule(q);
2990 : 0 : rcu_read_unlock();
2991 : : }
2992 : 3 : }
2993 : : EXPORT_SYMBOL(netif_tx_wake_queue);
2994 : :
2995 : 0 : void __dev_kfree_skb_irq(struct sk_buff *skb, enum skb_free_reason reason)
2996 : : {
2997 : 0 : unsigned long flags;
2998 : :
2999 [ # # ]: 0 : if (unlikely(!skb))
3000 : : return;
3001 : :
3002 [ # # ]: 0 : if (likely(refcount_read(&skb->users) == 1)) {
3003 : 0 : smp_rmb();
3004 : 0 : refcount_set(&skb->users, 0);
3005 [ # # ]: 0 : } else if (likely(!refcount_dec_and_test(&skb->users))) {
3006 : : return;
3007 : : }
3008 : 0 : get_kfree_skb_cb(skb)->reason = reason;
3009 : 0 : local_irq_save(flags);
3010 : 0 : skb->next = __this_cpu_read(softnet_data.completion_queue);
3011 : 0 : __this_cpu_write(softnet_data.completion_queue, skb);
3012 : 0 : raise_softirq_irqoff(NET_TX_SOFTIRQ);
3013 : 0 : local_irq_restore(flags);
3014 : : }
3015 : : EXPORT_SYMBOL(__dev_kfree_skb_irq);
3016 : :
3017 : 0 : void __dev_kfree_skb_any(struct sk_buff *skb, enum skb_free_reason reason)
3018 : : {
3019 [ # # # # ]: 0 : if (in_irq() || irqs_disabled())
3020 : 0 : __dev_kfree_skb_irq(skb, reason);
3021 : : else
3022 : 0 : dev_kfree_skb(skb);
3023 : 0 : }
3024 : : EXPORT_SYMBOL(__dev_kfree_skb_any);
3025 : :
3026 : :
3027 : : /**
3028 : : * netif_device_detach - mark device as removed
3029 : : * @dev: network device
3030 : : *
3031 : : * Mark device as removed from system and therefore no longer available.
3032 : : */
3033 : 0 : void netif_device_detach(struct net_device *dev)
3034 : : {
3035 [ # # # # ]: 0 : if (test_and_clear_bit(__LINK_STATE_PRESENT, &dev->state) &&
3036 : : netif_running(dev)) {
3037 : : netif_tx_stop_all_queues(dev);
3038 : : }
3039 : 0 : }
3040 : : EXPORT_SYMBOL(netif_device_detach);
3041 : :
3042 : : /**
3043 : : * netif_device_attach - mark device as attached
3044 : : * @dev: network device
3045 : : *
3046 : : * Mark device as attached from system and restart if needed.
3047 : : */
3048 : 0 : void netif_device_attach(struct net_device *dev)
3049 : : {
3050 [ # # # # ]: 0 : if (!test_and_set_bit(__LINK_STATE_PRESENT, &dev->state) &&
3051 : : netif_running(dev)) {
3052 : : netif_tx_wake_all_queues(dev);
3053 : 0 : __netdev_watchdog_up(dev);
3054 : : }
3055 : 0 : }
3056 : : EXPORT_SYMBOL(netif_device_attach);
3057 : :
3058 : : /*
3059 : : * Returns a Tx hash based on the given packet descriptor a Tx queues' number
3060 : : * to be used as a distribution range.
3061 : : */
3062 : 0 : static u16 skb_tx_hash(const struct net_device *dev,
3063 : : const struct net_device *sb_dev,
3064 : : struct sk_buff *skb)
3065 : : {
3066 : 0 : u32 hash;
3067 : 0 : u16 qoffset = 0;
3068 : 0 : u16 qcount = dev->real_num_tx_queues;
3069 : :
3070 [ # # ]: 0 : if (dev->num_tc) {
3071 : 0 : u8 tc = netdev_get_prio_tc_map(dev, skb->priority);
3072 : :
3073 : 0 : qoffset = sb_dev->tc_to_txq[tc].offset;
3074 : 0 : qcount = sb_dev->tc_to_txq[tc].count;
3075 : : }
3076 : :
3077 [ # # ]: 0 : if (skb_rx_queue_recorded(skb)) {
3078 [ # # ]: 0 : hash = skb_get_rx_queue(skb);
3079 [ # # ]: 0 : if (hash >= qoffset)
3080 : 0 : hash -= qoffset;
3081 [ # # ]: 0 : while (unlikely(hash >= qcount))
3082 : 0 : hash -= qcount;
3083 : 0 : return hash + qoffset;
3084 : : }
3085 : :
3086 [ # # ]: 0 : return (u16) reciprocal_scale(skb_get_hash(skb), qcount) + qoffset;
3087 : : }
3088 : :
3089 : 0 : static void skb_warn_bad_offload(const struct sk_buff *skb)
3090 : : {
3091 : 0 : static const netdev_features_t null_features;
3092 : 0 : struct net_device *dev = skb->dev;
3093 : 0 : const char *name = "";
3094 : :
3095 [ # # ]: 0 : if (!net_ratelimit())
3096 : : return;
3097 : :
3098 [ # # ]: 0 : if (dev) {
3099 [ # # ]: 0 : if (dev->dev.parent)
3100 : 0 : name = dev_driver_string(dev->dev.parent);
3101 : : else
3102 [ # # ]: 0 : name = netdev_name(dev);
3103 : : }
3104 : 0 : skb_dump(KERN_WARNING, skb, false);
3105 [ # # # # ]: 0 : WARN(1, "%s: caps=(%pNF, %pNF)\n",
3106 : : name, dev ? &dev->features : &null_features,
3107 : : skb->sk ? &skb->sk->sk_route_caps : &null_features);
3108 : : }
3109 : :
3110 : : /*
3111 : : * Invalidate hardware checksum when packet is to be mangled, and
3112 : : * complete checksum manually on outgoing path.
3113 : : */
3114 : 0 : int skb_checksum_help(struct sk_buff *skb)
3115 : : {
3116 : 0 : __wsum csum;
3117 : 0 : int ret = 0, offset;
3118 : :
3119 [ # # ]: 0 : if (skb->ip_summed == CHECKSUM_COMPLETE)
3120 : 0 : goto out_set_summed;
3121 : :
3122 [ # # ]: 0 : if (unlikely(skb_shinfo(skb)->gso_size)) {
3123 : 0 : skb_warn_bad_offload(skb);
3124 : 0 : return -EINVAL;
3125 : : }
3126 : :
3127 : : /* Before computing a checksum, we should make sure no frag could
3128 : : * be modified by an external entity : checksum could be wrong.
3129 : : */
3130 [ # # # # ]: 0 : if (skb_has_shared_frag(skb)) {
3131 : 0 : ret = __skb_linearize(skb);
3132 : 0 : if (ret)
3133 : 0 : goto out;
3134 : : }
3135 : :
3136 [ # # ]: 0 : offset = skb_checksum_start_offset(skb);
3137 [ # # ]: 0 : BUG_ON(offset >= skb_headlen(skb));
3138 : 0 : csum = skb_checksum(skb, offset, skb->len - offset, 0);
3139 : :
3140 : 0 : offset += skb->csum_offset;
3141 [ # # ]: 0 : BUG_ON(offset + sizeof(__sum16) > skb_headlen(skb));
3142 : :
3143 : 0 : ret = skb_ensure_writable(skb, offset + sizeof(__sum16));
3144 [ # # ]: 0 : if (ret)
3145 : 0 : goto out;
3146 : :
3147 [ # # ]: 0 : *(__sum16 *)(skb->data + offset) = csum_fold(csum) ?: CSUM_MANGLED_0;
3148 : 0 : out_set_summed:
3149 : 0 : skb->ip_summed = CHECKSUM_NONE;
3150 : : out:
3151 : : return ret;
3152 : : }
3153 : : EXPORT_SYMBOL(skb_checksum_help);
3154 : :
3155 : 0 : int skb_crc32c_csum_help(struct sk_buff *skb)
3156 : : {
3157 : 0 : __le32 crc32c_csum;
3158 : 0 : int ret = 0, offset, start;
3159 : :
3160 [ # # ]: 0 : if (skb->ip_summed != CHECKSUM_PARTIAL)
3161 : 0 : goto out;
3162 : :
3163 [ # # ]: 0 : if (unlikely(skb_is_gso(skb)))
3164 : 0 : goto out;
3165 : :
3166 : : /* Before computing a checksum, we should make sure no frag could
3167 : : * be modified by an external entity : checksum could be wrong.
3168 : : */
3169 [ # # # # ]: 0 : if (unlikely(skb_has_shared_frag(skb))) {
3170 : 0 : ret = __skb_linearize(skb);
3171 : 0 : if (ret)
3172 : 0 : goto out;
3173 : : }
3174 [ # # ]: 0 : start = skb_checksum_start_offset(skb);
3175 : 0 : offset = start + offsetof(struct sctphdr, checksum);
3176 [ # # # # ]: 0 : if (WARN_ON_ONCE(offset >= skb_headlen(skb))) {
3177 : 0 : ret = -EINVAL;
3178 : 0 : goto out;
3179 : : }
3180 : :
3181 : 0 : ret = skb_ensure_writable(skb, offset + sizeof(__le32));
3182 [ # # ]: 0 : if (ret)
3183 : 0 : goto out;
3184 : :
3185 : 0 : crc32c_csum = cpu_to_le32(~__skb_checksum(skb, start,
3186 : : skb->len - start, ~(__u32)0,
3187 : : crc32c_csum_stub));
3188 : 0 : *(__le32 *)(skb->data + offset) = crc32c_csum;
3189 : 0 : skb->ip_summed = CHECKSUM_NONE;
3190 : 0 : skb->csum_not_inet = 0;
3191 : 0 : out:
3192 : 0 : return ret;
3193 : : }
3194 : :
3195 : 3 : __be16 skb_network_protocol(struct sk_buff *skb, int *depth)
3196 : : {
3197 : 3 : __be16 type = skb->protocol;
3198 : :
3199 : : /* Tunnel gso handlers can set protocol to ethernet. */
3200 [ - + ]: 3 : if (type == htons(ETH_P_TEB)) {
3201 : 0 : struct ethhdr *eth;
3202 : :
3203 [ # # ]: 0 : if (unlikely(!pskb_may_pull(skb, sizeof(struct ethhdr))))
3204 : : return 0;
3205 : :
3206 : 0 : eth = (struct ethhdr *)skb->data;
3207 : 0 : type = eth->h_proto;
3208 : : }
3209 : :
3210 : 3 : return __vlan_get_protocol(skb, type, depth);
3211 : : }
3212 : :
3213 : : /**
3214 : : * skb_mac_gso_segment - mac layer segmentation handler.
3215 : : * @skb: buffer to segment
3216 : : * @features: features for the output path (see dev->features)
3217 : : */
3218 : 0 : struct sk_buff *skb_mac_gso_segment(struct sk_buff *skb,
3219 : : netdev_features_t features)
3220 : : {
3221 : 0 : struct sk_buff *segs = ERR_PTR(-EPROTONOSUPPORT);
3222 : 0 : struct packet_offload *ptype;
3223 : 0 : int vlan_depth = skb->mac_len;
3224 : 0 : __be16 type = skb_network_protocol(skb, &vlan_depth);
3225 : :
3226 [ # # ]: 0 : if (unlikely(!type))
3227 : : return ERR_PTR(-EINVAL);
3228 : :
3229 [ # # ]: 0 : __skb_pull(skb, vlan_depth);
3230 : :
3231 : 0 : rcu_read_lock();
3232 [ # # ]: 0 : list_for_each_entry_rcu(ptype, &offload_base, list) {
3233 [ # # # # ]: 0 : if (ptype->type == type && ptype->callbacks.gso_segment) {
3234 : 0 : segs = ptype->callbacks.gso_segment(skb, features);
3235 : 0 : break;
3236 : : }
3237 : : }
3238 : 0 : rcu_read_unlock();
3239 : :
3240 : 0 : __skb_push(skb, skb->data - skb_mac_header(skb));
3241 : :
3242 : 0 : return segs;
3243 : : }
3244 : : EXPORT_SYMBOL(skb_mac_gso_segment);
3245 : :
3246 : :
3247 : : /* openvswitch calls this on rx path, so we need a different check.
3248 : : */
3249 : 0 : static inline bool skb_needs_check(struct sk_buff *skb, bool tx_path)
3250 : : {
3251 [ # # ]: 0 : if (tx_path)
3252 : 0 : return skb->ip_summed != CHECKSUM_PARTIAL &&
3253 : : skb->ip_summed != CHECKSUM_UNNECESSARY;
3254 : :
3255 : 0 : return skb->ip_summed == CHECKSUM_NONE;
3256 : : }
3257 : :
3258 : : /**
3259 : : * __skb_gso_segment - Perform segmentation on skb.
3260 : : * @skb: buffer to segment
3261 : : * @features: features for the output path (see dev->features)
3262 : : * @tx_path: whether it is called in TX path
3263 : : *
3264 : : * This function segments the given skb and returns a list of segments.
3265 : : *
3266 : : * It may return NULL if the skb requires no segmentation. This is
3267 : : * only possible when GSO is used for verifying header integrity.
3268 : : *
3269 : : * Segmentation preserves SKB_SGO_CB_OFFSET bytes of previous skb cb.
3270 : : */
3271 : 0 : struct sk_buff *__skb_gso_segment(struct sk_buff *skb,
3272 : : netdev_features_t features, bool tx_path)
3273 : : {
3274 : 0 : struct sk_buff *segs;
3275 : :
3276 [ # # # # ]: 0 : if (unlikely(skb_needs_check(skb, tx_path))) {
3277 : 0 : int err;
3278 : :
3279 : : /* We're going to init ->check field in TCP or UDP header */
3280 : 0 : err = skb_cow_head(skb, 0);
3281 [ # # ]: 0 : if (err < 0)
3282 : 0 : return ERR_PTR(err);
3283 : : }
3284 : :
3285 : : /* Only report GSO partial support if it will enable us to
3286 : : * support segmentation on this frame without needing additional
3287 : : * work.
3288 : : */
3289 [ # # ]: 0 : if (features & NETIF_F_GSO_PARTIAL) {
3290 : 0 : netdev_features_t partial_features = NETIF_F_GSO_ROBUST;
3291 : 0 : struct net_device *dev = skb->dev;
3292 : :
3293 : 0 : partial_features |= dev->features & dev->gso_partial_features;
3294 [ # # # # ]: 0 : if (!skb_gso_ok(skb, features | partial_features))
3295 : 0 : features &= ~NETIF_F_GSO_PARTIAL;
3296 : : }
3297 : :
3298 : 0 : BUILD_BUG_ON(SKB_SGO_CB_OFFSET +
3299 : : sizeof(*SKB_GSO_CB(skb)) > sizeof(skb->cb));
3300 : :
3301 : 0 : SKB_GSO_CB(skb)->mac_offset = skb_headroom(skb);
3302 : 0 : SKB_GSO_CB(skb)->encap_level = 0;
3303 : :
3304 : 0 : skb_reset_mac_header(skb);
3305 : 0 : skb_reset_mac_len(skb);
3306 : :
3307 : 0 : segs = skb_mac_gso_segment(skb, features);
3308 : :
3309 [ # # # # : 0 : if (segs != skb && unlikely(skb_needs_check(skb, tx_path) && !IS_ERR(segs)))
# # ]
3310 : 0 : skb_warn_bad_offload(skb);
3311 : :
3312 : : return segs;
3313 : : }
3314 : : EXPORT_SYMBOL(__skb_gso_segment);
3315 : :
3316 : : /* Take action when hardware reception checksum errors are detected. */
3317 : : #ifdef CONFIG_BUG
3318 : 0 : void netdev_rx_csum_fault(struct net_device *dev, struct sk_buff *skb)
3319 : : {
3320 [ # # ]: 0 : if (net_ratelimit()) {
3321 [ # # ]: 0 : pr_err("%s: hw csum failure\n", dev ? dev->name : "<unknown>");
3322 : 0 : skb_dump(KERN_ERR, skb, true);
3323 : 0 : dump_stack();
3324 : : }
3325 : 0 : }
3326 : : EXPORT_SYMBOL(netdev_rx_csum_fault);
3327 : : #endif
3328 : :
3329 : : /* XXX: check that highmem exists at all on the given machine. */
3330 : 3 : static int illegal_highdma(struct net_device *dev, struct sk_buff *skb)
3331 : : {
3332 : : #ifdef CONFIG_HIGHMEM
3333 : : int i;
3334 : :
3335 : : if (!(dev->features & NETIF_F_HIGHDMA)) {
3336 : : for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
3337 : : skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
3338 : :
3339 : : if (PageHighMem(skb_frag_page(frag)))
3340 : : return 1;
3341 : : }
3342 : : }
3343 : : #endif
3344 : 3 : return 0;
3345 : : }
3346 : :
3347 : : /* If MPLS offload request, verify we are testing hardware MPLS features
3348 : : * instead of standard features for the netdev.
3349 : : */
3350 : : #if IS_ENABLED(CONFIG_NET_MPLS_GSO)
3351 : : static netdev_features_t net_mpls_features(struct sk_buff *skb,
3352 : : netdev_features_t features,
3353 : : __be16 type)
3354 : : {
3355 : : if (eth_p_mpls(type))
3356 : : features &= skb->dev->mpls_features;
3357 : :
3358 : : return features;
3359 : : }
3360 : : #else
3361 : 3 : static netdev_features_t net_mpls_features(struct sk_buff *skb,
3362 : : netdev_features_t features,
3363 : : __be16 type)
3364 : : {
3365 : 3 : return features;
3366 : : }
3367 : : #endif
3368 : :
3369 : 3 : static netdev_features_t harmonize_features(struct sk_buff *skb,
3370 : : netdev_features_t features)
3371 : : {
3372 : 3 : int tmp;
3373 : 3 : __be16 type;
3374 : :
3375 : 3 : type = skb_network_protocol(skb, &tmp);
3376 : 3 : features = net_mpls_features(skb, features, type);
3377 : :
3378 [ - + - - ]: 3 : if (skb->ip_summed != CHECKSUM_NONE &&
3379 : : !can_checksum_protocol(features, type)) {
3380 : 0 : features &= ~(NETIF_F_CSUM_MASK | NETIF_F_GSO_MASK);
3381 : : }
3382 : 3 : if (illegal_highdma(skb->dev, skb))
3383 : : features &= ~NETIF_F_SG;
3384 : :
3385 : 3 : return features;
3386 : : }
3387 : :
3388 : 0 : netdev_features_t passthru_features_check(struct sk_buff *skb,
3389 : : struct net_device *dev,
3390 : : netdev_features_t features)
3391 : : {
3392 : 0 : return features;
3393 : : }
3394 : : EXPORT_SYMBOL(passthru_features_check);
3395 : :
3396 : 0 : static netdev_features_t dflt_features_check(struct sk_buff *skb,
3397 : : struct net_device *dev,
3398 : : netdev_features_t features)
3399 : : {
3400 : 0 : return vlan_features_check(skb, features);
3401 : : }
3402 : :
3403 : : static netdev_features_t gso_features_check(const struct sk_buff *skb,
3404 : : struct net_device *dev,
3405 : : netdev_features_t features)
3406 : : {
3407 : : u16 gso_segs = skb_shinfo(skb)->gso_segs;
3408 : :
3409 : : if (gso_segs > dev->gso_max_segs)
3410 : : return features & ~NETIF_F_GSO_MASK;
3411 : :
3412 : : /* Support for GSO partial features requires software
3413 : : * intervention before we can actually process the packets
3414 : : * so we need to strip support for any partial features now
3415 : : * and we can pull them back in after we have partially
3416 : : * segmented the frame.
3417 : : */
3418 : : if (!(skb_shinfo(skb)->gso_type & SKB_GSO_PARTIAL))
3419 : : features &= ~dev->gso_partial_features;
3420 : :
3421 : : /* Make sure to clear the IPv4 ID mangling feature if the
3422 : : * IPv4 header has the potential to be fragmented.
3423 : : */
3424 : : if (skb_shinfo(skb)->gso_type & SKB_GSO_TCPV4) {
3425 : : struct iphdr *iph = skb->encapsulation ?
3426 : : inner_ip_hdr(skb) : ip_hdr(skb);
3427 : :
3428 : : if (!(iph->frag_off & htons(IP_DF)))
3429 : : features &= ~NETIF_F_TSO_MANGLEID;
3430 : : }
3431 : :
3432 : : return features;
3433 : : }
3434 : :
3435 : 3 : netdev_features_t netif_skb_features(struct sk_buff *skb)
3436 : : {
3437 : 3 : struct net_device *dev = skb->dev;
3438 : 3 : netdev_features_t features = dev->features;
3439 : :
3440 [ - + ]: 3 : if (skb_is_gso(skb))
3441 : 0 : features = gso_features_check(skb, dev, features);
3442 : :
3443 : : /* If encapsulation offload request, verify we are testing
3444 : : * hardware encapsulation features instead of standard
3445 : : * features for the netdev
3446 : : */
3447 [ - + ]: 3 : if (skb->encapsulation)
3448 : 0 : features &= dev->hw_enc_features;
3449 : :
3450 [ + - ]: 3 : if (skb_vlan_tagged(skb))
3451 : 0 : features = netdev_intersect_features(features,
3452 [ # # ]: 0 : dev->vlan_features |
3453 : : NETIF_F_HW_VLAN_CTAG_TX |
3454 : : NETIF_F_HW_VLAN_STAG_TX);
3455 : :
3456 [ + - ]: 3 : if (dev->netdev_ops->ndo_features_check)
3457 : 3 : features &= dev->netdev_ops->ndo_features_check(skb, dev,
3458 : : features);
3459 : : else
3460 : 0 : features &= dflt_features_check(skb, dev, features);
3461 : :
3462 : 3 : return harmonize_features(skb, features);
3463 : : }
3464 : : EXPORT_SYMBOL(netif_skb_features);
3465 : :
3466 : 3 : static int xmit_one(struct sk_buff *skb, struct net_device *dev,
3467 : : struct netdev_queue *txq, bool more)
3468 : : {
3469 : 3 : unsigned int len;
3470 : 3 : int rc;
3471 : :
3472 [ + - - + ]: 6 : if (dev_nit_active(dev))
3473 : 0 : dev_queue_xmit_nit(skb, dev);
3474 : :
3475 : 3 : len = skb->len;
3476 : 3 : trace_net_dev_start_xmit(skb, dev);
3477 : 3 : rc = netdev_start_xmit(skb, dev, txq, more);
3478 : 3 : trace_net_dev_xmit(skb, rc, dev, len);
3479 : :
3480 : 3 : return rc;
3481 : : }
3482 : :
3483 : 3 : struct sk_buff *dev_hard_start_xmit(struct sk_buff *first, struct net_device *dev,
3484 : : struct netdev_queue *txq, int *ret)
3485 : : {
3486 : 3 : struct sk_buff *skb = first;
3487 : 3 : int rc = NETDEV_TX_OK;
3488 : :
3489 [ + + ]: 6 : while (skb) {
3490 : 3 : struct sk_buff *next = skb->next;
3491 : :
3492 : 3 : skb_mark_not_on_list(skb);
3493 : 3 : rc = xmit_one(skb, dev, txq, next != NULL);
3494 [ + - - + ]: 6 : if (unlikely(!dev_xmit_complete(rc))) {
3495 : 0 : skb->next = next;
3496 : 0 : goto out;
3497 : : }
3498 : :
3499 : 3 : skb = next;
3500 [ - + - - ]: 3 : if (netif_tx_queue_stopped(txq) && skb) {
3501 : : rc = NETDEV_TX_BUSY;
3502 : : break;
3503 : : }
3504 : : }
3505 : :
3506 : 3 : out:
3507 : 3 : *ret = rc;
3508 : 3 : return skb;
3509 : : }
3510 : :
3511 : 3 : static struct sk_buff *validate_xmit_vlan(struct sk_buff *skb,
3512 : : netdev_features_t features)
3513 : : {
3514 [ - + ]: 3 : if (skb_vlan_tag_present(skb) &&
3515 [ # # ]: 0 : !vlan_hw_offload_capable(features, skb->vlan_proto))
3516 : 0 : skb = __vlan_hwaccel_push_inside(skb);
3517 : 3 : return skb;
3518 : : }
3519 : :
3520 : 0 : int skb_csum_hwoffload_help(struct sk_buff *skb,
3521 : : const netdev_features_t features)
3522 : : {
3523 [ # # ]: 0 : if (unlikely(skb->csum_not_inet))
3524 [ # # ]: 0 : return !!(features & NETIF_F_SCTP_CRC) ? 0 :
3525 : 0 : skb_crc32c_csum_help(skb);
3526 : :
3527 [ # # ]: 0 : return !!(features & NETIF_F_CSUM_MASK) ? 0 : skb_checksum_help(skb);
3528 : : }
3529 : : EXPORT_SYMBOL(skb_csum_hwoffload_help);
3530 : :
3531 : : static struct sk_buff *validate_xmit_skb(struct sk_buff *skb, struct net_device *dev, bool *again)
3532 : : {
3533 : : netdev_features_t features;
3534 : :
3535 : : features = netif_skb_features(skb);
3536 : : skb = validate_xmit_vlan(skb, features);
3537 : : if (unlikely(!skb))
3538 : : goto out_null;
3539 : :
3540 : : skb = sk_validate_xmit_skb(skb, dev);
3541 : : if (unlikely(!skb))
3542 : : goto out_null;
3543 : :
3544 : : if (netif_needs_gso(skb, features)) {
3545 : : struct sk_buff *segs;
3546 : :
3547 : : segs = skb_gso_segment(skb, features);
3548 : : if (IS_ERR(segs)) {
3549 : : goto out_kfree_skb;
3550 : : } else if (segs) {
3551 : : consume_skb(skb);
3552 : : skb = segs;
3553 : : }
3554 : : } else {
3555 : : if (skb_needs_linearize(skb, features) &&
3556 : : __skb_linearize(skb))
3557 : : goto out_kfree_skb;
3558 : :
3559 : : /* If packet is not checksummed and device does not
3560 : : * support checksumming for this protocol, complete
3561 : : * checksumming here.
3562 : : */
3563 : : if (skb->ip_summed == CHECKSUM_PARTIAL) {
3564 : : if (skb->encapsulation)
3565 : : skb_set_inner_transport_header(skb,
3566 : : skb_checksum_start_offset(skb));
3567 : : else
3568 : : skb_set_transport_header(skb,
3569 : : skb_checksum_start_offset(skb));
3570 : : if (skb_csum_hwoffload_help(skb, features))
3571 : : goto out_kfree_skb;
3572 : : }
3573 : : }
3574 : :
3575 : : skb = validate_xmit_xfrm(skb, features, again);
3576 : :
3577 : : return skb;
3578 : :
3579 : : out_kfree_skb:
3580 : : kfree_skb(skb);
3581 : : out_null:
3582 : : atomic_long_inc(&dev->tx_dropped);
3583 : : return NULL;
3584 : : }
3585 : :
3586 : 3 : struct sk_buff *validate_xmit_skb_list(struct sk_buff *skb, struct net_device *dev, bool *again)
3587 : : {
3588 : 3 : struct sk_buff *next, *head = NULL, *tail;
3589 : :
3590 [ + + ]: 6 : for (; skb != NULL; skb = next) {
3591 : 3 : next = skb->next;
3592 : 3 : skb_mark_not_on_list(skb);
3593 : :
3594 : : /* in case skb wont be segmented, point to itself */
3595 : 3 : skb->prev = skb;
3596 : :
3597 : 3 : skb = validate_xmit_skb(skb, dev, again);
3598 [ - + ]: 3 : if (!skb)
3599 : 0 : continue;
3600 : :
3601 [ - + ]: 3 : if (!head)
3602 : : head = skb;
3603 : : else
3604 : 0 : tail->next = skb;
3605 : : /* If skb was segmented, skb->prev points to
3606 : : * the last segment. If not, it still contains skb.
3607 : : */
3608 : 3 : tail = skb->prev;
3609 : : }
3610 : 3 : return head;
3611 : : }
3612 : : EXPORT_SYMBOL_GPL(validate_xmit_skb_list);
3613 : :
3614 : 17 : static void qdisc_pkt_len_init(struct sk_buff *skb)
3615 : : {
3616 [ - + ]: 17 : const struct skb_shared_info *shinfo = skb_shinfo(skb);
3617 : :
3618 [ - + ]: 17 : qdisc_skb_cb(skb)->pkt_len = skb->len;
3619 : :
3620 : : /* To get more precise estimation of bytes sent on wire,
3621 : : * we add to pkt_len the headers size of all segments
3622 : : */
3623 [ - + - - ]: 17 : if (shinfo->gso_size && skb_transport_header_was_set(skb)) {
3624 : 0 : unsigned int hdr_len;
3625 : 0 : u16 gso_segs = shinfo->gso_segs;
3626 : :
3627 : : /* mac layer + network layer */
3628 [ # # ]: 0 : hdr_len = skb_transport_header(skb) - skb_mac_header(skb);
3629 : :
3630 : : /* + transport layer */
3631 [ # # ]: 0 : if (likely(shinfo->gso_type & (SKB_GSO_TCPV4 | SKB_GSO_TCPV6))) {
3632 : 0 : const struct tcphdr *th;
3633 : 0 : struct tcphdr _tcphdr;
3634 : :
3635 : 0 : th = skb_header_pointer(skb, skb_transport_offset(skb),
3636 : : sizeof(_tcphdr), &_tcphdr);
3637 [ # # ]: 0 : if (likely(th))
3638 : 0 : hdr_len += __tcp_hdrlen(th);
3639 : : } else {
3640 : 0 : struct udphdr _udphdr;
3641 : :
3642 [ # # ]: 0 : if (skb_header_pointer(skb, skb_transport_offset(skb),
3643 : : sizeof(_udphdr), &_udphdr))
3644 : 0 : hdr_len += sizeof(struct udphdr);
3645 : : }
3646 : :
3647 [ # # ]: 0 : if (shinfo->gso_type & SKB_GSO_DODGY)
3648 : 0 : gso_segs = DIV_ROUND_UP(skb->len - hdr_len,
3649 : : shinfo->gso_size);
3650 : :
3651 : 0 : qdisc_skb_cb(skb)->pkt_len += (gso_segs - 1) * hdr_len;
3652 : : }
3653 : 17 : }
3654 : :
3655 : 17 : static inline int __dev_xmit_skb(struct sk_buff *skb, struct Qdisc *q,
3656 : : struct net_device *dev,
3657 : : struct netdev_queue *txq)
3658 : : {
3659 [ - + ]: 17 : spinlock_t *root_lock = qdisc_lock(q);
3660 : 17 : struct sk_buff *to_free = NULL;
3661 : 17 : bool contended;
3662 : 17 : int rc;
3663 : :
3664 [ - + ]: 17 : qdisc_calculate_pkt_len(skb, q);
3665 : :
3666 [ + - ]: 17 : if (q->flags & TCQ_F_NOLOCK) {
3667 : 17 : rc = q->enqueue(skb, q, &to_free) & NET_XMIT_MASK;
3668 : 17 : qdisc_run(q);
3669 : :
3670 [ - + ]: 17 : if (unlikely(to_free))
3671 : 0 : kfree_skb_list(to_free);
3672 : 17 : return rc;
3673 : : }
3674 : :
3675 : : /*
3676 : : * Heuristic to force contended enqueues to serialize on a
3677 : : * separate lock before trying to get qdisc main lock.
3678 : : * This permits qdisc->running owner to get the lock more
3679 : : * often and dequeue packets faster.
3680 : : */
3681 : 0 : contended = qdisc_is_running(q);
3682 [ # # ]: 0 : if (unlikely(contended))
3683 : 0 : spin_lock(&q->busylock);
3684 : :
3685 : 0 : spin_lock(root_lock);
3686 [ # # ]: 0 : if (unlikely(test_bit(__QDISC_STATE_DEACTIVATED, &q->state))) {
3687 : 0 : __qdisc_drop(skb, &to_free);
3688 : 0 : rc = NET_XMIT_DROP;
3689 [ # # # # : 0 : } else if ((q->flags & TCQ_F_CAN_BYPASS) && !qdisc_qlen(q) &&
# # ]
3690 : 0 : qdisc_run_begin(q)) {
3691 : : /*
3692 : : * This is a work-conserving queue; there are no old skbs
3693 : : * waiting to be sent out; and the qdisc is not running -
3694 : : * xmit the skb directly.
3695 : : */
3696 : :
3697 [ # # ]: 0 : qdisc_bstats_update(q, skb);
3698 : :
3699 [ # # ]: 0 : if (sch_direct_xmit(skb, q, dev, txq, root_lock, true)) {
3700 [ # # ]: 0 : if (unlikely(contended)) {
3701 : 0 : spin_unlock(&q->busylock);
3702 : 0 : contended = false;
3703 : : }
3704 : 0 : __qdisc_run(q);
3705 : : }
3706 : :
3707 : 0 : qdisc_run_end(q);
3708 : : rc = NET_XMIT_SUCCESS;
3709 : : } else {
3710 : 0 : rc = q->enqueue(skb, q, &to_free) & NET_XMIT_MASK;
3711 [ # # ]: 0 : if (qdisc_run_begin(q)) {
3712 [ # # ]: 0 : if (unlikely(contended)) {
3713 : 0 : spin_unlock(&q->busylock);
3714 : 0 : contended = false;
3715 : : }
3716 : 0 : __qdisc_run(q);
3717 : 0 : qdisc_run_end(q);
3718 : : }
3719 : : }
3720 : 0 : spin_unlock(root_lock);
3721 [ # # ]: 0 : if (unlikely(to_free))
3722 : 0 : kfree_skb_list(to_free);
3723 [ # # ]: 0 : if (unlikely(contended))
3724 : 0 : spin_unlock(&q->busylock);
3725 : : return rc;
3726 : : }
3727 : :
3728 : : #if IS_ENABLED(CONFIG_CGROUP_NET_PRIO)
3729 : : static void skb_update_prio(struct sk_buff *skb)
3730 : : {
3731 : : const struct netprio_map *map;
3732 : : const struct sock *sk;
3733 : : unsigned int prioidx;
3734 : :
3735 : : if (skb->priority)
3736 : : return;
3737 : : map = rcu_dereference_bh(skb->dev->priomap);
3738 : : if (!map)
3739 : : return;
3740 : : sk = skb_to_full_sk(skb);
3741 : : if (!sk)
3742 : : return;
3743 : :
3744 : : prioidx = sock_cgroup_prioidx(&sk->sk_cgrp_data);
3745 : :
3746 : : if (prioidx < map->priomap_len)
3747 : : skb->priority = map->priomap[prioidx];
3748 : : }
3749 : : #else
3750 : : #define skb_update_prio(skb)
3751 : : #endif
3752 : :
3753 : : /**
3754 : : * dev_loopback_xmit - loop back @skb
3755 : : * @net: network namespace this loopback is happening in
3756 : : * @sk: sk needed to be a netfilter okfn
3757 : : * @skb: buffer to transmit
3758 : : */
3759 : 0 : int dev_loopback_xmit(struct net *net, struct sock *sk, struct sk_buff *skb)
3760 : : {
3761 [ # # ]: 0 : skb_reset_mac_header(skb);
3762 [ # # ]: 0 : __skb_pull(skb, skb_network_offset(skb));
3763 : 0 : skb->pkt_type = PACKET_LOOPBACK;
3764 : 0 : skb->ip_summed = CHECKSUM_UNNECESSARY;
3765 [ # # ]: 0 : WARN_ON(!skb_dst(skb));
3766 : 0 : skb_dst_force(skb);
3767 : 0 : netif_rx_ni(skb);
3768 : 0 : return 0;
3769 : : }
3770 : : EXPORT_SYMBOL(dev_loopback_xmit);
3771 : :
3772 : : #ifdef CONFIG_NET_EGRESS
3773 : : static struct sk_buff *
3774 : : sch_handle_egress(struct sk_buff *skb, int *ret, struct net_device *dev)
3775 : : {
3776 : : struct mini_Qdisc *miniq = rcu_dereference_bh(dev->miniq_egress);
3777 : : struct tcf_result cl_res;
3778 : :
3779 : : if (!miniq)
3780 : : return skb;
3781 : :
3782 : : /* qdisc_skb_cb(skb)->pkt_len was already set by the caller. */
3783 : : mini_qdisc_bstats_cpu_update(miniq, skb);
3784 : :
3785 : : switch (tcf_classify(skb, miniq->filter_list, &cl_res, false)) {
3786 : : case TC_ACT_OK:
3787 : : case TC_ACT_RECLASSIFY:
3788 : : skb->tc_index = TC_H_MIN(cl_res.classid);
3789 : : break;
3790 : : case TC_ACT_SHOT:
3791 : : mini_qdisc_qstats_cpu_drop(miniq);
3792 : : *ret = NET_XMIT_DROP;
3793 : : kfree_skb(skb);
3794 : : return NULL;
3795 : : case TC_ACT_STOLEN:
3796 : : case TC_ACT_QUEUED:
3797 : : case TC_ACT_TRAP:
3798 : : *ret = NET_XMIT_SUCCESS;
3799 : : consume_skb(skb);
3800 : : return NULL;
3801 : : case TC_ACT_REDIRECT:
3802 : : /* No need to push/pop skb's mac_header here on egress! */
3803 : : skb_do_redirect(skb);
3804 : : *ret = NET_XMIT_SUCCESS;
3805 : : return NULL;
3806 : : default:
3807 : : break;
3808 : : }
3809 : :
3810 : : return skb;
3811 : : }
3812 : : #endif /* CONFIG_NET_EGRESS */
3813 : :
3814 : : #ifdef CONFIG_XPS
3815 : 0 : static int __get_xps_queue_idx(struct net_device *dev, struct sk_buff *skb,
3816 : : struct xps_dev_maps *dev_maps, unsigned int tci)
3817 : : {
3818 : 0 : struct xps_map *map;
3819 : 0 : int queue_index = -1;
3820 : :
3821 [ # # ]: 0 : if (dev->num_tc) {
3822 : 0 : tci *= dev->num_tc;
3823 : 0 : tci += netdev_get_prio_tc_map(dev, skb->priority);
3824 : : }
3825 : :
3826 [ # # ]: 0 : map = rcu_dereference(dev_maps->attr_map[tci]);
3827 [ # # ]: 0 : if (map) {
3828 [ # # ]: 0 : if (map->len == 1)
3829 : 0 : queue_index = map->queues[0];
3830 : : else
3831 [ # # ]: 0 : queue_index = map->queues[reciprocal_scale(
3832 : : skb_get_hash(skb), map->len)];
3833 [ # # ]: 0 : if (unlikely(queue_index >= dev->real_num_tx_queues))
3834 : 0 : queue_index = -1;
3835 : : }
3836 : 0 : return queue_index;
3837 : : }
3838 : : #endif
3839 : :
3840 : 0 : static int get_xps_queue(struct net_device *dev, struct net_device *sb_dev,
3841 : : struct sk_buff *skb)
3842 : : {
3843 : : #ifdef CONFIG_XPS
3844 : 0 : struct xps_dev_maps *dev_maps;
3845 : 0 : struct sock *sk = skb->sk;
3846 : 0 : int queue_index = -1;
3847 : :
3848 [ # # ]: 0 : if (!static_key_false(&xps_needed))
3849 : 0 : return -1;
3850 : :
3851 : 0 : rcu_read_lock();
3852 [ - - ]: 0 : if (!static_key_false(&xps_rxqs_needed))
3853 : 0 : goto get_cpus_map;
3854 : :
3855 [ - - ]: 0 : dev_maps = rcu_dereference(sb_dev->xps_rxqs_map);
3856 [ - - ]: 0 : if (dev_maps) {
3857 [ - - ]: 0 : int tci = sk_rx_queue_get(sk);
3858 : :
3859 [ - - ]: 0 : if (tci >= 0 && tci < dev->num_rx_queues)
3860 : 0 : queue_index = __get_xps_queue_idx(dev, skb, dev_maps,
3861 : : tci);
3862 : : }
3863 : :
3864 : 0 : get_cpus_map:
3865 [ - - ]: 0 : if (queue_index < 0) {
3866 [ - - ]: 0 : dev_maps = rcu_dereference(sb_dev->xps_cpus_map);
3867 [ - - ]: 0 : if (dev_maps) {
3868 : 0 : unsigned int tci = skb->sender_cpu - 1;
3869 : :
3870 : 0 : queue_index = __get_xps_queue_idx(dev, skb, dev_maps,
3871 : : tci);
3872 : : }
3873 : : }
3874 : 0 : rcu_read_unlock();
3875 : :
3876 : 0 : return queue_index;
3877 : : #else
3878 : : return -1;
3879 : : #endif
3880 : : }
3881 : :
3882 : 0 : u16 dev_pick_tx_zero(struct net_device *dev, struct sk_buff *skb,
3883 : : struct net_device *sb_dev)
3884 : : {
3885 : 0 : return 0;
3886 : : }
3887 : : EXPORT_SYMBOL(dev_pick_tx_zero);
3888 : :
3889 : 0 : u16 dev_pick_tx_cpu_id(struct net_device *dev, struct sk_buff *skb,
3890 : : struct net_device *sb_dev)
3891 : : {
3892 : 0 : return (u16)raw_smp_processor_id() % dev->real_num_tx_queues;
3893 : : }
3894 : : EXPORT_SYMBOL(dev_pick_tx_cpu_id);
3895 : :
3896 : 0 : u16 netdev_pick_tx(struct net_device *dev, struct sk_buff *skb,
3897 : : struct net_device *sb_dev)
3898 : : {
3899 : 0 : struct sock *sk = skb->sk;
3900 [ # # ]: 0 : int queue_index = sk_tx_queue_get(sk);
3901 : :
3902 [ # # ]: 0 : sb_dev = sb_dev ? : dev;
3903 : :
3904 [ # # # # ]: 0 : if (queue_index < 0 || skb->ooo_okay ||
3905 [ # # ]: 0 : queue_index >= dev->real_num_tx_queues) {
3906 : 0 : int new_index = get_xps_queue(dev, sb_dev, skb);
3907 : :
3908 [ # # ]: 0 : if (new_index < 0)
3909 : 0 : new_index = skb_tx_hash(dev, sb_dev, skb);
3910 : :
3911 [ # # # # ]: 0 : if (queue_index != new_index && sk &&
3912 [ # # ]: 0 : sk_fullsock(sk) &&
3913 [ # # ]: 0 : rcu_access_pointer(sk->sk_dst_cache))
3914 [ # # ]: 0 : sk_tx_queue_set(sk, new_index);
3915 : :
3916 : : queue_index = new_index;
3917 : : }
3918 : :
3919 : 0 : return queue_index;
3920 : : }
3921 : : EXPORT_SYMBOL(netdev_pick_tx);
3922 : :
3923 : 17 : struct netdev_queue *netdev_core_pick_tx(struct net_device *dev,
3924 : : struct sk_buff *skb,
3925 : : struct net_device *sb_dev)
3926 : : {
3927 : 17 : int queue_index = 0;
3928 : :
3929 : : #ifdef CONFIG_XPS
3930 : 17 : u32 sender_cpu = skb->sender_cpu - 1;
3931 : :
3932 [ + - ]: 17 : if (sender_cpu >= (u32)NR_CPUS)
3933 : 17 : skb->sender_cpu = raw_smp_processor_id() + 1;
3934 : : #endif
3935 : :
3936 [ - + ]: 17 : if (dev->real_num_tx_queues != 1) {
3937 : 0 : const struct net_device_ops *ops = dev->netdev_ops;
3938 : :
3939 [ # # ]: 0 : if (ops->ndo_select_queue)
3940 : 0 : queue_index = ops->ndo_select_queue(dev, skb, sb_dev);
3941 : : else
3942 : 0 : queue_index = netdev_pick_tx(dev, skb, sb_dev);
3943 : :
3944 : 0 : queue_index = netdev_cap_txqueue(dev, queue_index);
3945 : : }
3946 : :
3947 : 17 : skb_set_queue_mapping(skb, queue_index);
3948 : 17 : return netdev_get_tx_queue(dev, queue_index);
3949 : : }
3950 : :
3951 : : /**
3952 : : * __dev_queue_xmit - transmit a buffer
3953 : : * @skb: buffer to transmit
3954 : : * @sb_dev: suboordinate device used for L2 forwarding offload
3955 : : *
3956 : : * Queue a buffer for transmission to a network device. The caller must
3957 : : * have set the device and priority and built the buffer before calling
3958 : : * this function. The function can be called from an interrupt.
3959 : : *
3960 : : * A negative errno code is returned on a failure. A success does not
3961 : : * guarantee the frame will be transmitted as it may be dropped due
3962 : : * to congestion or traffic shaping.
3963 : : *
3964 : : * -----------------------------------------------------------------------------------
3965 : : * I notice this method can also return errors from the queue disciplines,
3966 : : * including NET_XMIT_DROP, which is a positive value. So, errors can also
3967 : : * be positive.
3968 : : *
3969 : : * Regardless of the return value, the skb is consumed, so it is currently
3970 : : * difficult to retry a send to this method. (You can bump the ref count
3971 : : * before sending to hold a reference for retry if you are careful.)
3972 : : *
3973 : : * When calling this method, interrupts MUST be enabled. This is because
3974 : : * the BH enable code must have IRQs enabled so that it will not deadlock.
3975 : : * --BLG
3976 : : */
3977 : 17 : static int __dev_queue_xmit(struct sk_buff *skb, struct net_device *sb_dev)
3978 : : {
3979 : 17 : struct net_device *dev = skb->dev;
3980 : 17 : struct netdev_queue *txq;
3981 : 17 : struct Qdisc *q;
3982 : 17 : int rc = -ENOMEM;
3983 : 17 : bool again = false;
3984 : :
3985 [ - + ]: 17 : skb_reset_mac_header(skb);
3986 : :
3987 [ - + ]: 17 : if (unlikely(skb_shinfo(skb)->tx_flags & SKBTX_SCHED_TSTAMP))
3988 : 0 : __skb_tstamp_tx(skb, NULL, skb->sk, SCM_TSTAMP_SCHED);
3989 : :
3990 : : /* Disable soft irqs for various locks below. Also
3991 : : * stops preemption for RCU.
3992 : : */
3993 : 17 : rcu_read_lock_bh();
3994 : :
3995 : 17 : skb_update_prio(skb);
3996 : :
3997 : 17 : qdisc_pkt_len_init(skb);
3998 : : #ifdef CONFIG_NET_CLS_ACT
3999 : 17 : skb->tc_at_ingress = 0;
4000 : : # ifdef CONFIG_NET_EGRESS
4001 : : if (static_branch_unlikely(&egress_needed_key)) {
4002 : : skb = sch_handle_egress(skb, &rc, dev);
4003 : : if (!skb)
4004 : : goto out;
4005 : : }
4006 : : # endif
4007 : : #endif
4008 : : /* If device/qdisc don't need skb->dst, release it right now while
4009 : : * its hot in this cpu cache.
4010 : : */
4011 [ + - ]: 17 : if (dev->priv_flags & IFF_XMIT_DST_RELEASE)
4012 [ + - ]: 17 : skb_dst_drop(skb);
4013 : : else
4014 : 0 : skb_dst_force(skb);
4015 : :
4016 : 17 : txq = netdev_core_pick_tx(dev, skb, sb_dev);
4017 : 17 : q = rcu_dereference_bh(txq->qdisc);
4018 : :
4019 : 17 : trace_net_dev_queue(skb);
4020 [ + - ]: 17 : if (q->enqueue) {
4021 : 17 : rc = __dev_xmit_skb(skb, q, dev, txq);
4022 : 17 : goto out;
4023 : : }
4024 : :
4025 : : /* The device has no queue. Common case for software devices:
4026 : : * loopback, all the sorts of tunnels...
4027 : :
4028 : : * Really, it is unlikely that netif_tx_lock protection is necessary
4029 : : * here. (f.e. loopback and IP tunnels are clean ignoring statistics
4030 : : * counters.)
4031 : : * However, it is possible, that they rely on protection
4032 : : * made by us here.
4033 : :
4034 : : * Check this and shot the lock. It is not prone from deadlocks.
4035 : : *Either shot noqueue qdisc, it is even simpler 8)
4036 : : */
4037 [ # # ]: 0 : if (dev->flags & IFF_UP) {
4038 [ # # ]: 0 : int cpu = smp_processor_id(); /* ok because BHs are off */
4039 : :
4040 [ # # ]: 0 : if (txq->xmit_lock_owner != cpu) {
4041 [ # # ]: 0 : if (dev_xmit_recursion())
4042 : 0 : goto recursion_alert;
4043 : :
4044 : 0 : skb = validate_xmit_skb(skb, dev, &again);
4045 [ # # ]: 0 : if (!skb)
4046 : 0 : goto out;
4047 : :
4048 [ # # ]: 0 : HARD_TX_LOCK(dev, txq, cpu);
4049 : :
4050 [ # # ]: 0 : if (!netif_xmit_stopped(txq)) {
4051 : 0 : dev_xmit_recursion_inc();
4052 : 0 : skb = dev_hard_start_xmit(skb, dev, txq, &rc);
4053 [ # # ]: 0 : dev_xmit_recursion_dec();
4054 [ # # ]: 0 : if (dev_xmit_complete(rc)) {
4055 [ # # ]: 0 : HARD_TX_UNLOCK(dev, txq);
4056 : 0 : goto out;
4057 : : }
4058 : : }
4059 [ # # ]: 0 : HARD_TX_UNLOCK(dev, txq);
4060 [ # # ]: 0 : net_crit_ratelimited("Virtual device %s asks to queue packet!\n",
4061 : : dev->name);
4062 : : } else {
4063 : : /* Recursion is detected! It is possible,
4064 : : * unfortunately
4065 : : */
4066 : 0 : recursion_alert:
4067 [ # # ]: 0 : net_crit_ratelimited("Dead loop on virtual device %s, fix it urgently!\n",
4068 : : dev->name);
4069 : : }
4070 : : }
4071 : :
4072 : 0 : rc = -ENETDOWN;
4073 : 0 : rcu_read_unlock_bh();
4074 : :
4075 : 0 : atomic_long_inc(&dev->tx_dropped);
4076 : 0 : kfree_skb_list(skb);
4077 : 0 : return rc;
4078 : 17 : out:
4079 : 17 : rcu_read_unlock_bh();
4080 : 17 : return rc;
4081 : : }
4082 : :
4083 : 17 : int dev_queue_xmit(struct sk_buff *skb)
4084 : : {
4085 : 17 : return __dev_queue_xmit(skb, NULL);
4086 : : }
4087 : : EXPORT_SYMBOL(dev_queue_xmit);
4088 : :
4089 : 0 : int dev_queue_xmit_accel(struct sk_buff *skb, struct net_device *sb_dev)
4090 : : {
4091 : 0 : return __dev_queue_xmit(skb, sb_dev);
4092 : : }
4093 : : EXPORT_SYMBOL(dev_queue_xmit_accel);
4094 : :
4095 : 0 : int dev_direct_xmit(struct sk_buff *skb, u16 queue_id)
4096 : : {
4097 : 0 : struct net_device *dev = skb->dev;
4098 : 0 : struct sk_buff *orig_skb = skb;
4099 : 0 : struct netdev_queue *txq;
4100 : 0 : int ret = NETDEV_TX_BUSY;
4101 : 0 : bool again = false;
4102 : :
4103 [ # # # # ]: 0 : if (unlikely(!netif_running(dev) ||
4104 : : !netif_carrier_ok(dev)))
4105 : 0 : goto drop;
4106 : :
4107 : 0 : skb = validate_xmit_skb_list(skb, dev, &again);
4108 [ # # ]: 0 : if (skb != orig_skb)
4109 : 0 : goto drop;
4110 : :
4111 : 0 : skb_set_queue_mapping(skb, queue_id);
4112 : 0 : txq = skb_get_tx_queue(dev, skb);
4113 : :
4114 : 0 : local_bh_disable();
4115 : :
4116 [ # # ]: 0 : HARD_TX_LOCK(dev, txq, smp_processor_id());
4117 [ # # ]: 0 : if (!netif_xmit_frozen_or_drv_stopped(txq))
4118 : 0 : ret = netdev_start_xmit(skb, dev, txq, false);
4119 [ # # ]: 0 : HARD_TX_UNLOCK(dev, txq);
4120 : :
4121 : 0 : local_bh_enable();
4122 : :
4123 [ # # ]: 0 : if (!dev_xmit_complete(ret))
4124 : 0 : kfree_skb(skb);
4125 : :
4126 : : return ret;
4127 : 0 : drop:
4128 : 0 : atomic_long_inc(&dev->tx_dropped);
4129 : 0 : kfree_skb_list(skb);
4130 : 0 : return NET_XMIT_DROP;
4131 : : }
4132 : : EXPORT_SYMBOL(dev_direct_xmit);
4133 : :
4134 : : /*************************************************************************
4135 : : * Receiver routines
4136 : : *************************************************************************/
4137 : :
4138 : : int netdev_max_backlog __read_mostly = 1000;
4139 : : EXPORT_SYMBOL(netdev_max_backlog);
4140 : :
4141 : : int netdev_tstamp_prequeue __read_mostly = 1;
4142 : : int netdev_budget __read_mostly = 300;
4143 : : unsigned int __read_mostly netdev_budget_usecs = 2000;
4144 : : int weight_p __read_mostly = 64; /* old backlog weight */
4145 : : int dev_weight_rx_bias __read_mostly = 1; /* bias for backlog weight */
4146 : : int dev_weight_tx_bias __read_mostly = 1; /* bias for output_queue quota */
4147 : : int dev_rx_weight __read_mostly = 64;
4148 : : int dev_tx_weight __read_mostly = 64;
4149 : : /* Maximum number of GRO_NORMAL skbs to batch up for list-RX */
4150 : : int gro_normal_batch __read_mostly = 8;
4151 : :
4152 : : /* Called with irq disabled */
4153 : 3 : static inline void ____napi_schedule(struct softnet_data *sd,
4154 : : struct napi_struct *napi)
4155 : : {
4156 : 3 : list_add_tail(&napi->poll_list, &sd->poll_list);
4157 : 3 : __raise_softirq_irqoff(NET_RX_SOFTIRQ);
4158 : 0 : }
4159 : :
4160 : : #ifdef CONFIG_RPS
4161 : :
4162 : : /* One global table that all flow-based protocols share. */
4163 : : struct rps_sock_flow_table __rcu *rps_sock_flow_table __read_mostly;
4164 : : EXPORT_SYMBOL(rps_sock_flow_table);
4165 : : u32 rps_cpu_mask __read_mostly;
4166 : : EXPORT_SYMBOL(rps_cpu_mask);
4167 : :
4168 : : struct static_key_false rps_needed __read_mostly;
4169 : : EXPORT_SYMBOL(rps_needed);
4170 : : struct static_key_false rfs_needed __read_mostly;
4171 : : EXPORT_SYMBOL(rfs_needed);
4172 : :
4173 : : static struct rps_dev_flow *
4174 : 0 : set_rps_cpu(struct net_device *dev, struct sk_buff *skb,
4175 : : struct rps_dev_flow *rflow, u16 next_cpu)
4176 : : {
4177 [ # # ]: 0 : if (next_cpu < nr_cpu_ids) {
4178 : : #ifdef CONFIG_RFS_ACCEL
4179 : 0 : struct netdev_rx_queue *rxqueue;
4180 : 0 : struct rps_dev_flow_table *flow_table;
4181 : 0 : struct rps_dev_flow *old_rflow;
4182 : 0 : u32 flow_id;
4183 : 0 : u16 rxq_index;
4184 : 0 : int rc;
4185 : :
4186 : : /* Should we steer this flow to a different hardware queue? */
4187 [ # # # # ]: 0 : if (!skb_rx_queue_recorded(skb) || !dev->rx_cpu_rmap ||
4188 [ # # ]: 0 : !(dev->features & NETIF_F_NTUPLE))
4189 : 0 : goto out;
4190 [ # # ]: 0 : rxq_index = cpu_rmap_lookup_index(dev->rx_cpu_rmap, next_cpu);
4191 [ # # ]: 0 : if (rxq_index == skb_get_rx_queue(skb))
4192 : 0 : goto out;
4193 : :
4194 : 0 : rxqueue = dev->_rx + rxq_index;
4195 [ # # ]: 0 : flow_table = rcu_dereference(rxqueue->rps_flow_table);
4196 [ # # ]: 0 : if (!flow_table)
4197 : 0 : goto out;
4198 [ # # ]: 0 : flow_id = skb_get_hash(skb) & flow_table->mask;
4199 : 0 : rc = dev->netdev_ops->ndo_rx_flow_steer(dev, skb,
4200 : : rxq_index, flow_id);
4201 [ # # ]: 0 : if (rc < 0)
4202 : 0 : goto out;
4203 : 0 : old_rflow = rflow;
4204 : 0 : rflow = &flow_table->flows[flow_id];
4205 : 0 : rflow->filter = rc;
4206 [ # # ]: 0 : if (old_rflow->filter == rflow->filter)
4207 : 0 : old_rflow->filter = RPS_NO_FILTER;
4208 : 0 : out:
4209 : : #endif
4210 : 0 : rflow->last_qtail =
4211 : 0 : per_cpu(softnet_data, next_cpu).input_queue_head;
4212 : : }
4213 : :
4214 : 0 : rflow->cpu = next_cpu;
4215 : 0 : return rflow;
4216 : : }
4217 : :
4218 : : /*
4219 : : * get_rps_cpu is called from netif_receive_skb and returns the target
4220 : : * CPU from the RPS map of the receiving queue for a given skb.
4221 : : * rcu_read_lock must be held on entry.
4222 : : */
4223 : 0 : static int get_rps_cpu(struct net_device *dev, struct sk_buff *skb,
4224 : : struct rps_dev_flow **rflowp)
4225 : : {
4226 : 0 : const struct rps_sock_flow_table *sock_flow_table;
4227 : 0 : struct netdev_rx_queue *rxqueue = dev->_rx;
4228 : 0 : struct rps_dev_flow_table *flow_table;
4229 : 0 : struct rps_map *map;
4230 : 0 : int cpu = -1;
4231 : 0 : u32 tcpu;
4232 : 0 : u32 hash;
4233 : :
4234 [ # # ]: 0 : if (skb_rx_queue_recorded(skb)) {
4235 [ # # ]: 0 : u16 index = skb_get_rx_queue(skb);
4236 : :
4237 [ # # ]: 0 : if (unlikely(index >= dev->real_num_rx_queues)) {
4238 [ # # # # ]: 0 : WARN_ONCE(dev->real_num_rx_queues > 1,
4239 : : "%s received packet on queue %u, but number "
4240 : : "of RX queues is %u\n",
4241 : : dev->name, index, dev->real_num_rx_queues);
4242 : 0 : goto done;
4243 : : }
4244 : 0 : rxqueue += index;
4245 : : }
4246 : :
4247 : : /* Avoid computing hash if RFS/RPS is not active for this rxqueue */
4248 : :
4249 [ # # ]: 0 : flow_table = rcu_dereference(rxqueue->rps_flow_table);
4250 : 0 : map = rcu_dereference(rxqueue->rps_map);
4251 [ # # ]: 0 : if (!flow_table && !map)
4252 : 0 : goto done;
4253 : :
4254 [ # # ]: 0 : skb_reset_network_header(skb);
4255 [ # # ]: 0 : hash = skb_get_hash(skb);
4256 [ # # ]: 0 : if (!hash)
4257 : 0 : goto done;
4258 : :
4259 [ # # ]: 0 : sock_flow_table = rcu_dereference(rps_sock_flow_table);
4260 [ # # ]: 0 : if (flow_table && sock_flow_table) {
4261 : 0 : struct rps_dev_flow *rflow;
4262 : 0 : u32 next_cpu;
4263 : 0 : u32 ident;
4264 : :
4265 : : /* First check into global flow table if there is a match */
4266 : 0 : ident = sock_flow_table->ents[hash & sock_flow_table->mask];
4267 [ # # ]: 0 : if ((ident ^ hash) & ~rps_cpu_mask)
4268 : 0 : goto try_rps;
4269 : :
4270 : 0 : next_cpu = ident & rps_cpu_mask;
4271 : :
4272 : : /* OK, now we know there is a match,
4273 : : * we can look at the local (per receive queue) flow table
4274 : : */
4275 : 0 : rflow = &flow_table->flows[hash & flow_table->mask];
4276 : 0 : tcpu = rflow->cpu;
4277 : :
4278 : : /*
4279 : : * If the desired CPU (where last recvmsg was done) is
4280 : : * different from current CPU (one in the rx-queue flow
4281 : : * table entry), switch if one of the following holds:
4282 : : * - Current CPU is unset (>= nr_cpu_ids).
4283 : : * - Current CPU is offline.
4284 : : * - The current CPU's queue tail has advanced beyond the
4285 : : * last packet that was enqueued using this table entry.
4286 : : * This guarantees that all previous packets for the flow
4287 : : * have been dequeued, thus preserving in order delivery.
4288 : : */
4289 [ # # ]: 0 : if (unlikely(tcpu != next_cpu) &&
4290 [ # # # # ]: 0 : (tcpu >= nr_cpu_ids || !cpu_online(tcpu) ||
4291 : 0 : ((int)(per_cpu(softnet_data, tcpu).input_queue_head -
4292 [ # # ]: 0 : rflow->last_qtail)) >= 0)) {
4293 : 0 : tcpu = next_cpu;
4294 : 0 : rflow = set_rps_cpu(dev, skb, rflow, next_cpu);
4295 : : }
4296 : :
4297 [ # # # # ]: 0 : if (tcpu < nr_cpu_ids && cpu_online(tcpu)) {
4298 : 0 : *rflowp = rflow;
4299 : 0 : cpu = tcpu;
4300 : 0 : goto done;
4301 : : }
4302 : : }
4303 : :
4304 : 0 : try_rps:
4305 : :
4306 [ # # ]: 0 : if (map) {
4307 : 0 : tcpu = map->cpus[reciprocal_scale(hash, map->len)];
4308 [ # # ]: 0 : if (cpu_online(tcpu)) {
4309 : 0 : cpu = tcpu;
4310 : 0 : goto done;
4311 : : }
4312 : : }
4313 : :
4314 : 0 : done:
4315 : 0 : return cpu;
4316 : : }
4317 : :
4318 : : #ifdef CONFIG_RFS_ACCEL
4319 : :
4320 : : /**
4321 : : * rps_may_expire_flow - check whether an RFS hardware filter may be removed
4322 : : * @dev: Device on which the filter was set
4323 : : * @rxq_index: RX queue index
4324 : : * @flow_id: Flow ID passed to ndo_rx_flow_steer()
4325 : : * @filter_id: Filter ID returned by ndo_rx_flow_steer()
4326 : : *
4327 : : * Drivers that implement ndo_rx_flow_steer() should periodically call
4328 : : * this function for each installed filter and remove the filters for
4329 : : * which it returns %true.
4330 : : */
4331 : 0 : bool rps_may_expire_flow(struct net_device *dev, u16 rxq_index,
4332 : : u32 flow_id, u16 filter_id)
4333 : : {
4334 : 0 : struct netdev_rx_queue *rxqueue = dev->_rx + rxq_index;
4335 : 0 : struct rps_dev_flow_table *flow_table;
4336 : 0 : struct rps_dev_flow *rflow;
4337 : 0 : bool expire = true;
4338 : 0 : unsigned int cpu;
4339 : :
4340 : 0 : rcu_read_lock();
4341 [ # # ]: 0 : flow_table = rcu_dereference(rxqueue->rps_flow_table);
4342 [ # # # # ]: 0 : if (flow_table && flow_id <= flow_table->mask) {
4343 : 0 : rflow = &flow_table->flows[flow_id];
4344 [ # # ]: 0 : cpu = READ_ONCE(rflow->cpu);
4345 [ # # # # ]: 0 : if (rflow->filter == filter_id && cpu < nr_cpu_ids &&
4346 : 0 : ((int)(per_cpu(softnet_data, cpu).input_queue_head -
4347 : 0 : rflow->last_qtail) <
4348 [ # # ]: 0 : (int)(10 * flow_table->mask)))
4349 : 0 : expire = false;
4350 : : }
4351 : 0 : rcu_read_unlock();
4352 : 0 : return expire;
4353 : : }
4354 : : EXPORT_SYMBOL(rps_may_expire_flow);
4355 : :
4356 : : #endif /* CONFIG_RFS_ACCEL */
4357 : :
4358 : : /* Called from hardirq (IPI) context */
4359 : 0 : static void rps_trigger_softirq(void *data)
4360 : : {
4361 : 0 : struct softnet_data *sd = data;
4362 : :
4363 : 0 : ____napi_schedule(sd, &sd->backlog);
4364 : 0 : sd->received_rps++;
4365 : 0 : }
4366 : :
4367 : : #endif /* CONFIG_RPS */
4368 : :
4369 : : /*
4370 : : * Check if this softnet_data structure is another cpu one
4371 : : * If yes, queue it to our IPI list and return 1
4372 : : * If no, return 0
4373 : : */
4374 : 0 : static int rps_ipi_queued(struct softnet_data *sd)
4375 : : {
4376 : : #ifdef CONFIG_RPS
4377 : 0 : struct softnet_data *mysd = this_cpu_ptr(&softnet_data);
4378 : :
4379 [ # # ]: 0 : if (sd != mysd) {
4380 : 0 : sd->rps_ipi_next = mysd->rps_ipi_list;
4381 : 0 : mysd->rps_ipi_list = sd;
4382 : :
4383 : 0 : __raise_softirq_irqoff(NET_RX_SOFTIRQ);
4384 : 0 : return 1;
4385 : : }
4386 : : #endif /* CONFIG_RPS */
4387 : : return 0;
4388 : : }
4389 : :
4390 : : #ifdef CONFIG_NET_FLOW_LIMIT
4391 : : int netdev_flow_limit_table_len __read_mostly = (1 << 12);
4392 : : #endif
4393 : :
4394 : 0 : static bool skb_flow_limit(struct sk_buff *skb, unsigned int qlen)
4395 : : {
4396 : : #ifdef CONFIG_NET_FLOW_LIMIT
4397 : 0 : struct sd_flow_limit *fl;
4398 : 0 : struct softnet_data *sd;
4399 : 0 : unsigned int old_flow, new_flow;
4400 : :
4401 [ # # ]: 0 : if (qlen < (netdev_max_backlog >> 1))
4402 : : return false;
4403 : :
4404 : 0 : sd = this_cpu_ptr(&softnet_data);
4405 : :
4406 : 0 : rcu_read_lock();
4407 [ # # ]: 0 : fl = rcu_dereference(sd->flow_limit);
4408 [ # # ]: 0 : if (fl) {
4409 [ # # ]: 0 : new_flow = skb_get_hash(skb) & (fl->num_buckets - 1);
4410 : 0 : old_flow = fl->history[fl->history_head];
4411 : 0 : fl->history[fl->history_head] = new_flow;
4412 : :
4413 : 0 : fl->history_head++;
4414 : 0 : fl->history_head &= FLOW_LIMIT_HISTORY - 1;
4415 : :
4416 [ # # ]: 0 : if (likely(fl->buckets[old_flow]))
4417 : 0 : fl->buckets[old_flow]--;
4418 : :
4419 [ # # ]: 0 : if (++fl->buckets[new_flow] > (FLOW_LIMIT_HISTORY >> 1)) {
4420 : 0 : fl->count++;
4421 : 0 : rcu_read_unlock();
4422 : 0 : return true;
4423 : : }
4424 : : }
4425 : 0 : rcu_read_unlock();
4426 : : #endif
4427 : 0 : return false;
4428 : : }
4429 : :
4430 : : /*
4431 : : * enqueue_to_backlog is called to queue an skb to a per CPU backlog
4432 : : * queue (may be a remote CPU queue).
4433 : : */
4434 : 0 : static int enqueue_to_backlog(struct sk_buff *skb, int cpu,
4435 : : unsigned int *qtail)
4436 : : {
4437 : 0 : struct softnet_data *sd;
4438 : 0 : unsigned long flags;
4439 : 0 : unsigned int qlen;
4440 : :
4441 : 0 : sd = &per_cpu(softnet_data, cpu);
4442 : :
4443 : 0 : local_irq_save(flags);
4444 : :
4445 : 0 : rps_lock(sd);
4446 [ # # ]: 0 : if (!netif_running(skb->dev))
4447 : 0 : goto drop;
4448 [ # # ]: 0 : qlen = skb_queue_len(&sd->input_pkt_queue);
4449 [ # # # # ]: 0 : if (qlen <= netdev_max_backlog && !skb_flow_limit(skb, qlen)) {
4450 [ # # ]: 0 : if (qlen) {
4451 : 0 : enqueue:
4452 : 0 : __skb_queue_tail(&sd->input_pkt_queue, skb);
4453 : 0 : input_queue_tail_incr_save(sd, qtail);
4454 : 0 : rps_unlock(sd);
4455 : 0 : local_irq_restore(flags);
4456 : 0 : return NET_RX_SUCCESS;
4457 : : }
4458 : :
4459 : : /* Schedule NAPI for backlog device
4460 : : * We can use non atomic operation since we own the queue lock
4461 : : */
4462 [ # # ]: 0 : if (!__test_and_set_bit(NAPI_STATE_SCHED, &sd->backlog.state)) {
4463 : 0 : if (!rps_ipi_queued(sd))
4464 : 0 : ____napi_schedule(sd, &sd->backlog);
4465 : : }
4466 : 0 : goto enqueue;
4467 : : }
4468 : :
4469 : 0 : drop:
4470 : 0 : sd->dropped++;
4471 : 0 : rps_unlock(sd);
4472 : :
4473 : 0 : local_irq_restore(flags);
4474 : :
4475 : 0 : atomic_long_inc(&skb->dev->rx_dropped);
4476 : 0 : kfree_skb(skb);
4477 : 0 : return NET_RX_DROP;
4478 : : }
4479 : :
4480 : 0 : static struct netdev_rx_queue *netif_get_rxqueue(struct sk_buff *skb)
4481 : : {
4482 : 0 : struct net_device *dev = skb->dev;
4483 : 0 : struct netdev_rx_queue *rxqueue;
4484 : :
4485 : 0 : rxqueue = dev->_rx;
4486 : :
4487 [ # # ]: 0 : if (skb_rx_queue_recorded(skb)) {
4488 [ # # ]: 0 : u16 index = skb_get_rx_queue(skb);
4489 : :
4490 [ # # ]: 0 : if (unlikely(index >= dev->real_num_rx_queues)) {
4491 [ # # # # ]: 0 : WARN_ONCE(dev->real_num_rx_queues > 1,
4492 : : "%s received packet on queue %u, but number "
4493 : : "of RX queues is %u\n",
4494 : : dev->name, index, dev->real_num_rx_queues);
4495 : :
4496 : 0 : return rxqueue; /* Return first rxqueue */
4497 : : }
4498 : 0 : rxqueue += index;
4499 : : }
4500 : : return rxqueue;
4501 : : }
4502 : :
4503 : 0 : static u32 netif_receive_generic_xdp(struct sk_buff *skb,
4504 : : struct xdp_buff *xdp,
4505 : : struct bpf_prog *xdp_prog)
4506 : : {
4507 : 0 : struct netdev_rx_queue *rxqueue;
4508 : 0 : void *orig_data, *orig_data_end;
4509 : 0 : u32 metalen, act = XDP_DROP;
4510 : 0 : __be16 orig_eth_type;
4511 : 0 : struct ethhdr *eth;
4512 : 0 : bool orig_bcast;
4513 : 0 : int hlen, off;
4514 : 0 : u32 mac_len;
4515 : :
4516 : : /* Reinjected packets coming from act_mirred or similar should
4517 : : * not get XDP generic processing.
4518 : : */
4519 : 0 : if (skb_is_redirected(skb))
4520 : : return XDP_PASS;
4521 : :
4522 : : /* XDP packets must be linear and must have sufficient headroom
4523 : : * of XDP_PACKET_HEADROOM bytes. This is the guarantee that also
4524 : : * native XDP provides, thus we need to do it here as well.
4525 : : */
4526 [ # # # # : 0 : if (skb_cloned(skb) || skb_is_nonlinear(skb) ||
# # ]
4527 [ # # ]: 0 : skb_headroom(skb) < XDP_PACKET_HEADROOM) {
4528 [ # # ]: 0 : int hroom = XDP_PACKET_HEADROOM - skb_headroom(skb);
4529 : 0 : int troom = skb->tail + skb->data_len - skb->end;
4530 : :
4531 : : /* In case we have to go down the path and also linearize,
4532 : : * then lets do the pskb_expand_head() work just once here.
4533 : : */
4534 [ # # # # : 0 : if (pskb_expand_head(skb,
# # ]
4535 : 0 : hroom > 0 ? ALIGN(hroom, NET_SKB_PAD) : 0,
4536 : : troom > 0 ? troom + 128 : 0, GFP_ATOMIC))
4537 : 0 : goto do_drop;
4538 [ # # ]: 0 : if (skb_linearize(skb))
4539 : 0 : goto do_drop;
4540 : : }
4541 : :
4542 : : /* The XDP program wants to see the packet starting at the MAC
4543 : : * header.
4544 : : */
4545 : 0 : mac_len = skb->data - skb_mac_header(skb);
4546 : 0 : hlen = skb_headlen(skb) + mac_len;
4547 : 0 : xdp->data = skb->data - mac_len;
4548 : 0 : xdp->data_meta = xdp->data;
4549 : 0 : xdp->data_end = xdp->data + hlen;
4550 : 0 : xdp->data_hard_start = skb->data - skb_headroom(skb);
4551 : 0 : orig_data_end = xdp->data_end;
4552 : 0 : orig_data = xdp->data;
4553 : 0 : eth = (struct ethhdr *)xdp->data;
4554 : 0 : orig_bcast = is_multicast_ether_addr_64bits(eth->h_dest);
4555 : 0 : orig_eth_type = eth->h_proto;
4556 : :
4557 : 0 : rxqueue = netif_get_rxqueue(skb);
4558 : 0 : xdp->rxq = &rxqueue->xdp_rxq;
4559 : :
4560 [ # # ]: 0 : act = bpf_prog_run_xdp(xdp_prog, xdp);
4561 : :
4562 : : /* check if bpf_xdp_adjust_head was used */
4563 : 0 : off = xdp->data - orig_data;
4564 [ # # ]: 0 : if (off) {
4565 [ # # ]: 0 : if (off > 0)
4566 [ # # ]: 0 : __skb_pull(skb, off);
4567 : 0 : else if (off < 0)
4568 : 0 : __skb_push(skb, -off);
4569 : :
4570 : 0 : skb->mac_header += off;
4571 : 0 : skb_reset_network_header(skb);
4572 : : }
4573 : :
4574 : : /* check if bpf_xdp_adjust_tail was used. it can only "shrink"
4575 : : * pckt.
4576 : : */
4577 : 0 : off = orig_data_end - xdp->data_end;
4578 [ # # ]: 0 : if (off != 0) {
4579 : 0 : skb_set_tail_pointer(skb, xdp->data_end - xdp->data);
4580 : 0 : skb->len -= off;
4581 : :
4582 : : }
4583 : :
4584 : : /* check if XDP changed eth hdr such SKB needs update */
4585 : 0 : eth = (struct ethhdr *)xdp->data;
4586 [ # # # # ]: 0 : if ((orig_eth_type != eth->h_proto) ||
4587 : : (orig_bcast != is_multicast_ether_addr_64bits(eth->h_dest))) {
4588 : 0 : __skb_push(skb, ETH_HLEN);
4589 : 0 : skb->protocol = eth_type_trans(skb, skb->dev);
4590 : : }
4591 : :
4592 [ # # # # : 0 : switch (act) {
# ]
4593 : 0 : case XDP_REDIRECT:
4594 : : case XDP_TX:
4595 : 0 : __skb_push(skb, mac_len);
4596 : : break;
4597 : 0 : case XDP_PASS:
4598 : 0 : metalen = xdp->data - xdp->data_meta;
4599 [ # # ]: 0 : if (metalen)
4600 : 0 : skb_metadata_set(skb, metalen);
4601 : : break;
4602 : 0 : default:
4603 : 0 : bpf_warn_invalid_xdp_action(act);
4604 : : /* fall through */
4605 : 0 : case XDP_ABORTED:
4606 : 0 : trace_xdp_exception(skb->dev, xdp_prog, act);
4607 : : /* fall through */
4608 : : case XDP_DROP:
4609 : 0 : do_drop:
4610 : 0 : kfree_skb(skb);
4611 : 0 : break;
4612 : : }
4613 : :
4614 : 0 : return act;
4615 : : }
4616 : :
4617 : : /* When doing generic XDP we have to bypass the qdisc layer and the
4618 : : * network taps in order to match in-driver-XDP behavior.
4619 : : */
4620 : 0 : void generic_xdp_tx(struct sk_buff *skb, struct bpf_prog *xdp_prog)
4621 : : {
4622 : 0 : struct net_device *dev = skb->dev;
4623 : 0 : struct netdev_queue *txq;
4624 : 0 : bool free_skb = true;
4625 : 0 : int cpu, rc;
4626 : :
4627 : 0 : txq = netdev_core_pick_tx(dev, skb, NULL);
4628 [ # # ]: 0 : cpu = smp_processor_id();
4629 [ # # ]: 0 : HARD_TX_LOCK(dev, txq, cpu);
4630 [ # # ]: 0 : if (!netif_xmit_stopped(txq)) {
4631 : 0 : rc = netdev_start_xmit(skb, dev, txq, 0);
4632 [ # # ]: 0 : if (dev_xmit_complete(rc))
4633 : : free_skb = false;
4634 : : }
4635 [ # # ]: 0 : HARD_TX_UNLOCK(dev, txq);
4636 [ # # ]: 0 : if (free_skb) {
4637 : 0 : trace_xdp_exception(dev, xdp_prog, XDP_TX);
4638 : 0 : kfree_skb(skb);
4639 : : }
4640 : 0 : }
4641 : : EXPORT_SYMBOL_GPL(generic_xdp_tx);
4642 : :
4643 : : static DEFINE_STATIC_KEY_FALSE(generic_xdp_needed_key);
4644 : :
4645 : 0 : int do_xdp_generic(struct bpf_prog *xdp_prog, struct sk_buff *skb)
4646 : : {
4647 [ # # ]: 0 : if (xdp_prog) {
4648 : 0 : struct xdp_buff xdp;
4649 : 0 : u32 act;
4650 : 0 : int err;
4651 : :
4652 : 0 : act = netif_receive_generic_xdp(skb, &xdp, xdp_prog);
4653 [ # # ]: 0 : if (act != XDP_PASS) {
4654 [ # # # ]: 0 : switch (act) {
4655 : 0 : case XDP_REDIRECT:
4656 : 0 : err = xdp_do_generic_redirect(skb->dev, skb,
4657 : : &xdp, xdp_prog);
4658 [ # # ]: 0 : if (err)
4659 : 0 : goto out_redir;
4660 : : break;
4661 : 0 : case XDP_TX:
4662 : 0 : generic_xdp_tx(skb, xdp_prog);
4663 : 0 : break;
4664 : : }
4665 : 0 : return XDP_DROP;
4666 : : }
4667 : : }
4668 : : return XDP_PASS;
4669 : : out_redir:
4670 : 0 : kfree_skb(skb);
4671 : 0 : return XDP_DROP;
4672 : : }
4673 : : EXPORT_SYMBOL_GPL(do_xdp_generic);
4674 : :
4675 : 0 : static int netif_rx_internal(struct sk_buff *skb)
4676 : : {
4677 : 0 : int ret;
4678 : :
4679 [ # # # # : 0 : net_timestamp_check(netdev_tstamp_prequeue, skb);
# # # # ]
4680 : :
4681 : 0 : trace_netif_rx(skb);
4682 : :
4683 : : #ifdef CONFIG_RPS
4684 [ # # # # ]: 0 : if (static_branch_unlikely(&rps_needed)) {
4685 : 0 : struct rps_dev_flow voidflow, *rflow = &voidflow;
4686 : 0 : int cpu;
4687 : :
4688 : 0 : preempt_disable();
4689 : 0 : rcu_read_lock();
4690 : :
4691 : 0 : cpu = get_rps_cpu(skb->dev, skb, &rflow);
4692 [ # # ]: 0 : if (cpu < 0)
4693 : 0 : cpu = smp_processor_id();
4694 : :
4695 : 0 : ret = enqueue_to_backlog(skb, cpu, &rflow->last_qtail);
4696 : :
4697 : 0 : rcu_read_unlock();
4698 : 0 : preempt_enable();
4699 : : } else
4700 : : #endif
4701 : : {
4702 : 0 : unsigned int qtail;
4703 : :
4704 : 0 : ret = enqueue_to_backlog(skb, get_cpu(), &qtail);
4705 : 0 : put_cpu();
4706 : : }
4707 : 0 : return ret;
4708 : : }
4709 : :
4710 : : /**
4711 : : * netif_rx - post buffer to the network code
4712 : : * @skb: buffer to post
4713 : : *
4714 : : * This function receives a packet from a device driver and queues it for
4715 : : * the upper (protocol) levels to process. It always succeeds. The buffer
4716 : : * may be dropped during processing for congestion control or by the
4717 : : * protocol layers.
4718 : : *
4719 : : * return values:
4720 : : * NET_RX_SUCCESS (no congestion)
4721 : : * NET_RX_DROP (packet was dropped)
4722 : : *
4723 : : */
4724 : :
4725 : 0 : int netif_rx(struct sk_buff *skb)
4726 : : {
4727 : 0 : int ret;
4728 : :
4729 : 0 : trace_netif_rx_entry(skb);
4730 : :
4731 : 0 : ret = netif_rx_internal(skb);
4732 : 0 : trace_netif_rx_exit(ret);
4733 : :
4734 : 0 : return ret;
4735 : : }
4736 : : EXPORT_SYMBOL(netif_rx);
4737 : :
4738 : 0 : int netif_rx_ni(struct sk_buff *skb)
4739 : : {
4740 : 0 : int err;
4741 : :
4742 : 0 : trace_netif_rx_ni_entry(skb);
4743 : :
4744 : 0 : preempt_disable();
4745 : 0 : err = netif_rx_internal(skb);
4746 [ # # ]: 0 : if (local_softirq_pending())
4747 : 0 : do_softirq();
4748 : 0 : preempt_enable();
4749 : 0 : trace_netif_rx_ni_exit(err);
4750 : :
4751 : 0 : return err;
4752 : : }
4753 : : EXPORT_SYMBOL(netif_rx_ni);
4754 : :
4755 : 0 : static __latent_entropy void net_tx_action(struct softirq_action *h)
4756 : : {
4757 : 0 : struct softnet_data *sd = this_cpu_ptr(&softnet_data);
4758 : :
4759 [ # # ]: 0 : if (sd->completion_queue) {
4760 : 0 : struct sk_buff *clist;
4761 : :
4762 : 0 : local_irq_disable();
4763 : 0 : clist = sd->completion_queue;
4764 : 0 : sd->completion_queue = NULL;
4765 : 0 : local_irq_enable();
4766 : :
4767 [ # # ]: 0 : while (clist) {
4768 : 0 : struct sk_buff *skb = clist;
4769 : :
4770 : 0 : clist = clist->next;
4771 : :
4772 [ # # ]: 0 : WARN_ON(refcount_read(&skb->users));
4773 [ # # ]: 0 : if (likely(get_kfree_skb_cb(skb)->reason == SKB_REASON_CONSUMED))
4774 : 0 : trace_consume_skb(skb);
4775 : : else
4776 : 0 : trace_kfree_skb(skb, net_tx_action);
4777 : :
4778 [ # # ]: 0 : if (skb->fclone != SKB_FCLONE_UNAVAILABLE)
4779 : 0 : __kfree_skb(skb);
4780 : : else
4781 : 0 : __kfree_skb_defer(skb);
4782 : : }
4783 : :
4784 : 0 : __kfree_skb_flush();
4785 : : }
4786 : :
4787 [ # # ]: 0 : if (sd->output_queue) {
4788 : 0 : struct Qdisc *head;
4789 : :
4790 : 0 : local_irq_disable();
4791 : 0 : head = sd->output_queue;
4792 : 0 : sd->output_queue = NULL;
4793 : 0 : sd->output_queue_tailp = &sd->output_queue;
4794 : 0 : local_irq_enable();
4795 : :
4796 [ # # ]: 0 : while (head) {
4797 : 0 : struct Qdisc *q = head;
4798 : 0 : spinlock_t *root_lock = NULL;
4799 : :
4800 : 0 : head = head->next_sched;
4801 : :
4802 [ # # ]: 0 : if (!(q->flags & TCQ_F_NOLOCK)) {
4803 : 0 : root_lock = qdisc_lock(q);
4804 : 0 : spin_lock(root_lock);
4805 : : }
4806 : : /* We need to make sure head->next_sched is read
4807 : : * before clearing __QDISC_STATE_SCHED
4808 : : */
4809 : 0 : smp_mb__before_atomic();
4810 : 0 : clear_bit(__QDISC_STATE_SCHED, &q->state);
4811 : 0 : qdisc_run(q);
4812 [ # # ]: 0 : if (root_lock)
4813 : 0 : spin_unlock(root_lock);
4814 : : }
4815 : : }
4816 : :
4817 : 0 : xfrm_dev_backlog(sd);
4818 : 0 : }
4819 : :
4820 : : #if IS_ENABLED(CONFIG_BRIDGE) && IS_ENABLED(CONFIG_ATM_LANE)
4821 : : /* This hook is defined here for ATM LANE */
4822 : : int (*br_fdb_test_addr_hook)(struct net_device *dev,
4823 : : unsigned char *addr) __read_mostly;
4824 : : EXPORT_SYMBOL_GPL(br_fdb_test_addr_hook);
4825 : : #endif
4826 : :
4827 : : static inline struct sk_buff *
4828 : 0 : sch_handle_ingress(struct sk_buff *skb, struct packet_type **pt_prev, int *ret,
4829 : : struct net_device *orig_dev)
4830 : : {
4831 : : #ifdef CONFIG_NET_CLS_ACT
4832 [ # # ]: 0 : struct mini_Qdisc *miniq = rcu_dereference_bh(skb->dev->miniq_ingress);
4833 : 0 : struct tcf_result cl_res;
4834 : :
4835 : : /* If there's at least one ingress present somewhere (so
4836 : : * we get here via enabled static key), remaining devices
4837 : : * that are not configured with an ingress qdisc will bail
4838 : : * out here.
4839 : : */
4840 [ # # ]: 0 : if (!miniq)
4841 : : return skb;
4842 : :
4843 [ # # ]: 0 : if (*pt_prev) {
4844 : 0 : *ret = deliver_skb(skb, *pt_prev, orig_dev);
4845 : 0 : *pt_prev = NULL;
4846 : : }
4847 : :
4848 : 0 : qdisc_skb_cb(skb)->pkt_len = skb->len;
4849 : 0 : skb->tc_at_ingress = 1;
4850 : 0 : mini_qdisc_bstats_cpu_update(miniq, skb);
4851 : :
4852 [ # # # # : 0 : switch (tcf_classify(skb, miniq->filter_list, &cl_res, false)) {
# # ]
4853 : 0 : case TC_ACT_OK:
4854 : : case TC_ACT_RECLASSIFY:
4855 : 0 : skb->tc_index = TC_H_MIN(cl_res.classid);
4856 : 0 : break;
4857 : 0 : case TC_ACT_SHOT:
4858 : 0 : mini_qdisc_qstats_cpu_drop(miniq);
4859 : 0 : kfree_skb(skb);
4860 : 0 : return NULL;
4861 : 0 : case TC_ACT_STOLEN:
4862 : : case TC_ACT_QUEUED:
4863 : : case TC_ACT_TRAP:
4864 : 0 : consume_skb(skb);
4865 : 0 : return NULL;
4866 : 0 : case TC_ACT_REDIRECT:
4867 : : /* skb_mac_header check was done by cls/act_bpf, so
4868 : : * we can safely push the L2 header back before
4869 : : * redirecting to another netdev
4870 : : */
4871 : 0 : __skb_push(skb, skb->mac_len);
4872 : 0 : skb_do_redirect(skb);
4873 : 0 : return NULL;
4874 : : case TC_ACT_CONSUMED:
4875 : : return NULL;
4876 : : default:
4877 : : break;
4878 : : }
4879 : : #endif /* CONFIG_NET_CLS_ACT */
4880 : : return skb;
4881 : : }
4882 : :
4883 : : /**
4884 : : * netdev_is_rx_handler_busy - check if receive handler is registered
4885 : : * @dev: device to check
4886 : : *
4887 : : * Check if a receive handler is already registered for a given device.
4888 : : * Return true if there one.
4889 : : *
4890 : : * The caller must hold the rtnl_mutex.
4891 : : */
4892 : 0 : bool netdev_is_rx_handler_busy(struct net_device *dev)
4893 : : {
4894 [ # # # # ]: 0 : ASSERT_RTNL();
4895 [ # # # # ]: 0 : return dev && rtnl_dereference(dev->rx_handler);
4896 : : }
4897 : : EXPORT_SYMBOL_GPL(netdev_is_rx_handler_busy);
4898 : :
4899 : : /**
4900 : : * netdev_rx_handler_register - register receive handler
4901 : : * @dev: device to register a handler for
4902 : : * @rx_handler: receive handler to register
4903 : : * @rx_handler_data: data pointer that is used by rx handler
4904 : : *
4905 : : * Register a receive handler for a device. This handler will then be
4906 : : * called from __netif_receive_skb. A negative errno code is returned
4907 : : * on a failure.
4908 : : *
4909 : : * The caller must hold the rtnl_mutex.
4910 : : *
4911 : : * For a general description of rx_handler, see enum rx_handler_result.
4912 : : */
4913 : 0 : int netdev_rx_handler_register(struct net_device *dev,
4914 : : rx_handler_func_t *rx_handler,
4915 : : void *rx_handler_data)
4916 : : {
4917 [ # # ]: 0 : if (netdev_is_rx_handler_busy(dev))
4918 : : return -EBUSY;
4919 : :
4920 [ # # ]: 0 : if (dev->priv_flags & IFF_NO_RX_HANDLER)
4921 : : return -EINVAL;
4922 : :
4923 : : /* Note: rx_handler_data must be set before rx_handler */
4924 : 0 : rcu_assign_pointer(dev->rx_handler_data, rx_handler_data);
4925 : 0 : rcu_assign_pointer(dev->rx_handler, rx_handler);
4926 : :
4927 : 0 : return 0;
4928 : : }
4929 : : EXPORT_SYMBOL_GPL(netdev_rx_handler_register);
4930 : :
4931 : : /**
4932 : : * netdev_rx_handler_unregister - unregister receive handler
4933 : : * @dev: device to unregister a handler from
4934 : : *
4935 : : * Unregister a receive handler from a device.
4936 : : *
4937 : : * The caller must hold the rtnl_mutex.
4938 : : */
4939 : 0 : void netdev_rx_handler_unregister(struct net_device *dev)
4940 : : {
4941 : :
4942 [ # # # # ]: 0 : ASSERT_RTNL();
4943 : 0 : RCU_INIT_POINTER(dev->rx_handler, NULL);
4944 : : /* a reader seeing a non NULL rx_handler in a rcu_read_lock()
4945 : : * section has a guarantee to see a non NULL rx_handler_data
4946 : : * as well.
4947 : : */
4948 : 0 : synchronize_net();
4949 : 0 : RCU_INIT_POINTER(dev->rx_handler_data, NULL);
4950 : 0 : }
4951 : : EXPORT_SYMBOL_GPL(netdev_rx_handler_unregister);
4952 : :
4953 : : /*
4954 : : * Limit the use of PFMEMALLOC reserves to those protocols that implement
4955 : : * the special handling of PFMEMALLOC skbs.
4956 : : */
4957 : 0 : static bool skb_pfmemalloc_protocol(struct sk_buff *skb)
4958 : : {
4959 : 0 : switch (skb->protocol) {
4960 : : case htons(ETH_P_ARP):
4961 : : case htons(ETH_P_IP):
4962 : : case htons(ETH_P_IPV6):
4963 : : case htons(ETH_P_8021Q):
4964 : : case htons(ETH_P_8021AD):
4965 : : return true;
4966 : : default:
4967 : 0 : return false;
4968 : : }
4969 : : }
4970 : :
4971 : 0 : static inline int nf_ingress(struct sk_buff *skb, struct packet_type **pt_prev,
4972 : : int *ret, struct net_device *orig_dev)
4973 : : {
4974 [ # # # # ]: 0 : if (nf_hook_ingress_active(skb)) {
4975 : 0 : int ingress_retval;
4976 : :
4977 [ - - ]: 0 : if (*pt_prev) {
4978 : 0 : *ret = deliver_skb(skb, *pt_prev, orig_dev);
4979 : 0 : *pt_prev = NULL;
4980 : : }
4981 : :
4982 : 0 : rcu_read_lock();
4983 : 0 : ingress_retval = nf_hook_ingress(skb);
4984 : 0 : rcu_read_unlock();
4985 : 0 : return ingress_retval;
4986 : : }
4987 : : return 0;
4988 : : }
4989 : :
4990 : 0 : static int __netif_receive_skb_core(struct sk_buff *skb, bool pfmemalloc,
4991 : : struct packet_type **ppt_prev)
4992 : : {
4993 : 0 : struct packet_type *ptype, *pt_prev;
4994 : 0 : rx_handler_func_t *rx_handler;
4995 : 0 : struct net_device *orig_dev;
4996 : 0 : bool deliver_exact = false;
4997 : 0 : int ret = NET_RX_DROP;
4998 : 0 : __be16 type;
4999 : :
5000 [ # # # # : 0 : net_timestamp_check(!netdev_tstamp_prequeue, skb);
# # # # ]
5001 : :
5002 : 0 : trace_netif_receive_skb(skb);
5003 : :
5004 : 0 : orig_dev = skb->dev;
5005 : :
5006 [ # # ]: 0 : skb_reset_network_header(skb);
5007 [ # # ]: 0 : if (!skb_transport_header_was_set(skb))
5008 : 0 : skb_reset_transport_header(skb);
5009 : 0 : skb_reset_mac_len(skb);
5010 : :
5011 : 0 : pt_prev = NULL;
5012 : :
5013 : 0 : another_round:
5014 : 0 : skb->skb_iif = skb->dev->ifindex;
5015 : :
5016 [ # # ]: 0 : __this_cpu_inc(softnet_data.processed);
5017 : :
5018 [ # # # # ]: 0 : if (static_branch_unlikely(&generic_xdp_needed_key)) {
5019 : 0 : int ret2;
5020 : :
5021 : 0 : preempt_disable();
5022 : 0 : ret2 = do_xdp_generic(rcu_dereference(skb->dev->xdp_prog), skb);
5023 : 0 : preempt_enable();
5024 : :
5025 [ # # ]: 0 : if (ret2 != XDP_PASS)
5026 : : return NET_RX_DROP;
5027 : 0 : skb_reset_mac_len(skb);
5028 : : }
5029 : :
5030 [ # # ]: 0 : if (skb->protocol == cpu_to_be16(ETH_P_8021Q) ||
5031 : : skb->protocol == cpu_to_be16(ETH_P_8021AD)) {
5032 : 0 : skb = skb_vlan_untag(skb);
5033 [ # # ]: 0 : if (unlikely(!skb))
5034 : 0 : goto out;
5035 : : }
5036 : :
5037 [ # # ]: 0 : if (skb_skip_tc_classify(skb))
5038 : 0 : goto skip_classify;
5039 : :
5040 [ # # ]: 0 : if (pfmemalloc)
5041 : 0 : goto skip_taps;
5042 : :
5043 [ # # ]: 0 : list_for_each_entry_rcu(ptype, &ptype_all, list) {
5044 [ # # ]: 0 : if (pt_prev)
5045 : 0 : ret = deliver_skb(skb, pt_prev, orig_dev);
5046 : 0 : pt_prev = ptype;
5047 : : }
5048 : :
5049 [ # # ]: 0 : list_for_each_entry_rcu(ptype, &skb->dev->ptype_all, list) {
5050 [ # # ]: 0 : if (pt_prev)
5051 : 0 : ret = deliver_skb(skb, pt_prev, orig_dev);
5052 : 0 : pt_prev = ptype;
5053 : : }
5054 : :
5055 : 0 : skip_taps:
5056 : : #ifdef CONFIG_NET_INGRESS
5057 [ # # # # ]: 0 : if (static_branch_unlikely(&ingress_needed_key)) {
5058 : 0 : skb = sch_handle_ingress(skb, &pt_prev, &ret, orig_dev);
5059 [ # # ]: 0 : if (!skb)
5060 : 0 : goto out;
5061 : :
5062 [ # # ]: 0 : if (nf_ingress(skb, &pt_prev, &ret, orig_dev) < 0)
5063 : 0 : goto out;
5064 : : }
5065 : : #endif
5066 : 0 : skb_reset_redirect(skb);
5067 : 0 : skip_classify:
5068 [ # # # # ]: 0 : if (pfmemalloc && !skb_pfmemalloc_protocol(skb))
5069 : 0 : goto drop;
5070 : :
5071 [ # # ]: 0 : if (skb_vlan_tag_present(skb)) {
5072 [ # # ]: 0 : if (pt_prev) {
5073 : 0 : ret = deliver_skb(skb, pt_prev, orig_dev);
5074 : 0 : pt_prev = NULL;
5075 : : }
5076 [ # # ]: 0 : if (vlan_do_receive(&skb))
5077 : : goto another_round;
5078 [ # # ]: 0 : else if (unlikely(!skb))
5079 : 0 : goto out;
5080 : : }
5081 : :
5082 [ # # ]: 0 : rx_handler = rcu_dereference(skb->dev->rx_handler);
5083 [ # # ]: 0 : if (rx_handler) {
5084 [ # # ]: 0 : if (pt_prev) {
5085 : 0 : ret = deliver_skb(skb, pt_prev, orig_dev);
5086 : 0 : pt_prev = NULL;
5087 : : }
5088 [ # # # # : 0 : switch (rx_handler(&skb)) {
# ]
5089 : 0 : case RX_HANDLER_CONSUMED:
5090 : 0 : ret = NET_RX_SUCCESS;
5091 : 0 : goto out;
5092 : 0 : case RX_HANDLER_ANOTHER:
5093 : 0 : goto another_round;
5094 : 0 : case RX_HANDLER_EXACT:
5095 : 0 : deliver_exact = true;
5096 : : case RX_HANDLER_PASS:
5097 : : break;
5098 : 0 : default:
5099 : 0 : BUG();
5100 : : }
5101 : 0 : }
5102 : :
5103 [ # # ]: 0 : if (unlikely(skb_vlan_tag_present(skb))) {
5104 : 0 : check_vlan_id:
5105 [ # # ]: 0 : if (skb_vlan_tag_get_id(skb)) {
5106 : : /* Vlan id is non 0 and vlan_do_receive() above couldn't
5107 : : * find vlan device.
5108 : : */
5109 : 0 : skb->pkt_type = PACKET_OTHERHOST;
5110 [ # # ]: 0 : } else if (skb->protocol == cpu_to_be16(ETH_P_8021Q) ||
5111 : : skb->protocol == cpu_to_be16(ETH_P_8021AD)) {
5112 : : /* Outer header is 802.1P with vlan 0, inner header is
5113 : : * 802.1Q or 802.1AD and vlan_do_receive() above could
5114 : : * not find vlan dev for vlan id 0.
5115 : : */
5116 : 0 : __vlan_hwaccel_clear_tag(skb);
5117 : 0 : skb = skb_vlan_untag(skb);
5118 [ # # ]: 0 : if (unlikely(!skb))
5119 : 0 : goto out;
5120 : 0 : if (vlan_do_receive(&skb))
5121 : : /* After stripping off 802.1P header with vlan 0
5122 : : * vlan dev is found for inner header.
5123 : : */
5124 : : goto another_round;
5125 : 0 : else if (unlikely(!skb))
5126 : : goto out;
5127 : : else
5128 : : /* We have stripped outer 802.1P vlan 0 header.
5129 : : * But could not find vlan dev.
5130 : : * check again for vlan id to set OTHERHOST.
5131 : : */
5132 : 0 : goto check_vlan_id;
5133 : : }
5134 : : /* Note: we might in the future use prio bits
5135 : : * and set skb->priority like in vlan_do_receive()
5136 : : * For the time being, just ignore Priority Code Point
5137 : : */
5138 : 0 : __vlan_hwaccel_clear_tag(skb);
5139 : : }
5140 : :
5141 : 0 : type = skb->protocol;
5142 : :
5143 : : /* deliver only exact match when indicated */
5144 [ # # ]: 0 : if (likely(!deliver_exact)) {
5145 : 0 : deliver_ptype_list_skb(skb, &pt_prev, orig_dev, type,
5146 : 0 : &ptype_base[ntohs(type) &
5147 : : PTYPE_HASH_MASK]);
5148 : : }
5149 : :
5150 : 0 : deliver_ptype_list_skb(skb, &pt_prev, orig_dev, type,
5151 : : &orig_dev->ptype_specific);
5152 : :
5153 [ # # ]: 0 : if (unlikely(skb->dev != orig_dev)) {
5154 : 0 : deliver_ptype_list_skb(skb, &pt_prev, orig_dev, type,
5155 : : &skb->dev->ptype_specific);
5156 : : }
5157 : :
5158 [ # # ]: 0 : if (pt_prev) {
5159 [ # # ]: 0 : if (unlikely(skb_orphan_frags_rx(skb, GFP_ATOMIC)))
5160 : 0 : goto drop;
5161 : 0 : *ppt_prev = pt_prev;
5162 : : } else {
5163 : 0 : drop:
5164 [ # # ]: 0 : if (!deliver_exact)
5165 : 0 : atomic_long_inc(&skb->dev->rx_dropped);
5166 : : else
5167 : 0 : atomic_long_inc(&skb->dev->rx_nohandler);
5168 : 0 : kfree_skb(skb);
5169 : : /* Jamal, now you will not able to escape explaining
5170 : : * me how you were going to use this. :-)
5171 : : */
5172 : 0 : ret = NET_RX_DROP;
5173 : : }
5174 : :
5175 : 0 : out:
5176 : 0 : return ret;
5177 : : }
5178 : :
5179 : 0 : static int __netif_receive_skb_one_core(struct sk_buff *skb, bool pfmemalloc)
5180 : : {
5181 : 0 : struct net_device *orig_dev = skb->dev;
5182 : 0 : struct packet_type *pt_prev = NULL;
5183 : 0 : int ret;
5184 : :
5185 : 0 : ret = __netif_receive_skb_core(skb, pfmemalloc, &pt_prev);
5186 [ # # ]: 0 : if (pt_prev)
5187 [ # # # # ]: 0 : ret = INDIRECT_CALL_INET(pt_prev->func, ipv6_rcv, ip_rcv, skb,
5188 : : skb->dev, pt_prev, orig_dev);
5189 : 0 : return ret;
5190 : : }
5191 : :
5192 : : /**
5193 : : * netif_receive_skb_core - special purpose version of netif_receive_skb
5194 : : * @skb: buffer to process
5195 : : *
5196 : : * More direct receive version of netif_receive_skb(). It should
5197 : : * only be used by callers that have a need to skip RPS and Generic XDP.
5198 : : * Caller must also take care of handling if ``(page_is_)pfmemalloc``.
5199 : : *
5200 : : * This function may only be called from softirq context and interrupts
5201 : : * should be enabled.
5202 : : *
5203 : : * Return values (usually ignored):
5204 : : * NET_RX_SUCCESS: no congestion
5205 : : * NET_RX_DROP: packet was dropped
5206 : : */
5207 : 0 : int netif_receive_skb_core(struct sk_buff *skb)
5208 : : {
5209 : 0 : int ret;
5210 : :
5211 : 0 : rcu_read_lock();
5212 : 0 : ret = __netif_receive_skb_one_core(skb, false);
5213 : 0 : rcu_read_unlock();
5214 : :
5215 : 0 : return ret;
5216 : : }
5217 : : EXPORT_SYMBOL(netif_receive_skb_core);
5218 : :
5219 : 0 : static inline void __netif_receive_skb_list_ptype(struct list_head *head,
5220 : : struct packet_type *pt_prev,
5221 : : struct net_device *orig_dev)
5222 : : {
5223 : 0 : struct sk_buff *skb, *next;
5224 : :
5225 [ # # ]: 0 : if (!pt_prev)
5226 : : return;
5227 [ # # ]: 0 : if (list_empty(head))
5228 : : return;
5229 [ # # ]: 0 : if (pt_prev->list_func != NULL)
5230 [ # # # # ]: 0 : INDIRECT_CALL_INET(pt_prev->list_func, ipv6_list_rcv,
5231 : : ip_list_rcv, head, pt_prev, orig_dev);
5232 : : else
5233 [ # # ]: 0 : list_for_each_entry_safe(skb, next, head, list) {
5234 : 0 : skb_list_del_init(skb);
5235 : 0 : pt_prev->func(skb, skb->dev, pt_prev, orig_dev);
5236 : : }
5237 : : }
5238 : :
5239 : 0 : static void __netif_receive_skb_list_core(struct list_head *head, bool pfmemalloc)
5240 : : {
5241 : : /* Fast-path assumptions:
5242 : : * - There is no RX handler.
5243 : : * - Only one packet_type matches.
5244 : : * If either of these fails, we will end up doing some per-packet
5245 : : * processing in-line, then handling the 'last ptype' for the whole
5246 : : * sublist. This can't cause out-of-order delivery to any single ptype,
5247 : : * because the 'last ptype' must be constant across the sublist, and all
5248 : : * other ptypes are handled per-packet.
5249 : : */
5250 : : /* Current (common) ptype of sublist */
5251 : 0 : struct packet_type *pt_curr = NULL;
5252 : : /* Current (common) orig_dev of sublist */
5253 : 0 : struct net_device *od_curr = NULL;
5254 : 0 : struct list_head sublist;
5255 : 0 : struct sk_buff *skb, *next;
5256 : :
5257 : 0 : INIT_LIST_HEAD(&sublist);
5258 [ # # ]: 0 : list_for_each_entry_safe(skb, next, head, list) {
5259 : 0 : struct net_device *orig_dev = skb->dev;
5260 : 0 : struct packet_type *pt_prev = NULL;
5261 : :
5262 : 0 : skb_list_del_init(skb);
5263 : 0 : __netif_receive_skb_core(skb, pfmemalloc, &pt_prev);
5264 [ # # ]: 0 : if (!pt_prev)
5265 : 0 : continue;
5266 [ # # # # ]: 0 : if (pt_curr != pt_prev || od_curr != orig_dev) {
5267 : : /* dispatch old sublist */
5268 : 0 : __netif_receive_skb_list_ptype(&sublist, pt_curr, od_curr);
5269 : : /* start new sublist */
5270 : 0 : INIT_LIST_HEAD(&sublist);
5271 : 0 : pt_curr = pt_prev;
5272 : 0 : od_curr = orig_dev;
5273 : : }
5274 : 0 : list_add_tail(&skb->list, &sublist);
5275 : : }
5276 : :
5277 : : /* dispatch final sublist */
5278 : 0 : __netif_receive_skb_list_ptype(&sublist, pt_curr, od_curr);
5279 : 0 : }
5280 : :
5281 : 0 : static int __netif_receive_skb(struct sk_buff *skb)
5282 : : {
5283 : 0 : int ret;
5284 : :
5285 [ # # # # : 0 : if (sk_memalloc_socks() && skb_pfmemalloc(skb)) {
# # ]
5286 : 0 : unsigned int noreclaim_flag;
5287 : :
5288 : : /*
5289 : : * PFMEMALLOC skbs are special, they should
5290 : : * - be delivered to SOCK_MEMALLOC sockets only
5291 : : * - stay away from userspace
5292 : : * - have bounded memory usage
5293 : : *
5294 : : * Use PF_MEMALLOC as this saves us from propagating the allocation
5295 : : * context down to all allocation sites.
5296 : : */
5297 : 0 : noreclaim_flag = memalloc_noreclaim_save();
5298 : 0 : ret = __netif_receive_skb_one_core(skb, true);
5299 : 0 : memalloc_noreclaim_restore(noreclaim_flag);
5300 : : } else
5301 : 0 : ret = __netif_receive_skb_one_core(skb, false);
5302 : :
5303 : 0 : return ret;
5304 : : }
5305 : :
5306 : 0 : static void __netif_receive_skb_list(struct list_head *head)
5307 : : {
5308 : 0 : unsigned long noreclaim_flag = 0;
5309 : 0 : struct sk_buff *skb, *next;
5310 : 0 : bool pfmemalloc = false; /* Is current sublist PF_MEMALLOC? */
5311 : :
5312 [ # # ]: 0 : list_for_each_entry_safe(skb, next, head, list) {
5313 [ # # # # : 0 : if ((sk_memalloc_socks() && skb_pfmemalloc(skb)) != pfmemalloc) {
# # # # ]
5314 : 0 : struct list_head sublist;
5315 : :
5316 : : /* Handle the previous sublist */
5317 [ # # ]: 0 : list_cut_before(&sublist, head, &skb->list);
5318 [ # # ]: 0 : if (!list_empty(&sublist))
5319 : 0 : __netif_receive_skb_list_core(&sublist, pfmemalloc);
5320 : 0 : pfmemalloc = !pfmemalloc;
5321 : : /* See comments in __netif_receive_skb */
5322 [ # # ]: 0 : if (pfmemalloc)
5323 : 0 : noreclaim_flag = memalloc_noreclaim_save();
5324 : : else
5325 : 0 : memalloc_noreclaim_restore(noreclaim_flag);
5326 : : }
5327 : : }
5328 : : /* Handle the remaining sublist */
5329 [ # # ]: 0 : if (!list_empty(head))
5330 : 0 : __netif_receive_skb_list_core(head, pfmemalloc);
5331 : : /* Restore pflags */
5332 [ # # ]: 0 : if (pfmemalloc)
5333 : 0 : memalloc_noreclaim_restore(noreclaim_flag);
5334 : 0 : }
5335 : :
5336 : 0 : static int generic_xdp_install(struct net_device *dev, struct netdev_bpf *xdp)
5337 : : {
5338 : 0 : struct bpf_prog *old = rtnl_dereference(dev->xdp_prog);
5339 : 0 : struct bpf_prog *new = xdp->prog;
5340 : 0 : int ret = 0;
5341 : :
5342 [ # # # ]: 0 : switch (xdp->command) {
5343 : 0 : case XDP_SETUP_PROG:
5344 [ # # ]: 0 : rcu_assign_pointer(dev->xdp_prog, new);
5345 : 0 : if (old)
5346 : : bpf_prog_put(old);
5347 : :
5348 [ # # ]: 0 : if (old && !new) {
5349 : 0 : static_branch_dec(&generic_xdp_needed_key);
5350 [ # # ]: 0 : } else if (new && !old) {
5351 : 0 : static_branch_inc(&generic_xdp_needed_key);
5352 : 0 : dev_disable_lro(dev);
5353 : 0 : dev_disable_gro_hw(dev);
5354 : : }
5355 : : break;
5356 : :
5357 : 0 : case XDP_QUERY_PROG:
5358 [ # # ]: 0 : xdp->prog_id = old ? old->aux->id : 0;
5359 : 0 : break;
5360 : :
5361 : : default:
5362 : : ret = -EINVAL;
5363 : : break;
5364 : : }
5365 : :
5366 : 0 : return ret;
5367 : : }
5368 : :
5369 : 0 : static int netif_receive_skb_internal(struct sk_buff *skb)
5370 : : {
5371 : 0 : int ret;
5372 : :
5373 [ # # # # : 0 : net_timestamp_check(netdev_tstamp_prequeue, skb);
# # # # ]
5374 : :
5375 : 0 : if (skb_defer_rx_timestamp(skb))
5376 : : return NET_RX_SUCCESS;
5377 : :
5378 : 0 : rcu_read_lock();
5379 : : #ifdef CONFIG_RPS
5380 [ # # # # ]: 0 : if (static_branch_unlikely(&rps_needed)) {
5381 : 0 : struct rps_dev_flow voidflow, *rflow = &voidflow;
5382 : 0 : int cpu = get_rps_cpu(skb->dev, skb, &rflow);
5383 : :
5384 [ # # ]: 0 : if (cpu >= 0) {
5385 : 0 : ret = enqueue_to_backlog(skb, cpu, &rflow->last_qtail);
5386 : 0 : rcu_read_unlock();
5387 : 0 : return ret;
5388 : : }
5389 : : }
5390 : : #endif
5391 : 0 : ret = __netif_receive_skb(skb);
5392 : 0 : rcu_read_unlock();
5393 : 0 : return ret;
5394 : : }
5395 : :
5396 : 0 : static void netif_receive_skb_list_internal(struct list_head *head)
5397 : : {
5398 : 0 : struct sk_buff *skb, *next;
5399 : 0 : struct list_head sublist;
5400 : :
5401 : 0 : INIT_LIST_HEAD(&sublist);
5402 [ # # ]: 0 : list_for_each_entry_safe(skb, next, head, list) {
5403 [ # # # # : 0 : net_timestamp_check(netdev_tstamp_prequeue, skb);
# # # # ]
5404 : 0 : skb_list_del_init(skb);
5405 : 0 : if (!skb_defer_rx_timestamp(skb))
5406 : 0 : list_add_tail(&skb->list, &sublist);
5407 : : }
5408 [ # # ]: 0 : list_splice_init(&sublist, head);
5409 : :
5410 : 0 : rcu_read_lock();
5411 : : #ifdef CONFIG_RPS
5412 [ # # # # ]: 0 : if (static_branch_unlikely(&rps_needed)) {
5413 [ # # ]: 0 : list_for_each_entry_safe(skb, next, head, list) {
5414 : 0 : struct rps_dev_flow voidflow, *rflow = &voidflow;
5415 : 0 : int cpu = get_rps_cpu(skb->dev, skb, &rflow);
5416 : :
5417 [ # # ]: 0 : if (cpu >= 0) {
5418 : : /* Will be handled, remove from list */
5419 : 0 : skb_list_del_init(skb);
5420 : 0 : enqueue_to_backlog(skb, cpu, &rflow->last_qtail);
5421 : : }
5422 : : }
5423 : : }
5424 : : #endif
5425 : 0 : __netif_receive_skb_list(head);
5426 : 0 : rcu_read_unlock();
5427 : 0 : }
5428 : :
5429 : : /**
5430 : : * netif_receive_skb - process receive buffer from network
5431 : : * @skb: buffer to process
5432 : : *
5433 : : * netif_receive_skb() is the main receive data processing function.
5434 : : * It always succeeds. The buffer may be dropped during processing
5435 : : * for congestion control or by the protocol layers.
5436 : : *
5437 : : * This function may only be called from softirq context and interrupts
5438 : : * should be enabled.
5439 : : *
5440 : : * Return values (usually ignored):
5441 : : * NET_RX_SUCCESS: no congestion
5442 : : * NET_RX_DROP: packet was dropped
5443 : : */
5444 : 0 : int netif_receive_skb(struct sk_buff *skb)
5445 : : {
5446 : 0 : int ret;
5447 : :
5448 : 0 : trace_netif_receive_skb_entry(skb);
5449 : :
5450 : 0 : ret = netif_receive_skb_internal(skb);
5451 : 0 : trace_netif_receive_skb_exit(ret);
5452 : :
5453 : 0 : return ret;
5454 : : }
5455 : : EXPORT_SYMBOL(netif_receive_skb);
5456 : :
5457 : : /**
5458 : : * netif_receive_skb_list - process many receive buffers from network
5459 : : * @head: list of skbs to process.
5460 : : *
5461 : : * Since return value of netif_receive_skb() is normally ignored, and
5462 : : * wouldn't be meaningful for a list, this function returns void.
5463 : : *
5464 : : * This function may only be called from softirq context and interrupts
5465 : : * should be enabled.
5466 : : */
5467 : 0 : void netif_receive_skb_list(struct list_head *head)
5468 : : {
5469 : 0 : struct sk_buff *skb;
5470 : :
5471 [ # # ]: 0 : if (list_empty(head))
5472 : : return;
5473 [ # # ]: 0 : if (trace_netif_receive_skb_list_entry_enabled()) {
5474 [ - - ]: 0 : list_for_each_entry(skb, head, list)
5475 : 0 : trace_netif_receive_skb_list_entry(skb);
5476 : : }
5477 : 0 : netif_receive_skb_list_internal(head);
5478 : 0 : trace_netif_receive_skb_list_exit(0);
5479 : : }
5480 : : EXPORT_SYMBOL(netif_receive_skb_list);
5481 : :
5482 : : DEFINE_PER_CPU(struct work_struct, flush_works);
5483 : :
5484 : : /* Network device is going away, flush any packets still pending */
5485 : 0 : static void flush_backlog(struct work_struct *work)
5486 : : {
5487 : 0 : struct sk_buff *skb, *tmp;
5488 : 0 : struct softnet_data *sd;
5489 : :
5490 : 0 : local_bh_disable();
5491 : 0 : sd = this_cpu_ptr(&softnet_data);
5492 : :
5493 : 0 : local_irq_disable();
5494 : 0 : rps_lock(sd);
5495 [ # # ]: 0 : skb_queue_walk_safe(&sd->input_pkt_queue, skb, tmp) {
5496 [ # # ]: 0 : if (skb->dev->reg_state == NETREG_UNREGISTERING) {
5497 : 0 : __skb_unlink(skb, &sd->input_pkt_queue);
5498 : 0 : kfree_skb(skb);
5499 : 0 : input_queue_head_incr(sd);
5500 : : }
5501 : : }
5502 : 0 : rps_unlock(sd);
5503 : 0 : local_irq_enable();
5504 : :
5505 [ # # ]: 0 : skb_queue_walk_safe(&sd->process_queue, skb, tmp) {
5506 [ # # ]: 0 : if (skb->dev->reg_state == NETREG_UNREGISTERING) {
5507 : 0 : __skb_unlink(skb, &sd->process_queue);
5508 : 0 : kfree_skb(skb);
5509 : 0 : input_queue_head_incr(sd);
5510 : : }
5511 : : }
5512 : 0 : local_bh_enable();
5513 : 0 : }
5514 : :
5515 : 0 : static void flush_all_backlogs(void)
5516 : : {
5517 : 0 : unsigned int cpu;
5518 : :
5519 : 0 : get_online_cpus();
5520 : :
5521 [ # # ]: 0 : for_each_online_cpu(cpu)
5522 : 0 : queue_work_on(cpu, system_highpri_wq,
5523 : 0 : per_cpu_ptr(&flush_works, cpu));
5524 : :
5525 [ # # ]: 0 : for_each_online_cpu(cpu)
5526 : 0 : flush_work(per_cpu_ptr(&flush_works, cpu));
5527 : :
5528 : 0 : put_online_cpus();
5529 : 0 : }
5530 : :
5531 : : /* Pass the currently batched GRO_NORMAL SKBs up to the stack. */
5532 : 3 : static void gro_normal_list(struct napi_struct *napi)
5533 : : {
5534 : 3 : if (!napi->rx_count)
5535 : : return;
5536 : 0 : netif_receive_skb_list_internal(&napi->rx_list);
5537 : 0 : INIT_LIST_HEAD(&napi->rx_list);
5538 : 0 : napi->rx_count = 0;
5539 : : }
5540 : :
5541 : : /* Queue one GRO_NORMAL SKB up for list processing. If batch size exceeded,
5542 : : * pass the whole batch up to the stack.
5543 : : */
5544 : 0 : static void gro_normal_one(struct napi_struct *napi, struct sk_buff *skb)
5545 : : {
5546 [ # # ]: 0 : list_add_tail(&skb->list, &napi->rx_list);
5547 [ # # ]: 0 : if (++napi->rx_count >= gro_normal_batch)
5548 [ # # ]: 0 : gro_normal_list(napi);
5549 : 0 : }
5550 : :
5551 : : INDIRECT_CALLABLE_DECLARE(int inet_gro_complete(struct sk_buff *, int));
5552 : : INDIRECT_CALLABLE_DECLARE(int ipv6_gro_complete(struct sk_buff *, int));
5553 : 0 : static int napi_gro_complete(struct napi_struct *napi, struct sk_buff *skb)
5554 : : {
5555 : 0 : struct packet_offload *ptype;
5556 : 0 : __be16 type = skb->protocol;
5557 : 0 : struct list_head *head = &offload_base;
5558 : 0 : int err = -ENOENT;
5559 : :
5560 : 0 : BUILD_BUG_ON(sizeof(struct napi_gro_cb) > sizeof(skb->cb));
5561 : :
5562 [ # # ]: 0 : if (NAPI_GRO_CB(skb)->count == 1) {
5563 : 0 : skb_shinfo(skb)->gso_size = 0;
5564 : 0 : goto out;
5565 : : }
5566 : :
5567 : 0 : rcu_read_lock();
5568 [ # # ]: 0 : list_for_each_entry_rcu(ptype, head, list) {
5569 [ # # # # ]: 0 : if (ptype->type != type || !ptype->callbacks.gro_complete)
5570 : 0 : continue;
5571 : :
5572 [ # # # # ]: 0 : err = INDIRECT_CALL_INET(ptype->callbacks.gro_complete,
5573 : : ipv6_gro_complete, inet_gro_complete,
5574 : : skb, 0);
5575 : : break;
5576 : : }
5577 : 0 : rcu_read_unlock();
5578 : :
5579 [ # # ]: 0 : if (err) {
5580 [ # # ]: 0 : WARN_ON(&ptype->list == head);
5581 : 0 : kfree_skb(skb);
5582 : 0 : return NET_RX_SUCCESS;
5583 : : }
5584 : :
5585 : 0 : out:
5586 : 0 : gro_normal_one(napi, skb);
5587 : 0 : return NET_RX_SUCCESS;
5588 : : }
5589 : :
5590 : 0 : static void __napi_gro_flush_chain(struct napi_struct *napi, u32 index,
5591 : : bool flush_old)
5592 : : {
5593 : 0 : struct list_head *head = &napi->gro_hash[index].list;
5594 : 0 : struct sk_buff *skb, *p;
5595 : :
5596 [ # # ]: 0 : list_for_each_entry_safe_reverse(skb, p, head, list) {
5597 [ # # # # ]: 0 : if (flush_old && NAPI_GRO_CB(skb)->age == jiffies)
5598 : : return;
5599 : 0 : skb_list_del_init(skb);
5600 : 0 : napi_gro_complete(napi, skb);
5601 : 0 : napi->gro_hash[index].count--;
5602 : : }
5603 : :
5604 [ # # ]: 0 : if (!napi->gro_hash[index].count)
5605 : 0 : __clear_bit(index, &napi->gro_bitmask);
5606 : : }
5607 : :
5608 : : /* napi->gro_hash[].list contains packets ordered by age.
5609 : : * youngest packets at the head of it.
5610 : : * Complete skbs in reverse order to reduce latencies.
5611 : : */
5612 : 0 : void napi_gro_flush(struct napi_struct *napi, bool flush_old)
5613 : : {
5614 : 0 : unsigned long bitmask = napi->gro_bitmask;
5615 : 0 : unsigned int i, base = ~0U;
5616 : :
5617 [ # # ]: 0 : while ((i = ffs(bitmask)) != 0) {
5618 : 0 : bitmask >>= i;
5619 : 0 : base += i;
5620 : 0 : __napi_gro_flush_chain(napi, base, flush_old);
5621 : : }
5622 : 0 : }
5623 : : EXPORT_SYMBOL(napi_gro_flush);
5624 : :
5625 : 0 : static struct list_head *gro_list_prepare(struct napi_struct *napi,
5626 : : struct sk_buff *skb)
5627 : : {
5628 : 0 : unsigned int maclen = skb->dev->hard_header_len;
5629 : 0 : u32 hash = skb_get_hash_raw(skb);
5630 : 0 : struct list_head *head;
5631 : 0 : struct sk_buff *p;
5632 : :
5633 : 0 : head = &napi->gro_hash[hash & (GRO_HASH_BUCKETS - 1)].list;
5634 [ # # ]: 0 : list_for_each_entry(p, head, list) {
5635 : 0 : unsigned long diffs;
5636 : :
5637 : 0 : NAPI_GRO_CB(p)->flush = 0;
5638 : :
5639 [ # # ]: 0 : if (hash != skb_get_hash_raw(p)) {
5640 : 0 : NAPI_GRO_CB(p)->same_flow = 0;
5641 : 0 : continue;
5642 : : }
5643 : :
5644 : 0 : diffs = (unsigned long)p->dev ^ (unsigned long)skb->dev;
5645 : 0 : diffs |= skb_vlan_tag_present(p) ^ skb_vlan_tag_present(skb);
5646 [ # # ]: 0 : if (skb_vlan_tag_present(p))
5647 : 0 : diffs |= skb_vlan_tag_get(p) ^ skb_vlan_tag_get(skb);
5648 : 0 : diffs |= skb_metadata_dst_cmp(p, skb);
5649 : 0 : diffs |= skb_metadata_differs(p, skb);
5650 [ # # ]: 0 : if (maclen == ETH_HLEN)
5651 : 0 : diffs |= compare_ether_header(skb_mac_header(p),
5652 : 0 : skb_mac_header(skb));
5653 [ # # ]: 0 : else if (!diffs)
5654 : 0 : diffs = memcmp(skb_mac_header(p),
5655 : 0 : skb_mac_header(skb),
5656 : : maclen);
5657 : 0 : NAPI_GRO_CB(p)->same_flow = !diffs;
5658 : : }
5659 : :
5660 : 0 : return head;
5661 : : }
5662 : :
5663 : 0 : static void skb_gro_reset_offset(struct sk_buff *skb)
5664 : : {
5665 [ # # ]: 0 : const struct skb_shared_info *pinfo = skb_shinfo(skb);
5666 : 0 : const skb_frag_t *frag0 = &pinfo->frags[0];
5667 : :
5668 : 0 : NAPI_GRO_CB(skb)->data_offset = 0;
5669 : 0 : NAPI_GRO_CB(skb)->frag0 = NULL;
5670 : 0 : NAPI_GRO_CB(skb)->frag0_len = 0;
5671 : :
5672 [ # # # # ]: 0 : if (!skb_headlen(skb) && pinfo->nr_frags &&
5673 : 0 : !PageHighMem(skb_frag_page(frag0))) {
5674 : 0 : NAPI_GRO_CB(skb)->frag0 = skb_frag_address(frag0);
5675 : 0 : NAPI_GRO_CB(skb)->frag0_len = min_t(unsigned int,
5676 : : skb_frag_size(frag0),
5677 : : skb->end - skb->tail);
5678 : : }
5679 : 0 : }
5680 : :
5681 : 0 : static void gro_pull_from_frag0(struct sk_buff *skb, int grow)
5682 : : {
5683 [ # # ]: 0 : struct skb_shared_info *pinfo = skb_shinfo(skb);
5684 : :
5685 [ # # ]: 0 : BUG_ON(skb->end - skb->tail < grow);
5686 : :
5687 [ # # ]: 0 : memcpy(skb_tail_pointer(skb), NAPI_GRO_CB(skb)->frag0, grow);
5688 : :
5689 : 0 : skb->data_len -= grow;
5690 : 0 : skb->tail += grow;
5691 : :
5692 [ # # ]: 0 : skb_frag_off_add(&pinfo->frags[0], grow);
5693 [ # # ]: 0 : skb_frag_size_sub(&pinfo->frags[0], grow);
5694 : :
5695 [ # # ]: 0 : if (unlikely(!skb_frag_size(&pinfo->frags[0]))) {
5696 : 0 : skb_frag_unref(skb, 0);
5697 : 0 : memmove(pinfo->frags, pinfo->frags + 1,
5698 : 0 : --pinfo->nr_frags * sizeof(pinfo->frags[0]));
5699 : : }
5700 : 0 : }
5701 : :
5702 : : static void gro_flush_oldest(struct napi_struct *napi, struct list_head *head)
5703 : : {
5704 : : struct sk_buff *oldest;
5705 : :
5706 : : oldest = list_last_entry(head, struct sk_buff, list);
5707 : :
5708 : : /* We are called with head length >= MAX_GRO_SKBS, so this is
5709 : : * impossible.
5710 : : */
5711 : : if (WARN_ON_ONCE(!oldest))
5712 : : return;
5713 : :
5714 : : /* Do not adjust napi->gro_hash[].count, caller is adding a new
5715 : : * SKB to the chain.
5716 : : */
5717 : : skb_list_del_init(oldest);
5718 : : napi_gro_complete(napi, oldest);
5719 : : }
5720 : :
5721 : : INDIRECT_CALLABLE_DECLARE(struct sk_buff *inet_gro_receive(struct list_head *,
5722 : : struct sk_buff *));
5723 : : INDIRECT_CALLABLE_DECLARE(struct sk_buff *ipv6_gro_receive(struct list_head *,
5724 : : struct sk_buff *));
5725 : 0 : static enum gro_result dev_gro_receive(struct napi_struct *napi, struct sk_buff *skb)
5726 : : {
5727 [ # # ]: 0 : u32 hash = skb_get_hash_raw(skb) & (GRO_HASH_BUCKETS - 1);
5728 : 0 : struct list_head *head = &offload_base;
5729 : 0 : struct packet_offload *ptype;
5730 : 0 : __be16 type = skb->protocol;
5731 : 0 : struct list_head *gro_head;
5732 : 0 : struct sk_buff *pp = NULL;
5733 : 0 : enum gro_result ret;
5734 : 0 : int same_flow;
5735 : 0 : int grow;
5736 : :
5737 [ # # ]: 0 : if (netif_elide_gro(skb->dev))
5738 : 0 : goto normal;
5739 : :
5740 : 0 : gro_head = gro_list_prepare(napi, skb);
5741 : :
5742 : 0 : rcu_read_lock();
5743 [ # # ]: 0 : list_for_each_entry_rcu(ptype, head, list) {
5744 [ # # # # ]: 0 : if (ptype->type != type || !ptype->callbacks.gro_receive)
5745 : 0 : continue;
5746 : :
5747 [ # # ]: 0 : skb_set_network_header(skb, skb_gro_offset(skb));
5748 [ # # ]: 0 : skb_reset_mac_len(skb);
5749 : 0 : NAPI_GRO_CB(skb)->same_flow = 0;
5750 [ # # # # ]: 0 : NAPI_GRO_CB(skb)->flush = skb_is_gso(skb) || skb_has_frag_list(skb);
5751 : 0 : NAPI_GRO_CB(skb)->free = 0;
5752 : 0 : NAPI_GRO_CB(skb)->encap_mark = 0;
5753 : 0 : NAPI_GRO_CB(skb)->recursion_counter = 0;
5754 : 0 : NAPI_GRO_CB(skb)->is_fou = 0;
5755 : 0 : NAPI_GRO_CB(skb)->is_atomic = 1;
5756 : 0 : NAPI_GRO_CB(skb)->gro_remcsum_start = 0;
5757 : :
5758 : : /* Setup for GRO checksum validation */
5759 [ # # # ]: 0 : switch (skb->ip_summed) {
5760 : 0 : case CHECKSUM_COMPLETE:
5761 : 0 : NAPI_GRO_CB(skb)->csum = skb->csum;
5762 : 0 : NAPI_GRO_CB(skb)->csum_valid = 1;
5763 : 0 : NAPI_GRO_CB(skb)->csum_cnt = 0;
5764 : 0 : break;
5765 : 0 : case CHECKSUM_UNNECESSARY:
5766 : 0 : NAPI_GRO_CB(skb)->csum_cnt = skb->csum_level + 1;
5767 : 0 : NAPI_GRO_CB(skb)->csum_valid = 0;
5768 : 0 : break;
5769 : 0 : default:
5770 : 0 : NAPI_GRO_CB(skb)->csum_cnt = 0;
5771 : 0 : NAPI_GRO_CB(skb)->csum_valid = 0;
5772 : : }
5773 : :
5774 [ # # # # ]: 0 : pp = INDIRECT_CALL_INET(ptype->callbacks.gro_receive,
5775 : : ipv6_gro_receive, inet_gro_receive,
5776 : : gro_head, skb);
5777 : : break;
5778 : : }
5779 : 0 : rcu_read_unlock();
5780 : :
5781 [ # # ]: 0 : if (&ptype->list == head)
5782 : 0 : goto normal;
5783 : :
5784 [ # # ]: 0 : if (PTR_ERR(pp) == -EINPROGRESS) {
5785 : 0 : ret = GRO_CONSUMED;
5786 : 0 : goto ok;
5787 : : }
5788 : :
5789 : 0 : same_flow = NAPI_GRO_CB(skb)->same_flow;
5790 : 0 : ret = NAPI_GRO_CB(skb)->free ? GRO_MERGED_FREE : GRO_MERGED;
5791 : :
5792 [ # # ]: 0 : if (pp) {
5793 : 0 : skb_list_del_init(pp);
5794 : 0 : napi_gro_complete(napi, pp);
5795 : 0 : napi->gro_hash[hash].count--;
5796 : : }
5797 : :
5798 [ # # ]: 0 : if (same_flow)
5799 : 0 : goto ok;
5800 : :
5801 [ # # ]: 0 : if (NAPI_GRO_CB(skb)->flush)
5802 : 0 : goto normal;
5803 : :
5804 [ # # ]: 0 : if (unlikely(napi->gro_hash[hash].count >= MAX_GRO_SKBS)) {
5805 : 0 : gro_flush_oldest(napi, gro_head);
5806 : : } else {
5807 : 0 : napi->gro_hash[hash].count++;
5808 : : }
5809 : 0 : NAPI_GRO_CB(skb)->count = 1;
5810 : 0 : NAPI_GRO_CB(skb)->age = jiffies;
5811 : 0 : NAPI_GRO_CB(skb)->last = skb;
5812 : 0 : skb_shinfo(skb)->gso_size = skb_gro_len(skb);
5813 : 0 : list_add(&skb->list, gro_head);
5814 : 0 : ret = GRO_HELD;
5815 : :
5816 : 0 : pull:
5817 [ # # ]: 0 : grow = skb_gro_offset(skb) - skb_headlen(skb);
5818 [ # # ]: 0 : if (grow > 0)
5819 : 0 : gro_pull_from_frag0(skb, grow);
5820 : 0 : ok:
5821 [ # # ]: 0 : if (napi->gro_hash[hash].count) {
5822 [ # # ]: 0 : if (!test_bit(hash, &napi->gro_bitmask))
5823 : 0 : __set_bit(hash, &napi->gro_bitmask);
5824 [ # # ]: 0 : } else if (test_bit(hash, &napi->gro_bitmask)) {
5825 : 0 : __clear_bit(hash, &napi->gro_bitmask);
5826 : : }
5827 : :
5828 : 0 : return ret;
5829 : :
5830 : 0 : normal:
5831 : 0 : ret = GRO_NORMAL;
5832 : 0 : goto pull;
5833 : : }
5834 : :
5835 : 0 : struct packet_offload *gro_find_receive_by_type(__be16 type)
5836 : : {
5837 : 0 : struct list_head *offload_head = &offload_base;
5838 : 0 : struct packet_offload *ptype;
5839 : :
5840 [ # # ]: 0 : list_for_each_entry_rcu(ptype, offload_head, list) {
5841 [ # # # # ]: 0 : if (ptype->type != type || !ptype->callbacks.gro_receive)
5842 : 0 : continue;
5843 : : return ptype;
5844 : : }
5845 : : return NULL;
5846 : : }
5847 : : EXPORT_SYMBOL(gro_find_receive_by_type);
5848 : :
5849 : 0 : struct packet_offload *gro_find_complete_by_type(__be16 type)
5850 : : {
5851 : 0 : struct list_head *offload_head = &offload_base;
5852 : 0 : struct packet_offload *ptype;
5853 : :
5854 [ # # ]: 0 : list_for_each_entry_rcu(ptype, offload_head, list) {
5855 [ # # # # ]: 0 : if (ptype->type != type || !ptype->callbacks.gro_complete)
5856 : 0 : continue;
5857 : : return ptype;
5858 : : }
5859 : : return NULL;
5860 : : }
5861 : : EXPORT_SYMBOL(gro_find_complete_by_type);
5862 : :
5863 : 0 : static void napi_skb_free_stolen_head(struct sk_buff *skb)
5864 : : {
5865 [ # # ]: 0 : skb_dst_drop(skb);
5866 [ # # ]: 0 : skb_ext_put(skb);
5867 : 0 : kmem_cache_free(skbuff_head_cache, skb);
5868 : 0 : }
5869 : :
5870 : 0 : static gro_result_t napi_skb_finish(struct napi_struct *napi,
5871 : : struct sk_buff *skb,
5872 : : gro_result_t ret)
5873 : : {
5874 [ # # # # ]: 0 : switch (ret) {
5875 : 0 : case GRO_NORMAL:
5876 : 0 : gro_normal_one(napi, skb);
5877 : 0 : break;
5878 : :
5879 : 0 : case GRO_DROP:
5880 : 0 : kfree_skb(skb);
5881 : 0 : break;
5882 : :
5883 : 0 : case GRO_MERGED_FREE:
5884 [ # # ]: 0 : if (NAPI_GRO_CB(skb)->free == NAPI_GRO_FREE_STOLEN_HEAD)
5885 : 0 : napi_skb_free_stolen_head(skb);
5886 : : else
5887 : 0 : __kfree_skb(skb);
5888 : : break;
5889 : :
5890 : : case GRO_HELD:
5891 : : case GRO_MERGED:
5892 : : case GRO_CONSUMED:
5893 : : break;
5894 : : }
5895 : :
5896 : 0 : return ret;
5897 : : }
5898 : :
5899 : 0 : gro_result_t napi_gro_receive(struct napi_struct *napi, struct sk_buff *skb)
5900 : : {
5901 : 0 : gro_result_t ret;
5902 : :
5903 : 0 : skb_mark_napi_id(skb, napi);
5904 : 0 : trace_napi_gro_receive_entry(skb);
5905 : :
5906 : 0 : skb_gro_reset_offset(skb);
5907 : :
5908 : 0 : ret = napi_skb_finish(napi, skb, dev_gro_receive(napi, skb));
5909 : 0 : trace_napi_gro_receive_exit(ret);
5910 : :
5911 : 0 : return ret;
5912 : : }
5913 : : EXPORT_SYMBOL(napi_gro_receive);
5914 : :
5915 : : static void napi_reuse_skb(struct napi_struct *napi, struct sk_buff *skb)
5916 : : {
5917 : : if (unlikely(skb->pfmemalloc)) {
5918 : : consume_skb(skb);
5919 : : return;
5920 : : }
5921 : : __skb_pull(skb, skb_headlen(skb));
5922 : : /* restore the reserve we had after netdev_alloc_skb_ip_align() */
5923 : : skb_reserve(skb, NET_SKB_PAD + NET_IP_ALIGN - skb_headroom(skb));
5924 : : __vlan_hwaccel_clear_tag(skb);
5925 : : skb->dev = napi->dev;
5926 : : skb->skb_iif = 0;
5927 : :
5928 : : /* eth_type_trans() assumes pkt_type is PACKET_HOST */
5929 : : skb->pkt_type = PACKET_HOST;
5930 : :
5931 : : skb->encapsulation = 0;
5932 : : skb_shinfo(skb)->gso_type = 0;
5933 : : skb->truesize = SKB_TRUESIZE(skb_end_offset(skb));
5934 : : skb_ext_reset(skb);
5935 : :
5936 : : napi->skb = skb;
5937 : : }
5938 : :
5939 : 0 : struct sk_buff *napi_get_frags(struct napi_struct *napi)
5940 : : {
5941 : 0 : struct sk_buff *skb = napi->skb;
5942 : :
5943 [ # # ]: 0 : if (!skb) {
5944 : 0 : skb = napi_alloc_skb(napi, GRO_MAX_HEAD);
5945 [ # # ]: 0 : if (skb) {
5946 : 0 : napi->skb = skb;
5947 : 0 : skb_mark_napi_id(skb, napi);
5948 : : }
5949 : : }
5950 : 0 : return skb;
5951 : : }
5952 : : EXPORT_SYMBOL(napi_get_frags);
5953 : :
5954 : 0 : static gro_result_t napi_frags_finish(struct napi_struct *napi,
5955 : : struct sk_buff *skb,
5956 : : gro_result_t ret)
5957 : : {
5958 [ # # # # ]: 0 : switch (ret) {
5959 : 0 : case GRO_NORMAL:
5960 : : case GRO_HELD:
5961 : 0 : __skb_push(skb, ETH_HLEN);
5962 : 0 : skb->protocol = eth_type_trans(skb, skb->dev);
5963 [ # # ]: 0 : if (ret == GRO_NORMAL)
5964 : 0 : gro_normal_one(napi, skb);
5965 : : break;
5966 : :
5967 : 0 : case GRO_DROP:
5968 : 0 : napi_reuse_skb(napi, skb);
5969 : 0 : break;
5970 : :
5971 : 0 : case GRO_MERGED_FREE:
5972 [ # # ]: 0 : if (NAPI_GRO_CB(skb)->free == NAPI_GRO_FREE_STOLEN_HEAD)
5973 : 0 : napi_skb_free_stolen_head(skb);
5974 : : else
5975 : 0 : napi_reuse_skb(napi, skb);
5976 : : break;
5977 : :
5978 : : case GRO_MERGED:
5979 : : case GRO_CONSUMED:
5980 : : break;
5981 : : }
5982 : :
5983 : 0 : return ret;
5984 : : }
5985 : :
5986 : : /* Upper GRO stack assumes network header starts at gro_offset=0
5987 : : * Drivers could call both napi_gro_frags() and napi_gro_receive()
5988 : : * We copy ethernet header into skb->data to have a common layout.
5989 : : */
5990 : 0 : static struct sk_buff *napi_frags_skb(struct napi_struct *napi)
5991 : : {
5992 : 0 : struct sk_buff *skb = napi->skb;
5993 : 0 : const struct ethhdr *eth;
5994 : 0 : unsigned int hlen = sizeof(*eth);
5995 : :
5996 : 0 : napi->skb = NULL;
5997 : :
5998 : 0 : skb_reset_mac_header(skb);
5999 : 0 : skb_gro_reset_offset(skb);
6000 : :
6001 [ # # ]: 0 : if (unlikely(skb_gro_header_hard(skb, hlen))) {
6002 : 0 : eth = skb_gro_header_slow(skb, hlen, 0);
6003 [ # # ]: 0 : if (unlikely(!eth)) {
6004 [ # # ]: 0 : net_warn_ratelimited("%s: dropping impossible skb from %s\n",
6005 : : __func__, napi->dev->name);
6006 : 0 : napi_reuse_skb(napi, skb);
6007 : 0 : return NULL;
6008 : : }
6009 : : } else {
6010 : 0 : eth = (const struct ethhdr *)skb->data;
6011 : 0 : gro_pull_from_frag0(skb, hlen);
6012 : 0 : NAPI_GRO_CB(skb)->frag0 += hlen;
6013 : 0 : NAPI_GRO_CB(skb)->frag0_len -= hlen;
6014 : : }
6015 [ # # ]: 0 : __skb_pull(skb, hlen);
6016 : :
6017 : : /*
6018 : : * This works because the only protocols we care about don't require
6019 : : * special handling.
6020 : : * We'll fix it up properly in napi_frags_finish()
6021 : : */
6022 : 0 : skb->protocol = eth->h_proto;
6023 : :
6024 : 0 : return skb;
6025 : : }
6026 : :
6027 : 0 : gro_result_t napi_gro_frags(struct napi_struct *napi)
6028 : : {
6029 : 0 : gro_result_t ret;
6030 : 0 : struct sk_buff *skb = napi_frags_skb(napi);
6031 : :
6032 [ # # ]: 0 : if (!skb)
6033 : : return GRO_DROP;
6034 : :
6035 : 0 : trace_napi_gro_frags_entry(skb);
6036 : :
6037 : 0 : ret = napi_frags_finish(napi, skb, dev_gro_receive(napi, skb));
6038 : 0 : trace_napi_gro_frags_exit(ret);
6039 : :
6040 : 0 : return ret;
6041 : : }
6042 : : EXPORT_SYMBOL(napi_gro_frags);
6043 : :
6044 : : /* Compute the checksum from gro_offset and return the folded value
6045 : : * after adding in any pseudo checksum.
6046 : : */
6047 : 0 : __sum16 __skb_gro_checksum_complete(struct sk_buff *skb)
6048 : : {
6049 : 0 : __wsum wsum;
6050 : 0 : __sum16 sum;
6051 : :
6052 : 0 : wsum = skb_checksum(skb, skb_gro_offset(skb), skb_gro_len(skb), 0);
6053 : :
6054 : : /* NAPI_GRO_CB(skb)->csum holds pseudo checksum */
6055 [ # # ]: 0 : sum = csum_fold(csum_add(NAPI_GRO_CB(skb)->csum, wsum));
6056 : : /* See comments in __skb_checksum_complete(). */
6057 [ # # ]: 0 : if (likely(!sum)) {
6058 [ # # ]: 0 : if (unlikely(skb->ip_summed == CHECKSUM_COMPLETE) &&
6059 [ # # ]: 0 : !skb->csum_complete_sw)
6060 : 0 : netdev_rx_csum_fault(skb->dev, skb);
6061 : : }
6062 : :
6063 : 0 : NAPI_GRO_CB(skb)->csum = wsum;
6064 : 0 : NAPI_GRO_CB(skb)->csum_valid = 1;
6065 : :
6066 : 0 : return sum;
6067 : : }
6068 : : EXPORT_SYMBOL(__skb_gro_checksum_complete);
6069 : :
6070 : 0 : static void net_rps_send_ipi(struct softnet_data *remsd)
6071 : : {
6072 : : #ifdef CONFIG_RPS
6073 [ # # ]: 0 : while (remsd) {
6074 : 0 : struct softnet_data *next = remsd->rps_ipi_next;
6075 : :
6076 [ # # ]: 0 : if (cpu_online(remsd->cpu))
6077 : 0 : smp_call_function_single_async(remsd->cpu, &remsd->csd);
6078 : : remsd = next;
6079 : : }
6080 : : #endif
6081 : 0 : }
6082 : :
6083 : : /*
6084 : : * net_rps_action_and_irq_enable sends any pending IPI's for rps.
6085 : : * Note: called with local irq disabled, but exits with local irq enabled.
6086 : : */
6087 : 0 : static void net_rps_action_and_irq_enable(struct softnet_data *sd)
6088 : : {
6089 : : #ifdef CONFIG_RPS
6090 : 0 : struct softnet_data *remsd = sd->rps_ipi_list;
6091 : :
6092 : 0 : if (remsd) {
6093 : 0 : sd->rps_ipi_list = NULL;
6094 : :
6095 : 0 : local_irq_enable();
6096 : :
6097 : : /* Send pending IPI's to kick RPS processing on remote cpus. */
6098 : 0 : net_rps_send_ipi(remsd);
6099 : : } else
6100 : : #endif
6101 : 0 : local_irq_enable();
6102 : : }
6103 : :
6104 : 3 : static bool sd_has_rps_ipi_waiting(struct softnet_data *sd)
6105 : : {
6106 : : #ifdef CONFIG_RPS
6107 : 3 : return sd->rps_ipi_list != NULL;
6108 : : #else
6109 : : return false;
6110 : : #endif
6111 : : }
6112 : :
6113 : 0 : static int process_backlog(struct napi_struct *napi, int quota)
6114 : : {
6115 : 0 : struct softnet_data *sd = container_of(napi, struct softnet_data, backlog);
6116 : 0 : bool again = true;
6117 : 0 : int work = 0;
6118 : :
6119 : : /* Check if we have pending ipi, its better to send them now,
6120 : : * not waiting net_rx_action() end.
6121 : : */
6122 [ # # ]: 0 : if (sd_has_rps_ipi_waiting(sd)) {
6123 : 0 : local_irq_disable();
6124 [ # # ]: 0 : net_rps_action_and_irq_enable(sd);
6125 : : }
6126 : :
6127 : 0 : napi->weight = dev_rx_weight;
6128 : 0 : while (again) {
6129 : : struct sk_buff *skb;
6130 : :
6131 [ # # # # ]: 0 : while ((skb = __skb_dequeue(&sd->process_queue))) {
6132 : 0 : rcu_read_lock();
6133 : 0 : __netif_receive_skb(skb);
6134 : 0 : rcu_read_unlock();
6135 [ # # ]: 0 : input_queue_head_incr(sd);
6136 [ # # ]: 0 : if (++work >= quota)
6137 : 0 : return work;
6138 : :
6139 : : }
6140 : :
6141 : 0 : local_irq_disable();
6142 : 0 : rps_lock(sd);
6143 [ # # ]: 0 : if (skb_queue_empty(&sd->input_pkt_queue)) {
6144 : : /*
6145 : : * Inline a custom version of __napi_complete().
6146 : : * only current cpu owns and manipulates this napi,
6147 : : * and NAPI_STATE_SCHED is the only possible flag set
6148 : : * on backlog.
6149 : : * We can use a plain write instead of clear_bit(),
6150 : : * and we dont need an smp_mb() memory barrier.
6151 : : */
6152 : 0 : napi->state = 0;
6153 : 0 : again = false;
6154 : : } else {
6155 : 0 : skb_queue_splice_tail_init(&sd->input_pkt_queue,
6156 : : &sd->process_queue);
6157 : : }
6158 : 0 : rps_unlock(sd);
6159 [ # # ]: 0 : local_irq_enable();
6160 : : }
6161 : :
6162 : : return work;
6163 : : }
6164 : :
6165 : : /**
6166 : : * __napi_schedule - schedule for receive
6167 : : * @n: entry to schedule
6168 : : *
6169 : : * The entry's receive function will be scheduled to run.
6170 : : * Consider using __napi_schedule_irqoff() if hard irqs are masked.
6171 : : */
6172 : 3 : void __napi_schedule(struct napi_struct *n)
6173 : : {
6174 : 3 : unsigned long flags;
6175 : :
6176 : 3 : local_irq_save(flags);
6177 : 3 : ____napi_schedule(this_cpu_ptr(&softnet_data), n);
6178 : 3 : local_irq_restore(flags);
6179 : 3 : }
6180 : : EXPORT_SYMBOL(__napi_schedule);
6181 : :
6182 : : /**
6183 : : * napi_schedule_prep - check if napi can be scheduled
6184 : : * @n: napi context
6185 : : *
6186 : : * Test if NAPI routine is already running, and if not mark
6187 : : * it as running. This is used as a condition variable
6188 : : * insure only one NAPI poll instance runs. We also make
6189 : : * sure there is no pending NAPI disable.
6190 : : */
6191 : 3 : bool napi_schedule_prep(struct napi_struct *n)
6192 : : {
6193 : 3 : unsigned long val, new;
6194 : 3 : printk(KERN_INFO "napi_schedule_prep\n");
6195 : :
6196 : 3 : do {
6197 [ + - ]: 3 : val = READ_ONCE(n->state);
6198 [ + - ]: 3 : if (unlikely(val & NAPIF_STATE_DISABLE))
6199 : : return false;
6200 : 3 : new = val | NAPIF_STATE_SCHED;
6201 : :
6202 : : /* Sets STATE_MISSED bit if STATE_SCHED was already set
6203 : : * This was suggested by Alexander Duyck, as compiler
6204 : : * emits better code than :
6205 : : * if (val & NAPIF_STATE_SCHED)
6206 : : * new |= NAPIF_STATE_MISSED;
6207 : : */
6208 : 3 : new |= (val & NAPIF_STATE_SCHED) / NAPIF_STATE_SCHED *
6209 : : NAPIF_STATE_MISSED;
6210 [ - + ]: 3 : } while (cmpxchg(&n->state, val, new) != val);
6211 : 3 : printk(KERN_INFO "res: %d\n", !(val & NAPIF_STATE_SCHED));
6212 : 3 : return !(val & NAPIF_STATE_SCHED);
6213 : : }
6214 : : EXPORT_SYMBOL(napi_schedule_prep);
6215 : :
6216 : : /**
6217 : : * __napi_schedule_irqoff - schedule for receive
6218 : : * @n: entry to schedule
6219 : : *
6220 : : * Variant of __napi_schedule() assuming hard irqs are masked
6221 : : */
6222 : 0 : void __napi_schedule_irqoff(struct napi_struct *n)
6223 : : {
6224 : 0 : ____napi_schedule(this_cpu_ptr(&softnet_data), n);
6225 : 0 : }
6226 : : EXPORT_SYMBOL(__napi_schedule_irqoff);
6227 : :
6228 : 3 : bool napi_complete_done(struct napi_struct *n, int work_done)
6229 : : {
6230 : 3 : unsigned long flags, val, new;
6231 : :
6232 : : /*
6233 : : * 1) Don't let napi dequeue from the cpu poll list
6234 : : * just in case its running on a different cpu.
6235 : : * 2) If we are busy polling, do nothing here, we have
6236 : : * the guarantee we will be called later.
6237 : : */
6238 [ + - ]: 3 : if (unlikely(n->state & (NAPIF_STATE_NPSVC |
6239 : : NAPIF_STATE_IN_BUSY_POLL)))
6240 : : return false;
6241 : :
6242 [ - + ]: 3 : if (n->gro_bitmask) {
6243 : 0 : unsigned long timeout = 0;
6244 : :
6245 [ # # ]: 0 : if (work_done)
6246 : 0 : timeout = n->dev->gro_flush_timeout;
6247 : :
6248 : : /* When the NAPI instance uses a timeout and keeps postponing
6249 : : * it, we need to bound somehow the time packets are kept in
6250 : : * the GRO layer
6251 : : */
6252 : 0 : napi_gro_flush(n, !!timeout);
6253 [ # # ]: 0 : if (timeout)
6254 : 0 : hrtimer_start(&n->timer, ns_to_ktime(timeout),
6255 : : HRTIMER_MODE_REL_PINNED);
6256 : : }
6257 : :
6258 [ - + ]: 3 : gro_normal_list(n);
6259 : :
6260 [ - + ]: 3 : if (unlikely(!list_empty(&n->poll_list))) {
6261 : : /* If n->poll_list is not empty, we need to mask irqs */
6262 : 0 : local_irq_save(flags);
6263 : 0 : list_del_init(&n->poll_list);
6264 : 0 : local_irq_restore(flags);
6265 : : }
6266 : :
6267 : 3 : do {
6268 [ - + ]: 3 : val = READ_ONCE(n->state);
6269 : :
6270 [ - + ]: 3 : WARN_ON_ONCE(!(val & NAPIF_STATE_SCHED));
6271 : :
6272 : 3 : new = val & ~(NAPIF_STATE_MISSED | NAPIF_STATE_SCHED);
6273 : :
6274 : : /* If STATE_MISSED was set, leave STATE_SCHED set,
6275 : : * because we will call napi->poll() one more time.
6276 : : * This C code was suggested by Alexander Duyck to help gcc.
6277 : : */
6278 : 3 : new |= (val & NAPIF_STATE_MISSED) / NAPIF_STATE_MISSED *
6279 : : NAPIF_STATE_SCHED;
6280 [ - + ]: 3 : } while (cmpxchg(&n->state, val, new) != val);
6281 : :
6282 [ - + ]: 3 : if (unlikely(val & NAPIF_STATE_MISSED)) {
6283 : 0 : __napi_schedule(n);
6284 : 0 : return false;
6285 : : }
6286 : :
6287 : : return true;
6288 : : }
6289 : : EXPORT_SYMBOL(napi_complete_done);
6290 : :
6291 : : /* must be called under rcu_read_lock(), as we dont take a reference */
6292 : 3 : static struct napi_struct *napi_by_id(unsigned int napi_id)
6293 : : {
6294 : 3 : unsigned int hash = napi_id % HASH_SIZE(napi_hash);
6295 : 3 : struct napi_struct *napi;
6296 : :
6297 [ - - - + : 3 : hlist_for_each_entry_rcu(napi, &napi_hash[hash], napi_hash_node)
- - - - -
- - - -
- ]
6298 [ # # # # : 0 : if (napi->napi_id == napi_id)
# # ]
6299 : : return napi;
6300 : :
6301 : : return NULL;
6302 : : }
6303 : :
6304 : : #if defined(CONFIG_NET_RX_BUSY_POLL)
6305 : :
6306 : : #define BUSY_POLL_BUDGET 8
6307 : :
6308 : 0 : static void busy_poll_stop(struct napi_struct *napi, void *have_poll_lock)
6309 : : {
6310 : 0 : int rc;
6311 : :
6312 : : /* Busy polling means there is a high chance device driver hard irq
6313 : : * could not grab NAPI_STATE_SCHED, and that NAPI_STATE_MISSED was
6314 : : * set in napi_schedule_prep().
6315 : : * Since we are about to call napi->poll() once more, we can safely
6316 : : * clear NAPI_STATE_MISSED.
6317 : : *
6318 : : * Note: x86 could use a single "lock and ..." instruction
6319 : : * to perform these two clear_bit()
6320 : : */
6321 : 0 : clear_bit(NAPI_STATE_MISSED, &napi->state);
6322 : 0 : clear_bit(NAPI_STATE_IN_BUSY_POLL, &napi->state);
6323 : :
6324 : 0 : local_bh_disable();
6325 : :
6326 : : /* All we really want here is to re-enable device interrupts.
6327 : : * Ideally, a new ndo_busy_poll_stop() could avoid another round.
6328 : : */
6329 : 0 : rc = napi->poll(napi, BUSY_POLL_BUDGET);
6330 : : /* We can't gro_normal_list() here, because napi->poll() might have
6331 : : * rearmed the napi (napi_complete_done()) in which case it could
6332 : : * already be running on another CPU.
6333 : : */
6334 : 0 : trace_napi_poll(napi, rc, BUSY_POLL_BUDGET);
6335 [ # # ]: 0 : netpoll_poll_unlock(have_poll_lock);
6336 [ # # ]: 0 : if (rc == BUSY_POLL_BUDGET) {
6337 : : /* As the whole budget was spent, we still own the napi so can
6338 : : * safely handle the rx_list.
6339 : : */
6340 [ # # ]: 0 : gro_normal_list(napi);
6341 : 0 : __napi_schedule(napi);
6342 : : }
6343 : 0 : local_bh_enable();
6344 : 0 : }
6345 : :
6346 : 0 : void napi_busy_loop(unsigned int napi_id,
6347 : : bool (*loop_end)(void *, unsigned long),
6348 : : void *loop_end_arg)
6349 : : {
6350 [ # # ]: 0 : unsigned long start_time = loop_end ? busy_loop_current_time() : 0;
6351 : 0 : int (*napi_poll)(struct napi_struct *napi, int budget);
6352 : 0 : void *have_poll_lock = NULL;
6353 : 0 : struct napi_struct *napi;
6354 : :
6355 : 0 : restart:
6356 : 0 : napi_poll = NULL;
6357 : :
6358 : 0 : rcu_read_lock();
6359 : :
6360 [ # # ]: 0 : napi = napi_by_id(napi_id);
6361 [ # # ]: 0 : if (!napi)
6362 : 0 : goto out;
6363 : :
6364 : 0 : preempt_disable();
6365 : 0 : for (;;) {
6366 : 0 : int work = 0;
6367 : :
6368 : 0 : local_bh_disable();
6369 [ # # ]: 0 : if (!napi_poll) {
6370 [ # # ]: 0 : unsigned long val = READ_ONCE(napi->state);
6371 : :
6372 : : /* If multiple threads are competing for this napi,
6373 : : * we avoid dirtying napi->state as much as we can.
6374 : : */
6375 [ # # ]: 0 : if (val & (NAPIF_STATE_DISABLE | NAPIF_STATE_SCHED |
6376 : : NAPIF_STATE_IN_BUSY_POLL))
6377 : 0 : goto count;
6378 [ # # ]: 0 : if (cmpxchg(&napi->state, val,
6379 : : val | NAPIF_STATE_IN_BUSY_POLL |
6380 : : NAPIF_STATE_SCHED) != val)
6381 : 0 : goto count;
6382 : 0 : have_poll_lock = netpoll_poll_lock(napi);
6383 : 0 : napi_poll = napi->poll;
6384 : : }
6385 : 0 : work = napi_poll(napi, BUSY_POLL_BUDGET);
6386 : 0 : trace_napi_poll(napi, work, BUSY_POLL_BUDGET);
6387 [ # # ]: 0 : gro_normal_list(napi);
6388 : 0 : count:
6389 [ # # ]: 0 : if (work > 0)
6390 [ # # # # : 0 : __NET_ADD_STATS(dev_net(napi->dev),
# # ]
6391 : : LINUX_MIB_BUSYPOLLRXPACKETS, work);
6392 : 0 : local_bh_enable();
6393 : :
6394 [ # # # # ]: 0 : if (!loop_end || loop_end(loop_end_arg, start_time))
6395 : : break;
6396 : :
6397 [ # # ]: 0 : if (unlikely(need_resched())) {
6398 [ # # ]: 0 : if (napi_poll)
6399 : 0 : busy_poll_stop(napi, have_poll_lock);
6400 : 0 : preempt_enable();
6401 : 0 : rcu_read_unlock();
6402 : 0 : cond_resched();
6403 [ # # ]: 0 : if (loop_end(loop_end_arg, start_time))
6404 : : return;
6405 : 0 : goto restart;
6406 : : }
6407 : 0 : cpu_relax();
6408 : : }
6409 [ # # ]: 0 : if (napi_poll)
6410 : 0 : busy_poll_stop(napi, have_poll_lock);
6411 : 0 : preempt_enable();
6412 : 0 : out:
6413 : 0 : rcu_read_unlock();
6414 : : }
6415 : : EXPORT_SYMBOL(napi_busy_loop);
6416 : :
6417 : : #endif /* CONFIG_NET_RX_BUSY_POLL */
6418 : :
6419 : 6 : static void napi_hash_add(struct napi_struct *napi)
6420 : : {
6421 [ + + - + ]: 9 : if (test_bit(NAPI_STATE_NO_BUSY_POLL, &napi->state) ||
6422 : 3 : test_and_set_bit(NAPI_STATE_HASHED, &napi->state))
6423 : 3 : return;
6424 : :
6425 : 3 : spin_lock(&napi_hash_lock);
6426 : :
6427 : : /* 0..NR_CPUS range is reserved for sender_cpu use */
6428 : 3 : do {
6429 [ - + ]: 3 : if (unlikely(++napi_gen_id < MIN_NAPI_ID))
6430 : 0 : napi_gen_id = MIN_NAPI_ID;
6431 [ - + - + ]: 6 : } while (napi_by_id(napi_gen_id));
6432 : 3 : napi->napi_id = napi_gen_id;
6433 : :
6434 : 3 : hlist_add_head_rcu(&napi->napi_hash_node,
6435 : 3 : &napi_hash[napi->napi_id % HASH_SIZE(napi_hash)]);
6436 : :
6437 : 3 : spin_unlock(&napi_hash_lock);
6438 : : }
6439 : :
6440 : : /* Warning : caller is responsible to make sure rcu grace period
6441 : : * is respected before freeing memory containing @napi
6442 : : */
6443 : 0 : bool napi_hash_del(struct napi_struct *napi)
6444 : : {
6445 : 0 : bool rcu_sync_needed = false;
6446 : :
6447 : 0 : spin_lock(&napi_hash_lock);
6448 : :
6449 [ # # ]: 0 : if (test_and_clear_bit(NAPI_STATE_HASHED, &napi->state)) {
6450 : 0 : rcu_sync_needed = true;
6451 [ # # ]: 0 : hlist_del_rcu(&napi->napi_hash_node);
6452 : : }
6453 : 0 : spin_unlock(&napi_hash_lock);
6454 : 0 : return rcu_sync_needed;
6455 : : }
6456 : : EXPORT_SYMBOL_GPL(napi_hash_del);
6457 : :
6458 : 0 : static enum hrtimer_restart napi_watchdog(struct hrtimer *timer)
6459 : : {
6460 : 0 : struct napi_struct *napi;
6461 : :
6462 : 0 : napi = container_of(timer, struct napi_struct, timer);
6463 : :
6464 : : /* Note : we use a relaxed variant of napi_schedule_prep() not setting
6465 : : * NAPI_STATE_MISSED, since we do not react to a device IRQ.
6466 : : */
6467 [ # # # # : 0 : if (napi->gro_bitmask && !napi_disable_pending(napi) &&
# # ]
6468 : 0 : !test_and_set_bit(NAPI_STATE_SCHED, &napi->state))
6469 : 0 : __napi_schedule_irqoff(napi);
6470 : :
6471 : 0 : return HRTIMER_NORESTART;
6472 : : }
6473 : :
6474 : 9 : static void init_gro_hash(struct napi_struct *napi)
6475 : : {
6476 : : int i;
6477 : :
6478 [ + + + + ]: 81 : for (i = 0; i < GRO_HASH_BUCKETS; i++) {
6479 : 72 : INIT_LIST_HEAD(&napi->gro_hash[i].list);
6480 : 72 : napi->gro_hash[i].count = 0;
6481 : : }
6482 : 9 : napi->gro_bitmask = 0;
6483 : : }
6484 : :
6485 : 6 : void netif_napi_add(struct net_device *dev, struct napi_struct *napi,
6486 : : int (*poll)(struct napi_struct *, int), int weight)
6487 : : {
6488 : 6 : INIT_LIST_HEAD(&napi->poll_list);
6489 : 6 : hrtimer_init(&napi->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL_PINNED);
6490 : 6 : napi->timer.function = napi_watchdog;
6491 : 6 : init_gro_hash(napi);
6492 : 6 : napi->skb = NULL;
6493 [ - + ]: 6 : INIT_LIST_HEAD(&napi->rx_list);
6494 : 6 : napi->rx_count = 0;
6495 : 6 : napi->poll = poll;
6496 [ - + ]: 6 : if (weight > NAPI_POLL_WEIGHT)
6497 [ # # ]: 0 : netdev_err_once(dev, "%s() called with weight %d\n", __func__,
6498 : : weight);
6499 : 6 : napi->weight = weight;
6500 : 6 : list_add(&napi->dev_list, &dev->napi_list);
6501 : 6 : napi->dev = dev;
6502 : : #ifdef CONFIG_NETPOLL
6503 : 6 : napi->poll_owner = -1;
6504 : : #endif
6505 : 6 : set_bit(NAPI_STATE_SCHED, &napi->state);
6506 : 6 : napi_hash_add(napi);
6507 : 6 : }
6508 : : EXPORT_SYMBOL(netif_napi_add);
6509 : :
6510 : 0 : void napi_disable(struct napi_struct *n)
6511 : : {
6512 : 0 : might_sleep();
6513 : 0 : set_bit(NAPI_STATE_DISABLE, &n->state);
6514 : :
6515 [ # # ]: 0 : while (test_and_set_bit(NAPI_STATE_SCHED, &n->state))
6516 : 0 : msleep(1);
6517 [ # # ]: 0 : while (test_and_set_bit(NAPI_STATE_NPSVC, &n->state))
6518 : 0 : msleep(1);
6519 : :
6520 : 0 : hrtimer_cancel(&n->timer);
6521 : :
6522 : 0 : clear_bit(NAPI_STATE_DISABLE, &n->state);
6523 : 0 : }
6524 : : EXPORT_SYMBOL(napi_disable);
6525 : :
6526 : 0 : static void flush_gro_hash(struct napi_struct *napi)
6527 : : {
6528 : 0 : int i;
6529 : :
6530 [ # # ]: 0 : for (i = 0; i < GRO_HASH_BUCKETS; i++) {
6531 : 0 : struct sk_buff *skb, *n;
6532 : :
6533 [ # # ]: 0 : list_for_each_entry_safe(skb, n, &napi->gro_hash[i].list, list)
6534 : 0 : kfree_skb(skb);
6535 : 0 : napi->gro_hash[i].count = 0;
6536 : : }
6537 : 0 : }
6538 : :
6539 : : /* Must be called in process context */
6540 : 0 : void netif_napi_del(struct napi_struct *napi)
6541 : : {
6542 : 0 : might_sleep();
6543 [ # # ]: 0 : if (napi_hash_del(napi))
6544 : 0 : synchronize_net();
6545 : 0 : list_del_init(&napi->dev_list);
6546 : 0 : napi_free_frags(napi);
6547 : :
6548 : 0 : flush_gro_hash(napi);
6549 : 0 : napi->gro_bitmask = 0;
6550 : 0 : }
6551 : : EXPORT_SYMBOL(netif_napi_del);
6552 : :
6553 : 3 : static int napi_poll(struct napi_struct *n, struct list_head *repoll)
6554 : : {
6555 : 3 : void *have;
6556 : 3 : int work, weight;
6557 : :
6558 : 3 : list_del_init(&n->poll_list);
6559 : :
6560 : 3 : have = netpoll_poll_lock(n);
6561 : :
6562 : 3 : weight = n->weight;
6563 : :
6564 : : /* This NAPI_STATE_SCHED test is for avoiding a race
6565 : : * with netpoll's poll_napi(). Only the entity which
6566 : : * obtains the lock and sees NAPI_STATE_SCHED set will
6567 : : * actually make the ->poll() call. Therefore we avoid
6568 : : * accidentally calling ->poll() when NAPI is not scheduled.
6569 : : */
6570 : 3 : work = 0;
6571 [ + - ]: 3 : if (test_bit(NAPI_STATE_SCHED, &n->state)) {
6572 : 3 : work = n->poll(n, weight);
6573 : 3 : trace_napi_poll(n, work, weight);
6574 : : }
6575 : :
6576 [ - + ]: 3 : WARN_ON_ONCE(work > weight);
6577 : :
6578 [ + - ]: 3 : if (likely(work < weight))
6579 : 3 : goto out_unlock;
6580 : :
6581 : : /* Drivers must not modify the NAPI state if they
6582 : : * consume the entire weight. In such cases this code
6583 : : * still "owns" the NAPI instance and therefore can
6584 : : * move the instance around on the list at-will.
6585 : : */
6586 [ # # ]: 0 : if (unlikely(napi_disable_pending(n))) {
6587 : 0 : napi_complete(n);
6588 : 0 : goto out_unlock;
6589 : : }
6590 : :
6591 [ # # ]: 0 : if (n->gro_bitmask) {
6592 : : /* flush too old packets
6593 : : * If HZ < 1000, flush all packets.
6594 : : */
6595 : 0 : napi_gro_flush(n, HZ >= 1000);
6596 : : }
6597 : :
6598 [ # # ]: 0 : gro_normal_list(n);
6599 : :
6600 : : /* Some drivers may have called napi_schedule
6601 : : * prior to exhausting their budget.
6602 : : */
6603 [ # # ]: 0 : if (unlikely(!list_empty(&n->poll_list))) {
6604 [ # # # # ]: 0 : pr_warn_once("%s: Budget exhausted after napi rescheduled\n",
6605 : : n->dev ? n->dev->name : "backlog");
6606 : 0 : goto out_unlock;
6607 : : }
6608 : :
6609 : 0 : list_add_tail(&n->poll_list, repoll);
6610 : :
6611 : 3 : out_unlock:
6612 [ - + ]: 3 : netpoll_poll_unlock(have);
6613 : :
6614 : 3 : return work;
6615 : : }
6616 : :
6617 : 3 : static __latent_entropy void net_rx_action(struct softirq_action *h)
6618 : : {
6619 : 3 : struct softnet_data *sd = this_cpu_ptr(&softnet_data);
6620 : 6 : unsigned long time_limit = jiffies +
6621 [ - + ]: 3 : usecs_to_jiffies(netdev_budget_usecs);
6622 : 3 : int budget = netdev_budget;
6623 : 3 : LIST_HEAD(list);
6624 : 3 : LIST_HEAD(repoll);
6625 : :
6626 : 3 : local_irq_disable();
6627 [ + - ]: 3 : list_splice_init(&sd->poll_list, &list);
6628 : 3 : local_irq_enable();
6629 : :
6630 : 6 : for (;;) {
6631 : 6 : struct napi_struct *n;
6632 : :
6633 [ + + ]: 6 : if (list_empty(&list)) {
6634 [ + - + - ]: 3 : if (!sd_has_rps_ipi_waiting(sd) && list_empty(&repoll))
6635 : 3 : goto out;
6636 : : break;
6637 : : }
6638 : :
6639 : 3 : n = list_first_entry(&list, struct napi_struct, poll_list);
6640 : 3 : budget -= napi_poll(n, &repoll);
6641 : :
6642 : : /* If softirq window is exhausted then punt.
6643 : : * Allow this to run for 2 jiffies since which will allow
6644 : : * an average latency of 1.5/HZ.
6645 : : */
6646 [ + - + - ]: 3 : if (unlikely(budget <= 0 ||
6647 : : time_after_eq(jiffies, time_limit))) {
6648 : 0 : sd->time_squeeze++;
6649 : 0 : break;
6650 : : }
6651 : : }
6652 : :
6653 : 0 : local_irq_disable();
6654 : :
6655 [ # # ]: 0 : list_splice_tail_init(&sd->poll_list, &list);
6656 [ # # ]: 0 : list_splice_tail(&repoll, &list);
6657 [ # # ]: 0 : list_splice(&list, &sd->poll_list);
6658 [ # # ]: 0 : if (!list_empty(&sd->poll_list))
6659 : 0 : __raise_softirq_irqoff(NET_RX_SOFTIRQ);
6660 : :
6661 [ # # ]: 0 : net_rps_action_and_irq_enable(sd);
6662 : 3 : out:
6663 : 3 : __kfree_skb_flush();
6664 : 3 : }
6665 : :
6666 : : struct netdev_adjacent {
6667 : : struct net_device *dev;
6668 : :
6669 : : /* upper master flag, there can only be one master device per list */
6670 : : bool master;
6671 : :
6672 : : /* lookup ignore flag */
6673 : : bool ignore;
6674 : :
6675 : : /* counter for the number of times this device was added to us */
6676 : : u16 ref_nr;
6677 : :
6678 : : /* private field for the users */
6679 : : void *private;
6680 : :
6681 : : struct list_head list;
6682 : : struct rcu_head rcu;
6683 : : };
6684 : :
6685 : 0 : static struct netdev_adjacent *__netdev_find_adj(struct net_device *adj_dev,
6686 : : struct list_head *adj_list)
6687 : : {
6688 : 0 : struct netdev_adjacent *adj;
6689 : :
6690 [ # # # # : 0 : list_for_each_entry(adj, adj_list, list) {
# # # # #
# ]
6691 [ # # # # : 0 : if (adj->dev == adj_dev)
# # # # #
# ]
6692 : : return adj;
6693 : : }
6694 : : return NULL;
6695 : : }
6696 : :
6697 : 0 : static int ____netdev_has_upper_dev(struct net_device *upper_dev, void *data)
6698 : : {
6699 : 0 : struct net_device *dev = data;
6700 : :
6701 : 0 : return upper_dev == dev;
6702 : : }
6703 : :
6704 : : /**
6705 : : * netdev_has_upper_dev - Check if device is linked to an upper device
6706 : : * @dev: device
6707 : : * @upper_dev: upper device to check
6708 : : *
6709 : : * Find out if a device is linked to specified upper device and return true
6710 : : * in case it is. Note that this checks only immediate upper device,
6711 : : * not through a complete stack of devices. The caller must hold the RTNL lock.
6712 : : */
6713 : 0 : bool netdev_has_upper_dev(struct net_device *dev,
6714 : : struct net_device *upper_dev)
6715 : : {
6716 [ # # # # ]: 0 : ASSERT_RTNL();
6717 : :
6718 : 0 : return netdev_walk_all_upper_dev_rcu(dev, ____netdev_has_upper_dev,
6719 : : upper_dev);
6720 : : }
6721 : : EXPORT_SYMBOL(netdev_has_upper_dev);
6722 : :
6723 : : /**
6724 : : * netdev_has_upper_dev_all - Check if device is linked to an upper device
6725 : : * @dev: device
6726 : : * @upper_dev: upper device to check
6727 : : *
6728 : : * Find out if a device is linked to specified upper device and return true
6729 : : * in case it is. Note that this checks the entire upper device chain.
6730 : : * The caller must hold rcu lock.
6731 : : */
6732 : :
6733 : 0 : bool netdev_has_upper_dev_all_rcu(struct net_device *dev,
6734 : : struct net_device *upper_dev)
6735 : : {
6736 : 0 : return !!netdev_walk_all_upper_dev_rcu(dev, ____netdev_has_upper_dev,
6737 : : upper_dev);
6738 : : }
6739 : : EXPORT_SYMBOL(netdev_has_upper_dev_all_rcu);
6740 : :
6741 : : /**
6742 : : * netdev_has_any_upper_dev - Check if device is linked to some device
6743 : : * @dev: device
6744 : : *
6745 : : * Find out if a device is linked to an upper device and return true in case
6746 : : * it is. The caller must hold the RTNL lock.
6747 : : */
6748 : 0 : bool netdev_has_any_upper_dev(struct net_device *dev)
6749 : : {
6750 [ # # # # ]: 0 : ASSERT_RTNL();
6751 : :
6752 : 0 : return !list_empty(&dev->adj_list.upper);
6753 : : }
6754 : : EXPORT_SYMBOL(netdev_has_any_upper_dev);
6755 : :
6756 : : /**
6757 : : * netdev_master_upper_dev_get - Get master upper device
6758 : : * @dev: device
6759 : : *
6760 : : * Find a master upper device and return pointer to it or NULL in case
6761 : : * it's not there. The caller must hold the RTNL lock.
6762 : : */
6763 : 24 : struct net_device *netdev_master_upper_dev_get(struct net_device *dev)
6764 : : {
6765 : 24 : struct netdev_adjacent *upper;
6766 : :
6767 [ - + - - ]: 24 : ASSERT_RTNL();
6768 : :
6769 [ - + ]: 24 : if (list_empty(&dev->adj_list.upper))
6770 : : return NULL;
6771 : :
6772 : 0 : upper = list_first_entry(&dev->adj_list.upper,
6773 : : struct netdev_adjacent, list);
6774 [ # # ]: 0 : if (likely(upper->master))
6775 : 0 : return upper->dev;
6776 : : return NULL;
6777 : : }
6778 : : EXPORT_SYMBOL(netdev_master_upper_dev_get);
6779 : :
6780 : 0 : static struct net_device *__netdev_master_upper_dev_get(struct net_device *dev)
6781 : : {
6782 : 0 : struct netdev_adjacent *upper;
6783 : :
6784 [ # # # # ]: 0 : ASSERT_RTNL();
6785 : :
6786 [ # # ]: 0 : if (list_empty(&dev->adj_list.upper))
6787 : : return NULL;
6788 : :
6789 : 0 : upper = list_first_entry(&dev->adj_list.upper,
6790 : : struct netdev_adjacent, list);
6791 [ # # # # ]: 0 : if (likely(upper->master) && !upper->ignore)
6792 : 0 : return upper->dev;
6793 : : return NULL;
6794 : : }
6795 : :
6796 : : /**
6797 : : * netdev_has_any_lower_dev - Check if device is linked to some device
6798 : : * @dev: device
6799 : : *
6800 : : * Find out if a device is linked to a lower device and return true in case
6801 : : * it is. The caller must hold the RTNL lock.
6802 : : */
6803 : 0 : static bool netdev_has_any_lower_dev(struct net_device *dev)
6804 : : {
6805 [ # # # # ]: 0 : ASSERT_RTNL();
6806 : :
6807 : 0 : return !list_empty(&dev->adj_list.lower);
6808 : : }
6809 : :
6810 : 0 : void *netdev_adjacent_get_private(struct list_head *adj_list)
6811 : : {
6812 : 0 : struct netdev_adjacent *adj;
6813 : :
6814 : 0 : adj = list_entry(adj_list, struct netdev_adjacent, list);
6815 : :
6816 : 0 : return adj->private;
6817 : : }
6818 : : EXPORT_SYMBOL(netdev_adjacent_get_private);
6819 : :
6820 : : /**
6821 : : * netdev_upper_get_next_dev_rcu - Get the next dev from upper list
6822 : : * @dev: device
6823 : : * @iter: list_head ** of the current position
6824 : : *
6825 : : * Gets the next device from the dev's upper list, starting from iter
6826 : : * position. The caller must hold RCU read lock.
6827 : : */
6828 : 18 : struct net_device *netdev_upper_get_next_dev_rcu(struct net_device *dev,
6829 : : struct list_head **iter)
6830 : : {
6831 : 18 : struct netdev_adjacent *upper;
6832 : :
6833 [ # # ]: 0 : WARN_ON_ONCE(!rcu_read_lock_held() && !lockdep_rtnl_is_held());
6834 : :
6835 [ - + - - : 18 : upper = list_entry_rcu((*iter)->next, struct netdev_adjacent, list);
- - ]
6836 : :
6837 [ - + - - : 18 : if (&upper->list == &dev->adj_list.upper)
- - ]
6838 : : return NULL;
6839 : :
6840 : 0 : *iter = &upper->list;
6841 : :
6842 : 0 : return upper->dev;
6843 : : }
6844 : : EXPORT_SYMBOL(netdev_upper_get_next_dev_rcu);
6845 : :
6846 : 0 : static struct net_device *__netdev_next_upper_dev(struct net_device *dev,
6847 : : struct list_head **iter,
6848 : : bool *ignore)
6849 : : {
6850 : 0 : struct netdev_adjacent *upper;
6851 : :
6852 : 0 : upper = list_entry((*iter)->next, struct netdev_adjacent, list);
6853 : :
6854 : 0 : if (&upper->list == &dev->adj_list.upper)
6855 : : return NULL;
6856 : :
6857 : 0 : *iter = &upper->list;
6858 : 0 : *ignore = upper->ignore;
6859 : :
6860 : 0 : return upper->dev;
6861 : : }
6862 : :
6863 : 0 : static struct net_device *netdev_next_upper_dev_rcu(struct net_device *dev,
6864 : : struct list_head **iter)
6865 : : {
6866 : 0 : struct netdev_adjacent *upper;
6867 : :
6868 : 0 : WARN_ON_ONCE(!rcu_read_lock_held() && !lockdep_rtnl_is_held());
6869 : :
6870 [ # # ]: 0 : upper = list_entry_rcu((*iter)->next, struct netdev_adjacent, list);
6871 : :
6872 [ # # ]: 0 : if (&upper->list == &dev->adj_list.upper)
6873 : : return NULL;
6874 : :
6875 : 0 : *iter = &upper->list;
6876 : :
6877 : 0 : return upper->dev;
6878 : : }
6879 : :
6880 : 0 : static int __netdev_walk_all_upper_dev(struct net_device *dev,
6881 : : int (*fn)(struct net_device *dev,
6882 : : void *data),
6883 : : void *data)
6884 : : {
6885 : 0 : struct net_device *udev, *next, *now, *dev_stack[MAX_NEST_DEV + 1];
6886 : 0 : struct list_head *niter, *iter, *iter_stack[MAX_NEST_DEV + 1];
6887 : 0 : int ret, cur = 0;
6888 : 0 : bool ignore;
6889 : :
6890 : 0 : now = dev;
6891 : 0 : iter = &dev->adj_list.upper;
6892 : :
6893 : 0 : while (1) {
6894 [ # # ]: 0 : if (now != dev) {
6895 : 0 : ret = fn(now, data);
6896 [ # # ]: 0 : if (ret)
6897 : 0 : return ret;
6898 : : }
6899 : :
6900 : : next = NULL;
6901 : 0 : while (1) {
6902 [ # # ]: 0 : udev = __netdev_next_upper_dev(now, &iter, &ignore);
6903 [ # # ]: 0 : if (!udev)
6904 : : break;
6905 [ # # ]: 0 : if (ignore)
6906 : 0 : continue;
6907 : :
6908 : 0 : next = udev;
6909 : 0 : niter = &udev->adj_list.upper;
6910 : 0 : dev_stack[cur] = now;
6911 : 0 : iter_stack[cur++] = iter;
6912 : 0 : break;
6913 : : }
6914 : :
6915 [ # # ]: 0 : if (!next) {
6916 [ # # ]: 0 : if (!cur)
6917 : : return 0;
6918 : 0 : next = dev_stack[--cur];
6919 : 0 : niter = iter_stack[cur];
6920 : : }
6921 : :
6922 : : now = next;
6923 : : iter = niter;
6924 : : }
6925 : :
6926 : : return 0;
6927 : : }
6928 : :
6929 : 0 : int netdev_walk_all_upper_dev_rcu(struct net_device *dev,
6930 : : int (*fn)(struct net_device *dev,
6931 : : void *data),
6932 : : void *data)
6933 : : {
6934 : 0 : struct net_device *udev, *next, *now, *dev_stack[MAX_NEST_DEV + 1];
6935 : 0 : struct list_head *niter, *iter, *iter_stack[MAX_NEST_DEV + 1];
6936 : 0 : int ret, cur = 0;
6937 : :
6938 : 0 : now = dev;
6939 : 0 : iter = &dev->adj_list.upper;
6940 : :
6941 : 0 : while (1) {
6942 [ # # ]: 0 : if (now != dev) {
6943 : 0 : ret = fn(now, data);
6944 [ # # ]: 0 : if (ret)
6945 : 0 : return ret;
6946 : : }
6947 : :
6948 : 0 : next = NULL;
6949 : 0 : while (1) {
6950 [ # # ]: 0 : udev = netdev_next_upper_dev_rcu(now, &iter);
6951 [ # # ]: 0 : if (!udev)
6952 : : break;
6953 : :
6954 : 0 : next = udev;
6955 : 0 : niter = &udev->adj_list.upper;
6956 : 0 : dev_stack[cur] = now;
6957 : 0 : iter_stack[cur++] = iter;
6958 : 0 : break;
6959 : : }
6960 : :
6961 [ # # ]: 0 : if (!next) {
6962 [ # # ]: 0 : if (!cur)
6963 : : return 0;
6964 : 0 : next = dev_stack[--cur];
6965 : 0 : niter = iter_stack[cur];
6966 : : }
6967 : :
6968 : : now = next;
6969 : : iter = niter;
6970 : : }
6971 : :
6972 : : return 0;
6973 : : }
6974 : : EXPORT_SYMBOL_GPL(netdev_walk_all_upper_dev_rcu);
6975 : :
6976 : 0 : static bool __netdev_has_upper_dev(struct net_device *dev,
6977 : : struct net_device *upper_dev)
6978 : : {
6979 [ # # # # ]: 0 : ASSERT_RTNL();
6980 : :
6981 : 0 : return __netdev_walk_all_upper_dev(dev, ____netdev_has_upper_dev,
6982 : : upper_dev);
6983 : : }
6984 : :
6985 : : /**
6986 : : * netdev_lower_get_next_private - Get the next ->private from the
6987 : : * lower neighbour list
6988 : : * @dev: device
6989 : : * @iter: list_head ** of the current position
6990 : : *
6991 : : * Gets the next netdev_adjacent->private from the dev's lower neighbour
6992 : : * list, starting from iter position. The caller must hold either hold the
6993 : : * RTNL lock or its own locking that guarantees that the neighbour lower
6994 : : * list will remain unchanged.
6995 : : */
6996 : 0 : void *netdev_lower_get_next_private(struct net_device *dev,
6997 : : struct list_head **iter)
6998 : : {
6999 : 0 : struct netdev_adjacent *lower;
7000 : :
7001 : 0 : lower = list_entry(*iter, struct netdev_adjacent, list);
7002 : :
7003 [ # # ]: 0 : if (&lower->list == &dev->adj_list.lower)
7004 : : return NULL;
7005 : :
7006 : 0 : *iter = lower->list.next;
7007 : :
7008 : 0 : return lower->private;
7009 : : }
7010 : : EXPORT_SYMBOL(netdev_lower_get_next_private);
7011 : :
7012 : : /**
7013 : : * netdev_lower_get_next_private_rcu - Get the next ->private from the
7014 : : * lower neighbour list, RCU
7015 : : * variant
7016 : : * @dev: device
7017 : : * @iter: list_head ** of the current position
7018 : : *
7019 : : * Gets the next netdev_adjacent->private from the dev's lower neighbour
7020 : : * list, starting from iter position. The caller must hold RCU read lock.
7021 : : */
7022 : 0 : void *netdev_lower_get_next_private_rcu(struct net_device *dev,
7023 : : struct list_head **iter)
7024 : : {
7025 : 0 : struct netdev_adjacent *lower;
7026 : :
7027 [ # # ]: 0 : WARN_ON_ONCE(!rcu_read_lock_held());
7028 : :
7029 [ # # ]: 0 : lower = list_entry_rcu((*iter)->next, struct netdev_adjacent, list);
7030 : :
7031 [ # # ]: 0 : if (&lower->list == &dev->adj_list.lower)
7032 : : return NULL;
7033 : :
7034 : 0 : *iter = &lower->list;
7035 : :
7036 : 0 : return lower->private;
7037 : : }
7038 : : EXPORT_SYMBOL(netdev_lower_get_next_private_rcu);
7039 : :
7040 : : /**
7041 : : * netdev_lower_get_next - Get the next device from the lower neighbour
7042 : : * list
7043 : : * @dev: device
7044 : : * @iter: list_head ** of the current position
7045 : : *
7046 : : * Gets the next netdev_adjacent from the dev's lower neighbour
7047 : : * list, starting from iter position. The caller must hold RTNL lock or
7048 : : * its own locking that guarantees that the neighbour lower
7049 : : * list will remain unchanged.
7050 : : */
7051 : 18 : void *netdev_lower_get_next(struct net_device *dev, struct list_head **iter)
7052 : : {
7053 : 18 : struct netdev_adjacent *lower;
7054 : :
7055 : 18 : lower = list_entry(*iter, struct netdev_adjacent, list);
7056 : :
7057 [ # # # # : 0 : if (&lower->list == &dev->adj_list.lower)
# # ]
7058 : : return NULL;
7059 : :
7060 : 0 : *iter = lower->list.next;
7061 : :
7062 : 0 : return lower->dev;
7063 : : }
7064 : : EXPORT_SYMBOL(netdev_lower_get_next);
7065 : :
7066 : 0 : static struct net_device *netdev_next_lower_dev(struct net_device *dev,
7067 : : struct list_head **iter)
7068 : : {
7069 : 0 : struct netdev_adjacent *lower;
7070 : :
7071 : 0 : lower = list_entry((*iter)->next, struct netdev_adjacent, list);
7072 : :
7073 : 0 : if (&lower->list == &dev->adj_list.lower)
7074 : : return NULL;
7075 : :
7076 : 0 : *iter = &lower->list;
7077 : :
7078 : 0 : return lower->dev;
7079 : : }
7080 : :
7081 : 0 : static struct net_device *__netdev_next_lower_dev(struct net_device *dev,
7082 : : struct list_head **iter,
7083 : : bool *ignore)
7084 : : {
7085 : 0 : struct netdev_adjacent *lower;
7086 : :
7087 : 0 : lower = list_entry((*iter)->next, struct netdev_adjacent, list);
7088 : :
7089 : 0 : if (&lower->list == &dev->adj_list.lower)
7090 : : return NULL;
7091 : :
7092 : 0 : *iter = &lower->list;
7093 : 0 : *ignore = lower->ignore;
7094 : :
7095 : 0 : return lower->dev;
7096 : : }
7097 : :
7098 : 0 : int netdev_walk_all_lower_dev(struct net_device *dev,
7099 : : int (*fn)(struct net_device *dev,
7100 : : void *data),
7101 : : void *data)
7102 : : {
7103 : 0 : struct net_device *ldev, *next, *now, *dev_stack[MAX_NEST_DEV + 1];
7104 : 0 : struct list_head *niter, *iter, *iter_stack[MAX_NEST_DEV + 1];
7105 : 0 : int ret, cur = 0;
7106 : :
7107 : 0 : now = dev;
7108 : 0 : iter = &dev->adj_list.lower;
7109 : :
7110 : 0 : while (1) {
7111 [ # # ]: 0 : if (now != dev) {
7112 : 0 : ret = fn(now, data);
7113 [ # # ]: 0 : if (ret)
7114 : 0 : return ret;
7115 : : }
7116 : :
7117 : 0 : next = NULL;
7118 : 0 : while (1) {
7119 [ # # ]: 0 : ldev = netdev_next_lower_dev(now, &iter);
7120 [ # # ]: 0 : if (!ldev)
7121 : : break;
7122 : :
7123 : 0 : next = ldev;
7124 : 0 : niter = &ldev->adj_list.lower;
7125 : 0 : dev_stack[cur] = now;
7126 : 0 : iter_stack[cur++] = iter;
7127 : 0 : break;
7128 : : }
7129 : :
7130 [ # # ]: 0 : if (!next) {
7131 [ # # ]: 0 : if (!cur)
7132 : : return 0;
7133 : 0 : next = dev_stack[--cur];
7134 : 0 : niter = iter_stack[cur];
7135 : : }
7136 : :
7137 : : now = next;
7138 : : iter = niter;
7139 : : }
7140 : :
7141 : : return 0;
7142 : : }
7143 : : EXPORT_SYMBOL_GPL(netdev_walk_all_lower_dev);
7144 : :
7145 : 0 : static int __netdev_walk_all_lower_dev(struct net_device *dev,
7146 : : int (*fn)(struct net_device *dev,
7147 : : void *data),
7148 : : void *data)
7149 : : {
7150 : 0 : struct net_device *ldev, *next, *now, *dev_stack[MAX_NEST_DEV + 1];
7151 : 0 : struct list_head *niter, *iter, *iter_stack[MAX_NEST_DEV + 1];
7152 : 0 : int ret, cur = 0;
7153 : 0 : bool ignore;
7154 : :
7155 : 0 : now = dev;
7156 : 0 : iter = &dev->adj_list.lower;
7157 : :
7158 : 0 : while (1) {
7159 [ # # ]: 0 : if (now != dev) {
7160 : 0 : ret = fn(now, data);
7161 [ # # ]: 0 : if (ret)
7162 : 0 : return ret;
7163 : : }
7164 : :
7165 : : next = NULL;
7166 : 0 : while (1) {
7167 [ # # ]: 0 : ldev = __netdev_next_lower_dev(now, &iter, &ignore);
7168 [ # # ]: 0 : if (!ldev)
7169 : : break;
7170 [ # # ]: 0 : if (ignore)
7171 : 0 : continue;
7172 : :
7173 : 0 : next = ldev;
7174 : 0 : niter = &ldev->adj_list.lower;
7175 : 0 : dev_stack[cur] = now;
7176 : 0 : iter_stack[cur++] = iter;
7177 : 0 : break;
7178 : : }
7179 : :
7180 [ # # ]: 0 : if (!next) {
7181 [ # # ]: 0 : if (!cur)
7182 : : return 0;
7183 : 0 : next = dev_stack[--cur];
7184 : 0 : niter = iter_stack[cur];
7185 : : }
7186 : :
7187 : : now = next;
7188 : : iter = niter;
7189 : : }
7190 : :
7191 : : return 0;
7192 : : }
7193 : :
7194 : 0 : struct net_device *netdev_next_lower_dev_rcu(struct net_device *dev,
7195 : : struct list_head **iter)
7196 : : {
7197 : 0 : struct netdev_adjacent *lower;
7198 : :
7199 [ # # ]: 0 : lower = list_entry_rcu((*iter)->next, struct netdev_adjacent, list);
7200 [ # # # # ]: 0 : if (&lower->list == &dev->adj_list.lower)
7201 : : return NULL;
7202 : :
7203 : 0 : *iter = &lower->list;
7204 : :
7205 : 0 : return lower->dev;
7206 : : }
7207 : : EXPORT_SYMBOL(netdev_next_lower_dev_rcu);
7208 : :
7209 : 0 : static u8 __netdev_upper_depth(struct net_device *dev)
7210 : : {
7211 : 0 : struct net_device *udev;
7212 : 0 : struct list_head *iter;
7213 : 0 : u8 max_depth = 0;
7214 : 0 : bool ignore;
7215 : :
7216 : 0 : for (iter = &dev->adj_list.upper,
7217 : : udev = __netdev_next_upper_dev(dev, &iter, &ignore);
7218 [ # # # # : 0 : udev;
# # ]
7219 [ # # # # : 0 : udev = __netdev_next_upper_dev(dev, &iter, &ignore)) {
# # ]
7220 [ # # # # : 0 : if (ignore)
# # ]
7221 : 0 : continue;
7222 : 0 : if (max_depth < udev->upper_level)
7223 : : max_depth = udev->upper_level;
7224 : : }
7225 : :
7226 : 0 : return max_depth;
7227 : : }
7228 : :
7229 : 0 : static u8 __netdev_lower_depth(struct net_device *dev)
7230 : : {
7231 : 0 : struct net_device *ldev;
7232 : 0 : struct list_head *iter;
7233 : 0 : u8 max_depth = 0;
7234 : 0 : bool ignore;
7235 : :
7236 : 0 : for (iter = &dev->adj_list.lower,
7237 : : ldev = __netdev_next_lower_dev(dev, &iter, &ignore);
7238 [ # # # # : 0 : ldev;
# # ]
7239 [ # # # # : 0 : ldev = __netdev_next_lower_dev(dev, &iter, &ignore)) {
# # ]
7240 [ # # # # : 0 : if (ignore)
# # ]
7241 : 0 : continue;
7242 : 0 : if (max_depth < ldev->lower_level)
7243 : : max_depth = ldev->lower_level;
7244 : : }
7245 : :
7246 : 0 : return max_depth;
7247 : : }
7248 : :
7249 : 0 : static int __netdev_update_upper_level(struct net_device *dev, void *data)
7250 : : {
7251 [ # # ]: 0 : dev->upper_level = __netdev_upper_depth(dev) + 1;
7252 : 0 : return 0;
7253 : : }
7254 : :
7255 : 0 : static int __netdev_update_lower_level(struct net_device *dev, void *data)
7256 : : {
7257 [ # # ]: 0 : dev->lower_level = __netdev_lower_depth(dev) + 1;
7258 : 0 : return 0;
7259 : : }
7260 : :
7261 : 0 : int netdev_walk_all_lower_dev_rcu(struct net_device *dev,
7262 : : int (*fn)(struct net_device *dev,
7263 : : void *data),
7264 : : void *data)
7265 : : {
7266 : 0 : struct net_device *ldev, *next, *now, *dev_stack[MAX_NEST_DEV + 1];
7267 : 0 : struct list_head *niter, *iter, *iter_stack[MAX_NEST_DEV + 1];
7268 : 0 : int ret, cur = 0;
7269 : :
7270 : 0 : now = dev;
7271 : 0 : iter = &dev->adj_list.lower;
7272 : :
7273 : 0 : while (1) {
7274 [ # # ]: 0 : if (now != dev) {
7275 : 0 : ret = fn(now, data);
7276 [ # # ]: 0 : if (ret)
7277 : 0 : return ret;
7278 : : }
7279 : :
7280 : 0 : next = NULL;
7281 : 0 : while (1) {
7282 [ # # ]: 0 : ldev = netdev_next_lower_dev_rcu(now, &iter);
7283 [ # # ]: 0 : if (!ldev)
7284 : : break;
7285 : :
7286 : 0 : next = ldev;
7287 : 0 : niter = &ldev->adj_list.lower;
7288 : 0 : dev_stack[cur] = now;
7289 : 0 : iter_stack[cur++] = iter;
7290 : 0 : break;
7291 : : }
7292 : :
7293 [ # # ]: 0 : if (!next) {
7294 [ # # ]: 0 : if (!cur)
7295 : : return 0;
7296 : 0 : next = dev_stack[--cur];
7297 : 0 : niter = iter_stack[cur];
7298 : : }
7299 : :
7300 : : now = next;
7301 : : iter = niter;
7302 : : }
7303 : :
7304 : : return 0;
7305 : : }
7306 : : EXPORT_SYMBOL_GPL(netdev_walk_all_lower_dev_rcu);
7307 : :
7308 : : /**
7309 : : * netdev_lower_get_first_private_rcu - Get the first ->private from the
7310 : : * lower neighbour list, RCU
7311 : : * variant
7312 : : * @dev: device
7313 : : *
7314 : : * Gets the first netdev_adjacent->private from the dev's lower neighbour
7315 : : * list. The caller must hold RCU read lock.
7316 : : */
7317 : 0 : void *netdev_lower_get_first_private_rcu(struct net_device *dev)
7318 : : {
7319 : 0 : struct netdev_adjacent *lower;
7320 : :
7321 [ # # # # ]: 0 : lower = list_first_or_null_rcu(&dev->adj_list.lower,
7322 : : struct netdev_adjacent, list);
7323 [ # # ]: 0 : if (lower)
7324 : 0 : return lower->private;
7325 : : return NULL;
7326 : : }
7327 : : EXPORT_SYMBOL(netdev_lower_get_first_private_rcu);
7328 : :
7329 : : /**
7330 : : * netdev_master_upper_dev_get_rcu - Get master upper device
7331 : : * @dev: device
7332 : : *
7333 : : * Find a master upper device and return pointer to it or NULL in case
7334 : : * it's not there. The caller must hold the RCU read lock.
7335 : : */
7336 : 108 : struct net_device *netdev_master_upper_dev_get_rcu(struct net_device *dev)
7337 : : {
7338 : 108 : struct netdev_adjacent *upper;
7339 : :
7340 [ + - - - ]: 108 : upper = list_first_or_null_rcu(&dev->adj_list.upper,
7341 : : struct netdev_adjacent, list);
7342 [ - - - - ]: 108 : if (upper && likely(upper->master))
7343 : 0 : return upper->dev;
7344 : : return NULL;
7345 : : }
7346 : : EXPORT_SYMBOL(netdev_master_upper_dev_get_rcu);
7347 : :
7348 : 0 : static int netdev_adjacent_sysfs_add(struct net_device *dev,
7349 : : struct net_device *adj_dev,
7350 : : struct list_head *dev_list)
7351 : : {
7352 : 0 : char linkname[IFNAMSIZ+7];
7353 : :
7354 : 0 : sprintf(linkname, dev_list == &dev->adj_list.upper ?
7355 [ # # ]: 0 : "upper_%s" : "lower_%s", adj_dev->name);
7356 : 0 : return sysfs_create_link(&(dev->dev.kobj), &(adj_dev->dev.kobj),
7357 : : linkname);
7358 : : }
7359 : 0 : static void netdev_adjacent_sysfs_del(struct net_device *dev,
7360 : : char *name,
7361 : : struct list_head *dev_list)
7362 : : {
7363 : 0 : char linkname[IFNAMSIZ+7];
7364 : :
7365 [ # # ]: 0 : sprintf(linkname, dev_list == &dev->adj_list.upper ?
7366 : : "upper_%s" : "lower_%s", name);
7367 : 0 : sysfs_remove_link(&(dev->dev.kobj), linkname);
7368 : 0 : }
7369 : :
7370 : 0 : static inline bool netdev_adjacent_is_neigh_list(struct net_device *dev,
7371 : : struct net_device *adj_dev,
7372 : : struct list_head *dev_list)
7373 : : {
7374 : 0 : return (dev_list == &dev->adj_list.upper ||
7375 [ # # # # : 0 : dev_list == &dev->adj_list.lower) &&
# # # # #
# # # ]
7376 : : net_eq(dev_net(dev), dev_net(adj_dev));
7377 : : }
7378 : :
7379 : 0 : static int __netdev_adjacent_dev_insert(struct net_device *dev,
7380 : : struct net_device *adj_dev,
7381 : : struct list_head *dev_list,
7382 : : void *private, bool master)
7383 : : {
7384 : 0 : struct netdev_adjacent *adj;
7385 : 0 : int ret;
7386 : :
7387 : 0 : adj = __netdev_find_adj(adj_dev, dev_list);
7388 : :
7389 [ # # ]: 0 : if (adj) {
7390 : 0 : adj->ref_nr += 1;
7391 : 0 : pr_debug("Insert adjacency: dev %s adj_dev %s adj->ref_nr %d\n",
7392 : : dev->name, adj_dev->name, adj->ref_nr);
7393 : :
7394 : 0 : return 0;
7395 : : }
7396 : :
7397 : 0 : adj = kmalloc(sizeof(*adj), GFP_KERNEL);
7398 [ # # ]: 0 : if (!adj)
7399 : : return -ENOMEM;
7400 : :
7401 : 0 : adj->dev = adj_dev;
7402 : 0 : adj->master = master;
7403 : 0 : adj->ref_nr = 1;
7404 : 0 : adj->private = private;
7405 : 0 : adj->ignore = false;
7406 : 0 : dev_hold(adj_dev);
7407 : :
7408 : 0 : pr_debug("Insert adjacency: dev %s adj_dev %s adj->ref_nr %d; dev_hold on %s\n",
7409 : : dev->name, adj_dev->name, adj->ref_nr, adj_dev->name);
7410 : :
7411 [ # # # # ]: 0 : if (netdev_adjacent_is_neigh_list(dev, adj_dev, dev_list)) {
7412 : 0 : ret = netdev_adjacent_sysfs_add(dev, adj_dev, dev_list);
7413 [ # # ]: 0 : if (ret)
7414 : 0 : goto free_adj;
7415 : : }
7416 : :
7417 : : /* Ensure that master link is always the first item in list. */
7418 [ # # ]: 0 : if (master) {
7419 : 0 : ret = sysfs_create_link(&(dev->dev.kobj),
7420 : : &(adj_dev->dev.kobj), "master");
7421 [ # # ]: 0 : if (ret)
7422 : 0 : goto remove_symlinks;
7423 : :
7424 : 0 : list_add_rcu(&adj->list, dev_list);
7425 : : } else {
7426 : 0 : list_add_tail_rcu(&adj->list, dev_list);
7427 : : }
7428 : :
7429 : : return 0;
7430 : :
7431 : : remove_symlinks:
7432 [ # # # # ]: 0 : if (netdev_adjacent_is_neigh_list(dev, adj_dev, dev_list))
7433 : 0 : netdev_adjacent_sysfs_del(dev, adj_dev->name, dev_list);
7434 : 0 : free_adj:
7435 : 0 : kfree(adj);
7436 : 0 : dev_put(adj_dev);
7437 : :
7438 : 0 : return ret;
7439 : : }
7440 : :
7441 : 0 : static void __netdev_adjacent_dev_remove(struct net_device *dev,
7442 : : struct net_device *adj_dev,
7443 : : u16 ref_nr,
7444 : : struct list_head *dev_list)
7445 : : {
7446 : 0 : struct netdev_adjacent *adj;
7447 : :
7448 : 0 : pr_debug("Remove adjacency: dev %s adj_dev %s ref_nr %d\n",
7449 : : dev->name, adj_dev->name, ref_nr);
7450 : :
7451 : 0 : adj = __netdev_find_adj(adj_dev, dev_list);
7452 : :
7453 [ # # ]: 0 : if (!adj) {
7454 : 0 : pr_err("Adjacency does not exist for device %s from %s\n",
7455 : : dev->name, adj_dev->name);
7456 : 0 : WARN_ON(1);
7457 : 0 : return;
7458 : : }
7459 : :
7460 [ # # ]: 0 : if (adj->ref_nr > ref_nr) {
7461 : 0 : pr_debug("adjacency: %s to %s ref_nr - %d = %d\n",
7462 : : dev->name, adj_dev->name, ref_nr,
7463 : : adj->ref_nr - ref_nr);
7464 : 0 : adj->ref_nr -= ref_nr;
7465 : 0 : return;
7466 : : }
7467 : :
7468 [ # # ]: 0 : if (adj->master)
7469 : 0 : sysfs_remove_link(&(dev->dev.kobj), "master");
7470 : :
7471 [ # # # # ]: 0 : if (netdev_adjacent_is_neigh_list(dev, adj_dev, dev_list))
7472 : 0 : netdev_adjacent_sysfs_del(dev, adj_dev->name, dev_list);
7473 : :
7474 : 0 : list_del_rcu(&adj->list);
7475 : 0 : pr_debug("adjacency: dev_put for %s, because link removed from %s to %s\n",
7476 : : adj_dev->name, dev->name, adj_dev->name);
7477 : 0 : dev_put(adj_dev);
7478 : 0 : kfree_rcu(adj, rcu);
7479 : : }
7480 : :
7481 : 0 : static int __netdev_adjacent_dev_link_lists(struct net_device *dev,
7482 : : struct net_device *upper_dev,
7483 : : struct list_head *up_list,
7484 : : struct list_head *down_list,
7485 : : void *private, bool master)
7486 : : {
7487 : 0 : int ret;
7488 : :
7489 : 0 : ret = __netdev_adjacent_dev_insert(dev, upper_dev, up_list,
7490 : : private, master);
7491 [ # # ]: 0 : if (ret)
7492 : : return ret;
7493 : :
7494 : 0 : ret = __netdev_adjacent_dev_insert(upper_dev, dev, down_list,
7495 : : private, false);
7496 [ # # ]: 0 : if (ret) {
7497 : 0 : __netdev_adjacent_dev_remove(dev, upper_dev, 1, up_list);
7498 : 0 : return ret;
7499 : : }
7500 : :
7501 : : return 0;
7502 : : }
7503 : :
7504 : 0 : static void __netdev_adjacent_dev_unlink_lists(struct net_device *dev,
7505 : : struct net_device *upper_dev,
7506 : : u16 ref_nr,
7507 : : struct list_head *up_list,
7508 : : struct list_head *down_list)
7509 : : {
7510 : 0 : __netdev_adjacent_dev_remove(dev, upper_dev, ref_nr, up_list);
7511 : 0 : __netdev_adjacent_dev_remove(upper_dev, dev, ref_nr, down_list);
7512 : : }
7513 : :
7514 : 0 : static int __netdev_adjacent_dev_link_neighbour(struct net_device *dev,
7515 : : struct net_device *upper_dev,
7516 : : void *private, bool master)
7517 : : {
7518 : 0 : return __netdev_adjacent_dev_link_lists(dev, upper_dev,
7519 : : &dev->adj_list.upper,
7520 : : &upper_dev->adj_list.lower,
7521 : : private, master);
7522 : : }
7523 : :
7524 : 0 : static void __netdev_adjacent_dev_unlink_neighbour(struct net_device *dev,
7525 : : struct net_device *upper_dev)
7526 : : {
7527 : 0 : __netdev_adjacent_dev_unlink_lists(dev, upper_dev, 1,
7528 : : &dev->adj_list.upper,
7529 : : &upper_dev->adj_list.lower);
7530 : 0 : }
7531 : :
7532 : 0 : static int __netdev_upper_dev_link(struct net_device *dev,
7533 : : struct net_device *upper_dev, bool master,
7534 : : void *upper_priv, void *upper_info,
7535 : : struct netlink_ext_ack *extack)
7536 : : {
7537 : 0 : struct netdev_notifier_changeupper_info changeupper_info = {
7538 : : .info = {
7539 : : .dev = dev,
7540 : : .extack = extack,
7541 : : },
7542 : : .upper_dev = upper_dev,
7543 : : .master = master,
7544 : : .linking = true,
7545 : : .upper_info = upper_info,
7546 : : };
7547 : 0 : struct net_device *master_dev;
7548 : 0 : int ret = 0;
7549 : :
7550 [ # # # # ]: 0 : ASSERT_RTNL();
7551 : :
7552 [ # # ]: 0 : if (dev == upper_dev)
7553 : : return -EBUSY;
7554 : :
7555 : : /* To prevent loops, check if dev is not upper device to upper_dev. */
7556 [ # # ]: 0 : if (__netdev_has_upper_dev(upper_dev, dev))
7557 : : return -EBUSY;
7558 : :
7559 [ # # ]: 0 : if ((dev->lower_level + upper_dev->upper_level) > MAX_NEST_DEV)
7560 : : return -EMLINK;
7561 : :
7562 [ # # ]: 0 : if (!master) {
7563 [ # # ]: 0 : if (__netdev_has_upper_dev(dev, upper_dev))
7564 : : return -EEXIST;
7565 : : } else {
7566 : 0 : master_dev = __netdev_master_upper_dev_get(dev);
7567 [ # # ]: 0 : if (master_dev)
7568 [ # # ]: 0 : return master_dev == upper_dev ? -EEXIST : -EBUSY;
7569 : : }
7570 : :
7571 : 0 : ret = call_netdevice_notifiers_info(NETDEV_PRECHANGEUPPER,
7572 : : &changeupper_info.info);
7573 [ # # ]: 0 : ret = notifier_to_errno(ret);
7574 : 0 : if (ret)
7575 : 0 : return ret;
7576 : :
7577 : 0 : ret = __netdev_adjacent_dev_link_neighbour(dev, upper_dev, upper_priv,
7578 : : master);
7579 [ # # ]: 0 : if (ret)
7580 : : return ret;
7581 : :
7582 : 0 : ret = call_netdevice_notifiers_info(NETDEV_CHANGEUPPER,
7583 : : &changeupper_info.info);
7584 [ # # ]: 0 : ret = notifier_to_errno(ret);
7585 : 0 : if (ret)
7586 : 0 : goto rollback;
7587 : :
7588 [ # # ]: 0 : __netdev_update_upper_level(dev, NULL);
7589 : 0 : __netdev_walk_all_lower_dev(dev, __netdev_update_upper_level, NULL);
7590 : :
7591 [ # # ]: 0 : __netdev_update_lower_level(upper_dev, NULL);
7592 : 0 : __netdev_walk_all_upper_dev(upper_dev, __netdev_update_lower_level,
7593 : : NULL);
7594 : :
7595 : 0 : return 0;
7596 : :
7597 : : rollback:
7598 : 0 : __netdev_adjacent_dev_unlink_neighbour(dev, upper_dev);
7599 : :
7600 : 0 : return ret;
7601 : : }
7602 : :
7603 : : /**
7604 : : * netdev_upper_dev_link - Add a link to the upper device
7605 : : * @dev: device
7606 : : * @upper_dev: new upper device
7607 : : * @extack: netlink extended ack
7608 : : *
7609 : : * Adds a link to device which is upper to this one. The caller must hold
7610 : : * the RTNL lock. On a failure a negative errno code is returned.
7611 : : * On success the reference counts are adjusted and the function
7612 : : * returns zero.
7613 : : */
7614 : 0 : int netdev_upper_dev_link(struct net_device *dev,
7615 : : struct net_device *upper_dev,
7616 : : struct netlink_ext_ack *extack)
7617 : : {
7618 : 0 : return __netdev_upper_dev_link(dev, upper_dev, false,
7619 : : NULL, NULL, extack);
7620 : : }
7621 : : EXPORT_SYMBOL(netdev_upper_dev_link);
7622 : :
7623 : : /**
7624 : : * netdev_master_upper_dev_link - Add a master link to the upper device
7625 : : * @dev: device
7626 : : * @upper_dev: new upper device
7627 : : * @upper_priv: upper device private
7628 : : * @upper_info: upper info to be passed down via notifier
7629 : : * @extack: netlink extended ack
7630 : : *
7631 : : * Adds a link to device which is upper to this one. In this case, only
7632 : : * one master upper device can be linked, although other non-master devices
7633 : : * might be linked as well. The caller must hold the RTNL lock.
7634 : : * On a failure a negative errno code is returned. On success the reference
7635 : : * counts are adjusted and the function returns zero.
7636 : : */
7637 : 0 : int netdev_master_upper_dev_link(struct net_device *dev,
7638 : : struct net_device *upper_dev,
7639 : : void *upper_priv, void *upper_info,
7640 : : struct netlink_ext_ack *extack)
7641 : : {
7642 : 0 : return __netdev_upper_dev_link(dev, upper_dev, true,
7643 : : upper_priv, upper_info, extack);
7644 : : }
7645 : : EXPORT_SYMBOL(netdev_master_upper_dev_link);
7646 : :
7647 : : /**
7648 : : * netdev_upper_dev_unlink - Removes a link to upper device
7649 : : * @dev: device
7650 : : * @upper_dev: new upper device
7651 : : *
7652 : : * Removes a link to device which is upper to this one. The caller must hold
7653 : : * the RTNL lock.
7654 : : */
7655 : 0 : void netdev_upper_dev_unlink(struct net_device *dev,
7656 : : struct net_device *upper_dev)
7657 : : {
7658 : 0 : struct netdev_notifier_changeupper_info changeupper_info = {
7659 : : .info = {
7660 : : .dev = dev,
7661 : : },
7662 : : .upper_dev = upper_dev,
7663 : : .linking = false,
7664 : : };
7665 : :
7666 [ # # # # ]: 0 : ASSERT_RTNL();
7667 : :
7668 : 0 : changeupper_info.master = netdev_master_upper_dev_get(dev) == upper_dev;
7669 : :
7670 : 0 : call_netdevice_notifiers_info(NETDEV_PRECHANGEUPPER,
7671 : : &changeupper_info.info);
7672 : :
7673 : 0 : __netdev_adjacent_dev_unlink_neighbour(dev, upper_dev);
7674 : :
7675 : 0 : call_netdevice_notifiers_info(NETDEV_CHANGEUPPER,
7676 : : &changeupper_info.info);
7677 : :
7678 [ # # ]: 0 : __netdev_update_upper_level(dev, NULL);
7679 : 0 : __netdev_walk_all_lower_dev(dev, __netdev_update_upper_level, NULL);
7680 : :
7681 [ # # ]: 0 : __netdev_update_lower_level(upper_dev, NULL);
7682 : 0 : __netdev_walk_all_upper_dev(upper_dev, __netdev_update_lower_level,
7683 : : NULL);
7684 : 0 : }
7685 : : EXPORT_SYMBOL(netdev_upper_dev_unlink);
7686 : :
7687 : 0 : static void __netdev_adjacent_dev_set(struct net_device *upper_dev,
7688 : : struct net_device *lower_dev,
7689 : : bool val)
7690 : : {
7691 : 0 : struct netdev_adjacent *adj;
7692 : :
7693 : 0 : adj = __netdev_find_adj(lower_dev, &upper_dev->adj_list.lower);
7694 [ # # ]: 0 : if (adj)
7695 : 0 : adj->ignore = val;
7696 : :
7697 : 0 : adj = __netdev_find_adj(upper_dev, &lower_dev->adj_list.upper);
7698 [ # # ]: 0 : if (adj)
7699 : 0 : adj->ignore = val;
7700 : 0 : }
7701 : :
7702 : 0 : static void netdev_adjacent_dev_disable(struct net_device *upper_dev,
7703 : : struct net_device *lower_dev)
7704 : : {
7705 : 0 : __netdev_adjacent_dev_set(upper_dev, lower_dev, true);
7706 : 0 : }
7707 : :
7708 : 0 : static void netdev_adjacent_dev_enable(struct net_device *upper_dev,
7709 : : struct net_device *lower_dev)
7710 : : {
7711 : 0 : __netdev_adjacent_dev_set(upper_dev, lower_dev, false);
7712 : 0 : }
7713 : :
7714 : 0 : int netdev_adjacent_change_prepare(struct net_device *old_dev,
7715 : : struct net_device *new_dev,
7716 : : struct net_device *dev,
7717 : : struct netlink_ext_ack *extack)
7718 : : {
7719 : 0 : int err;
7720 : :
7721 [ # # ]: 0 : if (!new_dev)
7722 : : return 0;
7723 : :
7724 [ # # ]: 0 : if (old_dev && new_dev != old_dev)
7725 : 0 : netdev_adjacent_dev_disable(dev, old_dev);
7726 : :
7727 : 0 : err = netdev_upper_dev_link(new_dev, dev, extack);
7728 [ # # ]: 0 : if (err) {
7729 [ # # ]: 0 : if (old_dev && new_dev != old_dev)
7730 : 0 : netdev_adjacent_dev_enable(dev, old_dev);
7731 : 0 : return err;
7732 : : }
7733 : :
7734 : : return 0;
7735 : : }
7736 : : EXPORT_SYMBOL(netdev_adjacent_change_prepare);
7737 : :
7738 : 0 : void netdev_adjacent_change_commit(struct net_device *old_dev,
7739 : : struct net_device *new_dev,
7740 : : struct net_device *dev)
7741 : : {
7742 [ # # ]: 0 : if (!new_dev || !old_dev)
7743 : : return;
7744 : :
7745 [ # # ]: 0 : if (new_dev == old_dev)
7746 : : return;
7747 : :
7748 : 0 : netdev_adjacent_dev_enable(dev, old_dev);
7749 : 0 : netdev_upper_dev_unlink(old_dev, dev);
7750 : : }
7751 : : EXPORT_SYMBOL(netdev_adjacent_change_commit);
7752 : :
7753 : 0 : void netdev_adjacent_change_abort(struct net_device *old_dev,
7754 : : struct net_device *new_dev,
7755 : : struct net_device *dev)
7756 : : {
7757 [ # # ]: 0 : if (!new_dev)
7758 : : return;
7759 : :
7760 [ # # ]: 0 : if (old_dev && new_dev != old_dev)
7761 : 0 : netdev_adjacent_dev_enable(dev, old_dev);
7762 : :
7763 : 0 : netdev_upper_dev_unlink(new_dev, dev);
7764 : : }
7765 : : EXPORT_SYMBOL(netdev_adjacent_change_abort);
7766 : :
7767 : : /**
7768 : : * netdev_bonding_info_change - Dispatch event about slave change
7769 : : * @dev: device
7770 : : * @bonding_info: info to dispatch
7771 : : *
7772 : : * Send NETDEV_BONDING_INFO to netdev notifiers with info.
7773 : : * The caller must hold the RTNL lock.
7774 : : */
7775 : 0 : void netdev_bonding_info_change(struct net_device *dev,
7776 : : struct netdev_bonding_info *bonding_info)
7777 : : {
7778 : 0 : struct netdev_notifier_bonding_info info = {
7779 : : .info.dev = dev,
7780 : : };
7781 : :
7782 : 0 : memcpy(&info.bonding_info, bonding_info,
7783 : : sizeof(struct netdev_bonding_info));
7784 : 0 : call_netdevice_notifiers_info(NETDEV_BONDING_INFO,
7785 : : &info.info);
7786 : 0 : }
7787 : : EXPORT_SYMBOL(netdev_bonding_info_change);
7788 : :
7789 : 0 : static void netdev_adjacent_add_links(struct net_device *dev)
7790 : : {
7791 : 0 : struct netdev_adjacent *iter;
7792 : :
7793 : 0 : struct net *net = dev_net(dev);
7794 : :
7795 [ # # ]: 0 : list_for_each_entry(iter, &dev->adj_list.upper, list) {
7796 [ # # ]: 0 : if (!net_eq(net, dev_net(iter->dev)))
7797 : 0 : continue;
7798 : 0 : netdev_adjacent_sysfs_add(iter->dev, dev,
7799 : : &iter->dev->adj_list.lower);
7800 : 0 : netdev_adjacent_sysfs_add(dev, iter->dev,
7801 : : &dev->adj_list.upper);
7802 : : }
7803 : :
7804 [ # # ]: 0 : list_for_each_entry(iter, &dev->adj_list.lower, list) {
7805 [ # # ]: 0 : if (!net_eq(net, dev_net(iter->dev)))
7806 : 0 : continue;
7807 : 0 : netdev_adjacent_sysfs_add(iter->dev, dev,
7808 : : &iter->dev->adj_list.upper);
7809 : 0 : netdev_adjacent_sysfs_add(dev, iter->dev,
7810 : : &dev->adj_list.lower);
7811 : : }
7812 : 0 : }
7813 : :
7814 : 0 : static void netdev_adjacent_del_links(struct net_device *dev)
7815 : : {
7816 : 0 : struct netdev_adjacent *iter;
7817 : :
7818 : 0 : struct net *net = dev_net(dev);
7819 : :
7820 [ # # ]: 0 : list_for_each_entry(iter, &dev->adj_list.upper, list) {
7821 [ # # ]: 0 : if (!net_eq(net, dev_net(iter->dev)))
7822 : 0 : continue;
7823 : 0 : netdev_adjacent_sysfs_del(iter->dev, dev->name,
7824 : : &iter->dev->adj_list.lower);
7825 : 0 : netdev_adjacent_sysfs_del(dev, iter->dev->name,
7826 : : &dev->adj_list.upper);
7827 : : }
7828 : :
7829 [ # # ]: 0 : list_for_each_entry(iter, &dev->adj_list.lower, list) {
7830 [ # # ]: 0 : if (!net_eq(net, dev_net(iter->dev)))
7831 : 0 : continue;
7832 : 0 : netdev_adjacent_sysfs_del(iter->dev, dev->name,
7833 : : &iter->dev->adj_list.upper);
7834 : 0 : netdev_adjacent_sysfs_del(dev, iter->dev->name,
7835 : : &dev->adj_list.lower);
7836 : : }
7837 : 0 : }
7838 : :
7839 : 0 : void netdev_adjacent_rename_links(struct net_device *dev, char *oldname)
7840 : : {
7841 : 0 : struct netdev_adjacent *iter;
7842 : :
7843 : 0 : struct net *net = dev_net(dev);
7844 : :
7845 [ # # ]: 0 : list_for_each_entry(iter, &dev->adj_list.upper, list) {
7846 [ # # ]: 0 : if (!net_eq(net, dev_net(iter->dev)))
7847 : 0 : continue;
7848 : 0 : netdev_adjacent_sysfs_del(iter->dev, oldname,
7849 : : &iter->dev->adj_list.lower);
7850 : 0 : netdev_adjacent_sysfs_add(iter->dev, dev,
7851 : 0 : &iter->dev->adj_list.lower);
7852 : : }
7853 : :
7854 [ # # ]: 0 : list_for_each_entry(iter, &dev->adj_list.lower, list) {
7855 [ # # ]: 0 : if (!net_eq(net, dev_net(iter->dev)))
7856 : 0 : continue;
7857 : 0 : netdev_adjacent_sysfs_del(iter->dev, oldname,
7858 : : &iter->dev->adj_list.upper);
7859 : 0 : netdev_adjacent_sysfs_add(iter->dev, dev,
7860 : 0 : &iter->dev->adj_list.upper);
7861 : : }
7862 : 0 : }
7863 : :
7864 : 0 : void *netdev_lower_dev_get_private(struct net_device *dev,
7865 : : struct net_device *lower_dev)
7866 : : {
7867 : 0 : struct netdev_adjacent *lower;
7868 : :
7869 [ # # ]: 0 : if (!lower_dev)
7870 : : return NULL;
7871 : 0 : lower = __netdev_find_adj(lower_dev, &dev->adj_list.lower);
7872 [ # # ]: 0 : if (!lower)
7873 : : return NULL;
7874 : :
7875 : 0 : return lower->private;
7876 : : }
7877 : : EXPORT_SYMBOL(netdev_lower_dev_get_private);
7878 : :
7879 : :
7880 : : /**
7881 : : * netdev_lower_change - Dispatch event about lower device state change
7882 : : * @lower_dev: device
7883 : : * @lower_state_info: state to dispatch
7884 : : *
7885 : : * Send NETDEV_CHANGELOWERSTATE to netdev notifiers with info.
7886 : : * The caller must hold the RTNL lock.
7887 : : */
7888 : 0 : void netdev_lower_state_changed(struct net_device *lower_dev,
7889 : : void *lower_state_info)
7890 : : {
7891 : 0 : struct netdev_notifier_changelowerstate_info changelowerstate_info = {
7892 : : .info.dev = lower_dev,
7893 : : };
7894 : :
7895 [ # # # # ]: 0 : ASSERT_RTNL();
7896 : 0 : changelowerstate_info.lower_state_info = lower_state_info;
7897 : 0 : call_netdevice_notifiers_info(NETDEV_CHANGELOWERSTATE,
7898 : : &changelowerstate_info.info);
7899 : 0 : }
7900 : : EXPORT_SYMBOL(netdev_lower_state_changed);
7901 : :
7902 : 0 : static void dev_change_rx_flags(struct net_device *dev, int flags)
7903 : : {
7904 : 0 : const struct net_device_ops *ops = dev->netdev_ops;
7905 : :
7906 : 0 : if (ops->ndo_change_rx_flags)
7907 : 0 : ops->ndo_change_rx_flags(dev, flags);
7908 : : }
7909 : :
7910 : 0 : static int __dev_set_promiscuity(struct net_device *dev, int inc, bool notify)
7911 : : {
7912 : 0 : unsigned int old_flags = dev->flags;
7913 : 0 : kuid_t uid;
7914 : 0 : kgid_t gid;
7915 : :
7916 [ # # # # ]: 0 : ASSERT_RTNL();
7917 : :
7918 : 0 : dev->flags |= IFF_PROMISC;
7919 : 0 : dev->promiscuity += inc;
7920 [ # # ]: 0 : if (dev->promiscuity == 0) {
7921 : : /*
7922 : : * Avoid overflow.
7923 : : * If inc causes overflow, untouch promisc and return error.
7924 : : */
7925 [ # # ]: 0 : if (inc < 0)
7926 : 0 : dev->flags &= ~IFF_PROMISC;
7927 : : else {
7928 : 0 : dev->promiscuity -= inc;
7929 : 0 : pr_warn("%s: promiscuity touches roof, set promiscuity failed. promiscuity feature of device might be broken.\n",
7930 : : dev->name);
7931 : 0 : return -EOVERFLOW;
7932 : : }
7933 : : }
7934 [ # # ]: 0 : if (dev->flags != old_flags) {
7935 [ # # ]: 0 : pr_info("device %s %s promiscuous mode\n",
7936 : : dev->name,
7937 : : dev->flags & IFF_PROMISC ? "entered" : "left");
7938 [ # # ]: 0 : if (audit_enabled) {
7939 : 0 : current_uid_gid(&uid, &gid);
7940 : 0 : audit_log(audit_context(), GFP_ATOMIC,
7941 : : AUDIT_ANOM_PROMISCUOUS,
7942 : : "dev=%s prom=%d old_prom=%d auid=%u uid=%u gid=%u ses=%u",
7943 : 0 : dev->name, (dev->flags & IFF_PROMISC),
7944 : : (old_flags & IFF_PROMISC),
7945 : : from_kuid(&init_user_ns, audit_get_loginuid(current)),
7946 : : from_kuid(&init_user_ns, uid),
7947 : : from_kgid(&init_user_ns, gid),
7948 : : audit_get_sessionid(current));
7949 : : }
7950 : :
7951 [ # # ]: 0 : dev_change_rx_flags(dev, IFF_PROMISC);
7952 : : }
7953 [ # # ]: 0 : if (notify)
7954 : 0 : __dev_notify_flags(dev, old_flags, IFF_PROMISC);
7955 : : return 0;
7956 : : }
7957 : :
7958 : : /**
7959 : : * dev_set_promiscuity - update promiscuity count on a device
7960 : : * @dev: device
7961 : : * @inc: modifier
7962 : : *
7963 : : * Add or remove promiscuity from a device. While the count in the device
7964 : : * remains above zero the interface remains promiscuous. Once it hits zero
7965 : : * the device reverts back to normal filtering operation. A negative inc
7966 : : * value is used to drop promiscuity on the device.
7967 : : * Return 0 if successful or a negative errno code on error.
7968 : : */
7969 : 0 : int dev_set_promiscuity(struct net_device *dev, int inc)
7970 : : {
7971 : 0 : unsigned int old_flags = dev->flags;
7972 : 0 : int err;
7973 : :
7974 : 0 : err = __dev_set_promiscuity(dev, inc, true);
7975 [ # # ]: 0 : if (err < 0)
7976 : : return err;
7977 [ # # ]: 0 : if (dev->flags != old_flags)
7978 : 0 : dev_set_rx_mode(dev);
7979 : : return err;
7980 : : }
7981 : : EXPORT_SYMBOL(dev_set_promiscuity);
7982 : :
7983 : 0 : static int __dev_set_allmulti(struct net_device *dev, int inc, bool notify)
7984 : : {
7985 : 0 : unsigned int old_flags = dev->flags, old_gflags = dev->gflags;
7986 : :
7987 [ # # # # ]: 0 : ASSERT_RTNL();
7988 : :
7989 : 0 : dev->flags |= IFF_ALLMULTI;
7990 : 0 : dev->allmulti += inc;
7991 [ # # ]: 0 : if (dev->allmulti == 0) {
7992 : : /*
7993 : : * Avoid overflow.
7994 : : * If inc causes overflow, untouch allmulti and return error.
7995 : : */
7996 [ # # ]: 0 : if (inc < 0)
7997 : 0 : dev->flags &= ~IFF_ALLMULTI;
7998 : : else {
7999 : 0 : dev->allmulti -= inc;
8000 : 0 : pr_warn("%s: allmulti touches roof, set allmulti failed. allmulti feature of device might be broken.\n",
8001 : : dev->name);
8002 : 0 : return -EOVERFLOW;
8003 : : }
8004 : : }
8005 [ # # ]: 0 : if (dev->flags ^ old_flags) {
8006 [ # # ]: 0 : dev_change_rx_flags(dev, IFF_ALLMULTI);
8007 : 0 : dev_set_rx_mode(dev);
8008 [ # # ]: 0 : if (notify)
8009 : 0 : __dev_notify_flags(dev, old_flags,
8010 : 0 : dev->gflags ^ old_gflags);
8011 : : }
8012 : : return 0;
8013 : : }
8014 : :
8015 : : /**
8016 : : * dev_set_allmulti - update allmulti count on a device
8017 : : * @dev: device
8018 : : * @inc: modifier
8019 : : *
8020 : : * Add or remove reception of all multicast frames to a device. While the
8021 : : * count in the device remains above zero the interface remains listening
8022 : : * to all interfaces. Once it hits zero the device reverts back to normal
8023 : : * filtering operation. A negative @inc value is used to drop the counter
8024 : : * when releasing a resource needing all multicasts.
8025 : : * Return 0 if successful or a negative errno code on error.
8026 : : */
8027 : :
8028 : 0 : int dev_set_allmulti(struct net_device *dev, int inc)
8029 : : {
8030 : 0 : return __dev_set_allmulti(dev, inc, true);
8031 : : }
8032 : : EXPORT_SYMBOL(dev_set_allmulti);
8033 : :
8034 : : /*
8035 : : * Upload unicast and multicast address lists to device and
8036 : : * configure RX filtering. When the device doesn't support unicast
8037 : : * filtering it is put in promiscuous mode while unicast addresses
8038 : : * are present.
8039 : : */
8040 : 24 : void __dev_set_rx_mode(struct net_device *dev)
8041 : : {
8042 : 24 : const struct net_device_ops *ops = dev->netdev_ops;
8043 : :
8044 : : /* dev_open will call this function so the list will stay sane. */
8045 [ + + ]: 24 : if (!(dev->flags&IFF_UP))
8046 : : return;
8047 : :
8048 [ + - ]: 15 : if (!netif_device_present(dev))
8049 : : return;
8050 : :
8051 [ + - ]: 15 : if (!(dev->priv_flags & IFF_UNICAST_FLT)) {
8052 : : /* Unicast addresses changes may only happen under the rtnl,
8053 : : * therefore calling __dev_set_promiscuity here is safe.
8054 : : */
8055 [ - + - - ]: 15 : if (!netdev_uc_empty(dev) && !dev->uc_promisc) {
8056 : 0 : __dev_set_promiscuity(dev, 1, false);
8057 : 0 : dev->uc_promisc = true;
8058 [ + - - + ]: 15 : } else if (netdev_uc_empty(dev) && dev->uc_promisc) {
8059 : 0 : __dev_set_promiscuity(dev, -1, false);
8060 : 0 : dev->uc_promisc = false;
8061 : : }
8062 : : }
8063 : :
8064 [ + + ]: 15 : if (ops->ndo_set_rx_mode)
8065 : 9 : ops->ndo_set_rx_mode(dev);
8066 : : }
8067 : :
8068 : 15 : void dev_set_rx_mode(struct net_device *dev)
8069 : : {
8070 : 15 : netif_addr_lock_bh(dev);
8071 : 15 : __dev_set_rx_mode(dev);
8072 : 15 : netif_addr_unlock_bh(dev);
8073 : 15 : }
8074 : :
8075 : : /**
8076 : : * dev_get_flags - get flags reported to userspace
8077 : : * @dev: device
8078 : : *
8079 : : * Get the combination of flag bits exported through APIs to userspace.
8080 : : */
8081 : 81 : unsigned int dev_get_flags(const struct net_device *dev)
8082 : : {
8083 : 81 : unsigned int flags;
8084 : :
8085 : 81 : flags = (dev->flags & ~(IFF_PROMISC |
8086 : : IFF_ALLMULTI |
8087 : : IFF_RUNNING |
8088 : : IFF_LOWER_UP |
8089 : : IFF_DORMANT)) |
8090 : 81 : (dev->gflags & (IFF_PROMISC |
8091 : : IFF_ALLMULTI));
8092 : :
8093 [ + + ]: 81 : if (netif_running(dev)) {
8094 [ + - ]: 45 : if (netif_oper_up(dev))
8095 : 45 : flags |= IFF_RUNNING;
8096 [ + - ]: 45 : if (netif_carrier_ok(dev))
8097 : 45 : flags |= IFF_LOWER_UP;
8098 [ - + ]: 45 : if (netif_dormant(dev))
8099 : 0 : flags |= IFF_DORMANT;
8100 : : }
8101 : :
8102 : 81 : return flags;
8103 : : }
8104 : : EXPORT_SYMBOL(dev_get_flags);
8105 : :
8106 : 9 : int __dev_change_flags(struct net_device *dev, unsigned int flags,
8107 : : struct netlink_ext_ack *extack)
8108 : : {
8109 : 9 : unsigned int old_flags = dev->flags;
8110 : 9 : int ret;
8111 : :
8112 [ - + - - ]: 9 : ASSERT_RTNL();
8113 : :
8114 : : /*
8115 : : * Set the flags on our device.
8116 : : */
8117 : :
8118 : 9 : dev->flags = (flags & (IFF_DEBUG | IFF_NOTRAILERS | IFF_NOARP |
8119 : : IFF_DYNAMIC | IFF_MULTICAST | IFF_PORTSEL |
8120 : 9 : IFF_AUTOMEDIA)) |
8121 : 9 : (dev->flags & (IFF_UP | IFF_VOLATILE | IFF_PROMISC |
8122 : : IFF_ALLMULTI));
8123 : :
8124 : : /*
8125 : : * Load in the correct multicast list now the flags have changed.
8126 : : */
8127 : :
8128 [ - + ]: 9 : if ((old_flags ^ flags) & IFF_MULTICAST)
8129 [ # # ]: 0 : dev_change_rx_flags(dev, IFF_MULTICAST);
8130 : :
8131 : 9 : dev_set_rx_mode(dev);
8132 : :
8133 : : /*
8134 : : * Have we downed the interface. We handle IFF_UP ourselves
8135 : : * according to user attempts to set it, rather than blindly
8136 : : * setting it.
8137 : : */
8138 : :
8139 : 9 : ret = 0;
8140 [ + + ]: 9 : if ((old_flags ^ flags) & IFF_UP) {
8141 [ - + ]: 6 : if (old_flags & IFF_UP)
8142 : 0 : __dev_close(dev);
8143 : : else
8144 : 6 : ret = __dev_open(dev, extack);
8145 : : }
8146 : :
8147 [ - + ]: 9 : if ((flags ^ dev->gflags) & IFF_PROMISC) {
8148 [ # # ]: 0 : int inc = (flags & IFF_PROMISC) ? 1 : -1;
8149 : 0 : unsigned int old_flags = dev->flags;
8150 : :
8151 : 0 : dev->gflags ^= IFF_PROMISC;
8152 : :
8153 [ # # ]: 0 : if (__dev_set_promiscuity(dev, inc, false) >= 0)
8154 [ # # ]: 0 : if (dev->flags != old_flags)
8155 : 0 : dev_set_rx_mode(dev);
8156 : : }
8157 : :
8158 : : /* NOTE: order of synchronization of IFF_PROMISC and IFF_ALLMULTI
8159 : : * is important. Some (broken) drivers set IFF_PROMISC, when
8160 : : * IFF_ALLMULTI is requested not asking us and not reporting.
8161 : : */
8162 [ - + ]: 9 : if ((flags ^ dev->gflags) & IFF_ALLMULTI) {
8163 [ # # ]: 0 : int inc = (flags & IFF_ALLMULTI) ? 1 : -1;
8164 : :
8165 : 0 : dev->gflags ^= IFF_ALLMULTI;
8166 : 0 : __dev_set_allmulti(dev, inc, false);
8167 : : }
8168 : :
8169 : 9 : return ret;
8170 : : }
8171 : :
8172 : 9 : void __dev_notify_flags(struct net_device *dev, unsigned int old_flags,
8173 : : unsigned int gchanges)
8174 : : {
8175 : 9 : unsigned int changes = dev->flags ^ old_flags;
8176 : :
8177 [ + + ]: 9 : if (gchanges)
8178 : 6 : rtmsg_ifinfo(RTM_NEWLINK, dev, gchanges, GFP_ATOMIC);
8179 : :
8180 [ + + ]: 9 : if (changes & IFF_UP) {
8181 [ + - ]: 6 : if (dev->flags & IFF_UP)
8182 : 6 : call_netdevice_notifiers(NETDEV_UP, dev);
8183 : : else
8184 : 0 : call_netdevice_notifiers(NETDEV_DOWN, dev);
8185 : : }
8186 : :
8187 [ + - ]: 9 : if (dev->flags & IFF_UP &&
8188 [ - + ]: 9 : (changes & ~(IFF_UP | IFF_PROMISC | IFF_ALLMULTI | IFF_VOLATILE))) {
8189 : 0 : struct netdev_notifier_change_info change_info = {
8190 : : .info = {
8191 : : .dev = dev,
8192 : : },
8193 : : .flags_changed = changes,
8194 : : };
8195 : :
8196 : 0 : call_netdevice_notifiers_info(NETDEV_CHANGE, &change_info.info);
8197 : : }
8198 : 9 : }
8199 : :
8200 : : /**
8201 : : * dev_change_flags - change device settings
8202 : : * @dev: device
8203 : : * @flags: device state flags
8204 : : * @extack: netlink extended ack
8205 : : *
8206 : : * Change settings on device based state flags. The flags are
8207 : : * in the userspace exported format.
8208 : : */
8209 : 9 : int dev_change_flags(struct net_device *dev, unsigned int flags,
8210 : : struct netlink_ext_ack *extack)
8211 : : {
8212 : 9 : int ret;
8213 : 9 : unsigned int changes, old_flags = dev->flags, old_gflags = dev->gflags;
8214 : :
8215 : 9 : ret = __dev_change_flags(dev, flags, extack);
8216 [ + - ]: 9 : if (ret < 0)
8217 : : return ret;
8218 : :
8219 : 9 : changes = (old_flags ^ dev->flags) | (old_gflags ^ dev->gflags);
8220 : 9 : __dev_notify_flags(dev, old_flags, changes);
8221 : 9 : return ret;
8222 : : }
8223 : : EXPORT_SYMBOL(dev_change_flags);
8224 : :
8225 : 0 : int __dev_set_mtu(struct net_device *dev, int new_mtu)
8226 : : {
8227 : 0 : const struct net_device_ops *ops = dev->netdev_ops;
8228 : :
8229 [ # # ]: 0 : if (ops->ndo_change_mtu)
8230 : 0 : return ops->ndo_change_mtu(dev, new_mtu);
8231 : :
8232 : : /* Pairs with all the lockless reads of dev->mtu in the stack */
8233 : 0 : WRITE_ONCE(dev->mtu, new_mtu);
8234 : 0 : return 0;
8235 : : }
8236 : : EXPORT_SYMBOL(__dev_set_mtu);
8237 : :
8238 : 0 : int dev_validate_mtu(struct net_device *dev, int new_mtu,
8239 : : struct netlink_ext_ack *extack)
8240 : : {
8241 : : /* MTU must be positive, and in range */
8242 [ # # # # : 0 : if (new_mtu < 0 || new_mtu < dev->min_mtu) {
# # ]
8243 [ # # # # ]: 0 : NL_SET_ERR_MSG(extack, "mtu less than device minimum");
8244 : 0 : return -EINVAL;
8245 : : }
8246 : :
8247 [ # # # # : 0 : if (dev->max_mtu > 0 && new_mtu > dev->max_mtu) {
# # # # ]
8248 [ # # # # ]: 0 : NL_SET_ERR_MSG(extack, "mtu greater than device maximum");
8249 : 0 : return -EINVAL;
8250 : : }
8251 : : return 0;
8252 : : }
8253 : :
8254 : : /**
8255 : : * dev_set_mtu_ext - Change maximum transfer unit
8256 : : * @dev: device
8257 : : * @new_mtu: new transfer unit
8258 : : * @extack: netlink extended ack
8259 : : *
8260 : : * Change the maximum transfer size of the network device.
8261 : : */
8262 : 0 : int dev_set_mtu_ext(struct net_device *dev, int new_mtu,
8263 : : struct netlink_ext_ack *extack)
8264 : : {
8265 : 0 : int err, orig_mtu;
8266 : :
8267 [ # # ]: 0 : if (new_mtu == dev->mtu)
8268 : : return 0;
8269 : :
8270 [ # # ]: 0 : err = dev_validate_mtu(dev, new_mtu, extack);
8271 : : if (err)
8272 : 0 : return err;
8273 : :
8274 [ # # ]: 0 : if (!netif_device_present(dev))
8275 : : return -ENODEV;
8276 : :
8277 : 0 : err = call_netdevice_notifiers(NETDEV_PRECHANGEMTU, dev);
8278 [ # # ]: 0 : err = notifier_to_errno(err);
8279 : 0 : if (err)
8280 : 0 : return err;
8281 : :
8282 : 0 : orig_mtu = dev->mtu;
8283 [ # # ]: 0 : err = __dev_set_mtu(dev, new_mtu);
8284 : :
8285 [ # # ]: 0 : if (!err) {
8286 : 0 : err = call_netdevice_notifiers_mtu(NETDEV_CHANGEMTU, dev,
8287 : : orig_mtu);
8288 [ # # ]: 0 : err = notifier_to_errno(err);
8289 : 0 : if (err) {
8290 : : /* setting mtu back and notifying everyone again,
8291 : : * so that they have a chance to revert changes.
8292 : : */
8293 [ # # ]: 0 : __dev_set_mtu(dev, orig_mtu);
8294 : 0 : call_netdevice_notifiers_mtu(NETDEV_CHANGEMTU, dev,
8295 : : new_mtu);
8296 : : }
8297 : : }
8298 : : return err;
8299 : : }
8300 : :
8301 : 0 : int dev_set_mtu(struct net_device *dev, int new_mtu)
8302 : : {
8303 : 0 : struct netlink_ext_ack extack;
8304 : 0 : int err;
8305 : :
8306 : 0 : memset(&extack, 0, sizeof(extack));
8307 : 0 : err = dev_set_mtu_ext(dev, new_mtu, &extack);
8308 [ # # # # ]: 0 : if (err && extack._msg)
8309 [ # # ]: 0 : net_err_ratelimited("%s: %s\n", dev->name, extack._msg);
8310 : 0 : return err;
8311 : : }
8312 : : EXPORT_SYMBOL(dev_set_mtu);
8313 : :
8314 : : /**
8315 : : * dev_change_tx_queue_len - Change TX queue length of a netdevice
8316 : : * @dev: device
8317 : : * @new_len: new tx queue length
8318 : : */
8319 : 0 : int dev_change_tx_queue_len(struct net_device *dev, unsigned long new_len)
8320 : : {
8321 : 0 : unsigned int orig_len = dev->tx_queue_len;
8322 : 0 : int res;
8323 : :
8324 [ # # ]: 0 : if (new_len != (unsigned int)new_len)
8325 : : return -ERANGE;
8326 : :
8327 [ # # ]: 0 : if (new_len != orig_len) {
8328 : 0 : dev->tx_queue_len = new_len;
8329 : 0 : res = call_netdevice_notifiers(NETDEV_CHANGE_TX_QUEUE_LEN, dev);
8330 [ # # ]: 0 : res = notifier_to_errno(res);
8331 : 0 : if (res)
8332 : 0 : goto err_rollback;
8333 : 0 : res = dev_qdisc_change_tx_queue_len(dev);
8334 [ # # ]: 0 : if (res)
8335 : 0 : goto err_rollback;
8336 : : }
8337 : :
8338 : : return 0;
8339 : :
8340 : 0 : err_rollback:
8341 : 0 : netdev_err(dev, "refused to change device tx_queue_len\n");
8342 : 0 : dev->tx_queue_len = orig_len;
8343 : 0 : return res;
8344 : : }
8345 : :
8346 : : /**
8347 : : * dev_set_group - Change group this device belongs to
8348 : : * @dev: device
8349 : : * @new_group: group this device should belong to
8350 : : */
8351 : 0 : void dev_set_group(struct net_device *dev, int new_group)
8352 : : {
8353 : 0 : dev->group = new_group;
8354 : 0 : }
8355 : : EXPORT_SYMBOL(dev_set_group);
8356 : :
8357 : : /**
8358 : : * dev_pre_changeaddr_notify - Call NETDEV_PRE_CHANGEADDR.
8359 : : * @dev: device
8360 : : * @addr: new address
8361 : : * @extack: netlink extended ack
8362 : : */
8363 : 0 : int dev_pre_changeaddr_notify(struct net_device *dev, const char *addr,
8364 : : struct netlink_ext_ack *extack)
8365 : : {
8366 : 0 : struct netdev_notifier_pre_changeaddr_info info = {
8367 : : .info.dev = dev,
8368 : : .info.extack = extack,
8369 : : .dev_addr = addr,
8370 : : };
8371 : 0 : int rc;
8372 : :
8373 : 0 : rc = call_netdevice_notifiers_info(NETDEV_PRE_CHANGEADDR, &info.info);
8374 [ # # # # ]: 0 : return notifier_to_errno(rc);
8375 : : }
8376 : : EXPORT_SYMBOL(dev_pre_changeaddr_notify);
8377 : :
8378 : : /**
8379 : : * dev_set_mac_address - Change Media Access Control Address
8380 : : * @dev: device
8381 : : * @sa: new address
8382 : : * @extack: netlink extended ack
8383 : : *
8384 : : * Change the hardware (MAC) address of the device
8385 : : */
8386 : 0 : int dev_set_mac_address(struct net_device *dev, struct sockaddr *sa,
8387 : : struct netlink_ext_ack *extack)
8388 : : {
8389 : 0 : const struct net_device_ops *ops = dev->netdev_ops;
8390 : 0 : int err;
8391 : :
8392 [ # # ]: 0 : if (!ops->ndo_set_mac_address)
8393 : : return -EOPNOTSUPP;
8394 [ # # ]: 0 : if (sa->sa_family != dev->type)
8395 : : return -EINVAL;
8396 [ # # ]: 0 : if (!netif_device_present(dev))
8397 : : return -ENODEV;
8398 : 0 : err = dev_pre_changeaddr_notify(dev, sa->sa_data, extack);
8399 : 0 : if (err)
8400 : 0 : return err;
8401 : 0 : err = ops->ndo_set_mac_address(dev, sa);
8402 [ # # ]: 0 : if (err)
8403 : : return err;
8404 : 0 : dev->addr_assign_type = NET_ADDR_SET;
8405 : 0 : call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
8406 : 0 : add_device_randomness(dev->dev_addr, dev->addr_len);
8407 : 0 : return 0;
8408 : : }
8409 : : EXPORT_SYMBOL(dev_set_mac_address);
8410 : :
8411 : : /**
8412 : : * dev_change_carrier - Change device carrier
8413 : : * @dev: device
8414 : : * @new_carrier: new value
8415 : : *
8416 : : * Change device carrier
8417 : : */
8418 : 0 : int dev_change_carrier(struct net_device *dev, bool new_carrier)
8419 : : {
8420 : 0 : const struct net_device_ops *ops = dev->netdev_ops;
8421 : :
8422 [ # # ]: 0 : if (!ops->ndo_change_carrier)
8423 : : return -EOPNOTSUPP;
8424 [ # # ]: 0 : if (!netif_device_present(dev))
8425 : : return -ENODEV;
8426 : 0 : return ops->ndo_change_carrier(dev, new_carrier);
8427 : : }
8428 : : EXPORT_SYMBOL(dev_change_carrier);
8429 : :
8430 : : /**
8431 : : * dev_get_phys_port_id - Get device physical port ID
8432 : : * @dev: device
8433 : : * @ppid: port ID
8434 : : *
8435 : : * Get device physical port ID
8436 : : */
8437 : 60 : int dev_get_phys_port_id(struct net_device *dev,
8438 : : struct netdev_phys_item_id *ppid)
8439 : : {
8440 : 60 : const struct net_device_ops *ops = dev->netdev_ops;
8441 : :
8442 [ - + ]: 60 : if (!ops->ndo_get_phys_port_id)
8443 : : return -EOPNOTSUPP;
8444 : 0 : return ops->ndo_get_phys_port_id(dev, ppid);
8445 : : }
8446 : : EXPORT_SYMBOL(dev_get_phys_port_id);
8447 : :
8448 : : /**
8449 : : * dev_get_phys_port_name - Get device physical port name
8450 : : * @dev: device
8451 : : * @name: port name
8452 : : * @len: limit of bytes to copy to name
8453 : : *
8454 : : * Get device physical port name
8455 : : */
8456 : 63 : int dev_get_phys_port_name(struct net_device *dev,
8457 : : char *name, size_t len)
8458 : : {
8459 : 63 : const struct net_device_ops *ops = dev->netdev_ops;
8460 : 63 : int err;
8461 : :
8462 [ - + ]: 63 : if (ops->ndo_get_phys_port_name) {
8463 : 0 : err = ops->ndo_get_phys_port_name(dev, name, len);
8464 [ # # ]: 0 : if (err != -EOPNOTSUPP)
8465 : 0 : return err;
8466 : : }
8467 : : return devlink_compat_phys_port_name_get(dev, name, len);
8468 : : }
8469 : : EXPORT_SYMBOL(dev_get_phys_port_name);
8470 : :
8471 : : /**
8472 : : * dev_get_port_parent_id - Get the device's port parent identifier
8473 : : * @dev: network device
8474 : : * @ppid: pointer to a storage for the port's parent identifier
8475 : : * @recurse: allow/disallow recursion to lower devices
8476 : : *
8477 : : * Get the devices's port parent identifier
8478 : : */
8479 : 60 : int dev_get_port_parent_id(struct net_device *dev,
8480 : : struct netdev_phys_item_id *ppid,
8481 : : bool recurse)
8482 : : {
8483 : 60 : const struct net_device_ops *ops = dev->netdev_ops;
8484 : 60 : struct netdev_phys_item_id first = { };
8485 : 60 : struct net_device *lower_dev;
8486 : 60 : struct list_head *iter;
8487 : 60 : int err;
8488 : :
8489 [ - + ]: 60 : if (ops->ndo_get_port_parent_id) {
8490 : 0 : err = ops->ndo_get_port_parent_id(dev, ppid);
8491 [ # # ]: 0 : if (err != -EOPNOTSUPP)
8492 : : return err;
8493 : : }
8494 : :
8495 [ - + ]: 60 : err = devlink_compat_switch_id_get(dev, ppid);
8496 : 60 : if (!err || err != -EOPNOTSUPP)
8497 : : return err;
8498 : :
8499 [ - + ]: 60 : if (!recurse)
8500 : : return -EOPNOTSUPP;
8501 : :
8502 [ # # # # : 0 : netdev_for_each_lower_dev(dev, lower_dev, iter) {
# # ]
8503 : 0 : err = dev_get_port_parent_id(lower_dev, ppid, recurse);
8504 [ # # ]: 0 : if (err)
8505 : : break;
8506 [ # # ]: 0 : if (!first.id_len)
8507 : 0 : first = *ppid;
8508 [ # # ]: 0 : else if (memcmp(&first, ppid, sizeof(*ppid)))
8509 : : return -ENODATA;
8510 : : }
8511 : :
8512 : : return err;
8513 : : }
8514 : : EXPORT_SYMBOL(dev_get_port_parent_id);
8515 : :
8516 : : /**
8517 : : * netdev_port_same_parent_id - Indicate if two network devices have
8518 : : * the same port parent identifier
8519 : : * @a: first network device
8520 : : * @b: second network device
8521 : : */
8522 : 0 : bool netdev_port_same_parent_id(struct net_device *a, struct net_device *b)
8523 : : {
8524 : 0 : struct netdev_phys_item_id a_id = { };
8525 : 0 : struct netdev_phys_item_id b_id = { };
8526 : :
8527 [ # # # # ]: 0 : if (dev_get_port_parent_id(a, &a_id, true) ||
8528 : 0 : dev_get_port_parent_id(b, &b_id, true))
8529 : 0 : return false;
8530 : :
8531 [ # # ]: 0 : return netdev_phys_item_id_same(&a_id, &b_id);
8532 : : }
8533 : : EXPORT_SYMBOL(netdev_port_same_parent_id);
8534 : :
8535 : : /**
8536 : : * dev_change_proto_down - update protocol port state information
8537 : : * @dev: device
8538 : : * @proto_down: new value
8539 : : *
8540 : : * This info can be used by switch drivers to set the phys state of the
8541 : : * port.
8542 : : */
8543 : 0 : int dev_change_proto_down(struct net_device *dev, bool proto_down)
8544 : : {
8545 : 0 : const struct net_device_ops *ops = dev->netdev_ops;
8546 : :
8547 [ # # ]: 0 : if (!ops->ndo_change_proto_down)
8548 : : return -EOPNOTSUPP;
8549 [ # # ]: 0 : if (!netif_device_present(dev))
8550 : : return -ENODEV;
8551 : 0 : return ops->ndo_change_proto_down(dev, proto_down);
8552 : : }
8553 : : EXPORT_SYMBOL(dev_change_proto_down);
8554 : :
8555 : : /**
8556 : : * dev_change_proto_down_generic - generic implementation for
8557 : : * ndo_change_proto_down that sets carrier according to
8558 : : * proto_down.
8559 : : *
8560 : : * @dev: device
8561 : : * @proto_down: new value
8562 : : */
8563 : 0 : int dev_change_proto_down_generic(struct net_device *dev, bool proto_down)
8564 : : {
8565 [ # # ]: 0 : if (proto_down)
8566 : 0 : netif_carrier_off(dev);
8567 : : else
8568 : 0 : netif_carrier_on(dev);
8569 : 0 : dev->proto_down = proto_down;
8570 : 0 : return 0;
8571 : : }
8572 : : EXPORT_SYMBOL(dev_change_proto_down_generic);
8573 : :
8574 : 120 : u32 __dev_xdp_query(struct net_device *dev, bpf_op_t bpf_op,
8575 : : enum bpf_netdev_command cmd)
8576 : : {
8577 : 120 : struct netdev_bpf xdp;
8578 : :
8579 [ - + ]: 120 : if (!bpf_op)
8580 : : return 0;
8581 : :
8582 : 0 : memset(&xdp, 0, sizeof(xdp));
8583 : 0 : xdp.command = cmd;
8584 : :
8585 : : /* Query must always succeed. */
8586 [ # # # # : 0 : WARN_ON(bpf_op(dev, &xdp) < 0 && cmd == XDP_QUERY_PROG);
# # ]
8587 : :
8588 : 0 : return xdp.prog_id;
8589 : : }
8590 : :
8591 : 0 : static int dev_xdp_install(struct net_device *dev, bpf_op_t bpf_op,
8592 : : struct netlink_ext_ack *extack, u32 flags,
8593 : : struct bpf_prog *prog)
8594 : : {
8595 : 0 : bool non_hw = !(flags & XDP_FLAGS_HW_MODE);
8596 : 0 : struct bpf_prog *prev_prog = NULL;
8597 : 0 : struct netdev_bpf xdp;
8598 : 0 : int err;
8599 : :
8600 [ # # ]: 0 : if (non_hw) {
8601 : 0 : prev_prog = bpf_prog_by_id(__dev_xdp_query(dev, bpf_op,
8602 : : XDP_QUERY_PROG));
8603 : 0 : if (IS_ERR(prev_prog))
8604 : 0 : prev_prog = NULL;
8605 : : }
8606 : :
8607 : 0 : memset(&xdp, 0, sizeof(xdp));
8608 [ # # ]: 0 : if (flags & XDP_FLAGS_HW_MODE)
8609 : 0 : xdp.command = XDP_SETUP_PROG_HW;
8610 : : else
8611 : 0 : xdp.command = XDP_SETUP_PROG;
8612 : 0 : xdp.extack = extack;
8613 : 0 : xdp.flags = flags;
8614 : 0 : xdp.prog = prog;
8615 : :
8616 : 0 : err = bpf_op(dev, &xdp);
8617 [ # # ]: 0 : if (!err && non_hw)
8618 : 0 : bpf_prog_change_xdp(prev_prog, prog);
8619 : :
8620 : 0 : if (prev_prog)
8621 : : bpf_prog_put(prev_prog);
8622 : :
8623 : 0 : return err;
8624 : : }
8625 : :
8626 : 0 : static void dev_xdp_uninstall(struct net_device *dev)
8627 : : {
8628 : 0 : struct netdev_bpf xdp;
8629 : 0 : bpf_op_t ndo_bpf;
8630 : :
8631 : : /* Remove generic XDP */
8632 [ # # ]: 0 : WARN_ON(dev_xdp_install(dev, generic_xdp_install, NULL, 0, NULL));
8633 : :
8634 : : /* Remove from the driver */
8635 : 0 : ndo_bpf = dev->netdev_ops->ndo_bpf;
8636 [ # # ]: 0 : if (!ndo_bpf)
8637 : 0 : return;
8638 : :
8639 : 0 : memset(&xdp, 0, sizeof(xdp));
8640 : 0 : xdp.command = XDP_QUERY_PROG;
8641 [ # # ]: 0 : WARN_ON(ndo_bpf(dev, &xdp));
8642 [ # # ]: 0 : if (xdp.prog_id)
8643 [ # # ]: 0 : WARN_ON(dev_xdp_install(dev, ndo_bpf, NULL, xdp.prog_flags,
8644 : : NULL));
8645 : :
8646 : : /* Remove HW offload */
8647 : 0 : memset(&xdp, 0, sizeof(xdp));
8648 : 0 : xdp.command = XDP_QUERY_PROG_HW;
8649 [ # # # # ]: 0 : if (!ndo_bpf(dev, &xdp) && xdp.prog_id)
8650 [ # # ]: 0 : WARN_ON(dev_xdp_install(dev, ndo_bpf, NULL, xdp.prog_flags,
8651 : : NULL));
8652 : : }
8653 : :
8654 : : /**
8655 : : * dev_change_xdp_fd - set or clear a bpf program for a device rx path
8656 : : * @dev: device
8657 : : * @extack: netlink extended ack
8658 : : * @fd: new program fd or negative value to clear
8659 : : * @flags: xdp-related flags
8660 : : *
8661 : : * Set or clear a bpf program for a device
8662 : : */
8663 : 0 : int dev_change_xdp_fd(struct net_device *dev, struct netlink_ext_ack *extack,
8664 : : int fd, u32 flags)
8665 : : {
8666 : 0 : const struct net_device_ops *ops = dev->netdev_ops;
8667 : 0 : enum bpf_netdev_command query;
8668 : 0 : struct bpf_prog *prog = NULL;
8669 : 0 : bpf_op_t bpf_op, bpf_chk;
8670 : 0 : bool offload;
8671 : 0 : int err;
8672 : :
8673 [ # # # # ]: 0 : ASSERT_RTNL();
8674 : :
8675 : 0 : offload = flags & XDP_FLAGS_HW_MODE;
8676 [ # # ]: 0 : query = offload ? XDP_QUERY_PROG_HW : XDP_QUERY_PROG;
8677 : :
8678 : 0 : bpf_op = bpf_chk = ops->ndo_bpf;
8679 [ # # # # ]: 0 : if (!bpf_op && (flags & (XDP_FLAGS_DRV_MODE | XDP_FLAGS_HW_MODE))) {
8680 [ # # ]: 0 : NL_SET_ERR_MSG(extack, "underlying driver does not support XDP in native mode");
8681 : 0 : return -EOPNOTSUPP;
8682 : : }
8683 [ # # # # ]: 0 : if (!bpf_op || (flags & XDP_FLAGS_SKB_MODE))
8684 : 0 : bpf_op = generic_xdp_install;
8685 [ # # ]: 0 : if (bpf_op == bpf_chk)
8686 : 0 : bpf_chk = generic_xdp_install;
8687 : :
8688 [ # # ]: 0 : if (fd >= 0) {
8689 : 0 : u32 prog_id;
8690 : :
8691 [ # # # # ]: 0 : if (!offload && __dev_xdp_query(dev, bpf_chk, XDP_QUERY_PROG)) {
8692 [ # # ]: 0 : NL_SET_ERR_MSG(extack, "native and generic XDP can't be active at the same time");
8693 : 0 : return -EEXIST;
8694 : : }
8695 : :
8696 : 0 : prog_id = __dev_xdp_query(dev, bpf_op, query);
8697 [ # # # # ]: 0 : if ((flags & XDP_FLAGS_UPDATE_IF_NOEXIST) && prog_id) {
8698 [ # # ]: 0 : NL_SET_ERR_MSG(extack, "XDP program already attached");
8699 : 0 : return -EBUSY;
8700 : : }
8701 : :
8702 : : prog = bpf_prog_get_type_dev(fd, BPF_PROG_TYPE_XDP,
8703 : : bpf_op == ops->ndo_bpf);
8704 : : if (IS_ERR(prog))
8705 : : return PTR_ERR(prog);
8706 : :
8707 : : if (!offload && bpf_prog_is_dev_bound(prog->aux)) {
8708 : : NL_SET_ERR_MSG(extack, "using device-bound program without HW_MODE flag is not supported");
8709 : : bpf_prog_put(prog);
8710 : : return -EINVAL;
8711 : : }
8712 : :
8713 : : /* prog->aux->id may be 0 for orphaned device-bound progs */
8714 : : if (prog->aux->id && prog->aux->id == prog_id) {
8715 : : bpf_prog_put(prog);
8716 : : return 0;
8717 : : }
8718 : : } else {
8719 [ # # ]: 0 : if (!__dev_xdp_query(dev, bpf_op, query))
8720 : : return 0;
8721 : : }
8722 : :
8723 : 0 : err = dev_xdp_install(dev, bpf_op, extack, flags, prog);
8724 : 0 : if (err < 0 && prog)
8725 : : bpf_prog_put(prog);
8726 : :
8727 : 0 : return err;
8728 : : }
8729 : :
8730 : : /**
8731 : : * dev_new_index - allocate an ifindex
8732 : : * @net: the applicable net namespace
8733 : : *
8734 : : * Returns a suitable unique value for a new device interface
8735 : : * number. The caller must hold the rtnl semaphore or the
8736 : : * dev_base_lock to be sure it remains unique.
8737 : : */
8738 : 9 : static int dev_new_index(struct net *net)
8739 : : {
8740 : 9 : int ifindex = net->ifindex;
8741 : :
8742 : 9 : for (;;) {
8743 : 9 : if (++ifindex <= 0)
8744 : : ifindex = 1;
8745 [ - + - + ]: 18 : if (!__dev_get_by_index(net, ifindex))
8746 : 9 : return net->ifindex = ifindex;
8747 : : }
8748 : : }
8749 : :
8750 : : /* Delayed registration/unregisteration */
8751 : : static LIST_HEAD(net_todo_list);
8752 : : DECLARE_WAIT_QUEUE_HEAD(netdev_unregistering_wq);
8753 : :
8754 : 0 : static void net_set_todo(struct net_device *dev)
8755 : : {
8756 : 0 : list_add_tail(&dev->todo_list, &net_todo_list);
8757 : 0 : dev_net(dev)->dev_unreg_count++;
8758 : 0 : }
8759 : :
8760 : 0 : static void rollback_registered_many(struct list_head *head)
8761 : : {
8762 : 0 : struct net_device *dev, *tmp;
8763 : 0 : LIST_HEAD(close_head);
8764 : :
8765 [ # # ]: 0 : BUG_ON(dev_boot_phase);
8766 [ # # # # ]: 0 : ASSERT_RTNL();
8767 : :
8768 [ # # ]: 0 : list_for_each_entry_safe(dev, tmp, head, unreg_list) {
8769 : : /* Some devices call without registering
8770 : : * for initialization unwind. Remove those
8771 : : * devices and proceed with the remaining.
8772 : : */
8773 [ # # ]: 0 : if (dev->reg_state == NETREG_UNINITIALIZED) {
8774 : 0 : pr_debug("unregister_netdevice: device %s/%p never was registered\n",
8775 : : dev->name, dev);
8776 : :
8777 : 0 : WARN_ON(1);
8778 : 0 : list_del(&dev->unreg_list);
8779 : 0 : continue;
8780 : : }
8781 : 0 : dev->dismantle = true;
8782 [ # # ]: 0 : BUG_ON(dev->reg_state != NETREG_REGISTERED);
8783 : : }
8784 : :
8785 : : /* If device is running, close it first. */
8786 [ # # ]: 0 : list_for_each_entry(dev, head, unreg_list)
8787 : 0 : list_add_tail(&dev->close_list, &close_head);
8788 : 0 : dev_close_many(&close_head, true);
8789 : :
8790 [ # # ]: 0 : list_for_each_entry(dev, head, unreg_list) {
8791 : : /* And unlink it from device chain. */
8792 : 0 : unlist_netdevice(dev);
8793 : :
8794 : 0 : dev->reg_state = NETREG_UNREGISTERING;
8795 : : }
8796 : 0 : flush_all_backlogs();
8797 : :
8798 : 0 : synchronize_net();
8799 : :
8800 [ # # ]: 0 : list_for_each_entry(dev, head, unreg_list) {
8801 : 0 : struct sk_buff *skb = NULL;
8802 : :
8803 : : /* Shutdown queueing discipline. */
8804 : 0 : dev_shutdown(dev);
8805 : :
8806 : 0 : dev_xdp_uninstall(dev);
8807 : :
8808 : : /* Notify protocols, that we are about to destroy
8809 : : * this device. They should clean all the things.
8810 : : */
8811 : 0 : call_netdevice_notifiers(NETDEV_UNREGISTER, dev);
8812 : :
8813 [ # # ]: 0 : if (!dev->rtnl_link_ops ||
8814 [ # # ]: 0 : dev->rtnl_link_state == RTNL_LINK_INITIALIZED)
8815 : 0 : skb = rtmsg_ifinfo_build_skb(RTM_DELLINK, dev, ~0U, 0,
8816 : : GFP_KERNEL, NULL, 0);
8817 : :
8818 : : /*
8819 : : * Flush the unicast and multicast chains
8820 : : */
8821 : 0 : dev_uc_flush(dev);
8822 : 0 : dev_mc_flush(dev);
8823 : :
8824 : 0 : netdev_name_node_alt_flush(dev);
8825 : 0 : netdev_name_node_free(dev->name_node);
8826 : :
8827 [ # # ]: 0 : if (dev->netdev_ops->ndo_uninit)
8828 : 0 : dev->netdev_ops->ndo_uninit(dev);
8829 : :
8830 [ # # ]: 0 : if (skb)
8831 : 0 : rtmsg_ifinfo_send(skb, dev, GFP_KERNEL);
8832 : :
8833 : : /* Notifier chain MUST detach us all upper devices. */
8834 [ # # ]: 0 : WARN_ON(netdev_has_any_upper_dev(dev));
8835 [ # # ]: 0 : WARN_ON(netdev_has_any_lower_dev(dev));
8836 : :
8837 : : /* Remove entries from kobject tree */
8838 : 0 : netdev_unregister_kobject(dev);
8839 : : #ifdef CONFIG_XPS
8840 : : /* Remove XPS queueing entries */
8841 : 0 : netif_reset_xps_queues_gt(dev, 0);
8842 : : #endif
8843 : : }
8844 : :
8845 : 0 : synchronize_net();
8846 : :
8847 [ # # ]: 0 : list_for_each_entry(dev, head, unreg_list)
8848 : 0 : dev_put(dev);
8849 : 0 : }
8850 : :
8851 : 0 : static void rollback_registered(struct net_device *dev)
8852 : : {
8853 : 0 : LIST_HEAD(single);
8854 : :
8855 : 0 : list_add(&dev->unreg_list, &single);
8856 : 0 : rollback_registered_many(&single);
8857 : 0 : list_del(&single);
8858 : : }
8859 : :
8860 : : static netdev_features_t netdev_sync_upper_features(struct net_device *lower,
8861 : : struct net_device *upper, netdev_features_t features)
8862 : : {
8863 : : netdev_features_t upper_disables = NETIF_F_UPPER_DISABLES;
8864 : : netdev_features_t feature;
8865 : : int feature_bit;
8866 : :
8867 : : for_each_netdev_feature(upper_disables, feature_bit) {
8868 : : feature = __NETIF_F_BIT(feature_bit);
8869 : : if (!(upper->wanted_features & feature)
8870 : : && (features & feature)) {
8871 : : netdev_dbg(lower, "Dropping feature %pNF, upper dev %s has it off.\n",
8872 : : &feature, upper->name);
8873 : : features &= ~feature;
8874 : : }
8875 : : }
8876 : :
8877 : : return features;
8878 : : }
8879 : :
8880 : 0 : static void netdev_sync_lower_features(struct net_device *upper,
8881 : : struct net_device *lower, netdev_features_t features)
8882 : : {
8883 : 0 : netdev_features_t upper_disables = NETIF_F_UPPER_DISABLES;
8884 : 0 : netdev_features_t feature;
8885 : 0 : int feature_bit;
8886 : :
8887 [ # # ]: 0 : for_each_netdev_feature(upper_disables, feature_bit) {
8888 : 0 : feature = __NETIF_F_BIT(feature_bit);
8889 [ # # # # ]: 0 : if (!(features & feature) && (lower->features & feature)) {
8890 : 0 : netdev_dbg(upper, "Disabling feature %pNF on lower dev %s.\n",
8891 : : &feature, lower->name);
8892 : 0 : lower->wanted_features &= ~feature;
8893 : 0 : netdev_update_features(lower);
8894 : :
8895 [ # # ]: 0 : if (unlikely(lower->features & feature))
8896 : 0 : netdev_WARN(upper, "failed to disable %pNF on %s!\n",
8897 : : &feature, lower->name);
8898 : : }
8899 : : }
8900 : 0 : }
8901 : :
8902 : 18 : static netdev_features_t netdev_fix_features(struct net_device *dev,
8903 : : netdev_features_t features)
8904 : : {
8905 : : /* Fix illegal checksum combinations */
8906 [ + + ]: 18 : if ((features & NETIF_F_HW_CSUM) &&
8907 [ - + ]: 12 : (features & (NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM))) {
8908 : 0 : netdev_warn(dev, "mixed HW and IP checksum settings.\n");
8909 : 0 : features &= ~(NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM);
8910 : : }
8911 : :
8912 : : /* TSO requires that SG is present as well. */
8913 [ + - - + ]: 18 : if ((features & NETIF_F_ALL_TSO) && !(features & NETIF_F_SG)) {
8914 : 0 : netdev_dbg(dev, "Dropping TSO features since no SG feature.\n");
8915 : 0 : features &= ~NETIF_F_ALL_TSO;
8916 : : }
8917 : :
8918 [ - + ]: 18 : if ((features & NETIF_F_TSO) && !(features & NETIF_F_HW_CSUM) &&
8919 : : !(features & NETIF_F_IP_CSUM)) {
8920 : 0 : netdev_dbg(dev, "Dropping TSO features since no CSUM feature.\n");
8921 : 0 : features &= ~NETIF_F_TSO;
8922 : 0 : features &= ~NETIF_F_TSO_ECN;
8923 : : }
8924 : :
8925 [ - + ]: 18 : if ((features & NETIF_F_TSO6) && !(features & NETIF_F_HW_CSUM) &&
8926 : : !(features & NETIF_F_IPV6_CSUM)) {
8927 : 0 : netdev_dbg(dev, "Dropping TSO6 features since no CSUM feature.\n");
8928 : 0 : features &= ~NETIF_F_TSO6;
8929 : : }
8930 : :
8931 : : /* TSO with IPv4 ID mangling requires IPv4 TSO be enabled */
8932 [ - + ]: 18 : if ((features & NETIF_F_TSO_MANGLEID) && !(features & NETIF_F_TSO))
8933 : 0 : features &= ~NETIF_F_TSO_MANGLEID;
8934 : :
8935 : : /* TSO ECN requires that TSO is present as well. */
8936 [ - + ]: 18 : if ((features & NETIF_F_ALL_TSO) == NETIF_F_TSO_ECN)
8937 : 0 : features &= ~NETIF_F_TSO_ECN;
8938 : :
8939 : : /* Software GSO depends on SG. */
8940 [ - + ]: 18 : if ((features & NETIF_F_GSO) && !(features & NETIF_F_SG)) {
8941 : 0 : netdev_dbg(dev, "Dropping NETIF_F_GSO since no SG feature.\n");
8942 : 0 : features &= ~NETIF_F_GSO;
8943 : : }
8944 : :
8945 : : /* GSO partial features require GSO partial be set */
8946 [ - + ]: 18 : if ((features & dev->gso_partial_features) &&
8947 [ # # ]: 0 : !(features & NETIF_F_GSO_PARTIAL)) {
8948 : 0 : netdev_dbg(dev,
8949 : : "Dropping partially supported GSO features since no GSO partial.\n");
8950 : 0 : features &= ~dev->gso_partial_features;
8951 : : }
8952 : :
8953 [ + + ]: 18 : if (!(features & NETIF_F_RXCSUM)) {
8954 : : /* NETIF_F_GRO_HW implies doing RXCSUM since every packet
8955 : : * successfully merged by hardware must also have the
8956 : : * checksum verified by hardware. If the user does not
8957 : : * want to enable RXCSUM, logically, we should disable GRO_HW.
8958 : : */
8959 [ - + ]: 6 : if (features & NETIF_F_GRO_HW) {
8960 : 0 : netdev_dbg(dev, "Dropping NETIF_F_GRO_HW since no RXCSUM feature.\n");
8961 : 0 : features &= ~NETIF_F_GRO_HW;
8962 : : }
8963 : : }
8964 : :
8965 : : /* LRO/HW-GRO features cannot be combined with RX-FCS */
8966 [ - + ]: 18 : if (features & NETIF_F_RXFCS) {
8967 [ # # ]: 0 : if (features & NETIF_F_LRO) {
8968 : 0 : netdev_dbg(dev, "Dropping LRO feature since RX-FCS is requested.\n");
8969 : 0 : features &= ~NETIF_F_LRO;
8970 : : }
8971 : :
8972 [ # # ]: 0 : if (features & NETIF_F_GRO_HW) {
8973 : 0 : netdev_dbg(dev, "Dropping HW-GRO feature since RX-FCS is requested.\n");
8974 : 0 : features &= ~NETIF_F_GRO_HW;
8975 : : }
8976 : : }
8977 : :
8978 : 18 : return features;
8979 : : }
8980 : :
8981 : 18 : int __netdev_update_features(struct net_device *dev)
8982 : : {
8983 : 18 : struct net_device *upper, *lower;
8984 : 18 : netdev_features_t features;
8985 : 18 : struct list_head *iter;
8986 : 18 : int err = -1;
8987 : :
8988 [ - + - - ]: 18 : ASSERT_RTNL();
8989 : :
8990 [ - + ]: 18 : features = netdev_get_wanted_features(dev);
8991 : :
8992 [ - + ]: 18 : if (dev->netdev_ops->ndo_fix_features)
8993 : 0 : features = dev->netdev_ops->ndo_fix_features(dev, features);
8994 : :
8995 : : /* driver might be less strict about feature dependencies */
8996 : 18 : features = netdev_fix_features(dev, features);
8997 : :
8998 : : /* some features can't be enabled if they're off an an upper device */
8999 [ - + - + ]: 36 : netdev_for_each_upper_dev_rcu(dev, upper, iter)
9000 [ # # ]: 0 : features = netdev_sync_upper_features(dev, upper, features);
9001 : :
9002 [ + - ]: 18 : if (dev->features == features)
9003 : 18 : goto sync_lower;
9004 : :
9005 : 0 : netdev_dbg(dev, "Features changed: %pNF -> %pNF\n",
9006 : : &dev->features, &features);
9007 : :
9008 [ # # ]: 0 : if (dev->netdev_ops->ndo_set_features)
9009 : 0 : err = dev->netdev_ops->ndo_set_features(dev, features);
9010 : : else
9011 : : err = 0;
9012 : :
9013 [ # # ]: 0 : if (unlikely(err < 0)) {
9014 : 0 : netdev_err(dev,
9015 : : "set_features() failed (%d); wanted %pNF, left %pNF\n",
9016 : : err, &features, &dev->features);
9017 : : /* return non-0 since some features might have changed and
9018 : : * it's better to fire a spurious notification than miss it
9019 : : */
9020 : 0 : return -1;
9021 : : }
9022 : :
9023 : 0 : sync_lower:
9024 : : /* some features must be disabled on lower devices when disabled
9025 : : * on an upper device (think: bonding master or bridge)
9026 : : */
9027 [ - + - - : 36 : netdev_for_each_lower_dev(dev, lower, iter)
- + ]
9028 : 0 : netdev_sync_lower_features(dev, lower, features);
9029 : :
9030 [ - + ]: 18 : if (!err) {
9031 : 0 : netdev_features_t diff = features ^ dev->features;
9032 : :
9033 [ # # ]: 0 : if (diff & NETIF_F_RX_UDP_TUNNEL_PORT) {
9034 : : /* udp_tunnel_{get,drop}_rx_info both need
9035 : : * NETIF_F_RX_UDP_TUNNEL_PORT enabled on the
9036 : : * device, or they won't do anything.
9037 : : * Thus we need to update dev->features
9038 : : * *before* calling udp_tunnel_get_rx_info,
9039 : : * but *after* calling udp_tunnel_drop_rx_info.
9040 : : */
9041 [ # # ]: 0 : if (features & NETIF_F_RX_UDP_TUNNEL_PORT) {
9042 : 0 : dev->features = features;
9043 : 0 : udp_tunnel_get_rx_info(dev);
9044 : : } else {
9045 : 0 : udp_tunnel_drop_rx_info(dev);
9046 : : }
9047 : : }
9048 : :
9049 [ # # ]: 0 : if (diff & NETIF_F_HW_VLAN_CTAG_FILTER) {
9050 [ # # ]: 0 : if (features & NETIF_F_HW_VLAN_CTAG_FILTER) {
9051 : 0 : dev->features = features;
9052 : 0 : err |= vlan_get_rx_ctag_filter_info(dev);
9053 : : } else {
9054 : 0 : vlan_drop_rx_ctag_filter_info(dev);
9055 : : }
9056 : : }
9057 : :
9058 [ # # ]: 0 : if (diff & NETIF_F_HW_VLAN_STAG_FILTER) {
9059 [ # # ]: 0 : if (features & NETIF_F_HW_VLAN_STAG_FILTER) {
9060 : 0 : dev->features = features;
9061 : 0 : err |= vlan_get_rx_stag_filter_info(dev);
9062 : : } else {
9063 : 0 : vlan_drop_rx_stag_filter_info(dev);
9064 : : }
9065 : : }
9066 : :
9067 : 0 : dev->features = features;
9068 : : }
9069 : :
9070 : 18 : return err < 0 ? 0 : 1;
9071 : : }
9072 : :
9073 : : /**
9074 : : * netdev_update_features - recalculate device features
9075 : : * @dev: the device to check
9076 : : *
9077 : : * Recalculate dev->features set and send notifications if it
9078 : : * has changed. Should be called after driver or hardware dependent
9079 : : * conditions might have changed that influence the features.
9080 : : */
9081 : 0 : void netdev_update_features(struct net_device *dev)
9082 : : {
9083 [ # # ]: 0 : if (__netdev_update_features(dev))
9084 : 0 : netdev_features_change(dev);
9085 : 0 : }
9086 : : EXPORT_SYMBOL(netdev_update_features);
9087 : :
9088 : : /**
9089 : : * netdev_change_features - recalculate device features
9090 : : * @dev: the device to check
9091 : : *
9092 : : * Recalculate dev->features set and send notifications even
9093 : : * if they have not changed. Should be called instead of
9094 : : * netdev_update_features() if also dev->vlan_features might
9095 : : * have changed to allow the changes to be propagated to stacked
9096 : : * VLAN devices.
9097 : : */
9098 : 0 : void netdev_change_features(struct net_device *dev)
9099 : : {
9100 : 0 : __netdev_update_features(dev);
9101 : 0 : netdev_features_change(dev);
9102 : 0 : }
9103 : : EXPORT_SYMBOL(netdev_change_features);
9104 : :
9105 : : /**
9106 : : * netif_stacked_transfer_operstate - transfer operstate
9107 : : * @rootdev: the root or lower level device to transfer state from
9108 : : * @dev: the device to transfer operstate to
9109 : : *
9110 : : * Transfer operational state from root to device. This is normally
9111 : : * called when a stacking relationship exists between the root
9112 : : * device and the device(a leaf device).
9113 : : */
9114 : 0 : void netif_stacked_transfer_operstate(const struct net_device *rootdev,
9115 : : struct net_device *dev)
9116 : : {
9117 [ # # ]: 0 : if (rootdev->operstate == IF_OPER_DORMANT)
9118 : 0 : netif_dormant_on(dev);
9119 : : else
9120 : 0 : netif_dormant_off(dev);
9121 : :
9122 [ # # ]: 0 : if (netif_carrier_ok(rootdev))
9123 : 0 : netif_carrier_on(dev);
9124 : : else
9125 : 0 : netif_carrier_off(dev);
9126 : 0 : }
9127 : : EXPORT_SYMBOL(netif_stacked_transfer_operstate);
9128 : :
9129 : 12 : static int netif_alloc_rx_queues(struct net_device *dev)
9130 : : {
9131 : 12 : unsigned int i, count = dev->num_rx_queues;
9132 : 12 : struct netdev_rx_queue *rx;
9133 : 12 : size_t sz = count * sizeof(*rx);
9134 : 12 : int err = 0;
9135 : :
9136 [ - + ]: 12 : BUG_ON(count < 1);
9137 : :
9138 : 12 : rx = kvzalloc(sz, GFP_KERNEL | __GFP_RETRY_MAYFAIL);
9139 [ + - ]: 12 : if (!rx)
9140 : : return -ENOMEM;
9141 : :
9142 : 12 : dev->_rx = rx;
9143 : :
9144 [ + + ]: 24 : for (i = 0; i < count; i++) {
9145 : 12 : rx[i].dev = dev;
9146 : :
9147 : : /* XDP RX-queue setup */
9148 : 12 : err = xdp_rxq_info_reg(&rx[i].xdp_rxq, dev, i);
9149 [ - + ]: 12 : if (err < 0)
9150 : 0 : goto err_rxq_info;
9151 : : }
9152 : : return 0;
9153 : :
9154 : : err_rxq_info:
9155 : : /* Rollback successful reg's and free other resources */
9156 [ # # ]: 0 : while (i--)
9157 : 0 : xdp_rxq_info_unreg(&rx[i].xdp_rxq);
9158 : 0 : kvfree(dev->_rx);
9159 : 0 : dev->_rx = NULL;
9160 : 0 : return err;
9161 : : }
9162 : :
9163 : : static void netif_free_rx_queues(struct net_device *dev)
9164 : : {
9165 : : unsigned int i, count = dev->num_rx_queues;
9166 : :
9167 : : /* netif_alloc_rx_queues alloc failed, resources have been unreg'ed */
9168 : : if (!dev->_rx)
9169 : : return;
9170 : :
9171 : : for (i = 0; i < count; i++)
9172 : : xdp_rxq_info_unreg(&dev->_rx[i].xdp_rxq);
9173 : :
9174 : : kvfree(dev->_rx);
9175 : : }
9176 : :
9177 : 12 : static void netdev_init_one_queue(struct net_device *dev,
9178 : : struct netdev_queue *queue, void *_unused)
9179 : : {
9180 : : /* Initialize queue lock */
9181 : 12 : spin_lock_init(&queue->_xmit_lock);
9182 : 12 : lockdep_set_class(&queue->_xmit_lock, &dev->qdisc_xmit_lock_key);
9183 : 12 : queue->xmit_lock_owner = -1;
9184 : 12 : netdev_queue_numa_node_write(queue, NUMA_NO_NODE);
9185 : 12 : queue->dev = dev;
9186 : : #ifdef CONFIG_BQL
9187 : 12 : dql_init(&queue->dql, HZ);
9188 : : #endif
9189 : 12 : }
9190 : :
9191 : 0 : static void netif_free_tx_queues(struct net_device *dev)
9192 : : {
9193 : 0 : kvfree(dev->_tx);
9194 : : }
9195 : :
9196 : 12 : static int netif_alloc_netdev_queues(struct net_device *dev)
9197 : : {
9198 : 12 : unsigned int count = dev->num_tx_queues;
9199 : 12 : struct netdev_queue *tx;
9200 : 12 : size_t sz = count * sizeof(*tx);
9201 : :
9202 [ + - ]: 12 : if (count < 1 || count > 0xffff)
9203 : : return -EINVAL;
9204 : :
9205 : 12 : tx = kvzalloc(sz, GFP_KERNEL | __GFP_RETRY_MAYFAIL);
9206 [ + - ]: 12 : if (!tx)
9207 : : return -ENOMEM;
9208 : :
9209 : 12 : dev->_tx = tx;
9210 : :
9211 : 12 : netdev_for_each_tx_queue(dev, netdev_init_one_queue, NULL);
9212 : 12 : spin_lock_init(&dev->tx_global_lock);
9213 : :
9214 : 12 : return 0;
9215 : : }
9216 : :
9217 : 0 : void netif_tx_stop_all_queues(struct net_device *dev)
9218 : : {
9219 : 0 : unsigned int i;
9220 : :
9221 [ # # # # ]: 0 : for (i = 0; i < dev->num_tx_queues; i++) {
9222 : 0 : struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
9223 : :
9224 : 0 : netif_tx_stop_queue(txq);
9225 : : }
9226 : 0 : }
9227 : : EXPORT_SYMBOL(netif_tx_stop_all_queues);
9228 : :
9229 : 12 : static void netdev_register_lockdep_key(struct net_device *dev)
9230 : : {
9231 : 12 : lockdep_register_key(&dev->qdisc_tx_busylock_key);
9232 : 12 : lockdep_register_key(&dev->qdisc_running_key);
9233 : 12 : lockdep_register_key(&dev->qdisc_xmit_lock_key);
9234 : 12 : lockdep_register_key(&dev->addr_list_lock_key);
9235 : : }
9236 : :
9237 : 0 : static void netdev_unregister_lockdep_key(struct net_device *dev)
9238 : : {
9239 : 0 : lockdep_unregister_key(&dev->qdisc_tx_busylock_key);
9240 : 0 : lockdep_unregister_key(&dev->qdisc_running_key);
9241 : 0 : lockdep_unregister_key(&dev->qdisc_xmit_lock_key);
9242 : 0 : lockdep_unregister_key(&dev->addr_list_lock_key);
9243 : : }
9244 : :
9245 : 0 : void netdev_update_lockdep_key(struct net_device *dev)
9246 : : {
9247 : 0 : lockdep_unregister_key(&dev->addr_list_lock_key);
9248 : 0 : lockdep_register_key(&dev->addr_list_lock_key);
9249 : :
9250 : 0 : lockdep_set_class(&dev->addr_list_lock, &dev->addr_list_lock_key);
9251 : 0 : }
9252 : : EXPORT_SYMBOL(netdev_update_lockdep_key);
9253 : :
9254 : : /**
9255 : : * register_netdevice - register a network device
9256 : : * @dev: device to register
9257 : : *
9258 : : * Take a completed network device structure and add it to the kernel
9259 : : * interfaces. A %NETDEV_REGISTER message is sent to the netdev notifier
9260 : : * chain. 0 is returned on success. A negative errno code is returned
9261 : : * on a failure to set up the device, or if the name is a duplicate.
9262 : : *
9263 : : * Callers must hold the rtnl semaphore. You may want
9264 : : * register_netdev() instead of this.
9265 : : *
9266 : : * BUGS:
9267 : : * The locking appears insufficient to guarantee two parallel registers
9268 : : * will not get the same name.
9269 : : */
9270 : :
9271 : 9 : int register_netdevice(struct net_device *dev)
9272 : : {
9273 : 9 : int ret;
9274 [ - + ]: 9 : struct net *net = dev_net(dev);
9275 : :
9276 : 9 : BUILD_BUG_ON(sizeof(netdev_features_t) * BITS_PER_BYTE <
9277 : : NETDEV_FEATURE_COUNT);
9278 [ - + ]: 9 : BUG_ON(dev_boot_phase);
9279 [ - + - - ]: 9 : ASSERT_RTNL();
9280 : :
9281 : 9 : might_sleep();
9282 : :
9283 : : /* When net_device's are persistent, this will be fatal. */
9284 [ - + ]: 9 : BUG_ON(dev->reg_state != NETREG_UNINITIALIZED);
9285 [ - + ]: 9 : BUG_ON(!net);
9286 : :
9287 : 9 : spin_lock_init(&dev->addr_list_lock);
9288 : 9 : lockdep_set_class(&dev->addr_list_lock, &dev->addr_list_lock_key);
9289 : :
9290 : 9 : ret = dev_get_valid_name(net, dev, dev->name);
9291 [ - + ]: 9 : if (ret < 0)
9292 : 0 : goto out;
9293 : :
9294 : 9 : ret = -ENOMEM;
9295 : 9 : dev->name_node = netdev_name_node_head_alloc(dev);
9296 [ - + ]: 9 : if (!dev->name_node)
9297 : 0 : goto out;
9298 : :
9299 : : /* Init, if this function is available */
9300 [ + + ]: 9 : if (dev->netdev_ops->ndo_init) {
9301 : 6 : ret = dev->netdev_ops->ndo_init(dev);
9302 [ - + ]: 6 : if (ret) {
9303 [ # # ]: 0 : if (ret > 0)
9304 : 0 : ret = -EIO;
9305 : 0 : goto err_free_name;
9306 : : }
9307 : : }
9308 : :
9309 [ - + ]: 9 : if (((dev->hw_features | dev->features) &
9310 : 0 : NETIF_F_HW_VLAN_CTAG_FILTER) &&
9311 [ # # ]: 0 : (!dev->netdev_ops->ndo_vlan_rx_add_vid ||
9312 [ # # ]: 0 : !dev->netdev_ops->ndo_vlan_rx_kill_vid)) {
9313 : 0 : netdev_WARN(dev, "Buggy VLAN acceleration in driver!\n");
9314 : 0 : ret = -EINVAL;
9315 : 0 : goto err_uninit;
9316 : : }
9317 : :
9318 : 9 : ret = -EBUSY;
9319 [ + - ]: 9 : if (!dev->ifindex)
9320 : 9 : dev->ifindex = dev_new_index(net);
9321 [ # # # # ]: 0 : else if (__dev_get_by_index(net, dev->ifindex))
9322 : 0 : goto err_uninit;
9323 : :
9324 : : /* Transfer changeable features to wanted_features and enable
9325 : : * software offloads (GSO and GRO).
9326 : : */
9327 : 9 : dev->hw_features |= (NETIF_F_SOFT_FEATURES | NETIF_F_SOFT_FEATURES_OFF);
9328 : 9 : dev->features |= NETIF_F_SOFT_FEATURES;
9329 : :
9330 [ - + ]: 9 : if (dev->netdev_ops->ndo_udp_tunnel_add) {
9331 : 0 : dev->features |= NETIF_F_RX_UDP_TUNNEL_PORT;
9332 : 0 : dev->hw_features |= NETIF_F_RX_UDP_TUNNEL_PORT;
9333 : : }
9334 : :
9335 : 9 : dev->wanted_features = dev->features & dev->hw_features;
9336 : :
9337 [ + + ]: 9 : if (!(dev->flags & IFF_LOOPBACK))
9338 : 6 : dev->hw_features |= NETIF_F_NOCACHE_COPY;
9339 : :
9340 : : /* If IPv4 TCP segmentation offload is supported we should also
9341 : : * allow the device to enable segmenting the frame with the option
9342 : : * of ignoring a static IP ID value. This doesn't enable the
9343 : : * feature itself but allows the user to enable it later.
9344 : : */
9345 [ + - ]: 9 : if (dev->hw_features & NETIF_F_TSO)
9346 : 9 : dev->hw_features |= NETIF_F_TSO_MANGLEID;
9347 [ + + ]: 9 : if (dev->vlan_features & NETIF_F_TSO)
9348 : 3 : dev->vlan_features |= NETIF_F_TSO_MANGLEID;
9349 [ - + ]: 9 : if (dev->mpls_features & NETIF_F_TSO)
9350 : 0 : dev->mpls_features |= NETIF_F_TSO_MANGLEID;
9351 [ - + ]: 9 : if (dev->hw_enc_features & NETIF_F_TSO)
9352 : 0 : dev->hw_enc_features |= NETIF_F_TSO_MANGLEID;
9353 : :
9354 : : /* Make NETIF_F_HIGHDMA inheritable to VLAN devices.
9355 : : */
9356 : 9 : dev->vlan_features |= NETIF_F_HIGHDMA;
9357 : :
9358 : : /* Make NETIF_F_SG inheritable to tunnel devices.
9359 : : */
9360 : 9 : dev->hw_enc_features |= NETIF_F_SG | NETIF_F_GSO_PARTIAL;
9361 : :
9362 : : /* Make NETIF_F_SG inheritable to MPLS.
9363 : : */
9364 : 9 : dev->mpls_features |= NETIF_F_SG;
9365 : :
9366 : 9 : ret = call_netdevice_notifiers(NETDEV_POST_INIT, dev);
9367 [ - + ]: 9 : ret = notifier_to_errno(ret);
9368 : 0 : if (ret)
9369 : 0 : goto err_uninit;
9370 : :
9371 : 9 : ret = netdev_register_kobject(dev);
9372 [ - + ]: 9 : if (ret) {
9373 : 0 : dev->reg_state = NETREG_UNREGISTERED;
9374 : 0 : goto err_uninit;
9375 : : }
9376 : 9 : dev->reg_state = NETREG_REGISTERED;
9377 : :
9378 : 9 : __netdev_update_features(dev);
9379 : :
9380 : : /*
9381 : : * Default initial state at registry is that the
9382 : : * device is present.
9383 : : */
9384 : :
9385 : 9 : set_bit(__LINK_STATE_PRESENT, &dev->state);
9386 : :
9387 : 9 : linkwatch_init_dev(dev);
9388 : :
9389 : 9 : dev_init_scheduler(dev);
9390 : 9 : dev_hold(dev);
9391 : 9 : list_netdevice(dev);
9392 : 9 : add_device_randomness(dev->dev_addr, dev->addr_len);
9393 : :
9394 : : /* If the device has permanent device address, driver should
9395 : : * set dev_addr and also addr_assign_type should be set to
9396 : : * NET_ADDR_PERM (default value).
9397 : : */
9398 [ + - ]: 9 : if (dev->addr_assign_type == NET_ADDR_PERM)
9399 : 9 : memcpy(dev->perm_addr, dev->dev_addr, dev->addr_len);
9400 : :
9401 : : /* Notify protocols, that a new device appeared. */
9402 : 9 : ret = call_netdevice_notifiers(NETDEV_REGISTER, dev);
9403 [ - + ]: 9 : ret = notifier_to_errno(ret);
9404 : 0 : if (ret) {
9405 : 0 : rollback_registered(dev);
9406 : 0 : rcu_barrier();
9407 : :
9408 : 0 : dev->reg_state = NETREG_UNREGISTERED;
9409 : : }
9410 : : /*
9411 : : * Prevent userspace races by waiting until the network
9412 : : * device is fully setup before sending notifications.
9413 : : */
9414 [ + + ]: 9 : if (!dev->rtnl_link_ops ||
9415 [ - + ]: 3 : dev->rtnl_link_state == RTNL_LINK_INITIALIZED)
9416 : 9 : rtmsg_ifinfo(RTM_NEWLINK, dev, ~0U, GFP_KERNEL);
9417 : :
9418 : 0 : out:
9419 : 9 : return ret;
9420 : :
9421 : 0 : err_uninit:
9422 [ # # ]: 0 : if (dev->netdev_ops->ndo_uninit)
9423 : 0 : dev->netdev_ops->ndo_uninit(dev);
9424 [ # # ]: 0 : if (dev->priv_destructor)
9425 : 0 : dev->priv_destructor(dev);
9426 : 0 : err_free_name:
9427 : 0 : netdev_name_node_free(dev->name_node);
9428 : 0 : goto out;
9429 : : }
9430 : : EXPORT_SYMBOL(register_netdevice);
9431 : :
9432 : : /**
9433 : : * init_dummy_netdev - init a dummy network device for NAPI
9434 : : * @dev: device to init
9435 : : *
9436 : : * This takes a network device structure and initialize the minimum
9437 : : * amount of fields so it can be used to schedule NAPI polls without
9438 : : * registering a full blown interface. This is to be used by drivers
9439 : : * that need to tie several hardware interfaces to a single NAPI
9440 : : * poll scheduler due to HW limitations.
9441 : : */
9442 : 3 : int init_dummy_netdev(struct net_device *dev)
9443 : : {
9444 : : /* Clear everything. Note we don't initialize spinlocks
9445 : : * are they aren't supposed to be taken by any of the
9446 : : * NAPI code and this dummy netdev is supposed to be
9447 : : * only ever used for NAPI polls
9448 : : */
9449 : 3 : memset(dev, 0, sizeof(struct net_device));
9450 : :
9451 : : /* make sure we BUG if trying to hit standard
9452 : : * register/unregister code path
9453 : : */
9454 : 3 : dev->reg_state = NETREG_DUMMY;
9455 : :
9456 : : /* NAPI wants this */
9457 : 3 : INIT_LIST_HEAD(&dev->napi_list);
9458 : :
9459 : : /* a dummy interface is started by default */
9460 : 3 : set_bit(__LINK_STATE_PRESENT, &dev->state);
9461 : 3 : set_bit(__LINK_STATE_START, &dev->state);
9462 : :
9463 : : /* napi_busy_loop stats accounting wants this */
9464 : 3 : dev_net_set(dev, &init_net);
9465 : :
9466 : : /* Note : We dont allocate pcpu_refcnt for dummy devices,
9467 : : * because users of this 'device' dont need to change
9468 : : * its refcount.
9469 : : */
9470 : :
9471 : 3 : return 0;
9472 : : }
9473 : : EXPORT_SYMBOL_GPL(init_dummy_netdev);
9474 : :
9475 : :
9476 : : /**
9477 : : * register_netdev - register a network device
9478 : : * @dev: device to register
9479 : : *
9480 : : * Take a completed network device structure and add it to the kernel
9481 : : * interfaces. A %NETDEV_REGISTER message is sent to the netdev notifier
9482 : : * chain. 0 is returned on success. A negative errno code is returned
9483 : : * on a failure to set up the device, or if the name is a duplicate.
9484 : : *
9485 : : * This is a wrapper around register_netdevice that takes the rtnl semaphore
9486 : : * and expands the device name if you passed a format string to
9487 : : * alloc_netdev.
9488 : : */
9489 : 9 : int register_netdev(struct net_device *dev)
9490 : : {
9491 : 9 : int err;
9492 : :
9493 [ + - ]: 9 : if (rtnl_lock_killable())
9494 : : return -EINTR;
9495 : 9 : err = register_netdevice(dev);
9496 : 9 : rtnl_unlock();
9497 : 9 : return err;
9498 : : }
9499 : : EXPORT_SYMBOL(register_netdev);
9500 : :
9501 : 0 : int netdev_refcnt_read(const struct net_device *dev)
9502 : : {
9503 : 0 : int i, refcnt = 0;
9504 : :
9505 [ # # ]: 0 : for_each_possible_cpu(i)
9506 : 0 : refcnt += *per_cpu_ptr(dev->pcpu_refcnt, i);
9507 : 0 : return refcnt;
9508 : : }
9509 : : EXPORT_SYMBOL(netdev_refcnt_read);
9510 : :
9511 : : /**
9512 : : * netdev_wait_allrefs - wait until all references are gone.
9513 : : * @dev: target net_device
9514 : : *
9515 : : * This is called when unregistering network devices.
9516 : : *
9517 : : * Any protocol or device that holds a reference should register
9518 : : * for netdevice notification, and cleanup and put back the
9519 : : * reference if they receive an UNREGISTER event.
9520 : : * We can get stuck here if buggy protocols don't correctly
9521 : : * call dev_put.
9522 : : */
9523 : 0 : static void netdev_wait_allrefs(struct net_device *dev)
9524 : : {
9525 : 0 : unsigned long rebroadcast_time, warning_time;
9526 : 0 : int refcnt;
9527 : :
9528 : 0 : linkwatch_forget_dev(dev);
9529 : :
9530 : 0 : rebroadcast_time = warning_time = jiffies;
9531 : 0 : refcnt = netdev_refcnt_read(dev);
9532 : :
9533 [ # # ]: 0 : while (refcnt != 0) {
9534 [ # # ]: 0 : if (time_after(jiffies, rebroadcast_time + 1 * HZ)) {
9535 : 0 : rtnl_lock();
9536 : :
9537 : : /* Rebroadcast unregister notification */
9538 : 0 : call_netdevice_notifiers(NETDEV_UNREGISTER, dev);
9539 : :
9540 : 0 : __rtnl_unlock();
9541 : 0 : rcu_barrier();
9542 : 0 : rtnl_lock();
9543 : :
9544 [ # # ]: 0 : if (test_bit(__LINK_STATE_LINKWATCH_PENDING,
9545 : 0 : &dev->state)) {
9546 : : /* We must not have linkwatch events
9547 : : * pending on unregister. If this
9548 : : * happens, we simply run the queue
9549 : : * unscheduled, resulting in a noop
9550 : : * for this device.
9551 : : */
9552 : 0 : linkwatch_run_queue();
9553 : : }
9554 : :
9555 : 0 : __rtnl_unlock();
9556 : :
9557 : 0 : rebroadcast_time = jiffies;
9558 : : }
9559 : :
9560 : 0 : msleep(250);
9561 : :
9562 : 0 : refcnt = netdev_refcnt_read(dev);
9563 : :
9564 [ # # # # ]: 0 : if (refcnt && time_after(jiffies, warning_time + 10 * HZ)) {
9565 : 0 : pr_emerg("unregister_netdevice: waiting for %s to become free. Usage count = %d\n",
9566 : : dev->name, refcnt);
9567 : 0 : warning_time = jiffies;
9568 : : }
9569 : : }
9570 : 0 : }
9571 : :
9572 : : /* The sequence is:
9573 : : *
9574 : : * rtnl_lock();
9575 : : * ...
9576 : : * register_netdevice(x1);
9577 : : * register_netdevice(x2);
9578 : : * ...
9579 : : * unregister_netdevice(y1);
9580 : : * unregister_netdevice(y2);
9581 : : * ...
9582 : : * rtnl_unlock();
9583 : : * free_netdev(y1);
9584 : : * free_netdev(y2);
9585 : : *
9586 : : * We are invoked by rtnl_unlock().
9587 : : * This allows us to deal with problems:
9588 : : * 1) We can delete sysfs objects which invoke hotplug
9589 : : * without deadlocking with linkwatch via keventd.
9590 : : * 2) Since we run with the RTNL semaphore not held, we can sleep
9591 : : * safely in order to wait for the netdev refcnt to drop to zero.
9592 : : *
9593 : : * We must not return until all unregister events added during
9594 : : * the interval the lock was held have been completed.
9595 : : */
9596 : 408 : void netdev_run_todo(void)
9597 : : {
9598 : 408 : struct list_head list;
9599 : :
9600 : : /* Snapshot list, allow later requests */
9601 : 408 : list_replace_init(&net_todo_list, &list);
9602 : :
9603 : 408 : __rtnl_unlock();
9604 : :
9605 : :
9606 : : /* Wait for rcu callbacks to finish before next phase */
9607 [ - + ]: 408 : if (!list_empty(&list))
9608 : 0 : rcu_barrier();
9609 : :
9610 [ - + ]: 408 : while (!list_empty(&list)) {
9611 : 0 : struct net_device *dev
9612 : 0 : = list_first_entry(&list, struct net_device, todo_list);
9613 [ # # ]: 0 : list_del(&dev->todo_list);
9614 : :
9615 [ # # ]: 0 : if (unlikely(dev->reg_state != NETREG_UNREGISTERING)) {
9616 : 0 : pr_err("network todo '%s' but state %d\n",
9617 : : dev->name, dev->reg_state);
9618 : 0 : dump_stack();
9619 : 0 : continue;
9620 : : }
9621 : :
9622 : 0 : dev->reg_state = NETREG_UNREGISTERED;
9623 : :
9624 : 0 : netdev_wait_allrefs(dev);
9625 : :
9626 : : /* paranoia */
9627 [ # # ]: 0 : BUG_ON(netdev_refcnt_read(dev));
9628 [ # # ]: 0 : BUG_ON(!list_empty(&dev->ptype_all));
9629 [ # # ]: 0 : BUG_ON(!list_empty(&dev->ptype_specific));
9630 [ # # ]: 0 : WARN_ON(rcu_access_pointer(dev->ip_ptr));
9631 [ # # ]: 0 : WARN_ON(rcu_access_pointer(dev->ip6_ptr));
9632 : : #if IS_ENABLED(CONFIG_DECNET)
9633 : : WARN_ON(dev->dn_ptr);
9634 : : #endif
9635 [ # # ]: 0 : if (dev->priv_destructor)
9636 : 0 : dev->priv_destructor(dev);
9637 [ # # ]: 0 : if (dev->needs_free_netdev)
9638 : 0 : free_netdev(dev);
9639 : :
9640 : : /* Report a network device has been unregistered */
9641 : 0 : rtnl_lock();
9642 : 0 : dev_net(dev)->dev_unreg_count--;
9643 : 0 : __rtnl_unlock();
9644 : 0 : wake_up(&netdev_unregistering_wq);
9645 : :
9646 : : /* Free network device */
9647 : 0 : kobject_put(&dev->dev.kobj);
9648 : : }
9649 : 408 : }
9650 : :
9651 : : /* Convert net_device_stats to rtnl_link_stats64. rtnl_link_stats64 has
9652 : : * all the same fields in the same order as net_device_stats, with only
9653 : : * the type differing, but rtnl_link_stats64 may have additional fields
9654 : : * at the end for newer counters.
9655 : : */
9656 : 39 : void netdev_stats_to_stats64(struct rtnl_link_stats64 *stats64,
9657 : : const struct net_device_stats *netdev_stats)
9658 : : {
9659 : : #if BITS_PER_LONG == 64
9660 : 39 : BUILD_BUG_ON(sizeof(*stats64) < sizeof(*netdev_stats));
9661 : 39 : memcpy(stats64, netdev_stats, sizeof(*netdev_stats));
9662 : : /* zero out counters that only exist in rtnl_link_stats64 */
9663 : 39 : memset((char *)stats64 + sizeof(*netdev_stats), 0,
9664 : : sizeof(*stats64) - sizeof(*netdev_stats));
9665 : : #else
9666 : : size_t i, n = sizeof(*netdev_stats) / sizeof(unsigned long);
9667 : : const unsigned long *src = (const unsigned long *)netdev_stats;
9668 : : u64 *dst = (u64 *)stats64;
9669 : :
9670 : : BUILD_BUG_ON(n > sizeof(*stats64) / sizeof(u64));
9671 : : for (i = 0; i < n; i++)
9672 : : dst[i] = src[i];
9673 : : /* zero out counters that only exist in rtnl_link_stats64 */
9674 : : memset((char *)stats64 + n * sizeof(u64), 0,
9675 : : sizeof(*stats64) - n * sizeof(u64));
9676 : : #endif
9677 : 39 : }
9678 : : EXPORT_SYMBOL(netdev_stats_to_stats64);
9679 : :
9680 : : /**
9681 : : * dev_get_stats - get network device statistics
9682 : : * @dev: device to get statistics from
9683 : : * @storage: place to store stats
9684 : : *
9685 : : * Get network statistics from device. Return @storage.
9686 : : * The device driver may provide its own method by setting
9687 : : * dev->netdev_ops->get_stats64 or dev->netdev_ops->get_stats;
9688 : : * otherwise the internal statistics structure is used.
9689 : : */
9690 : 60 : struct rtnl_link_stats64 *dev_get_stats(struct net_device *dev,
9691 : : struct rtnl_link_stats64 *storage)
9692 : : {
9693 : 60 : const struct net_device_ops *ops = dev->netdev_ops;
9694 : :
9695 [ + + ]: 60 : if (ops->ndo_get_stats64) {
9696 : 39 : memset(storage, 0, sizeof(*storage));
9697 : 39 : ops->ndo_get_stats64(dev, storage);
9698 [ + - ]: 21 : } else if (ops->ndo_get_stats) {
9699 : 21 : netdev_stats_to_stats64(storage, ops->ndo_get_stats(dev));
9700 : : } else {
9701 : 0 : netdev_stats_to_stats64(storage, &dev->stats);
9702 : : }
9703 : 60 : storage->rx_dropped += (unsigned long)atomic_long_read(&dev->rx_dropped);
9704 : 60 : storage->tx_dropped += (unsigned long)atomic_long_read(&dev->tx_dropped);
9705 : 60 : storage->rx_nohandler += (unsigned long)atomic_long_read(&dev->rx_nohandler);
9706 : 60 : return storage;
9707 : : }
9708 : : EXPORT_SYMBOL(dev_get_stats);
9709 : :
9710 : 0 : struct netdev_queue *dev_ingress_queue_create(struct net_device *dev)
9711 : : {
9712 [ # # ]: 0 : struct netdev_queue *queue = dev_ingress_queue(dev);
9713 : :
9714 : : #ifdef CONFIG_NET_CLS_ACT
9715 [ # # ]: 0 : if (queue)
9716 : : return queue;
9717 : 0 : queue = kzalloc(sizeof(*queue), GFP_KERNEL);
9718 [ # # ]: 0 : if (!queue)
9719 : : return NULL;
9720 : 0 : netdev_init_one_queue(dev, queue, NULL);
9721 : 0 : RCU_INIT_POINTER(queue->qdisc, &noop_qdisc);
9722 : 0 : queue->qdisc_sleeping = &noop_qdisc;
9723 : 0 : rcu_assign_pointer(dev->ingress_queue, queue);
9724 : : #endif
9725 : 0 : return queue;
9726 : : }
9727 : :
9728 : : static const struct ethtool_ops default_ethtool_ops;
9729 : :
9730 : 0 : void netdev_set_default_ethtool_ops(struct net_device *dev,
9731 : : const struct ethtool_ops *ops)
9732 : : {
9733 [ # # ]: 0 : if (dev->ethtool_ops == &default_ethtool_ops)
9734 : 0 : dev->ethtool_ops = ops;
9735 : 0 : }
9736 : : EXPORT_SYMBOL_GPL(netdev_set_default_ethtool_ops);
9737 : :
9738 : 0 : void netdev_freemem(struct net_device *dev)
9739 : : {
9740 : 0 : char *addr = (char *)dev - dev->padded;
9741 : :
9742 : 0 : kvfree(addr);
9743 : 0 : }
9744 : :
9745 : : /**
9746 : : * alloc_netdev_mqs - allocate network device
9747 : : * @sizeof_priv: size of private data to allocate space for
9748 : : * @name: device name format string
9749 : : * @name_assign_type: origin of device name
9750 : : * @setup: callback to initialize device
9751 : : * @txqs: the number of TX subqueues to allocate
9752 : : * @rxqs: the number of RX subqueues to allocate
9753 : : *
9754 : : * Allocates a struct net_device with private data area for driver use
9755 : : * and performs basic initialization. Also allocates subqueue structs
9756 : : * for each queue on the device.
9757 : : */
9758 : 12 : struct net_device *alloc_netdev_mqs(int sizeof_priv, const char *name,
9759 : : unsigned char name_assign_type,
9760 : : void (*setup)(struct net_device *),
9761 : : unsigned int txqs, unsigned int rxqs)
9762 : : {
9763 : 12 : struct net_device *dev;
9764 : 12 : unsigned int alloc_size;
9765 : 12 : struct net_device *p;
9766 : :
9767 [ - + ]: 12 : BUG_ON(strlen(name) >= sizeof(dev->name));
9768 : :
9769 [ - + ]: 12 : if (txqs < 1) {
9770 : 0 : pr_err("alloc_netdev: Unable to allocate device with zero queues\n");
9771 : 0 : return NULL;
9772 : : }
9773 : :
9774 [ - + ]: 12 : if (rxqs < 1) {
9775 : 0 : pr_err("alloc_netdev: Unable to allocate device with zero RX queues\n");
9776 : 0 : return NULL;
9777 : : }
9778 : :
9779 : 12 : alloc_size = sizeof(struct net_device);
9780 [ + + ]: 12 : if (sizeof_priv) {
9781 : : /* ensure 32-byte alignment of private area */
9782 : 6 : alloc_size = ALIGN(alloc_size, NETDEV_ALIGN);
9783 : 6 : alloc_size += sizeof_priv;
9784 : : }
9785 : : /* ensure 32-byte alignment of whole construct */
9786 : 12 : alloc_size += NETDEV_ALIGN - 1;
9787 : :
9788 : 12 : p = kvzalloc(alloc_size, GFP_KERNEL | __GFP_RETRY_MAYFAIL);
9789 [ + - ]: 12 : if (!p)
9790 : : return NULL;
9791 : :
9792 : 12 : dev = PTR_ALIGN(p, NETDEV_ALIGN);
9793 : 12 : dev->padded = (char *)dev - (char *)p;
9794 : :
9795 : 12 : dev->pcpu_refcnt = alloc_percpu(int);
9796 [ - + ]: 12 : if (!dev->pcpu_refcnt)
9797 : 0 : goto free_dev;
9798 : :
9799 [ - + ]: 12 : if (dev_addr_init(dev))
9800 : 0 : goto free_pcpu;
9801 : :
9802 : 12 : dev_mc_init(dev);
9803 : 12 : dev_uc_init(dev);
9804 : :
9805 : 12 : dev_net_set(dev, &init_net);
9806 : :
9807 : 12 : netdev_register_lockdep_key(dev);
9808 : :
9809 : 12 : dev->gso_max_size = GSO_MAX_SIZE;
9810 : 12 : dev->gso_max_segs = GSO_MAX_SEGS;
9811 : 12 : dev->upper_level = 1;
9812 : 12 : dev->lower_level = 1;
9813 : :
9814 : 12 : INIT_LIST_HEAD(&dev->napi_list);
9815 : 12 : INIT_LIST_HEAD(&dev->unreg_list);
9816 : 12 : INIT_LIST_HEAD(&dev->close_list);
9817 : 12 : INIT_LIST_HEAD(&dev->link_watch_list);
9818 : 12 : INIT_LIST_HEAD(&dev->adj_list.upper);
9819 : 12 : INIT_LIST_HEAD(&dev->adj_list.lower);
9820 : 12 : INIT_LIST_HEAD(&dev->ptype_all);
9821 : 12 : INIT_LIST_HEAD(&dev->ptype_specific);
9822 : 12 : INIT_LIST_HEAD(&dev->net_notifier_list);
9823 : : #ifdef CONFIG_NET_SCHED
9824 : 12 : hash_init(dev->qdisc_hash);
9825 : : #endif
9826 : 12 : dev->priv_flags = IFF_XMIT_DST_RELEASE | IFF_XMIT_DST_RELEASE_PERM;
9827 : 12 : setup(dev);
9828 : :
9829 [ + + ]: 12 : if (!dev->tx_queue_len) {
9830 : 9 : dev->priv_flags |= IFF_NO_QUEUE;
9831 : 9 : dev->tx_queue_len = DEFAULT_TX_QUEUE_LEN;
9832 : : }
9833 : :
9834 : 12 : dev->num_tx_queues = txqs;
9835 : 12 : dev->real_num_tx_queues = txqs;
9836 [ - + ]: 12 : if (netif_alloc_netdev_queues(dev))
9837 : 0 : goto free_all;
9838 : :
9839 : 12 : dev->num_rx_queues = rxqs;
9840 : 12 : dev->real_num_rx_queues = rxqs;
9841 [ - + ]: 12 : if (netif_alloc_rx_queues(dev))
9842 : 0 : goto free_all;
9843 : :
9844 : 12 : strcpy(dev->name, name);
9845 : 12 : dev->name_assign_type = name_assign_type;
9846 : 12 : dev->group = INIT_NETDEV_GROUP;
9847 [ + + ]: 12 : if (!dev->ethtool_ops)
9848 : 9 : dev->ethtool_ops = &default_ethtool_ops;
9849 : :
9850 : 12 : nf_hook_ingress_init(dev);
9851 : :
9852 : 12 : return dev;
9853 : :
9854 : 0 : free_all:
9855 : 0 : free_netdev(dev);
9856 : 0 : return NULL;
9857 : :
9858 : : free_pcpu:
9859 : 0 : free_percpu(dev->pcpu_refcnt);
9860 : 0 : free_dev:
9861 : 0 : netdev_freemem(dev);
9862 : 0 : return NULL;
9863 : : }
9864 : : EXPORT_SYMBOL(alloc_netdev_mqs);
9865 : :
9866 : : /**
9867 : : * free_netdev - free network device
9868 : : * @dev: device
9869 : : *
9870 : : * This function does the last stage of destroying an allocated device
9871 : : * interface. The reference to the device object is released. If this
9872 : : * is the last reference then it will be freed.Must be called in process
9873 : : * context.
9874 : : */
9875 : 0 : void free_netdev(struct net_device *dev)
9876 : : {
9877 : 0 : struct napi_struct *p, *n;
9878 : :
9879 : 0 : might_sleep();
9880 : 0 : netif_free_tx_queues(dev);
9881 : 0 : netif_free_rx_queues(dev);
9882 : :
9883 : 0 : kfree(rcu_dereference_protected(dev->ingress_queue, 1));
9884 : :
9885 : : /* Flush device addresses */
9886 : 0 : dev_addr_flush(dev);
9887 : :
9888 [ # # ]: 0 : list_for_each_entry_safe(p, n, &dev->napi_list, dev_list)
9889 : 0 : netif_napi_del(p);
9890 : :
9891 : 0 : free_percpu(dev->pcpu_refcnt);
9892 : 0 : dev->pcpu_refcnt = NULL;
9893 : 0 : free_percpu(dev->xdp_bulkq);
9894 : 0 : dev->xdp_bulkq = NULL;
9895 : :
9896 [ # # ]: 0 : netdev_unregister_lockdep_key(dev);
9897 : :
9898 : : /* Compatibility with error handling in drivers */
9899 [ # # ]: 0 : if (dev->reg_state == NETREG_UNINITIALIZED) {
9900 : 0 : netdev_freemem(dev);
9901 : 0 : return;
9902 : : }
9903 : :
9904 [ # # ]: 0 : BUG_ON(dev->reg_state != NETREG_UNREGISTERED);
9905 : 0 : dev->reg_state = NETREG_RELEASED;
9906 : :
9907 : : /* will free via device release */
9908 : 0 : put_device(&dev->dev);
9909 : : }
9910 : : EXPORT_SYMBOL(free_netdev);
9911 : :
9912 : : /**
9913 : : * synchronize_net - Synchronize with packet receive processing
9914 : : *
9915 : : * Wait for packets currently being received to be done.
9916 : : * Does not block later packets from starting.
9917 : : */
9918 : 0 : void synchronize_net(void)
9919 : : {
9920 : 0 : might_sleep();
9921 [ # # ]: 0 : if (rtnl_is_locked())
9922 : 0 : synchronize_rcu_expedited();
9923 : : else
9924 : 0 : synchronize_rcu();
9925 : 0 : }
9926 : : EXPORT_SYMBOL(synchronize_net);
9927 : :
9928 : : /**
9929 : : * unregister_netdevice_queue - remove device from the kernel
9930 : : * @dev: device
9931 : : * @head: list
9932 : : *
9933 : : * This function shuts down a device interface and removes it
9934 : : * from the kernel tables.
9935 : : * If head not NULL, device is queued to be unregistered later.
9936 : : *
9937 : : * Callers must hold the rtnl semaphore. You may want
9938 : : * unregister_netdev() instead of this.
9939 : : */
9940 : :
9941 : 0 : void unregister_netdevice_queue(struct net_device *dev, struct list_head *head)
9942 : : {
9943 [ # # # # ]: 0 : ASSERT_RTNL();
9944 : :
9945 [ # # ]: 0 : if (head) {
9946 : 0 : list_move_tail(&dev->unreg_list, head);
9947 : : } else {
9948 : 0 : rollback_registered(dev);
9949 : : /* Finish processing unregister after unlock */
9950 : 0 : net_set_todo(dev);
9951 : : }
9952 : 0 : }
9953 : : EXPORT_SYMBOL(unregister_netdevice_queue);
9954 : :
9955 : : /**
9956 : : * unregister_netdevice_many - unregister many devices
9957 : : * @head: list of devices
9958 : : *
9959 : : * Note: As most callers use a stack allocated list_head,
9960 : : * we force a list_del() to make sure stack wont be corrupted later.
9961 : : */
9962 : 0 : void unregister_netdevice_many(struct list_head *head)
9963 : : {
9964 : 0 : struct net_device *dev;
9965 : :
9966 [ # # ]: 0 : if (!list_empty(head)) {
9967 : 0 : rollback_registered_many(head);
9968 [ # # ]: 0 : list_for_each_entry(dev, head, unreg_list)
9969 : 0 : net_set_todo(dev);
9970 : 0 : list_del(head);
9971 : : }
9972 : 0 : }
9973 : : EXPORT_SYMBOL(unregister_netdevice_many);
9974 : :
9975 : : /**
9976 : : * unregister_netdev - remove device from the kernel
9977 : : * @dev: device
9978 : : *
9979 : : * This function shuts down a device interface and removes it
9980 : : * from the kernel tables.
9981 : : *
9982 : : * This is just a wrapper for unregister_netdevice that takes
9983 : : * the rtnl semaphore. In general you want to use this and not
9984 : : * unregister_netdevice.
9985 : : */
9986 : 0 : void unregister_netdev(struct net_device *dev)
9987 : : {
9988 : 0 : rtnl_lock();
9989 : 0 : unregister_netdevice(dev);
9990 : 0 : rtnl_unlock();
9991 : 0 : }
9992 : : EXPORT_SYMBOL(unregister_netdev);
9993 : :
9994 : : /**
9995 : : * dev_change_net_namespace - move device to different nethost namespace
9996 : : * @dev: device
9997 : : * @net: network namespace
9998 : : * @pat: If not NULL name pattern to try if the current device name
9999 : : * is already taken in the destination network namespace.
10000 : : *
10001 : : * This function shuts down a device interface and moves it
10002 : : * to a new network namespace. On success 0 is returned, on
10003 : : * a failure a netagive errno code is returned.
10004 : : *
10005 : : * Callers must hold the rtnl semaphore.
10006 : : */
10007 : :
10008 : 0 : int dev_change_net_namespace(struct net_device *dev, struct net *net, const char *pat)
10009 : : {
10010 : 0 : int err, new_nsid, new_ifindex;
10011 : :
10012 [ # # # # ]: 0 : ASSERT_RTNL();
10013 : :
10014 : : /* Don't allow namespace local devices to be moved. */
10015 : 0 : err = -EINVAL;
10016 [ # # ]: 0 : if (dev->features & NETIF_F_NETNS_LOCAL)
10017 : 0 : goto out;
10018 : :
10019 : : /* Ensure the device has been registrered */
10020 [ # # ]: 0 : if (dev->reg_state != NETREG_REGISTERED)
10021 : 0 : goto out;
10022 : :
10023 : : /* Get out if there is nothing todo */
10024 : 0 : err = 0;
10025 [ # # ]: 0 : if (net_eq(dev_net(dev), net))
10026 : 0 : goto out;
10027 : :
10028 : : /* Pick the destination device name, and ensure
10029 : : * we can use it in the destination network namespace.
10030 : : */
10031 : 0 : err = -EEXIST;
10032 [ # # ]: 0 : if (__dev_get_by_name(net, dev->name)) {
10033 : : /* We get here if we can't use the current device name */
10034 [ # # ]: 0 : if (!pat)
10035 : 0 : goto out;
10036 : 0 : err = dev_get_valid_name(net, dev, pat);
10037 [ # # ]: 0 : if (err < 0)
10038 : 0 : goto out;
10039 : : }
10040 : :
10041 : : /*
10042 : : * And now a mini version of register_netdevice unregister_netdevice.
10043 : : */
10044 : :
10045 : : /* If device is running close it first. */
10046 : 0 : dev_close(dev);
10047 : :
10048 : : /* And unlink it from device chain */
10049 : 0 : unlist_netdevice(dev);
10050 : :
10051 : 0 : synchronize_net();
10052 : :
10053 : : /* Shutdown queueing discipline. */
10054 : 0 : dev_shutdown(dev);
10055 : :
10056 : : /* Notify protocols, that we are about to destroy
10057 : : * this device. They should clean all the things.
10058 : : *
10059 : : * Note that dev->reg_state stays at NETREG_REGISTERED.
10060 : : * This is wanted because this way 8021q and macvlan know
10061 : : * the device is just moving and can keep their slaves up.
10062 : : */
10063 : 0 : call_netdevice_notifiers(NETDEV_UNREGISTER, dev);
10064 : 0 : rcu_barrier();
10065 : :
10066 : 0 : new_nsid = peernet2id_alloc(dev_net(dev), net, GFP_KERNEL);
10067 : : /* If there is an ifindex conflict assign a new one */
10068 [ # # # # ]: 0 : if (__dev_get_by_index(net, dev->ifindex))
10069 : 0 : new_ifindex = dev_new_index(net);
10070 : : else
10071 : : new_ifindex = dev->ifindex;
10072 : :
10073 : 0 : rtmsg_ifinfo_newnet(RTM_DELLINK, dev, ~0U, GFP_KERNEL, &new_nsid,
10074 : : new_ifindex);
10075 : :
10076 : : /*
10077 : : * Flush the unicast and multicast chains
10078 : : */
10079 : 0 : dev_uc_flush(dev);
10080 : 0 : dev_mc_flush(dev);
10081 : :
10082 : : /* Send a netdev-removed uevent to the old namespace */
10083 : 0 : kobject_uevent(&dev->dev.kobj, KOBJ_REMOVE);
10084 : 0 : netdev_adjacent_del_links(dev);
10085 : :
10086 : : /* Move per-net netdevice notifiers that are following the netdevice */
10087 : 0 : move_netdevice_notifiers_dev_net(dev, net);
10088 : :
10089 : : /* Actually switch the network namespace */
10090 : 0 : dev_net_set(dev, net);
10091 : 0 : dev->ifindex = new_ifindex;
10092 : :
10093 : : /* Send a netdev-add uevent to the new namespace */
10094 : 0 : kobject_uevent(&dev->dev.kobj, KOBJ_ADD);
10095 : 0 : netdev_adjacent_add_links(dev);
10096 : :
10097 : : /* Fixup kobjects */
10098 : 0 : err = device_rename(&dev->dev, dev->name);
10099 [ # # ]: 0 : WARN_ON(err);
10100 : :
10101 : : /* Add the device back in the hashes */
10102 : 0 : list_netdevice(dev);
10103 : :
10104 : : /* Notify protocols, that a new device appeared. */
10105 : 0 : call_netdevice_notifiers(NETDEV_REGISTER, dev);
10106 : :
10107 : : /*
10108 : : * Prevent userspace races by waiting until the network
10109 : : * device is fully setup before sending notifications.
10110 : : */
10111 : 0 : rtmsg_ifinfo(RTM_NEWLINK, dev, ~0U, GFP_KERNEL);
10112 : :
10113 : 0 : synchronize_net();
10114 : 0 : err = 0;
10115 : 0 : out:
10116 : 0 : return err;
10117 : : }
10118 : : EXPORT_SYMBOL_GPL(dev_change_net_namespace);
10119 : :
10120 : 0 : static int dev_cpu_dead(unsigned int oldcpu)
10121 : : {
10122 : 0 : struct sk_buff **list_skb;
10123 : 0 : struct sk_buff *skb;
10124 : 0 : unsigned int cpu;
10125 : 0 : struct softnet_data *sd, *oldsd, *remsd = NULL;
10126 : :
10127 : 0 : local_irq_disable();
10128 : 0 : cpu = smp_processor_id();
10129 : 0 : sd = &per_cpu(softnet_data, cpu);
10130 : 0 : oldsd = &per_cpu(softnet_data, oldcpu);
10131 : :
10132 : : /* Find end of our completion_queue. */
10133 : 0 : list_skb = &sd->completion_queue;
10134 [ # # ]: 0 : while (*list_skb)
10135 : 0 : list_skb = &(*list_skb)->next;
10136 : : /* Append completion queue from offline CPU. */
10137 : 0 : *list_skb = oldsd->completion_queue;
10138 : 0 : oldsd->completion_queue = NULL;
10139 : :
10140 : : /* Append output queue from offline CPU. */
10141 [ # # ]: 0 : if (oldsd->output_queue) {
10142 : 0 : *sd->output_queue_tailp = oldsd->output_queue;
10143 : 0 : sd->output_queue_tailp = oldsd->output_queue_tailp;
10144 : 0 : oldsd->output_queue = NULL;
10145 : 0 : oldsd->output_queue_tailp = &oldsd->output_queue;
10146 : : }
10147 : : /* Append NAPI poll list from offline CPU, with one exception :
10148 : : * process_backlog() must be called by cpu owning percpu backlog.
10149 : : * We properly handle process_queue & input_pkt_queue later.
10150 : : */
10151 [ # # ]: 0 : while (!list_empty(&oldsd->poll_list)) {
10152 : 0 : struct napi_struct *napi = list_first_entry(&oldsd->poll_list,
10153 : : struct napi_struct,
10154 : : poll_list);
10155 : :
10156 [ # # ]: 0 : list_del_init(&napi->poll_list);
10157 [ # # ]: 0 : if (napi->poll == process_backlog)
10158 : 0 : napi->state = 0;
10159 : : else
10160 : 0 : ____napi_schedule(sd, napi);
10161 : : }
10162 : :
10163 : 0 : raise_softirq_irqoff(NET_TX_SOFTIRQ);
10164 : 0 : local_irq_enable();
10165 : :
10166 : : #ifdef CONFIG_RPS
10167 : 0 : remsd = oldsd->rps_ipi_list;
10168 : 0 : oldsd->rps_ipi_list = NULL;
10169 : : #endif
10170 : : /* send out pending IPI's on offline CPU */
10171 : 0 : net_rps_send_ipi(remsd);
10172 : :
10173 : : /* Process offline CPU's input_pkt_queue */
10174 [ # # # # ]: 0 : while ((skb = __skb_dequeue(&oldsd->process_queue))) {
10175 : 0 : netif_rx_ni(skb);
10176 : 0 : input_queue_head_incr(oldsd);
10177 : : }
10178 [ # # ]: 0 : while ((skb = skb_dequeue(&oldsd->input_pkt_queue))) {
10179 : 0 : netif_rx_ni(skb);
10180 : 0 : input_queue_head_incr(oldsd);
10181 : : }
10182 : :
10183 : 0 : return 0;
10184 : : }
10185 : :
10186 : : /**
10187 : : * netdev_increment_features - increment feature set by one
10188 : : * @all: current feature set
10189 : : * @one: new feature set
10190 : : * @mask: mask feature set
10191 : : *
10192 : : * Computes a new feature set after adding a device with feature set
10193 : : * @one to the master device with current feature set @all. Will not
10194 : : * enable anything that is off in @mask. Returns the new feature set.
10195 : : */
10196 : 0 : netdev_features_t netdev_increment_features(netdev_features_t all,
10197 : : netdev_features_t one, netdev_features_t mask)
10198 : : {
10199 [ # # ]: 0 : if (mask & NETIF_F_HW_CSUM)
10200 : 0 : mask |= NETIF_F_CSUM_MASK;
10201 : 0 : mask |= NETIF_F_VLAN_CHALLENGED;
10202 : :
10203 : 0 : all |= one & (NETIF_F_ONE_FOR_ALL | NETIF_F_CSUM_MASK) & mask;
10204 : 0 : all &= one | ~NETIF_F_ALL_FOR_ALL;
10205 : :
10206 : : /* If one device supports hw checksumming, set for all. */
10207 [ # # ]: 0 : if (all & NETIF_F_HW_CSUM)
10208 : 0 : all &= ~(NETIF_F_CSUM_MASK & ~NETIF_F_HW_CSUM);
10209 : :
10210 : 0 : return all;
10211 : : }
10212 : : EXPORT_SYMBOL(netdev_increment_features);
10213 : :
10214 : 6 : static struct hlist_head * __net_init netdev_create_hash(void)
10215 : : {
10216 : 6 : int i;
10217 : 6 : struct hlist_head *hash;
10218 : :
10219 : 6 : hash = kmalloc_array(NETDEV_HASHENTRIES, sizeof(*hash), GFP_KERNEL);
10220 [ + - ]: 6 : if (hash != NULL)
10221 [ + + ]: 1542 : for (i = 0; i < NETDEV_HASHENTRIES; i++)
10222 : 1536 : INIT_HLIST_HEAD(&hash[i]);
10223 : :
10224 : 6 : return hash;
10225 : : }
10226 : :
10227 : : /* Initialize per network namespace state */
10228 : 3 : static int __net_init netdev_init(struct net *net)
10229 : : {
10230 : 3 : BUILD_BUG_ON(GRO_HASH_BUCKETS >
10231 : : 8 * sizeof_field(struct napi_struct, gro_bitmask));
10232 : :
10233 [ - + ]: 3 : if (net != &init_net)
10234 : 0 : INIT_LIST_HEAD(&net->dev_base_head);
10235 : :
10236 : 3 : net->dev_name_head = netdev_create_hash();
10237 [ - + ]: 3 : if (net->dev_name_head == NULL)
10238 : 0 : goto err_name;
10239 : :
10240 : 3 : net->dev_index_head = netdev_create_hash();
10241 [ - + ]: 3 : if (net->dev_index_head == NULL)
10242 : 0 : goto err_idx;
10243 : :
10244 : 3 : RAW_INIT_NOTIFIER_HEAD(&net->netdev_chain);
10245 : :
10246 : 3 : return 0;
10247 : :
10248 : : err_idx:
10249 : 0 : kfree(net->dev_name_head);
10250 : : err_name:
10251 : : return -ENOMEM;
10252 : : }
10253 : :
10254 : : /**
10255 : : * netdev_drivername - network driver for the device
10256 : : * @dev: network device
10257 : : *
10258 : : * Determine network driver for device.
10259 : : */
10260 : 0 : const char *netdev_drivername(const struct net_device *dev)
10261 : : {
10262 : 0 : const struct device_driver *driver;
10263 : 0 : const struct device *parent;
10264 : 0 : const char *empty = "";
10265 : :
10266 : 0 : parent = dev->dev.parent;
10267 [ # # ]: 0 : if (!parent)
10268 : : return empty;
10269 : :
10270 : 0 : driver = parent->driver;
10271 [ # # # # ]: 0 : if (driver && driver->name)
10272 : 0 : return driver->name;
10273 : : return empty;
10274 : : }
10275 : :
10276 : 6 : static void __netdev_printk(const char *level, const struct net_device *dev,
10277 : : struct va_format *vaf)
10278 : : {
10279 [ + - + - ]: 6 : if (dev && dev->dev.parent) {
10280 : 12 : dev_printk_emit(level[1] - '0',
10281 : 6 : dev->dev.parent,
10282 : : "%s %s %s%s: %pV",
10283 : : dev_driver_string(dev->dev.parent),
10284 [ + - ]: 6 : dev_name(dev->dev.parent),
10285 : : netdev_name(dev), netdev_reg_state(dev),
10286 : : vaf);
10287 [ # # ]: 0 : } else if (dev) {
10288 : 0 : printk("%s%s%s: %pV",
10289 : : level, netdev_name(dev), netdev_reg_state(dev), vaf);
10290 : : } else {
10291 : 0 : printk("%s(NULL net_device): %pV", level, vaf);
10292 : : }
10293 : 6 : }
10294 : :
10295 : 0 : void netdev_printk(const char *level, const struct net_device *dev,
10296 : : const char *format, ...)
10297 : : {
10298 : 0 : struct va_format vaf;
10299 : 0 : va_list args;
10300 : :
10301 : 0 : va_start(args, format);
10302 : :
10303 : 0 : vaf.fmt = format;
10304 : 0 : vaf.va = &args;
10305 : :
10306 : 0 : __netdev_printk(level, dev, &vaf);
10307 : :
10308 : 0 : va_end(args);
10309 : 0 : }
10310 : : EXPORT_SYMBOL(netdev_printk);
10311 : :
10312 : : #define define_netdev_printk_level(func, level) \
10313 : : void func(const struct net_device *dev, const char *fmt, ...) \
10314 : : { \
10315 : : struct va_format vaf; \
10316 : : va_list args; \
10317 : : \
10318 : : va_start(args, fmt); \
10319 : : \
10320 : : vaf.fmt = fmt; \
10321 : : vaf.va = &args; \
10322 : : \
10323 : : __netdev_printk(level, dev, &vaf); \
10324 : : \
10325 : : va_end(args); \
10326 : : } \
10327 : : EXPORT_SYMBOL(func);
10328 : :
10329 : 0 : define_netdev_printk_level(netdev_emerg, KERN_EMERG);
10330 : 0 : define_netdev_printk_level(netdev_alert, KERN_ALERT);
10331 : 0 : define_netdev_printk_level(netdev_crit, KERN_CRIT);
10332 : 0 : define_netdev_printk_level(netdev_err, KERN_ERR);
10333 : 0 : define_netdev_printk_level(netdev_warn, KERN_WARNING);
10334 : 0 : define_netdev_printk_level(netdev_notice, KERN_NOTICE);
10335 : 6 : define_netdev_printk_level(netdev_info, KERN_INFO);
10336 : :
10337 : 0 : static void __net_exit netdev_exit(struct net *net)
10338 : : {
10339 : 0 : kfree(net->dev_name_head);
10340 : 0 : kfree(net->dev_index_head);
10341 [ # # ]: 0 : if (net != &init_net)
10342 [ # # ]: 0 : WARN_ON_ONCE(!list_empty(&net->dev_base_head));
10343 : 0 : }
10344 : :
10345 : : static struct pernet_operations __net_initdata netdev_net_ops = {
10346 : : .init = netdev_init,
10347 : : .exit = netdev_exit,
10348 : : };
10349 : :
10350 : 0 : static void __net_exit default_device_exit(struct net *net)
10351 : : {
10352 : 0 : struct net_device *dev, *aux;
10353 : : /*
10354 : : * Push all migratable network devices back to the
10355 : : * initial network namespace
10356 : : */
10357 : 0 : rtnl_lock();
10358 [ # # ]: 0 : for_each_netdev_safe(net, dev, aux) {
10359 : 0 : int err;
10360 : 0 : char fb_name[IFNAMSIZ];
10361 : :
10362 : : /* Ignore unmoveable devices (i.e. loopback) */
10363 [ # # ]: 0 : if (dev->features & NETIF_F_NETNS_LOCAL)
10364 : 0 : continue;
10365 : :
10366 : : /* Leave virtual devices for the generic cleanup */
10367 [ # # ]: 0 : if (dev->rtnl_link_ops)
10368 : 0 : continue;
10369 : :
10370 : : /* Push remaining network devices to init_net */
10371 : 0 : snprintf(fb_name, IFNAMSIZ, "dev%d", dev->ifindex);
10372 [ # # ]: 0 : if (__dev_get_by_name(&init_net, fb_name))
10373 : 0 : snprintf(fb_name, IFNAMSIZ, "dev%%d");
10374 : 0 : err = dev_change_net_namespace(dev, &init_net, fb_name);
10375 [ # # ]: 0 : if (err) {
10376 : 0 : pr_emerg("%s: failed to move %s to init_net: %d\n",
10377 : : __func__, dev->name, err);
10378 : 0 : BUG();
10379 : : }
10380 : : }
10381 : 0 : rtnl_unlock();
10382 : 0 : }
10383 : :
10384 : 0 : static void __net_exit rtnl_lock_unregistering(struct list_head *net_list)
10385 : : {
10386 : : /* Return with the rtnl_lock held when there are no network
10387 : : * devices unregistering in any network namespace in net_list.
10388 : : */
10389 : 0 : struct net *net;
10390 : 0 : bool unregistering;
10391 : 0 : DEFINE_WAIT_FUNC(wait, woken_wake_function);
10392 : :
10393 : 0 : add_wait_queue(&netdev_unregistering_wq, &wait);
10394 : 0 : for (;;) {
10395 : 0 : unregistering = false;
10396 : 0 : rtnl_lock();
10397 [ # # ]: 0 : list_for_each_entry(net, net_list, exit_list) {
10398 [ # # ]: 0 : if (net->dev_unreg_count > 0) {
10399 : : unregistering = true;
10400 : : break;
10401 : : }
10402 : : }
10403 [ # # ]: 0 : if (!unregistering)
10404 : : break;
10405 : 0 : __rtnl_unlock();
10406 : :
10407 : 0 : wait_woken(&wait, TASK_UNINTERRUPTIBLE, MAX_SCHEDULE_TIMEOUT);
10408 : : }
10409 : 0 : remove_wait_queue(&netdev_unregistering_wq, &wait);
10410 : 0 : }
10411 : :
10412 : 0 : static void __net_exit default_device_exit_batch(struct list_head *net_list)
10413 : : {
10414 : : /* At exit all network devices most be removed from a network
10415 : : * namespace. Do this in the reverse order of registration.
10416 : : * Do this across as many network namespaces as possible to
10417 : : * improve batching efficiency.
10418 : : */
10419 : 0 : struct net_device *dev;
10420 : 0 : struct net *net;
10421 : 0 : LIST_HEAD(dev_kill_list);
10422 : :
10423 : : /* To prevent network device cleanup code from dereferencing
10424 : : * loopback devices or network devices that have been freed
10425 : : * wait here for all pending unregistrations to complete,
10426 : : * before unregistring the loopback device and allowing the
10427 : : * network namespace be freed.
10428 : : *
10429 : : * The netdev todo list containing all network devices
10430 : : * unregistrations that happen in default_device_exit_batch
10431 : : * will run in the rtnl_unlock() at the end of
10432 : : * default_device_exit_batch.
10433 : : */
10434 : 0 : rtnl_lock_unregistering(net_list);
10435 [ # # ]: 0 : list_for_each_entry(net, net_list, exit_list) {
10436 [ # # ]: 0 : for_each_netdev_reverse(net, dev) {
10437 [ # # # # ]: 0 : if (dev->rtnl_link_ops && dev->rtnl_link_ops->dellink)
10438 : 0 : dev->rtnl_link_ops->dellink(dev, &dev_kill_list);
10439 : : else
10440 : 0 : unregister_netdevice_queue(dev, &dev_kill_list);
10441 : : }
10442 : : }
10443 : 0 : unregister_netdevice_many(&dev_kill_list);
10444 : 0 : rtnl_unlock();
10445 : 0 : }
10446 : :
10447 : : static struct pernet_operations __net_initdata default_device_ops = {
10448 : : .exit = default_device_exit,
10449 : : .exit_batch = default_device_exit_batch,
10450 : : };
10451 : :
10452 : : /*
10453 : : * Initialize the DEV module. At boot time this walks the device list and
10454 : : * unhooks any devices that fail to initialise (normally hardware not
10455 : : * present) and leaves us with a valid list of present and active devices.
10456 : : *
10457 : : */
10458 : :
10459 : : /*
10460 : : * This is called single threaded during boot, so no need
10461 : : * to take the rtnl semaphore.
10462 : : */
10463 : 3 : static int __init net_dev_init(void)
10464 : : {
10465 : 3 : int i, rc = -ENOMEM;
10466 : :
10467 [ - + ]: 3 : BUG_ON(!dev_boot_phase);
10468 : :
10469 [ - + ]: 3 : if (dev_proc_init())
10470 : 0 : goto out;
10471 : :
10472 [ - + ]: 3 : if (netdev_kobject_init())
10473 : 0 : goto out;
10474 : :
10475 : 3 : INIT_LIST_HEAD(&ptype_all);
10476 [ + + ]: 51 : for (i = 0; i < PTYPE_HASH_SIZE; i++)
10477 : 48 : INIT_LIST_HEAD(&ptype_base[i]);
10478 : :
10479 : 3 : INIT_LIST_HEAD(&offload_base);
10480 : :
10481 [ - + ]: 3 : if (register_pernet_subsys(&netdev_net_ops))
10482 : 0 : goto out;
10483 : :
10484 : : /*
10485 : : * Initialise the packet receive queues.
10486 : : */
10487 : :
10488 [ + + ]: 6 : for_each_possible_cpu(i) {
10489 : 3 : struct work_struct *flush = per_cpu_ptr(&flush_works, i);
10490 : 3 : struct softnet_data *sd = &per_cpu(softnet_data, i);
10491 : :
10492 : 3 : INIT_WORK(flush, flush_backlog);
10493 : :
10494 : 3 : skb_queue_head_init(&sd->input_pkt_queue);
10495 : 3 : skb_queue_head_init(&sd->process_queue);
10496 : : #ifdef CONFIG_XFRM_OFFLOAD
10497 : : skb_queue_head_init(&sd->xfrm_backlog);
10498 : : #endif
10499 : 3 : INIT_LIST_HEAD(&sd->poll_list);
10500 : 3 : sd->output_queue_tailp = &sd->output_queue;
10501 : : #ifdef CONFIG_RPS
10502 : 3 : sd->csd.func = rps_trigger_softirq;
10503 : 3 : sd->csd.info = sd;
10504 : 3 : sd->cpu = i;
10505 : : #endif
10506 : :
10507 : 3 : init_gro_hash(&sd->backlog);
10508 : 3 : sd->backlog.poll = process_backlog;
10509 : 3 : sd->backlog.weight = weight_p;
10510 : : }
10511 : :
10512 : 3 : dev_boot_phase = 0;
10513 : :
10514 : : /* The loopback device is special if any other network devices
10515 : : * is present in a network namespace the loopback device must
10516 : : * be present. Since we now dynamically allocate and free the
10517 : : * loopback device ensure this invariant is maintained by
10518 : : * keeping the loopback device as the first device on the
10519 : : * list of network devices. Ensuring the loopback devices
10520 : : * is the first device that appears and the last network device
10521 : : * that disappears.
10522 : : */
10523 [ - + ]: 3 : if (register_pernet_device(&loopback_net_ops))
10524 : 0 : goto out;
10525 : :
10526 [ - + ]: 3 : if (register_pernet_device(&default_device_ops))
10527 : 0 : goto out;
10528 : :
10529 : 3 : open_softirq(NET_TX_SOFTIRQ, net_tx_action);
10530 : 3 : open_softirq(NET_RX_SOFTIRQ, net_rx_action);
10531 : :
10532 : 3 : rc = cpuhp_setup_state_nocalls(CPUHP_NET_DEV_DEAD, "net/dev:dead",
10533 : : NULL, dev_cpu_dead);
10534 [ - + ]: 3 : WARN_ON(rc < 0);
10535 : : rc = 0;
10536 : 3 : out:
10537 : 3 : return rc;
10538 : : }
10539 : :
10540 : : subsys_initcall(net_dev_init);
|
