sk_buff: drop all skb extensions on free and skb scrubbing
[sfrench/cifs-2.6.git] / net / core / dev.c
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 static inline void dev_base_seq_inc(struct net *net)
200 {
201         while (++net->dev_base_seq == 0)
202                 ;
203 }
204
205 static inline struct hlist_head *dev_name_hash(struct net *net, const char *name)
206 {
207         unsigned int hash = full_name_hash(net, name, strnlen(name, IFNAMSIZ));
208
209         return &net->dev_name_head[hash_32(hash, NETDEV_HASHBITS)];
210 }
211
212 static inline struct hlist_head *dev_index_hash(struct net *net, int ifindex)
213 {
214         return &net->dev_index_head[ifindex & (NETDEV_HASHENTRIES - 1)];
215 }
216
217 static inline void rps_lock(struct softnet_data *sd)
218 {
219 #ifdef CONFIG_RPS
220         spin_lock(&sd->input_pkt_queue.lock);
221 #endif
222 }
223
224 static inline void rps_unlock(struct softnet_data *sd)
225 {
226 #ifdef CONFIG_RPS
227         spin_unlock(&sd->input_pkt_queue.lock);
228 #endif
229 }
230
231 /* Device list insertion */
232 static void list_netdevice(struct net_device *dev)
233 {
234         struct net *net = dev_net(dev);
235
236         ASSERT_RTNL();
237
238         write_lock_bh(&dev_base_lock);
239         list_add_tail_rcu(&dev->dev_list, &net->dev_base_head);
240         hlist_add_head_rcu(&dev->name_hlist, dev_name_hash(net, dev->name));
241         hlist_add_head_rcu(&dev->index_hlist,
242                            dev_index_hash(net, dev->ifindex));
243         write_unlock_bh(&dev_base_lock);
244
245         dev_base_seq_inc(net);
246 }
247
248 /* Device list removal
249  * caller must respect a RCU grace period before freeing/reusing dev
250  */
251 static void unlist_netdevice(struct net_device *dev)
252 {
253         ASSERT_RTNL();
254
255         /* Unlink dev from the device chain */
256         write_lock_bh(&dev_base_lock);
257         list_del_rcu(&dev->dev_list);
258         hlist_del_rcu(&dev->name_hlist);
259         hlist_del_rcu(&dev->index_hlist);
260         write_unlock_bh(&dev_base_lock);
261
262         dev_base_seq_inc(dev_net(dev));
263 }
264
265 /*
266  *      Our notifier list
267  */
268
269 static RAW_NOTIFIER_HEAD(netdev_chain);
270
271 /*
272  *      Device drivers call our routines to queue packets here. We empty the
273  *      queue in the local softnet handler.
274  */
275
276 DEFINE_PER_CPU_ALIGNED(struct softnet_data, softnet_data);
277 EXPORT_PER_CPU_SYMBOL(softnet_data);
278
279 #ifdef CONFIG_LOCKDEP
280 /*
281  * register_netdevice() inits txq->_xmit_lock and sets lockdep class
282  * according to dev->type
283  */
284 static const unsigned short netdev_lock_type[] = {
285          ARPHRD_NETROM, ARPHRD_ETHER, ARPHRD_EETHER, ARPHRD_AX25,
286          ARPHRD_PRONET, ARPHRD_CHAOS, ARPHRD_IEEE802, ARPHRD_ARCNET,
287          ARPHRD_APPLETLK, ARPHRD_DLCI, ARPHRD_ATM, ARPHRD_METRICOM,
288          ARPHRD_IEEE1394, ARPHRD_EUI64, ARPHRD_INFINIBAND, ARPHRD_SLIP,
289          ARPHRD_CSLIP, ARPHRD_SLIP6, ARPHRD_CSLIP6, ARPHRD_RSRVD,
290          ARPHRD_ADAPT, ARPHRD_ROSE, ARPHRD_X25, ARPHRD_HWX25,
291          ARPHRD_PPP, ARPHRD_CISCO, ARPHRD_LAPB, ARPHRD_DDCMP,
292          ARPHRD_RAWHDLC, ARPHRD_TUNNEL, ARPHRD_TUNNEL6, ARPHRD_FRAD,
293          ARPHRD_SKIP, ARPHRD_LOOPBACK, ARPHRD_LOCALTLK, ARPHRD_FDDI,
294          ARPHRD_BIF, ARPHRD_SIT, ARPHRD_IPDDP, ARPHRD_IPGRE,
295          ARPHRD_PIMREG, ARPHRD_HIPPI, ARPHRD_ASH, ARPHRD_ECONET,
296          ARPHRD_IRDA, ARPHRD_FCPP, ARPHRD_FCAL, ARPHRD_FCPL,
297          ARPHRD_FCFABRIC, ARPHRD_IEEE80211, ARPHRD_IEEE80211_PRISM,
298          ARPHRD_IEEE80211_RADIOTAP, ARPHRD_PHONET, ARPHRD_PHONET_PIPE,
299          ARPHRD_IEEE802154, ARPHRD_VOID, ARPHRD_NONE};
300
301 static const char *const netdev_lock_name[] = {
302         "_xmit_NETROM", "_xmit_ETHER", "_xmit_EETHER", "_xmit_AX25",
303         "_xmit_PRONET", "_xmit_CHAOS", "_xmit_IEEE802", "_xmit_ARCNET",
304         "_xmit_APPLETLK", "_xmit_DLCI", "_xmit_ATM", "_xmit_METRICOM",
305         "_xmit_IEEE1394", "_xmit_EUI64", "_xmit_INFINIBAND", "_xmit_SLIP",
306         "_xmit_CSLIP", "_xmit_SLIP6", "_xmit_CSLIP6", "_xmit_RSRVD",
307         "_xmit_ADAPT", "_xmit_ROSE", "_xmit_X25", "_xmit_HWX25",
308         "_xmit_PPP", "_xmit_CISCO", "_xmit_LAPB", "_xmit_DDCMP",
309         "_xmit_RAWHDLC", "_xmit_TUNNEL", "_xmit_TUNNEL6", "_xmit_FRAD",
310         "_xmit_SKIP", "_xmit_LOOPBACK", "_xmit_LOCALTLK", "_xmit_FDDI",
311         "_xmit_BIF", "_xmit_SIT", "_xmit_IPDDP", "_xmit_IPGRE",
312         "_xmit_PIMREG", "_xmit_HIPPI", "_xmit_ASH", "_xmit_ECONET",
313         "_xmit_IRDA", "_xmit_FCPP", "_xmit_FCAL", "_xmit_FCPL",
314         "_xmit_FCFABRIC", "_xmit_IEEE80211", "_xmit_IEEE80211_PRISM",
315         "_xmit_IEEE80211_RADIOTAP", "_xmit_PHONET", "_xmit_PHONET_PIPE",
316         "_xmit_IEEE802154", "_xmit_VOID", "_xmit_NONE"};
317
318 static struct lock_class_key netdev_xmit_lock_key[ARRAY_SIZE(netdev_lock_type)];
319 static struct lock_class_key netdev_addr_lock_key[ARRAY_SIZE(netdev_lock_type)];
320
321 static inline unsigned short netdev_lock_pos(unsigned short dev_type)
322 {
323         int i;
324
325         for (i = 0; i < ARRAY_SIZE(netdev_lock_type); i++)
326                 if (netdev_lock_type[i] == dev_type)
327                         return i;
328         /* the last key is used by default */
329         return ARRAY_SIZE(netdev_lock_type) - 1;
330 }
331
332 static inline void netdev_set_xmit_lockdep_class(spinlock_t *lock,
333                                                  unsigned short dev_type)
334 {
335         int i;
336
337         i = netdev_lock_pos(dev_type);
338         lockdep_set_class_and_name(lock, &netdev_xmit_lock_key[i],
339                                    netdev_lock_name[i]);
340 }
341
342 static inline void netdev_set_addr_lockdep_class(struct net_device *dev)
343 {
344         int i;
345
346         i = netdev_lock_pos(dev->type);
347         lockdep_set_class_and_name(&dev->addr_list_lock,
348                                    &netdev_addr_lock_key[i],
349                                    netdev_lock_name[i]);
350 }
351 #else
352 static inline void netdev_set_xmit_lockdep_class(spinlock_t *lock,
353                                                  unsigned short dev_type)
354 {
355 }
356 static inline void netdev_set_addr_lockdep_class(struct net_device *dev)
357 {
358 }
359 #endif
360
361 /*******************************************************************************
362  *
363  *              Protocol management and registration routines
364  *
365  *******************************************************************************/
366
367
368 /*
369  *      Add a protocol ID to the list. Now that the input handler is
370  *      smarter we can dispense with all the messy stuff that used to be
371  *      here.
372  *
373  *      BEWARE!!! Protocol handlers, mangling input packets,
374  *      MUST BE last in hash buckets and checking protocol handlers
375  *      MUST start from promiscuous ptype_all chain in net_bh.
376  *      It is true now, do not change it.
377  *      Explanation follows: if protocol handler, mangling packet, will
378  *      be the first on list, it is not able to sense, that packet
379  *      is cloned and should be copied-on-write, so that it will
380  *      change it and subsequent readers will get broken packet.
381  *                                                      --ANK (980803)
382  */
383
384 static inline struct list_head *ptype_head(const struct packet_type *pt)
385 {
386         if (pt->type == htons(ETH_P_ALL))
387                 return pt->dev ? &pt->dev->ptype_all : &ptype_all;
388         else
389                 return pt->dev ? &pt->dev->ptype_specific :
390                                  &ptype_base[ntohs(pt->type) & PTYPE_HASH_MASK];
391 }
392
393 /**
394  *      dev_add_pack - add packet handler
395  *      @pt: packet type declaration
396  *
397  *      Add a protocol handler to the networking stack. The passed &packet_type
398  *      is linked into kernel lists and may not be freed until it has been
399  *      removed from the kernel lists.
400  *
401  *      This call does not sleep therefore it can not
402  *      guarantee all CPU's that are in middle of receiving packets
403  *      will see the new packet type (until the next received packet).
404  */
405
406 void dev_add_pack(struct packet_type *pt)
407 {
408         struct list_head *head = ptype_head(pt);
409
410         spin_lock(&ptype_lock);
411         list_add_rcu(&pt->list, head);
412         spin_unlock(&ptype_lock);
413 }
414 EXPORT_SYMBOL(dev_add_pack);
415
416 /**
417  *      __dev_remove_pack        - remove packet handler
418  *      @pt: packet type declaration
419  *
420  *      Remove a protocol handler that was previously added to the kernel
421  *      protocol handlers by dev_add_pack(). The passed &packet_type is removed
422  *      from the kernel lists and can be freed or reused once this function
423  *      returns.
424  *
425  *      The packet type might still be in use by receivers
426  *      and must not be freed until after all the CPU's have gone
427  *      through a quiescent state.
428  */
429 void __dev_remove_pack(struct packet_type *pt)
430 {
431         struct list_head *head = ptype_head(pt);
432         struct packet_type *pt1;
433
434         spin_lock(&ptype_lock);
435
436         list_for_each_entry(pt1, head, list) {
437                 if (pt == pt1) {
438                         list_del_rcu(&pt->list);
439                         goto out;
440                 }
441         }
442
443         pr_warn("dev_remove_pack: %p not found\n", pt);
444 out:
445         spin_unlock(&ptype_lock);
446 }
447 EXPORT_SYMBOL(__dev_remove_pack);
448
449 /**
450  *      dev_remove_pack  - remove packet handler
451  *      @pt: packet type declaration
452  *
453  *      Remove a protocol handler that was previously added to the kernel
454  *      protocol handlers by dev_add_pack(). The passed &packet_type is removed
455  *      from the kernel lists and can be freed or reused once this function
456  *      returns.
457  *
458  *      This call sleeps to guarantee that no CPU is looking at the packet
459  *      type after return.
460  */
461 void dev_remove_pack(struct packet_type *pt)
462 {
463         __dev_remove_pack(pt);
464
465         synchronize_net();
466 }
467 EXPORT_SYMBOL(dev_remove_pack);
468
469
470 /**
471  *      dev_add_offload - register offload handlers
472  *      @po: protocol offload declaration
473  *
474  *      Add protocol offload handlers to the networking stack. The passed
475  *      &proto_offload is linked into kernel lists and may not be freed until
476  *      it has been removed from the kernel lists.
477  *
478  *      This call does not sleep therefore it can not
479  *      guarantee all CPU's that are in middle of receiving packets
480  *      will see the new offload handlers (until the next received packet).
481  */
482 void dev_add_offload(struct packet_offload *po)
483 {
484         struct packet_offload *elem;
485
486         spin_lock(&offload_lock);
487         list_for_each_entry(elem, &offload_base, list) {
488                 if (po->priority < elem->priority)
489                         break;
490         }
491         list_add_rcu(&po->list, elem->list.prev);
492         spin_unlock(&offload_lock);
493 }
494 EXPORT_SYMBOL(dev_add_offload);
495
496 /**
497  *      __dev_remove_offload     - remove offload handler
498  *      @po: packet offload declaration
499  *
500  *      Remove a protocol offload handler that was previously added to the
501  *      kernel offload handlers by dev_add_offload(). The passed &offload_type
502  *      is removed from the kernel lists and can be freed or reused once this
503  *      function returns.
504  *
505  *      The packet type might still be in use by receivers
506  *      and must not be freed until after all the CPU's have gone
507  *      through a quiescent state.
508  */
509 static void __dev_remove_offload(struct packet_offload *po)
510 {
511         struct list_head *head = &offload_base;
512         struct packet_offload *po1;
513
514         spin_lock(&offload_lock);
515
516         list_for_each_entry(po1, head, list) {
517                 if (po == po1) {
518                         list_del_rcu(&po->list);
519                         goto out;
520                 }
521         }
522
523         pr_warn("dev_remove_offload: %p not found\n", po);
524 out:
525         spin_unlock(&offload_lock);
526 }
527
528 /**
529  *      dev_remove_offload       - remove packet offload handler
530  *      @po: packet offload declaration
531  *
532  *      Remove a packet offload handler that was previously added to the kernel
533  *      offload handlers by dev_add_offload(). The passed &offload_type is
534  *      removed from the kernel lists and can be freed or reused once this
535  *      function returns.
536  *
537  *      This call sleeps to guarantee that no CPU is looking at the packet
538  *      type after return.
539  */
540 void dev_remove_offload(struct packet_offload *po)
541 {
542         __dev_remove_offload(po);
543
544         synchronize_net();
545 }
546 EXPORT_SYMBOL(dev_remove_offload);
547
548 /******************************************************************************
549  *
550  *                    Device Boot-time Settings Routines
551  *
552  ******************************************************************************/
553
554 /* Boot time configuration table */
555 static struct netdev_boot_setup dev_boot_setup[NETDEV_BOOT_SETUP_MAX];
556
557 /**
558  *      netdev_boot_setup_add   - add new setup entry
559  *      @name: name of the device
560  *      @map: configured settings for the device
561  *
562  *      Adds new setup entry to the dev_boot_setup list.  The function
563  *      returns 0 on error and 1 on success.  This is a generic routine to
564  *      all netdevices.
565  */
566 static int netdev_boot_setup_add(char *name, struct ifmap *map)
567 {
568         struct netdev_boot_setup *s;
569         int i;
570
571         s = dev_boot_setup;
572         for (i = 0; i < NETDEV_BOOT_SETUP_MAX; i++) {
573                 if (s[i].name[0] == '\0' || s[i].name[0] == ' ') {
574                         memset(s[i].name, 0, sizeof(s[i].name));
575                         strlcpy(s[i].name, name, IFNAMSIZ);
576                         memcpy(&s[i].map, map, sizeof(s[i].map));
577                         break;
578                 }
579         }
580
581         return i >= NETDEV_BOOT_SETUP_MAX ? 0 : 1;
582 }
583
584 /**
585  * netdev_boot_setup_check      - check boot time settings
586  * @dev: the netdevice
587  *
588  * Check boot time settings for the device.
589  * The found settings are set for the device to be used
590  * later in the device probing.
591  * Returns 0 if no settings found, 1 if they are.
592  */
593 int netdev_boot_setup_check(struct net_device *dev)
594 {
595         struct netdev_boot_setup *s = dev_boot_setup;
596         int i;
597
598         for (i = 0; i < NETDEV_BOOT_SETUP_MAX; i++) {
599                 if (s[i].name[0] != '\0' && s[i].name[0] != ' ' &&
600                     !strcmp(dev->name, s[i].name)) {
601                         dev->irq = s[i].map.irq;
602                         dev->base_addr = s[i].map.base_addr;
603                         dev->mem_start = s[i].map.mem_start;
604                         dev->mem_end = s[i].map.mem_end;
605                         return 1;
606                 }
607         }
608         return 0;
609 }
610 EXPORT_SYMBOL(netdev_boot_setup_check);
611
612
613 /**
614  * netdev_boot_base     - get address from boot time settings
615  * @prefix: prefix for network device
616  * @unit: id for network device
617  *
618  * Check boot time settings for the base address of device.
619  * The found settings are set for the device to be used
620  * later in the device probing.
621  * Returns 0 if no settings found.
622  */
623 unsigned long netdev_boot_base(const char *prefix, int unit)
624 {
625         const struct netdev_boot_setup *s = dev_boot_setup;
626         char name[IFNAMSIZ];
627         int i;
628
629         sprintf(name, "%s%d", prefix, unit);
630
631         /*
632          * If device already registered then return base of 1
633          * to indicate not to probe for this interface
634          */
635         if (__dev_get_by_name(&init_net, name))
636                 return 1;
637
638         for (i = 0; i < NETDEV_BOOT_SETUP_MAX; i++)
639                 if (!strcmp(name, s[i].name))
640                         return s[i].map.base_addr;
641         return 0;
642 }
643
644 /*
645  * Saves at boot time configured settings for any netdevice.
646  */
647 int __init netdev_boot_setup(char *str)
648 {
649         int ints[5];
650         struct ifmap map;
651
652         str = get_options(str, ARRAY_SIZE(ints), ints);
653         if (!str || !*str)
654                 return 0;
655
656         /* Save settings */
657         memset(&map, 0, sizeof(map));
658         if (ints[0] > 0)
659                 map.irq = ints[1];
660         if (ints[0] > 1)
661                 map.base_addr = ints[2];
662         if (ints[0] > 2)
663                 map.mem_start = ints[3];
664         if (ints[0] > 3)
665                 map.mem_end = ints[4];
666
667         /* Add new entry to the list */
668         return netdev_boot_setup_add(str, &map);
669 }
670
671 __setup("netdev=", netdev_boot_setup);
672
673 /*******************************************************************************
674  *
675  *                          Device Interface Subroutines
676  *
677  *******************************************************************************/
678
679 /**
680  *      dev_get_iflink  - get 'iflink' value of a interface
681  *      @dev: targeted interface
682  *
683  *      Indicates the ifindex the interface is linked to.
684  *      Physical interfaces have the same 'ifindex' and 'iflink' values.
685  */
686
687 int dev_get_iflink(const struct net_device *dev)
688 {
689         if (dev->netdev_ops && dev->netdev_ops->ndo_get_iflink)
690                 return dev->netdev_ops->ndo_get_iflink(dev);
691
692         return dev->ifindex;
693 }
694 EXPORT_SYMBOL(dev_get_iflink);
695
696 /**
697  *      dev_fill_metadata_dst - Retrieve tunnel egress information.
698  *      @dev: targeted interface
699  *      @skb: The packet.
700  *
701  *      For better visibility of tunnel traffic OVS needs to retrieve
702  *      egress tunnel information for a packet. Following API allows
703  *      user to get this info.
704  */
705 int dev_fill_metadata_dst(struct net_device *dev, struct sk_buff *skb)
706 {
707         struct ip_tunnel_info *info;
708
709         if (!dev->netdev_ops  || !dev->netdev_ops->ndo_fill_metadata_dst)
710                 return -EINVAL;
711
712         info = skb_tunnel_info_unclone(skb);
713         if (!info)
714                 return -ENOMEM;
715         if (unlikely(!(info->mode & IP_TUNNEL_INFO_TX)))
716                 return -EINVAL;
717
718         return dev->netdev_ops->ndo_fill_metadata_dst(dev, skb);
719 }
720 EXPORT_SYMBOL_GPL(dev_fill_metadata_dst);
721
722 /**
723  *      __dev_get_by_name       - find a device by its name
724  *      @net: the applicable net namespace
725  *      @name: name to find
726  *
727  *      Find an interface by name. Must be called under RTNL semaphore
728  *      or @dev_base_lock. If the name is found a pointer to the device
729  *      is returned. If the name is not found then %NULL is returned. The
730  *      reference counters are not incremented so the caller must be
731  *      careful with locks.
732  */
733
734 struct net_device *__dev_get_by_name(struct net *net, const char *name)
735 {
736         struct net_device *dev;
737         struct hlist_head *head = dev_name_hash(net, name);
738
739         hlist_for_each_entry(dev, head, name_hlist)
740                 if (!strncmp(dev->name, name, IFNAMSIZ))
741                         return dev;
742
743         return NULL;
744 }
745 EXPORT_SYMBOL(__dev_get_by_name);
746
747 /**
748  * dev_get_by_name_rcu  - find a device by its name
749  * @net: the applicable net namespace
750  * @name: name to find
751  *
752  * Find an interface by name.
753  * If the name is found a pointer to the device is returned.
754  * If the name is not found then %NULL is returned.
755  * The reference counters are not incremented so the caller must be
756  * careful with locks. The caller must hold RCU lock.
757  */
758
759 struct net_device *dev_get_by_name_rcu(struct net *net, const char *name)
760 {
761         struct net_device *dev;
762         struct hlist_head *head = dev_name_hash(net, name);
763
764         hlist_for_each_entry_rcu(dev, head, name_hlist)
765                 if (!strncmp(dev->name, name, IFNAMSIZ))
766                         return dev;
767
768         return NULL;
769 }
770 EXPORT_SYMBOL(dev_get_by_name_rcu);
771
772 /**
773  *      dev_get_by_name         - find a device by its name
774  *      @net: the applicable net namespace
775  *      @name: name to find
776  *
777  *      Find an interface by name. This can be called from any
778  *      context and does its own locking. The returned handle has
779  *      the usage count incremented and the caller must use dev_put() to
780  *      release it when it is no longer needed. %NULL is returned if no
781  *      matching device is found.
782  */
783
784 struct net_device *dev_get_by_name(struct net *net, const char *name)
785 {
786         struct net_device *dev;
787
788         rcu_read_lock();
789         dev = dev_get_by_name_rcu(net, name);
790         if (dev)
791                 dev_hold(dev);
792         rcu_read_unlock();
793         return dev;
794 }
795 EXPORT_SYMBOL(dev_get_by_name);
796
797 /**
798  *      __dev_get_by_index - find a device by its ifindex
799  *      @net: the applicable net namespace
800  *      @ifindex: index of device
801  *
802  *      Search for an interface by index. Returns %NULL if the device
803  *      is not found or a pointer to the device. The device has not
804  *      had its reference counter increased so the caller must be careful
805  *      about locking. The caller must hold either the RTNL semaphore
806  *      or @dev_base_lock.
807  */
808
809 struct net_device *__dev_get_by_index(struct net *net, int ifindex)
810 {
811         struct net_device *dev;
812         struct hlist_head *head = dev_index_hash(net, ifindex);
813
814         hlist_for_each_entry(dev, head, index_hlist)
815                 if (dev->ifindex == ifindex)
816                         return dev;
817
818         return NULL;
819 }
820 EXPORT_SYMBOL(__dev_get_by_index);
821
822 /**
823  *      dev_get_by_index_rcu - find a device by its ifindex
824  *      @net: the applicable net namespace
825  *      @ifindex: index of device
826  *
827  *      Search for an interface by index. Returns %NULL if the device
828  *      is not found or a pointer to the device. The device has not
829  *      had its reference counter increased so the caller must be careful
830  *      about locking. The caller must hold RCU lock.
831  */
832
833 struct net_device *dev_get_by_index_rcu(struct net *net, int ifindex)
834 {
835         struct net_device *dev;
836         struct hlist_head *head = dev_index_hash(net, ifindex);
837
838         hlist_for_each_entry_rcu(dev, head, index_hlist)
839                 if (dev->ifindex == ifindex)
840                         return dev;
841
842         return NULL;
843 }
844 EXPORT_SYMBOL(dev_get_by_index_rcu);
845
846
847 /**
848  *      dev_get_by_index - find a device by its ifindex
849  *      @net: the applicable net namespace
850  *      @ifindex: index of device
851  *
852  *      Search for an interface by index. Returns NULL if the device
853  *      is not found or a pointer to the device. The device returned has
854  *      had a reference added and the pointer is safe until the user calls
855  *      dev_put to indicate they have finished with it.
856  */
857
858 struct net_device *dev_get_by_index(struct net *net, int ifindex)
859 {
860         struct net_device *dev;
861
862         rcu_read_lock();
863         dev = dev_get_by_index_rcu(net, ifindex);
864         if (dev)
865                 dev_hold(dev);
866         rcu_read_unlock();
867         return dev;
868 }
869 EXPORT_SYMBOL(dev_get_by_index);
870
871 /**
872  *      dev_get_by_napi_id - find a device by napi_id
873  *      @napi_id: ID of the NAPI struct
874  *
875  *      Search for an interface by NAPI ID. Returns %NULL if the device
876  *      is not found or a pointer to the device. The device has not had
877  *      its reference counter increased so the caller must be careful
878  *      about locking. The caller must hold RCU lock.
879  */
880
881 struct net_device *dev_get_by_napi_id(unsigned int napi_id)
882 {
883         struct napi_struct *napi;
884
885         WARN_ON_ONCE(!rcu_read_lock_held());
886
887         if (napi_id < MIN_NAPI_ID)
888                 return NULL;
889
890         napi = napi_by_id(napi_id);
891
892         return napi ? napi->dev : NULL;
893 }
894 EXPORT_SYMBOL(dev_get_by_napi_id);
895
896 /**
897  *      netdev_get_name - get a netdevice name, knowing its ifindex.
898  *      @net: network namespace
899  *      @name: a pointer to the buffer where the name will be stored.
900  *      @ifindex: the ifindex of the interface to get the name from.
901  *
902  *      The use of raw_seqcount_begin() and cond_resched() before
903  *      retrying is required as we want to give the writers a chance
904  *      to complete when CONFIG_PREEMPT is not set.
905  */
906 int netdev_get_name(struct net *net, char *name, int ifindex)
907 {
908         struct net_device *dev;
909         unsigned int seq;
910
911 retry:
912         seq = raw_seqcount_begin(&devnet_rename_seq);
913         rcu_read_lock();
914         dev = dev_get_by_index_rcu(net, ifindex);
915         if (!dev) {
916                 rcu_read_unlock();
917                 return -ENODEV;
918         }
919
920         strcpy(name, dev->name);
921         rcu_read_unlock();
922         if (read_seqcount_retry(&devnet_rename_seq, seq)) {
923                 cond_resched();
924                 goto retry;
925         }
926
927         return 0;
928 }
929
930 /**
931  *      dev_getbyhwaddr_rcu - find a device by its hardware address
932  *      @net: the applicable net namespace
933  *      @type: media type of device
934  *      @ha: hardware address
935  *
936  *      Search for an interface by MAC address. Returns NULL if the device
937  *      is not found or a pointer to the device.
938  *      The caller must hold RCU or RTNL.
939  *      The returned device has not had its ref count increased
940  *      and the caller must therefore be careful about locking
941  *
942  */
943
944 struct net_device *dev_getbyhwaddr_rcu(struct net *net, unsigned short type,
945                                        const char *ha)
946 {
947         struct net_device *dev;
948
949         for_each_netdev_rcu(net, dev)
950                 if (dev->type == type &&
951                     !memcmp(dev->dev_addr, ha, dev->addr_len))
952                         return dev;
953
954         return NULL;
955 }
956 EXPORT_SYMBOL(dev_getbyhwaddr_rcu);
957
958 struct net_device *__dev_getfirstbyhwtype(struct net *net, unsigned short type)
959 {
960         struct net_device *dev;
961
962         ASSERT_RTNL();
963         for_each_netdev(net, dev)
964                 if (dev->type == type)
965                         return dev;
966
967         return NULL;
968 }
969 EXPORT_SYMBOL(__dev_getfirstbyhwtype);
970
971 struct net_device *dev_getfirstbyhwtype(struct net *net, unsigned short type)
972 {
973         struct net_device *dev, *ret = NULL;
974
975         rcu_read_lock();
976         for_each_netdev_rcu(net, dev)
977                 if (dev->type == type) {
978                         dev_hold(dev);
979                         ret = dev;
980                         break;
981                 }
982         rcu_read_unlock();
983         return ret;
984 }
985 EXPORT_SYMBOL(dev_getfirstbyhwtype);
986
987 /**
988  *      __dev_get_by_flags - find any device with given flags
989  *      @net: the applicable net namespace
990  *      @if_flags: IFF_* values
991  *      @mask: bitmask of bits in if_flags to check
992  *
993  *      Search for any interface with the given flags. Returns NULL if a device
994  *      is not found or a pointer to the device. Must be called inside
995  *      rtnl_lock(), and result refcount is unchanged.
996  */
997
998 struct net_device *__dev_get_by_flags(struct net *net, unsigned short if_flags,
999                                       unsigned short mask)
1000 {
1001         struct net_device *dev, *ret;
1002
1003         ASSERT_RTNL();
1004
1005         ret = NULL;
1006         for_each_netdev(net, dev) {
1007                 if (((dev->flags ^ if_flags) & mask) == 0) {
1008                         ret = dev;
1009                         break;
1010                 }
1011         }
1012         return ret;
1013 }
1014 EXPORT_SYMBOL(__dev_get_by_flags);
1015
1016 /**
1017  *      dev_valid_name - check if name is okay for network device
1018  *      @name: name string
1019  *
1020  *      Network device names need to be valid file names to
1021  *      to allow sysfs to work.  We also disallow any kind of
1022  *      whitespace.
1023  */
1024 bool dev_valid_name(const char *name)
1025 {
1026         if (*name == '\0')
1027                 return false;
1028         if (strnlen(name, IFNAMSIZ) == IFNAMSIZ)
1029                 return false;
1030         if (!strcmp(name, ".") || !strcmp(name, ".."))
1031                 return false;
1032
1033         while (*name) {
1034                 if (*name == '/' || *name == ':' || isspace(*name))
1035                         return false;
1036                 name++;
1037         }
1038         return true;
1039 }
1040 EXPORT_SYMBOL(dev_valid_name);
1041
1042 /**
1043  *      __dev_alloc_name - allocate a name for a device
1044  *      @net: network namespace to allocate the device name in
1045  *      @name: name format string
1046  *      @buf:  scratch buffer and result name string
1047  *
1048  *      Passed a format string - eg "lt%d" it will try and find a suitable
1049  *      id. It scans list of devices to build up a free map, then chooses
1050  *      the first empty slot. The caller must hold the dev_base or rtnl lock
1051  *      while allocating the name and adding the device in order to avoid
1052  *      duplicates.
1053  *      Limited to bits_per_byte * page size devices (ie 32K on most platforms).
1054  *      Returns the number of the unit assigned or a negative errno code.
1055  */
1056
1057 static int __dev_alloc_name(struct net *net, const char *name, char *buf)
1058 {
1059         int i = 0;
1060         const char *p;
1061         const int max_netdevices = 8*PAGE_SIZE;
1062         unsigned long *inuse;
1063         struct net_device *d;
1064
1065         if (!dev_valid_name(name))
1066                 return -EINVAL;
1067
1068         p = strchr(name, '%');
1069         if (p) {
1070                 /*
1071                  * Verify the string as this thing may have come from
1072                  * the user.  There must be either one "%d" and no other "%"
1073                  * characters.
1074                  */
1075                 if (p[1] != 'd' || strchr(p + 2, '%'))
1076                         return -EINVAL;
1077
1078                 /* Use one page as a bit array of possible slots */
1079                 inuse = (unsigned long *) get_zeroed_page(GFP_ATOMIC);
1080                 if (!inuse)
1081                         return -ENOMEM;
1082
1083                 for_each_netdev(net, d) {
1084                         if (!sscanf(d->name, name, &i))
1085                                 continue;
1086                         if (i < 0 || i >= max_netdevices)
1087                                 continue;
1088
1089                         /*  avoid cases where sscanf is not exact inverse of printf */
1090                         snprintf(buf, IFNAMSIZ, name, i);
1091                         if (!strncmp(buf, d->name, IFNAMSIZ))
1092                                 set_bit(i, inuse);
1093                 }
1094
1095                 i = find_first_zero_bit(inuse, max_netdevices);
1096                 free_page((unsigned long) inuse);
1097         }
1098
1099         snprintf(buf, IFNAMSIZ, name, i);
1100         if (!__dev_get_by_name(net, buf))
1101                 return i;
1102
1103         /* It is possible to run out of possible slots
1104          * when the name is long and there isn't enough space left
1105          * for the digits, or if all bits are used.
1106          */
1107         return -ENFILE;
1108 }
1109
1110 static int dev_alloc_name_ns(struct net *net,
1111                              struct net_device *dev,
1112                              const char *name)
1113 {
1114         char buf[IFNAMSIZ];
1115         int ret;
1116
1117         BUG_ON(!net);
1118         ret = __dev_alloc_name(net, name, buf);
1119         if (ret >= 0)
1120                 strlcpy(dev->name, buf, IFNAMSIZ);
1121         return ret;
1122 }
1123
1124 /**
1125  *      dev_alloc_name - allocate a name for a device
1126  *      @dev: device
1127  *      @name: name format string
1128  *
1129  *      Passed a format string - eg "lt%d" it will try and find a suitable
1130  *      id. It scans list of devices to build up a free map, then chooses
1131  *      the first empty slot. The caller must hold the dev_base or rtnl lock
1132  *      while allocating the name and adding the device in order to avoid
1133  *      duplicates.
1134  *      Limited to bits_per_byte * page size devices (ie 32K on most platforms).
1135  *      Returns the number of the unit assigned or a negative errno code.
1136  */
1137
1138 int dev_alloc_name(struct net_device *dev, const char *name)
1139 {
1140         return dev_alloc_name_ns(dev_net(dev), dev, name);
1141 }
1142 EXPORT_SYMBOL(dev_alloc_name);
1143
1144 int dev_get_valid_name(struct net *net, struct net_device *dev,
1145                        const char *name)
1146 {
1147         BUG_ON(!net);
1148
1149         if (!dev_valid_name(name))
1150                 return -EINVAL;
1151
1152         if (strchr(name, '%'))
1153                 return dev_alloc_name_ns(net, dev, name);
1154         else if (__dev_get_by_name(net, name))
1155                 return -EEXIST;
1156         else if (dev->name != name)
1157                 strlcpy(dev->name, name, IFNAMSIZ);
1158
1159         return 0;
1160 }
1161 EXPORT_SYMBOL(dev_get_valid_name);
1162
1163 /**
1164  *      dev_change_name - change name of a device
1165  *      @dev: device
1166  *      @newname: name (or format string) must be at least IFNAMSIZ
1167  *
1168  *      Change name of a device, can pass format strings "eth%d".
1169  *      for wildcarding.
1170  */
1171 int dev_change_name(struct net_device *dev, const char *newname)
1172 {
1173         unsigned char old_assign_type;
1174         char oldname[IFNAMSIZ];
1175         int err = 0;
1176         int ret;
1177         struct net *net;
1178
1179         ASSERT_RTNL();
1180         BUG_ON(!dev_net(dev));
1181
1182         net = dev_net(dev);
1183
1184         /* Some auto-enslaved devices e.g. failover slaves are
1185          * special, as userspace might rename the device after
1186          * the interface had been brought up and running since
1187          * the point kernel initiated auto-enslavement. Allow
1188          * live name change even when these slave devices are
1189          * up and running.
1190          *
1191          * Typically, users of these auto-enslaving devices
1192          * don't actually care about slave name change, as
1193          * they are supposed to operate on master interface
1194          * directly.
1195          */
1196         if (dev->flags & IFF_UP &&
1197             likely(!(dev->priv_flags & IFF_LIVE_RENAME_OK)))
1198                 return -EBUSY;
1199
1200         write_seqcount_begin(&devnet_rename_seq);
1201
1202         if (strncmp(newname, dev->name, IFNAMSIZ) == 0) {
1203                 write_seqcount_end(&devnet_rename_seq);
1204                 return 0;
1205         }
1206
1207         memcpy(oldname, dev->name, IFNAMSIZ);
1208
1209         err = dev_get_valid_name(net, dev, newname);
1210         if (err < 0) {
1211                 write_seqcount_end(&devnet_rename_seq);
1212                 return err;
1213         }
1214
1215         if (oldname[0] && !strchr(oldname, '%'))
1216                 netdev_info(dev, "renamed from %s\n", oldname);
1217
1218         old_assign_type = dev->name_assign_type;
1219         dev->name_assign_type = NET_NAME_RENAMED;
1220
1221 rollback:
1222         ret = device_rename(&dev->dev, dev->name);
1223         if (ret) {
1224                 memcpy(dev->name, oldname, IFNAMSIZ);
1225                 dev->name_assign_type = old_assign_type;
1226                 write_seqcount_end(&devnet_rename_seq);
1227                 return ret;
1228         }
1229
1230         write_seqcount_end(&devnet_rename_seq);
1231
1232         netdev_adjacent_rename_links(dev, oldname);
1233
1234         write_lock_bh(&dev_base_lock);
1235         hlist_del_rcu(&dev->name_hlist);
1236         write_unlock_bh(&dev_base_lock);
1237
1238         synchronize_rcu();
1239
1240         write_lock_bh(&dev_base_lock);
1241         hlist_add_head_rcu(&dev->name_hlist, dev_name_hash(net, dev->name));
1242         write_unlock_bh(&dev_base_lock);
1243
1244         ret = call_netdevice_notifiers(NETDEV_CHANGENAME, dev);
1245         ret = notifier_to_errno(ret);
1246
1247         if (ret) {
1248                 /* err >= 0 after dev_alloc_name() or stores the first errno */
1249                 if (err >= 0) {
1250                         err = ret;
1251                         write_seqcount_begin(&devnet_rename_seq);
1252                         memcpy(dev->name, oldname, IFNAMSIZ);
1253                         memcpy(oldname, newname, IFNAMSIZ);
1254                         dev->name_assign_type = old_assign_type;
1255                         old_assign_type = NET_NAME_RENAMED;
1256                         goto rollback;
1257                 } else {
1258                         pr_err("%s: name change rollback failed: %d\n",
1259                                dev->name, ret);
1260                 }
1261         }
1262
1263         return err;
1264 }
1265
1266 /**
1267  *      dev_set_alias - change ifalias of a device
1268  *      @dev: device
1269  *      @alias: name up to IFALIASZ
1270  *      @len: limit of bytes to copy from info
1271  *
1272  *      Set ifalias for a device,
1273  */
1274 int dev_set_alias(struct net_device *dev, const char *alias, size_t len)
1275 {
1276         struct dev_ifalias *new_alias = NULL;
1277
1278         if (len >= IFALIASZ)
1279                 return -EINVAL;
1280
1281         if (len) {
1282                 new_alias = kmalloc(sizeof(*new_alias) + len + 1, GFP_KERNEL);
1283                 if (!new_alias)
1284                         return -ENOMEM;
1285
1286                 memcpy(new_alias->ifalias, alias, len);
1287                 new_alias->ifalias[len] = 0;
1288         }
1289
1290         mutex_lock(&ifalias_mutex);
1291         rcu_swap_protected(dev->ifalias, new_alias,
1292                            mutex_is_locked(&ifalias_mutex));
1293         mutex_unlock(&ifalias_mutex);
1294
1295         if (new_alias)
1296                 kfree_rcu(new_alias, rcuhead);
1297
1298         return len;
1299 }
1300 EXPORT_SYMBOL(dev_set_alias);
1301
1302 /**
1303  *      dev_get_alias - get ifalias of a device
1304  *      @dev: device
1305  *      @name: buffer to store name of ifalias
1306  *      @len: size of buffer
1307  *
1308  *      get ifalias for a device.  Caller must make sure dev cannot go
1309  *      away,  e.g. rcu read lock or own a reference count to device.
1310  */
1311 int dev_get_alias(const struct net_device *dev, char *name, size_t len)
1312 {
1313         const struct dev_ifalias *alias;
1314         int ret = 0;
1315
1316         rcu_read_lock();
1317         alias = rcu_dereference(dev->ifalias);
1318         if (alias)
1319                 ret = snprintf(name, len, "%s", alias->ifalias);
1320         rcu_read_unlock();
1321
1322         return ret;
1323 }
1324
1325 /**
1326  *      netdev_features_change - device changes features
1327  *      @dev: device to cause notification
1328  *
1329  *      Called to indicate a device has changed features.
1330  */
1331 void netdev_features_change(struct net_device *dev)
1332 {
1333         call_netdevice_notifiers(NETDEV_FEAT_CHANGE, dev);
1334 }
1335 EXPORT_SYMBOL(netdev_features_change);
1336
1337 /**
1338  *      netdev_state_change - device changes state
1339  *      @dev: device to cause notification
1340  *
1341  *      Called to indicate a device has changed state. This function calls
1342  *      the notifier chains for netdev_chain and sends a NEWLINK message
1343  *      to the routing socket.
1344  */
1345 void netdev_state_change(struct net_device *dev)
1346 {
1347         if (dev->flags & IFF_UP) {
1348                 struct netdev_notifier_change_info change_info = {
1349                         .info.dev = dev,
1350                 };
1351
1352                 call_netdevice_notifiers_info(NETDEV_CHANGE,
1353                                               &change_info.info);
1354                 rtmsg_ifinfo(RTM_NEWLINK, dev, 0, GFP_KERNEL);
1355         }
1356 }
1357 EXPORT_SYMBOL(netdev_state_change);
1358
1359 /**
1360  * netdev_notify_peers - notify network peers about existence of @dev
1361  * @dev: network device
1362  *
1363  * Generate traffic such that interested network peers are aware of
1364  * @dev, such as by generating a gratuitous ARP. This may be used when
1365  * a device wants to inform the rest of the network about some sort of
1366  * reconfiguration such as a failover event or virtual machine
1367  * migration.
1368  */
1369 void netdev_notify_peers(struct net_device *dev)
1370 {
1371         rtnl_lock();
1372         call_netdevice_notifiers(NETDEV_NOTIFY_PEERS, dev);
1373         call_netdevice_notifiers(NETDEV_RESEND_IGMP, dev);
1374         rtnl_unlock();
1375 }
1376 EXPORT_SYMBOL(netdev_notify_peers);
1377
1378 static int __dev_open(struct net_device *dev, struct netlink_ext_ack *extack)
1379 {
1380         const struct net_device_ops *ops = dev->netdev_ops;
1381         int ret;
1382
1383         ASSERT_RTNL();
1384
1385         if (!netif_device_present(dev))
1386                 return -ENODEV;
1387
1388         /* Block netpoll from trying to do any rx path servicing.
1389          * If we don't do this there is a chance ndo_poll_controller
1390          * or ndo_poll may be running while we open the device
1391          */
1392         netpoll_poll_disable(dev);
1393
1394         ret = call_netdevice_notifiers_extack(NETDEV_PRE_UP, dev, extack);
1395         ret = notifier_to_errno(ret);
1396         if (ret)
1397                 return ret;
1398
1399         set_bit(__LINK_STATE_START, &dev->state);
1400
1401         if (ops->ndo_validate_addr)
1402                 ret = ops->ndo_validate_addr(dev);
1403
1404         if (!ret && ops->ndo_open)
1405                 ret = ops->ndo_open(dev);
1406
1407         netpoll_poll_enable(dev);
1408
1409         if (ret)
1410                 clear_bit(__LINK_STATE_START, &dev->state);
1411         else {
1412                 dev->flags |= IFF_UP;
1413                 dev_set_rx_mode(dev);
1414                 dev_activate(dev);
1415                 add_device_randomness(dev->dev_addr, dev->addr_len);
1416         }
1417
1418         return ret;
1419 }
1420
1421 /**
1422  *      dev_open        - prepare an interface for use.
1423  *      @dev: device to open
1424  *      @extack: netlink extended ack
1425  *
1426  *      Takes a device from down to up state. The device's private open
1427  *      function is invoked and then the multicast lists are loaded. Finally
1428  *      the device is moved into the up state and a %NETDEV_UP message is
1429  *      sent to the netdev notifier chain.
1430  *
1431  *      Calling this function on an active interface is a nop. On a failure
1432  *      a negative errno code is returned.
1433  */
1434 int dev_open(struct net_device *dev, struct netlink_ext_ack *extack)
1435 {
1436         int ret;
1437
1438         if (dev->flags & IFF_UP)
1439                 return 0;
1440
1441         ret = __dev_open(dev, extack);
1442         if (ret < 0)
1443                 return ret;
1444
1445         rtmsg_ifinfo(RTM_NEWLINK, dev, IFF_UP|IFF_RUNNING, GFP_KERNEL);
1446         call_netdevice_notifiers(NETDEV_UP, dev);
1447
1448         return ret;
1449 }
1450 EXPORT_SYMBOL(dev_open);
1451
1452 static void __dev_close_many(struct list_head *head)
1453 {
1454         struct net_device *dev;
1455
1456         ASSERT_RTNL();
1457         might_sleep();
1458
1459         list_for_each_entry(dev, head, close_list) {
1460                 /* Temporarily disable netpoll until the interface is down */
1461                 netpoll_poll_disable(dev);
1462
1463                 call_netdevice_notifiers(NETDEV_GOING_DOWN, dev);
1464
1465                 clear_bit(__LINK_STATE_START, &dev->state);
1466
1467                 /* Synchronize to scheduled poll. We cannot touch poll list, it
1468                  * can be even on different cpu. So just clear netif_running().
1469                  *
1470                  * dev->stop() will invoke napi_disable() on all of it's
1471                  * napi_struct instances on this device.
1472                  */
1473                 smp_mb__after_atomic(); /* Commit netif_running(). */
1474         }
1475
1476         dev_deactivate_many(head);
1477
1478         list_for_each_entry(dev, head, close_list) {
1479                 const struct net_device_ops *ops = dev->netdev_ops;
1480
1481                 /*
1482                  *      Call the device specific close. This cannot fail.
1483                  *      Only if device is UP
1484                  *
1485                  *      We allow it to be called even after a DETACH hot-plug
1486                  *      event.
1487                  */
1488                 if (ops->ndo_stop)
1489                         ops->ndo_stop(dev);
1490
1491                 dev->flags &= ~IFF_UP;
1492                 netpoll_poll_enable(dev);
1493         }
1494 }
1495
1496 static void __dev_close(struct net_device *dev)
1497 {
1498         LIST_HEAD(single);
1499
1500         list_add(&dev->close_list, &single);
1501         __dev_close_many(&single);
1502         list_del(&single);
1503 }
1504
1505 void dev_close_many(struct list_head *head, bool unlink)
1506 {
1507         struct net_device *dev, *tmp;
1508
1509         /* Remove the devices that don't need to be closed */
1510         list_for_each_entry_safe(dev, tmp, head, close_list)
1511                 if (!(dev->flags & IFF_UP))
1512                         list_del_init(&dev->close_list);
1513
1514         __dev_close_many(head);
1515
1516         list_for_each_entry_safe(dev, tmp, head, close_list) {
1517                 rtmsg_ifinfo(RTM_NEWLINK, dev, IFF_UP|IFF_RUNNING, GFP_KERNEL);
1518                 call_netdevice_notifiers(NETDEV_DOWN, dev);
1519                 if (unlink)
1520                         list_del_init(&dev->close_list);
1521         }
1522 }
1523 EXPORT_SYMBOL(dev_close_many);
1524
1525 /**
1526  *      dev_close - shutdown an interface.
1527  *      @dev: device to shutdown
1528  *
1529  *      This function moves an active device into down state. A
1530  *      %NETDEV_GOING_DOWN is sent to the netdev notifier chain. The device
1531  *      is then deactivated and finally a %NETDEV_DOWN is sent to the notifier
1532  *      chain.
1533  */
1534 void dev_close(struct net_device *dev)
1535 {
1536         if (dev->flags & IFF_UP) {
1537                 LIST_HEAD(single);
1538
1539                 list_add(&dev->close_list, &single);
1540                 dev_close_many(&single, true);
1541                 list_del(&single);
1542         }
1543 }
1544 EXPORT_SYMBOL(dev_close);
1545
1546
1547 /**
1548  *      dev_disable_lro - disable Large Receive Offload on a device
1549  *      @dev: device
1550  *
1551  *      Disable Large Receive Offload (LRO) on a net device.  Must be
1552  *      called under RTNL.  This is needed if received packets may be
1553  *      forwarded to another interface.
1554  */
1555 void dev_disable_lro(struct net_device *dev)
1556 {
1557         struct net_device *lower_dev;
1558         struct list_head *iter;
1559
1560         dev->wanted_features &= ~NETIF_F_LRO;
1561         netdev_update_features(dev);
1562
1563         if (unlikely(dev->features & NETIF_F_LRO))
1564                 netdev_WARN(dev, "failed to disable LRO!\n");
1565
1566         netdev_for_each_lower_dev(dev, lower_dev, iter)
1567                 dev_disable_lro(lower_dev);
1568 }
1569 EXPORT_SYMBOL(dev_disable_lro);
1570
1571 /**
1572  *      dev_disable_gro_hw - disable HW Generic Receive Offload on a device
1573  *      @dev: device
1574  *
1575  *      Disable HW Generic Receive Offload (GRO_HW) on a net device.  Must be
1576  *      called under RTNL.  This is needed if Generic XDP is installed on
1577  *      the device.
1578  */
1579 static void dev_disable_gro_hw(struct net_device *dev)
1580 {
1581         dev->wanted_features &= ~NETIF_F_GRO_HW;
1582         netdev_update_features(dev);
1583
1584         if (unlikely(dev->features & NETIF_F_GRO_HW))
1585                 netdev_WARN(dev, "failed to disable GRO_HW!\n");
1586 }
1587
1588 const char *netdev_cmd_to_name(enum netdev_cmd cmd)
1589 {
1590 #define N(val)                                          \
1591         case NETDEV_##val:                              \
1592                 return "NETDEV_" __stringify(val);
1593         switch (cmd) {
1594         N(UP) N(DOWN) N(REBOOT) N(CHANGE) N(REGISTER) N(UNREGISTER)
1595         N(CHANGEMTU) N(CHANGEADDR) N(GOING_DOWN) N(CHANGENAME) N(FEAT_CHANGE)
1596         N(BONDING_FAILOVER) N(PRE_UP) N(PRE_TYPE_CHANGE) N(POST_TYPE_CHANGE)
1597         N(POST_INIT) N(RELEASE) N(NOTIFY_PEERS) N(JOIN) N(CHANGEUPPER)
1598         N(RESEND_IGMP) N(PRECHANGEMTU) N(CHANGEINFODATA) N(BONDING_INFO)
1599         N(PRECHANGEUPPER) N(CHANGELOWERSTATE) N(UDP_TUNNEL_PUSH_INFO)
1600         N(UDP_TUNNEL_DROP_INFO) N(CHANGE_TX_QUEUE_LEN)
1601         N(CVLAN_FILTER_PUSH_INFO) N(CVLAN_FILTER_DROP_INFO)
1602         N(SVLAN_FILTER_PUSH_INFO) N(SVLAN_FILTER_DROP_INFO)
1603         N(PRE_CHANGEADDR)
1604         }
1605 #undef N
1606         return "UNKNOWN_NETDEV_EVENT";
1607 }
1608 EXPORT_SYMBOL_GPL(netdev_cmd_to_name);
1609
1610 static int call_netdevice_notifier(struct notifier_block *nb, unsigned long val,
1611                                    struct net_device *dev)
1612 {
1613         struct netdev_notifier_info info = {
1614                 .dev = dev,
1615         };
1616
1617         return nb->notifier_call(nb, val, &info);
1618 }
1619
1620 static int dev_boot_phase = 1;
1621
1622 /**
1623  * register_netdevice_notifier - register a network notifier block
1624  * @nb: notifier
1625  *
1626  * Register a notifier to be called when network device events occur.
1627  * The notifier passed is linked into the kernel structures and must
1628  * not be reused until it has been unregistered. A negative errno code
1629  * is returned on a failure.
1630  *
1631  * When registered all registration and up events are replayed
1632  * to the new notifier to allow device to have a race free
1633  * view of the network device list.
1634  */
1635
1636 int register_netdevice_notifier(struct notifier_block *nb)
1637 {
1638         struct net_device *dev;
1639         struct net_device *last;
1640         struct net *net;
1641         int err;
1642
1643         /* Close race with setup_net() and cleanup_net() */
1644         down_write(&pernet_ops_rwsem);
1645         rtnl_lock();
1646         err = raw_notifier_chain_register(&netdev_chain, nb);
1647         if (err)
1648                 goto unlock;
1649         if (dev_boot_phase)
1650                 goto unlock;
1651         for_each_net(net) {
1652                 for_each_netdev(net, dev) {
1653                         err = call_netdevice_notifier(nb, NETDEV_REGISTER, dev);
1654                         err = notifier_to_errno(err);
1655                         if (err)
1656                                 goto rollback;
1657
1658                         if (!(dev->flags & IFF_UP))
1659                                 continue;
1660
1661                         call_netdevice_notifier(nb, NETDEV_UP, dev);
1662                 }
1663         }
1664
1665 unlock:
1666         rtnl_unlock();
1667         up_write(&pernet_ops_rwsem);
1668         return err;
1669
1670 rollback:
1671         last = dev;
1672         for_each_net(net) {
1673                 for_each_netdev(net, dev) {
1674                         if (dev == last)
1675                                 goto outroll;
1676
1677                         if (dev->flags & IFF_UP) {
1678                                 call_netdevice_notifier(nb, NETDEV_GOING_DOWN,
1679                                                         dev);
1680                                 call_netdevice_notifier(nb, NETDEV_DOWN, dev);
1681                         }
1682                         call_netdevice_notifier(nb, NETDEV_UNREGISTER, dev);
1683                 }
1684         }
1685
1686 outroll:
1687         raw_notifier_chain_unregister(&netdev_chain, nb);
1688         goto unlock;
1689 }
1690 EXPORT_SYMBOL(register_netdevice_notifier);
1691
1692 /**
1693  * unregister_netdevice_notifier - unregister a network notifier block
1694  * @nb: notifier
1695  *
1696  * Unregister a notifier previously registered by
1697  * register_netdevice_notifier(). The notifier is unlinked into the
1698  * kernel structures and may then be reused. A negative errno code
1699  * is returned on a failure.
1700  *
1701  * After unregistering unregister and down device events are synthesized
1702  * for all devices on the device list to the removed notifier to remove
1703  * the need for special case cleanup code.
1704  */
1705
1706 int unregister_netdevice_notifier(struct notifier_block *nb)
1707 {
1708         struct net_device *dev;
1709         struct net *net;
1710         int err;
1711
1712         /* Close race with setup_net() and cleanup_net() */
1713         down_write(&pernet_ops_rwsem);
1714         rtnl_lock();
1715         err = raw_notifier_chain_unregister(&netdev_chain, nb);
1716         if (err)
1717                 goto unlock;
1718
1719         for_each_net(net) {
1720                 for_each_netdev(net, dev) {
1721                         if (dev->flags & IFF_UP) {
1722                                 call_netdevice_notifier(nb, NETDEV_GOING_DOWN,
1723                                                         dev);
1724                                 call_netdevice_notifier(nb, NETDEV_DOWN, dev);
1725                         }
1726                         call_netdevice_notifier(nb, NETDEV_UNREGISTER, dev);
1727                 }
1728         }
1729 unlock:
1730         rtnl_unlock();
1731         up_write(&pernet_ops_rwsem);
1732         return err;
1733 }
1734 EXPORT_SYMBOL(unregister_netdevice_notifier);
1735
1736 /**
1737  *      call_netdevice_notifiers_info - call all network notifier blocks
1738  *      @val: value passed unmodified to notifier function
1739  *      @info: notifier information data
1740  *
1741  *      Call all network notifier blocks.  Parameters and return value
1742  *      are as for raw_notifier_call_chain().
1743  */
1744
1745 static int call_netdevice_notifiers_info(unsigned long val,
1746                                          struct netdev_notifier_info *info)
1747 {
1748         ASSERT_RTNL();
1749         return raw_notifier_call_chain(&netdev_chain, val, info);
1750 }
1751
1752 static int call_netdevice_notifiers_extack(unsigned long val,
1753                                            struct net_device *dev,
1754                                            struct netlink_ext_ack *extack)
1755 {
1756         struct netdev_notifier_info info = {
1757                 .dev = dev,
1758                 .extack = extack,
1759         };
1760
1761         return call_netdevice_notifiers_info(val, &info);
1762 }
1763
1764 /**
1765  *      call_netdevice_notifiers - call all network notifier blocks
1766  *      @val: value passed unmodified to notifier function
1767  *      @dev: net_device pointer passed unmodified to notifier function
1768  *
1769  *      Call all network notifier blocks.  Parameters and return value
1770  *      are as for raw_notifier_call_chain().
1771  */
1772
1773 int call_netdevice_notifiers(unsigned long val, struct net_device *dev)
1774 {
1775         return call_netdevice_notifiers_extack(val, dev, NULL);
1776 }
1777 EXPORT_SYMBOL(call_netdevice_notifiers);
1778
1779 /**
1780  *      call_netdevice_notifiers_mtu - call all network notifier blocks
1781  *      @val: value passed unmodified to notifier function
1782  *      @dev: net_device pointer passed unmodified to notifier function
1783  *      @arg: additional u32 argument passed to the notifier function
1784  *
1785  *      Call all network notifier blocks.  Parameters and return value
1786  *      are as for raw_notifier_call_chain().
1787  */
1788 static int call_netdevice_notifiers_mtu(unsigned long val,
1789                                         struct net_device *dev, u32 arg)
1790 {
1791         struct netdev_notifier_info_ext info = {
1792                 .info.dev = dev,
1793                 .ext.mtu = arg,
1794         };
1795
1796         BUILD_BUG_ON(offsetof(struct netdev_notifier_info_ext, info) != 0);
1797
1798         return call_netdevice_notifiers_info(val, &info.info);
1799 }
1800
1801 #ifdef CONFIG_NET_INGRESS
1802 static DEFINE_STATIC_KEY_FALSE(ingress_needed_key);
1803
1804 void net_inc_ingress_queue(void)
1805 {
1806         static_branch_inc(&ingress_needed_key);
1807 }
1808 EXPORT_SYMBOL_GPL(net_inc_ingress_queue);
1809
1810 void net_dec_ingress_queue(void)
1811 {
1812         static_branch_dec(&ingress_needed_key);
1813 }
1814 EXPORT_SYMBOL_GPL(net_dec_ingress_queue);
1815 #endif
1816
1817 #ifdef CONFIG_NET_EGRESS
1818 static DEFINE_STATIC_KEY_FALSE(egress_needed_key);
1819
1820 void net_inc_egress_queue(void)
1821 {
1822         static_branch_inc(&egress_needed_key);
1823 }
1824 EXPORT_SYMBOL_GPL(net_inc_egress_queue);
1825
1826 void net_dec_egress_queue(void)
1827 {
1828         static_branch_dec(&egress_needed_key);
1829 }
1830 EXPORT_SYMBOL_GPL(net_dec_egress_queue);
1831 #endif
1832
1833 static DEFINE_STATIC_KEY_FALSE(netstamp_needed_key);
1834 #ifdef CONFIG_JUMP_LABEL
1835 static atomic_t netstamp_needed_deferred;
1836 static atomic_t netstamp_wanted;
1837 static void netstamp_clear(struct work_struct *work)
1838 {
1839         int deferred = atomic_xchg(&netstamp_needed_deferred, 0);
1840         int wanted;
1841
1842         wanted = atomic_add_return(deferred, &netstamp_wanted);
1843         if (wanted > 0)
1844                 static_branch_enable(&netstamp_needed_key);
1845         else
1846                 static_branch_disable(&netstamp_needed_key);
1847 }
1848 static DECLARE_WORK(netstamp_work, netstamp_clear);
1849 #endif
1850
1851 void net_enable_timestamp(void)
1852 {
1853 #ifdef CONFIG_JUMP_LABEL
1854         int wanted;
1855
1856         while (1) {
1857                 wanted = atomic_read(&netstamp_wanted);
1858                 if (wanted <= 0)
1859                         break;
1860                 if (atomic_cmpxchg(&netstamp_wanted, wanted, wanted + 1) == wanted)
1861                         return;
1862         }
1863         atomic_inc(&netstamp_needed_deferred);
1864         schedule_work(&netstamp_work);
1865 #else
1866         static_branch_inc(&netstamp_needed_key);
1867 #endif
1868 }
1869 EXPORT_SYMBOL(net_enable_timestamp);
1870
1871 void net_disable_timestamp(void)
1872 {
1873 #ifdef CONFIG_JUMP_LABEL
1874         int wanted;
1875
1876         while (1) {
1877                 wanted = atomic_read(&netstamp_wanted);
1878                 if (wanted <= 1)
1879                         break;
1880                 if (atomic_cmpxchg(&netstamp_wanted, wanted, wanted - 1) == wanted)
1881                         return;
1882         }
1883         atomic_dec(&netstamp_needed_deferred);
1884         schedule_work(&netstamp_work);
1885 #else
1886         static_branch_dec(&netstamp_needed_key);
1887 #endif
1888 }
1889 EXPORT_SYMBOL(net_disable_timestamp);
1890
1891 static inline void net_timestamp_set(struct sk_buff *skb)
1892 {
1893         skb->tstamp = 0;
1894         if (static_branch_unlikely(&netstamp_needed_key))
1895                 __net_timestamp(skb);
1896 }
1897
1898 #define net_timestamp_check(COND, SKB)                          \
1899         if (static_branch_unlikely(&netstamp_needed_key)) {     \
1900                 if ((COND) && !(SKB)->tstamp)                   \
1901                         __net_timestamp(SKB);                   \
1902         }                                                       \
1903
1904 bool is_skb_forwardable(const struct net_device *dev, const struct sk_buff *skb)
1905 {
1906         unsigned int len;
1907
1908         if (!(dev->flags & IFF_UP))
1909                 return false;
1910
1911         len = dev->mtu + dev->hard_header_len + VLAN_HLEN;
1912         if (skb->len <= len)
1913                 return true;
1914
1915         /* if TSO is enabled, we don't care about the length as the packet
1916          * could be forwarded without being segmented before
1917          */
1918         if (skb_is_gso(skb))
1919                 return true;
1920
1921         return false;
1922 }
1923 EXPORT_SYMBOL_GPL(is_skb_forwardable);
1924
1925 int __dev_forward_skb(struct net_device *dev, struct sk_buff *skb)
1926 {
1927         int ret = ____dev_forward_skb(dev, skb);
1928
1929         if (likely(!ret)) {
1930                 skb->protocol = eth_type_trans(skb, dev);
1931                 skb_postpull_rcsum(skb, eth_hdr(skb), ETH_HLEN);
1932         }
1933
1934         return ret;
1935 }
1936 EXPORT_SYMBOL_GPL(__dev_forward_skb);
1937
1938 /**
1939  * dev_forward_skb - loopback an skb to another netif
1940  *
1941  * @dev: destination network device
1942  * @skb: buffer to forward
1943  *
1944  * return values:
1945  *      NET_RX_SUCCESS  (no congestion)
1946  *      NET_RX_DROP     (packet was dropped, but freed)
1947  *
1948  * dev_forward_skb can be used for injecting an skb from the
1949  * start_xmit function of one device into the receive queue
1950  * of another device.
1951  *
1952  * The receiving device may be in another namespace, so
1953  * we have to clear all information in the skb that could
1954  * impact namespace isolation.
1955  */
1956 int dev_forward_skb(struct net_device *dev, struct sk_buff *skb)
1957 {
1958         return __dev_forward_skb(dev, skb) ?: netif_rx_internal(skb);
1959 }
1960 EXPORT_SYMBOL_GPL(dev_forward_skb);
1961
1962 static inline int deliver_skb(struct sk_buff *skb,
1963                               struct packet_type *pt_prev,
1964                               struct net_device *orig_dev)
1965 {
1966         if (unlikely(skb_orphan_frags_rx(skb, GFP_ATOMIC)))
1967                 return -ENOMEM;
1968         refcount_inc(&skb->users);
1969         return pt_prev->func(skb, skb->dev, pt_prev, orig_dev);
1970 }
1971
1972 static inline void deliver_ptype_list_skb(struct sk_buff *skb,
1973                                           struct packet_type **pt,
1974                                           struct net_device *orig_dev,
1975                                           __be16 type,
1976                                           struct list_head *ptype_list)
1977 {
1978         struct packet_type *ptype, *pt_prev = *pt;
1979
1980         list_for_each_entry_rcu(ptype, ptype_list, list) {
1981                 if (ptype->type != type)
1982                         continue;
1983                 if (pt_prev)
1984                         deliver_skb(skb, pt_prev, orig_dev);
1985                 pt_prev = ptype;
1986         }
1987         *pt = pt_prev;
1988 }
1989
1990 static inline bool skb_loop_sk(struct packet_type *ptype, struct sk_buff *skb)
1991 {
1992         if (!ptype->af_packet_priv || !skb->sk)
1993                 return false;
1994
1995         if (ptype->id_match)
1996                 return ptype->id_match(ptype, skb->sk);
1997         else if ((struct sock *)ptype->af_packet_priv == skb->sk)
1998                 return true;
1999
2000         return false;
2001 }
2002
2003 /**
2004  * dev_nit_active - return true if any network interface taps are in use
2005  *
2006  * @dev: network device to check for the presence of taps
2007  */
2008 bool dev_nit_active(struct net_device *dev)
2009 {
2010         return !list_empty(&ptype_all) || !list_empty(&dev->ptype_all);
2011 }
2012 EXPORT_SYMBOL_GPL(dev_nit_active);
2013
2014 /*
2015  *      Support routine. Sends outgoing frames to any network
2016  *      taps currently in use.
2017  */
2018
2019 void dev_queue_xmit_nit(struct sk_buff *skb, struct net_device *dev)
2020 {
2021         struct packet_type *ptype;
2022         struct sk_buff *skb2 = NULL;
2023         struct packet_type *pt_prev = NULL;
2024         struct list_head *ptype_list = &ptype_all;
2025
2026         rcu_read_lock();
2027 again:
2028         list_for_each_entry_rcu(ptype, ptype_list, list) {
2029                 if (ptype->ignore_outgoing)
2030                         continue;
2031
2032                 /* Never send packets back to the socket
2033                  * they originated from - MvS (miquels@drinkel.ow.org)
2034                  */
2035                 if (skb_loop_sk(ptype, skb))
2036                         continue;
2037
2038                 if (pt_prev) {
2039                         deliver_skb(skb2, pt_prev, skb->dev);
2040                         pt_prev = ptype;
2041                         continue;
2042                 }
2043
2044                 /* need to clone skb, done only once */
2045                 skb2 = skb_clone(skb, GFP_ATOMIC);
2046                 if (!skb2)
2047                         goto out_unlock;
2048
2049                 net_timestamp_set(skb2);
2050
2051                 /* skb->nh should be correctly
2052                  * set by sender, so that the second statement is
2053                  * just protection against buggy protocols.
2054                  */
2055                 skb_reset_mac_header(skb2);
2056
2057                 if (skb_network_header(skb2) < skb2->data ||
2058                     skb_network_header(skb2) > skb_tail_pointer(skb2)) {
2059                         net_crit_ratelimited("protocol %04x is buggy, dev %s\n",
2060                                              ntohs(skb2->protocol),
2061                                              dev->name);
2062                         skb_reset_network_header(skb2);
2063                 }
2064
2065                 skb2->transport_header = skb2->network_header;
2066                 skb2->pkt_type = PACKET_OUTGOING;
2067                 pt_prev = ptype;
2068         }
2069
2070         if (ptype_list == &ptype_all) {
2071                 ptype_list = &dev->ptype_all;
2072                 goto again;
2073         }
2074 out_unlock:
2075         if (pt_prev) {
2076                 if (!skb_orphan_frags_rx(skb2, GFP_ATOMIC))
2077                         pt_prev->func(skb2, skb->dev, pt_prev, skb->dev);
2078                 else
2079                         kfree_skb(skb2);
2080         }
2081         rcu_read_unlock();
2082 }
2083 EXPORT_SYMBOL_GPL(dev_queue_xmit_nit);
2084
2085 /**
2086  * netif_setup_tc - Handle tc mappings on real_num_tx_queues change
2087  * @dev: Network device
2088  * @txq: number of queues available
2089  *
2090  * If real_num_tx_queues is changed the tc mappings may no longer be
2091  * valid. To resolve this verify the tc mapping remains valid and if
2092  * not NULL the mapping. With no priorities mapping to this
2093  * offset/count pair it will no longer be used. In the worst case TC0
2094  * is invalid nothing can be done so disable priority mappings. If is
2095  * expected that drivers will fix this mapping if they can before
2096  * calling netif_set_real_num_tx_queues.
2097  */
2098 static void netif_setup_tc(struct net_device *dev, unsigned int txq)
2099 {
2100         int i;
2101         struct netdev_tc_txq *tc = &dev->tc_to_txq[0];
2102
2103         /* If TC0 is invalidated disable TC mapping */
2104         if (tc->offset + tc->count > txq) {
2105                 pr_warn("Number of in use tx queues changed invalidating tc mappings. Priority traffic classification disabled!\n");
2106                 dev->num_tc = 0;
2107                 return;
2108         }
2109
2110         /* Invalidated prio to tc mappings set to TC0 */
2111         for (i = 1; i < TC_BITMASK + 1; i++) {
2112                 int q = netdev_get_prio_tc_map(dev, i);
2113
2114                 tc = &dev->tc_to_txq[q];
2115                 if (tc->offset + tc->count > txq) {
2116                         pr_warn("Number of in use tx queues changed. Priority %i to tc mapping %i is no longer valid. Setting map to 0\n",
2117                                 i, q);
2118                         netdev_set_prio_tc_map(dev, i, 0);
2119                 }
2120         }
2121 }
2122
2123 int netdev_txq_to_tc(struct net_device *dev, unsigned int txq)
2124 {
2125         if (dev->num_tc) {
2126                 struct netdev_tc_txq *tc = &dev->tc_to_txq[0];
2127                 int i;
2128
2129                 /* walk through the TCs and see if it falls into any of them */
2130                 for (i = 0; i < TC_MAX_QUEUE; i++, tc++) {
2131                         if ((txq - tc->offset) < tc->count)
2132                                 return i;
2133                 }
2134
2135                 /* didn't find it, just return -1 to indicate no match */
2136                 return -1;
2137         }
2138
2139         return 0;
2140 }
2141 EXPORT_SYMBOL(netdev_txq_to_tc);
2142
2143 #ifdef CONFIG_XPS
2144 struct static_key xps_needed __read_mostly;
2145 EXPORT_SYMBOL(xps_needed);
2146 struct static_key xps_rxqs_needed __read_mostly;
2147 EXPORT_SYMBOL(xps_rxqs_needed);
2148 static DEFINE_MUTEX(xps_map_mutex);
2149 #define xmap_dereference(P)             \
2150         rcu_dereference_protected((P), lockdep_is_held(&xps_map_mutex))
2151
2152 static bool remove_xps_queue(struct xps_dev_maps *dev_maps,
2153                              int tci, u16 index)
2154 {
2155         struct xps_map *map = NULL;
2156         int pos;
2157
2158         if (dev_maps)
2159                 map = xmap_dereference(dev_maps->attr_map[tci]);
2160         if (!map)
2161                 return false;
2162
2163         for (pos = map->len; pos--;) {
2164                 if (map->queues[pos] != index)
2165                         continue;
2166
2167                 if (map->len > 1) {
2168                         map->queues[pos] = map->queues[--map->len];
2169                         break;
2170                 }
2171
2172                 RCU_INIT_POINTER(dev_maps->attr_map[tci], NULL);
2173                 kfree_rcu(map, rcu);
2174                 return false;
2175         }
2176
2177         return true;
2178 }
2179
2180 static bool remove_xps_queue_cpu(struct net_device *dev,
2181                                  struct xps_dev_maps *dev_maps,
2182                                  int cpu, u16 offset, u16 count)
2183 {
2184         int num_tc = dev->num_tc ? : 1;
2185         bool active = false;
2186         int tci;
2187
2188         for (tci = cpu * num_tc; num_tc--; tci++) {
2189                 int i, j;
2190
2191                 for (i = count, j = offset; i--; j++) {
2192                         if (!remove_xps_queue(dev_maps, tci, j))
2193                                 break;
2194                 }
2195
2196                 active |= i < 0;
2197         }
2198
2199         return active;
2200 }
2201
2202 static void reset_xps_maps(struct net_device *dev,
2203                            struct xps_dev_maps *dev_maps,
2204                            bool is_rxqs_map)
2205 {
2206         if (is_rxqs_map) {
2207                 static_key_slow_dec_cpuslocked(&xps_rxqs_needed);
2208                 RCU_INIT_POINTER(dev->xps_rxqs_map, NULL);
2209         } else {
2210                 RCU_INIT_POINTER(dev->xps_cpus_map, NULL);
2211         }
2212         static_key_slow_dec_cpuslocked(&xps_needed);
2213         kfree_rcu(dev_maps, rcu);
2214 }
2215
2216 static void clean_xps_maps(struct net_device *dev, const unsigned long *mask,
2217                            struct xps_dev_maps *dev_maps, unsigned int nr_ids,
2218                            u16 offset, u16 count, bool is_rxqs_map)
2219 {
2220         bool active = false;
2221         int i, j;
2222
2223         for (j = -1; j = netif_attrmask_next(j, mask, nr_ids),
2224              j < nr_ids;)
2225                 active |= remove_xps_queue_cpu(dev, dev_maps, j, offset,
2226                                                count);
2227         if (!active)
2228                 reset_xps_maps(dev, dev_maps, is_rxqs_map);
2229
2230         if (!is_rxqs_map) {
2231                 for (i = offset + (count - 1); count--; i--) {
2232                         netdev_queue_numa_node_write(
2233                                 netdev_get_tx_queue(dev, i),
2234                                 NUMA_NO_NODE);
2235                 }
2236         }
2237 }
2238
2239 static void netif_reset_xps_queues(struct net_device *dev, u16 offset,
2240                                    u16 count)
2241 {
2242         const unsigned long *possible_mask = NULL;
2243         struct xps_dev_maps *dev_maps;
2244         unsigned int nr_ids;
2245
2246         if (!static_key_false(&xps_needed))
2247                 return;
2248
2249         cpus_read_lock();
2250         mutex_lock(&xps_map_mutex);
2251
2252         if (static_key_false(&xps_rxqs_needed)) {
2253                 dev_maps = xmap_dereference(dev->xps_rxqs_map);
2254                 if (dev_maps) {
2255                         nr_ids = dev->num_rx_queues;
2256                         clean_xps_maps(dev, possible_mask, dev_maps, nr_ids,
2257                                        offset, count, true);
2258                 }
2259         }
2260
2261         dev_maps = xmap_dereference(dev->xps_cpus_map);
2262         if (!dev_maps)
2263                 goto out_no_maps;
2264
2265         if (num_possible_cpus() > 1)
2266                 possible_mask = cpumask_bits(cpu_possible_mask);
2267         nr_ids = nr_cpu_ids;
2268         clean_xps_maps(dev, possible_mask, dev_maps, nr_ids, offset, count,
2269                        false);
2270
2271 out_no_maps:
2272         mutex_unlock(&xps_map_mutex);
2273         cpus_read_unlock();
2274 }
2275
2276 static void netif_reset_xps_queues_gt(struct net_device *dev, u16 index)
2277 {
2278         netif_reset_xps_queues(dev, index, dev->num_tx_queues - index);
2279 }
2280
2281 static struct xps_map *expand_xps_map(struct xps_map *map, int attr_index,
2282                                       u16 index, bool is_rxqs_map)
2283 {
2284         struct xps_map *new_map;
2285         int alloc_len = XPS_MIN_MAP_ALLOC;
2286         int i, pos;
2287
2288         for (pos = 0; map && pos < map->len; pos++) {
2289                 if (map->queues[pos] != index)
2290                         continue;
2291                 return map;
2292         }
2293
2294         /* Need to add tx-queue to this CPU's/rx-queue's existing map */
2295         if (map) {
2296                 if (pos < map->alloc_len)
2297                         return map;
2298
2299                 alloc_len = map->alloc_len * 2;
2300         }
2301
2302         /* Need to allocate new map to store tx-queue on this CPU's/rx-queue's
2303          *  map
2304          */
2305         if (is_rxqs_map)
2306                 new_map = kzalloc(XPS_MAP_SIZE(alloc_len), GFP_KERNEL);
2307         else
2308                 new_map = kzalloc_node(XPS_MAP_SIZE(alloc_len), GFP_KERNEL,
2309                                        cpu_to_node(attr_index));
2310         if (!new_map)
2311                 return NULL;
2312
2313         for (i = 0; i < pos; i++)
2314                 new_map->queues[i] = map->queues[i];
2315         new_map->alloc_len = alloc_len;
2316         new_map->len = pos;
2317
2318         return new_map;
2319 }
2320
2321 /* Must be called under cpus_read_lock */
2322 int __netif_set_xps_queue(struct net_device *dev, const unsigned long *mask,
2323                           u16 index, bool is_rxqs_map)
2324 {
2325         const unsigned long *online_mask = NULL, *possible_mask = NULL;
2326         struct xps_dev_maps *dev_maps, *new_dev_maps = NULL;
2327         int i, j, tci, numa_node_id = -2;
2328         int maps_sz, num_tc = 1, tc = 0;
2329         struct xps_map *map, *new_map;
2330         bool active = false;
2331         unsigned int nr_ids;
2332
2333         if (dev->num_tc) {
2334                 /* Do not allow XPS on subordinate device directly */
2335                 num_tc = dev->num_tc;
2336                 if (num_tc < 0)
2337                         return -EINVAL;
2338
2339                 /* If queue belongs to subordinate dev use its map */
2340                 dev = netdev_get_tx_queue(dev, index)->sb_dev ? : dev;
2341
2342                 tc = netdev_txq_to_tc(dev, index);
2343                 if (tc < 0)
2344                         return -EINVAL;
2345         }
2346
2347         mutex_lock(&xps_map_mutex);
2348         if (is_rxqs_map) {
2349                 maps_sz = XPS_RXQ_DEV_MAPS_SIZE(num_tc, dev->num_rx_queues);
2350                 dev_maps = xmap_dereference(dev->xps_rxqs_map);
2351                 nr_ids = dev->num_rx_queues;
2352         } else {
2353                 maps_sz = XPS_CPU_DEV_MAPS_SIZE(num_tc);
2354                 if (num_possible_cpus() > 1) {
2355                         online_mask = cpumask_bits(cpu_online_mask);
2356                         possible_mask = cpumask_bits(cpu_possible_mask);
2357                 }
2358                 dev_maps = xmap_dereference(dev->xps_cpus_map);
2359                 nr_ids = nr_cpu_ids;
2360         }
2361
2362         if (maps_sz < L1_CACHE_BYTES)
2363                 maps_sz = L1_CACHE_BYTES;
2364
2365         /* allocate memory for queue storage */
2366         for (j = -1; j = netif_attrmask_next_and(j, online_mask, mask, nr_ids),
2367              j < nr_ids;) {
2368                 if (!new_dev_maps)
2369                         new_dev_maps = kzalloc(maps_sz, GFP_KERNEL);
2370                 if (!new_dev_maps) {
2371                         mutex_unlock(&xps_map_mutex);
2372                         return -ENOMEM;
2373                 }
2374
2375                 tci = j * num_tc + tc;
2376                 map = dev_maps ? xmap_dereference(dev_maps->attr_map[tci]) :
2377                                  NULL;
2378
2379                 map = expand_xps_map(map, j, index, is_rxqs_map);
2380                 if (!map)
2381                         goto error;
2382
2383                 RCU_INIT_POINTER(new_dev_maps->attr_map[tci], map);
2384         }
2385
2386         if (!new_dev_maps)
2387                 goto out_no_new_maps;
2388
2389         if (!dev_maps) {
2390                 /* Increment static keys at most once per type */
2391                 static_key_slow_inc_cpuslocked(&xps_needed);
2392                 if (is_rxqs_map)
2393                         static_key_slow_inc_cpuslocked(&xps_rxqs_needed);
2394         }
2395
2396         for (j = -1; j = netif_attrmask_next(j, possible_mask, nr_ids),
2397              j < nr_ids;) {
2398                 /* copy maps belonging to foreign traffic classes */
2399                 for (i = tc, tci = j * num_tc; dev_maps && i--; tci++) {
2400                         /* fill in the new device map from the old device map */
2401                         map = xmap_dereference(dev_maps->attr_map[tci]);
2402                         RCU_INIT_POINTER(new_dev_maps->attr_map[tci], map);
2403                 }
2404
2405                 /* We need to explicitly update tci as prevous loop
2406                  * could break out early if dev_maps is NULL.
2407                  */
2408                 tci = j * num_tc + tc;
2409
2410                 if (netif_attr_test_mask(j, mask, nr_ids) &&
2411                     netif_attr_test_online(j, online_mask, nr_ids)) {
2412                         /* add tx-queue to CPU/rx-queue maps */
2413                         int pos = 0;
2414
2415                         map = xmap_dereference(new_dev_maps->attr_map[tci]);
2416                         while ((pos < map->len) && (map->queues[pos] != index))
2417                                 pos++;
2418
2419                         if (pos == map->len)
2420                                 map->queues[map->len++] = index;
2421 #ifdef CONFIG_NUMA
2422                         if (!is_rxqs_map) {
2423                                 if (numa_node_id == -2)
2424                                         numa_node_id = cpu_to_node(j);
2425                                 else if (numa_node_id != cpu_to_node(j))
2426                                         numa_node_id = -1;
2427                         }
2428 #endif
2429                 } else if (dev_maps) {
2430                         /* fill in the new device map from the old device map */
2431                         map = xmap_dereference(dev_maps->attr_map[tci]);
2432                         RCU_INIT_POINTER(new_dev_maps->attr_map[tci], map);
2433                 }
2434
2435                 /* copy maps belonging to foreign traffic classes */
2436                 for (i = num_tc - tc, tci++; dev_maps && --i; tci++) {
2437                         /* fill in the new device map from the old device map */
2438                         map = xmap_dereference(dev_maps->attr_map[tci]);
2439                         RCU_INIT_POINTER(new_dev_maps->attr_map[tci], map);
2440                 }
2441         }
2442
2443         if (is_rxqs_map)
2444                 rcu_assign_pointer(dev->xps_rxqs_map, new_dev_maps);
2445         else
2446                 rcu_assign_pointer(dev->xps_cpus_map, new_dev_maps);
2447
2448         /* Cleanup old maps */
2449         if (!dev_maps)
2450                 goto out_no_old_maps;
2451
2452         for (j = -1; j = netif_attrmask_next(j, possible_mask, nr_ids),
2453              j < nr_ids;) {
2454                 for (i = num_tc, tci = j * num_tc; i--; tci++) {
2455                         new_map = xmap_dereference(new_dev_maps->attr_map[tci]);
2456                         map = xmap_dereference(dev_maps->attr_map[tci]);
2457                         if (map && map != new_map)
2458                                 kfree_rcu(map, rcu);
2459                 }
2460         }
2461
2462         kfree_rcu(dev_maps, rcu);
2463
2464 out_no_old_maps:
2465         dev_maps = new_dev_maps;
2466         active = true;
2467
2468 out_no_new_maps:
2469         if (!is_rxqs_map) {
2470                 /* update Tx queue numa node */
2471                 netdev_queue_numa_node_write(netdev_get_tx_queue(dev, index),
2472                                              (numa_node_id >= 0) ?
2473                                              numa_node_id : NUMA_NO_NODE);
2474         }
2475
2476         if (!dev_maps)
2477                 goto out_no_maps;
2478
2479         /* removes tx-queue from unused CPUs/rx-queues */
2480         for (j = -1; j = netif_attrmask_next(j, possible_mask, nr_ids),
2481              j < nr_ids;) {
2482                 for (i = tc, tci = j * num_tc; i--; tci++)
2483                         active |= remove_xps_queue(dev_maps, tci, index);
2484                 if (!netif_attr_test_mask(j, mask, nr_ids) ||
2485                     !netif_attr_test_online(j, online_mask, nr_ids))
2486                         active |= remove_xps_queue(dev_maps, tci, index);
2487                 for (i = num_tc - tc, tci++; --i; tci++)
2488                         active |= remove_xps_queue(dev_maps, tci, index);
2489         }
2490
2491         /* free map if not active */
2492         if (!active)
2493                 reset_xps_maps(dev, dev_maps, is_rxqs_map);
2494
2495 out_no_maps:
2496         mutex_unlock(&xps_map_mutex);
2497
2498         return 0;
2499 error:
2500         /* remove any maps that we added */
2501         for (j = -1; j = netif_attrmask_next(j, possible_mask, nr_ids),
2502              j < nr_ids;) {
2503                 for (i = num_tc, tci = j * num_tc; i--; tci++) {
2504                         new_map = xmap_dereference(new_dev_maps->attr_map[tci]);
2505                         map = dev_maps ?
2506                               xmap_dereference(dev_maps->attr_map[tci]) :
2507                               NULL;
2508                         if (new_map && new_map != map)
2509                                 kfree(new_map);
2510                 }
2511         }
2512
2513         mutex_unlock(&xps_map_mutex);
2514
2515         kfree(new_dev_maps);
2516         return -ENOMEM;
2517 }
2518 EXPORT_SYMBOL_GPL(__netif_set_xps_queue);
2519
2520 int netif_set_xps_queue(struct net_device *dev, const struct cpumask *mask,
2521                         u16 index)
2522 {
2523         int ret;
2524
2525         cpus_read_lock();
2526         ret =  __netif_set_xps_queue(dev, cpumask_bits(mask), index, false);
2527         cpus_read_unlock();
2528
2529         return ret;
2530 }
2531 EXPORT_SYMBOL(netif_set_xps_queue);
2532
2533 #endif
2534 static void netdev_unbind_all_sb_channels(struct net_device *dev)
2535 {
2536         struct netdev_queue *txq = &dev->_tx[dev->num_tx_queues];
2537
2538         /* Unbind any subordinate channels */
2539         while (txq-- != &dev->_tx[0]) {
2540                 if (txq->sb_dev)
2541                         netdev_unbind_sb_channel(dev, txq->sb_dev);
2542         }
2543 }
2544
2545 void netdev_reset_tc(struct net_device *dev)
2546 {
2547 #ifdef CONFIG_XPS
2548         netif_reset_xps_queues_gt(dev, 0);
2549 #endif
2550         netdev_unbind_all_sb_channels(dev);
2551
2552         /* Reset TC configuration of device */
2553         dev->num_tc = 0;
2554         memset(dev->tc_to_txq, 0, sizeof(dev->tc_to_txq));
2555         memset(dev->prio_tc_map, 0, sizeof(dev->prio_tc_map));
2556 }
2557 EXPORT_SYMBOL(netdev_reset_tc);
2558
2559 int netdev_set_tc_queue(struct net_device *dev, u8 tc, u16 count, u16 offset)
2560 {
2561         if (tc >= dev->num_tc)
2562                 return -EINVAL;
2563
2564 #ifdef CONFIG_XPS
2565         netif_reset_xps_queues(dev, offset, count);
2566 #endif
2567         dev->tc_to_txq[tc].count = count;
2568         dev->tc_to_txq[tc].offset = offset;
2569         return 0;
2570 }
2571 EXPORT_SYMBOL(netdev_set_tc_queue);
2572
2573 int netdev_set_num_tc(struct net_device *dev, u8 num_tc)
2574 {
2575         if (num_tc > TC_MAX_QUEUE)
2576                 return -EINVAL;
2577
2578 #ifdef CONFIG_XPS
2579         netif_reset_xps_queues_gt(dev, 0);
2580 #endif
2581         netdev_unbind_all_sb_channels(dev);
2582
2583         dev->num_tc = num_tc;
2584         return 0;
2585 }
2586 EXPORT_SYMBOL(netdev_set_num_tc);
2587
2588 void netdev_unbind_sb_channel(struct net_device *dev,
2589                               struct net_device *sb_dev)
2590 {
2591         struct netdev_queue *txq = &dev->_tx[dev->num_tx_queues];
2592
2593 #ifdef CONFIG_XPS
2594         netif_reset_xps_queues_gt(sb_dev, 0);
2595 #endif
2596         memset(sb_dev->tc_to_txq, 0, sizeof(sb_dev->tc_to_txq));
2597         memset(sb_dev->prio_tc_map, 0, sizeof(sb_dev->prio_tc_map));
2598
2599         while (txq-- != &dev->_tx[0]) {
2600                 if (txq->sb_dev == sb_dev)
2601                         txq->sb_dev = NULL;
2602         }
2603 }
2604 EXPORT_SYMBOL(netdev_unbind_sb_channel);
2605
2606 int netdev_bind_sb_channel_queue(struct net_device *dev,
2607                                  struct net_device *sb_dev,
2608                                  u8 tc, u16 count, u16 offset)
2609 {
2610         /* Make certain the sb_dev and dev are already configured */
2611         if (sb_dev->num_tc >= 0 || tc >= dev->num_tc)
2612                 return -EINVAL;
2613
2614         /* We cannot hand out queues we don't have */
2615         if ((offset + count) > dev->real_num_tx_queues)
2616                 return -EINVAL;
2617
2618         /* Record the mapping */
2619         sb_dev->tc_to_txq[tc].count = count;
2620         sb_dev->tc_to_txq[tc].offset = offset;
2621
2622         /* Provide a way for Tx queue to find the tc_to_txq map or
2623          * XPS map for itself.
2624          */
2625         while (count--)
2626                 netdev_get_tx_queue(dev, count + offset)->sb_dev = sb_dev;
2627
2628         return 0;
2629 }
2630 EXPORT_SYMBOL(netdev_bind_sb_channel_queue);
2631
2632 int netdev_set_sb_channel(struct net_device *dev, u16 channel)
2633 {
2634         /* Do not use a multiqueue device to represent a subordinate channel */
2635         if (netif_is_multiqueue(dev))
2636                 return -ENODEV;
2637
2638         /* We allow channels 1 - 32767 to be used for subordinate channels.
2639          * Channel 0 is meant to be "native" mode and used only to represent
2640          * the main root device. We allow writing 0 to reset the device back
2641          * to normal mode after being used as a subordinate channel.
2642          */
2643         if (channel > S16_MAX)
2644                 return -EINVAL;
2645
2646         dev->num_tc = -channel;
2647
2648         return 0;
2649 }
2650 EXPORT_SYMBOL(netdev_set_sb_channel);
2651
2652 /*
2653  * Routine to help set real_num_tx_queues. To avoid skbs mapped to queues
2654  * greater than real_num_tx_queues stale skbs on the qdisc must be flushed.
2655  */
2656 int netif_set_real_num_tx_queues(struct net_device *dev, unsigned int txq)
2657 {
2658         bool disabling;
2659         int rc;
2660
2661         disabling = txq < dev->real_num_tx_queues;
2662
2663         if (txq < 1 || txq > dev->num_tx_queues)
2664                 return -EINVAL;
2665
2666         if (dev->reg_state == NETREG_REGISTERED ||
2667             dev->reg_state == NETREG_UNREGISTERING) {
2668                 ASSERT_RTNL();
2669
2670                 rc = netdev_queue_update_kobjects(dev, dev->real_num_tx_queues,
2671                                                   txq);
2672                 if (rc)
2673                         return rc;
2674
2675                 if (dev->num_tc)
2676                         netif_setup_tc(dev, txq);
2677
2678                 dev->real_num_tx_queues = txq;
2679
2680                 if (disabling) {
2681                         synchronize_net();
2682                         qdisc_reset_all_tx_gt(dev, txq);
2683 #ifdef CONFIG_XPS
2684                         netif_reset_xps_queues_gt(dev, txq);
2685 #endif
2686                 }
2687         } else {
2688                 dev->real_num_tx_queues = txq;
2689         }
2690
2691         return 0;
2692 }
2693 EXPORT_SYMBOL(netif_set_real_num_tx_queues);
2694
2695 #ifdef CONFIG_SYSFS
2696 /**
2697  *      netif_set_real_num_rx_queues - set actual number of RX queues used
2698  *      @dev: Network device
2699  *      @rxq: Actual number of RX queues
2700  *
2701  *      This must be called either with the rtnl_lock held or before
2702  *      registration of the net device.  Returns 0 on success, or a
2703  *      negative error code.  If called before registration, it always
2704  *      succeeds.
2705  */
2706 int netif_set_real_num_rx_queues(struct net_device *dev, unsigned int rxq)
2707 {
2708         int rc;
2709
2710         if (rxq < 1 || rxq > dev->num_rx_queues)
2711                 return -EINVAL;
2712
2713         if (dev->reg_state == NETREG_REGISTERED) {
2714                 ASSERT_RTNL();
2715
2716                 rc = net_rx_queue_update_kobjects(dev, dev->real_num_rx_queues,
2717                                                   rxq);
2718                 if (rc)
2719                         return rc;
2720         }
2721
2722         dev->real_num_rx_queues = rxq;
2723         return 0;
2724 }
2725 EXPORT_SYMBOL(netif_set_real_num_rx_queues);
2726 #endif
2727
2728 /**
2729  * netif_get_num_default_rss_queues - default number of RSS queues
2730  *
2731  * This routine should set an upper limit on the number of RSS queues
2732  * used by default by multiqueue devices.
2733  */
2734 int netif_get_num_default_rss_queues(void)
2735 {
2736         return is_kdump_kernel() ?
2737                 1 : min_t(int, DEFAULT_MAX_NUM_RSS_QUEUES, num_online_cpus());
2738 }
2739 EXPORT_SYMBOL(netif_get_num_default_rss_queues);
2740
2741 static void __netif_reschedule(struct Qdisc *q)
2742 {
2743         struct softnet_data *sd;
2744         unsigned long flags;
2745
2746         local_irq_save(flags);
2747         sd = this_cpu_ptr(&softnet_data);
2748         q->next_sched = NULL;
2749         *sd->output_queue_tailp = q;
2750         sd->output_queue_tailp = &q->next_sched;
2751         raise_softirq_irqoff(NET_TX_SOFTIRQ);
2752         local_irq_restore(flags);
2753 }
2754
2755 void __netif_schedule(struct Qdisc *q)
2756 {
2757         if (!test_and_set_bit(__QDISC_STATE_SCHED, &q->state))
2758                 __netif_reschedule(q);
2759 }
2760 EXPORT_SYMBOL(__netif_schedule);
2761
2762 struct dev_kfree_skb_cb {
2763         enum skb_free_reason reason;
2764 };
2765
2766 static struct dev_kfree_skb_cb *get_kfree_skb_cb(const struct sk_buff *skb)
2767 {
2768         return (struct dev_kfree_skb_cb *)skb->cb;
2769 }
2770
2771 void netif_schedule_queue(struct netdev_queue *txq)
2772 {
2773         rcu_read_lock();
2774         if (!(txq->state & QUEUE_STATE_ANY_XOFF)) {
2775                 struct Qdisc *q = rcu_dereference(txq->qdisc);
2776
2777                 __netif_schedule(q);
2778         }
2779         rcu_read_unlock();
2780 }
2781 EXPORT_SYMBOL(netif_schedule_queue);
2782
2783 void netif_tx_wake_queue(struct netdev_queue *dev_queue)
2784 {
2785         if (test_and_clear_bit(__QUEUE_STATE_DRV_XOFF, &dev_queue->state)) {
2786                 struct Qdisc *q;
2787
2788                 rcu_read_lock();
2789                 q = rcu_dereference(dev_queue->qdisc);
2790                 __netif_schedule(q);
2791                 rcu_read_unlock();
2792         }
2793 }
2794 EXPORT_SYMBOL(netif_tx_wake_queue);
2795
2796 void __dev_kfree_skb_irq(struct sk_buff *skb, enum skb_free_reason reason)
2797 {
2798         unsigned long flags;
2799
2800         if (unlikely(!skb))
2801                 return;
2802
2803         if (likely(refcount_read(&skb->users) == 1)) {
2804                 smp_rmb();
2805                 refcount_set(&skb->users, 0);
2806         } else if (likely(!refcount_dec_and_test(&skb->users))) {
2807                 return;
2808         }
2809         get_kfree_skb_cb(skb)->reason = reason;
2810         local_irq_save(flags);
2811         skb->next = __this_cpu_read(softnet_data.completion_queue);
2812         __this_cpu_write(softnet_data.completion_queue, skb);
2813         raise_softirq_irqoff(NET_TX_SOFTIRQ);
2814         local_irq_restore(flags);
2815 }
2816 EXPORT_SYMBOL(__dev_kfree_skb_irq);
2817
2818 void __dev_kfree_skb_any(struct sk_buff *skb, enum skb_free_reason reason)
2819 {
2820         if (in_irq() || irqs_disabled())
2821                 __dev_kfree_skb_irq(skb, reason);
2822         else
2823                 dev_kfree_skb(skb);
2824 }
2825 EXPORT_SYMBOL(__dev_kfree_skb_any);
2826
2827
2828 /**
2829  * netif_device_detach - mark device as removed
2830  * @dev: network device
2831  *
2832  * Mark device as removed from system and therefore no longer available.
2833  */
2834 void netif_device_detach(struct net_device *dev)
2835 {
2836         if (test_and_clear_bit(__LINK_STATE_PRESENT, &dev->state) &&
2837             netif_running(dev)) {
2838                 netif_tx_stop_all_queues(dev);
2839         }
2840 }
2841 EXPORT_SYMBOL(netif_device_detach);
2842
2843 /**
2844  * netif_device_attach - mark device as attached
2845  * @dev: network device
2846  *
2847  * Mark device as attached from system and restart if needed.
2848  */
2849 void netif_device_attach(struct net_device *dev)
2850 {
2851         if (!test_and_set_bit(__LINK_STATE_PRESENT, &dev->state) &&
2852             netif_running(dev)) {
2853                 netif_tx_wake_all_queues(dev);
2854                 __netdev_watchdog_up(dev);
2855         }
2856 }
2857 EXPORT_SYMBOL(netif_device_attach);
2858
2859 /*
2860  * Returns a Tx hash based on the given packet descriptor a Tx queues' number
2861  * to be used as a distribution range.
2862  */
2863 static u16 skb_tx_hash(const struct net_device *dev,
2864                        const struct net_device *sb_dev,
2865                        struct sk_buff *skb)
2866 {
2867         u32 hash;
2868         u16 qoffset = 0;
2869         u16 qcount = dev->real_num_tx_queues;
2870
2871         if (dev->num_tc) {
2872                 u8 tc = netdev_get_prio_tc_map(dev, skb->priority);
2873
2874                 qoffset = sb_dev->tc_to_txq[tc].offset;
2875                 qcount = sb_dev->tc_to_txq[tc].count;
2876         }
2877
2878         if (skb_rx_queue_recorded(skb)) {
2879                 hash = skb_get_rx_queue(skb);
2880                 while (unlikely(hash >= qcount))
2881                         hash -= qcount;
2882                 return hash + qoffset;
2883         }
2884
2885         return (u16) reciprocal_scale(skb_get_hash(skb), qcount) + qoffset;
2886 }
2887
2888 static void skb_warn_bad_offload(const struct sk_buff *skb)
2889 {
2890         static const netdev_features_t null_features;
2891         struct net_device *dev = skb->dev;
2892         const char *name = "";
2893
2894         if (!net_ratelimit())
2895                 return;
2896
2897         if (dev) {
2898                 if (dev->dev.parent)
2899                         name = dev_driver_string(dev->dev.parent);
2900                 else
2901                         name = netdev_name(dev);
2902         }
2903         skb_dump(KERN_WARNING, skb, false);
2904         WARN(1, "%s: caps=(%pNF, %pNF)\n",
2905              name, dev ? &dev->features : &null_features,
2906              skb->sk ? &skb->sk->sk_route_caps : &null_features);
2907 }
2908
2909 /*
2910  * Invalidate hardware checksum when packet is to be mangled, and
2911  * complete checksum manually on outgoing path.
2912  */
2913 int skb_checksum_help(struct sk_buff *skb)
2914 {
2915         __wsum csum;
2916         int ret = 0, offset;
2917
2918         if (skb->ip_summed == CHECKSUM_COMPLETE)
2919                 goto out_set_summed;
2920
2921         if (unlikely(skb_shinfo(skb)->gso_size)) {
2922                 skb_warn_bad_offload(skb);
2923                 return -EINVAL;
2924         }
2925
2926         /* Before computing a checksum, we should make sure no frag could
2927          * be modified by an external entity : checksum could be wrong.
2928          */
2929         if (skb_has_shared_frag(skb)) {
2930                 ret = __skb_linearize(skb);
2931                 if (ret)
2932                         goto out;
2933         }
2934
2935         offset = skb_checksum_start_offset(skb);
2936         BUG_ON(offset >= skb_headlen(skb));
2937         csum = skb_checksum(skb, offset, skb->len - offset, 0);
2938
2939         offset += skb->csum_offset;
2940         BUG_ON(offset + sizeof(__sum16) > skb_headlen(skb));
2941
2942         if (skb_cloned(skb) &&
2943             !skb_clone_writable(skb, offset + sizeof(__sum16))) {
2944                 ret = pskb_expand_head(skb, 0, 0, GFP_ATOMIC);
2945                 if (ret)
2946                         goto out;
2947         }
2948
2949         *(__sum16 *)(skb->data + offset) = csum_fold(csum) ?: CSUM_MANGLED_0;
2950 out_set_summed:
2951         skb->ip_summed = CHECKSUM_NONE;
2952 out:
2953         return ret;
2954 }
2955 EXPORT_SYMBOL(skb_checksum_help);
2956
2957 int skb_crc32c_csum_help(struct sk_buff *skb)
2958 {
2959         __le32 crc32c_csum;
2960         int ret = 0, offset, start;
2961
2962         if (skb->ip_summed != CHECKSUM_PARTIAL)
2963                 goto out;
2964
2965         if (unlikely(skb_is_gso(skb)))
2966                 goto out;
2967
2968         /* Before computing a checksum, we should make sure no frag could
2969          * be modified by an external entity : checksum could be wrong.
2970          */
2971         if (unlikely(skb_has_shared_frag(skb))) {
2972                 ret = __skb_linearize(skb);
2973                 if (ret)
2974                         goto out;
2975         }
2976         start = skb_checksum_start_offset(skb);
2977         offset = start + offsetof(struct sctphdr, checksum);
2978         if (WARN_ON_ONCE(offset >= skb_headlen(skb))) {
2979                 ret = -EINVAL;
2980                 goto out;
2981         }
2982         if (skb_cloned(skb) &&
2983             !skb_clone_writable(skb, offset + sizeof(__le32))) {
2984                 ret = pskb_expand_head(skb, 0, 0, GFP_ATOMIC);
2985                 if (ret)
2986                         goto out;
2987         }
2988         crc32c_csum = cpu_to_le32(~__skb_checksum(skb, start,
2989                                                   skb->len - start, ~(__u32)0,
2990                                                   crc32c_csum_stub));
2991         *(__le32 *)(skb->data + offset) = crc32c_csum;
2992         skb->ip_summed = CHECKSUM_NONE;
2993         skb->csum_not_inet = 0;
2994 out:
2995         return ret;
2996 }
2997
2998 __be16 skb_network_protocol(struct sk_buff *skb, int *depth)
2999 {
3000         __be16 type = skb->protocol;
3001
3002         /* Tunnel gso handlers can set protocol to ethernet. */
3003         if (type == htons(ETH_P_TEB)) {
3004                 struct ethhdr *eth;
3005
3006                 if (unlikely(!pskb_may_pull(skb, sizeof(struct ethhdr))))
3007                         return 0;
3008
3009                 eth = (struct ethhdr *)skb->data;
3010                 type = eth->h_proto;
3011         }
3012
3013         return __vlan_get_protocol(skb, type, depth);
3014 }
3015
3016 /**
3017  *      skb_mac_gso_segment - mac layer segmentation handler.
3018  *      @skb: buffer to segment
3019  *      @features: features for the output path (see dev->features)
3020  */
3021 struct sk_buff *skb_mac_gso_segment(struct sk_buff *skb,
3022                                     netdev_features_t features)
3023 {
3024         struct sk_buff *segs = ERR_PTR(-EPROTONOSUPPORT);
3025         struct packet_offload *ptype;
3026         int vlan_depth = skb->mac_len;
3027         __be16 type = skb_network_protocol(skb, &vlan_depth);
3028
3029         if (unlikely(!type))
3030                 return ERR_PTR(-EINVAL);
3031
3032         __skb_pull(skb, vlan_depth);
3033
3034         rcu_read_lock();
3035         list_for_each_entry_rcu(ptype, &offload_base, list) {
3036                 if (ptype->type == type && ptype->callbacks.gso_segment) {
3037                         segs = ptype->callbacks.gso_segment(skb, features);
3038                         break;
3039                 }
3040         }
3041         rcu_read_unlock();
3042
3043         __skb_push(skb, skb->data - skb_mac_header(skb));
3044
3045         return segs;
3046 }
3047 EXPORT_SYMBOL(skb_mac_gso_segment);
3048
3049
3050 /* openvswitch calls this on rx path, so we need a different check.
3051  */
3052 static inline bool skb_needs_check(struct sk_buff *skb, bool tx_path)
3053 {
3054         if (tx_path)
3055                 return skb->ip_summed != CHECKSUM_PARTIAL &&
3056                        skb->ip_summed != CHECKSUM_UNNECESSARY;
3057
3058         return skb->ip_summed == CHECKSUM_NONE;
3059 }
3060
3061 /**
3062  *      __skb_gso_segment - Perform segmentation on skb.
3063  *      @skb: buffer to segment
3064  *      @features: features for the output path (see dev->features)
3065  *      @tx_path: whether it is called in TX path
3066  *
3067  *      This function segments the given skb and returns a list of segments.
3068  *
3069  *      It may return NULL if the skb requires no segmentation.  This is
3070  *      only possible when GSO is used for verifying header integrity.
3071  *
3072  *      Segmentation preserves SKB_SGO_CB_OFFSET bytes of previous skb cb.
3073  */
3074 struct sk_buff *__skb_gso_segment(struct sk_buff *skb,
3075                                   netdev_features_t features, bool tx_path)
3076 {
3077         struct sk_buff *segs;
3078
3079         if (unlikely(skb_needs_check(skb, tx_path))) {
3080                 int err;
3081
3082                 /* We're going to init ->check field in TCP or UDP header */
3083                 err = skb_cow_head(skb, 0);
3084                 if (err < 0)
3085                         return ERR_PTR(err);
3086         }
3087
3088         /* Only report GSO partial support if it will enable us to
3089          * support segmentation on this frame without needing additional
3090          * work.
3091          */
3092         if (features & NETIF_F_GSO_PARTIAL) {
3093                 netdev_features_t partial_features = NETIF_F_GSO_ROBUST;
3094                 struct net_device *dev = skb->dev;
3095
3096                 partial_features |= dev->features & dev->gso_partial_features;
3097                 if (!skb_gso_ok(skb, features | partial_features))
3098                         features &= ~NETIF_F_GSO_PARTIAL;
3099         }
3100
3101         BUILD_BUG_ON(SKB_SGO_CB_OFFSET +
3102                      sizeof(*SKB_GSO_CB(skb)) > sizeof(skb->cb));
3103
3104         SKB_GSO_CB(skb)->mac_offset = skb_headroom(skb);
3105         SKB_GSO_CB(skb)->encap_level = 0;
3106
3107         skb_reset_mac_header(skb);
3108         skb_reset_mac_len(skb);
3109
3110         segs = skb_mac_gso_segment(skb, features);
3111
3112         if (unlikely(skb_needs_check(skb, tx_path) && !IS_ERR(segs)))
3113                 skb_warn_bad_offload(skb);
3114
3115         return segs;
3116 }
3117 EXPORT_SYMBOL(__skb_gso_segment);
3118
3119 /* Take action when hardware reception checksum errors are detected. */
3120 #ifdef CONFIG_BUG
3121 void netdev_rx_csum_fault(struct net_device *dev, struct sk_buff *skb)
3122 {
3123         if (net_ratelimit()) {
3124                 pr_err("%s: hw csum failure\n", dev ? dev->name : "<unknown>");
3125                 skb_dump(KERN_ERR, skb, true);
3126                 dump_stack();
3127         }
3128 }
3129 EXPORT_SYMBOL(netdev_rx_csum_fault);
3130 #endif
3131
3132 /* XXX: check that highmem exists at all on the given machine. */
3133 static int illegal_highdma(struct net_device *dev, struct sk_buff *skb)
3134 {
3135 #ifdef CONFIG_HIGHMEM
3136         int i;
3137
3138         if (!(dev->features & NETIF_F_HIGHDMA)) {
3139                 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
3140                         skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
3141
3142                         if (PageHighMem(skb_frag_page(frag)))
3143                                 return 1;
3144                 }
3145         }
3146 #endif
3147         return 0;
3148 }
3149
3150 /* If MPLS offload request, verify we are testing hardware MPLS features
3151  * instead of standard features for the netdev.
3152  */
3153 #if IS_ENABLED(CONFIG_NET_MPLS_GSO)
3154 static netdev_features_t net_mpls_features(struct sk_buff *skb,
3155                                            netdev_features_t features,
3156                                            __be16 type)
3157 {
3158         if (eth_p_mpls(type))
3159                 features &= skb->dev->mpls_features;
3160
3161         return features;
3162 }
3163 #else
3164 static netdev_features_t net_mpls_features(struct sk_buff *skb,
3165                                            netdev_features_t features,
3166                                            __be16 type)
3167 {
3168         return features;
3169 }
3170 #endif
3171
3172 static netdev_features_t harmonize_features(struct sk_buff *skb,
3173         netdev_features_t features)
3174 {
3175         int tmp;
3176         __be16 type;
3177
3178         type = skb_network_protocol(skb, &tmp);
3179         features = net_mpls_features(skb, features, type);
3180
3181         if (skb->ip_summed != CHECKSUM_NONE &&
3182             !can_checksum_protocol(features, type)) {
3183                 features &= ~(NETIF_F_CSUM_MASK | NETIF_F_GSO_MASK);
3184         }
3185         if (illegal_highdma(skb->dev, skb))
3186                 features &= ~NETIF_F_SG;
3187
3188         return features;
3189 }
3190
3191 netdev_features_t passthru_features_check(struct sk_buff *skb,
3192                                           struct net_device *dev,
3193                                           netdev_features_t features)
3194 {
3195         return features;
3196 }
3197 EXPORT_SYMBOL(passthru_features_check);
3198
3199 static netdev_features_t dflt_features_check(struct sk_buff *skb,
3200                                              struct net_device *dev,
3201                                              netdev_features_t features)
3202 {
3203         return vlan_features_check(skb, features);
3204 }
3205
3206 static netdev_features_t gso_features_check(const struct sk_buff *skb,
3207                                             struct net_device *dev,
3208                                             netdev_features_t features)
3209 {
3210         u16 gso_segs = skb_shinfo(skb)->gso_segs;
3211
3212         if (gso_segs > dev->gso_max_segs)
3213                 return features & ~NETIF_F_GSO_MASK;
3214
3215         /* Support for GSO partial features requires software
3216          * intervention before we can actually process the packets
3217          * so we need to strip support for any partial features now
3218          * and we can pull them back in after we have partially
3219          * segmented the frame.
3220          */
3221         if (!(skb_shinfo(skb)->gso_type & SKB_GSO_PARTIAL))
3222                 features &= ~dev->gso_partial_features;
3223
3224         /* Make sure to clear the IPv4 ID mangling feature if the
3225          * IPv4 header has the potential to be fragmented.
3226          */
3227         if (skb_shinfo(skb)->gso_type & SKB_GSO_TCPV4) {
3228                 struct iphdr *iph = skb->encapsulation ?
3229                                     inner_ip_hdr(skb) : ip_hdr(skb);
3230
3231                 if (!(iph->frag_off & htons(IP_DF)))
3232                         features &= ~NETIF_F_TSO_MANGLEID;
3233         }
3234
3235         return features;
3236 }
3237
3238 netdev_features_t netif_skb_features(struct sk_buff *skb)
3239 {
3240         struct net_device *dev = skb->dev;
3241         netdev_features_t features = dev->features;
3242
3243         if (skb_is_gso(skb))
3244                 features = gso_features_check(skb, dev, features);
3245
3246         /* If encapsulation offload request, verify we are testing
3247          * hardware encapsulation features instead of standard
3248          * features for the netdev
3249          */
3250         if (skb->encapsulation)
3251                 features &= dev->hw_enc_features;
3252
3253         if (skb_vlan_tagged(skb))
3254                 features = netdev_intersect_features(features,
3255                                                      dev->vlan_features |
3256                                                      NETIF_F_HW_VLAN_CTAG_TX |
3257                                                      NETIF_F_HW_VLAN_STAG_TX);
3258
3259         if (dev->netdev_ops->ndo_features_check)
3260                 features &= dev->netdev_ops->ndo_features_check(skb, dev,
3261                                                                 features);
3262         else
3263                 features &= dflt_features_check(skb, dev, features);
3264
3265         return harmonize_features(skb, features);
3266 }
3267 EXPORT_SYMBOL(netif_skb_features);
3268
3269 static int xmit_one(struct sk_buff *skb, struct net_device *dev,
3270                     struct netdev_queue *txq, bool more)
3271 {
3272         unsigned int len;
3273         int rc;
3274
3275         if (dev_nit_active(dev))
3276                 dev_queue_xmit_nit(skb, dev);
3277
3278         len = skb->len;
3279         trace_net_dev_start_xmit(skb, dev);
3280         rc = netdev_start_xmit(skb, dev, txq, more);
3281         trace_net_dev_xmit(skb, rc, dev, len);
3282
3283         return rc;
3284 }
3285
3286 struct sk_buff *dev_hard_start_xmit(struct sk_buff *first, struct net_device *dev,
3287                                     struct netdev_queue *txq, int *ret)
3288 {
3289         struct sk_buff *skb = first;
3290         int rc = NETDEV_TX_OK;
3291
3292         while (skb) {
3293                 struct sk_buff *next = skb->next;
3294
3295                 skb_mark_not_on_list(skb);
3296                 rc = xmit_one(skb, dev, txq, next != NULL);
3297                 if (unlikely(!dev_xmit_complete(rc))) {
3298                         skb->next = next;
3299                         goto out;
3300                 }
3301
3302                 skb = next;
3303                 if (netif_tx_queue_stopped(txq) && skb) {
3304                         rc = NETDEV_TX_BUSY;
3305                         break;
3306                 }
3307         }
3308
3309 out:
3310         *ret = rc;
3311         return skb;
3312 }
3313
3314 static struct sk_buff *validate_xmit_vlan(struct sk_buff *skb,
3315                                           netdev_features_t features)
3316 {
3317         if (skb_vlan_tag_present(skb) &&
3318             !vlan_hw_offload_capable(features, skb->vlan_proto))
3319                 skb = __vlan_hwaccel_push_inside(skb);
3320         return skb;
3321 }
3322
3323 int skb_csum_hwoffload_help(struct sk_buff *skb,
3324                             const netdev_features_t features)
3325 {
3326         if (unlikely(skb->csum_not_inet))
3327                 return !!(features & NETIF_F_SCTP_CRC) ? 0 :
3328                         skb_crc32c_csum_help(skb);
3329
3330         return !!(features & NETIF_F_CSUM_MASK) ? 0 : skb_checksum_help(skb);
3331 }
3332 EXPORT_SYMBOL(skb_csum_hwoffload_help);
3333
3334 static struct sk_buff *validate_xmit_skb(struct sk_buff *skb, struct net_device *dev, bool *again)
3335 {
3336         netdev_features_t features;
3337
3338         features = netif_skb_features(skb);
3339         skb = validate_xmit_vlan(skb, features);
3340         if (unlikely(!skb))
3341                 goto out_null;
3342
3343         skb = sk_validate_xmit_skb(skb, dev);
3344         if (unlikely(!skb))
3345                 goto out_null;
3346
3347         if (netif_needs_gso(skb, features)) {
3348                 struct sk_buff *segs;
3349
3350                 segs = skb_gso_segment(skb, features);
3351                 if (IS_ERR(segs)) {
3352                         goto out_kfree_skb;
3353                 } else if (segs) {
3354                         consume_skb(skb);
3355                         skb = segs;
3356                 }
3357         } else {
3358                 if (skb_needs_linearize(skb, features) &&
3359                     __skb_linearize(skb))
3360                         goto out_kfree_skb;
3361
3362                 /* If packet is not checksummed and device does not
3363                  * support checksumming for this protocol, complete
3364                  * checksumming here.
3365                  */
3366                 if (skb->ip_summed == CHECKSUM_PARTIAL) {
3367                         if (skb->encapsulation)
3368                                 skb_set_inner_transport_header(skb,
3369                                                                skb_checksum_start_offset(skb));
3370                         else
3371                                 skb_set_transport_header(skb,
3372                                                          skb_checksum_start_offset(skb));
3373                         if (skb_csum_hwoffload_help(skb, features))
3374                                 goto out_kfree_skb;
3375                 }
3376         }
3377
3378         skb = validate_xmit_xfrm(skb, features, again);
3379
3380         return skb;
3381
3382 out_kfree_skb:
3383         kfree_skb(skb);
3384 out_null:
3385         atomic_long_inc(&dev->tx_dropped);
3386         return NULL;
3387 }
3388
3389 struct sk_buff *validate_xmit_skb_list(struct sk_buff *skb, struct net_device *dev, bool *again)
3390 {
3391         struct sk_buff *next, *head = NULL, *tail;
3392
3393         for (; skb != NULL; skb = next) {
3394                 next = skb->next;
3395                 skb_mark_not_on_list(skb);
3396
3397                 /* in case skb wont be segmented, point to itself */
3398                 skb->prev = skb;
3399
3400                 skb = validate_xmit_skb(skb, dev, again);
3401                 if (!skb)
3402                         continue;
3403
3404                 if (!head)
3405                         head = skb;
3406                 else
3407                         tail->next = skb;
3408                 /* If skb was segmented, skb->prev points to
3409                  * the last segment. If not, it still contains skb.
3410                  */
3411                 tail = skb->prev;
3412         }
3413         return head;
3414 }
3415 EXPORT_SYMBOL_GPL(validate_xmit_skb_list);
3416
3417 static void qdisc_pkt_len_init(struct sk_buff *skb)
3418 {
3419         const struct skb_shared_info *shinfo = skb_shinfo(skb);
3420
3421         qdisc_skb_cb(skb)->pkt_len = skb->len;
3422
3423         /* To get more precise estimation of bytes sent on wire,
3424          * we add to pkt_len the headers size of all segments
3425          */
3426         if (shinfo->gso_size && skb_transport_header_was_set(skb)) {
3427                 unsigned int hdr_len;
3428                 u16 gso_segs = shinfo->gso_segs;
3429
3430                 /* mac layer + network layer */
3431                 hdr_len = skb_transport_header(skb) - skb_mac_header(skb);
3432
3433                 /* + transport layer */
3434                 if (likely(shinfo->gso_type & (SKB_GSO_TCPV4 | SKB_GSO_TCPV6))) {
3435                         const struct tcphdr *th;
3436                         struct tcphdr _tcphdr;
3437
3438                         th = skb_header_pointer(skb, skb_transport_offset(skb),
3439                                                 sizeof(_tcphdr), &_tcphdr);
3440                         if (likely(th))
3441                                 hdr_len += __tcp_hdrlen(th