Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/net
[~shefty/rdma-dev.git] / net / core / dev.c
1 /*
2  *      NET3    Protocol independent device support routines.
3  *
4  *              This program is free software; you can redistribute it and/or
5  *              modify it under the terms of the GNU General Public License
6  *              as published by the Free Software Foundation; either version
7  *              2 of the License, or (at your option) any later version.
8  *
9  *      Derived from the non IP parts of dev.c 1.0.19
10  *              Authors:        Ross Biro
11  *                              Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
12  *                              Mark Evans, <evansmp@uhura.aston.ac.uk>
13  *
14  *      Additional Authors:
15  *              Florian la Roche <rzsfl@rz.uni-sb.de>
16  *              Alan Cox <gw4pts@gw4pts.ampr.org>
17  *              David Hinds <dahinds@users.sourceforge.net>
18  *              Alexey Kuznetsov <kuznet@ms2.inr.ac.ru>
19  *              Adam Sulmicki <adam@cfar.umd.edu>
20  *              Pekka Riikonen <priikone@poesidon.pspt.fi>
21  *
22  *      Changes:
23  *              D.J. Barrow     :       Fixed bug where dev->refcnt gets set
24  *                                      to 2 if register_netdev gets called
25  *                                      before net_dev_init & also removed a
26  *                                      few lines of code in the process.
27  *              Alan Cox        :       device private ioctl copies fields back.
28  *              Alan Cox        :       Transmit queue code does relevant
29  *                                      stunts to keep the queue safe.
30  *              Alan Cox        :       Fixed double lock.
31  *              Alan Cox        :       Fixed promisc NULL pointer trap
32  *              ????????        :       Support the full private ioctl range
33  *              Alan Cox        :       Moved ioctl permission check into
34  *                                      drivers
35  *              Tim Kordas      :       SIOCADDMULTI/SIOCDELMULTI
36  *              Alan Cox        :       100 backlog just doesn't cut it when
37  *                                      you start doing multicast video 8)
38  *              Alan Cox        :       Rewrote net_bh and list manager.
39  *              Alan Cox        :       Fix ETH_P_ALL echoback lengths.
40  *              Alan Cox        :       Took out transmit every packet pass
41  *                                      Saved a few bytes in the ioctl handler
42  *              Alan Cox        :       Network driver sets packet type before
43  *                                      calling netif_rx. Saves a function
44  *                                      call a packet.
45  *              Alan Cox        :       Hashed net_bh()
46  *              Richard Kooijman:       Timestamp fixes.
47  *              Alan Cox        :       Wrong field in SIOCGIFDSTADDR
48  *              Alan Cox        :       Device lock protection.
49  *              Alan Cox        :       Fixed nasty side effect of device close
50  *                                      changes.
51  *              Rudi Cilibrasi  :       Pass the right thing to
52  *                                      set_mac_address()
53  *              Dave Miller     :       32bit quantity for the device lock to
54  *                                      make it work out on a Sparc.
55  *              Bjorn Ekwall    :       Added KERNELD hack.
56  *              Alan Cox        :       Cleaned up the backlog initialise.
57  *              Craig Metz      :       SIOCGIFCONF fix if space for under
58  *                                      1 device.
59  *          Thomas Bogendoerfer :       Return ENODEV for dev_open, if there
60  *                                      is no device open function.
61  *              Andi Kleen      :       Fix error reporting for SIOCGIFCONF
62  *          Michael Chastain    :       Fix signed/unsigned for SIOCGIFCONF
63  *              Cyrus Durgin    :       Cleaned for KMOD
64  *              Adam Sulmicki   :       Bug Fix : Network Device Unload
65  *                                      A network device unload needs to purge
66  *                                      the backlog queue.
67  *      Paul Rusty Russell      :       SIOCSIFNAME
68  *              Pekka Riikonen  :       Netdev boot-time settings code
69  *              Andrew Morton   :       Make unregister_netdevice wait
70  *                                      indefinitely on dev->refcnt
71  *              J Hadi Salim    :       - Backlog queue sampling
72  *                                      - netif_rx() feedback
73  */
74
75 #include <asm/uaccess.h>
76 #include <linux/bitops.h>
77 #include <linux/capability.h>
78 #include <linux/cpu.h>
79 #include <linux/types.h>
80 #include <linux/kernel.h>
81 #include <linux/hash.h>
82 #include <linux/slab.h>
83 #include <linux/sched.h>
84 #include <linux/mutex.h>
85 #include <linux/string.h>
86 #include <linux/mm.h>
87 #include <linux/socket.h>
88 #include <linux/sockios.h>
89 #include <linux/errno.h>
90 #include <linux/interrupt.h>
91 #include <linux/if_ether.h>
92 #include <linux/netdevice.h>
93 #include <linux/etherdevice.h>
94 #include <linux/ethtool.h>
95 #include <linux/notifier.h>
96 #include <linux/skbuff.h>
97 #include <net/net_namespace.h>
98 #include <net/sock.h>
99 #include <linux/rtnetlink.h>
100 #include <linux/stat.h>
101 #include <net/dst.h>
102 #include <net/pkt_sched.h>
103 #include <net/checksum.h>
104 #include <net/xfrm.h>
105 #include <linux/highmem.h>
106 #include <linux/init.h>
107 #include <linux/module.h>
108 #include <linux/netpoll.h>
109 #include <linux/rcupdate.h>
110 #include <linux/delay.h>
111 #include <net/iw_handler.h>
112 #include <asm/current.h>
113 #include <linux/audit.h>
114 #include <linux/dmaengine.h>
115 #include <linux/err.h>
116 #include <linux/ctype.h>
117 #include <linux/if_arp.h>
118 #include <linux/if_vlan.h>
119 #include <linux/ip.h>
120 #include <net/ip.h>
121 #include <linux/ipv6.h>
122 #include <linux/in.h>
123 #include <linux/jhash.h>
124 #include <linux/random.h>
125 #include <trace/events/napi.h>
126 #include <trace/events/net.h>
127 #include <trace/events/skb.h>
128 #include <linux/pci.h>
129 #include <linux/inetdevice.h>
130 #include <linux/cpu_rmap.h>
131 #include <linux/static_key.h>
132
133 #include "net-sysfs.h"
134
135 /* Instead of increasing this, you should create a hash table. */
136 #define MAX_GRO_SKBS 8
137
138 /* This should be increased if a protocol with a bigger head is added. */
139 #define GRO_MAX_HEAD (MAX_HEADER + 128)
140
141 static DEFINE_SPINLOCK(ptype_lock);
142 static DEFINE_SPINLOCK(offload_lock);
143 struct list_head ptype_base[PTYPE_HASH_SIZE] __read_mostly;
144 struct list_head ptype_all __read_mostly;       /* Taps */
145 static struct list_head offload_base __read_mostly;
146
147 /*
148  * The @dev_base_head list is protected by @dev_base_lock and the rtnl
149  * semaphore.
150  *
151  * Pure readers hold dev_base_lock for reading, or rcu_read_lock()
152  *
153  * Writers must hold the rtnl semaphore while they loop through the
154  * dev_base_head list, and hold dev_base_lock for writing when they do the
155  * actual updates.  This allows pure readers to access the list even
156  * while a writer is preparing to update it.
157  *
158  * To put it another way, dev_base_lock is held for writing only to
159  * protect against pure readers; the rtnl semaphore provides the
160  * protection against other writers.
161  *
162  * See, for example usages, register_netdevice() and
163  * unregister_netdevice(), which must be called with the rtnl
164  * semaphore held.
165  */
166 DEFINE_RWLOCK(dev_base_lock);
167 EXPORT_SYMBOL(dev_base_lock);
168
169 seqcount_t devnet_rename_seq;
170
171 static inline void dev_base_seq_inc(struct net *net)
172 {
173         while (++net->dev_base_seq == 0);
174 }
175
176 static inline struct hlist_head *dev_name_hash(struct net *net, const char *name)
177 {
178         unsigned int hash = full_name_hash(name, strnlen(name, IFNAMSIZ));
179
180         return &net->dev_name_head[hash_32(hash, NETDEV_HASHBITS)];
181 }
182
183 static inline struct hlist_head *dev_index_hash(struct net *net, int ifindex)
184 {
185         return &net->dev_index_head[ifindex & (NETDEV_HASHENTRIES - 1)];
186 }
187
188 static inline void rps_lock(struct softnet_data *sd)
189 {
190 #ifdef CONFIG_RPS
191         spin_lock(&sd->input_pkt_queue.lock);
192 #endif
193 }
194
195 static inline void rps_unlock(struct softnet_data *sd)
196 {
197 #ifdef CONFIG_RPS
198         spin_unlock(&sd->input_pkt_queue.lock);
199 #endif
200 }
201
202 /* Device list insertion */
203 static int list_netdevice(struct net_device *dev)
204 {
205         struct net *net = dev_net(dev);
206
207         ASSERT_RTNL();
208
209         write_lock_bh(&dev_base_lock);
210         list_add_tail_rcu(&dev->dev_list, &net->dev_base_head);
211         hlist_add_head_rcu(&dev->name_hlist, dev_name_hash(net, dev->name));
212         hlist_add_head_rcu(&dev->index_hlist,
213                            dev_index_hash(net, dev->ifindex));
214         write_unlock_bh(&dev_base_lock);
215
216         dev_base_seq_inc(net);
217
218         return 0;
219 }
220
221 /* Device list removal
222  * caller must respect a RCU grace period before freeing/reusing dev
223  */
224 static void unlist_netdevice(struct net_device *dev)
225 {
226         ASSERT_RTNL();
227
228         /* Unlink dev from the device chain */
229         write_lock_bh(&dev_base_lock);
230         list_del_rcu(&dev->dev_list);
231         hlist_del_rcu(&dev->name_hlist);
232         hlist_del_rcu(&dev->index_hlist);
233         write_unlock_bh(&dev_base_lock);
234
235         dev_base_seq_inc(dev_net(dev));
236 }
237
238 /*
239  *      Our notifier list
240  */
241
242 static RAW_NOTIFIER_HEAD(netdev_chain);
243
244 /*
245  *      Device drivers call our routines to queue packets here. We empty the
246  *      queue in the local softnet handler.
247  */
248
249 DEFINE_PER_CPU_ALIGNED(struct softnet_data, softnet_data);
250 EXPORT_PER_CPU_SYMBOL(softnet_data);
251
252 #ifdef CONFIG_LOCKDEP
253 /*
254  * register_netdevice() inits txq->_xmit_lock and sets lockdep class
255  * according to dev->type
256  */
257 static const unsigned short netdev_lock_type[] =
258         {ARPHRD_NETROM, ARPHRD_ETHER, ARPHRD_EETHER, ARPHRD_AX25,
259          ARPHRD_PRONET, ARPHRD_CHAOS, ARPHRD_IEEE802, ARPHRD_ARCNET,
260          ARPHRD_APPLETLK, ARPHRD_DLCI, ARPHRD_ATM, ARPHRD_METRICOM,
261          ARPHRD_IEEE1394, ARPHRD_EUI64, ARPHRD_INFINIBAND, ARPHRD_SLIP,
262          ARPHRD_CSLIP, ARPHRD_SLIP6, ARPHRD_CSLIP6, ARPHRD_RSRVD,
263          ARPHRD_ADAPT, ARPHRD_ROSE, ARPHRD_X25, ARPHRD_HWX25,
264          ARPHRD_PPP, ARPHRD_CISCO, ARPHRD_LAPB, ARPHRD_DDCMP,
265          ARPHRD_RAWHDLC, ARPHRD_TUNNEL, ARPHRD_TUNNEL6, ARPHRD_FRAD,
266          ARPHRD_SKIP, ARPHRD_LOOPBACK, ARPHRD_LOCALTLK, ARPHRD_FDDI,
267          ARPHRD_BIF, ARPHRD_SIT, ARPHRD_IPDDP, ARPHRD_IPGRE,
268          ARPHRD_PIMREG, ARPHRD_HIPPI, ARPHRD_ASH, ARPHRD_ECONET,
269          ARPHRD_IRDA, ARPHRD_FCPP, ARPHRD_FCAL, ARPHRD_FCPL,
270          ARPHRD_FCFABRIC, ARPHRD_IEEE80211, ARPHRD_IEEE80211_PRISM,
271          ARPHRD_IEEE80211_RADIOTAP, ARPHRD_PHONET, ARPHRD_PHONET_PIPE,
272          ARPHRD_IEEE802154, ARPHRD_VOID, ARPHRD_NONE};
273
274 static const char *const netdev_lock_name[] =
275         {"_xmit_NETROM", "_xmit_ETHER", "_xmit_EETHER", "_xmit_AX25",
276          "_xmit_PRONET", "_xmit_CHAOS", "_xmit_IEEE802", "_xmit_ARCNET",
277          "_xmit_APPLETLK", "_xmit_DLCI", "_xmit_ATM", "_xmit_METRICOM",
278          "_xmit_IEEE1394", "_xmit_EUI64", "_xmit_INFINIBAND", "_xmit_SLIP",
279          "_xmit_CSLIP", "_xmit_SLIP6", "_xmit_CSLIP6", "_xmit_RSRVD",
280          "_xmit_ADAPT", "_xmit_ROSE", "_xmit_X25", "_xmit_HWX25",
281          "_xmit_PPP", "_xmit_CISCO", "_xmit_LAPB", "_xmit_DDCMP",
282          "_xmit_RAWHDLC", "_xmit_TUNNEL", "_xmit_TUNNEL6", "_xmit_FRAD",
283          "_xmit_SKIP", "_xmit_LOOPBACK", "_xmit_LOCALTLK", "_xmit_FDDI",
284          "_xmit_BIF", "_xmit_SIT", "_xmit_IPDDP", "_xmit_IPGRE",
285          "_xmit_PIMREG", "_xmit_HIPPI", "_xmit_ASH", "_xmit_ECONET",
286          "_xmit_IRDA", "_xmit_FCPP", "_xmit_FCAL", "_xmit_FCPL",
287          "_xmit_FCFABRIC", "_xmit_IEEE80211", "_xmit_IEEE80211_PRISM",
288          "_xmit_IEEE80211_RADIOTAP", "_xmit_PHONET", "_xmit_PHONET_PIPE",
289          "_xmit_IEEE802154", "_xmit_VOID", "_xmit_NONE"};
290
291 static struct lock_class_key netdev_xmit_lock_key[ARRAY_SIZE(netdev_lock_type)];
292 static struct lock_class_key netdev_addr_lock_key[ARRAY_SIZE(netdev_lock_type)];
293
294 static inline unsigned short netdev_lock_pos(unsigned short dev_type)
295 {
296         int i;
297
298         for (i = 0; i < ARRAY_SIZE(netdev_lock_type); i++)
299                 if (netdev_lock_type[i] == dev_type)
300                         return i;
301         /* the last key is used by default */
302         return ARRAY_SIZE(netdev_lock_type) - 1;
303 }
304
305 static inline void netdev_set_xmit_lockdep_class(spinlock_t *lock,
306                                                  unsigned short dev_type)
307 {
308         int i;
309
310         i = netdev_lock_pos(dev_type);
311         lockdep_set_class_and_name(lock, &netdev_xmit_lock_key[i],
312                                    netdev_lock_name[i]);
313 }
314
315 static inline void netdev_set_addr_lockdep_class(struct net_device *dev)
316 {
317         int i;
318
319         i = netdev_lock_pos(dev->type);
320         lockdep_set_class_and_name(&dev->addr_list_lock,
321                                    &netdev_addr_lock_key[i],
322                                    netdev_lock_name[i]);
323 }
324 #else
325 static inline void netdev_set_xmit_lockdep_class(spinlock_t *lock,
326                                                  unsigned short dev_type)
327 {
328 }
329 static inline void netdev_set_addr_lockdep_class(struct net_device *dev)
330 {
331 }
332 #endif
333
334 /*******************************************************************************
335
336                 Protocol management and registration routines
337
338 *******************************************************************************/
339
340 /*
341  *      Add a protocol ID to the list. Now that the input handler is
342  *      smarter we can dispense with all the messy stuff that used to be
343  *      here.
344  *
345  *      BEWARE!!! Protocol handlers, mangling input packets,
346  *      MUST BE last in hash buckets and checking protocol handlers
347  *      MUST start from promiscuous ptype_all chain in net_bh.
348  *      It is true now, do not change it.
349  *      Explanation follows: if protocol handler, mangling packet, will
350  *      be the first on list, it is not able to sense, that packet
351  *      is cloned and should be copied-on-write, so that it will
352  *      change it and subsequent readers will get broken packet.
353  *                                                      --ANK (980803)
354  */
355
356 static inline struct list_head *ptype_head(const struct packet_type *pt)
357 {
358         if (pt->type == htons(ETH_P_ALL))
359                 return &ptype_all;
360         else
361                 return &ptype_base[ntohs(pt->type) & PTYPE_HASH_MASK];
362 }
363
364 /**
365  *      dev_add_pack - add packet handler
366  *      @pt: packet type declaration
367  *
368  *      Add a protocol handler to the networking stack. The passed &packet_type
369  *      is linked into kernel lists and may not be freed until it has been
370  *      removed from the kernel lists.
371  *
372  *      This call does not sleep therefore it can not
373  *      guarantee all CPU's that are in middle of receiving packets
374  *      will see the new packet type (until the next received packet).
375  */
376
377 void dev_add_pack(struct packet_type *pt)
378 {
379         struct list_head *head = ptype_head(pt);
380
381         spin_lock(&ptype_lock);
382         list_add_rcu(&pt->list, head);
383         spin_unlock(&ptype_lock);
384 }
385 EXPORT_SYMBOL(dev_add_pack);
386
387 /**
388  *      __dev_remove_pack        - remove packet handler
389  *      @pt: packet type declaration
390  *
391  *      Remove a protocol handler that was previously added to the kernel
392  *      protocol handlers by dev_add_pack(). The passed &packet_type is removed
393  *      from the kernel lists and can be freed or reused once this function
394  *      returns.
395  *
396  *      The packet type might still be in use by receivers
397  *      and must not be freed until after all the CPU's have gone
398  *      through a quiescent state.
399  */
400 void __dev_remove_pack(struct packet_type *pt)
401 {
402         struct list_head *head = ptype_head(pt);
403         struct packet_type *pt1;
404
405         spin_lock(&ptype_lock);
406
407         list_for_each_entry(pt1, head, list) {
408                 if (pt == pt1) {
409                         list_del_rcu(&pt->list);
410                         goto out;
411                 }
412         }
413
414         pr_warn("dev_remove_pack: %p not found\n", pt);
415 out:
416         spin_unlock(&ptype_lock);
417 }
418 EXPORT_SYMBOL(__dev_remove_pack);
419
420 /**
421  *      dev_remove_pack  - remove packet handler
422  *      @pt: packet type declaration
423  *
424  *      Remove a protocol handler that was previously added to the kernel
425  *      protocol handlers by dev_add_pack(). The passed &packet_type is removed
426  *      from the kernel lists and can be freed or reused once this function
427  *      returns.
428  *
429  *      This call sleeps to guarantee that no CPU is looking at the packet
430  *      type after return.
431  */
432 void dev_remove_pack(struct packet_type *pt)
433 {
434         __dev_remove_pack(pt);
435
436         synchronize_net();
437 }
438 EXPORT_SYMBOL(dev_remove_pack);
439
440
441 /**
442  *      dev_add_offload - register offload handlers
443  *      @po: protocol offload declaration
444  *
445  *      Add protocol offload handlers to the networking stack. The passed
446  *      &proto_offload is linked into kernel lists and may not be freed until
447  *      it has been removed from the kernel lists.
448  *
449  *      This call does not sleep therefore it can not
450  *      guarantee all CPU's that are in middle of receiving packets
451  *      will see the new offload handlers (until the next received packet).
452  */
453 void dev_add_offload(struct packet_offload *po)
454 {
455         struct list_head *head = &offload_base;
456
457         spin_lock(&offload_lock);
458         list_add_rcu(&po->list, head);
459         spin_unlock(&offload_lock);
460 }
461 EXPORT_SYMBOL(dev_add_offload);
462
463 /**
464  *      __dev_remove_offload     - remove offload handler
465  *      @po: packet offload declaration
466  *
467  *      Remove a protocol offload handler that was previously added to the
468  *      kernel offload handlers by dev_add_offload(). The passed &offload_type
469  *      is removed from the kernel lists and can be freed or reused once this
470  *      function returns.
471  *
472  *      The packet type might still be in use by receivers
473  *      and must not be freed until after all the CPU's have gone
474  *      through a quiescent state.
475  */
476 void __dev_remove_offload(struct packet_offload *po)
477 {
478         struct list_head *head = &offload_base;
479         struct packet_offload *po1;
480
481         spin_lock(&offload_lock);
482
483         list_for_each_entry(po1, head, list) {
484                 if (po == po1) {
485                         list_del_rcu(&po->list);
486                         goto out;
487                 }
488         }
489
490         pr_warn("dev_remove_offload: %p not found\n", po);
491 out:
492         spin_unlock(&offload_lock);
493 }
494 EXPORT_SYMBOL(__dev_remove_offload);
495
496 /**
497  *      dev_remove_offload       - remove packet offload handler
498  *      @po: packet offload declaration
499  *
500  *      Remove a packet offload handler that was previously added to the kernel
501  *      offload handlers by dev_add_offload(). The passed &offload_type is
502  *      removed from the kernel lists and can be freed or reused once this
503  *      function returns.
504  *
505  *      This call sleeps to guarantee that no CPU is looking at the packet
506  *      type after return.
507  */
508 void dev_remove_offload(struct packet_offload *po)
509 {
510         __dev_remove_offload(po);
511
512         synchronize_net();
513 }
514 EXPORT_SYMBOL(dev_remove_offload);
515
516 /******************************************************************************
517
518                       Device Boot-time Settings Routines
519
520 *******************************************************************************/
521
522 /* Boot time configuration table */
523 static struct netdev_boot_setup dev_boot_setup[NETDEV_BOOT_SETUP_MAX];
524
525 /**
526  *      netdev_boot_setup_add   - add new setup entry
527  *      @name: name of the device
528  *      @map: configured settings for the device
529  *
530  *      Adds new setup entry to the dev_boot_setup list.  The function
531  *      returns 0 on error and 1 on success.  This is a generic routine to
532  *      all netdevices.
533  */
534 static int netdev_boot_setup_add(char *name, struct ifmap *map)
535 {
536         struct netdev_boot_setup *s;
537         int i;
538
539         s = dev_boot_setup;
540         for (i = 0; i < NETDEV_BOOT_SETUP_MAX; i++) {
541                 if (s[i].name[0] == '\0' || s[i].name[0] == ' ') {
542                         memset(s[i].name, 0, sizeof(s[i].name));
543                         strlcpy(s[i].name, name, IFNAMSIZ);
544                         memcpy(&s[i].map, map, sizeof(s[i].map));
545                         break;
546                 }
547         }
548
549         return i >= NETDEV_BOOT_SETUP_MAX ? 0 : 1;
550 }
551
552 /**
553  *      netdev_boot_setup_check - check boot time settings
554  *      @dev: the netdevice
555  *
556  *      Check boot time settings for the device.
557  *      The found settings are set for the device to be used
558  *      later in the device probing.
559  *      Returns 0 if no settings found, 1 if they are.
560  */
561 int netdev_boot_setup_check(struct net_device *dev)
562 {
563         struct netdev_boot_setup *s = dev_boot_setup;
564         int i;
565
566         for (i = 0; i < NETDEV_BOOT_SETUP_MAX; i++) {
567                 if (s[i].name[0] != '\0' && s[i].name[0] != ' ' &&
568                     !strcmp(dev->name, s[i].name)) {
569                         dev->irq        = s[i].map.irq;
570                         dev->base_addr  = s[i].map.base_addr;
571                         dev->mem_start  = s[i].map.mem_start;
572                         dev->mem_end    = s[i].map.mem_end;
573                         return 1;
574                 }
575         }
576         return 0;
577 }
578 EXPORT_SYMBOL(netdev_boot_setup_check);
579
580
581 /**
582  *      netdev_boot_base        - get address from boot time settings
583  *      @prefix: prefix for network device
584  *      @unit: id for network device
585  *
586  *      Check boot time settings for the base address of device.
587  *      The found settings are set for the device to be used
588  *      later in the device probing.
589  *      Returns 0 if no settings found.
590  */
591 unsigned long netdev_boot_base(const char *prefix, int unit)
592 {
593         const struct netdev_boot_setup *s = dev_boot_setup;
594         char name[IFNAMSIZ];
595         int i;
596
597         sprintf(name, "%s%d", prefix, unit);
598
599         /*
600          * If device already registered then return base of 1
601          * to indicate not to probe for this interface
602          */
603         if (__dev_get_by_name(&init_net, name))
604                 return 1;
605
606         for (i = 0; i < NETDEV_BOOT_SETUP_MAX; i++)
607                 if (!strcmp(name, s[i].name))
608                         return s[i].map.base_addr;
609         return 0;
610 }
611
612 /*
613  * Saves at boot time configured settings for any netdevice.
614  */
615 int __init netdev_boot_setup(char *str)
616 {
617         int ints[5];
618         struct ifmap map;
619
620         str = get_options(str, ARRAY_SIZE(ints), ints);
621         if (!str || !*str)
622                 return 0;
623
624         /* Save settings */
625         memset(&map, 0, sizeof(map));
626         if (ints[0] > 0)
627                 map.irq = ints[1];
628         if (ints[0] > 1)
629                 map.base_addr = ints[2];
630         if (ints[0] > 2)
631                 map.mem_start = ints[3];
632         if (ints[0] > 3)
633                 map.mem_end = ints[4];
634
635         /* Add new entry to the list */
636         return netdev_boot_setup_add(str, &map);
637 }
638
639 __setup("netdev=", netdev_boot_setup);
640
641 /*******************************************************************************
642
643                             Device Interface Subroutines
644
645 *******************************************************************************/
646
647 /**
648  *      __dev_get_by_name       - find a device by its name
649  *      @net: the applicable net namespace
650  *      @name: name to find
651  *
652  *      Find an interface by name. Must be called under RTNL semaphore
653  *      or @dev_base_lock. If the name is found a pointer to the device
654  *      is returned. If the name is not found then %NULL is returned. The
655  *      reference counters are not incremented so the caller must be
656  *      careful with locks.
657  */
658
659 struct net_device *__dev_get_by_name(struct net *net, const char *name)
660 {
661         struct net_device *dev;
662         struct hlist_head *head = dev_name_hash(net, name);
663
664         hlist_for_each_entry(dev, head, name_hlist)
665                 if (!strncmp(dev->name, name, IFNAMSIZ))
666                         return dev;
667
668         return NULL;
669 }
670 EXPORT_SYMBOL(__dev_get_by_name);
671
672 /**
673  *      dev_get_by_name_rcu     - find a device by its name
674  *      @net: the applicable net namespace
675  *      @name: name to find
676  *
677  *      Find an interface by name.
678  *      If the name is found a pointer to the device is returned.
679  *      If the name is not found then %NULL is returned.
680  *      The reference counters are not incremented so the caller must be
681  *      careful with locks. The caller must hold RCU lock.
682  */
683
684 struct net_device *dev_get_by_name_rcu(struct net *net, const char *name)
685 {
686         struct net_device *dev;
687         struct hlist_head *head = dev_name_hash(net, name);
688
689         hlist_for_each_entry_rcu(dev, head, name_hlist)
690                 if (!strncmp(dev->name, name, IFNAMSIZ))
691                         return dev;
692
693         return NULL;
694 }
695 EXPORT_SYMBOL(dev_get_by_name_rcu);
696
697 /**
698  *      dev_get_by_name         - find a device by its name
699  *      @net: the applicable net namespace
700  *      @name: name to find
701  *
702  *      Find an interface by name. This can be called from any
703  *      context and does its own locking. The returned handle has
704  *      the usage count incremented and the caller must use dev_put() to
705  *      release it when it is no longer needed. %NULL is returned if no
706  *      matching device is found.
707  */
708
709 struct net_device *dev_get_by_name(struct net *net, const char *name)
710 {
711         struct net_device *dev;
712
713         rcu_read_lock();
714         dev = dev_get_by_name_rcu(net, name);
715         if (dev)
716                 dev_hold(dev);
717         rcu_read_unlock();
718         return dev;
719 }
720 EXPORT_SYMBOL(dev_get_by_name);
721
722 /**
723  *      __dev_get_by_index - find a device by its ifindex
724  *      @net: the applicable net namespace
725  *      @ifindex: index of device
726  *
727  *      Search for an interface by index. Returns %NULL if the device
728  *      is not found or a pointer to the device. The device has not
729  *      had its reference counter increased so the caller must be careful
730  *      about locking. The caller must hold either the RTNL semaphore
731  *      or @dev_base_lock.
732  */
733
734 struct net_device *__dev_get_by_index(struct net *net, int ifindex)
735 {
736         struct net_device *dev;
737         struct hlist_head *head = dev_index_hash(net, ifindex);
738
739         hlist_for_each_entry(dev, head, index_hlist)
740                 if (dev->ifindex == ifindex)
741                         return dev;
742
743         return NULL;
744 }
745 EXPORT_SYMBOL(__dev_get_by_index);
746
747 /**
748  *      dev_get_by_index_rcu - find a device by its ifindex
749  *      @net: the applicable net namespace
750  *      @ifindex: index of device
751  *
752  *      Search for an interface by index. Returns %NULL if the device
753  *      is not found or a pointer to the device. The device has not
754  *      had its reference counter increased so the caller must be careful
755  *      about locking. The caller must hold RCU lock.
756  */
757
758 struct net_device *dev_get_by_index_rcu(struct net *net, int ifindex)
759 {
760         struct net_device *dev;
761         struct hlist_head *head = dev_index_hash(net, ifindex);
762
763         hlist_for_each_entry_rcu(dev, head, index_hlist)
764                 if (dev->ifindex == ifindex)
765                         return dev;
766
767         return NULL;
768 }
769 EXPORT_SYMBOL(dev_get_by_index_rcu);
770
771
772 /**
773  *      dev_get_by_index - find a device by its ifindex
774  *      @net: the applicable net namespace
775  *      @ifindex: index of device
776  *
777  *      Search for an interface by index. Returns NULL if the device
778  *      is not found or a pointer to the device. The device returned has
779  *      had a reference added and the pointer is safe until the user calls
780  *      dev_put to indicate they have finished with it.
781  */
782
783 struct net_device *dev_get_by_index(struct net *net, int ifindex)
784 {
785         struct net_device *dev;
786
787         rcu_read_lock();
788         dev = dev_get_by_index_rcu(net, ifindex);
789         if (dev)
790                 dev_hold(dev);
791         rcu_read_unlock();
792         return dev;
793 }
794 EXPORT_SYMBOL(dev_get_by_index);
795
796 /**
797  *      dev_getbyhwaddr_rcu - find a device by its hardware address
798  *      @net: the applicable net namespace
799  *      @type: media type of device
800  *      @ha: hardware address
801  *
802  *      Search for an interface by MAC address. Returns NULL if the device
803  *      is not found or a pointer to the device.
804  *      The caller must hold RCU or RTNL.
805  *      The returned device has not had its ref count increased
806  *      and the caller must therefore be careful about locking
807  *
808  */
809
810 struct net_device *dev_getbyhwaddr_rcu(struct net *net, unsigned short type,
811                                        const char *ha)
812 {
813         struct net_device *dev;
814
815         for_each_netdev_rcu(net, dev)
816                 if (dev->type == type &&
817                     !memcmp(dev->dev_addr, ha, dev->addr_len))
818                         return dev;
819
820         return NULL;
821 }
822 EXPORT_SYMBOL(dev_getbyhwaddr_rcu);
823
824 struct net_device *__dev_getfirstbyhwtype(struct net *net, unsigned short type)
825 {
826         struct net_device *dev;
827
828         ASSERT_RTNL();
829         for_each_netdev(net, dev)
830                 if (dev->type == type)
831                         return dev;
832
833         return NULL;
834 }
835 EXPORT_SYMBOL(__dev_getfirstbyhwtype);
836
837 struct net_device *dev_getfirstbyhwtype(struct net *net, unsigned short type)
838 {
839         struct net_device *dev, *ret = NULL;
840
841         rcu_read_lock();
842         for_each_netdev_rcu(net, dev)
843                 if (dev->type == type) {
844                         dev_hold(dev);
845                         ret = dev;
846                         break;
847                 }
848         rcu_read_unlock();
849         return ret;
850 }
851 EXPORT_SYMBOL(dev_getfirstbyhwtype);
852
853 /**
854  *      dev_get_by_flags_rcu - find any device with given flags
855  *      @net: the applicable net namespace
856  *      @if_flags: IFF_* values
857  *      @mask: bitmask of bits in if_flags to check
858  *
859  *      Search for any interface with the given flags. Returns NULL if a device
860  *      is not found or a pointer to the device. Must be called inside
861  *      rcu_read_lock(), and result refcount is unchanged.
862  */
863
864 struct net_device *dev_get_by_flags_rcu(struct net *net, unsigned short if_flags,
865                                     unsigned short mask)
866 {
867         struct net_device *dev, *ret;
868
869         ret = NULL;
870         for_each_netdev_rcu(net, dev) {
871                 if (((dev->flags ^ if_flags) & mask) == 0) {
872                         ret = dev;
873                         break;
874                 }
875         }
876         return ret;
877 }
878 EXPORT_SYMBOL(dev_get_by_flags_rcu);
879
880 /**
881  *      dev_valid_name - check if name is okay for network device
882  *      @name: name string
883  *
884  *      Network device names need to be valid file names to
885  *      to allow sysfs to work.  We also disallow any kind of
886  *      whitespace.
887  */
888 bool dev_valid_name(const char *name)
889 {
890         if (*name == '\0')
891                 return false;
892         if (strlen(name) >= IFNAMSIZ)
893                 return false;
894         if (!strcmp(name, ".") || !strcmp(name, ".."))
895                 return false;
896
897         while (*name) {
898                 if (*name == '/' || isspace(*name))
899                         return false;
900                 name++;
901         }
902         return true;
903 }
904 EXPORT_SYMBOL(dev_valid_name);
905
906 /**
907  *      __dev_alloc_name - allocate a name for a device
908  *      @net: network namespace to allocate the device name in
909  *      @name: name format string
910  *      @buf:  scratch buffer and result name string
911  *
912  *      Passed a format string - eg "lt%d" it will try and find a suitable
913  *      id. It scans list of devices to build up a free map, then chooses
914  *      the first empty slot. The caller must hold the dev_base or rtnl lock
915  *      while allocating the name and adding the device in order to avoid
916  *      duplicates.
917  *      Limited to bits_per_byte * page size devices (ie 32K on most platforms).
918  *      Returns the number of the unit assigned or a negative errno code.
919  */
920
921 static int __dev_alloc_name(struct net *net, const char *name, char *buf)
922 {
923         int i = 0;
924         const char *p;
925         const int max_netdevices = 8*PAGE_SIZE;
926         unsigned long *inuse;
927         struct net_device *d;
928
929         p = strnchr(name, IFNAMSIZ-1, '%');
930         if (p) {
931                 /*
932                  * Verify the string as this thing may have come from
933                  * the user.  There must be either one "%d" and no other "%"
934                  * characters.
935                  */
936                 if (p[1] != 'd' || strchr(p + 2, '%'))
937                         return -EINVAL;
938
939                 /* Use one page as a bit array of possible slots */
940                 inuse = (unsigned long *) get_zeroed_page(GFP_ATOMIC);
941                 if (!inuse)
942                         return -ENOMEM;
943
944                 for_each_netdev(net, d) {
945                         if (!sscanf(d->name, name, &i))
946                                 continue;
947                         if (i < 0 || i >= max_netdevices)
948                                 continue;
949
950                         /*  avoid cases where sscanf is not exact inverse of printf */
951                         snprintf(buf, IFNAMSIZ, name, i);
952                         if (!strncmp(buf, d->name, IFNAMSIZ))
953                                 set_bit(i, inuse);
954                 }
955
956                 i = find_first_zero_bit(inuse, max_netdevices);
957                 free_page((unsigned long) inuse);
958         }
959
960         if (buf != name)
961                 snprintf(buf, IFNAMSIZ, name, i);
962         if (!__dev_get_by_name(net, buf))
963                 return i;
964
965         /* It is possible to run out of possible slots
966          * when the name is long and there isn't enough space left
967          * for the digits, or if all bits are used.
968          */
969         return -ENFILE;
970 }
971
972 /**
973  *      dev_alloc_name - allocate a name for a device
974  *      @dev: device
975  *      @name: name format string
976  *
977  *      Passed a format string - eg "lt%d" it will try and find a suitable
978  *      id. It scans list of devices to build up a free map, then chooses
979  *      the first empty slot. The caller must hold the dev_base or rtnl lock
980  *      while allocating the name and adding the device in order to avoid
981  *      duplicates.
982  *      Limited to bits_per_byte * page size devices (ie 32K on most platforms).
983  *      Returns the number of the unit assigned or a negative errno code.
984  */
985
986 int dev_alloc_name(struct net_device *dev, const char *name)
987 {
988         char buf[IFNAMSIZ];
989         struct net *net;
990         int ret;
991
992         BUG_ON(!dev_net(dev));
993         net = dev_net(dev);
994         ret = __dev_alloc_name(net, name, buf);
995         if (ret >= 0)
996                 strlcpy(dev->name, buf, IFNAMSIZ);
997         return ret;
998 }
999 EXPORT_SYMBOL(dev_alloc_name);
1000
1001 static int dev_alloc_name_ns(struct net *net,
1002                              struct net_device *dev,
1003                              const char *name)
1004 {
1005         char buf[IFNAMSIZ];
1006         int ret;
1007
1008         ret = __dev_alloc_name(net, name, buf);
1009         if (ret >= 0)
1010                 strlcpy(dev->name, buf, IFNAMSIZ);
1011         return ret;
1012 }
1013
1014 static int dev_get_valid_name(struct net *net,
1015                               struct net_device *dev,
1016                               const char *name)
1017 {
1018         BUG_ON(!net);
1019
1020         if (!dev_valid_name(name))
1021                 return -EINVAL;
1022
1023         if (strchr(name, '%'))
1024                 return dev_alloc_name_ns(net, dev, name);
1025         else if (__dev_get_by_name(net, name))
1026                 return -EEXIST;
1027         else if (dev->name != name)
1028                 strlcpy(dev->name, name, IFNAMSIZ);
1029
1030         return 0;
1031 }
1032
1033 /**
1034  *      dev_change_name - change name of a device
1035  *      @dev: device
1036  *      @newname: name (or format string) must be at least IFNAMSIZ
1037  *
1038  *      Change name of a device, can pass format strings "eth%d".
1039  *      for wildcarding.
1040  */
1041 int dev_change_name(struct net_device *dev, const char *newname)
1042 {
1043         char oldname[IFNAMSIZ];
1044         int err = 0;
1045         int ret;
1046         struct net *net;
1047
1048         ASSERT_RTNL();
1049         BUG_ON(!dev_net(dev));
1050
1051         net = dev_net(dev);
1052         if (dev->flags & IFF_UP)
1053                 return -EBUSY;
1054
1055         write_seqcount_begin(&devnet_rename_seq);
1056
1057         if (strncmp(newname, dev->name, IFNAMSIZ) == 0) {
1058                 write_seqcount_end(&devnet_rename_seq);
1059                 return 0;
1060         }
1061
1062         memcpy(oldname, dev->name, IFNAMSIZ);
1063
1064         err = dev_get_valid_name(net, dev, newname);
1065         if (err < 0) {
1066                 write_seqcount_end(&devnet_rename_seq);
1067                 return err;
1068         }
1069
1070 rollback:
1071         ret = device_rename(&dev->dev, dev->name);
1072         if (ret) {
1073                 memcpy(dev->name, oldname, IFNAMSIZ);
1074                 write_seqcount_end(&devnet_rename_seq);
1075                 return ret;
1076         }
1077
1078         write_seqcount_end(&devnet_rename_seq);
1079
1080         write_lock_bh(&dev_base_lock);
1081         hlist_del_rcu(&dev->name_hlist);
1082         write_unlock_bh(&dev_base_lock);
1083
1084         synchronize_rcu();
1085
1086         write_lock_bh(&dev_base_lock);
1087         hlist_add_head_rcu(&dev->name_hlist, dev_name_hash(net, dev->name));
1088         write_unlock_bh(&dev_base_lock);
1089
1090         ret = call_netdevice_notifiers(NETDEV_CHANGENAME, dev);
1091         ret = notifier_to_errno(ret);
1092
1093         if (ret) {
1094                 /* err >= 0 after dev_alloc_name() or stores the first errno */
1095                 if (err >= 0) {
1096                         err = ret;
1097                         write_seqcount_begin(&devnet_rename_seq);
1098                         memcpy(dev->name, oldname, IFNAMSIZ);
1099                         goto rollback;
1100                 } else {
1101                         pr_err("%s: name change rollback failed: %d\n",
1102                                dev->name, ret);
1103                 }
1104         }
1105
1106         return err;
1107 }
1108
1109 /**
1110  *      dev_set_alias - change ifalias of a device
1111  *      @dev: device
1112  *      @alias: name up to IFALIASZ
1113  *      @len: limit of bytes to copy from info
1114  *
1115  *      Set ifalias for a device,
1116  */
1117 int dev_set_alias(struct net_device *dev, const char *alias, size_t len)
1118 {
1119         char *new_ifalias;
1120
1121         ASSERT_RTNL();
1122
1123         if (len >= IFALIASZ)
1124                 return -EINVAL;
1125
1126         if (!len) {
1127                 kfree(dev->ifalias);
1128                 dev->ifalias = NULL;
1129                 return 0;
1130         }
1131
1132         new_ifalias = krealloc(dev->ifalias, len + 1, GFP_KERNEL);
1133         if (!new_ifalias)
1134                 return -ENOMEM;
1135         dev->ifalias = new_ifalias;
1136
1137         strlcpy(dev->ifalias, alias, len+1);
1138         return len;
1139 }
1140
1141
1142 /**
1143  *      netdev_features_change - device changes features
1144  *      @dev: device to cause notification
1145  *
1146  *      Called to indicate a device has changed features.
1147  */
1148 void netdev_features_change(struct net_device *dev)
1149 {
1150         call_netdevice_notifiers(NETDEV_FEAT_CHANGE, dev);
1151 }
1152 EXPORT_SYMBOL(netdev_features_change);
1153
1154 /**
1155  *      netdev_state_change - device changes state
1156  *      @dev: device to cause notification
1157  *
1158  *      Called to indicate a device has changed state. This function calls
1159  *      the notifier chains for netdev_chain and sends a NEWLINK message
1160  *      to the routing socket.
1161  */
1162 void netdev_state_change(struct net_device *dev)
1163 {
1164         if (dev->flags & IFF_UP) {
1165                 call_netdevice_notifiers(NETDEV_CHANGE, dev);
1166                 rtmsg_ifinfo(RTM_NEWLINK, dev, 0);
1167         }
1168 }
1169 EXPORT_SYMBOL(netdev_state_change);
1170
1171 /**
1172  *      netdev_notify_peers - notify network peers about existence of @dev
1173  *      @dev: network device
1174  *
1175  * Generate traffic such that interested network peers are aware of
1176  * @dev, such as by generating a gratuitous ARP. This may be used when
1177  * a device wants to inform the rest of the network about some sort of
1178  * reconfiguration such as a failover event or virtual machine
1179  * migration.
1180  */
1181 void netdev_notify_peers(struct net_device *dev)
1182 {
1183         rtnl_lock();
1184         call_netdevice_notifiers(NETDEV_NOTIFY_PEERS, dev);
1185         rtnl_unlock();
1186 }
1187 EXPORT_SYMBOL(netdev_notify_peers);
1188
1189 static int __dev_open(struct net_device *dev)
1190 {
1191         const struct net_device_ops *ops = dev->netdev_ops;
1192         int ret;
1193
1194         ASSERT_RTNL();
1195
1196         if (!netif_device_present(dev))
1197                 return -ENODEV;
1198
1199         /* Block netpoll from trying to do any rx path servicing.
1200          * If we don't do this there is a chance ndo_poll_controller
1201          * or ndo_poll may be running while we open the device
1202          */
1203         ret = netpoll_rx_disable(dev);
1204         if (ret)
1205                 return ret;
1206
1207         ret = call_netdevice_notifiers(NETDEV_PRE_UP, dev);
1208         ret = notifier_to_errno(ret);
1209         if (ret)
1210                 return ret;
1211
1212         set_bit(__LINK_STATE_START, &dev->state);
1213
1214         if (ops->ndo_validate_addr)
1215                 ret = ops->ndo_validate_addr(dev);
1216
1217         if (!ret && ops->ndo_open)
1218                 ret = ops->ndo_open(dev);
1219
1220         netpoll_rx_enable(dev);
1221
1222         if (ret)
1223                 clear_bit(__LINK_STATE_START, &dev->state);
1224         else {
1225                 dev->flags |= IFF_UP;
1226                 net_dmaengine_get();
1227                 dev_set_rx_mode(dev);
1228                 dev_activate(dev);
1229                 add_device_randomness(dev->dev_addr, dev->addr_len);
1230         }
1231
1232         return ret;
1233 }
1234
1235 /**
1236  *      dev_open        - prepare an interface for use.
1237  *      @dev:   device to open
1238  *
1239  *      Takes a device from down to up state. The device's private open
1240  *      function is invoked and then the multicast lists are loaded. Finally
1241  *      the device is moved into the up state and a %NETDEV_UP message is
1242  *      sent to the netdev notifier chain.
1243  *
1244  *      Calling this function on an active interface is a nop. On a failure
1245  *      a negative errno code is returned.
1246  */
1247 int dev_open(struct net_device *dev)
1248 {
1249         int ret;
1250
1251         if (dev->flags & IFF_UP)
1252                 return 0;
1253
1254         ret = __dev_open(dev);
1255         if (ret < 0)
1256                 return ret;
1257
1258         rtmsg_ifinfo(RTM_NEWLINK, dev, IFF_UP|IFF_RUNNING);
1259         call_netdevice_notifiers(NETDEV_UP, dev);
1260
1261         return ret;
1262 }
1263 EXPORT_SYMBOL(dev_open);
1264
1265 static int __dev_close_many(struct list_head *head)
1266 {
1267         struct net_device *dev;
1268
1269         ASSERT_RTNL();
1270         might_sleep();
1271
1272         list_for_each_entry(dev, head, unreg_list) {
1273                 call_netdevice_notifiers(NETDEV_GOING_DOWN, dev);
1274
1275                 clear_bit(__LINK_STATE_START, &dev->state);
1276
1277                 /* Synchronize to scheduled poll. We cannot touch poll list, it
1278                  * can be even on different cpu. So just clear netif_running().
1279                  *
1280                  * dev->stop() will invoke napi_disable() on all of it's
1281                  * napi_struct instances on this device.
1282                  */
1283                 smp_mb__after_clear_bit(); /* Commit netif_running(). */
1284         }
1285
1286         dev_deactivate_many(head);
1287
1288         list_for_each_entry(dev, head, unreg_list) {
1289                 const struct net_device_ops *ops = dev->netdev_ops;
1290
1291                 /*
1292                  *      Call the device specific close. This cannot fail.
1293                  *      Only if device is UP
1294                  *
1295                  *      We allow it to be called even after a DETACH hot-plug
1296                  *      event.
1297                  */
1298                 if (ops->ndo_stop)
1299                         ops->ndo_stop(dev);
1300
1301                 dev->flags &= ~IFF_UP;
1302                 net_dmaengine_put();
1303         }
1304
1305         return 0;
1306 }
1307
1308 static int __dev_close(struct net_device *dev)
1309 {
1310         int retval;
1311         LIST_HEAD(single);
1312
1313         /* Temporarily disable netpoll until the interface is down */
1314         retval = netpoll_rx_disable(dev);
1315         if (retval)
1316                 return retval;
1317
1318         list_add(&dev->unreg_list, &single);
1319         retval = __dev_close_many(&single);
1320         list_del(&single);
1321
1322         netpoll_rx_enable(dev);
1323         return retval;
1324 }
1325
1326 static int dev_close_many(struct list_head *head)
1327 {
1328         struct net_device *dev, *tmp;
1329         LIST_HEAD(tmp_list);
1330
1331         list_for_each_entry_safe(dev, tmp, head, unreg_list)
1332                 if (!(dev->flags & IFF_UP))
1333                         list_move(&dev->unreg_list, &tmp_list);
1334
1335         __dev_close_many(head);
1336
1337         list_for_each_entry(dev, head, unreg_list) {
1338                 rtmsg_ifinfo(RTM_NEWLINK, dev, IFF_UP|IFF_RUNNING);
1339                 call_netdevice_notifiers(NETDEV_DOWN, dev);
1340         }
1341
1342         /* rollback_registered_many needs the complete original list */
1343         list_splice(&tmp_list, head);
1344         return 0;
1345 }
1346
1347 /**
1348  *      dev_close - shutdown an interface.
1349  *      @dev: device to shutdown
1350  *
1351  *      This function moves an active device into down state. A
1352  *      %NETDEV_GOING_DOWN is sent to the netdev notifier chain. The device
1353  *      is then deactivated and finally a %NETDEV_DOWN is sent to the notifier
1354  *      chain.
1355  */
1356 int dev_close(struct net_device *dev)
1357 {
1358         int ret = 0;
1359         if (dev->flags & IFF_UP) {
1360                 LIST_HEAD(single);
1361
1362                 /* Block netpoll rx while the interface is going down */
1363                 ret = netpoll_rx_disable(dev);
1364                 if (ret)
1365                         return ret;
1366
1367                 list_add(&dev->unreg_list, &single);
1368                 dev_close_many(&single);
1369                 list_del(&single);
1370
1371                 netpoll_rx_enable(dev);
1372         }
1373         return ret;
1374 }
1375 EXPORT_SYMBOL(dev_close);
1376
1377
1378 /**
1379  *      dev_disable_lro - disable Large Receive Offload on a device
1380  *      @dev: device
1381  *
1382  *      Disable Large Receive Offload (LRO) on a net device.  Must be
1383  *      called under RTNL.  This is needed if received packets may be
1384  *      forwarded to another interface.
1385  */
1386 void dev_disable_lro(struct net_device *dev)
1387 {
1388         /*
1389          * If we're trying to disable lro on a vlan device
1390          * use the underlying physical device instead
1391          */
1392         if (is_vlan_dev(dev))
1393                 dev = vlan_dev_real_dev(dev);
1394
1395         dev->wanted_features &= ~NETIF_F_LRO;
1396         netdev_update_features(dev);
1397
1398         if (unlikely(dev->features & NETIF_F_LRO))
1399                 netdev_WARN(dev, "failed to disable LRO!\n");
1400 }
1401 EXPORT_SYMBOL(dev_disable_lro);
1402
1403
1404 static int dev_boot_phase = 1;
1405
1406 /**
1407  *      register_netdevice_notifier - register a network notifier block
1408  *      @nb: notifier
1409  *
1410  *      Register a notifier to be called when network device events occur.
1411  *      The notifier passed is linked into the kernel structures and must
1412  *      not be reused until it has been unregistered. A negative errno code
1413  *      is returned on a failure.
1414  *
1415  *      When registered all registration and up events are replayed
1416  *      to the new notifier to allow device to have a race free
1417  *      view of the network device list.
1418  */
1419
1420 int register_netdevice_notifier(struct notifier_block *nb)
1421 {
1422         struct net_device *dev;
1423         struct net_device *last;
1424         struct net *net;
1425         int err;
1426
1427         rtnl_lock();
1428         err = raw_notifier_chain_register(&netdev_chain, nb);
1429         if (err)
1430                 goto unlock;
1431         if (dev_boot_phase)
1432                 goto unlock;
1433         for_each_net(net) {
1434                 for_each_netdev(net, dev) {
1435                         err = nb->notifier_call(nb, NETDEV_REGISTER, dev);
1436                         err = notifier_to_errno(err);
1437                         if (err)
1438                                 goto rollback;
1439
1440                         if (!(dev->flags & IFF_UP))
1441                                 continue;
1442
1443                         nb->notifier_call(nb, NETDEV_UP, dev);
1444                 }
1445         }
1446
1447 unlock:
1448         rtnl_unlock();
1449         return err;
1450
1451 rollback:
1452         last = dev;
1453         for_each_net(net) {
1454                 for_each_netdev(net, dev) {
1455                         if (dev == last)
1456                                 goto outroll;
1457
1458                         if (dev->flags & IFF_UP) {
1459                                 nb->notifier_call(nb, NETDEV_GOING_DOWN, dev);
1460                                 nb->notifier_call(nb, NETDEV_DOWN, dev);
1461                         }
1462                         nb->notifier_call(nb, NETDEV_UNREGISTER, dev);
1463                 }
1464         }
1465
1466 outroll:
1467         raw_notifier_chain_unregister(&netdev_chain, nb);
1468         goto unlock;
1469 }
1470 EXPORT_SYMBOL(register_netdevice_notifier);
1471
1472 /**
1473  *      unregister_netdevice_notifier - unregister a network notifier block
1474  *      @nb: notifier
1475  *
1476  *      Unregister a notifier previously registered by
1477  *      register_netdevice_notifier(). The notifier is unlinked into the
1478  *      kernel structures and may then be reused. A negative errno code
1479  *      is returned on a failure.
1480  *
1481  *      After unregistering unregister and down device events are synthesized
1482  *      for all devices on the device list to the removed notifier to remove
1483  *      the need for special case cleanup code.
1484  */
1485
1486 int unregister_netdevice_notifier(struct notifier_block *nb)
1487 {
1488         struct net_device *dev;
1489         struct net *net;
1490         int err;
1491
1492         rtnl_lock();
1493         err = raw_notifier_chain_unregister(&netdev_chain, nb);
1494         if (err)
1495                 goto unlock;
1496
1497         for_each_net(net) {
1498                 for_each_netdev(net, dev) {
1499                         if (dev->flags & IFF_UP) {
1500                                 nb->notifier_call(nb, NETDEV_GOING_DOWN, dev);
1501                                 nb->notifier_call(nb, NETDEV_DOWN, dev);
1502                         }
1503                         nb->notifier_call(nb, NETDEV_UNREGISTER, dev);
1504                 }
1505         }
1506 unlock:
1507         rtnl_unlock();
1508         return err;
1509 }
1510 EXPORT_SYMBOL(unregister_netdevice_notifier);
1511
1512 /**
1513  *      call_netdevice_notifiers - call all network notifier blocks
1514  *      @val: value passed unmodified to notifier function
1515  *      @dev: net_device pointer passed unmodified to notifier function
1516  *
1517  *      Call all network notifier blocks.  Parameters and return value
1518  *      are as for raw_notifier_call_chain().
1519  */
1520
1521 int call_netdevice_notifiers(unsigned long val, struct net_device *dev)
1522 {
1523         ASSERT_RTNL();
1524         return raw_notifier_call_chain(&netdev_chain, val, dev);
1525 }
1526 EXPORT_SYMBOL(call_netdevice_notifiers);
1527
1528 static struct static_key netstamp_needed __read_mostly;
1529 #ifdef HAVE_JUMP_LABEL
1530 /* We are not allowed to call static_key_slow_dec() from irq context
1531  * If net_disable_timestamp() is called from irq context, defer the
1532  * static_key_slow_dec() calls.
1533  */
1534 static atomic_t netstamp_needed_deferred;
1535 #endif
1536
1537 void net_enable_timestamp(void)
1538 {
1539 #ifdef HAVE_JUMP_LABEL
1540         int deferred = atomic_xchg(&netstamp_needed_deferred, 0);
1541
1542         if (deferred) {
1543                 while (--deferred)
1544                         static_key_slow_dec(&netstamp_needed);
1545                 return;
1546         }
1547 #endif
1548         static_key_slow_inc(&netstamp_needed);
1549 }
1550 EXPORT_SYMBOL(net_enable_timestamp);
1551
1552 void net_disable_timestamp(void)
1553 {
1554 #ifdef HAVE_JUMP_LABEL
1555         if (in_interrupt()) {
1556                 atomic_inc(&netstamp_needed_deferred);
1557                 return;
1558         }
1559 #endif
1560         static_key_slow_dec(&netstamp_needed);
1561 }
1562 EXPORT_SYMBOL(net_disable_timestamp);
1563
1564 static inline void net_timestamp_set(struct sk_buff *skb)
1565 {
1566         skb->tstamp.tv64 = 0;
1567         if (static_key_false(&netstamp_needed))
1568                 __net_timestamp(skb);
1569 }
1570
1571 #define net_timestamp_check(COND, SKB)                  \
1572         if (static_key_false(&netstamp_needed)) {               \
1573                 if ((COND) && !(SKB)->tstamp.tv64)      \
1574                         __net_timestamp(SKB);           \
1575         }                                               \
1576
1577 static inline bool is_skb_forwardable(struct net_device *dev,
1578                                       struct sk_buff *skb)
1579 {
1580         unsigned int len;
1581
1582         if (!(dev->flags & IFF_UP))
1583                 return false;
1584
1585         len = dev->mtu + dev->hard_header_len + VLAN_HLEN;
1586         if (skb->len <= len)
1587                 return true;
1588
1589         /* if TSO is enabled, we don't care about the length as the packet
1590          * could be forwarded without being segmented before
1591          */
1592         if (skb_is_gso(skb))
1593                 return true;
1594
1595         return false;
1596 }
1597
1598 /**
1599  * dev_forward_skb - loopback an skb to another netif
1600  *
1601  * @dev: destination network device
1602  * @skb: buffer to forward
1603  *
1604  * return values:
1605  *      NET_RX_SUCCESS  (no congestion)
1606  *      NET_RX_DROP     (packet was dropped, but freed)
1607  *
1608  * dev_forward_skb can be used for injecting an skb from the
1609  * start_xmit function of one device into the receive queue
1610  * of another device.
1611  *
1612  * The receiving device may be in another namespace, so
1613  * we have to clear all information in the skb that could
1614  * impact namespace isolation.
1615  */
1616 int dev_forward_skb(struct net_device *dev, struct sk_buff *skb)
1617 {
1618         if (skb_shinfo(skb)->tx_flags & SKBTX_DEV_ZEROCOPY) {
1619                 if (skb_copy_ubufs(skb, GFP_ATOMIC)) {
1620                         atomic_long_inc(&dev->rx_dropped);
1621                         kfree_skb(skb);
1622                         return NET_RX_DROP;
1623                 }
1624         }
1625
1626         skb_orphan(skb);
1627         nf_reset(skb);
1628
1629         if (unlikely(!is_skb_forwardable(dev, skb))) {
1630                 atomic_long_inc(&dev->rx_dropped);
1631                 kfree_skb(skb);
1632                 return NET_RX_DROP;
1633         }
1634         skb->skb_iif = 0;
1635         skb->dev = dev;
1636         skb_dst_drop(skb);
1637         skb->tstamp.tv64 = 0;
1638         skb->pkt_type = PACKET_HOST;
1639         skb->protocol = eth_type_trans(skb, dev);
1640         skb->mark = 0;
1641         secpath_reset(skb);
1642         nf_reset(skb);
1643         return netif_rx(skb);
1644 }
1645 EXPORT_SYMBOL_GPL(dev_forward_skb);
1646
1647 static inline int deliver_skb(struct sk_buff *skb,
1648                               struct packet_type *pt_prev,
1649                               struct net_device *orig_dev)
1650 {
1651         if (unlikely(skb_orphan_frags(skb, GFP_ATOMIC)))
1652                 return -ENOMEM;
1653         atomic_inc(&skb->users);
1654         return pt_prev->func(skb, skb->dev, pt_prev, orig_dev);
1655 }
1656
1657 static inline bool skb_loop_sk(struct packet_type *ptype, struct sk_buff *skb)
1658 {
1659         if (!ptype->af_packet_priv || !skb->sk)
1660                 return false;
1661
1662         if (ptype->id_match)
1663                 return ptype->id_match(ptype, skb->sk);
1664         else if ((struct sock *)ptype->af_packet_priv == skb->sk)
1665                 return true;
1666
1667         return false;
1668 }
1669
1670 /*
1671  *      Support routine. Sends outgoing frames to any network
1672  *      taps currently in use.
1673  */
1674
1675 static void dev_queue_xmit_nit(struct sk_buff *skb, struct net_device *dev)
1676 {
1677         struct packet_type *ptype;
1678         struct sk_buff *skb2 = NULL;
1679         struct packet_type *pt_prev = NULL;
1680
1681         rcu_read_lock();
1682         list_for_each_entry_rcu(ptype, &ptype_all, list) {
1683                 /* Never send packets back to the socket
1684                  * they originated from - MvS (miquels@drinkel.ow.org)
1685                  */
1686                 if ((ptype->dev == dev || !ptype->dev) &&
1687                     (!skb_loop_sk(ptype, skb))) {
1688                         if (pt_prev) {
1689                                 deliver_skb(skb2, pt_prev, skb->dev);
1690                                 pt_prev = ptype;
1691                                 continue;
1692                         }
1693
1694                         skb2 = skb_clone(skb, GFP_ATOMIC);
1695                         if (!skb2)
1696                                 break;
1697
1698                         net_timestamp_set(skb2);
1699
1700                         /* skb->nh should be correctly
1701                            set by sender, so that the second statement is
1702                            just protection against buggy protocols.
1703                          */
1704                         skb_reset_mac_header(skb2);
1705
1706                         if (skb_network_header(skb2) < skb2->data ||
1707                             skb2->network_header > skb2->tail) {
1708                                 net_crit_ratelimited("protocol %04x is buggy, dev %s\n",
1709                                                      ntohs(skb2->protocol),
1710                                                      dev->name);
1711                                 skb_reset_network_header(skb2);
1712                         }
1713
1714                         skb2->transport_header = skb2->network_header;
1715                         skb2->pkt_type = PACKET_OUTGOING;
1716                         pt_prev = ptype;
1717                 }
1718         }
1719         if (pt_prev)
1720                 pt_prev->func(skb2, skb->dev, pt_prev, skb->dev);
1721         rcu_read_unlock();
1722 }
1723
1724 /**
1725  * netif_setup_tc - Handle tc mappings on real_num_tx_queues change
1726  * @dev: Network device
1727  * @txq: number of queues available
1728  *
1729  * If real_num_tx_queues is changed the tc mappings may no longer be
1730  * valid. To resolve this verify the tc mapping remains valid and if
1731  * not NULL the mapping. With no priorities mapping to this
1732  * offset/count pair it will no longer be used. In the worst case TC0
1733  * is invalid nothing can be done so disable priority mappings. If is
1734  * expected that drivers will fix this mapping if they can before
1735  * calling netif_set_real_num_tx_queues.
1736  */
1737 static void netif_setup_tc(struct net_device *dev, unsigned int txq)
1738 {
1739         int i;
1740         struct netdev_tc_txq *tc = &dev->tc_to_txq[0];
1741
1742         /* If TC0 is invalidated disable TC mapping */
1743         if (tc->offset + tc->count > txq) {
1744                 pr_warn("Number of in use tx queues changed invalidating tc mappings. Priority traffic classification disabled!\n");
1745                 dev->num_tc = 0;
1746                 return;
1747         }
1748
1749         /* Invalidated prio to tc mappings set to TC0 */
1750         for (i = 1; i < TC_BITMASK + 1; i++) {
1751                 int q = netdev_get_prio_tc_map(dev, i);
1752
1753                 tc = &dev->tc_to_txq[q];
1754                 if (tc->offset + tc->count > txq) {
1755                         pr_warn("Number of in use tx queues changed. Priority %i to tc mapping %i is no longer valid. Setting map to 0\n",
1756                                 i, q);
1757                         netdev_set_prio_tc_map(dev, i, 0);
1758                 }
1759         }
1760 }
1761
1762 #ifdef CONFIG_XPS
1763 static DEFINE_MUTEX(xps_map_mutex);
1764 #define xmap_dereference(P)             \
1765         rcu_dereference_protected((P), lockdep_is_held(&xps_map_mutex))
1766
1767 static struct xps_map *remove_xps_queue(struct xps_dev_maps *dev_maps,
1768                                         int cpu, u16 index)
1769 {
1770         struct xps_map *map = NULL;
1771         int pos;
1772
1773         if (dev_maps)
1774                 map = xmap_dereference(dev_maps->cpu_map[cpu]);
1775
1776         for (pos = 0; map && pos < map->len; pos++) {
1777                 if (map->queues[pos] == index) {
1778                         if (map->len > 1) {
1779                                 map->queues[pos] = map->queues[--map->len];
1780                         } else {
1781                                 RCU_INIT_POINTER(dev_maps->cpu_map[cpu], NULL);
1782                                 kfree_rcu(map, rcu);
1783                                 map = NULL;
1784                         }
1785                         break;
1786                 }
1787         }
1788
1789         return map;
1790 }
1791
1792 static void netif_reset_xps_queues_gt(struct net_device *dev, u16 index)
1793 {
1794         struct xps_dev_maps *dev_maps;
1795         int cpu, i;
1796         bool active = false;
1797
1798         mutex_lock(&xps_map_mutex);
1799         dev_maps = xmap_dereference(dev->xps_maps);
1800
1801         if (!dev_maps)
1802                 goto out_no_maps;
1803
1804         for_each_possible_cpu(cpu) {
1805                 for (i = index; i < dev->num_tx_queues; i++) {
1806                         if (!remove_xps_queue(dev_maps, cpu, i))
1807                                 break;
1808                 }
1809                 if (i == dev->num_tx_queues)
1810                         active = true;
1811         }
1812
1813         if (!active) {
1814                 RCU_INIT_POINTER(dev->xps_maps, NULL);
1815                 kfree_rcu(dev_maps, rcu);
1816         }
1817
1818         for (i = index; i < dev->num_tx_queues; i++)
1819                 netdev_queue_numa_node_write(netdev_get_tx_queue(dev, i),
1820                                              NUMA_NO_NODE);
1821
1822 out_no_maps:
1823         mutex_unlock(&xps_map_mutex);
1824 }
1825
1826 static struct xps_map *expand_xps_map(struct xps_map *map,
1827                                       int cpu, u16 index)
1828 {
1829         struct xps_map *new_map;
1830         int alloc_len = XPS_MIN_MAP_ALLOC;
1831         int i, pos;
1832
1833         for (pos = 0; map && pos < map->len; pos++) {
1834                 if (map->queues[pos] != index)
1835                         continue;
1836                 return map;
1837         }
1838
1839         /* Need to add queue to this CPU's existing map */
1840         if (map) {
1841                 if (pos < map->alloc_len)
1842                         return map;
1843
1844                 alloc_len = map->alloc_len * 2;
1845         }
1846
1847         /* Need to allocate new map to store queue on this CPU's map */
1848         new_map = kzalloc_node(XPS_MAP_SIZE(alloc_len), GFP_KERNEL,
1849                                cpu_to_node(cpu));
1850         if (!new_map)
1851                 return NULL;
1852
1853         for (i = 0; i < pos; i++)
1854                 new_map->queues[i] = map->queues[i];
1855         new_map->alloc_len = alloc_len;
1856         new_map->len = pos;
1857
1858         return new_map;
1859 }
1860
1861 int netif_set_xps_queue(struct net_device *dev, struct cpumask *mask, u16 index)
1862 {
1863         struct xps_dev_maps *dev_maps, *new_dev_maps = NULL;
1864         struct xps_map *map, *new_map;
1865         int maps_sz = max_t(unsigned int, XPS_DEV_MAPS_SIZE, L1_CACHE_BYTES);
1866         int cpu, numa_node_id = -2;
1867         bool active = false;
1868
1869         mutex_lock(&xps_map_mutex);
1870
1871         dev_maps = xmap_dereference(dev->xps_maps);
1872
1873         /* allocate memory for queue storage */
1874         for_each_online_cpu(cpu) {
1875                 if (!cpumask_test_cpu(cpu, mask))
1876                         continue;
1877
1878                 if (!new_dev_maps)
1879                         new_dev_maps = kzalloc(maps_sz, GFP_KERNEL);
1880                 if (!new_dev_maps) {
1881                         mutex_unlock(&xps_map_mutex);
1882                         return -ENOMEM;
1883                 }
1884
1885                 map = dev_maps ? xmap_dereference(dev_maps->cpu_map[cpu]) :
1886                                  NULL;
1887
1888                 map = expand_xps_map(map, cpu, index);
1889                 if (!map)
1890                         goto error;
1891
1892                 RCU_INIT_POINTER(new_dev_maps->cpu_map[cpu], map);
1893         }
1894
1895         if (!new_dev_maps)
1896                 goto out_no_new_maps;
1897
1898         for_each_possible_cpu(cpu) {
1899                 if (cpumask_test_cpu(cpu, mask) && cpu_online(cpu)) {
1900                         /* add queue to CPU maps */
1901                         int pos = 0;
1902
1903                         map = xmap_dereference(new_dev_maps->cpu_map[cpu]);
1904                         while ((pos < map->len) && (map->queues[pos] != index))
1905                                 pos++;
1906
1907                         if (pos == map->len)
1908                                 map->queues[map->len++] = index;
1909 #ifdef CONFIG_NUMA
1910                         if (numa_node_id == -2)
1911                                 numa_node_id = cpu_to_node(cpu);
1912                         else if (numa_node_id != cpu_to_node(cpu))
1913                                 numa_node_id = -1;
1914 #endif
1915                 } else if (dev_maps) {
1916                         /* fill in the new device map from the old device map */
1917                         map = xmap_dereference(dev_maps->cpu_map[cpu]);
1918                         RCU_INIT_POINTER(new_dev_maps->cpu_map[cpu], map);
1919                 }
1920
1921         }
1922
1923         rcu_assign_pointer(dev->xps_maps, new_dev_maps);
1924
1925         /* Cleanup old maps */
1926         if (dev_maps) {
1927                 for_each_possible_cpu(cpu) {
1928                         new_map = xmap_dereference(new_dev_maps->cpu_map[cpu]);
1929                         map = xmap_dereference(dev_maps->cpu_map[cpu]);
1930                         if (map && map != new_map)
1931                                 kfree_rcu(map, rcu);
1932                 }
1933
1934                 kfree_rcu(dev_maps, rcu);
1935         }
1936
1937         dev_maps = new_dev_maps;
1938         active = true;
1939
1940 out_no_new_maps:
1941         /* update Tx queue numa node */
1942         netdev_queue_numa_node_write(netdev_get_tx_queue(dev, index),
1943                                      (numa_node_id >= 0) ? numa_node_id :
1944                                      NUMA_NO_NODE);
1945
1946         if (!dev_maps)
1947                 goto out_no_maps;
1948
1949         /* removes queue from unused CPUs */
1950         for_each_possible_cpu(cpu) {
1951                 if (cpumask_test_cpu(cpu, mask) && cpu_online(cpu))
1952                         continue;
1953
1954                 if (remove_xps_queue(dev_maps, cpu, index))
1955                         active = true;
1956         }
1957
1958         /* free map if not active */
1959         if (!active) {
1960                 RCU_INIT_POINTER(dev->xps_maps, NULL);
1961                 kfree_rcu(dev_maps, rcu);
1962         }
1963
1964 out_no_maps:
1965         mutex_unlock(&xps_map_mutex);
1966
1967         return 0;
1968 error:
1969         /* remove any maps that we added */
1970         for_each_possible_cpu(cpu) {
1971                 new_map = xmap_dereference(new_dev_maps->cpu_map[cpu]);
1972                 map = dev_maps ? xmap_dereference(dev_maps->cpu_map[cpu]) :
1973                                  NULL;
1974                 if (new_map && new_map != map)
1975                         kfree(new_map);
1976         }
1977
1978         mutex_unlock(&xps_map_mutex);
1979
1980         kfree(new_dev_maps);
1981         return -ENOMEM;
1982 }
1983 EXPORT_SYMBOL(netif_set_xps_queue);
1984
1985 #endif
1986 /*
1987  * Routine to help set real_num_tx_queues. To avoid skbs mapped to queues
1988  * greater then real_num_tx_queues stale skbs on the qdisc must be flushed.
1989  */
1990 int netif_set_real_num_tx_queues(struct net_device *dev, unsigned int txq)
1991 {
1992         int rc;
1993
1994         if (txq < 1 || txq > dev->num_tx_queues)
1995                 return -EINVAL;
1996
1997         if (dev->reg_state == NETREG_REGISTERED ||
1998             dev->reg_state == NETREG_UNREGISTERING) {
1999                 ASSERT_RTNL();
2000
2001                 rc = netdev_queue_update_kobjects(dev, dev->real_num_tx_queues,
2002                                                   txq);
2003                 if (rc)
2004                         return rc;
2005
2006                 if (dev->num_tc)
2007                         netif_setup_tc(dev, txq);
2008
2009                 if (txq < dev->real_num_tx_queues) {
2010                         qdisc_reset_all_tx_gt(dev, txq);
2011 #ifdef CONFIG_XPS
2012                         netif_reset_xps_queues_gt(dev, txq);
2013 #endif
2014                 }
2015         }
2016
2017         dev->real_num_tx_queues = txq;
2018         return 0;
2019 }
2020 EXPORT_SYMBOL(netif_set_real_num_tx_queues);
2021
2022 #ifdef CONFIG_RPS
2023 /**
2024  *      netif_set_real_num_rx_queues - set actual number of RX queues used
2025  *      @dev: Network device
2026  *      @rxq: Actual number of RX queues
2027  *
2028  *      This must be called either with the rtnl_lock held or before
2029  *      registration of the net device.  Returns 0 on success, or a
2030  *      negative error code.  If called before registration, it always
2031  *      succeeds.
2032  */
2033 int netif_set_real_num_rx_queues(struct net_device *dev, unsigned int rxq)
2034 {
2035         int rc;
2036
2037         if (rxq < 1 || rxq > dev->num_rx_queues)
2038                 return -EINVAL;
2039
2040         if (dev->reg_state == NETREG_REGISTERED) {
2041                 ASSERT_RTNL();
2042
2043                 rc = net_rx_queue_update_kobjects(dev, dev->real_num_rx_queues,
2044                                                   rxq);
2045                 if (rc)
2046                         return rc;
2047         }
2048
2049         dev->real_num_rx_queues = rxq;
2050         return 0;
2051 }
2052 EXPORT_SYMBOL(netif_set_real_num_rx_queues);
2053 #endif
2054
2055 /**
2056  * netif_get_num_default_rss_queues - default number of RSS queues
2057  *
2058  * This routine should set an upper limit on the number of RSS queues
2059  * used by default by multiqueue devices.
2060  */
2061 int netif_get_num_default_rss_queues(void)
2062 {
2063         return min_t(int, DEFAULT_MAX_NUM_RSS_QUEUES, num_online_cpus());
2064 }
2065 EXPORT_SYMBOL(netif_get_num_default_rss_queues);
2066
2067 static inline void __netif_reschedule(struct Qdisc *q)
2068 {
2069         struct softnet_data *sd;
2070         unsigned long flags;
2071
2072         local_irq_save(flags);
2073         sd = &__get_cpu_var(softnet_data);
2074         q->next_sched = NULL;
2075         *sd->output_queue_tailp = q;
2076         sd->output_queue_tailp = &q->next_sched;
2077         raise_softirq_irqoff(NET_TX_SOFTIRQ);
2078         local_irq_restore(flags);
2079 }
2080
2081 void __netif_schedule(struct Qdisc *q)
2082 {
2083         if (!test_and_set_bit(__QDISC_STATE_SCHED, &q->state))
2084                 __netif_reschedule(q);
2085 }
2086 EXPORT_SYMBOL(__netif_schedule);
2087
2088 void dev_kfree_skb_irq(struct sk_buff *skb)
2089 {
2090         if (atomic_dec_and_test(&skb->users)) {
2091                 struct softnet_data *sd;
2092                 unsigned long flags;
2093
2094                 local_irq_save(flags);
2095                 sd = &__get_cpu_var(softnet_data);
2096                 skb->next = sd->completion_queue;
2097                 sd->completion_queue = skb;
2098                 raise_softirq_irqoff(NET_TX_SOFTIRQ);
2099                 local_irq_restore(flags);
2100         }
2101 }
2102 EXPORT_SYMBOL(dev_kfree_skb_irq);
2103
2104 void dev_kfree_skb_any(struct sk_buff *skb)
2105 {
2106         if (in_irq() || irqs_disabled())
2107                 dev_kfree_skb_irq(skb);
2108         else
2109                 dev_kfree_skb(skb);
2110 }
2111 EXPORT_SYMBOL(dev_kfree_skb_any);
2112
2113
2114 /**
2115  * netif_device_detach - mark device as removed
2116  * @dev: network device
2117  *
2118  * Mark device as removed from system and therefore no longer available.
2119  */
2120 void netif_device_detach(struct net_device *dev)
2121 {
2122         if (test_and_clear_bit(__LINK_STATE_PRESENT, &dev->state) &&
2123             netif_running(dev)) {
2124                 netif_tx_stop_all_queues(dev);
2125         }
2126 }
2127 EXPORT_SYMBOL(netif_device_detach);
2128
2129 /**
2130  * netif_device_attach - mark device as attached
2131  * @dev: network device
2132  *
2133  * Mark device as attached from system and restart if needed.
2134  */
2135 void netif_device_attach(struct net_device *dev)
2136 {
2137         if (!test_and_set_bit(__LINK_STATE_PRESENT, &dev->state) &&
2138             netif_running(dev)) {
2139                 netif_tx_wake_all_queues(dev);
2140                 __netdev_watchdog_up(dev);
2141         }
2142 }
2143 EXPORT_SYMBOL(netif_device_attach);
2144
2145 static void skb_warn_bad_offload(const struct sk_buff *skb)
2146 {
2147         static const netdev_features_t null_features = 0;
2148         struct net_device *dev = skb->dev;
2149         const char *driver = "";
2150
2151         if (dev && dev->dev.parent)
2152                 driver = dev_driver_string(dev->dev.parent);
2153
2154         WARN(1, "%s: caps=(%pNF, %pNF) len=%d data_len=%d gso_size=%d "
2155              "gso_type=%d ip_summed=%d\n",
2156              driver, dev ? &dev->features : &null_features,
2157              skb->sk ? &skb->sk->sk_route_caps : &null_features,
2158              skb->len, skb->data_len, skb_shinfo(skb)->gso_size,
2159              skb_shinfo(skb)->gso_type, skb->ip_summed);
2160 }
2161
2162 /*
2163  * Invalidate hardware checksum when packet is to be mangled, and
2164  * complete checksum manually on outgoing path.
2165  */
2166 int skb_checksum_help(struct sk_buff *skb)
2167 {
2168         __wsum csum;
2169         int ret = 0, offset;
2170
2171         if (skb->ip_summed == CHECKSUM_COMPLETE)
2172                 goto out_set_summed;
2173
2174         if (unlikely(skb_shinfo(skb)->gso_size)) {
2175                 skb_warn_bad_offload(skb);
2176                 return -EINVAL;
2177         }
2178
2179         /* Before computing a checksum, we should make sure no frag could
2180          * be modified by an external entity : checksum could be wrong.
2181          */
2182         if (skb_has_shared_frag(skb)) {
2183                 ret = __skb_linearize(skb);
2184                 if (ret)
2185                         goto out;
2186         }
2187
2188         offset = skb_checksum_start_offset(skb);
2189         BUG_ON(offset >= skb_headlen(skb));
2190         csum = skb_checksum(skb, offset, skb->len - offset, 0);
2191
2192         offset += skb->csum_offset;
2193         BUG_ON(offset + sizeof(__sum16) > skb_headlen(skb));
2194
2195         if (skb_cloned(skb) &&
2196             !skb_clone_writable(skb, offset + sizeof(__sum16))) {
2197                 ret = pskb_expand_head(skb, 0, 0, GFP_ATOMIC);
2198                 if (ret)
2199                         goto out;
2200         }
2201
2202         *(__sum16 *)(skb->data + offset) = csum_fold(csum);
2203 out_set_summed:
2204         skb->ip_summed = CHECKSUM_NONE;
2205 out:
2206         return ret;
2207 }
2208 EXPORT_SYMBOL(skb_checksum_help);
2209
2210 __be16 skb_network_protocol(struct sk_buff *skb)
2211 {
2212         __be16 type = skb->protocol;
2213         int vlan_depth = ETH_HLEN;
2214
2215         while (type == htons(ETH_P_8021Q)) {
2216                 struct vlan_hdr *vh;
2217
2218                 if (unlikely(!pskb_may_pull(skb, vlan_depth + VLAN_HLEN)))
2219                         return 0;
2220
2221                 vh = (struct vlan_hdr *)(skb->data + vlan_depth);
2222                 type = vh->h_vlan_encapsulated_proto;
2223                 vlan_depth += VLAN_HLEN;
2224         }
2225
2226         return type;
2227 }
2228
2229 /**
2230  *      skb_mac_gso_segment - mac layer segmentation handler.
2231  *      @skb: buffer to segment
2232  *      @features: features for the output path (see dev->features)
2233  */
2234 struct sk_buff *skb_mac_gso_segment(struct sk_buff *skb,
2235                                     netdev_features_t features)
2236 {
2237         struct sk_buff *segs = ERR_PTR(-EPROTONOSUPPORT);
2238         struct packet_offload *ptype;
2239         __be16 type = skb_network_protocol(skb);
2240
2241         if (unlikely(!type))
2242                 return ERR_PTR(-EINVAL);
2243
2244         __skb_pull(skb, skb->mac_len);
2245
2246         rcu_read_lock();
2247         list_for_each_entry_rcu(ptype, &offload_base, list) {
2248                 if (ptype->type == type && ptype->callbacks.gso_segment) {
2249                         if (unlikely(skb->ip_summed != CHECKSUM_PARTIAL)) {
2250                                 int err;
2251
2252                                 err = ptype->callbacks.gso_send_check(skb);
2253                                 segs = ERR_PTR(err);
2254                                 if (err || skb_gso_ok(skb, features))
2255                                         break;
2256                                 __skb_push(skb, (skb->data -
2257                                                  skb_network_header(skb)));
2258                         }
2259                         segs = ptype->callbacks.gso_segment(skb, features);
2260                         break;
2261                 }
2262         }
2263         rcu_read_unlock();
2264
2265         __skb_push(skb, skb->data - skb_mac_header(skb));
2266
2267         return segs;
2268 }
2269 EXPORT_SYMBOL(skb_mac_gso_segment);
2270
2271
2272 /* openvswitch calls this on rx path, so we need a different check.
2273  */
2274 static inline bool skb_needs_check(struct sk_buff *skb, bool tx_path)
2275 {
2276         if (tx_path)
2277                 return skb->ip_summed != CHECKSUM_PARTIAL;
2278         else
2279                 return skb->ip_summed == CHECKSUM_NONE;
2280 }
2281
2282 /**
2283  *      __skb_gso_segment - Perform segmentation on skb.
2284  *      @skb: buffer to segment
2285  *      @features: features for the output path (see dev->features)
2286  *      @tx_path: whether it is called in TX path
2287  *
2288  *      This function segments the given skb and returns a list of segments.
2289  *
2290  *      It may return NULL if the skb requires no segmentation.  This is
2291  *      only possible when GSO is used for verifying header integrity.
2292  */
2293 struct sk_buff *__skb_gso_segment(struct sk_buff *skb,
2294                                   netdev_features_t features, bool tx_path)
2295 {
2296         if (unlikely(skb_needs_check(skb, tx_path))) {
2297                 int err;
2298
2299                 skb_warn_bad_offload(skb);
2300
2301                 if (skb_header_cloned(skb) &&
2302                     (err = pskb_expand_head(skb, 0, 0, GFP_ATOMIC)))
2303                         return ERR_PTR(err);
2304         }
2305
2306         SKB_GSO_CB(skb)->mac_offset = skb_headroom(skb);
2307         skb_reset_mac_header(skb);
2308         skb_reset_mac_len(skb);
2309
2310         return skb_mac_gso_segment(skb, features);
2311 }
2312 EXPORT_SYMBOL(__skb_gso_segment);
2313
2314 /* Take action when hardware reception checksum errors are detected. */
2315 #ifdef CONFIG_BUG
2316 void netdev_rx_csum_fault(struct net_device *dev)
2317 {
2318         if (net_ratelimit()) {
2319                 pr_err("%s: hw csum failure\n", dev ? dev->name : "<unknown>");
2320                 dump_stack();
2321         }
2322 }
2323 EXPORT_SYMBOL(netdev_rx_csum_fault);
2324 #endif
2325
2326 /* Actually, we should eliminate this check as soon as we know, that:
2327  * 1. IOMMU is present and allows to map all the memory.
2328  * 2. No high memory really exists on this machine.
2329  */
2330
2331 static int illegal_highdma(struct net_device *dev, struct sk_buff *skb)
2332 {
2333 #ifdef CONFIG_HIGHMEM
2334         int i;
2335         if (!(dev->features & NETIF_F_HIGHDMA)) {
2336                 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
2337                         skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
2338                         if (PageHighMem(skb_frag_page(frag)))
2339                                 return 1;
2340                 }
2341         }
2342
2343         if (PCI_DMA_BUS_IS_PHYS) {
2344                 struct device *pdev = dev->dev.parent;
2345
2346                 if (!pdev)
2347                         return 0;
2348                 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
2349                         skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
2350                         dma_addr_t addr = page_to_phys(skb_frag_page(frag));
2351                         if (!pdev->dma_mask || addr + PAGE_SIZE - 1 > *pdev->dma_mask)
2352                                 return 1;
2353                 }
2354         }
2355 #endif
2356         return 0;
2357 }
2358
2359 struct dev_gso_cb {
2360         void (*destructor)(struct sk_buff *skb);
2361 };
2362
2363 #define DEV_GSO_CB(skb) ((struct dev_gso_cb *)(skb)->cb)
2364
2365 static void dev_gso_skb_destructor(struct sk_buff *skb)
2366 {
2367         struct dev_gso_cb *cb;
2368
2369         do {
2370                 struct sk_buff *nskb = skb->next;
2371
2372                 skb->next = nskb->next;
2373                 nskb->next = NULL;
2374                 kfree_skb(nskb);
2375         } while (skb->next);
2376
2377         cb = DEV_GSO_CB(skb);
2378         if (cb->destructor)
2379                 cb->destructor(skb);
2380 }
2381
2382 /**
2383  *      dev_gso_segment - Perform emulated hardware segmentation on skb.
2384  *      @skb: buffer to segment
2385  *      @features: device features as applicable to this skb
2386  *
2387  *      This function segments the given skb and stores the list of segments
2388  *      in skb->next.
2389  */
2390 static int dev_gso_segment(struct sk_buff *skb, netdev_features_t features)
2391 {
2392         struct sk_buff *segs;
2393
2394         segs = skb_gso_segment(skb, features);
2395
2396         /* Verifying header integrity only. */
2397         if (!segs)
2398                 return 0;
2399
2400         if (IS_ERR(segs))
2401                 return PTR_ERR(segs);
2402
2403         skb->next = segs;
2404         DEV_GSO_CB(skb)->destructor = skb->destructor;
2405         skb->destructor = dev_gso_skb_destructor;
2406
2407         return 0;
2408 }
2409
2410 static netdev_features_t harmonize_features(struct sk_buff *skb,
2411         __be16 protocol, netdev_features_t features)
2412 {
2413         if (skb->ip_summed != CHECKSUM_NONE &&
2414             !can_checksum_protocol(features, protocol)) {
2415                 features &= ~NETIF_F_ALL_CSUM;
2416         } else if (illegal_highdma(skb->dev, skb)) {
2417                 features &= ~NETIF_F_SG;
2418         }
2419
2420         return features;
2421 }
2422
2423 netdev_features_t netif_skb_features(struct sk_buff *skb)
2424 {
2425         __be16 protocol = skb->protocol;
2426         netdev_features_t features = skb->dev->features;
2427
2428         if (skb_shinfo(skb)->gso_segs > skb->dev->gso_max_segs)
2429                 features &= ~NETIF_F_GSO_MASK;
2430
2431         if (protocol == htons(ETH_P_8021Q)) {
2432                 struct vlan_ethhdr *veh = (struct vlan_ethhdr *)skb->data;
2433                 protocol = veh->h_vlan_encapsulated_proto;
2434         } else if (!vlan_tx_tag_present(skb)) {
2435                 return harmonize_features(skb, protocol, features);
2436         }
2437
2438         features &= (skb->dev->vlan_features | NETIF_F_HW_VLAN_TX);
2439
2440         if (protocol != htons(ETH_P_8021Q)) {
2441                 return harmonize_features(skb, protocol, features);
2442         } else {
2443                 features &= NETIF_F_SG | NETIF_F_HIGHDMA | NETIF_F_FRAGLIST |
2444                                 NETIF_F_GEN_CSUM | NETIF_F_HW_VLAN_TX;
2445                 return harmonize_features(skb, protocol, features);
2446         }
2447 }
2448 EXPORT_SYMBOL(netif_skb_features);
2449
2450 /*
2451  * Returns true if either:
2452  *      1. skb has frag_list and the device doesn't support FRAGLIST, or
2453  *      2. skb is fragmented and the device does not support SG.
2454  */
2455 static inline int skb_needs_linearize(struct sk_buff *skb,
2456                                       int features)
2457 {
2458         return skb_is_nonlinear(skb) &&
2459                         ((skb_has_frag_list(skb) &&
2460                                 !(features & NETIF_F_FRAGLIST)) ||
2461                         (skb_shinfo(skb)->nr_frags &&
2462                                 !(features & NETIF_F_SG)));
2463 }
2464
2465 int dev_hard_start_xmit(struct sk_buff *skb, struct net_device *dev,
2466                         struct netdev_queue *txq)
2467 {
2468         const struct net_device_ops *ops = dev->netdev_ops;
2469         int rc = NETDEV_TX_OK;
2470         unsigned int skb_len;
2471
2472         if (likely(!skb->next)) {
2473                 netdev_features_t features;
2474
2475                 /*
2476                  * If device doesn't need skb->dst, release it right now while
2477                  * its hot in this cpu cache
2478                  */
2479                 if (dev->priv_flags & IFF_XMIT_DST_RELEASE)
2480                         skb_dst_drop(skb);
2481
2482                 features = netif_skb_features(skb);
2483
2484                 if (vlan_tx_tag_present(skb) &&
2485                     !(features & NETIF_F_HW_VLAN_TX)) {
2486                         skb = __vlan_put_tag(skb, vlan_tx_tag_get(skb));
2487                         if (unlikely(!skb))
2488                                 goto out;
2489
2490                         skb->vlan_tci = 0;
2491                 }
2492
2493                 /* If encapsulation offload request, verify we are testing
2494                  * hardware encapsulation features instead of standard
2495                  * features for the netdev
2496                  */
2497                 if (skb->encapsulation)
2498                         features &= dev->hw_enc_features;
2499
2500                 if (netif_needs_gso(skb, features)) {
2501                         if (unlikely(dev_gso_segment(skb, features)))
2502                                 goto out_kfree_skb;
2503                         if (skb->next)
2504                                 goto gso;
2505                 } else {
2506                         if (skb_needs_linearize(skb, features) &&
2507                             __skb_linearize(skb))
2508                                 goto out_kfree_skb;
2509
2510                         /* If packet is not checksummed and device does not
2511                          * support checksumming for this protocol, complete
2512                          * checksumming here.
2513                          */
2514                         if (skb->ip_summed == CHECKSUM_PARTIAL) {
2515                                 if (skb->encapsulation)
2516                                         skb_set_inner_transport_header(skb,
2517                                                 skb_checksum_start_offset(skb));
2518                                 else
2519                                         skb_set_transport_header(skb,
2520                                                 skb_checksum_start_offset(skb));
2521                                 if (!(features & NETIF_F_ALL_CSUM) &&
2522                                      skb_checksum_help(skb))
2523                                         goto out_kfree_skb;
2524                         }
2525                 }
2526
2527                 if (!list_empty(&ptype_all))
2528                         dev_queue_xmit_nit(skb, dev);
2529
2530                 skb_len = skb->len;
2531                 rc = ops->ndo_start_xmit(skb, dev);
2532                 trace_net_dev_xmit(skb, rc, dev, skb_len);
2533                 if (rc == NETDEV_TX_OK)
2534                         txq_trans_update(txq);
2535                 return rc;
2536         }
2537
2538 gso:
2539         do {
2540                 struct sk_buff *nskb = skb->next;
2541
2542                 skb->next = nskb->next;
2543                 nskb->next = NULL;
2544
2545                 /*
2546                  * If device doesn't need nskb->dst, release it right now while
2547                  * its hot in this cpu cache
2548                  */
2549                 if (dev->priv_flags & IFF_XMIT_DST_RELEASE)
2550                         skb_dst_drop(nskb);
2551
2552                 if (!list_empty(&ptype_all))
2553                         dev_queue_xmit_nit(nskb, dev);
2554
2555                 skb_len = nskb->len;
2556                 rc = ops->ndo_start_xmit(nskb, dev);
2557                 trace_net_dev_xmit(nskb, rc, dev, skb_len);
2558                 if (unlikely(rc != NETDEV_TX_OK)) {
2559                         if (rc & ~NETDEV_TX_MASK)
2560                                 goto out_kfree_gso_skb;
2561                         nskb->next = skb->next;
2562                         skb->next = nskb;
2563                         return rc;
2564                 }
2565                 txq_trans_update(txq);
2566                 if (unlikely(netif_xmit_stopped(txq) && skb->next))
2567                         return NETDEV_TX_BUSY;
2568         } while (skb->next);
2569
2570 out_kfree_gso_skb:
2571         if (likely(skb->next == NULL))
2572                 skb->destructor = DEV_GSO_CB(skb)->destructor;
2573 out_kfree_skb:
2574         kfree_skb(skb);
2575 out:
2576         return rc;
2577 }
2578
2579 static void qdisc_pkt_len_init(struct sk_buff *skb)
2580 {
2581         const struct skb_shared_info *shinfo = skb_shinfo(skb);
2582
2583         qdisc_skb_cb(skb)->pkt_len = skb->len;
2584
2585         /* To get more precise estimation of bytes sent on wire,
2586          * we add to pkt_len the headers size of all segments
2587          */
2588         if (shinfo->gso_size)  {
2589                 unsigned int hdr_len;
2590                 u16 gso_segs = shinfo->gso_segs;
2591
2592                 /* mac layer + network layer */
2593                 hdr_len = skb_transport_header(skb) - skb_mac_header(skb);
2594
2595                 /* + transport layer */
2596                 if (likely(shinfo->gso_type & (SKB_GSO_TCPV4 | SKB_GSO_TCPV6)))
2597                         hdr_len += tcp_hdrlen(skb);
2598                 else
2599                         hdr_len += sizeof(struct udphdr);
2600
2601                 if (shinfo->gso_type & SKB_GSO_DODGY)
2602                         gso_segs = DIV_ROUND_UP(skb->len - hdr_len,
2603                                                 shinfo->gso_size);
2604
2605                 qdisc_skb_cb(skb)->pkt_len += (gso_segs - 1) * hdr_len;
2606         }
2607 }
2608
2609 static inline int __dev_xmit_skb(struct sk_buff *skb, struct Qdisc *q,
2610                                  struct net_device *dev,
2611                                  struct netdev_queue *txq)
2612 {
2613         spinlock_t *root_lock = qdisc_lock(q);
2614         bool contended;
2615         int rc;
2616
2617         qdisc_pkt_len_init(skb);
2618         qdisc_calculate_pkt_len(skb, q);
2619         /*
2620          * Heuristic to force contended enqueues to serialize on a
2621          * separate lock before trying to get qdisc main lock.
2622          * This permits __QDISC_STATE_RUNNING owner to get the lock more often
2623          * and dequeue packets faster.
2624          */
2625         contended = qdisc_is_running(q);
2626         if (unlikely(contended))
2627                 spin_lock(&q->busylock);
2628
2629         spin_lock(root_lock);
2630         if (unlikely(test_bit(__QDISC_STATE_DEACTIVATED, &q->state))) {
2631                 kfree_skb(skb);
2632                 rc = NET_XMIT_DROP;
2633         } else if ((q->flags & TCQ_F_CAN_BYPASS) && !qdisc_qlen(q) &&
2634                    qdisc_run_begin(q)) {
2635                 /*
2636                  * This is a work-conserving queue; there are no old skbs
2637                  * waiting to be sent out; and the qdisc is not running -
2638                  * xmit the skb directly.
2639                  */
2640                 if (!(dev->priv_flags & IFF_XMIT_DST_RELEASE))
2641                         skb_dst_force(skb);
2642
2643                 qdisc_bstats_update(q, skb);
2644
2645                 if (sch_direct_xmit(skb, q, dev, txq, root_lock)) {
2646                         if (unlikely(contended)) {
2647                                 spin_unlock(&q->busylock);
2648                                 contended = false;
2649                         }
2650                         __qdisc_run(q);
2651                 } else
2652                         qdisc_run_end(q);
2653
2654                 rc = NET_XMIT_SUCCESS;
2655         } else {
2656                 skb_dst_force(skb);
2657                 rc = q->enqueue(skb, q) & NET_XMIT_MASK;
2658                 if (qdisc_run_begin(q)) {
2659                         if (unlikely(contended)) {
2660                                 spin_unlock(&q->busylock);
2661                                 contended = false;
2662                         }
2663                         __qdisc_run(q);
2664                 }
2665         }
2666         spin_unlock(root_lock);
2667         if (unlikely(contended))
2668                 spin_unlock(&q->busylock);
2669         return rc;
2670 }
2671
2672 #if IS_ENABLED(CONFIG_NETPRIO_CGROUP)
2673 static void skb_update_prio(struct sk_buff *skb)
2674 {
2675         struct netprio_map *map = rcu_dereference_bh(skb->dev->priomap);
2676
2677         if (!skb->priority && skb->sk && map) {
2678                 unsigned int prioidx = skb->sk->sk_cgrp_prioidx;
2679
2680                 if (prioidx < map->priomap_len)
2681                         skb->priority = map->priomap[prioidx];
2682         }
2683 }
2684 #else
2685 #define skb_update_prio(skb)
2686 #endif
2687
2688 static DEFINE_PER_CPU(int, xmit_recursion);
2689 #define RECURSION_LIMIT 10
2690
2691 /**
2692  *      dev_loopback_xmit - loop back @skb
2693  *      @skb: buffer to transmit
2694  */
2695 int dev_loopback_xmit(struct sk_buff *skb)
2696 {
2697         skb_reset_mac_header(skb);
2698         __skb_pull(skb, skb_network_offset(skb));
2699         skb->pkt_type = PACKET_LOOPBACK;
2700         skb->ip_summed = CHECKSUM_UNNECESSARY;
2701         WARN_ON(!skb_dst(skb));
2702         skb_dst_force(skb);
2703         netif_rx_ni(skb);
2704         return 0;
2705 }
2706 EXPORT_SYMBOL(dev_loopback_xmit);
2707
2708 /**
2709  *      dev_queue_xmit - transmit a buffer
2710  *      @skb: buffer to transmit
2711  *
2712  *      Queue a buffer for transmission to a network device. The caller must
2713  *      have set the device and priority and built the buffer before calling
2714  *      this function. The function can be called from an interrupt.
2715  *
2716  *      A negative errno code is returned on a failure. A success does not
2717  *      guarantee the frame will be transmitted as it may be dropped due
2718  *      to congestion or traffic shaping.
2719  *
2720  * -----------------------------------------------------------------------------------
2721  *      I notice this method can also return errors from the queue disciplines,
2722  *      including NET_XMIT_DROP, which is a positive value.  So, errors can also
2723  *      be positive.
2724  *
2725  *      Regardless of the return value, the skb is consumed, so it is currently
2726  *      difficult to retry a send to this method.  (You can bump the ref count
2727  *      before sending to hold a reference for retry if you are careful.)
2728  *
2729  *      When calling this method, interrupts MUST be enabled.  This is because
2730  *      the BH enable code must have IRQs enabled so that it will not deadlock.
2731  *          --BLG
2732  */
2733 int dev_queue_xmit(struct sk_buff *skb)
2734 {
2735         struct net_device *dev = skb->dev;
2736         struct netdev_queue *txq;
2737         struct Qdisc *q;
2738         int rc = -ENOMEM;
2739
2740         skb_reset_mac_header(skb);
2741
2742         /* Disable soft irqs for various locks below. Also
2743          * stops preemption for RCU.
2744          */
2745         rcu_read_lock_bh();
2746
2747         skb_update_prio(skb);
2748
2749         txq = netdev_pick_tx(dev, skb);
2750         q = rcu_dereference_bh(txq->qdisc);
2751
2752 #ifdef CONFIG_NET_CLS_ACT
2753         skb->tc_verd = SET_TC_AT(skb->tc_verd, AT_EGRESS);
2754 #endif
2755         trace_net_dev_queue(skb);
2756         if (q->enqueue) {
2757                 rc = __dev_xmit_skb(skb, q, dev, txq);
2758                 goto out;
2759         }
2760
2761         /* The device has no queue. Common case for software devices:
2762            loopback, all the sorts of tunnels...
2763
2764            Really, it is unlikely that netif_tx_lock protection is necessary
2765            here.  (f.e. loopback and IP tunnels are clean ignoring statistics
2766            counters.)
2767            However, it is possible, that they rely on protection
2768            made by us here.
2769
2770            Check this and shot the lock. It is not prone from deadlocks.
2771            Either shot noqueue qdisc, it is even simpler 8)
2772          */
2773         if (dev->flags & IFF_UP) {
2774                 int cpu = smp_processor_id(); /* ok because BHs are off */
2775
2776                 if (txq->xmit_lock_owner != cpu) {
2777
2778                         if (__this_cpu_read(xmit_recursion) > RECURSION_LIMIT)
2779                                 goto recursion_alert;
2780
2781                         HARD_TX_LOCK(dev, txq, cpu);
2782
2783                         if (!netif_xmit_stopped(txq)) {
2784                                 __this_cpu_inc(xmit_recursion);
2785                                 rc = dev_hard_start_xmit(skb, dev, txq);
2786                                 __this_cpu_dec(xmit_recursion);
2787                                 if (dev_xmit_complete(rc)) {
2788                                         HARD_TX_UNLOCK(dev, txq);
2789                                         goto out;
2790                                 }
2791                         }
2792                         HARD_TX_UNLOCK(dev, txq);
2793                         net_crit_ratelimited("Virtual device %s asks to queue packet!\n",
2794                                              dev->name);
2795                 } else {
2796                         /* Recursion is detected! It is possible,
2797                          * unfortunately
2798                          */
2799 recursion_alert:
2800                         net_crit_ratelimited("Dead loop on virtual device %s, fix it urgently!\n",
2801                                              dev->name);
2802                 }
2803         }
2804
2805         rc = -ENETDOWN;
2806         rcu_read_unlock_bh();
2807
2808         kfree_skb(skb);
2809         return rc;
2810 out:
2811         rcu_read_unlock_bh();
2812         return rc;
2813 }
2814 EXPORT_SYMBOL(dev_queue_xmit);
2815
2816
2817 /*=======================================================================
2818                         Receiver routines
2819   =======================================================================*/
2820
2821 int netdev_max_backlog __read_mostly = 1000;
2822 EXPORT_SYMBOL(netdev_max_backlog);
2823
2824 int netdev_tstamp_prequeue __read_mostly = 1;
2825 int netdev_budget __read_mostly = 300;
2826 int weight_p __read_mostly = 64;            /* old backlog weight */
2827
2828 /* Called with irq disabled */
2829 static inline void ____napi_schedule(struct softnet_data *sd,
2830                                      struct napi_struct *napi)
2831 {
2832         list_add_tail(&napi->poll_list, &sd->poll_list);
2833         __raise_softirq_irqoff(NET_RX_SOFTIRQ);
2834 }
2835
2836 #ifdef CONFIG_RPS
2837
2838 /* One global table that all flow-based protocols share. */
2839 struct rps_sock_flow_table __rcu *rps_sock_flow_table __read_mostly;
2840 EXPORT_SYMBOL(rps_sock_flow_table);
2841
2842 struct static_key rps_needed __read_mostly;
2843
2844 static struct rps_dev_flow *
2845 set_rps_cpu(struct net_device *dev, struct sk_buff *skb,
2846             struct rps_dev_flow *rflow, u16 next_cpu)
2847 {
2848         if (next_cpu != RPS_NO_CPU) {
2849 #ifdef CONFIG_RFS_ACCEL
2850                 struct netdev_rx_queue *rxqueue;
2851                 struct rps_dev_flow_table *flow_table;
2852                 struct rps_dev_flow *old_rflow;
2853                 u32 flow_id;
2854                 u16 rxq_index;
2855                 int rc;
2856
2857                 /* Should we steer this flow to a different hardware queue? */
2858                 if (!skb_rx_queue_recorded(skb) || !dev->rx_cpu_rmap ||
2859                     !(dev->features & NETIF_F_NTUPLE))
2860                         goto out;
2861                 rxq_index = cpu_rmap_lookup_index(dev->rx_cpu_rmap, next_cpu);
2862                 if (rxq_index == skb_get_rx_queue(skb))
2863                         goto out;
2864
2865                 rxqueue = dev->_rx + rxq_index;
2866                 flow_table = rcu_dereference(rxqueue->rps_flow_table);
2867                 if (!flow_table)
2868                         goto out;
2869                 flow_id = skb->rxhash & flow_table->mask;
2870                 rc = dev->netdev_ops->ndo_rx_flow_steer(dev, skb,
2871                                                         rxq_index, flow_id);
2872                 if (rc < 0)
2873                         goto out;
2874                 old_rflow = rflow;
2875                 rflow = &flow_table->flows[flow_id];
2876                 rflow->filter = rc;
2877                 if (old_rflow->filter == rflow->filter)
2878                         old_rflow->filter = RPS_NO_FILTER;
2879         out:
2880 #endif
2881                 rflow->last_qtail =
2882                         per_cpu(softnet_data, next_cpu).input_queue_head;
2883         }
2884
2885         rflow->cpu = next_cpu;
2886         return rflow;
2887 }
2888
2889 /*
2890  * get_rps_cpu is called from netif_receive_skb and returns the target
2891  * CPU from the RPS map of the receiving queue for a given skb.
2892  * rcu_read_lock must be held on entry.
2893  */
2894 static int get_rps_cpu(struct net_device *dev, struct sk_buff *skb,
2895                        struct rps_dev_flow **rflowp)
2896 {
2897         struct netdev_rx_queue *rxqueue;
2898         struct rps_map *map;
2899         struct rps_dev_flow_table *flow_table;
2900         struct rps_sock_flow_table *sock_flow_table;
2901         int cpu = -1;
2902         u16 tcpu;
2903
2904         if (skb_rx_queue_recorded(skb)) {
2905                 u16 index = skb_get_rx_queue(skb);
2906                 if (unlikely(index >= dev->real_num_rx_queues)) {
2907                         WARN_ONCE(dev->real_num_rx_queues > 1,
2908                                   "%s received packet on queue %u, but number "
2909                                   "of RX queues is %u\n",
2910                                   dev->name, index, dev->real_num_rx_queues);
2911                         goto done;
2912                 }
2913                 rxqueue = dev->_rx + index;
2914         } else
2915                 rxqueue = dev->_rx;
2916
2917         map = rcu_dereference(rxqueue->rps_map);
2918         if (map) {
2919                 if (map->len == 1 &&
2920                     !rcu_access_pointer(rxqueue->rps_flow_table)) {
2921                         tcpu = map->cpus[0];
2922                         if (cpu_online(tcpu))
2923                                 cpu = tcpu;
2924                         goto done;
2925                 }
2926         } else if (!rcu_access_pointer(rxqueue->rps_flow_table)) {
2927                 goto done;
2928         }
2929
2930         skb_reset_network_header(skb);
2931         if (!skb_get_rxhash(skb))
2932                 goto done;
2933
2934         flow_table = rcu_dereference(rxqueue->rps_flow_table);
2935         sock_flow_table = rcu_dereference(rps_sock_flow_table);
2936         if (flow_table && sock_flow_table) {
2937                 u16 next_cpu;
2938                 struct rps_dev_flow *rflow;
2939
2940                 rflow = &flow_table->flows[skb->rxhash & flow_table->mask];
2941                 tcpu = rflow->cpu;
2942
2943                 next_cpu = sock_flow_table->ents[skb->rxhash &
2944                     sock_flow_table->mask];
2945
2946                 /*
2947                  * If the desired CPU (where last recvmsg was done) is
2948                  * different from current CPU (one in the rx-queue flow
2949                  * table entry), switch if one of the following holds:
2950                  *   - Current CPU is unset (equal to RPS_NO_CPU).
2951                  *   - Current CPU is offline.
2952                  *   - The current CPU's queue tail has advanced beyond the
2953                  *     last packet that was enqueued using this table entry.
2954                  *     This guarantees that all previous packets for the flow
2955                  *     have been dequeued, thus preserving in order delivery.
2956                  */
2957                 if (unlikely(tcpu != next_cpu) &&
2958                     (tcpu == RPS_NO_CPU || !cpu_online(tcpu) ||
2959                      ((int)(per_cpu(softnet_data, tcpu).input_queue_head -
2960                       rflow->last_qtail)) >= 0)) {
2961                         tcpu = next_cpu;
2962                         rflow = set_rps_cpu(dev, skb, rflow, next_cpu);
2963                 }
2964
2965                 if (tcpu != RPS_NO_CPU && cpu_online(tcpu)) {
2966                         *rflowp = rflow;
2967                         cpu = tcpu;
2968                         goto done;
2969                 }
2970         }
2971
2972         if (map) {
2973                 tcpu = map->cpus[((u64) skb->rxhash * map->len) >> 32];
2974
2975                 if (cpu_online(tcpu)) {
2976                         cpu = tcpu;
2977                         goto done;
2978                 }
2979         }
2980
2981 done:
2982         return cpu;
2983 }
2984
2985 #ifdef CONFIG_RFS_ACCEL
2986
2987 /**
2988  * rps_may_expire_flow - check whether an RFS hardware filter may be removed
2989  * @dev: Device on which the filter was set
2990  * @rxq_index: RX queue index
2991  * @flow_id: Flow ID passed to ndo_rx_flow_steer()
2992  * @filter_id: Filter ID returned by ndo_rx_flow_steer()
2993  *
2994  * Drivers that implement ndo_rx_flow_steer() should periodically call
2995  * this function for each installed filter and remove the filters for
2996  * which it returns %true.
2997  */
2998 bool rps_may_expire_flow(struct net_device *dev, u16 rxq_index,
2999                          u32 flow_id, u16 filter_id)
3000 {
3001         struct netdev_rx_queue *rxqueue = dev->_rx + rxq_index;
3002         struct rps_dev_flow_table *flow_table;
3003         struct rps_dev_flow *rflow;
3004         bool expire = true;
3005         int cpu;
3006
3007         rcu_read_lock();
3008         flow_table = rcu_dereference(rxqueue->rps_flow_table);
3009         if (flow_table && flow_id <= flow_table->mask) {
3010                 rflow = &flow_table->flows[flow_id];
3011                 cpu = ACCESS_ONCE(rflow->cpu);
3012                 if (rflow->filter == filter_id && cpu != RPS_NO_CPU &&
3013                     ((int)(per_cpu(softnet_data, cpu).input_queue_head -
3014                            rflow->last_qtail) <
3015                      (int)(10 * flow_table->mask)))
3016                         expire = false;
3017         }
3018         rcu_read_unlock();
3019         return expire;
3020 }
3021 EXPORT_SYMBOL(rps_may_expire_flow);
3022
3023 #endif /* CONFIG_RFS_ACCEL */
3024
3025 /* Called from hardirq (IPI) context */
3026 static void rps_trigger_softirq(void *data)
3027 {
3028         struct softnet_data *sd = data;
3029
3030         ____napi_schedule(sd, &sd->backlog);
3031         sd->received_rps++;
3032 }
3033
3034 #endif /* CONFIG_RPS */
3035
3036 /*
3037  * Check if this softnet_data structure is another cpu one
3038  * If yes, queue it to our IPI list and return 1
3039  * If no, return 0
3040  */
3041 static int rps_ipi_queued(struct softnet_data *sd)
3042 {
3043 #ifdef CONFIG_RPS
3044         struct softnet_data *mysd = &__get_cpu_var(softnet_data);
3045
3046         if (sd != mysd) {
3047                 sd->rps_ipi_next = mysd->rps_ipi_list;
3048                 mysd->rps_ipi_list = sd;
3049
3050                 __raise_softirq_irqoff(NET_RX_SOFTIRQ);
3051                 return 1;
3052         }
3053 #endif /* CONFIG_RPS */
3054         return 0;
3055 }
3056
3057 /*
3058  * enqueue_to_backlog is called to queue an skb to a per CPU backlog
3059  * queue (may be a remote CPU queue).
3060  */
3061 static int enqueue_to_backlog(struct sk_buff *skb, int cpu,
3062                               unsigned int *qtail)
3063 {
3064         struct softnet_data *sd;
3065         unsigned long flags;
3066
3067         sd = &per_cpu(softnet_data, cpu);
3068
3069         local_irq_save(flags);
3070
3071         rps_lock(sd);
3072         if (skb_queue_len(&sd->input_pkt_queue) <= netdev_max_backlog) {
3073                 if (skb_queue_len(&sd->input_pkt_queue)) {
3074 enqueue:
3075                         __skb_queue_tail(&sd->input_pkt_queue, skb);
3076                         input_queue_tail_incr_save(sd, qtail);
3077                         rps_unlock(sd);
3078                         local_irq_restore(flags);
3079                         return NET_RX_SUCCESS;
3080                 }
3081
3082                 /* Schedule NAPI for backlog device
3083                  * We can use non atomic operation since we own the queue lock
3084                  */
3085                 if (!__test_and_set_bit(NAPI_STATE_SCHED, &sd->backlog.state)) {
3086                         if (!rps_ipi_queued(sd))
3087                                 ____napi_schedule(sd, &sd->backlog);
3088                 }
3089                 goto enqueue;
3090         }
3091
3092         sd->dropped++;
3093         rps_unlock(sd);
3094
3095         local_irq_restore(flags);
3096
3097         atomic_long_inc(&skb->dev->rx_dropped);
3098         kfree_skb(skb);
3099         return NET_RX_DROP;
3100 }
3101
3102 /**
3103  *      netif_rx        -       post buffer to the network code
3104  *      @skb: buffer to post
3105  *
3106  *      This function receives a packet from a device driver and queues it for
3107  *      the upper (protocol) levels to process.  It always succeeds. The buffer
3108  *      may be dropped during processing for congestion control or by the
3109  *      protocol layers.
3110  *
3111  *      return values:
3112  *      NET_RX_SUCCESS  (no congestion)
3113  *      NET_RX_DROP     (packet was dropped)
3114  *
3115  */
3116
3117 int netif_rx(struct sk_buff *skb)
3118 {
3119         int ret;
3120
3121         /* if netpoll wants it, pretend we never saw it */
3122         if (netpoll_rx(skb))
3123                 return NET_RX_DROP;
3124
3125         net_timestamp_check(netdev_tstamp_prequeue, skb);
3126
3127         trace_netif_rx(skb);
3128 #ifdef CONFIG_RPS
3129         if (static_key_false(&rps_needed)) {
3130                 struct rps_dev_flow voidflow, *rflow = &voidflow;
3131                 int cpu;
3132
3133                 preempt_disable();
3134                 rcu_read_lock();
3135
3136                 cpu = get_rps_cpu(skb->dev, skb, &rflow);
3137                 if (cpu < 0)
3138                         cpu = smp_processor_id();
3139
3140                 ret = enqueue_to_backlog(skb, cpu, &rflow->last_qtail);
3141
3142                 rcu_read_unlock();
3143                 preempt_enable();
3144         } else
3145 #endif
3146         {
3147                 unsigned int qtail;
3148                 ret = enqueue_to_backlog(skb, get_cpu(), &qtail);
3149                 put_cpu();
3150         }
3151         return ret;
3152 }
3153 EXPORT_SYMBOL(netif_rx);
3154
3155 int netif_rx_ni(struct sk_buff *skb)
3156 {
3157         int err;
3158
3159         preempt_disable();
3160         err = netif_rx(skb);
3161         if (local_softirq_pending())
3162                 do_softirq();
3163         preempt_enable();
3164
3165         return err;
3166 }
3167 EXPORT_SYMBOL(netif_rx_ni);
3168
3169 static void net_tx_action(struct softirq_action *h)
3170 {
3171         struct softnet_data *sd = &__get_cpu_var(softnet_data);
3172
3173         if (sd->completion_queue) {
3174                 struct sk_buff *clist;
3175
3176                 local_irq_disable();
3177                 clist = sd->completion_queue;
3178                 sd->completion_queue = NULL;
3179                 local_irq_enable();
3180
3181                 while (clist) {
3182                         struct sk_buff *skb = clist;
3183                         clist = clist->next;
3184
3185                         WARN_ON(atomic_read(&skb->users));
3186                         trace_kfree_skb(skb, net_tx_action);
3187                         __kfree_skb(skb);
3188                 }
3189         }
3190
3191         if (sd->output_queue) {
3192                 struct Qdisc *head;
3193
3194                 local_irq_disable();
3195                 head = sd->output_queue;
3196                 sd->output_queue = NULL;
3197                 sd->output_queue_tailp = &sd->output_queue;
3198                 local_irq_enable();
3199
3200                 while (head) {
3201                         struct Qdisc *q = head;
3202                         spinlock_t *root_lock;
3203
3204                         head = head->next_sched;
3205
3206                         root_lock = qdisc_lock(q);
3207                         if (spin_trylock(root_lock)) {
3208                                 smp_mb__before_clear_bit();
3209                                 clear_bit(__QDISC_STATE_SCHED,
3210                                           &q->state);
3211                                 qdisc_run(q);
3212                                 spin_unlock(root_lock);
3213                         } else {
3214                                 if (!test_bit(__QDISC_STATE_DEACTIVATED,
3215                                               &q->state)) {
3216                                         __netif_reschedule(q);
3217                                 } else {
3218                                         smp_mb__before_clear_bit();
3219                                         clear_bit(__QDISC_STATE_SCHED,
3220                                                   &q->state);
3221                                 }
3222                         }
3223                 }
3224         }
3225 }
3226
3227 #if (defined(CONFIG_BRIDGE) || defined(CONFIG_BRIDGE_MODULE)) && \
3228     (defined(CONFIG_ATM_LANE) || defined(CONFIG_ATM_LANE_MODULE))
3229 /* This hook is defined here for ATM LANE */
3230 int (*br_fdb_test_addr_hook)(struct net_device *dev,
3231                              unsigned char *addr) __read_mostly;
3232 EXPORT_SYMBOL_GPL(br_fdb_test_addr_hook);
3233 #endif
3234
3235 #ifdef CONFIG_NET_CLS_ACT
3236 /* TODO: Maybe we should just force sch_ingress to be compiled in
3237  * when CONFIG_NET_CLS_ACT is? otherwise some useless instructions
3238  * a compare and 2 stores extra right now if we dont have it on
3239  * but have CONFIG_NET_CLS_ACT
3240  * NOTE: This doesn't stop any functionality; if you dont have
3241  * the ingress scheduler, you just can't add policies on ingress.
3242  *
3243  */
3244 static int ing_filter(struct sk_buff *skb, struct netdev_queue *rxq)
3245 {
3246         struct net_device *dev = skb->dev;
3247         u32 ttl = G_TC_RTTL(skb->tc_verd);
3248         int result = TC_ACT_OK;
3249         struct Qdisc *q;
3250
3251         if (unlikely(MAX_RED_LOOP < ttl++)) {
3252                 net_warn_ratelimited("Redir loop detected Dropping packet (%d->%d)\n",
3253                                      skb->skb_iif, dev->ifindex);
3254                 return TC_ACT_SHOT;
3255         }
3256
3257         skb->tc_verd = SET_TC_RTTL(skb->tc_verd, ttl);
3258         skb->tc_verd = SET_TC_AT(skb->tc_verd, AT_INGRESS);
3259
3260         q = rxq->qdisc;
3261         if (q != &noop_qdisc) {
3262                 spin_lock(qdisc_lock(q));
3263                 if (likely(!test_bit(__QDISC_STATE_DEACTIVATED, &q->state)))
3264                         result = qdisc_enqueue_root(skb, q);
3265                 spin_unlock(qdisc_lock(q));
3266         }
3267
3268         return result;
3269 }
3270
3271 static inline struct sk_buff *handle_ing(struct sk_buff *skb,
3272                                          struct packet_type **pt_prev,
3273                                          int *ret, struct net_device *orig_dev)
3274 {
3275         struct netdev_queue *rxq = rcu_dereference(skb->dev->ingress_queue);
3276
3277         if (!rxq || rxq->qdisc == &noop_qdisc)
3278                 goto out;
3279
3280         if (*pt_prev) {
3281                 *ret = deliver_skb(skb, *pt_prev, orig_dev);
3282                 *pt_prev = NULL;
3283         }
3284
3285         switch (ing_filter(skb, rxq)) {
3286         case TC_ACT_SHOT:
3287         case TC_ACT_STOLEN:
3288                 kfree_skb(skb);
3289                 return NULL;
3290         }
3291
3292 out:
3293         skb->tc_verd = 0;
3294         return skb;
3295 }
3296 #endif
3297
3298 /**
3299  *      netdev_rx_handler_register - register receive handler
3300  *      @dev: device to register a handler for
3301  *      @rx_handler: receive handler to register
3302  *      @rx_handler_data: data pointer that is used by rx handler
3303  *
3304  *      Register a receive hander for a device. This handler will then be
3305  *      called from __netif_receive_skb. A negative errno code is returned
3306  *      on a failure.
3307  *
3308  *      The caller must hold the rtnl_mutex.
3309  *
3310  *      For a general description of rx_handler, see enum rx_handler_result.
3311  */
3312 int netdev_rx_handler_register(struct net_device *dev,
3313                                rx_handler_func_t *rx_handler,
3314                                void *rx_handler_data)
3315 {
3316         ASSERT_RTNL();
3317
3318         if (dev->rx_handler)
3319                 return -EBUSY;
3320
3321         rcu_assign_pointer(dev->rx_handler_data, rx_handler_data);
3322         rcu_assign_pointer(dev->rx_handler, rx_handler);
3323
3324         return 0;
3325 }
3326 EXPORT_SYMBOL_GPL(netdev_rx_handler_register);
3327
3328 /**
3329  *      netdev_rx_handler_unregister - unregister receive handler
3330  *      @dev: device to unregister a handler from
3331  *
3332  *      Unregister a receive handler from a device.
3333  *
3334  *      The caller must hold the rtnl_mutex.
3335  */
3336 void netdev_rx_handler_unregister(struct net_device *dev)
3337 {
3338
3339         ASSERT_RTNL();
3340         RCU_INIT_POINTER(dev->rx_handler, NULL);
3341         RCU_INIT_POINTER(dev->rx_handler_data, NULL);
3342 }
3343 EXPORT_SYMBOL_GPL(netdev_rx_handler_unregister);
3344
3345 /*
3346  * Limit the use of PFMEMALLOC reserves to those protocols that implement
3347  * the special handling of PFMEMALLOC skbs.
3348  */
3349 static bool skb_pfmemalloc_protocol(struct sk_buff *skb)
3350 {
3351         switch (skb->protocol) {
3352         case __constant_htons(ETH_P_ARP):
3353         case __constant_htons(ETH_P_IP):
3354         case __constant_htons(ETH_P_IPV6):
3355         case __constant_htons(ETH_P_8021Q):
3356                 return true;
3357         default:
3358                 return false;
3359         }
3360 }
3361
3362 static int __netif_receive_skb_core(struct sk_buff *skb, bool pfmemalloc)
3363 {
3364         struct packet_type *ptype, *pt_prev;
3365         rx_handler_func_t *rx_handler;
3366         struct net_device *orig_dev;
3367         struct net_device *null_or_dev;
3368         bool deliver_exact = false;
3369         int ret = NET_RX_DROP;
3370         __be16 type;
3371
3372         net_timestamp_check(!netdev_tstamp_prequeue, skb);
3373
3374         trace_netif_receive_skb(skb);
3375
3376         /* if we've gotten here through NAPI, check netpoll */
3377         if (netpoll_receive_skb(skb))
3378                 goto out;
3379
3380         orig_dev = skb->dev;
3381
3382         skb_reset_network_header(skb);
3383         if (!skb_transport_header_was_set(skb))
3384                 skb_reset_transport_header(skb);
3385         skb_reset_mac_len(skb);
3386
3387         pt_prev = NULL;
3388
3389         rcu_read_lock();
3390
3391 another_round:
3392         skb->skb_iif = skb->dev->ifindex;
3393
3394         __this_cpu_inc(softnet_data.processed);
3395
3396         if (skb->protocol == cpu_to_be16(ETH_P_8021Q)) {
3397                 skb = vlan_untag(skb);
3398                 if (unlikely(!skb))
3399                         goto unlock;
3400         }
3401
3402 #ifdef CONFIG_NET_CLS_ACT
3403         if (skb->tc_verd & TC_NCLS) {
3404                 skb->tc_verd = CLR_TC_NCLS(skb->tc_verd);
3405                 goto ncls;
3406         }
3407 #endif
3408
3409         if (pfmemalloc)
3410                 goto skip_taps;
3411
3412         list_for_each_entry_rcu(ptype, &ptype_all, list) {
3413                 if (!ptype->dev || ptype->dev == skb->dev) {
3414                         if (pt_prev)
3415                                 ret = deliver_skb(skb, pt_prev, orig_dev);
3416                         pt_prev = ptype;
3417                 }
3418         }
3419
3420 skip_taps:
3421 #ifdef CONFIG_NET_CLS_ACT
3422         skb = handle_ing(skb, &pt_prev, &ret, orig_dev);
3423         if (!skb)
3424                 goto unlock;
3425 ncls:
3426 #endif
3427
3428         if (pfmemalloc && !skb_pfmemalloc_protocol(skb))
3429                 goto drop;
3430
3431         if (vlan_tx_tag_present(skb)) {
3432                 if (pt_prev) {
3433                         ret = deliver_skb(skb, pt_prev, orig_dev);
3434                         pt_prev = NULL;
3435                 }
3436                 if (vlan_do_receive(&skb))
3437                         goto another_round;
3438                 else if (unlikely(!skb))
3439                         goto unlock;
3440         }
3441
3442         rx_handler = rcu_dereference(skb->dev->rx_handler);
3443         if (rx_handler) {
3444                 if (pt_prev) {
3445                         ret = deliver_skb(skb, pt_prev, orig_dev);
3446                         pt_prev = NULL;
3447                 }
3448                 switch (rx_handler(&skb)) {
3449                 case RX_HANDLER_CONSUMED:
3450                         ret = NET_RX_SUCCESS;
3451                         goto unlock;
3452                 case RX_HANDLER_ANOTHER:
3453                         goto another_round;
3454                 case RX_HANDLER_EXACT:
3455                         deliver_exact = true;
3456                 case RX_HANDLER_PASS:
3457                         break;
3458                 default:
3459                         BUG();
3460                 }
3461         }
3462
3463         if (vlan_tx_nonzero_tag_present(skb))
3464                 skb->pkt_type = PACKET_OTHERHOST;
3465
3466         /* deliver only exact match when indicated */
3467         null_or_dev = deliver_exact ? skb->dev : NULL;
3468
3469         type = skb->protocol;
3470         list_for_each_entry_rcu(ptype,
3471                         &ptype_base[ntohs(type) & PTYPE_HASH_MASK], list) {
3472                 if (ptype->type == type &&
3473                     (ptype->dev == null_or_dev || ptype->dev == skb->dev ||
3474                      ptype->dev == orig_dev)) {
3475                         if (pt_prev)
3476                                 ret = deliver_skb(skb, pt_prev, orig_dev);
3477                         pt_prev = ptype;
3478                 }
3479         }
3480
3481         if (pt_prev) {
3482                 if (unlikely(skb_orphan_frags(skb, GFP_ATOMIC)))
3483                         goto drop;
3484                 else
3485                         ret = pt_prev->func(skb, skb->dev, pt_prev, orig_dev);
3486         } else {
3487 drop:
3488                 atomic_long_inc(&skb->dev->rx_dropped);
3489                 kfree_skb(skb);
3490                 /* Jamal, now you will not able to escape explaining
3491                  * me how you were going to use this. :-)
3492                  */
3493                 ret = NET_RX_DROP;
3494         }
3495
3496 unlock:
3497         rcu_read_unlock();
3498 out:
3499         return ret;
3500 }
3501
3502 static int __netif_receive_skb(struct sk_buff *skb)
3503 {
3504         int ret;
3505
3506         if (sk_memalloc_socks() && skb_pfmemalloc(skb)) {
3507                 unsigned long pflags = current->flags;
3508
3509                 /*
3510                  * PFMEMALLOC skbs are special, they should
3511                  * - be delivered to SOCK_MEMALLOC sockets only
3512                  * - stay away from userspace
3513                  * - have bounded memory usage
3514                  *
3515                  * Use PF_MEMALLOC as this saves us from propagating the allocation
3516