net: Kill link between CSUM and SG features.
[pandora-kernel.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         WARN_ON(in_interrupt());
1549         static_key_slow_inc(&netstamp_needed);
1550 }
1551 EXPORT_SYMBOL(net_enable_timestamp);
1552
1553 void net_disable_timestamp(void)
1554 {
1555 #ifdef HAVE_JUMP_LABEL
1556         if (in_interrupt()) {
1557                 atomic_inc(&netstamp_needed_deferred);
1558                 return;
1559         }
1560 #endif
1561         static_key_slow_dec(&netstamp_needed);
1562 }
1563 EXPORT_SYMBOL(net_disable_timestamp);
1564
1565 static inline void net_timestamp_set(struct sk_buff *skb)
1566 {
1567         skb->tstamp.tv64 = 0;
1568         if (static_key_false(&netstamp_needed))
1569                 __net_timestamp(skb);
1570 }
1571
1572 #define net_timestamp_check(COND, SKB)                  \
1573         if (static_key_false(&netstamp_needed)) {               \
1574                 if ((COND) && !(SKB)->tstamp.tv64)      \
1575                         __net_timestamp(SKB);           \
1576         }                                               \
1577
1578 static inline bool is_skb_forwardable(struct net_device *dev,
1579                                       struct sk_buff *skb)
1580 {
1581         unsigned int len;
1582
1583         if (!(dev->flags & IFF_UP))
1584                 return false;
1585
1586         len = dev->mtu + dev->hard_header_len + VLAN_HLEN;
1587         if (skb->len <= len)
1588                 return true;
1589
1590         /* if TSO is enabled, we don't care about the length as the packet
1591          * could be forwarded without being segmented before
1592          */
1593         if (skb_is_gso(skb))
1594                 return true;
1595
1596         return false;
1597 }
1598
1599 /**
1600  * dev_forward_skb - loopback an skb to another netif
1601  *
1602  * @dev: destination network device
1603  * @skb: buffer to forward
1604  *
1605  * return values:
1606  *      NET_RX_SUCCESS  (no congestion)
1607  *      NET_RX_DROP     (packet was dropped, but freed)
1608  *
1609  * dev_forward_skb can be used for injecting an skb from the
1610  * start_xmit function of one device into the receive queue
1611  * of another device.
1612  *
1613  * The receiving device may be in another namespace, so
1614  * we have to clear all information in the skb that could
1615  * impact namespace isolation.
1616  */
1617 int dev_forward_skb(struct net_device *dev, struct sk_buff *skb)
1618 {
1619         if (skb_shinfo(skb)->tx_flags & SKBTX_DEV_ZEROCOPY) {
1620                 if (skb_copy_ubufs(skb, GFP_ATOMIC)) {
1621                         atomic_long_inc(&dev->rx_dropped);
1622                         kfree_skb(skb);
1623                         return NET_RX_DROP;
1624                 }
1625         }
1626
1627         skb_orphan(skb);
1628         nf_reset(skb);
1629
1630         if (unlikely(!is_skb_forwardable(dev, skb))) {
1631                 atomic_long_inc(&dev->rx_dropped);
1632                 kfree_skb(skb);
1633                 return NET_RX_DROP;
1634         }
1635         skb->skb_iif = 0;
1636         skb->dev = dev;
1637         skb_dst_drop(skb);
1638         skb->tstamp.tv64 = 0;
1639         skb->pkt_type = PACKET_HOST;
1640         skb->protocol = eth_type_trans(skb, dev);
1641         skb->mark = 0;
1642         secpath_reset(skb);
1643         nf_reset(skb);
1644         return netif_rx(skb);
1645 }
1646 EXPORT_SYMBOL_GPL(dev_forward_skb);
1647
1648 static inline int deliver_skb(struct sk_buff *skb,
1649                               struct packet_type *pt_prev,
1650                               struct net_device *orig_dev)
1651 {
1652         if (unlikely(skb_orphan_frags(skb, GFP_ATOMIC)))
1653                 return -ENOMEM;
1654         atomic_inc(&skb->users);
1655         return pt_prev->func(skb, skb->dev, pt_prev, orig_dev);
1656 }
1657
1658 static inline bool skb_loop_sk(struct packet_type *ptype, struct sk_buff *skb)
1659 {
1660         if (!ptype->af_packet_priv || !skb->sk)
1661                 return false;
1662
1663         if (ptype->id_match)
1664                 return ptype->id_match(ptype, skb->sk);
1665         else if ((struct sock *)ptype->af_packet_priv == skb->sk)
1666                 return true;
1667
1668         return false;
1669 }
1670
1671 /*
1672  *      Support routine. Sends outgoing frames to any network
1673  *      taps currently in use.
1674  */
1675
1676 static void dev_queue_xmit_nit(struct sk_buff *skb, struct net_device *dev)
1677 {
1678         struct packet_type *ptype;
1679         struct sk_buff *skb2 = NULL;
1680         struct packet_type *pt_prev = NULL;
1681
1682         rcu_read_lock();
1683         list_for_each_entry_rcu(ptype, &ptype_all, list) {
1684                 /* Never send packets back to the socket
1685                  * they originated from - MvS (miquels@drinkel.ow.org)
1686                  */
1687                 if ((ptype->dev == dev || !ptype->dev) &&
1688                     (!skb_loop_sk(ptype, skb))) {
1689                         if (pt_prev) {
1690                                 deliver_skb(skb2, pt_prev, skb->dev);
1691                                 pt_prev = ptype;
1692                                 continue;
1693                         }
1694
1695                         skb2 = skb_clone(skb, GFP_ATOMIC);
1696                         if (!skb2)
1697                                 break;
1698
1699                         net_timestamp_set(skb2);
1700
1701                         /* skb->nh should be correctly
1702                            set by sender, so that the second statement is
1703                            just protection against buggy protocols.
1704                          */
1705                         skb_reset_mac_header(skb2);
1706
1707                         if (skb_network_header(skb2) < skb2->data ||
1708                             skb2->network_header > skb2->tail) {
1709                                 net_crit_ratelimited("protocol %04x is buggy, dev %s\n",
1710                                                      ntohs(skb2->protocol),
1711                                                      dev->name);
1712                                 skb_reset_network_header(skb2);
1713                         }
1714
1715                         skb2->transport_header = skb2->network_header;
1716                         skb2->pkt_type = PACKET_OUTGOING;
1717                         pt_prev = ptype;
1718                 }
1719         }
1720         if (pt_prev)
1721                 pt_prev->func(skb2, skb->dev, pt_prev, skb->dev);
1722         rcu_read_unlock();
1723 }
1724
1725 /**
1726  * netif_setup_tc - Handle tc mappings on real_num_tx_queues change
1727  * @dev: Network device
1728  * @txq: number of queues available
1729  *
1730  * If real_num_tx_queues is changed the tc mappings may no longer be
1731  * valid. To resolve this verify the tc mapping remains valid and if
1732  * not NULL the mapping. With no priorities mapping to this
1733  * offset/count pair it will no longer be used. In the worst case TC0
1734  * is invalid nothing can be done so disable priority mappings. If is
1735  * expected that drivers will fix this mapping if they can before
1736  * calling netif_set_real_num_tx_queues.
1737  */
1738 static void netif_setup_tc(struct net_device *dev, unsigned int txq)
1739 {
1740         int i;
1741         struct netdev_tc_txq *tc = &dev->tc_to_txq[0];
1742
1743         /* If TC0 is invalidated disable TC mapping */
1744         if (tc->offset + tc->count > txq) {
1745                 pr_warn("Number of in use tx queues changed invalidating tc mappings. Priority traffic classification disabled!\n");
1746                 dev->num_tc = 0;
1747                 return;
1748         }
1749
1750         /* Invalidated prio to tc mappings set to TC0 */
1751         for (i = 1; i < TC_BITMASK + 1; i++) {
1752                 int q = netdev_get_prio_tc_map(dev, i);
1753
1754                 tc = &dev->tc_to_txq[q];
1755                 if (tc->offset + tc->count > txq) {
1756                         pr_warn("Number of in use tx queues changed. Priority %i to tc mapping %i is no longer valid. Setting map to 0\n",
1757                                 i, q);
1758                         netdev_set_prio_tc_map(dev, i, 0);
1759                 }
1760         }
1761 }
1762
1763 #ifdef CONFIG_XPS
1764 static DEFINE_MUTEX(xps_map_mutex);
1765 #define xmap_dereference(P)             \
1766         rcu_dereference_protected((P), lockdep_is_held(&xps_map_mutex))
1767
1768 static struct xps_map *remove_xps_queue(struct xps_dev_maps *dev_maps,
1769                                         int cpu, u16 index)
1770 {
1771         struct xps_map *map = NULL;
1772         int pos;
1773
1774         if (dev_maps)
1775                 map = xmap_dereference(dev_maps->cpu_map[cpu]);
1776
1777         for (pos = 0; map && pos < map->len; pos++) {
1778                 if (map->queues[pos] == index) {
1779                         if (map->len > 1) {
1780                                 map->queues[pos] = map->queues[--map->len];
1781                         } else {
1782                                 RCU_INIT_POINTER(dev_maps->cpu_map[cpu], NULL);
1783                                 kfree_rcu(map, rcu);
1784                                 map = NULL;
1785                         }
1786                         break;
1787                 }
1788         }
1789
1790         return map;
1791 }
1792
1793 static void netif_reset_xps_queues_gt(struct net_device *dev, u16 index)
1794 {
1795         struct xps_dev_maps *dev_maps;
1796         int cpu, i;
1797         bool active = false;
1798
1799         mutex_lock(&xps_map_mutex);
1800         dev_maps = xmap_dereference(dev->xps_maps);
1801
1802         if (!dev_maps)
1803                 goto out_no_maps;
1804
1805         for_each_possible_cpu(cpu) {
1806                 for (i = index; i < dev->num_tx_queues; i++) {
1807                         if (!remove_xps_queue(dev_maps, cpu, i))
1808                                 break;
1809                 }
1810                 if (i == dev->num_tx_queues)
1811                         active = true;
1812         }
1813
1814         if (!active) {
1815                 RCU_INIT_POINTER(dev->xps_maps, NULL);
1816                 kfree_rcu(dev_maps, rcu);
1817         }
1818
1819         for (i = index; i < dev->num_tx_queues; i++)
1820                 netdev_queue_numa_node_write(netdev_get_tx_queue(dev, i),
1821                                              NUMA_NO_NODE);
1822
1823 out_no_maps:
1824         mutex_unlock(&xps_map_mutex);
1825 }
1826
1827 static struct xps_map *expand_xps_map(struct xps_map *map,
1828                                       int cpu, u16 index)
1829 {
1830         struct xps_map *new_map;
1831         int alloc_len = XPS_MIN_MAP_ALLOC;
1832         int i, pos;
1833
1834         for (pos = 0; map && pos < map->len; pos++) {
1835                 if (map->queues[pos] != index)
1836                         continue;
1837                 return map;
1838         }
1839
1840         /* Need to add queue to this CPU's existing map */
1841         if (map) {
1842                 if (pos < map->alloc_len)
1843                         return map;
1844
1845                 alloc_len = map->alloc_len * 2;
1846         }
1847
1848         /* Need to allocate new map to store queue on this CPU's map */
1849         new_map = kzalloc_node(XPS_MAP_SIZE(alloc_len), GFP_KERNEL,
1850                                cpu_to_node(cpu));
1851         if (!new_map)
1852                 return NULL;
1853
1854         for (i = 0; i < pos; i++)
1855                 new_map->queues[i] = map->queues[i];
1856         new_map->alloc_len = alloc_len;
1857         new_map->len = pos;
1858
1859         return new_map;
1860 }
1861
1862 int netif_set_xps_queue(struct net_device *dev, struct cpumask *mask, u16 index)
1863 {
1864         struct xps_dev_maps *dev_maps, *new_dev_maps = NULL;
1865         struct xps_map *map, *new_map;
1866         int maps_sz = max_t(unsigned int, XPS_DEV_MAPS_SIZE, L1_CACHE_BYTES);
1867         int cpu, numa_node_id = -2;
1868         bool active = false;
1869
1870         mutex_lock(&xps_map_mutex);
1871
1872         dev_maps = xmap_dereference(dev->xps_maps);
1873
1874         /* allocate memory for queue storage */
1875         for_each_online_cpu(cpu) {
1876                 if (!cpumask_test_cpu(cpu, mask))
1877                         continue;
1878
1879                 if (!new_dev_maps)
1880                         new_dev_maps = kzalloc(maps_sz, GFP_KERNEL);
1881                 if (!new_dev_maps) {
1882                         mutex_unlock(&xps_map_mutex);
1883                         return -ENOMEM;
1884                 }
1885
1886                 map = dev_maps ? xmap_dereference(dev_maps->cpu_map[cpu]) :
1887                                  NULL;
1888
1889                 map = expand_xps_map(map, cpu, index);
1890                 if (!map)
1891                         goto error;
1892
1893                 RCU_INIT_POINTER(new_dev_maps->cpu_map[cpu], map);
1894         }
1895
1896         if (!new_dev_maps)
1897                 goto out_no_new_maps;
1898
1899         for_each_possible_cpu(cpu) {
1900                 if (cpumask_test_cpu(cpu, mask) && cpu_online(cpu)) {
1901                         /* add queue to CPU maps */
1902                         int pos = 0;
1903
1904                         map = xmap_dereference(new_dev_maps->cpu_map[cpu]);
1905                         while ((pos < map->len) && (map->queues[pos] != index))
1906                                 pos++;
1907
1908                         if (pos == map->len)
1909                                 map->queues[map->len++] = index;
1910 #ifdef CONFIG_NUMA
1911                         if (numa_node_id == -2)
1912                                 numa_node_id = cpu_to_node(cpu);
1913                         else if (numa_node_id != cpu_to_node(cpu))
1914                                 numa_node_id = -1;
1915 #endif
1916                 } else if (dev_maps) {
1917                         /* fill in the new device map from the old device map */
1918                         map = xmap_dereference(dev_maps->cpu_map[cpu]);
1919                         RCU_INIT_POINTER(new_dev_maps->cpu_map[cpu], map);
1920                 }
1921
1922         }
1923
1924         rcu_assign_pointer(dev->xps_maps, new_dev_maps);
1925
1926         /* Cleanup old maps */
1927         if (dev_maps) {
1928                 for_each_possible_cpu(cpu) {
1929                         new_map = xmap_dereference(new_dev_maps->cpu_map[cpu]);
1930                         map = xmap_dereference(dev_maps->cpu_map[cpu]);
1931                         if (map && map != new_map)
1932                                 kfree_rcu(map, rcu);
1933                 }
1934
1935                 kfree_rcu(dev_maps, rcu);
1936         }
1937
1938         dev_maps = new_dev_maps;
1939         active = true;
1940
1941 out_no_new_maps:
1942         /* update Tx queue numa node */
1943         netdev_queue_numa_node_write(netdev_get_tx_queue(dev, index),
1944                                      (numa_node_id >= 0) ? numa_node_id :
1945                                      NUMA_NO_NODE);
1946
1947         if (!dev_maps)
1948                 goto out_no_maps;
1949
1950         /* removes queue from unused CPUs */
1951         for_each_possible_cpu(cpu) {
1952                 if (cpumask_test_cpu(cpu, mask) && cpu_online(cpu))
1953                         continue;
1954
1955                 if (remove_xps_queue(dev_maps, cpu, index))
1956                         active = true;
1957         }
1958
1959         /* free map if not active */
1960         if (!active) {
1961                 RCU_INIT_POINTER(dev->xps_maps, NULL);
1962                 kfree_rcu(dev_maps, rcu);
1963         }
1964
1965 out_no_maps:
1966         mutex_unlock(&xps_map_mutex);
1967
1968         return 0;
1969 error:
1970         /* remove any maps that we added */
1971         for_each_possible_cpu(cpu) {
1972                 new_map = xmap_dereference(new_dev_maps->cpu_map[cpu]);
1973                 map = dev_maps ? xmap_dereference(dev_maps->cpu_map[cpu]) :
1974                                  NULL;
1975                 if (new_map && new_map != map)
1976                         kfree(new_map);
1977         }
1978
1979         mutex_unlock(&xps_map_mutex);
1980
1981         kfree(new_dev_maps);
1982         return -ENOMEM;
1983 }
1984 EXPORT_SYMBOL(netif_set_xps_queue);
1985
1986 #endif
1987 /*
1988  * Routine to help set real_num_tx_queues. To avoid skbs mapped to queues
1989  * greater then real_num_tx_queues stale skbs on the qdisc must be flushed.
1990  */
1991 int netif_set_real_num_tx_queues(struct net_device *dev, unsigned int txq)
1992 {
1993         int rc;
1994
1995         if (txq < 1 || txq > dev->num_tx_queues)
1996                 return -EINVAL;
1997
1998         if (dev->reg_state == NETREG_REGISTERED ||
1999             dev->reg_state == NETREG_UNREGISTERING) {
2000                 ASSERT_RTNL();
2001
2002                 rc = netdev_queue_update_kobjects(dev, dev->real_num_tx_queues,
2003                                                   txq);
2004                 if (rc)
2005                         return rc;
2006
2007                 if (dev->num_tc)
2008                         netif_setup_tc(dev, txq);
2009
2010                 if (txq < dev->real_num_tx_queues) {
2011                         qdisc_reset_all_tx_gt(dev, txq);
2012 #ifdef CONFIG_XPS
2013                         netif_reset_xps_queues_gt(dev, txq);
2014 #endif
2015                 }
2016         }
2017
2018         dev->real_num_tx_queues = txq;
2019         return 0;
2020 }
2021 EXPORT_SYMBOL(netif_set_real_num_tx_queues);
2022
2023 #ifdef CONFIG_RPS
2024 /**
2025  *      netif_set_real_num_rx_queues - set actual number of RX queues used
2026  *      @dev: Network device
2027  *      @rxq: Actual number of RX queues
2028  *
2029  *      This must be called either with the rtnl_lock held or before
2030  *      registration of the net device.  Returns 0 on success, or a
2031  *      negative error code.  If called before registration, it always
2032  *      succeeds.
2033  */
2034 int netif_set_real_num_rx_queues(struct net_device *dev, unsigned int rxq)
2035 {
2036         int rc;
2037
2038         if (rxq < 1 || rxq > dev->num_rx_queues)
2039                 return -EINVAL;
2040
2041         if (dev->reg_state == NETREG_REGISTERED) {
2042                 ASSERT_RTNL();
2043
2044                 rc = net_rx_queue_update_kobjects(dev, dev->real_num_rx_queues,
2045                                                   rxq);
2046                 if (rc)
2047                         return rc;
2048         }
2049
2050         dev->real_num_rx_queues = rxq;
2051         return 0;
2052 }
2053 EXPORT_SYMBOL(netif_set_real_num_rx_queues);
2054 #endif
2055
2056 /**
2057  * netif_get_num_default_rss_queues - default number of RSS queues
2058  *
2059  * This routine should set an upper limit on the number of RSS queues
2060  * used by default by multiqueue devices.
2061  */
2062 int netif_get_num_default_rss_queues(void)
2063 {
2064         return min_t(int, DEFAULT_MAX_NUM_RSS_QUEUES, num_online_cpus());
2065 }
2066 EXPORT_SYMBOL(netif_get_num_default_rss_queues);
2067
2068 static inline void __netif_reschedule(struct Qdisc *q)
2069 {
2070         struct softnet_data *sd;
2071         unsigned long flags;
2072
2073         local_irq_save(flags);
2074         sd = &__get_cpu_var(softnet_data);
2075         q->next_sched = NULL;
2076         *sd->output_queue_tailp = q;
2077         sd->output_queue_tailp = &q->next_sched;
2078         raise_softirq_irqoff(NET_TX_SOFTIRQ);
2079         local_irq_restore(flags);
2080 }
2081
2082 void __netif_schedule(struct Qdisc *q)
2083 {
2084         if (!test_and_set_bit(__QDISC_STATE_SCHED, &q->state))
2085                 __netif_reschedule(q);
2086 }
2087 EXPORT_SYMBOL(__netif_schedule);
2088
2089 void dev_kfree_skb_irq(struct sk_buff *skb)
2090 {
2091         if (atomic_dec_and_test(&skb->users)) {
2092                 struct softnet_data *sd;
2093                 unsigned long flags;
2094
2095                 local_irq_save(flags);
2096                 sd = &__get_cpu_var(softnet_data);
2097                 skb->next = sd->completion_queue;
2098                 sd->completion_queue = skb;
2099                 raise_softirq_irqoff(NET_TX_SOFTIRQ);
2100                 local_irq_restore(flags);
2101         }
2102 }
2103 EXPORT_SYMBOL(dev_kfree_skb_irq);
2104
2105 void dev_kfree_skb_any(struct sk_buff *skb)
2106 {
2107         if (in_irq() || irqs_disabled())
2108                 dev_kfree_skb_irq(skb);
2109         else
2110                 dev_kfree_skb(skb);
2111 }
2112 EXPORT_SYMBOL(dev_kfree_skb_any);
2113
2114
2115 /**
2116  * netif_device_detach - mark device as removed
2117  * @dev: network device
2118  *
2119  * Mark device as removed from system and therefore no longer available.
2120  */
2121 void netif_device_detach(struct net_device *dev)
2122 {
2123         if (test_and_clear_bit(__LINK_STATE_PRESENT, &dev->state) &&
2124             netif_running(dev)) {
2125                 netif_tx_stop_all_queues(dev);
2126         }
2127 }
2128 EXPORT_SYMBOL(netif_device_detach);
2129
2130 /**
2131  * netif_device_attach - mark device as attached
2132  * @dev: network device
2133  *
2134  * Mark device as attached from system and restart if needed.
2135  */
2136 void netif_device_attach(struct net_device *dev)
2137 {
2138         if (!test_and_set_bit(__LINK_STATE_PRESENT, &dev->state) &&
2139             netif_running(dev)) {
2140                 netif_tx_wake_all_queues(dev);
2141                 __netdev_watchdog_up(dev);
2142         }
2143 }
2144 EXPORT_SYMBOL(netif_device_attach);
2145
2146 static void skb_warn_bad_offload(const struct sk_buff *skb)
2147 {
2148         static const netdev_features_t null_features = 0;
2149         struct net_device *dev = skb->dev;
2150         const char *driver = "";
2151
2152         if (dev && dev->dev.parent)
2153                 driver = dev_driver_string(dev->dev.parent);
2154
2155         WARN(1, "%s: caps=(%pNF, %pNF) len=%d data_len=%d gso_size=%d "
2156              "gso_type=%d ip_summed=%d\n",
2157              driver, dev ? &dev->features : &null_features,
2158              skb->sk ? &skb->sk->sk_route_caps : &null_features,
2159              skb->len, skb->data_len, skb_shinfo(skb)->gso_size,
2160              skb_shinfo(skb)->gso_type, skb->ip_summed);
2161 }
2162
2163 /*
2164  * Invalidate hardware checksum when packet is to be mangled, and
2165  * complete checksum manually on outgoing path.
2166  */
2167 int skb_checksum_help(struct sk_buff *skb)
2168 {
2169         __wsum csum;
2170         int ret = 0, offset;
2171
2172         if (skb->ip_summed == CHECKSUM_COMPLETE)
2173                 goto out_set_summed;
2174
2175         if (unlikely(skb_shinfo(skb)->gso_size)) {
2176                 skb_warn_bad_offload(skb);
2177                 return -EINVAL;
2178         }
2179
2180         /* Before computing a checksum, we should make sure no frag could
2181          * be modified by an external entity : checksum could be wrong.
2182          */
2183         if (skb_has_shared_frag(skb)) {
2184                 ret = __skb_linearize(skb);
2185                 if (ret)
2186                         goto out;
2187         }
2188
2189         offset = skb_checksum_start_offset(skb);
2190         BUG_ON(offset >= skb_headlen(skb));
2191         csum = skb_checksum(skb, offset, skb->len - offset, 0);
2192
2193         offset += skb->csum_offset;
2194         BUG_ON(offset + sizeof(__sum16) > skb_headlen(skb));
2195
2196         if (skb_cloned(skb) &&
2197             !skb_clone_writable(skb, offset + sizeof(__sum16))) {
2198                 ret = pskb_expand_head(skb, 0, 0, GFP_ATOMIC);
2199                 if (ret)
2200                         goto out;
2201         }
2202
2203         *(__sum16 *)(skb->data + offset) = csum_fold(csum);
2204 out_set_summed:
2205         skb->ip_summed = CHECKSUM_NONE;
2206 out:
2207         return ret;
2208 }
2209 EXPORT_SYMBOL(skb_checksum_help);
2210
2211 __be16 skb_network_protocol(struct sk_buff *skb)
2212 {
2213         __be16 type = skb->protocol;
2214
2215         while (type == htons(ETH_P_8021Q)) {
2216                 int vlan_depth = ETH_HLEN;
2217                 struct vlan_hdr *vh;
2218
2219                 if (unlikely(!pskb_may_pull(skb, vlan_depth + VLAN_HLEN)))
2220                         return 0;
2221
2222                 vh = (struct vlan_hdr *)(skb->data + vlan_depth);
2223                 type = vh->h_vlan_encapsulated_proto;
2224                 vlan_depth += VLAN_HLEN;
2225         }
2226
2227         return type;
2228 }
2229
2230 /**
2231  *      skb_mac_gso_segment - mac layer segmentation handler.
2232  *      @skb: buffer to segment
2233  *      @features: features for the output path (see dev->features)
2234  */
2235 struct sk_buff *skb_mac_gso_segment(struct sk_buff *skb,
2236                                     netdev_features_t features)
2237 {
2238         struct sk_buff *segs = ERR_PTR(-EPROTONOSUPPORT);
2239         struct packet_offload *ptype;
2240         __be16 type = skb_network_protocol(skb);
2241
2242         if (unlikely(!type))
2243                 return ERR_PTR(-EINVAL);
2244
2245         __skb_pull(skb, skb->mac_len);
2246
2247         rcu_read_lock();
2248         list_for_each_entry_rcu(ptype, &offload_base, list) {
2249                 if (ptype->type == type && ptype->callbacks.gso_segment) {
2250                         if (unlikely(skb->ip_summed != CHECKSUM_PARTIAL)) {
2251                                 int err;
2252
2253                                 err = ptype->callbacks.gso_send_check(skb);
2254                                 segs = ERR_PTR(err);
2255                                 if (err || skb_gso_ok(skb, features))
2256                                         break;
2257                                 __skb_push(skb, (skb->data -
2258                                                  skb_network_header(skb)));
2259                         }
2260                         segs = ptype->callbacks.gso_segment(skb, features);
2261                         break;
2262                 }
2263         }
2264         rcu_read_unlock();
2265
2266         __skb_push(skb, skb->data - skb_mac_header(skb));
2267
2268         return segs;
2269 }
2270 EXPORT_SYMBOL(skb_mac_gso_segment);
2271
2272
2273 /* openvswitch calls this on rx path, so we need a different check.
2274  */
2275 static inline bool skb_needs_check(struct sk_buff *skb, bool tx_path)
2276 {
2277         if (tx_path)
2278                 return skb->ip_summed != CHECKSUM_PARTIAL;
2279         else
2280                 return skb->ip_summed == CHECKSUM_NONE;
2281 }
2282
2283 /**
2284  *      __skb_gso_segment - Perform segmentation on skb.
2285  *      @skb: buffer to segment
2286  *      @features: features for the output path (see dev->features)
2287  *      @tx_path: whether it is called in TX path
2288  *
2289  *      This function segments the given skb and returns a list of segments.
2290  *
2291  *      It may return NULL if the skb requires no segmentation.  This is
2292  *      only possible when GSO is used for verifying header integrity.
2293  */
2294 struct sk_buff *__skb_gso_segment(struct sk_buff *skb,
2295                                   netdev_features_t features, bool tx_path)
2296 {
2297         if (unlikely(skb_needs_check(skb, tx_path))) {
2298                 int err;
2299
2300                 skb_warn_bad_offload(skb);
2301
2302                 if (skb_header_cloned(skb) &&
2303                     (err = pskb_expand_head(skb, 0, 0, GFP_ATOMIC)))
2304                         return ERR_PTR(err);
2305         }
2306
2307         SKB_GSO_CB(skb)->mac_offset = skb_headroom(skb);
2308         skb_reset_mac_header(skb);
2309         skb_reset_mac_len(skb);
2310
2311         return skb_mac_gso_segment(skb, features);
2312 }
2313 EXPORT_SYMBOL(__skb_gso_segment);
2314
2315 /* Take action when hardware reception checksum errors are detected. */
2316 #ifdef CONFIG_BUG
2317 void netdev_rx_csum_fault(struct net_device *dev)
2318 {
2319         if (net_ratelimit()) {
2320                 pr_err("%s: hw csum failure\n", dev ? dev->name : "<unknown>");
2321                 dump_stack();
2322         }
2323 }
2324 EXPORT_SYMBOL(netdev_rx_csum_fault);
2325 #endif
2326
2327 /* Actually, we should eliminate this check as soon as we know, that:
2328  * 1. IOMMU is present and allows to map all the memory.
2329  * 2. No high memory really exists on this machine.
2330  */
2331
2332 static int illegal_highdma(struct net_device *dev, struct sk_buff *skb)
2333 {
2334 #ifdef CONFIG_HIGHMEM
2335         int i;
2336         if (!(dev->features & NETIF_F_HIGHDMA)) {
2337                 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
2338                         skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
2339                         if (PageHighMem(skb_frag_page(frag)))
2340                                 return 1;
2341                 }
2342         }
2343
2344         if (PCI_DMA_BUS_IS_PHYS) {
2345                 struct device *pdev = dev->dev.parent;
2346
2347                 if (!pdev)
2348                         return 0;
2349                 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
2350                         skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
2351                         dma_addr_t addr = page_to_phys(skb_frag_page(frag));
2352                         if (!pdev->dma_mask || addr + PAGE_SIZE - 1 > *pdev->dma_mask)
2353                                 return 1;
2354                 }
2355         }
2356 #endif
2357         return 0;
2358 }
2359
2360 struct dev_gso_cb {
2361         void (*destructor)(struct sk_buff *skb);
2362 };
2363
2364 #define DEV_GSO_CB(skb) ((struct dev_gso_cb *)(skb)->cb)
2365
2366 static void dev_gso_skb_destructor(struct sk_buff *skb)
2367 {
2368         struct dev_gso_cb *cb;
2369
2370         do {
2371                 struct sk_buff *nskb = skb->next;
2372
2373                 skb->next = nskb->next;
2374                 nskb->next = NULL;
2375                 kfree_skb(nskb);
2376         } while (skb->next);
2377
2378         cb = DEV_GSO_CB(skb);
2379         if (cb->destructor)
2380                 cb->destructor(skb);
2381 }
2382
2383 /**
2384  *      dev_gso_segment - Perform emulated hardware segmentation on skb.
2385  *      @skb: buffer to segment
2386  *      @features: device features as applicable to this skb
2387  *
2388  *      This function segments the given skb and stores the list of segments
2389  *      in skb->next.
2390  */
2391 static int dev_gso_segment(struct sk_buff *skb, netdev_features_t features)
2392 {
2393         struct sk_buff *segs;
2394
2395         segs = skb_gso_segment(skb, features);
2396
2397         /* Verifying header integrity only. */
2398         if (!segs)
2399                 return 0;
2400
2401         if (IS_ERR(segs))
2402                 return PTR_ERR(segs);
2403
2404         skb->next = segs;
2405         DEV_GSO_CB(skb)->destructor = skb->destructor;
2406         skb->destructor = dev_gso_skb_destructor;
2407
2408         return 0;
2409 }
2410
2411 static netdev_features_t harmonize_features(struct sk_buff *skb,
2412         __be16 protocol, netdev_features_t features)
2413 {
2414         if (skb->ip_summed != CHECKSUM_NONE &&
2415             !can_checksum_protocol(features, protocol)) {
2416                 features &= ~NETIF_F_ALL_CSUM;
2417         } else if (illegal_highdma(skb->dev, skb)) {
2418                 features &= ~NETIF_F_SG;
2419         }
2420
2421         return features;
2422 }
2423
2424 netdev_features_t netif_skb_features(struct sk_buff *skb)
2425 {
2426         __be16 protocol = skb->protocol;
2427         netdev_features_t features = skb->dev->features;
2428
2429         if (skb_shinfo(skb)->gso_segs > skb->dev->gso_max_segs)
2430                 features &= ~NETIF_F_GSO_MASK;
2431
2432         if (protocol == htons(ETH_P_8021Q)) {
2433                 struct vlan_ethhdr *veh = (struct vlan_ethhdr *)skb->data;
2434                 protocol = veh->h_vlan_encapsulated_proto;
2435         } else if (!vlan_tx_tag_present(skb)) {
2436                 return harmonize_features(skb, protocol, features);
2437         }
2438
2439         features &= (skb->dev->vlan_features | NETIF_F_HW_VLAN_TX);
2440
2441         if (protocol != htons(ETH_P_8021Q)) {
2442                 return harmonize_features(skb, protocol, features);
2443         } else {
2444                 features &= NETIF_F_SG | NETIF_F_HIGHDMA | NETIF_F_FRAGLIST |
2445                                 NETIF_F_GEN_CSUM | NETIF_F_HW_VLAN_TX;
2446                 return harmonize_features(skb, protocol, features);
2447         }
2448 }
2449 EXPORT_SYMBOL(netif_skb_features);
2450
2451 /*
2452  * Returns true if either:
2453  *      1. skb has frag_list and the device doesn't support FRAGLIST, or
2454  *      2. skb is fragmented and the device does not support SG.
2455  */
2456 static inline int skb_needs_linearize(struct sk_buff *skb,
2457                                       int features)
2458 {
2459         return skb_is_nonlinear(skb) &&
2460                         ((skb_has_frag_list(skb) &&
2461                                 !(features & NETIF_F_FRAGLIST)) ||
2462                         (skb_shinfo(skb)->nr_frags &&
2463                                 !(features & NETIF_F_SG)));
2464 }
2465
2466 int dev_hard_start_xmit(struct sk_buff *skb, struct net_device *dev,
2467                         struct netdev_queue *txq)
2468 {
2469         const struct net_device_ops *ops = dev->netdev_ops;
2470         int rc = NETDEV_TX_OK;
2471         unsigned int skb_len;
2472
2473         if (likely(!skb->next)) {
2474                 netdev_features_t features;
2475
2476                 /*
2477                  * If device doesn't need skb->dst, release it right now while
2478                  * its hot in this cpu cache
2479                  */
2480                 if (dev->priv_flags & IFF_XMIT_DST_RELEASE)
2481                         skb_dst_drop(skb);
2482
2483                 features = netif_skb_features(skb);
2484
2485                 if (vlan_tx_tag_present(skb) &&
2486                     !(features & NETIF_F_HW_VLAN_TX)) {
2487                         skb = __vlan_put_tag(skb, vlan_tx_tag_get(skb));
2488                         if (unlikely(!skb))
2489                                 goto out;
2490
2491                         skb->vlan_tci = 0;
2492                 }
2493
2494                 /* If encapsulation offload request, verify we are testing
2495                  * hardware encapsulation features instead of standard
2496                  * features for the netdev
2497                  */
2498                 if (skb->encapsulation)
2499                         features &= dev->hw_enc_features;
2500
2501                 if (netif_needs_gso(skb, features)) {
2502                         if (unlikely(dev_gso_segment(skb, features)))
2503                                 goto out_kfree_skb;
2504                         if (skb->next)
2505                                 goto gso;
2506                 } else {
2507                         if (skb_needs_linearize(skb, features) &&
2508                             __skb_linearize(skb))
2509                                 goto out_kfree_skb;
2510
2511                         /* If packet is not checksummed and device does not
2512                          * support checksumming for this protocol, complete
2513                          * checksumming here.
2514                          */
2515                         if (skb->ip_summed == CHECKSUM_PARTIAL) {
2516                                 if (skb->encapsulation)
2517                                         skb_set_inner_transport_header(skb,
2518                                                 skb_checksum_start_offset(skb));
2519                                 else
2520                                         skb_set_transport_header(skb,
2521                                                 skb_checksum_start_offset(skb));
2522                                 if (!(features & NETIF_F_ALL_CSUM) &&
2523                                      skb_checksum_help(skb))
2524                                         goto out_kfree_skb;
2525                         }
2526                 }
2527
2528                 if (!list_empty(&ptype_all))
2529                         dev_queue_xmit_nit(skb, dev);
2530
2531                 skb_len = skb->len;
2532                 rc = ops->ndo_start_xmit(skb, dev);
2533                 trace_net_dev_xmit(skb, rc, dev, skb_len);
2534                 if (rc == NETDEV_TX_OK)
2535                         txq_trans_update(txq);
2536                 return rc;
2537         }
2538
2539 gso:
2540         do {
2541                 struct sk_buff *nskb = skb->next;
2542
2543                 skb->next = nskb->next;
2544                 nskb->next = NULL;
2545
2546                 /*
2547                  * If device doesn't need nskb->dst, release it right now while
2548                  * its hot in this cpu cache
2549                  */
2550                 if (dev->priv_flags & IFF_XMIT_DST_RELEASE)
2551                         skb_dst_drop(nskb);
2552
2553                 if (!list_empty(&ptype_all))
2554                         dev_queue_xmit_nit(nskb, dev);
2555
2556                 skb_len = nskb->len;
2557                 rc = ops->ndo_start_xmit(nskb, dev);
2558                 trace_net_dev_xmit(nskb, rc, dev, skb_len);
2559                 if (unlikely(rc != NETDEV_TX_OK)) {
2560                         if (rc & ~NETDEV_TX_MASK)
2561                                 goto out_kfree_gso_skb;
2562                         nskb->next = skb->next;
2563                         skb->next = nskb;
2564                         return rc;
2565                 }
2566                 txq_trans_update(txq);
2567                 if (unlikely(netif_xmit_stopped(txq) && skb->next))
2568                         return NETDEV_TX_BUSY;
2569         } while (skb->next);
2570
2571 out_kfree_gso_skb:
2572         if (likely(skb->next == NULL))
2573                 skb->destructor = DEV_GSO_CB(skb)->destructor;
2574 out_kfree_skb:
2575         kfree_skb(skb);
2576 out:
2577         return rc;
2578 }
2579
2580 static void qdisc_pkt_len_init(struct sk_buff *skb)
2581 {
2582         const struct skb_shared_info *shinfo = skb_shinfo(skb);
2583
2584         qdisc_skb_cb(skb)->pkt_len = skb->len;
2585
2586         /* To get more precise estimation of bytes sent on wire,
2587          * we add to pkt_len the headers size of all segments
2588          */
2589         if (shinfo->gso_size)  {
2590                 unsigned int hdr_len;
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                 qdisc_skb_cb(skb)->pkt_len += (shinfo->gso_segs - 1) * hdr_len;
2601         }
2602 }
2603
2604 static inline int __dev_xmit_skb(struct sk_buff *skb, struct Qdisc *q,
2605                                  struct net_device *dev,
2606                                  struct netdev_queue *txq)
2607 {
2608         spinlock_t *root_lock = qdisc_lock(q);
2609         bool contended;
2610         int rc;
2611
2612         qdisc_pkt_len_init(skb);
2613         qdisc_calculate_pkt_len(skb, q);
2614         /*
2615          * Heuristic to force contended enqueues to serialize on a
2616          * separate lock before trying to get qdisc main lock.
2617          * This permits __QDISC_STATE_RUNNING owner to get the lock more often
2618          * and dequeue packets faster.
2619          */
2620         contended = qdisc_is_running(q);
2621         if (unlikely(contended))
2622                 spin_lock(&q->busylock);
2623
2624         spin_lock(root_lock);
2625         if (unlikely(test_bit(__QDISC_STATE_DEACTIVATED, &q->state))) {
2626                 kfree_skb(skb);
2627                 rc = NET_XMIT_DROP;
2628         } else if ((q->flags & TCQ_F_CAN_BYPASS) && !qdisc_qlen(q) &&
2629                    qdisc_run_begin(q)) {
2630                 /*
2631                  * This is a work-conserving queue; there are no old skbs
2632                  * waiting to be sent out; and the qdisc is not running -
2633                  * xmit the skb directly.
2634                  */
2635                 if (!(dev->priv_flags & IFF_XMIT_DST_RELEASE))
2636                         skb_dst_force(skb);
2637
2638                 qdisc_bstats_update(q, skb);
2639
2640                 if (sch_direct_xmit(skb, q, dev, txq, root_lock)) {
2641                         if (unlikely(contended)) {
2642                                 spin_unlock(&q->busylock);
2643                                 contended = false;
2644                         }
2645                         __qdisc_run(q);
2646                 } else
2647                         qdisc_run_end(q);
2648
2649                 rc = NET_XMIT_SUCCESS;
2650         } else {
2651                 skb_dst_force(skb);
2652                 rc = q->enqueue(skb, q) & NET_XMIT_MASK;
2653                 if (qdisc_run_begin(q)) {
2654                         if (unlikely(contended)) {
2655                                 spin_unlock(&q->busylock);
2656                                 contended = false;
2657                         }
2658                         __qdisc_run(q);
2659                 }
2660         }
2661         spin_unlock(root_lock);
2662         if (unlikely(contended))
2663                 spin_unlock(&q->busylock);
2664         return rc;
2665 }
2666
2667 #if IS_ENABLED(CONFIG_NETPRIO_CGROUP)
2668 static void skb_update_prio(struct sk_buff *skb)
2669 {
2670         struct netprio_map *map = rcu_dereference_bh(skb->dev->priomap);
2671
2672         if (!skb->priority && skb->sk && map) {
2673                 unsigned int prioidx = skb->sk->sk_cgrp_prioidx;
2674
2675                 if (prioidx < map->priomap_len)
2676                         skb->priority = map->priomap[prioidx];
2677         }
2678 }
2679 #else
2680 #define skb_update_prio(skb)
2681 #endif
2682
2683 static DEFINE_PER_CPU(int, xmit_recursion);
2684 #define RECURSION_LIMIT 10
2685
2686 /**
2687  *      dev_loopback_xmit - loop back @skb
2688  *      @skb: buffer to transmit
2689  */
2690 int dev_loopback_xmit(struct sk_buff *skb)
2691 {
2692         skb_reset_mac_header(skb);
2693         __skb_pull(skb, skb_network_offset(skb));
2694         skb->pkt_type = PACKET_LOOPBACK;
2695         skb->ip_summed = CHECKSUM_UNNECESSARY;
2696         WARN_ON(!skb_dst(skb));
2697         skb_dst_force(skb);
2698         netif_rx_ni(skb);
2699         return 0;
2700 }
2701 EXPORT_SYMBOL(dev_loopback_xmit);
2702
2703 /**
2704  *      dev_queue_xmit - transmit a buffer
2705  *      @skb: buffer to transmit
2706  *
2707  *      Queue a buffer for transmission to a network device. The caller must
2708  *      have set the device and priority and built the buffer before calling
2709  *      this function. The function can be called from an interrupt.
2710  *
2711  *      A negative errno code is returned on a failure. A success does not
2712  *      guarantee the frame will be transmitted as it may be dropped due
2713  *      to congestion or traffic shaping.
2714  *
2715  * -----------------------------------------------------------------------------------
2716  *      I notice this method can also return errors from the queue disciplines,
2717  *      including NET_XMIT_DROP, which is a positive value.  So, errors can also
2718  *      be positive.
2719  *
2720  *      Regardless of the return value, the skb is consumed, so it is currently
2721  *      difficult to retry a send to this method.  (You can bump the ref count
2722  *      before sending to hold a reference for retry if you are careful.)
2723  *
2724  *      When calling this method, interrupts MUST be enabled.  This is because
2725  *      the BH enable code must have IRQs enabled so that it will not deadlock.
2726  *          --BLG
2727  */
2728 int dev_queue_xmit(struct sk_buff *skb)
2729 {
2730         struct net_device *dev = skb->dev;
2731         struct netdev_queue *txq;
2732         struct Qdisc *q;
2733         int rc = -ENOMEM;
2734
2735         skb_reset_mac_header(skb);
2736
2737         /* Disable soft irqs for various locks below. Also
2738          * stops preemption for RCU.
2739          */
2740         rcu_read_lock_bh();
2741
2742         skb_update_prio(skb);
2743
2744         txq = netdev_pick_tx(dev, skb);
2745         q = rcu_dereference_bh(txq->qdisc);
2746
2747 #ifdef CONFIG_NET_CLS_ACT
2748         skb->tc_verd = SET_TC_AT(skb->tc_verd, AT_EGRESS);
2749 #endif
2750         trace_net_dev_queue(skb);
2751         if (q->enqueue) {
2752                 rc = __dev_xmit_skb(skb, q, dev, txq);
2753                 goto out;
2754         }
2755
2756         /* The device has no queue. Common case for software devices:
2757            loopback, all the sorts of tunnels...
2758
2759            Really, it is unlikely that netif_tx_lock protection is necessary
2760            here.  (f.e. loopback and IP tunnels are clean ignoring statistics
2761            counters.)
2762            However, it is possible, that they rely on protection
2763            made by us here.
2764
2765            Check this and shot the lock. It is not prone from deadlocks.
2766            Either shot noqueue qdisc, it is even simpler 8)
2767          */
2768         if (dev->flags & IFF_UP) {
2769                 int cpu = smp_processor_id(); /* ok because BHs are off */
2770
2771                 if (txq->xmit_lock_owner != cpu) {
2772
2773                         if (__this_cpu_read(xmit_recursion) > RECURSION_LIMIT)
2774                                 goto recursion_alert;
2775
2776                         HARD_TX_LOCK(dev, txq, cpu);
2777
2778                         if (!netif_xmit_stopped(txq)) {
2779                                 __this_cpu_inc(xmit_recursion);
2780                                 rc = dev_hard_start_xmit(skb, dev, txq);
2781                                 __this_cpu_dec(xmit_recursion);
2782                                 if (dev_xmit_complete(rc)) {
2783                                         HARD_TX_UNLOCK(dev, txq);
2784                                         goto out;
2785                                 }
2786                         }
2787                         HARD_TX_UNLOCK(dev, txq);
2788                         net_crit_ratelimited("Virtual device %s asks to queue packet!\n",
2789                                              dev->name);
2790                 } else {
2791                         /* Recursion is detected! It is possible,
2792                          * unfortunately
2793                          */
2794 recursion_alert:
2795                         net_crit_ratelimited("Dead loop on virtual device %s, fix it urgently!\n",
2796                                              dev->name);
2797                 }
2798         }
2799
2800         rc = -ENETDOWN;
2801         rcu_read_unlock_bh();
2802
2803         kfree_skb(skb);
2804         return rc;
2805 out:
2806         rcu_read_unlock_bh();
2807         return rc;
2808 }
2809 EXPORT_SYMBOL(dev_queue_xmit);
2810
2811
2812 /*=======================================================================
2813                         Receiver routines
2814   =======================================================================*/
2815
2816 int netdev_max_backlog __read_mostly = 1000;
2817 EXPORT_SYMBOL(netdev_max_backlog);
2818
2819 int netdev_tstamp_prequeue __read_mostly = 1;
2820 int netdev_budget __read_mostly = 300;
2821 int weight_p __read_mostly = 64;            /* old backlog weight */
2822
2823 /* Called with irq disabled */
2824 static inline void ____napi_schedule(struct softnet_data *sd,
2825                                      struct napi_struct *napi)
2826 {
2827         list_add_tail(&napi->poll_list, &sd->poll_list);
2828         __raise_softirq_irqoff(NET_RX_SOFTIRQ);
2829 }
2830
2831 #ifdef CONFIG_RPS
2832
2833 /* One global table that all flow-based protocols share. */
2834 struct rps_sock_flow_table __rcu *rps_sock_flow_table __read_mostly;
2835 EXPORT_SYMBOL(rps_sock_flow_table);
2836
2837 struct static_key rps_needed __read_mostly;
2838
2839 static struct rps_dev_flow *
2840 set_rps_cpu(struct net_device *dev, struct sk_buff *skb,
2841             struct rps_dev_flow *rflow, u16 next_cpu)
2842 {
2843         if (next_cpu != RPS_NO_CPU) {
2844 #ifdef CONFIG_RFS_ACCEL
2845                 struct netdev_rx_queue *rxqueue;
2846                 struct rps_dev_flow_table *flow_table;
2847                 struct rps_dev_flow *old_rflow;
2848                 u32 flow_id;
2849                 u16 rxq_index;
2850                 int rc;
2851
2852                 /* Should we steer this flow to a different hardware queue? */
2853                 if (!skb_rx_queue_recorded(skb) || !dev->rx_cpu_rmap ||
2854                     !(dev->features & NETIF_F_NTUPLE))
2855                         goto out;
2856                 rxq_index = cpu_rmap_lookup_index(dev->rx_cpu_rmap, next_cpu);
2857                 if (rxq_index == skb_get_rx_queue(skb))
2858                         goto out;
2859
2860                 rxqueue = dev->_rx + rxq_index;
2861                 flow_table = rcu_dereference(rxqueue->rps_flow_table);
2862                 if (!flow_table)
2863                         goto out;
2864                 flow_id = skb->rxhash & flow_table->mask;
2865                 rc = dev->netdev_ops->ndo_rx_flow_steer(dev, skb,
2866                                                         rxq_index, flow_id);
2867                 if (rc < 0)
2868                         goto out;
2869                 old_rflow = rflow;
2870                 rflow = &flow_table->flows[flow_id];
2871                 rflow->filter = rc;
2872                 if (old_rflow->filter == rflow->filter)
2873                         old_rflow->filter = RPS_NO_FILTER;
2874         out:
2875 #endif
2876                 rflow->last_qtail =
2877                         per_cpu(softnet_data, next_cpu).input_queue_head;
2878         }
2879
2880         rflow->cpu = next_cpu;
2881         return rflow;
2882 }
2883
2884 /*
2885  * get_rps_cpu is called from netif_receive_skb and returns the target
2886  * CPU from the RPS map of the receiving queue for a given skb.
2887  * rcu_read_lock must be held on entry.
2888  */
2889 static int get_rps_cpu(struct net_device *dev, struct sk_buff *skb,
2890                        struct rps_dev_flow **rflowp)
2891 {
2892         struct netdev_rx_queue *rxqueue;
2893         struct rps_map *map;
2894         struct rps_dev_flow_table *flow_table;
2895         struct rps_sock_flow_table *sock_flow_table;
2896         int cpu = -1;
2897         u16 tcpu;
2898
2899         if (skb_rx_queue_recorded(skb)) {
2900                 u16 index = skb_get_rx_queue(skb);
2901                 if (unlikely(index >= dev->real_num_rx_queues)) {
2902                         WARN_ONCE(dev->real_num_rx_queues > 1,
2903                                   "%s received packet on queue %u, but number "
2904                                   "of RX queues is %u\n",
2905                                   dev->name, index, dev->real_num_rx_queues);
2906                         goto done;
2907                 }
2908                 rxqueue = dev->_rx + index;
2909         } else
2910                 rxqueue = dev->_rx;
2911
2912         map = rcu_dereference(rxqueue->rps_map);
2913         if (map) {
2914                 if (map->len == 1 &&
2915                     !rcu_access_pointer(rxqueue->rps_flow_table)) {
2916                         tcpu = map->cpus[0];
2917                         if (cpu_online(tcpu))
2918                                 cpu = tcpu;
2919                         goto done;
2920                 }
2921         } else if (!rcu_access_pointer(rxqueue->rps_flow_table)) {
2922                 goto done;
2923         }
2924
2925         skb_reset_network_header(skb);
2926         if (!skb_get_rxhash(skb))
2927                 goto done;
2928
2929         flow_table = rcu_dereference(rxqueue->rps_flow_table);
2930         sock_flow_table = rcu_dereference(rps_sock_flow_table);
2931         if (flow_table && sock_flow_table) {
2932                 u16 next_cpu;
2933                 struct rps_dev_flow *rflow;
2934
2935                 rflow = &flow_table->flows[skb->rxhash & flow_table->mask];
2936                 tcpu = rflow->cpu;
2937
2938                 next_cpu = sock_flow_table->ents[skb->rxhash &
2939                     sock_flow_table->mask];
2940
2941                 /*
2942                  * If the desired CPU (where last recvmsg was done) is
2943                  * different from current CPU (one in the rx-queue flow
2944                  * table entry), switch if one of the following holds:
2945                  *   - Current CPU is unset (equal to RPS_NO_CPU).
2946                  *   - Current CPU is offline.
2947                  *   - The current CPU's queue tail has advanced beyond the
2948                  *     last packet that was enqueued using this table entry.
2949                  *     This guarantees that all previous packets for the flow
2950                  *     have been dequeued, thus preserving in order delivery.
2951                  */
2952                 if (unlikely(tcpu != next_cpu) &&
2953                     (tcpu == RPS_NO_CPU || !cpu_online(tcpu) ||
2954                      ((int)(per_cpu(softnet_data, tcpu).input_queue_head -
2955                       rflow->last_qtail)) >= 0)) {
2956                         tcpu = next_cpu;
2957                         rflow = set_rps_cpu(dev, skb, rflow, next_cpu);
2958                 }
2959
2960                 if (tcpu != RPS_NO_CPU && cpu_online(tcpu)) {
2961                         *rflowp = rflow;
2962                         cpu = tcpu;
2963                         goto done;
2964                 }
2965         }
2966
2967         if (map) {
2968                 tcpu = map->cpus[((u64) skb->rxhash * map->len) >> 32];
2969
2970                 if (cpu_online(tcpu)) {
2971                         cpu = tcpu;
2972                         goto done;
2973                 }
2974         }
2975
2976 done:
2977         return cpu;
2978 }
2979
2980 #ifdef CONFIG_RFS_ACCEL
2981
2982 /**
2983  * rps_may_expire_flow - check whether an RFS hardware filter may be removed
2984  * @dev: Device on which the filter was set
2985  * @rxq_index: RX queue index
2986  * @flow_id: Flow ID passed to ndo_rx_flow_steer()
2987  * @filter_id: Filter ID returned by ndo_rx_flow_steer()
2988  *
2989  * Drivers that implement ndo_rx_flow_steer() should periodically call
2990  * this function for each installed filter and remove the filters for
2991  * which it returns %true.
2992  */
2993 bool rps_may_expire_flow(struct net_device *dev, u16 rxq_index,
2994                          u32 flow_id, u16 filter_id)
2995 {
2996         struct netdev_rx_queue *rxqueue = dev->_rx + rxq_index;
2997         struct rps_dev_flow_table *flow_table;
2998         struct rps_dev_flow *rflow;
2999         bool expire = true;
3000         int cpu;
3001
3002         rcu_read_lock();
3003         flow_table = rcu_dereference(rxqueue->rps_flow_table);
3004         if (flow_table && flow_id <= flow_table->mask) {
3005                 rflow = &flow_table->flows[flow_id];
3006                 cpu = ACCESS_ONCE(rflow->cpu);
3007                 if (rflow->filter == filter_id && cpu != RPS_NO_CPU &&
3008                     ((int)(per_cpu(softnet_data, cpu).input_queue_head -
3009                            rflow->last_qtail) <
3010                      (int)(10 * flow_table->mask)))
3011                         expire = false;
3012         }
3013         rcu_read_unlock();
3014         return expire;
3015 }
3016 EXPORT_SYMBOL(rps_may_expire_flow);
3017
3018 #endif /* CONFIG_RFS_ACCEL */
3019
3020 /* Called from hardirq (IPI) context */
3021 static void rps_trigger_softirq(void *data)
3022 {
3023         struct softnet_data *sd = data;
3024
3025         ____napi_schedule(sd, &sd->backlog);
3026         sd->received_rps++;
3027 }
3028
3029 #endif /* CONFIG_RPS */
3030
3031 /*
3032  * Check if this softnet_data structure is another cpu one
3033  * If yes, queue it to our IPI list and return 1
3034  * If no, return 0
3035  */
3036 static int rps_ipi_queued(struct softnet_data *sd)
3037 {
3038 #ifdef CONFIG_RPS
3039         struct softnet_data *mysd = &__get_cpu_var(softnet_data);
3040
3041         if (sd != mysd) {
3042                 sd->rps_ipi_next = mysd->rps_ipi_list;
3043                 mysd->rps_ipi_list = sd;
3044
3045                 __raise_softirq_irqoff(NET_RX_SOFTIRQ);
3046                 return 1;
3047         }
3048 #endif /* CONFIG_RPS */
3049         return 0;
3050 }
3051
3052 /*
3053  * enqueue_to_backlog is called to queue an skb to a per CPU backlog
3054  * queue (may be a remote CPU queue).
3055  */
3056 static int enqueue_to_backlog(struct sk_buff *skb, int cpu,
3057                               unsigned int *qtail)
3058 {
3059         struct softnet_data *sd;
3060         unsigned long flags;
3061
3062         sd = &per_cpu(softnet_data, cpu);
3063
3064         local_irq_save(flags);
3065
3066         rps_lock(sd);
3067         if (skb_queue_len(&sd->input_pkt_queue) <= netdev_max_backlog) {
3068                 if (skb_queue_len(&sd->input_pkt_queue)) {
3069 enqueue:
3070                         __skb_queue_tail(&sd->input_pkt_queue, skb);
3071                         input_queue_tail_incr_save(sd, qtail);
3072                         rps_unlock(sd);
3073                         local_irq_restore(flags);
3074                         return NET_RX_SUCCESS;
3075                 }
3076
3077                 /* Schedule NAPI for backlog device
3078                  * We can use non atomic operation since we own the queue lock
3079                  */
3080                 if (!__test_and_set_bit(NAPI_STATE_SCHED, &sd->backlog.state)) {
3081                         if (!rps_ipi_queued(sd))
3082                                 ____napi_schedule(sd, &sd->backlog);
3083                 }
3084                 goto enqueue;
3085         }
3086
3087         sd->dropped++;
3088         rps_unlock(sd);
3089
3090         local_irq_restore(flags);
3091
3092         atomic_long_inc(&skb->dev->rx_dropped);
3093         kfree_skb(skb);
3094         return NET_RX_DROP;
3095 }
3096
3097 /**
3098  *      netif_rx        -       post buffer to the network code
3099  *      @skb: buffer to post
3100  *
3101  *      This function receives a packet from a device driver and queues it for
3102  *      the upper (protocol) levels to process.  It always succeeds. The buffer
3103  *      may be dropped during processing for congestion control or by the
3104  *      protocol layers.
3105  *
3106  *      return values:
3107  *      NET_RX_SUCCESS  (no congestion)
3108  *      NET_RX_DROP     (packet was dropped)
3109  *
3110  */
3111
3112 int netif_rx(struct sk_buff *skb)
3113 {
3114         int ret;
3115
3116         /* if netpoll wants it, pretend we never saw it */
3117         if (netpoll_rx(skb))
3118                 return NET_RX_DROP;
3119
3120         net_timestamp_check(netdev_tstamp_prequeue, skb);
3121
3122         trace_netif_rx(skb);
3123 #ifdef CONFIG_RPS
3124         if (static_key_false(&rps_needed)) {
3125                 struct rps_dev_flow voidflow, *rflow = &voidflow;
3126                 int cpu;
3127
3128                 preempt_disable();
3129                 rcu_read_lock();
3130
3131                 cpu = get_rps_cpu(skb->dev, skb, &rflow);
3132                 if (cpu < 0)
3133                         cpu = smp_processor_id();
3134
3135                 ret = enqueue_to_backlog(skb, cpu, &rflow->last_qtail);
3136
3137                 rcu_read_unlock();
3138                 preempt_enable();
3139         } else
3140 #endif
3141         {
3142                 unsigned int qtail;
3143                 ret = enqueue_to_backlog(skb, get_cpu(), &qtail);
3144                 put_cpu();
3145         }
3146         return ret;
3147 }
3148 EXPORT_SYMBOL(netif_rx);
3149
3150 int netif_rx_ni(struct sk_buff *skb)
3151 {
3152         int err;
3153
3154         preempt_disable();
3155         err = netif_rx(skb);
3156         if (local_softirq_pending())
3157                 do_softirq();
3158         preempt_enable();
3159
3160         return err;
3161 }
3162 EXPORT_SYMBOL(netif_rx_ni);
3163
3164 static void net_tx_action(struct softirq_action *h)
3165 {
3166         struct softnet_data *sd = &__get_cpu_var(softnet_data);
3167
3168         if (sd->completion_queue) {
3169                 struct sk_buff *clist;
3170
3171                 local_irq_disable();
3172                 clist = sd->completion_queue;
3173                 sd->completion_queue = NULL;
3174                 local_irq_enable();
3175
3176                 while (clist) {
3177                         struct sk_buff *skb = clist;
3178                         clist = clist->next;
3179
3180                         WARN_ON(atomic_read(&skb->users));
3181                         trace_kfree_skb(skb, net_tx_action);
3182                         __kfree_skb(skb);
3183                 }
3184         }
3185
3186         if (sd->output_queue) {
3187                 struct Qdisc *head;
3188
3189                 local_irq_disable();
3190                 head = sd->output_queue;
3191                 sd->output_queue = NULL;
3192                 sd->output_queue_tailp = &sd->output_queue;
3193                 local_irq_enable();
3194
3195                 while (head) {
3196                         struct Qdisc *q = head;
3197                         spinlock_t *root_lock;
3198
3199                         head = head->next_sched;
3200
3201                         root_lock = qdisc_lock(q);
3202                         if (spin_trylock(root_lock)) {
3203                                 smp_mb__before_clear_bit();
3204                                 clear_bit(__QDISC_STATE_SCHED,
3205                                           &q->state);
3206                                 qdisc_run(q);
3207                                 spin_unlock(root_lock);
3208                         } else {
3209                                 if (!test_bit(__QDISC_STATE_DEACTIVATED,
3210                                               &q->state)) {
3211                                         __netif_reschedule(q);
3212                                 } else {
3213                                         smp_mb__before_clear_bit();
3214                                         clear_bit(__QDISC_STATE_SCHED,
3215                                                   &q->state);
3216                                 }
3217                         }
3218                 }
3219         }
3220 }
3221
3222 #if (defined(CONFIG_BRIDGE) || defined(CONFIG_BRIDGE_MODULE)) && \
3223     (defined(CONFIG_ATM_LANE) || defined(CONFIG_ATM_LANE_MODULE))
3224 /* This hook is defined here for ATM LANE */
3225 int (*br_fdb_test_addr_hook)(struct net_device *dev,
3226                              unsigned char *addr) __read_mostly;
3227 EXPORT_SYMBOL_GPL(br_fdb_test_addr_hook);
3228 #endif
3229
3230 #ifdef CONFIG_NET_CLS_ACT
3231 /* TODO: Maybe we should just force sch_ingress to be compiled in
3232  * when CONFIG_NET_CLS_ACT is? otherwise some useless instructions
3233  * a compare and 2 stores extra right now if we dont have it on
3234  * but have CONFIG_NET_CLS_ACT
3235  * NOTE: This doesn't stop any functionality; if you dont have
3236  * the ingress scheduler, you just can't add policies on ingress.
3237  *
3238  */
3239 static int ing_filter(struct sk_buff *skb, struct netdev_queue *rxq)
3240 {
3241         struct net_device *dev = skb->dev;
3242         u32 ttl = G_TC_RTTL(skb->tc_verd);
3243         int result = TC_ACT_OK;
3244         struct Qdisc *q;
3245
3246         if (unlikely(MAX_RED_LOOP < ttl++)) {
3247                 net_warn_ratelimited("Redir loop detected Dropping packet (%d->%d)\n",
3248                                      skb->skb_iif, dev->ifindex);
3249                 return TC_ACT_SHOT;
3250         }
3251
3252         skb->tc_verd = SET_TC_RTTL(skb->tc_verd, ttl);
3253         skb->tc_verd = SET_TC_AT(skb->tc_verd, AT_INGRESS);
3254
3255         q = rxq->qdisc;
3256         if (q != &noop_qdisc) {
3257                 spin_lock(qdisc_lock(q));
3258                 if (likely(!test_bit(__QDISC_STATE_DEACTIVATED, &q->state)))
3259                         result = qdisc_enqueue_root(skb, q);
3260                 spin_unlock(qdisc_lock(q));
3261         }
3262
3263         return result;
3264 }
3265
3266 static inline struct sk_buff *handle_ing(struct sk_buff *skb,
3267                                          struct packet_type **pt_prev,
3268                                          int *ret, struct net_device *orig_dev)
3269 {
3270         struct netdev_queue *rxq = rcu_dereference(skb->dev->ingress_queue);
3271
3272         if (!rxq || rxq->qdisc == &noop_qdisc)
3273                 goto out;
3274
3275         if (*pt_prev) {
3276                 *ret = deliver_skb(skb, *pt_prev, orig_dev);
3277                 *pt_prev = NULL;
3278         }
3279
3280         switch (ing_filter(skb, rxq)) {
3281         case TC_ACT_SHOT:
3282         case TC_ACT_STOLEN:
3283                 kfree_skb(skb);
3284                 return NULL;
3285         }
3286
3287 out:
3288         skb->tc_verd = 0;
3289         return skb;
3290 }
3291 #endif
3292
3293 /**
3294  *      netdev_rx_handler_register - register receive handler
3295  *      @dev: device to register a handler for
3296  *      @rx_handler: receive handler to register
3297  *      @rx_handler_data: data pointer that is used by rx handler
3298  *
3299  *      Register a receive hander for a device. This handler will then be
3300  *      called from __netif_receive_skb. A negative errno code is returned
3301  *      on a failure.
3302  *
3303  *      The caller must hold the rtnl_mutex.
3304  *
3305  *      For a general description of rx_handler, see enum rx_handler_result.
3306  */
3307 int netdev_rx_handler_register(struct net_device *dev,
3308                                rx_handler_func_t *rx_handler,
3309                                void *rx_handler_data)
3310 {
3311         ASSERT_RTNL();
3312
3313         if (dev->rx_handler)
3314                 return -EBUSY;
3315
3316         rcu_assign_pointer(dev->rx_handler_data, rx_handler_data);
3317         rcu_assign_pointer(dev->rx_handler, rx_handler);
3318
3319         return 0;
3320 }
3321 EXPORT_SYMBOL_GPL(netdev_rx_handler_register);
3322
3323 /**
3324  *      netdev_rx_handler_unregister - unregister receive handler
3325  *      @dev: device to unregister a handler from
3326  *
3327  *      Unregister a receive hander from a device.
3328  *
3329  *      The caller must hold the rtnl_mutex.
3330  */
3331 void netdev_rx_handler_unregister(struct net_device *dev)
3332 {
3333
3334         ASSERT_RTNL();
3335         RCU_INIT_POINTER(dev->rx_handler, NULL);
3336         RCU_INIT_POINTER(dev->rx_handler_data, NULL);
3337 }
3338 EXPORT_SYMBOL_GPL(netdev_rx_handler_unregister);
3339
3340 /*
3341  * Limit the use of PFMEMALLOC reserves to those protocols that implement
3342  * the special handling of PFMEMALLOC skbs.
3343  */
3344 static bool skb_pfmemalloc_protocol(struct sk_buff *skb)
3345 {
3346         switch (skb->protocol) {
3347         case __constant_htons(ETH_P_ARP):
3348         case __constant_htons(ETH_P_IP):
3349         case __constant_htons(ETH_P_IPV6):
3350         case __constant_htons(ETH_P_8021Q):
3351                 return true;
3352         default:
3353                 return false;
3354         }
3355 }
3356
3357 static int __netif_receive_skb_core(struct sk_buff *skb, bool pfmemalloc)
3358 {
3359         struct packet_type *ptype, *pt_prev;
3360         rx_handler_func_t *rx_handler;
3361         struct net_device *orig_dev;
3362         struct net_device *null_or_dev;
3363         bool deliver_exact = false;
3364         int ret = NET_RX_DROP;
3365         __be16 type;
3366
3367         net_timestamp_check(!netdev_tstamp_prequeue, skb);
3368
3369         trace_netif_receive_skb(skb);
3370
3371         /* if we've gotten here through NAPI, check netpoll */
3372         if (netpoll_receive_skb(skb))
3373                 goto out;
3374
3375         orig_dev = skb->dev;
3376
3377         skb_reset_network_header(skb);
3378         if (!skb_transport_header_was_set(skb))
3379                 skb_reset_transport_header(skb);
3380         skb_reset_mac_len(skb);
3381
3382         pt_prev = NULL;
3383
3384         rcu_read_lock();
3385
3386 another_round:
3387         skb->skb_iif = skb->dev->ifindex;
3388
3389         __this_cpu_inc(softnet_data.processed);
3390
3391         if (skb->protocol == cpu_to_be16(ETH_P_8021Q)) {
3392                 skb = vlan_untag(skb);
3393                 if (unlikely(!skb))
3394                         goto unlock;
3395         }
3396
3397 #ifdef CONFIG_NET_CLS_ACT
3398         if (skb->tc_verd & TC_NCLS) {
3399                 skb->tc_verd = CLR_TC_NCLS(skb->tc_verd);
3400                 goto ncls;
3401         }
3402 #endif
3403
3404         if (pfmemalloc)
3405                 goto skip_taps;
3406
3407         list_for_each_entry_rcu(ptype, &ptype_all, list) {
3408                 if (!ptype->dev || ptype->dev == skb->dev) {
3409                         if (pt_prev)
3410                                 ret = deliver_skb(skb, pt_prev, orig_dev);
3411                         pt_prev = ptype;
3412                 }
3413         }
3414
3415 skip_taps:
3416 #ifdef CONFIG_NET_CLS_ACT
3417         skb = handle_ing(skb, &pt_prev, &ret, orig_dev);
3418         if (!skb)
3419                 goto unlock;
3420 ncls:
3421 #endif
3422
3423         if (pfmemalloc && !skb_pfmemalloc_protocol(skb))
3424                 goto drop;
3425
3426         if (vlan_tx_tag_present(skb)) {
3427                 if (pt_prev) {
3428                         ret = deliver_skb(skb, pt_prev, orig_dev);
3429                         pt_prev = NULL;
3430                 }
3431                 if (vlan_do_receive(&skb))
3432                         goto another_round;
3433                 else if (unlikely(!skb))
3434                         goto unlock;
3435         }
3436
3437         rx_handler = rcu_dereference(skb->dev->rx_handler);
3438         if (rx_handler) {
3439                 if (pt_prev) {
3440                         ret = deliver_skb(skb, pt_prev, orig_dev);
3441                         pt_prev = NULL;
3442                 }
3443                 switch (rx_handler(&skb)) {
3444                 case RX_HANDLER_CONSUMED:
3445                         goto unlock;
3446                 case RX_HANDLER_ANOTHER:
3447                         goto another_round;
3448                 case RX_HANDLER_EXACT:
3449                         deliver_exact = true;
3450                 case RX_HANDLER_PASS:
3451                         break;
3452                 default:
3453                         BUG();
3454                 }
3455         }
3456
3457         if (vlan_tx_nonzero_tag_present(skb))
3458                 skb->pkt_type = PACKET_OTHERHOST;
3459
3460         /* deliver only exact match when indicated */
3461         null_or_dev = deliver_exact ? skb->dev : NULL;
3462
3463         type = skb->protocol;
3464         list_for_each_entry_rcu(ptype,
3465                         &ptype_base[ntohs(type) & PTYPE_HASH_MASK], list) {
3466                 if (ptype->type == type &&
3467                     (ptype->dev == null_or_dev || ptype->dev == skb->dev ||
3468                      ptype->dev == orig_dev)) {
3469                         if (pt_prev)
3470                                 ret = deliver_skb(skb, pt_prev, orig_dev);
3471                         pt_prev = ptype;
3472                 }
3473         }
3474
3475         if (pt_prev) {
3476                 if (unlikely(skb_orphan_frags(skb, GFP_ATOMIC)))
3477                         goto drop;
3478                 else
3479                         ret = pt_prev->func(skb, skb->dev, pt_prev, orig_dev);
3480         } else {
3481 drop:
3482                 atomic_long_inc(&skb->dev->rx_dropped);
3483                 kfree_skb(skb);
3484                 /* Jamal, now you will not able to escape explaining
3485                  * me how you were going to use this. :-)
3486                  */
3487                 ret = NET_RX_DROP;
3488         }
3489
3490 unlock:
3491         rcu_read_unlock();
3492 out:
3493         return ret;
3494 }
3495
3496 static int __netif_receive_skb(struct sk_buff *skb)
3497 {
3498         int ret;
3499
3500         if (sk_memalloc_socks() && skb_pfmemalloc(skb)) {
3501                 unsigned long pflags = current->flags;
3502
3503                 /*
3504                  * PFMEMALLOC skbs are special, they should
3505                  * - be delivered to SOCK_MEMALLOC sockets only
3506                  * - stay away from userspace
3507                  * - have bounded memory usage
3508                  *
3509                  * Use PF_MEMALLOC as this saves us from propagating the allocation
3510                  * context down to all allocation sites.
3511                  */
3512                 current->flags |= PF_MEMALLOC;
3513                 ret = __netif_receive_skb_core(skb, true);
3514                 tsk_restore_flags(current, pflags, PF_MEMALLOC);
3515         } else
3516                 ret = __netif_receive_skb_core(skb, false);
3517
3518         return ret;
3519 }
3520
3521 /**
3522  *      netif_receive_skb - process receive buffer from network
3523  *      @skb: buffer to process
3524  *
3525  *      netif_receive_skb() is the main receive data processing function.
3526  *      It always succeeds. The buffer may be dropped during processing
3527  *      for congestion control or by the protocol layers.
3528  *
3529  *      This function may only be called from softirq context and interrupts
3530  *      should be enabled.
3531  *
3532  *      Return values (usually ignored):
3533  *      NET_RX_SUCCESS: no congestion
3534  *      NET_RX_DROP: packet was dropped
3535  */
3536 int netif_receive_skb(struct sk_buff *skb)
3537 {
3538         net_timestamp_check(netdev_tstamp_prequeue, skb);
3539
3540         if (skb_defer_rx_timestamp(skb))
3541                 return NET_RX_SUCCESS;
3542
3543 #ifdef CONFIG_RPS
3544         if (static_key_false(&rps_needed)) {
3545                 struct rps_dev_flow voidflow, *rflow = &voidflow;
3546                 int cpu, ret;
3547
3548                 rcu_read_lock();
3549
3550                 cpu = get_rps_cpu(skb->dev, skb, &rflow);
3551
3552                 if (cpu >= 0) {
3553                         ret = enqueue_to_backlog(skb, cpu, &rflow->last_qtail);
3554                         rcu_read_unlock();
3555                         return ret;
3556                 }
3557                 rcu_read_unlock();
3558         }
3559 #endif
3560         return __netif_receive_skb(skb);
3561 }
3562 EXPORT_SYMBOL(netif_receive_skb);
3563
3564 /* Network device is going away, flush any packets still pending
3565  * Called with irqs disabled.
3566  */
3567 static void flush_backlog(void *arg)
3568 {
3569         struct net_device *dev = arg;
3570         struct softnet_data *sd = &__get_cpu_var(softnet_data);
3571         struct sk_buff *skb, *tmp;
3572
3573         rps_lock(sd);
3574         skb_queue_walk_safe(&sd->input_pkt_queue, skb, tmp) {
3575                 if (skb->dev == dev) {
3576                         __skb_unlink(skb, &sd->input_pkt_queue);
3577                         kfree_skb(skb);
3578                         input_queue_head_incr(sd);
3579                 }
3580         }
3581         rps_unlock(sd);
3582
3583         skb_queue_walk_safe(&sd->process_queue, skb, tmp) {
3584                 if (skb->dev == dev) {
3585                         __skb_unlink(skb, &sd->process_queue);
3586                         kfree_skb(skb);
3587                         input_queue_head_incr(sd);
3588                 }
3589         }
3590 }
3591
3592 static int napi_gro_complete(struct sk_buff *skb)
3593 {
3594         struct packet_offload *ptype;
3595         __be16 type = skb->protocol;
3596         struct list_head *head = &offload_base;
3597         int err = -ENOENT;
3598
3599         BUILD_BUG_ON(sizeof(struct napi_gro_cb) > sizeof(skb->cb));
3600
3601         if (NAPI_GRO_CB(skb)->count == 1) {
3602                 skb_shinfo(skb)->gso_size = 0;
3603                 goto out;
3604         }
3605
3606         rcu_read_lock();
3607         list_for_each_entry_rcu(ptype, head, list) {
3608                 if (ptype->type != type || !ptype->callbacks.gro_complete)
3609                         continue;
3610
3611                 err = ptype->callbacks.gro_complete(skb);
3612                 break;
3613         }
3614         rcu_read_unlock();
3615
3616         if (err) {
3617                 WARN_ON(&ptype->list == head);
3618                 kfree_skb(skb);
3619                 return NET_RX_SUCCESS;
3620         }
3621
3622 out:
3623         return netif_receive_skb(skb);
3624 }
3625
3626 /* napi->gro_list contains packets ordered by age.
3627  * youngest packets at the head of it.
3628  * Complete skbs in reverse order to reduce latencies.
3629  */
3630 void napi_gro_flush(struct napi_struct *napi, bool flush_old)
3631 {
3632         struct sk_buff *skb, *prev = NULL;
3633
3634         /* scan list and build reverse chain */
3635         for (skb = napi->gro_list; skb != NULL; skb = skb->next) {
3636                 skb->prev = prev;
3637                 prev = skb;
3638         }
3639
3640         for (skb = prev; skb; skb = prev) {
3641                 skb->next = NULL;
3642
3643                 if (flush_old && NAPI_GRO_CB(skb)->age == jiffies)
3644                         return;
3645
3646                 prev = skb->prev;
3647                 napi_gro_complete(skb);
3648                 napi->gro_count--;
3649         }
3650
3651         napi->gro_list = NULL;
3652 }
3653 EXPORT_SYMBOL(napi_gro_flush);
3654
3655 static void gro_list_prepare(struct napi_struct *napi, struct sk_buff *skb)
3656 {
3657         struct sk_buff *p;
3658         unsigned int maclen = skb->dev->hard_header_len;
3659
3660         for (p = napi->gro_list; p; p = p->next) {
3661                 unsigned long diffs;
3662
3663                 diffs = (unsigned long)p->dev ^ (unsigned long)skb->dev;
3664                 diffs |= p->vlan_tci ^ skb->vlan_tci;
3665                 if (maclen == ETH_HLEN)
3666                         diffs |= compare_ether_header(skb_mac_header(p),
3667                                                       skb_gro_mac_header(skb));