96103894ad69dd86e93265305701a25e14867194
[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 /**
2212  *      skb_mac_gso_segment - mac layer segmentation handler.
2213  *      @skb: buffer to segment
2214  *      @features: features for the output path (see dev->features)
2215  */
2216 struct sk_buff *skb_mac_gso_segment(struct sk_buff *skb,
2217                                     netdev_features_t features)
2218 {
2219         struct sk_buff *segs = ERR_PTR(-EPROTONOSUPPORT);
2220         struct packet_offload *ptype;
2221         __be16 type = skb->protocol;
2222
2223         while (type == htons(ETH_P_8021Q)) {
2224                 int vlan_depth = ETH_HLEN;
2225                 struct vlan_hdr *vh;
2226
2227                 if (unlikely(!pskb_may_pull(skb, vlan_depth + VLAN_HLEN)))
2228                         return ERR_PTR(-EINVAL);
2229
2230                 vh = (struct vlan_hdr *)(skb->data + vlan_depth);
2231                 type = vh->h_vlan_encapsulated_proto;
2232                 vlan_depth += VLAN_HLEN;
2233         }
2234
2235         __skb_pull(skb, skb->mac_len);
2236
2237         rcu_read_lock();
2238         list_for_each_entry_rcu(ptype, &offload_base, list) {
2239                 if (ptype->type == type && ptype->callbacks.gso_segment) {
2240                         if (unlikely(skb->ip_summed != CHECKSUM_PARTIAL)) {
2241                                 int err;
2242
2243                                 err = ptype->callbacks.gso_send_check(skb);
2244                                 segs = ERR_PTR(err);
2245                                 if (err || skb_gso_ok(skb, features))
2246                                         break;
2247                                 __skb_push(skb, (skb->data -
2248                                                  skb_network_header(skb)));
2249                         }
2250                         segs = ptype->callbacks.gso_segment(skb, features);
2251                         break;
2252                 }
2253         }
2254         rcu_read_unlock();
2255
2256         __skb_push(skb, skb->data - skb_mac_header(skb));
2257
2258         return segs;
2259 }
2260 EXPORT_SYMBOL(skb_mac_gso_segment);
2261
2262
2263 /* openvswitch calls this on rx path, so we need a different check.
2264  */
2265 static inline bool skb_needs_check(struct sk_buff *skb, bool tx_path)
2266 {
2267         if (tx_path)
2268                 return skb->ip_summed != CHECKSUM_PARTIAL;
2269         else
2270                 return skb->ip_summed == CHECKSUM_NONE;
2271 }
2272
2273 /**
2274  *      __skb_gso_segment - Perform segmentation on skb.
2275  *      @skb: buffer to segment
2276  *      @features: features for the output path (see dev->features)
2277  *      @tx_path: whether it is called in TX path
2278  *
2279  *      This function segments the given skb and returns a list of segments.
2280  *
2281  *      It may return NULL if the skb requires no segmentation.  This is
2282  *      only possible when GSO is used for verifying header integrity.
2283  */
2284 struct sk_buff *__skb_gso_segment(struct sk_buff *skb,
2285                                   netdev_features_t features, bool tx_path)
2286 {
2287         if (unlikely(skb_needs_check(skb, tx_path))) {
2288                 int err;
2289
2290                 skb_warn_bad_offload(skb);
2291
2292                 if (skb_header_cloned(skb) &&
2293                     (err = pskb_expand_head(skb, 0, 0, GFP_ATOMIC)))
2294                         return ERR_PTR(err);
2295         }
2296
2297         SKB_GSO_CB(skb)->mac_offset = skb_headroom(skb);
2298         skb_reset_mac_header(skb);
2299         skb_reset_mac_len(skb);
2300
2301         return skb_mac_gso_segment(skb, features);
2302 }
2303 EXPORT_SYMBOL(__skb_gso_segment);
2304
2305 /* Take action when hardware reception checksum errors are detected. */
2306 #ifdef CONFIG_BUG
2307 void netdev_rx_csum_fault(struct net_device *dev)
2308 {
2309         if (net_ratelimit()) {
2310                 pr_err("%s: hw csum failure\n", dev ? dev->name : "<unknown>");
2311                 dump_stack();
2312         }
2313 }
2314 EXPORT_SYMBOL(netdev_rx_csum_fault);
2315 #endif
2316
2317 /* Actually, we should eliminate this check as soon as we know, that:
2318  * 1. IOMMU is present and allows to map all the memory.
2319  * 2. No high memory really exists on this machine.
2320  */
2321
2322 static int illegal_highdma(struct net_device *dev, struct sk_buff *skb)
2323 {
2324 #ifdef CONFIG_HIGHMEM
2325         int i;
2326         if (!(dev->features & NETIF_F_HIGHDMA)) {
2327                 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
2328                         skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
2329                         if (PageHighMem(skb_frag_page(frag)))
2330                                 return 1;
2331                 }
2332         }
2333
2334         if (PCI_DMA_BUS_IS_PHYS) {
2335                 struct device *pdev = dev->dev.parent;
2336
2337                 if (!pdev)
2338                         return 0;
2339                 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
2340                         skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
2341                         dma_addr_t addr = page_to_phys(skb_frag_page(frag));
2342                         if (!pdev->dma_mask || addr + PAGE_SIZE - 1 > *pdev->dma_mask)
2343                                 return 1;
2344                 }
2345         }
2346 #endif
2347         return 0;
2348 }
2349
2350 struct dev_gso_cb {
2351         void (*destructor)(struct sk_buff *skb);
2352 };
2353
2354 #define DEV_GSO_CB(skb) ((struct dev_gso_cb *)(skb)->cb)
2355
2356 static void dev_gso_skb_destructor(struct sk_buff *skb)
2357 {
2358         struct dev_gso_cb *cb;
2359
2360         do {
2361                 struct sk_buff *nskb = skb->next;
2362
2363                 skb->next = nskb->next;
2364                 nskb->next = NULL;
2365                 kfree_skb(nskb);
2366         } while (skb->next);
2367
2368         cb = DEV_GSO_CB(skb);
2369         if (cb->destructor)
2370                 cb->destructor(skb);
2371 }
2372
2373 /**
2374  *      dev_gso_segment - Perform emulated hardware segmentation on skb.
2375  *      @skb: buffer to segment
2376  *      @features: device features as applicable to this skb
2377  *
2378  *      This function segments the given skb and stores the list of segments
2379  *      in skb->next.
2380  */
2381 static int dev_gso_segment(struct sk_buff *skb, netdev_features_t features)
2382 {
2383         struct sk_buff *segs;
2384
2385         segs = skb_gso_segment(skb, features);
2386
2387         /* Verifying header integrity only. */
2388         if (!segs)
2389                 return 0;
2390
2391         if (IS_ERR(segs))
2392                 return PTR_ERR(segs);
2393
2394         skb->next = segs;
2395         DEV_GSO_CB(skb)->destructor = skb->destructor;
2396         skb->destructor = dev_gso_skb_destructor;
2397
2398         return 0;
2399 }
2400
2401 static bool can_checksum_protocol(netdev_features_t features, __be16 protocol)
2402 {
2403         return ((features & NETIF_F_GEN_CSUM) ||
2404                 ((features & NETIF_F_V4_CSUM) &&
2405                  protocol == htons(ETH_P_IP)) ||
2406                 ((features & NETIF_F_V6_CSUM) &&
2407                  protocol == htons(ETH_P_IPV6)) ||
2408                 ((features & NETIF_F_FCOE_CRC) &&
2409                  protocol == htons(ETH_P_FCOE)));
2410 }
2411
2412 static netdev_features_t harmonize_features(struct sk_buff *skb,
2413         __be16 protocol, netdev_features_t features)
2414 {
2415         if (skb->ip_summed != CHECKSUM_NONE &&
2416             !can_checksum_protocol(features, protocol)) {
2417                 features &= ~NETIF_F_ALL_CSUM;
2418                 features &= ~NETIF_F_SG;
2419         } else if (illegal_highdma(skb->dev, skb)) {
2420                 features &= ~NETIF_F_SG;
2421         }
2422
2423         return features;
2424 }
2425
2426 netdev_features_t netif_skb_features(struct sk_buff *skb)
2427 {
2428         __be16 protocol = skb->protocol;
2429         netdev_features_t features = skb->dev->features;
2430
2431         if (skb_shinfo(skb)->gso_segs > skb->dev->gso_max_segs)
2432                 features &= ~NETIF_F_GSO_MASK;
2433
2434         if (protocol == htons(ETH_P_8021Q)) {
2435                 struct vlan_ethhdr *veh = (struct vlan_ethhdr *)skb->data;
2436                 protocol = veh->h_vlan_encapsulated_proto;
2437         } else if (!vlan_tx_tag_present(skb)) {
2438                 return harmonize_features(skb, protocol, features);
2439         }
2440
2441         features &= (skb->dev->vlan_features | NETIF_F_HW_VLAN_TX);
2442
2443         if (protocol != htons(ETH_P_8021Q)) {
2444                 return harmonize_features(skb, protocol, features);
2445         } else {
2446                 features &= NETIF_F_SG | NETIF_F_HIGHDMA | NETIF_F_FRAGLIST |
2447                                 NETIF_F_GEN_CSUM | NETIF_F_HW_VLAN_TX;
2448                 return harmonize_features(skb, protocol, features);
2449         }
2450 }
2451 EXPORT_SYMBOL(netif_skb_features);
2452
2453 /*
2454  * Returns true if either:
2455  *      1. skb has frag_list and the device doesn't support FRAGLIST, or
2456  *      2. skb is fragmented and the device does not support SG.
2457  */
2458 static inline int skb_needs_linearize(struct sk_buff *skb,
2459                                       int features)
2460 {
2461         return skb_is_nonlinear(skb) &&
2462                         ((skb_has_frag_list(skb) &&
2463                                 !(features & NETIF_F_FRAGLIST)) ||
2464                         (skb_shinfo(skb)->nr_frags &&
2465                                 !(features & NETIF_F_SG)));
2466 }
2467
2468 int dev_hard_start_xmit(struct sk_buff *skb, struct net_device *dev,
2469                         struct netdev_queue *txq)
2470 {
2471         const struct net_device_ops *ops = dev->netdev_ops;
2472         int rc = NETDEV_TX_OK;
2473         unsigned int skb_len;
2474
2475         if (likely(!skb->next)) {
2476                 netdev_features_t features;
2477
2478                 /*
2479                  * If device doesn't need skb->dst, release it right now while
2480                  * its hot in this cpu cache
2481                  */
2482                 if (dev->priv_flags & IFF_XMIT_DST_RELEASE)
2483                         skb_dst_drop(skb);
2484
2485                 features = netif_skb_features(skb);
2486
2487                 if (vlan_tx_tag_present(skb) &&
2488                     !(features & NETIF_F_HW_VLAN_TX)) {
2489                         skb = __vlan_put_tag(skb, vlan_tx_tag_get(skb));
2490                         if (unlikely(!skb))
2491                                 goto out;
2492
2493                         skb->vlan_tci = 0;
2494                 }
2495
2496                 /* If encapsulation offload request, verify we are testing
2497                  * hardware encapsulation features instead of standard
2498                  * features for the netdev
2499                  */
2500                 if (skb->encapsulation)
2501                         features &= dev->hw_enc_features;
2502
2503                 if (netif_needs_gso(skb, features)) {
2504                         if (unlikely(dev_gso_segment(skb, features)))
2505                                 goto out_kfree_skb;
2506                         if (skb->next)
2507                                 goto gso;
2508                 } else {
2509                         if (skb_needs_linearize(skb, features) &&
2510                             __skb_linearize(skb))
2511                                 goto out_kfree_skb;
2512
2513                         /* If packet is not checksummed and device does not
2514                          * support checksumming for this protocol, complete
2515                          * checksumming here.
2516                          */
2517                         if (skb->ip_summed == CHECKSUM_PARTIAL) {
2518                                 if (skb->encapsulation)
2519                                         skb_set_inner_transport_header(skb,
2520                                                 skb_checksum_start_offset(skb));
2521                                 else
2522                                         skb_set_transport_header(skb,
2523                                                 skb_checksum_start_offset(skb));
2524                                 if (!(features & NETIF_F_ALL_CSUM) &&
2525                                      skb_checksum_help(skb))
2526                                         goto out_kfree_skb;
2527                         }
2528                 }
2529
2530                 if (!list_empty(&ptype_all))
2531                         dev_queue_xmit_nit(skb, dev);
2532
2533                 skb_len = skb->len;
2534                 rc = ops->ndo_start_xmit(skb, dev);
2535                 trace_net_dev_xmit(skb, rc, dev, skb_len);
2536                 if (rc == NETDEV_TX_OK)
2537                         txq_trans_update(txq);
2538                 return rc;
2539         }
2540
2541 gso:
2542         do {
2543                 struct sk_buff *nskb = skb->next;
2544
2545                 skb->next = nskb->next;
2546                 nskb->next = NULL;
2547
2548                 /*
2549                  * If device doesn't need nskb->dst, release it right now while
2550                  * its hot in this cpu cache
2551                  */
2552                 if (dev->priv_flags & IFF_XMIT_DST_RELEASE)
2553                         skb_dst_drop(nskb);
2554
2555                 if (!list_empty(&ptype_all))
2556                         dev_queue_xmit_nit(nskb, dev);
2557
2558                 skb_len = nskb->len;
2559                 rc = ops->ndo_start_xmit(nskb, dev);
2560                 trace_net_dev_xmit(nskb, rc, dev, skb_len);
2561                 if (unlikely(rc != NETDEV_TX_OK)) {
2562                         if (rc & ~NETDEV_TX_MASK)
2563                                 goto out_kfree_gso_skb;
2564                         nskb->next = skb->next;
2565                         skb->next = nskb;
2566                         return rc;
2567                 }
2568                 txq_trans_update(txq);
2569                 if (unlikely(netif_xmit_stopped(txq) && skb->next))
2570                         return NETDEV_TX_BUSY;
2571         } while (skb->next);
2572
2573 out_kfree_gso_skb:
2574         if (likely(skb->next == NULL))
2575                 skb->destructor = DEV_GSO_CB(skb)->destructor;
2576 out_kfree_skb:
2577         kfree_skb(skb);
2578 out:
2579         return rc;
2580 }
2581
2582 static void qdisc_pkt_len_init(struct sk_buff *skb)
2583 {
2584         const struct skb_shared_info *shinfo = skb_shinfo(skb);
2585
2586         qdisc_skb_cb(skb)->pkt_len = skb->len;
2587
2588         /* To get more precise estimation of bytes sent on wire,
2589          * we add to pkt_len the headers size of all segments
2590          */
2591         if (shinfo->gso_size)  {
2592                 unsigned int hdr_len;
2593
2594                 /* mac layer + network layer */
2595                 hdr_len = skb_transport_header(skb) - skb_mac_header(skb);
2596
2597                 /* + transport layer */
2598                 if (likely(shinfo->gso_type & (SKB_GSO_TCPV4 | SKB_GSO_TCPV6)))
2599                         hdr_len += tcp_hdrlen(skb);
2600                 else
2601                         hdr_len += sizeof(struct udphdr);
2602                 qdisc_skb_cb(skb)->pkt_len += (shinfo->gso_segs - 1) * hdr_len;
2603         }
2604 }
2605
2606 static inline int __dev_xmit_skb(struct sk_buff *skb, struct Qdisc *q,
2607                                  struct net_device *dev,
2608                                  struct netdev_queue *txq)
2609 {
2610         spinlock_t *root_lock = qdisc_lock(q);
2611         bool contended;
2612         int rc;
2613
2614         qdisc_pkt_len_init(skb);
2615         qdisc_calculate_pkt_len(skb, q);
2616         /*
2617          * Heuristic to force contended enqueues to serialize on a
2618          * separate lock before trying to get qdisc main lock.
2619          * This permits __QDISC_STATE_RUNNING owner to get the lock more often
2620          * and dequeue packets faster.
2621          */
2622         contended = qdisc_is_running(q);
2623         if (unlikely(contended))
2624                 spin_lock(&q->busylock);
2625
2626         spin_lock(root_lock);
2627         if (unlikely(test_bit(__QDISC_STATE_DEACTIVATED, &q->state))) {
2628                 kfree_skb(skb);
2629                 rc = NET_XMIT_DROP;
2630         } else if ((q->flags & TCQ_F_CAN_BYPASS) && !qdisc_qlen(q) &&
2631                    qdisc_run_begin(q)) {
2632                 /*
2633                  * This is a work-conserving queue; there are no old skbs
2634                  * waiting to be sent out; and the qdisc is not running -
2635                  * xmit the skb directly.
2636                  */
2637                 if (!(dev->priv_flags & IFF_XMIT_DST_RELEASE))
2638                         skb_dst_force(skb);
2639
2640                 qdisc_bstats_update(q, skb);
2641
2642                 if (sch_direct_xmit(skb, q, dev, txq, root_lock)) {
2643                         if (unlikely(contended)) {
2644                                 spin_unlock(&q->busylock);
2645                                 contended = false;
2646                         }
2647                         __qdisc_run(q);
2648                 } else
2649                         qdisc_run_end(q);
2650
2651                 rc = NET_XMIT_SUCCESS;
2652         } else {
2653                 skb_dst_force(skb);
2654                 rc = q->enqueue(skb, q) & NET_XMIT_MASK;
2655                 if (qdisc_run_begin(q)) {
2656                         if (unlikely(contended)) {
2657                                 spin_unlock(&q->busylock);
2658                                 contended = false;
2659                         }
2660                         __qdisc_run(q);
2661                 }
2662         }
2663         spin_unlock(root_lock);
2664         if (unlikely(contended))
2665                 spin_unlock(&q->busylock);
2666         return rc;
2667 }
2668
2669 #if IS_ENABLED(CONFIG_NETPRIO_CGROUP)
2670 static void skb_update_prio(struct sk_buff *skb)
2671 {
2672         struct netprio_map *map = rcu_dereference_bh(skb->dev->priomap);
2673
2674         if (!skb->priority && skb->sk && map) {
2675                 unsigned int prioidx = skb->sk->sk_cgrp_prioidx;
2676
2677                 if (prioidx < map->priomap_len)
2678                         skb->priority = map->priomap[prioidx];
2679         }
2680 }
2681 #else
2682 #define skb_update_prio(skb)
2683 #endif
2684
2685 static DEFINE_PER_CPU(int, xmit_recursion);
2686 #define RECURSION_LIMIT 10
2687
2688 /**
2689  *      dev_loopback_xmit - loop back @skb
2690  *      @skb: buffer to transmit
2691  */
2692 int dev_loopback_xmit(struct sk_buff *skb)
2693 {
2694         skb_reset_mac_header(skb);
2695         __skb_pull(skb, skb_network_offset(skb));
2696         skb->pkt_type = PACKET_LOOPBACK;
2697         skb->ip_summed = CHECKSUM_UNNECESSARY;
2698         WARN_ON(!skb_dst(skb));
2699         skb_dst_force(skb);
2700         netif_rx_ni(skb);
2701         return 0;
2702 }
2703 EXPORT_SYMBOL(dev_loopback_xmit);
2704
2705 /**
2706  *      dev_queue_xmit - transmit a buffer
2707  *      @skb: buffer to transmit
2708  *
2709  *      Queue a buffer for transmission to a network device. The caller must
2710  *      have set the device and priority and built the buffer before calling
2711  *      this function. The function can be called from an interrupt.
2712  *
2713  *      A negative errno code is returned on a failure. A success does not
2714  *      guarantee the frame will be transmitted as it may be dropped due
2715  *      to congestion or traffic shaping.
2716  *
2717  * -----------------------------------------------------------------------------------
2718  *      I notice this method can also return errors from the queue disciplines,
2719  *      including NET_XMIT_DROP, which is a positive value.  So, errors can also
2720  *      be positive.
2721  *
2722  *      Regardless of the return value, the skb is consumed, so it is currently
2723  *      difficult to retry a send to this method.  (You can bump the ref count
2724  *      before sending to hold a reference for retry if you are careful.)
2725  *
2726  *      When calling this method, interrupts MUST be enabled.  This is because
2727  *      the BH enable code must have IRQs enabled so that it will not deadlock.
2728  *          --BLG
2729  */
2730 int dev_queue_xmit(struct sk_buff *skb)
2731 {
2732         struct net_device *dev = skb->dev;
2733         struct netdev_queue *txq;
2734         struct Qdisc *q;
2735         int rc = -ENOMEM;
2736
2737         skb_reset_mac_header(skb);
2738
2739         /* Disable soft irqs for various locks below. Also
2740          * stops preemption for RCU.
2741          */
2742         rcu_read_lock_bh();
2743
2744         skb_update_prio(skb);
2745
2746         txq = netdev_pick_tx(dev, skb);
2747         q = rcu_dereference_bh(txq->qdisc);
2748
2749 #ifdef CONFIG_NET_CLS_ACT
2750         skb->tc_verd = SET_TC_AT(skb->tc_verd, AT_EGRESS);
2751 #endif
2752         trace_net_dev_queue(skb);
2753         if (q->enqueue) {
2754                 rc = __dev_xmit_skb(skb, q, dev, txq);
2755                 goto out;
2756         }
2757
2758         /* The device has no queue. Common case for software devices:
2759            loopback, all the sorts of tunnels...
2760
2761            Really, it is unlikely that netif_tx_lock protection is necessary
2762            here.  (f.e. loopback and IP tunnels are clean ignoring statistics
2763            counters.)
2764            However, it is possible, that they rely on protection
2765            made by us here.
2766
2767            Check this and shot the lock. It is not prone from deadlocks.
2768            Either shot noqueue qdisc, it is even simpler 8)
2769          */
2770         if (dev->flags & IFF_UP) {
2771                 int cpu = smp_processor_id(); /* ok because BHs are off */
2772
2773                 if (txq->xmit_lock_owner != cpu) {
2774
2775                         if (__this_cpu_read(xmit_recursion) > RECURSION_LIMIT)
2776                                 goto recursion_alert;
2777
2778                         HARD_TX_LOCK(dev, txq, cpu);
2779
2780                         if (!netif_xmit_stopped(txq)) {
2781                                 __this_cpu_inc(xmit_recursion);
2782                                 rc = dev_hard_start_xmit(skb, dev, txq);
2783                                 __this_cpu_dec(xmit_recursion);
2784                                 if (dev_xmit_complete(rc)) {
2785                                         HARD_TX_UNLOCK(dev, txq);
2786                                         goto out;
2787                                 }
2788                         }
2789                         HARD_TX_UNLOCK(dev, txq);
2790                         net_crit_ratelimited("Virtual device %s asks to queue packet!\n",
2791                                              dev->name);
2792                 } else {
2793                         /* Recursion is detected! It is possible,
2794                          * unfortunately
2795                          */
2796 recursion_alert:
2797                         net_crit_ratelimited("Dead loop on virtual device %s, fix it urgently!\n",
2798                                              dev->name);
2799                 }
2800         }
2801
2802         rc = -ENETDOWN;
2803         rcu_read_unlock_bh();
2804
2805         kfree_skb(skb);
2806         return rc;
2807 out:
2808         rcu_read_unlock_bh();
2809         return rc;
2810 }
2811 EXPORT_SYMBOL(dev_queue_xmit);
2812
2813
2814 /*=======================================================================
2815                         Receiver routines
2816   =======================================================================*/
2817
2818 int netdev_max_backlog __read_mostly = 1000;
2819 EXPORT_SYMBOL(netdev_max_backlog);
2820
2821 int netdev_tstamp_prequeue __read_mostly = 1;
2822 int netdev_budget __read_mostly = 300;
2823 int weight_p __read_mostly = 64;            /* old backlog weight */
2824
2825 /* Called with irq disabled */
2826 static inline void ____napi_schedule(struct softnet_data *sd,
2827                                      struct napi_struct *napi)
2828 {
2829         list_add_tail(&napi->poll_list, &sd->poll_list);
2830         __raise_softirq_irqoff(NET_RX_SOFTIRQ);
2831 }
2832
2833 #ifdef CONFIG_RPS
2834
2835 /* One global table that all flow-based protocols share. */
2836 struct rps_sock_flow_table __rcu *rps_sock_flow_table __read_mostly;
2837 EXPORT_SYMBOL(rps_sock_flow_table);
2838
2839 struct static_key rps_needed __read_mostly;
2840
2841 static struct rps_dev_flow *
2842 set_rps_cpu(struct net_device *dev, struct sk_buff *skb,
2843             struct rps_dev_flow *rflow, u16 next_cpu)
2844 {
2845         if (next_cpu != RPS_NO_CPU) {
2846 #ifdef CONFIG_RFS_ACCEL
2847                 struct netdev_rx_queue *rxqueue;
2848                 struct rps_dev_flow_table *flow_table;
2849                 struct rps_dev_flow *old_rflow;
2850                 u32 flow_id;
2851                 u16 rxq_index;
2852                 int rc;
2853
2854                 /* Should we steer this flow to a different hardware queue? */
2855                 if (!skb_rx_queue_recorded(skb) || !dev->rx_cpu_rmap ||
2856                     !(dev->features & NETIF_F_NTUPLE))
2857                         goto out;
2858                 rxq_index = cpu_rmap_lookup_index(dev->rx_cpu_rmap, next_cpu);
2859                 if (rxq_index == skb_get_rx_queue(skb))
2860                         goto out;
2861
2862                 rxqueue = dev->_rx + rxq_index;
2863                 flow_table = rcu_dereference(rxqueue->rps_flow_table);
2864                 if (!flow_table)
2865                         goto out;
2866                 flow_id = skb->rxhash & flow_table->mask;
2867                 rc = dev->netdev_ops->ndo_rx_flow_steer(dev, skb,
2868                                                         rxq_index, flow_id);
2869                 if (rc < 0)
2870                         goto out;
2871                 old_rflow = rflow;
2872                 rflow = &flow_table->flows[flow_id];
2873                 rflow->filter = rc;
2874                 if (old_rflow->filter == rflow->filter)
2875                         old_rflow->filter = RPS_NO_FILTER;
2876         out:
2877 #endif
2878                 rflow->last_qtail =
2879                         per_cpu(softnet_data, next_cpu).input_queue_head;
2880         }
2881
2882         rflow->cpu = next_cpu;
2883         return rflow;
2884 }
2885
2886 /*
2887  * get_rps_cpu is called from netif_receive_skb and returns the target
2888  * CPU from the RPS map of the receiving queue for a given skb.
2889  * rcu_read_lock must be held on entry.
2890  */
2891 static int get_rps_cpu(struct net_device *dev, struct sk_buff *skb,
2892                        struct rps_dev_flow **rflowp)
2893 {
2894         struct netdev_rx_queue *rxqueue;
2895         struct rps_map *map;
2896         struct rps_dev_flow_table *flow_table;
2897         struct rps_sock_flow_table *sock_flow_table;
2898         int cpu = -1;
2899         u16 tcpu;
2900
2901         if (skb_rx_queue_recorded(skb)) {
2902                 u16 index = skb_get_rx_queue(skb);
2903                 if (unlikely(index >= dev->real_num_rx_queues)) {
2904                         WARN_ONCE(dev->real_num_rx_queues > 1,
2905                                   "%s received packet on queue %u, but number "
2906                                   "of RX queues is %u\n",
2907                                   dev->name, index, dev->real_num_rx_queues);
2908                         goto done;
2909                 }
2910                 rxqueue = dev->_rx + index;
2911         } else
2912                 rxqueue = dev->_rx;
2913
2914         map = rcu_dereference(rxqueue->rps_map);
2915         if (map) {
2916                 if (map->len == 1 &&
2917                     !rcu_access_pointer(rxqueue->rps_flow_table)) {
2918                         tcpu = map->cpus[0];
2919                         if (cpu_online(tcpu))
2920                                 cpu = tcpu;
2921                         goto done;
2922                 }
2923         } else if (!rcu_access_pointer(rxqueue->rps_flow_table)) {
2924                 goto done;
2925         }
2926
2927         skb_reset_network_header(skb);
2928         if (!skb_get_rxhash(skb))
2929                 goto done;
2930
2931         flow_table = rcu_dereference(rxqueue->rps_flow_table);
2932         sock_flow_table = rcu_dereference(rps_sock_flow_table);
2933         if (flow_table && sock_flow_table) {
2934                 u16 next_cpu;
2935                 struct rps_dev_flow *rflow;
2936
2937                 rflow = &flow_table->flows[skb->rxhash & flow_table->mask];
2938                 tcpu = rflow->cpu;
2939
2940                 next_cpu = sock_flow_table->ents[skb->rxhash &
2941                     sock_flow_table->mask];
2942
2943                 /*
2944                  * If the desired CPU (where last recvmsg was done) is
2945                  * different from current CPU (one in the rx-queue flow
2946                  * table entry), switch if one of the following holds:
2947                  *   - Current CPU is unset (equal to RPS_NO_CPU).
2948                  *   - Current CPU is offline.
2949                  *   - The current CPU's queue tail has advanced beyond the
2950                  *     last packet that was enqueued using this table entry.
2951                  *     This guarantees that all previous packets for the flow
2952                  *     have been dequeued, thus preserving in order delivery.
2953                  */
2954                 if (unlikely(tcpu != next_cpu) &&
2955                     (tcpu == RPS_NO_CPU || !cpu_online(tcpu) ||
2956                      ((int)(per_cpu(softnet_data, tcpu).input_queue_head -
2957                       rflow->last_qtail)) >= 0)) {
2958                         tcpu = next_cpu;
2959                         rflow = set_rps_cpu(dev, skb, rflow, next_cpu);
2960                 }
2961
2962                 if (tcpu != RPS_NO_CPU && cpu_online(tcpu)) {
2963                         *rflowp = rflow;
2964                         cpu = tcpu;
2965                         goto done;
2966                 }
2967         }
2968
2969         if (map) {
2970                 tcpu = map->cpus[((u64) skb->rxhash * map->len) >> 32];
2971
2972                 if (cpu_online(tcpu)) {
2973                         cpu = tcpu;
2974                         goto done;
2975                 }
2976         }
2977
2978 done:
2979         return cpu;
2980 }
2981
2982 #ifdef CONFIG_RFS_ACCEL
2983
2984 /**
2985  * rps_may_expire_flow - check whether an RFS hardware filter may be removed
2986  * @dev: Device on which the filter was set
2987  * @rxq_index: RX queue index
2988  * @flow_id: Flow ID passed to ndo_rx_flow_steer()
2989  * @filter_id: Filter ID returned by ndo_rx_flow_steer()
2990  *
2991  * Drivers that implement ndo_rx_flow_steer() should periodically call
2992  * this function for each installed filter and remove the filters for
2993  * which it returns %true.
2994  */
2995 bool rps_may_expire_flow(struct net_device *dev, u16 rxq_index,
2996                          u32 flow_id, u16 filter_id)
2997 {
2998         struct netdev_rx_queue *rxqueue = dev->_rx + rxq_index;
2999         struct rps_dev_flow_table *flow_table;
3000         struct rps_dev_flow *rflow;
3001         bool expire = true;
3002         int cpu;
3003
3004         rcu_read_lock();
3005         flow_table = rcu_dereference(rxqueue->rps_flow_table);
3006         if (flow_table && flow_id <= flow_table->mask) {
3007                 rflow = &flow_table->flows[flow_id];
3008                 cpu = ACCESS_ONCE(rflow->cpu);
3009                 if (rflow->filter == filter_id && cpu != RPS_NO_CPU &&
3010                     ((int)(per_cpu(softnet_data, cpu).input_queue_head -
3011                            rflow->last_qtail) <
3012                      (int)(10 * flow_table->mask)))
3013                         expire = false;
3014         }
3015         rcu_read_unlock();
3016         return expire;
3017 }
3018 EXPORT_SYMBOL(rps_may_expire_flow);
3019
3020 #endif /* CONFIG_RFS_ACCEL */
3021
3022 /* Called from hardirq (IPI) context */
3023 static void rps_trigger_softirq(void *data)
3024 {
3025         struct softnet_data *sd = data;
3026
3027         ____napi_schedule(sd, &sd->backlog);
3028         sd->received_rps++;
3029 }
3030
3031 #endif /* CONFIG_RPS */
3032
3033 /*
3034  * Check if this softnet_data structure is another cpu one
3035  * If yes, queue it to our IPI list and return 1
3036  * If no, return 0
3037  */
3038 static int rps_ipi_queued(struct softnet_data *sd)
3039 {
3040 #ifdef CONFIG_RPS
3041         struct softnet_data *mysd = &__get_cpu_var(softnet_data);
3042
3043         if (sd != mysd) {
3044                 sd->rps_ipi_next = mysd->rps_ipi_list;
3045                 mysd->rps_ipi_list = sd;
3046
3047                 __raise_softirq_irqoff(NET_RX_SOFTIRQ);
3048                 return 1;
3049         }
3050 #endif /* CONFIG_RPS */
3051         return 0;
3052 }
3053
3054 /*
3055  * enqueue_to_backlog is called to queue an skb to a per CPU backlog
3056  * queue (may be a remote CPU queue).
3057  */
3058 static int enqueue_to_backlog(struct sk_buff *skb, int cpu,
3059                               unsigned int *qtail)
3060 {
3061         struct softnet_data *sd;
3062         unsigned long flags;
3063
3064         sd = &per_cpu(softnet_data, cpu);
3065
3066         local_irq_save(flags);
3067
3068         rps_lock(sd);
3069         if (skb_queue_len(&sd->input_pkt_queue) <= netdev_max_backlog) {
3070                 if (skb_queue_len(&sd->input_pkt_queue)) {
3071 enqueue:
3072                         __skb_queue_tail(&sd->input_pkt_queue, skb);
3073                         input_queue_tail_incr_save(sd, qtail);
3074                         rps_unlock(sd);
3075                         local_irq_restore(flags);
3076                         return NET_RX_SUCCESS;
3077                 }
3078
3079                 /* Schedule NAPI for backlog device
3080                  * We can use non atomic operation since we own the queue lock
3081                  */
3082                 if (!__test_and_set_bit(NAPI_STATE_SCHED, &sd->backlog.state)) {
3083                         if (!rps_ipi_queued(sd))
3084                                 ____napi_schedule(sd, &sd->backlog);
3085                 }
3086                 goto enqueue;
3087         }
3088
3089         sd->dropped++;
3090         rps_unlock(sd);
3091
3092         local_irq_restore(flags);
3093
3094         atomic_long_inc(&skb->dev->rx_dropped);
3095         kfree_skb(skb);
3096         return NET_RX_DROP;
3097 }
3098
3099 /**
3100  *      netif_rx        -       post buffer to the network code
3101  *      @skb: buffer to post
3102  *
3103  *      This function receives a packet from a device driver and queues it for
3104  *      the upper (protocol) levels to process.  It always succeeds. The buffer
3105  *      may be dropped during processing for congestion control or by the
3106  *      protocol layers.
3107  *
3108  *      return values:
3109  *      NET_RX_SUCCESS  (no congestion)
3110  *      NET_RX_DROP     (packet was dropped)
3111  *
3112  */
3113
3114 int netif_rx(struct sk_buff *skb)
3115 {
3116         int ret;
3117
3118         /* if netpoll wants it, pretend we never saw it */
3119         if (netpoll_rx(skb))
3120                 return NET_RX_DROP;
3121
3122         net_timestamp_check(netdev_tstamp_prequeue, skb);
3123
3124         trace_netif_rx(skb);
3125 #ifdef CONFIG_RPS
3126         if (static_key_false(&rps_needed)) {
3127                 struct rps_dev_flow voidflow, *rflow = &voidflow;
3128                 int cpu;
3129
3130                 preempt_disable();
3131                 rcu_read_lock();
3132
3133                 cpu = get_rps_cpu(skb->dev, skb, &rflow);
3134                 if (cpu < 0)
3135                         cpu = smp_processor_id();
3136
3137                 ret = enqueue_to_backlog(skb, cpu, &rflow->last_qtail);
3138
3139                 rcu_read_unlock();
3140                 preempt_enable();
3141         } else
3142 #endif
3143         {
3144                 unsigned int qtail;
3145                 ret = enqueue_to_backlog(skb, get_cpu(), &qtail);
3146                 put_cpu();
3147         }
3148         return ret;
3149 }
3150 EXPORT_SYMBOL(netif_rx);
3151
3152 int netif_rx_ni(struct sk_buff *skb)
3153 {
3154         int err;
3155
3156         preempt_disable();
3157         err = netif_rx(skb);
3158         if (local_softirq_pending())
3159                 do_softirq();
3160         preempt_enable();
3161
3162         return err;
3163 }
3164 EXPORT_SYMBOL(netif_rx_ni);
3165
3166 static void net_tx_action(struct softirq_action *h)
3167 {
3168         struct softnet_data *sd = &__get_cpu_var(softnet_data);
3169
3170         if (sd->completion_queue) {
3171                 struct sk_buff *clist;
3172
3173                 local_irq_disable();
3174                 clist = sd->completion_queue;
3175                 sd->completion_queue = NULL;
3176                 local_irq_enable();
3177
3178                 while (clist) {
3179                         struct sk_buff *skb = clist;
3180                         clist = clist->next;
3181
3182                         WARN_ON(atomic_read(&skb->users));
3183                         trace_kfree_skb(skb, net_tx_action);
3184                         __kfree_skb(skb);
3185                 }
3186         }
3187
3188         if (sd->output_queue) {
3189                 struct Qdisc *head;
3190
3191                 local_irq_disable();
3192                 head = sd->output_queue;
3193                 sd->output_queue = NULL;
3194                 sd->output_queue_tailp = &sd->output_queue;
3195                 local_irq_enable();
3196
3197                 while (head) {
3198                         struct Qdisc *q = head;
3199                         spinlock_t *root_lock;
3200
3201                         head = head->next_sched;
3202
3203                         root_lock = qdisc_lock(q);
3204                         if (spin_trylock(root_lock)) {
3205                                 smp_mb__before_clear_bit();
3206                                 clear_bit(__QDISC_STATE_SCHED,
3207                                           &q->state);
3208                                 qdisc_run(q);
3209                                 spin_unlock(root_lock);
3210                         } else {
3211                                 if (!test_bit(__QDISC_STATE_DEACTIVATED,
3212                                               &q->state)) {
3213                                         __netif_reschedule(q);
3214                                 } else {
3215                                         smp_mb__before_clear_bit();
3216                                         clear_bit(__QDISC_STATE_SCHED,
3217                                                   &q->state);
3218                                 }
3219                         }
3220                 }
3221         }
3222 }
3223
3224 #if (defined(CONFIG_BRIDGE) || defined(CONFIG_BRIDGE_MODULE)) && \
3225     (defined(CONFIG_ATM_LANE) || defined(CONFIG_ATM_LANE_MODULE))
3226 /* This hook is defined here for ATM LANE */
3227 int (*br_fdb_test_addr_hook)(struct net_device *dev,
3228                              unsigned char *addr) __read_mostly;
3229 EXPORT_SYMBOL_GPL(br_fdb_test_addr_hook);
3230 #endif
3231
3232 #ifdef CONFIG_NET_CLS_ACT
3233 /* TODO: Maybe we should just force sch_ingress to be compiled in
3234  * when CONFIG_NET_CLS_ACT is? otherwise some useless instructions
3235  * a compare and 2 stores extra right now if we dont have it on
3236  * but have CONFIG_NET_CLS_ACT
3237  * NOTE: This doesn't stop any functionality; if you dont have
3238  * the ingress scheduler, you just can't add policies on ingress.
3239  *
3240  */
3241 static int ing_filter(struct sk_buff *skb, struct netdev_queue *rxq)
3242 {
3243         struct net_device *dev = skb->dev;
3244         u32 ttl = G_TC_RTTL(skb->tc_verd);
3245         int result = TC_ACT_OK;
3246         struct Qdisc *q;
3247
3248         if (unlikely(MAX_RED_LOOP < ttl++)) {
3249                 net_warn_ratelimited("Redir loop detected Dropping packet (%d->%d)\n",
3250                                      skb->skb_iif, dev->ifindex);
3251                 return TC_ACT_SHOT;
3252         }
3253
3254         skb->tc_verd = SET_TC_RTTL(skb->tc_verd, ttl);
3255         skb->tc_verd = SET_TC_AT(skb->tc_verd, AT_INGRESS);
3256
3257         q = rxq->qdisc;
3258         if (q != &noop_qdisc) {
3259                 spin_lock(qdisc_lock(q));
3260                 if (likely(!test_bit(__QDISC_STATE_DEACTIVATED, &q->state)))
3261                         result = qdisc_enqueue_root(skb, q);
3262                 spin_unlock(qdisc_lock(q));
3263         }
3264
3265         return result;
3266 }
3267
3268 static inline struct sk_buff *handle_ing(struct sk_buff *skb,
3269                                          struct packet_type **pt_prev,
3270                                          int *ret, struct net_device *orig_dev)
3271 {
3272         struct netdev_queue *rxq = rcu_dereference(skb->dev->ingress_queue);
3273
3274         if (!rxq || rxq->qdisc == &noop_qdisc)
3275                 goto out;
3276
3277         if (*pt_prev) {
3278                 *ret = deliver_skb(skb, *pt_prev, orig_dev);
3279                 *pt_prev = NULL;
3280         }
3281
3282         switch (ing_filter(skb, rxq)) {
3283         case TC_ACT_SHOT:
3284         case TC_ACT_STOLEN:
3285                 kfree_skb(skb);
3286                 return NULL;
3287         }
3288
3289 out:
3290         skb->tc_verd = 0;
3291         return skb;
3292 }
3293 #endif
3294
3295 /**
3296  *      netdev_rx_handler_register - register receive handler
3297  *      @dev: device to register a handler for
3298  *      @rx_handler: receive handler to register
3299  *      @rx_handler_data: data pointer that is used by rx handler
3300  *
3301  *      Register a receive hander for a device. This handler will then be
3302  *      called from __netif_receive_skb. A negative errno code is returned
3303  *      on a failure.
3304  *
3305  *      The caller must hold the rtnl_mutex.
3306  *
3307  *      For a general description of rx_handler, see enum rx_handler_result.
3308  */
3309 int netdev_rx_handler_register(struct net_device *dev,
3310                                rx_handler_func_t *rx_handler,
3311                                void *rx_handler_data)
3312 {
3313         ASSERT_RTNL();
3314
3315         if (dev->rx_handler)
3316                 return -EBUSY;
3317
3318         rcu_assign_pointer(dev->rx_handler_data, rx_handler_data);
3319         rcu_assign_pointer(dev->rx_handler, rx_handler);
3320
3321         return 0;
3322 }
3323 EXPORT_SYMBOL_GPL(netdev_rx_handler_register);
3324
3325 /**
3326  *      netdev_rx_handler_unregister - unregister receive handler
3327  *      @dev: device to unregister a handler from
3328  *
3329  *      Unregister a receive hander from a device.
3330  *
3331  *      The caller must hold the rtnl_mutex.
3332  */
3333 void netdev_rx_handler_unregister(struct net_device *dev)
3334 {
3335
3336         ASSERT_RTNL();
3337         RCU_INIT_POINTER(dev->rx_handler, NULL);
3338         RCU_INIT_POINTER(dev->rx_handler_data, NULL);
3339 }
3340 EXPORT_SYMBOL_GPL(netdev_rx_handler_unregister);
3341
3342 /*
3343  * Limit the use of PFMEMALLOC reserves to those protocols that implement
3344  * the special handling of PFMEMALLOC skbs.
3345  */
3346 static bool skb_pfmemalloc_protocol(struct sk_buff *skb)
3347 {
3348         switch (skb->protocol) {
3349         case __constant_htons(ETH_P_ARP):
3350         case __constant_htons(ETH_P_IP):
3351         case __constant_htons(ETH_P_IPV6):
3352         case __constant_htons(ETH_P_8021Q):
3353                 return true;
3354         default:
3355                 return false;
3356         }
3357 }
3358
3359 static int __netif_receive_skb_core(struct sk_buff *skb, bool pfmemalloc)
3360 {
3361         struct packet_type *ptype, *pt_prev;
3362         rx_handler_func_t *rx_handler;
3363         struct net_device *orig_dev;
3364         struct net_device *null_or_dev;
3365         bool deliver_exact = false;
3366         int ret = NET_RX_DROP;
3367         __be16 type;
3368
3369         net_timestamp_check(!netdev_tstamp_prequeue, skb);
3370
3371         trace_netif_receive_skb(skb);
3372
3373         /* if we've gotten here through NAPI, check netpoll */
3374         if (netpoll_receive_skb(skb))
3375                 goto out;
3376
3377         orig_dev = skb->dev;
3378
3379         skb_reset_network_header(skb);
3380         if (!skb_transport_header_was_set(skb))
3381                 skb_reset_transport_header(skb);
3382         skb_reset_mac_len(skb);
3383
3384         pt_prev = NULL;
3385
3386         rcu_read_lock();
3387
3388 another_round:
3389         skb->skb_iif = skb->dev->ifindex;
3390
3391         __this_cpu_inc(softnet_data.processed);
3392
3393         if (skb->protocol == cpu_to_be16(ETH_P_8021Q)) {
3394                 skb = vlan_untag(skb);
3395                 if (unlikely(!skb))
3396                         goto unlock;
3397         }
3398
3399 #ifdef CONFIG_NET_CLS_ACT
3400         if (skb->tc_verd & TC_NCLS) {
3401                 skb->tc_verd = CLR_TC_NCLS(skb->tc_verd);
3402                 goto ncls;
3403         }
3404 #endif
3405
3406         if (pfmemalloc)
3407                 goto skip_taps;
3408
3409         list_for_each_entry_rcu(ptype, &ptype_all, list) {
3410                 if (!ptype->dev || ptype->dev == skb->dev) {
3411                         if (pt_prev)
3412                                 ret = deliver_skb(skb, pt_prev, orig_dev);
3413                         pt_prev = ptype;
3414                 }
3415         }
3416
3417 skip_taps:
3418 #ifdef CONFIG_NET_CLS_ACT
3419         skb = handle_ing(skb, &pt_prev, &ret, orig_dev);
3420         if (!skb)
3421                 goto unlock;
3422 ncls:
3423 #endif
3424
3425         if (pfmemalloc && !skb_pfmemalloc_protocol(skb))
3426                 goto drop;
3427
3428         if (vlan_tx_tag_present(skb)) {
3429                 if (pt_prev) {
3430                         ret = deliver_skb(skb, pt_prev, orig_dev);
3431                         pt_prev = NULL;
3432                 }
3433                 if (vlan_do_receive(&skb))
3434                         goto another_round;
3435                 else if (unlikely(!skb))
3436                         goto unlock;
3437         }
3438
3439         rx_handler = rcu_dereference(skb->dev->rx_handler);
3440         if (rx_handler) {
3441                 if (pt_prev) {
3442                         ret = deliver_skb(skb, pt_prev, orig_dev);
3443                         pt_prev = NULL;
3444                 }
3445                 switch (rx_handler(&skb)) {
3446                 case RX_HANDLER_CONSUMED:
3447                         goto unlock;
3448                 case RX_HANDLER_ANOTHER:
3449                         goto another_round;
3450                 case RX_HANDLER_EXACT:
3451                         deliver_exact = true;
3452                 case RX_HANDLER_PASS:
3453                         break;
3454                 default:
3455                         BUG();
3456                 }
3457         }
3458
3459         if (vlan_tx_nonzero_tag_present(skb))
3460                 skb->pkt_type = PACKET_OTHERHOST;
3461
3462         /* deliver only exact match when indicated */
3463         null_or_dev = deliver_exact ? skb->dev : NULL;
3464
3465         type = skb->protocol;
3466         list_for_each_entry_rcu(ptype,
3467                         &ptype_base[ntohs(type) & PTYPE_HASH_MASK], list) {
3468                 if (ptype->type == type &&
3469                     (ptype->dev == null_or_dev || ptype->dev == skb->dev ||
3470                      ptype->dev == orig_dev)) {
3471                         if (pt_prev)
3472                                 ret = deliver_skb(skb, pt_prev, orig_dev);
3473                         pt_prev = ptype;
3474                 }
3475         }
3476
3477         if (pt_prev) {
3478                 if (unlikely(skb_orphan_frags(skb, GFP_ATOMIC)))
3479                         goto drop;
3480                 else
3481                         ret = pt_prev->func(skb, skb->dev, pt_prev, orig_dev);
3482         } else {
3483 drop:
3484                 atomic_long_inc(&skb->dev->rx_dropped);
3485                 kfree_skb(skb);
3486                 /* Jamal, now you will not able to escape explaining
3487                  * me how you were going to use this. :-)
3488                  */
3489                 ret = NET_RX_DROP;
3490         }
3491
3492 unlock:
3493         rcu_read_unlock();
3494 out:
3495         return ret;
3496 }
3497
3498 static int __netif_receive_skb(struct sk_buff *skb)
3499 {
3500         int ret;
3501
3502         if (sk_memalloc_socks() && skb_pfmemalloc(skb)) {
3503                 unsigned long pflags = current->flags;
3504
3505                 /*
3506                  * PFMEMALLOC skbs are special, they should
3507                  * - be delivered to SOCK_MEMALLOC sockets only
3508                  * - stay away from userspace
3509                  * - have bounded memory usage
3510                  *
3511                  * Use PF_MEMALLOC as this saves us from propagating the allocation
3512                  * context down to all allocation sites.
3513                  */
3514                 current->flags |= PF_MEMALLOC;
3515                 ret = __netif_receive_skb_core(skb, true);
3516                 tsk_restore_flags(current, pflags, PF_MEMALLOC);
3517         } else
3518                 ret = __netif_receive_skb_core(skb, false);
3519
3520         return ret;
3521 }
3522
3523 /**
3524  *      netif_receive_skb - process receive buffer from network
3525  *      @skb: buffer to process
3526  *
3527  *      netif_receive_skb() is the main receive data processing function.
3528  *      It always succeeds. The buffer may be dropped during processing
3529  *      for congestion control or by the protocol layers.
3530  *
3531  *      This function may only be called from softirq context and interrupts
3532  *      should be enabled.
3533  *
3534  *      Return values (usually ignored):
3535  *      NET_RX_SUCCESS: no congestion
3536  *      NET_RX_DROP: packet was dropped
3537  */
3538 int netif_receive_skb(struct sk_buff *skb)
3539 {
3540         net_timestamp_check(netdev_tstamp_prequeue, skb);
3541
3542         if (skb_defer_rx_timestamp(skb))
3543                 return NET_RX_SUCCESS;
3544
3545 #ifdef CONFIG_RPS
3546         if (static_key_false(&rps_needed)) {
3547                 struct rps_dev_flow voidflow, *rflow = &voidflow;
3548                 int cpu, ret;
3549
3550                 rcu_read_lock();
3551
3552                 cpu = get_rps_cpu(skb->dev, skb, &rflow);
3553
3554                 if (cpu >= 0) {
3555                         ret = enqueue_to_backlog(skb, cpu, &rflow->last_qtail);
3556                         rcu_read_unlock();
3557                         return ret;
3558                 }
3559                 rcu_read_unlock();
3560         }
3561 #endif
3562         return __netif_receive_skb(skb);
3563 }
3564 EXPORT_SYMBOL(netif_receive_skb);
3565
3566 /* Network device is going away, flush any packets still pending
3567  * Called with irqs disabled.
3568  */
3569 static void flush_backlog(void *arg)
3570 {
3571         struct net_device *dev = arg;
3572         struct softnet_data *sd = &__get_cpu_var(softnet_data);
3573         struct sk_buff *skb, *tmp;
3574
3575         rps_lock(sd);
3576         skb_queue_walk_safe(&sd->input_pkt_queue, skb, tmp) {
3577                 if (skb->dev == dev) {
3578                         __skb_unlink(skb, &sd->input_pkt_queue);
3579                         kfree_skb(skb);
3580                         input_queue_head_incr(sd);
3581                 }
3582         }
3583         rps_unlock(sd);
3584
3585         skb_queue_walk_safe(&sd->process_queue, skb, tmp) {
3586                 if (skb->dev == dev) {
3587                         __skb_unlink(skb, &sd->process_queue);
3588                         kfree_skb(skb);
3589                         input_queue_head_incr(sd);
3590                 }
3591         }
3592 }
3593
3594 static int napi_gro_complete(struct sk_buff *skb)
3595 {
3596         struct packet_offload *ptype;
3597         __be16 type = skb->protocol;
3598         struct list_head *head = &offload_base;
3599         int err = -ENOENT;
3600
3601         BUILD_BUG_ON(sizeof(struct napi_gro_cb) > sizeof(skb->cb));
3602
3603         if (NAPI_GRO_CB(skb)->count == 1) {
3604                 skb_shinfo(skb)->gso_size = 0;
3605                 goto out;
3606         }
3607
3608         rcu_read_lock();
3609         list_for_each_entry_rcu(ptype, head, list) {
3610                 if (ptype->type != type || !ptype->callbacks.gro_complete)
3611                         continue;
3612
3613                 err = ptype->callbacks.gro_complete(skb);
3614                 break;
3615         }
3616         rcu_read_unlock();
3617
3618         if (err) {
3619                 WARN_ON(&ptype->list == head);
3620                 kfree_skb(skb);
3621                 return NET_RX_SUCCESS;
3622         }
3623
3624 out:
3625         return netif_receive_skb(skb);
3626 }
3627
3628 /* napi->gro_list contains packets ordered by age.
3629  * youngest packets at the head of it.
3630  * Complete skbs in reverse order to reduce latencies.
3631  */
3632 void napi_gro_flush(struct napi_struct *napi, bool flush_old)
3633 {
3634         struct sk_buff *skb, *prev = NULL;
3635
3636         /* scan list and build reverse chain */
3637         for (skb = napi->gro_list; skb != NULL; skb = skb->next) {
3638                 skb->prev = prev;
3639                 prev = skb;
3640         }
3641
3642         for (skb = prev; skb; skb = prev) {
3643                 skb->next = NULL;
3644
3645                 if (flush_old && NAPI_GRO_CB(skb)->age == jiffies)
3646                         return;
3647
3648                 prev = skb->prev;
3649                 napi_gro_complete(skb);
3650                 napi->gro_count--;
3651         }
3652
3653         napi->gro_list = NULL;
3654 }
3655 EXPORT_SYMBOL(napi_gro_flush);
3656
3657 static void gro_list_prepare(struct napi_struct *napi, struct sk_buff *skb)
3658 {
3659         struct sk_buff *p;
3660         unsigned int maclen = skb->dev->hard_header_len;
3661
3662         for (p = napi->gro_list; p; p = p->next) {
3663                 unsigned long diffs;
3664
3665                 diffs = (unsigned long)p->dev ^ (unsigned long)skb->dev;
3666                 diffs |= p->vlan_tci ^ skb->vlan_tci;
3667                 if (maclen == ETH_HLEN)
3668                         diffs |= compare_ether_header(skb_mac_header(p),
3669                                                       skb_gro_mac_header(skb));
3670                 else if (!diffs)
3671                         diffs = memcmp(skb_mac_header(p),
3672                                        skb_gro_mac_header(skb),
3673                                        maclen);
3674                 NAPI_GRO_CB(p)->same_flow = !diffs;
3675                 NAPI_GRO_CB(p)->flush = 0;
3676         }
3677 }
3678
3679 static enum gro_result dev_gro_receive(struct napi_struct *napi, struct sk_buff *skb)
3680 {
3681         struct sk_buff **pp = NULL;
3682         struct packet_offload *ptype;
3683         __be16 type = skb->protocol;
3684         struct list_head *head = &offload_base;
3685         int same_flow;
3686         enum gro_result ret;
3687
3688         if (!(skb->dev->features & NETIF_F_GRO) || netpoll_rx_on(skb))
3689                 goto normal;
3690
3691         if (skb_is_gso(skb) || skb_has_frag_list(skb))
3692                 goto normal;
3693
3694         gro_list_prepare(napi, skb);
3695
3696         rcu_read_lock();
3697         list_for_each_entry_rcu(ptype, head, list) {
3698                 if (ptype->type != type || !ptype->callbacks.gro_receive)
3699                         continue;
3700
3701                 skb_set_network_header(skb, skb_gro_offset(skb));
3702                 skb_reset_mac_len(skb);
3703                 NAPI_GRO_CB(skb)->same_flow = 0;
3704                 NAPI_GRO_CB(skb)->flush = 0;
3705                 NAPI_GRO_CB(skb)->free = 0;
3706
3707                 pp = ptype->callbacks.gro_receive(&napi->gro_list, skb);
3708                 break;
3709         }
3710         rcu_read_unlock();
3711
3712         if (&ptype->list == head)
3713                 goto normal;
3714
3715         same_flow = NAPI_GRO_CB(skb)->same_flow;
3716         ret = NAPI_GRO_CB(skb)->free ? GRO_MERGED_FREE : GRO_MERGED;
3717
3718         if (pp) {
3719                 struct sk_buff *nskb = *pp;
3720
3721                 *pp = nskb->next;
3722                 nskb->next = NULL;
3723                 napi_gro_complete(nskb);
3724                 napi->gro_count--;
3725         }
3726
3727         if (same_flow)
3728                 goto ok;
3729
3730         if (NAPI_GRO_CB(skb)->flush || napi->gro_count >= MAX_GRO_SKBS)
3731                 goto normal;
3732
3733         napi->gro_count++;
3734         NAPI_GRO_CB(skb)->count = 1;
3735         NAPI_GRO_CB(skb)->age = jiffies;
3736         skb_shinfo(skb)->gso_size = skb_gro_len(skb);
3737         skb->next = napi->gro_list;
3738         napi->gro_list = skb;
3739         ret = GRO_HELD;
3740
3741 pull:
3742         if (skb_headlen(skb) < skb_gro_offset(skb)) {
3743                 int grow = skb_gro_offset(skb) - skb_headlen(skb);
3744
3745                 BUG_ON(skb->end - skb->tail < grow);
3746
3747                 memcpy(skb_tail_pointer(skb), NAPI_GRO_CB(skb)->frag0, grow);
3748
3749                 skb->tail += grow;
3750                 skb->data_len -= grow;
3751
3752                 skb_shinfo(skb)->frags[0].page_offset += grow;
3753                 skb_frag_size_sub(&skb_shinfo(skb)->frags[0], grow);
3754
3755                 if (unlikely(!skb_frag_size(&skb_shinfo(skb)->frags[0]))) {
3756                         skb_frag_unref(skb, 0);
3757                         memmove(skb_shinfo(skb)->frags,
3758                                 skb_shinfo(skb)->frags + 1,
3759                                 --skb_shinfo(skb)->nr_frags * sizeof(skb_frag_t));
3760                 }
3761         }
3762
3763 ok:
3764         return ret;
3765
3766 normal:
3767         ret = GRO_NORMAL;
3768         goto pull;
3769 }
3770
3771
3772 static gro_result_t napi_skb_finish(gro_result_t ret, struct sk_buff *skb)
3773 {
3774         switch (ret) {
3775         case GRO_NORMAL:
3776                 if (netif_receive_skb(skb))
3777                         ret = GRO_DROP;
3778                 break;
3779
3780         case GRO_DROP:
3781                 kfree_skb(skb);
3782                 break;
3783
3784         case GRO_MERGED_FREE:
3785                 if (NAPI_GRO_CB(skb)->free == NAPI_GRO_FREE_STOLEN_HEAD)
3786                         kmem_cache_free(skbuff_head_cache, skb);
3787                 else
3788                         __kfree_skb(skb);
3789                 break;
3790
3791         case GRO_HELD:
3792         case GRO_MERGED:
3793                 break;
3794         }
3795
3796         return ret;
3797 }
3798
3799 static void skb_gro_reset_offset(struct sk_buff *skb)
3800 {
3801         const struct skb_shared_info *pinfo = skb_shinfo(skb);
3802         const skb_frag_t *frag0 = &pinfo->frags[0];
3803
3804         NAPI_GRO_CB(skb)->data_offset = 0;
3805         NAPI_GRO_CB(skb)->frag0 = NULL;
3806         NAPI_GRO_CB(skb)->frag0_len = 0;
3807
3808         if (skb->mac_header == skb->tail &&
3809             pinfo->nr_frags &&
3810             !PageHighMem(skb_frag_page(frag0))) {
3811                 NAPI_GRO_CB(skb)->frag0 = skb_frag_address(frag0);
3812                 NAPI_GRO_CB(skb)->frag0_len = skb_frag_size(frag0);
3813         }
3814 }
3815
3816 gro_result_t napi_gro_receive(struct napi_struct *napi, struct sk_buff *skb)
3817 {
3818         skb_gro_reset_offset(skb);
3819
3820         return napi_skb_finish(dev_gro_receive(napi, skb), skb);
3821 }
3822 EXPORT_SYMBOL(napi_gro_receive);
3823
3824 static void napi_reuse_skb(struct napi_struct *napi, struct sk_buff *skb)
3825 {
3826         __skb_pull(skb, skb_headlen(skb));
3827         /* restore the reserve we had after netdev_alloc_skb_ip_align() */
3828         skb_reserve(skb, NET_SKB_PAD + NET_IP_ALIGN - skb_headroom(skb));
3829         skb->vlan_tci = 0;
3830         skb->dev = napi->dev;
3831         skb->skb_iif = 0;
3832
3833         napi->skb = skb;
3834 }
3835
3836 struct sk_buff *napi_get_frags(struct napi_struct *napi)
3837 {
3838         struct sk_buff *skb = napi->skb;
3839
3840         if (!skb) {
3841                 skb = netdev_alloc_skb_ip_align(napi->dev, GRO_MAX_HEAD);
3842                 if (skb)
3843                         napi->skb = skb;
3844         }
3845         return skb;
3846 }
3847 EXPORT_SYMBOL(napi_get_frags);
3848
3849 static gro_result_t napi_frags_finish(struct napi_struct *napi, struct sk_buff *skb,
3850                                gro_result_t ret)
3851 {
3852         switch (ret) {
3853         case GRO_NORMAL:
3854         case GRO_HELD:
3855                 skb->protocol = eth_type_trans(skb, skb->dev);
3856
3857                 if (ret == GRO_HELD)
3858                         skb_gro_pull(skb, -ETH_HLEN);
3859                 else if (netif_receive_skb(skb))
3860                         ret = GRO_DROP;
3861                 break;
3862
3863         case GRO_DROP:
3864         case GRO_MERGED_FREE:
3865                 napi_reuse_skb(napi, skb);
3866                 break;
3867
3868         case GRO_MERGED:
3869                 break;
3870         }
3871
3872         return ret;
3873 }
3874
3875 static struct sk_buff *napi_frags_skb(struct napi_struct *napi)
3876 {
3877         struct sk_buff *skb = napi->skb;
3878         struct ethhdr *eth;
3879         unsigned int hlen;
3880         unsigned int off;
3881
3882         napi->skb = NULL;
3883
3884         skb_reset_mac_header(skb);
3885         skb_gro_reset_offset(skb);
3886
3887         off = skb_gro_offset(skb);
3888         hlen = off + sizeof(*eth);
3889         eth = skb_gro_header_fast(skb, off);
3890         if (skb_gro_header_hard(skb, hlen)) {
3891                 eth = skb_gro_header_slow(skb, hlen, off);
3892                 if (unlikely(!eth)) {
3893                  &nb