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