e6f2635912403a9517d3b3d975671b69dde063a9
[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 == '/' || 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         ASSERT_RTNL();
1063
1064         if (len >= IFALIASZ)
1065                 return -EINVAL;
1066
1067         if (!len) {
1068                 if (dev->ifalias) {
1069                         kfree(dev->ifalias);
1070                         dev->ifalias = NULL;
1071                 }
1072                 return 0;
1073         }
1074
1075         dev->ifalias = krealloc(dev->ifalias, len + 1, GFP_KERNEL);
1076         if (!dev->ifalias)
1077                 return -ENOMEM;
1078
1079         strlcpy(dev->ifalias, alias, len+1);
1080         return len;
1081 }
1082
1083
1084 /**
1085  *      netdev_features_change - device changes features
1086  *      @dev: device to cause notification
1087  *
1088  *      Called to indicate a device has changed features.
1089  */
1090 void netdev_features_change(struct net_device *dev)
1091 {
1092         call_netdevice_notifiers(NETDEV_FEAT_CHANGE, dev);
1093 }
1094 EXPORT_SYMBOL(netdev_features_change);
1095
1096 /**
1097  *      netdev_state_change - device changes state
1098  *      @dev: device to cause notification
1099  *
1100  *      Called to indicate a device has changed state. This function calls
1101  *      the notifier chains for netdev_chain and sends a NEWLINK message
1102  *      to the routing socket.
1103  */
1104 void netdev_state_change(struct net_device *dev)
1105 {
1106         if (dev->flags & IFF_UP) {
1107                 call_netdevice_notifiers(NETDEV_CHANGE, dev);
1108                 rtmsg_ifinfo(RTM_NEWLINK, dev, 0);
1109         }
1110 }
1111 EXPORT_SYMBOL(netdev_state_change);
1112
1113 int netdev_bonding_change(struct net_device *dev, unsigned long event)
1114 {
1115         return call_netdevice_notifiers(event, dev);
1116 }
1117 EXPORT_SYMBOL(netdev_bonding_change);
1118
1119 /**
1120  *      dev_load        - load a network module
1121  *      @net: the applicable net namespace
1122  *      @name: name of interface
1123  *
1124  *      If a network interface is not present and the process has suitable
1125  *      privileges this function loads the module. If module loading is not
1126  *      available in this kernel then it becomes a nop.
1127  */
1128
1129 void dev_load(struct net *net, const char *name)
1130 {
1131         struct net_device *dev;
1132         int no_module;
1133
1134         rcu_read_lock();
1135         dev = dev_get_by_name_rcu(net, name);
1136         rcu_read_unlock();
1137
1138         no_module = !dev;
1139         if (no_module && capable(CAP_NET_ADMIN))
1140                 no_module = request_module("netdev-%s", name);
1141         if (no_module && capable(CAP_SYS_MODULE)) {
1142                 if (!request_module("%s", name))
1143                         pr_err("Loading kernel module for a network device "
1144 "with CAP_SYS_MODULE (deprecated).  Use CAP_NET_ADMIN and alias netdev-%s "
1145 "instead\n", name);
1146         }
1147 }
1148 EXPORT_SYMBOL(dev_load);
1149
1150 static int __dev_open(struct net_device *dev)
1151 {
1152         const struct net_device_ops *ops = dev->netdev_ops;
1153         int ret;
1154
1155         ASSERT_RTNL();
1156
1157         if (!netif_device_present(dev))
1158                 return -ENODEV;
1159
1160         ret = call_netdevice_notifiers(NETDEV_PRE_UP, dev);
1161         ret = notifier_to_errno(ret);
1162         if (ret)
1163                 return ret;
1164
1165         set_bit(__LINK_STATE_START, &dev->state);
1166
1167         if (ops->ndo_validate_addr)
1168                 ret = ops->ndo_validate_addr(dev);
1169
1170         if (!ret && ops->ndo_open)
1171                 ret = ops->ndo_open(dev);
1172
1173         if (ret)
1174                 clear_bit(__LINK_STATE_START, &dev->state);
1175         else {
1176                 dev->flags |= IFF_UP;
1177                 net_dmaengine_get();
1178                 dev_set_rx_mode(dev);
1179                 dev_activate(dev);
1180                 add_device_randomness(dev->dev_addr, dev->addr_len);
1181         }
1182
1183         return ret;
1184 }
1185
1186 /**
1187  *      dev_open        - prepare an interface for use.
1188  *      @dev:   device to open
1189  *
1190  *      Takes a device from down to up state. The device's private open
1191  *      function is invoked and then the multicast lists are loaded. Finally
1192  *      the device is moved into the up state and a %NETDEV_UP message is
1193  *      sent to the netdev notifier chain.
1194  *
1195  *      Calling this function on an active interface is a nop. On a failure
1196  *      a negative errno code is returned.
1197  */
1198 int dev_open(struct net_device *dev)
1199 {
1200         int ret;
1201
1202         if (dev->flags & IFF_UP)
1203                 return 0;
1204
1205         ret = __dev_open(dev);
1206         if (ret < 0)
1207                 return ret;
1208
1209         rtmsg_ifinfo(RTM_NEWLINK, dev, IFF_UP|IFF_RUNNING);
1210         call_netdevice_notifiers(NETDEV_UP, dev);
1211
1212         return ret;
1213 }
1214 EXPORT_SYMBOL(dev_open);
1215
1216 static int __dev_close_many(struct list_head *head)
1217 {
1218         struct net_device *dev;
1219
1220         ASSERT_RTNL();
1221         might_sleep();
1222
1223         list_for_each_entry(dev, head, unreg_list) {
1224                 call_netdevice_notifiers(NETDEV_GOING_DOWN, dev);
1225
1226                 clear_bit(__LINK_STATE_START, &dev->state);
1227
1228                 /* Synchronize to scheduled poll. We cannot touch poll list, it
1229                  * can be even on different cpu. So just clear netif_running().
1230                  *
1231                  * dev->stop() will invoke napi_disable() on all of it's
1232                  * napi_struct instances on this device.
1233                  */
1234                 smp_mb__after_clear_bit(); /* Commit netif_running(). */
1235         }
1236
1237         dev_deactivate_many(head);
1238
1239         list_for_each_entry(dev, head, unreg_list) {
1240                 const struct net_device_ops *ops = dev->netdev_ops;
1241
1242                 /*
1243                  *      Call the device specific close. This cannot fail.
1244                  *      Only if device is UP
1245                  *
1246                  *      We allow it to be called even after a DETACH hot-plug
1247                  *      event.
1248                  */
1249                 if (ops->ndo_stop)
1250                         ops->ndo_stop(dev);
1251
1252                 dev->flags &= ~IFF_UP;
1253                 net_dmaengine_put();
1254         }
1255
1256         return 0;
1257 }
1258
1259 static int __dev_close(struct net_device *dev)
1260 {
1261         int retval;
1262         LIST_HEAD(single);
1263
1264         list_add(&dev->unreg_list, &single);
1265         retval = __dev_close_many(&single);
1266         list_del(&single);
1267         return retval;
1268 }
1269
1270 static int dev_close_many(struct list_head *head)
1271 {
1272         struct net_device *dev, *tmp;
1273         LIST_HEAD(tmp_list);
1274
1275         list_for_each_entry_safe(dev, tmp, head, unreg_list)
1276                 if (!(dev->flags & IFF_UP))
1277                         list_move(&dev->unreg_list, &tmp_list);
1278
1279         __dev_close_many(head);
1280
1281         list_for_each_entry(dev, head, unreg_list) {
1282                 rtmsg_ifinfo(RTM_NEWLINK, dev, IFF_UP|IFF_RUNNING);
1283                 call_netdevice_notifiers(NETDEV_DOWN, dev);
1284         }
1285
1286         /* rollback_registered_many needs the complete original list */
1287         list_splice(&tmp_list, head);
1288         return 0;
1289 }
1290
1291 /**
1292  *      dev_close - shutdown an interface.
1293  *      @dev: device to shutdown
1294  *
1295  *      This function moves an active device into down state. A
1296  *      %NETDEV_GOING_DOWN is sent to the netdev notifier chain. The device
1297  *      is then deactivated and finally a %NETDEV_DOWN is sent to the notifier
1298  *      chain.
1299  */
1300 int dev_close(struct net_device *dev)
1301 {
1302         if (dev->flags & IFF_UP) {
1303                 LIST_HEAD(single);
1304
1305                 list_add(&dev->unreg_list, &single);
1306                 dev_close_many(&single);
1307                 list_del(&single);
1308         }
1309         return 0;
1310 }
1311 EXPORT_SYMBOL(dev_close);
1312
1313
1314 /**
1315  *      dev_disable_lro - disable Large Receive Offload on a device
1316  *      @dev: device
1317  *
1318  *      Disable Large Receive Offload (LRO) on a net device.  Must be
1319  *      called under RTNL.  This is needed if received packets may be
1320  *      forwarded to another interface.
1321  */
1322 void dev_disable_lro(struct net_device *dev)
1323 {
1324         u32 flags;
1325
1326         /*
1327          * If we're trying to disable lro on a vlan device
1328          * use the underlying physical device instead
1329          */
1330         if (is_vlan_dev(dev))
1331                 dev = vlan_dev_real_dev(dev);
1332
1333         if (dev->ethtool_ops && dev->ethtool_ops->get_flags)
1334                 flags = dev->ethtool_ops->get_flags(dev);
1335         else
1336                 flags = ethtool_op_get_flags(dev);
1337
1338         if (!(flags & ETH_FLAG_LRO))
1339                 return;
1340
1341         __ethtool_set_flags(dev, flags & ~ETH_FLAG_LRO);
1342         if (unlikely(dev->features & NETIF_F_LRO))
1343                 netdev_WARN(dev, "failed to disable LRO!\n");
1344 }
1345 EXPORT_SYMBOL(dev_disable_lro);
1346
1347
1348 static int dev_boot_phase = 1;
1349
1350 /**
1351  *      register_netdevice_notifier - register a network notifier block
1352  *      @nb: notifier
1353  *
1354  *      Register a notifier to be called when network device events occur.
1355  *      The notifier passed is linked into the kernel structures and must
1356  *      not be reused until it has been unregistered. A negative errno code
1357  *      is returned on a failure.
1358  *
1359  *      When registered all registration and up events are replayed
1360  *      to the new notifier to allow device to have a race free
1361  *      view of the network device list.
1362  */
1363
1364 int register_netdevice_notifier(struct notifier_block *nb)
1365 {
1366         struct net_device *dev;
1367         struct net_device *last;
1368         struct net *net;
1369         int err;
1370
1371         rtnl_lock();
1372         err = raw_notifier_chain_register(&netdev_chain, nb);
1373         if (err)
1374                 goto unlock;
1375         if (dev_boot_phase)
1376                 goto unlock;
1377         for_each_net(net) {
1378                 for_each_netdev(net, dev) {
1379                         err = nb->notifier_call(nb, NETDEV_REGISTER, dev);
1380                         err = notifier_to_errno(err);
1381                         if (err)
1382                                 goto rollback;
1383
1384                         if (!(dev->flags & IFF_UP))
1385                                 continue;
1386
1387                         nb->notifier_call(nb, NETDEV_UP, dev);
1388                 }
1389         }
1390
1391 unlock:
1392         rtnl_unlock();
1393         return err;
1394
1395 rollback:
1396         last = dev;
1397         for_each_net(net) {
1398                 for_each_netdev(net, dev) {
1399                         if (dev == last)
1400                                 goto outroll;
1401
1402                         if (dev->flags & IFF_UP) {
1403                                 nb->notifier_call(nb, NETDEV_GOING_DOWN, dev);
1404                                 nb->notifier_call(nb, NETDEV_DOWN, dev);
1405                         }
1406                         nb->notifier_call(nb, NETDEV_UNREGISTER, dev);
1407                         nb->notifier_call(nb, NETDEV_UNREGISTER_BATCH, dev);
1408                 }
1409         }
1410
1411 outroll:
1412         raw_notifier_chain_unregister(&netdev_chain, nb);
1413         goto unlock;
1414 }
1415 EXPORT_SYMBOL(register_netdevice_notifier);
1416
1417 /**
1418  *      unregister_netdevice_notifier - unregister a network notifier block
1419  *      @nb: notifier
1420  *
1421  *      Unregister a notifier previously registered by
1422  *      register_netdevice_notifier(). The notifier is unlinked into the
1423  *      kernel structures and may then be reused. A negative errno code
1424  *      is returned on a failure.
1425  *
1426  *      After unregistering unregister and down device events are synthesized
1427  *      for all devices on the device list to the removed notifier to remove
1428  *      the need for special case cleanup code.
1429  */
1430
1431 int unregister_netdevice_notifier(struct notifier_block *nb)
1432 {
1433         struct net_device *dev;
1434         struct net *net;
1435         int err;
1436
1437         rtnl_lock();
1438         err = raw_notifier_chain_unregister(&netdev_chain, nb);
1439         if (err)
1440                 goto unlock;
1441
1442         for_each_net(net) {
1443                 for_each_netdev(net, dev) {
1444                         if (dev->flags & IFF_UP) {
1445                                 nb->notifier_call(nb, NETDEV_GOING_DOWN, dev);
1446                                 nb->notifier_call(nb, NETDEV_DOWN, dev);
1447                         }
1448                         nb->notifier_call(nb, NETDEV_UNREGISTER, dev);
1449                         nb->notifier_call(nb, NETDEV_UNREGISTER_BATCH, dev);
1450                 }
1451         }
1452 unlock:
1453         rtnl_unlock();
1454         return err;
1455 }
1456 EXPORT_SYMBOL(unregister_netdevice_notifier);
1457
1458 /**
1459  *      call_netdevice_notifiers - call all network notifier blocks
1460  *      @val: value passed unmodified to notifier function
1461  *      @dev: net_device pointer passed unmodified to notifier function
1462  *
1463  *      Call all network notifier blocks.  Parameters and return value
1464  *      are as for raw_notifier_call_chain().
1465  */
1466
1467 int call_netdevice_notifiers(unsigned long val, struct net_device *dev)
1468 {
1469         ASSERT_RTNL();
1470         return raw_notifier_call_chain(&netdev_chain, val, dev);
1471 }
1472 EXPORT_SYMBOL(call_netdevice_notifiers);
1473
1474 /* When > 0 there are consumers of rx skb time stamps */
1475 static atomic_t netstamp_needed = ATOMIC_INIT(0);
1476
1477 void net_enable_timestamp(void)
1478 {
1479         atomic_inc(&netstamp_needed);
1480 }
1481 EXPORT_SYMBOL(net_enable_timestamp);
1482
1483 void net_disable_timestamp(void)
1484 {
1485         atomic_dec(&netstamp_needed);
1486 }
1487 EXPORT_SYMBOL(net_disable_timestamp);
1488
1489 static inline void net_timestamp_set(struct sk_buff *skb)
1490 {
1491         if (atomic_read(&netstamp_needed))
1492                 __net_timestamp(skb);
1493         else
1494                 skb->tstamp.tv64 = 0;
1495 }
1496
1497 static inline void net_timestamp_check(struct sk_buff *skb)
1498 {
1499         if (!skb->tstamp.tv64 && atomic_read(&netstamp_needed))
1500                 __net_timestamp(skb);
1501 }
1502
1503 static int net_hwtstamp_validate(struct ifreq *ifr)
1504 {
1505         struct hwtstamp_config cfg;
1506         enum hwtstamp_tx_types tx_type;
1507         enum hwtstamp_rx_filters rx_filter;
1508         int tx_type_valid = 0;
1509         int rx_filter_valid = 0;
1510
1511         if (copy_from_user(&cfg, ifr->ifr_data, sizeof(cfg)))
1512                 return -EFAULT;
1513
1514         if (cfg.flags) /* reserved for future extensions */
1515                 return -EINVAL;
1516
1517         tx_type = cfg.tx_type;
1518         rx_filter = cfg.rx_filter;
1519
1520         switch (tx_type) {
1521         case HWTSTAMP_TX_OFF:
1522         case HWTSTAMP_TX_ON:
1523         case HWTSTAMP_TX_ONESTEP_SYNC:
1524                 tx_type_valid = 1;
1525                 break;
1526         }
1527
1528         switch (rx_filter) {
1529         case HWTSTAMP_FILTER_NONE:
1530         case HWTSTAMP_FILTER_ALL:
1531         case HWTSTAMP_FILTER_SOME:
1532         case HWTSTAMP_FILTER_PTP_V1_L4_EVENT:
1533         case HWTSTAMP_FILTER_PTP_V1_L4_SYNC:
1534         case HWTSTAMP_FILTER_PTP_V1_L4_DELAY_REQ:
1535         case HWTSTAMP_FILTER_PTP_V2_L4_EVENT:
1536         case HWTSTAMP_FILTER_PTP_V2_L4_SYNC:
1537         case HWTSTAMP_FILTER_PTP_V2_L4_DELAY_REQ:
1538         case HWTSTAMP_FILTER_PTP_V2_L2_EVENT:
1539         case HWTSTAMP_FILTER_PTP_V2_L2_SYNC:
1540         case HWTSTAMP_FILTER_PTP_V2_L2_DELAY_REQ:
1541         case HWTSTAMP_FILTER_PTP_V2_EVENT:
1542         case HWTSTAMP_FILTER_PTP_V2_SYNC:
1543         case HWTSTAMP_FILTER_PTP_V2_DELAY_REQ:
1544                 rx_filter_valid = 1;
1545                 break;
1546         }
1547
1548         if (!tx_type_valid || !rx_filter_valid)
1549                 return -ERANGE;
1550
1551         return 0;
1552 }
1553
1554 static inline bool is_skb_forwardable(struct net_device *dev,
1555                                       struct sk_buff *skb)
1556 {
1557         unsigned int len;
1558
1559         if (!(dev->flags & IFF_UP))
1560                 return false;
1561
1562         len = dev->mtu + dev->hard_header_len + VLAN_HLEN;
1563         if (skb->len <= len)
1564                 return true;
1565
1566         /* if TSO is enabled, we don't care about the length as the packet
1567          * could be forwarded without being segmented before
1568          */
1569         if (skb_is_gso(skb))
1570                 return true;
1571
1572         return false;
1573 }
1574
1575 /**
1576  * dev_forward_skb - loopback an skb to another netif
1577  *
1578  * @dev: destination network device
1579  * @skb: buffer to forward
1580  *
1581  * return values:
1582  *      NET_RX_SUCCESS  (no congestion)
1583  *      NET_RX_DROP     (packet was dropped, but freed)
1584  *
1585  * dev_forward_skb can be used for injecting an skb from the
1586  * start_xmit function of one device into the receive queue
1587  * of another device.
1588  *
1589  * The receiving device may be in another namespace, so
1590  * we have to clear all information in the skb that could
1591  * impact namespace isolation.
1592  */
1593 int dev_forward_skb(struct net_device *dev, struct sk_buff *skb)
1594 {
1595         if (skb_shinfo(skb)->tx_flags & SKBTX_DEV_ZEROCOPY) {
1596                 if (skb_copy_ubufs(skb, GFP_ATOMIC)) {
1597                         atomic_long_inc(&dev->rx_dropped);
1598                         kfree_skb(skb);
1599                         return NET_RX_DROP;
1600                 }
1601         }
1602
1603         skb_orphan(skb);
1604         nf_reset(skb);
1605
1606         if (unlikely(!is_skb_forwardable(dev, skb))) {
1607                 atomic_long_inc(&dev->rx_dropped);
1608                 kfree_skb(skb);
1609                 return NET_RX_DROP;
1610         }
1611         skb->dev = dev;
1612         skb_dst_drop(skb);
1613         skb->tstamp.tv64 = 0;
1614         skb->pkt_type = PACKET_HOST;
1615         skb->protocol = eth_type_trans(skb, dev);
1616         skb->mark = 0;
1617         secpath_reset(skb);
1618         nf_reset(skb);
1619         return netif_rx(skb);
1620 }
1621 EXPORT_SYMBOL_GPL(dev_forward_skb);
1622
1623 static inline int deliver_skb(struct sk_buff *skb,
1624                               struct packet_type *pt_prev,
1625                               struct net_device *orig_dev)
1626 {
1627         atomic_inc(&skb->users);
1628         return pt_prev->func(skb, skb->dev, pt_prev, orig_dev);
1629 }
1630
1631 /*
1632  *      Support routine. Sends outgoing frames to any network
1633  *      taps currently in use.
1634  */
1635
1636 static void dev_queue_xmit_nit(struct sk_buff *skb, struct net_device *dev)
1637 {
1638         struct packet_type *ptype;
1639         struct sk_buff *skb2 = NULL;
1640         struct packet_type *pt_prev = NULL;
1641
1642         rcu_read_lock();
1643         list_for_each_entry_rcu(ptype, &ptype_all, list) {
1644                 /* Never send packets back to the socket
1645                  * they originated from - MvS (miquels@drinkel.ow.org)
1646                  */
1647                 if ((ptype->dev == dev || !ptype->dev) &&
1648                     (ptype->af_packet_priv == NULL ||
1649                      (struct sock *)ptype->af_packet_priv != skb->sk)) {
1650                         if (pt_prev) {
1651                                 deliver_skb(skb2, pt_prev, skb->dev);
1652                                 pt_prev = ptype;
1653                                 continue;
1654                         }
1655
1656                         skb2 = skb_clone(skb, GFP_ATOMIC);
1657                         if (!skb2)
1658                                 break;
1659
1660                         net_timestamp_set(skb2);
1661
1662                         /* skb->nh should be correctly
1663                            set by sender, so that the second statement is
1664                            just protection against buggy protocols.
1665                          */
1666                         skb_reset_mac_header(skb2);
1667
1668                         if (skb_network_header(skb2) < skb2->data ||
1669                             skb2->network_header > skb2->tail) {
1670                                 if (net_ratelimit())
1671                                         printk(KERN_CRIT "protocol %04x is "
1672                                                "buggy, dev %s\n",
1673                                                ntohs(skb2->protocol),
1674                                                dev->name);
1675                                 skb_reset_network_header(skb2);
1676                         }
1677
1678                         skb2->transport_header = skb2->network_header;
1679                         skb2->pkt_type = PACKET_OUTGOING;
1680                         pt_prev = ptype;
1681                 }
1682         }
1683         if (pt_prev)
1684                 pt_prev->func(skb2, skb->dev, pt_prev, skb->dev);
1685         rcu_read_unlock();
1686 }
1687
1688 /* netif_setup_tc - Handle tc mappings on real_num_tx_queues change
1689  * @dev: Network device
1690  * @txq: number of queues available
1691  *
1692  * If real_num_tx_queues is changed the tc mappings may no longer be
1693  * valid. To resolve this verify the tc mapping remains valid and if
1694  * not NULL the mapping. With no priorities mapping to this
1695  * offset/count pair it will no longer be used. In the worst case TC0
1696  * is invalid nothing can be done so disable priority mappings. If is
1697  * expected that drivers will fix this mapping if they can before
1698  * calling netif_set_real_num_tx_queues.
1699  */
1700 static void netif_setup_tc(struct net_device *dev, unsigned int txq)
1701 {
1702         int i;
1703         struct netdev_tc_txq *tc = &dev->tc_to_txq[0];
1704
1705         /* If TC0 is invalidated disable TC mapping */
1706         if (tc->offset + tc->count > txq) {
1707                 pr_warning("Number of in use tx queues changed "
1708                            "invalidating tc mappings. Priority "
1709                            "traffic classification disabled!\n");
1710                 dev->num_tc = 0;
1711                 return;
1712         }
1713
1714         /* Invalidated prio to tc mappings set to TC0 */
1715         for (i = 1; i < TC_BITMASK + 1; i++) {
1716                 int q = netdev_get_prio_tc_map(dev, i);
1717
1718                 tc = &dev->tc_to_txq[q];
1719                 if (tc->offset + tc->count > txq) {
1720                         pr_warning("Number of in use tx queues "
1721                                    "changed. Priority %i to tc "
1722                                    "mapping %i is no longer valid "
1723                                    "setting map to 0\n",
1724                                    i, q);
1725                         netdev_set_prio_tc_map(dev, i, 0);
1726                 }
1727         }
1728 }
1729
1730 /*
1731  * Routine to help set real_num_tx_queues. To avoid skbs mapped to queues
1732  * greater then real_num_tx_queues stale skbs on the qdisc must be flushed.
1733  */
1734 int netif_set_real_num_tx_queues(struct net_device *dev, unsigned int txq)
1735 {
1736         int rc;
1737
1738         if (txq < 1 || txq > dev->num_tx_queues)
1739                 return -EINVAL;
1740
1741         if (dev->reg_state == NETREG_REGISTERED ||
1742             dev->reg_state == NETREG_UNREGISTERING) {
1743                 ASSERT_RTNL();
1744
1745                 rc = netdev_queue_update_kobjects(dev, dev->real_num_tx_queues,
1746                                                   txq);
1747                 if (rc)
1748                         return rc;
1749
1750                 if (dev->num_tc)
1751                         netif_setup_tc(dev, txq);
1752
1753                 if (txq < dev->real_num_tx_queues)
1754                         qdisc_reset_all_tx_gt(dev, txq);
1755         }
1756
1757         dev->real_num_tx_queues = txq;
1758         return 0;
1759 }
1760 EXPORT_SYMBOL(netif_set_real_num_tx_queues);
1761
1762 #ifdef CONFIG_RPS
1763 /**
1764  *      netif_set_real_num_rx_queues - set actual number of RX queues used
1765  *      @dev: Network device
1766  *      @rxq: Actual number of RX queues
1767  *
1768  *      This must be called either with the rtnl_lock held or before
1769  *      registration of the net device.  Returns 0 on success, or a
1770  *      negative error code.  If called before registration, it always
1771  *      succeeds.
1772  */
1773 int netif_set_real_num_rx_queues(struct net_device *dev, unsigned int rxq)
1774 {
1775         int rc;
1776
1777         if (rxq < 1 || rxq > dev->num_rx_queues)
1778                 return -EINVAL;
1779
1780         if (dev->reg_state == NETREG_REGISTERED) {
1781                 ASSERT_RTNL();
1782
1783                 rc = net_rx_queue_update_kobjects(dev, dev->real_num_rx_queues,
1784                                                   rxq);
1785                 if (rc)
1786                         return rc;
1787         }
1788
1789         dev->real_num_rx_queues = rxq;
1790         return 0;
1791 }
1792 EXPORT_SYMBOL(netif_set_real_num_rx_queues);
1793 #endif
1794
1795 static inline void __netif_reschedule(struct Qdisc *q)
1796 {
1797         struct softnet_data *sd;
1798         unsigned long flags;
1799
1800         local_irq_save(flags);
1801         sd = &__get_cpu_var(softnet_data);
1802         q->next_sched = NULL;
1803         *sd->output_queue_tailp = q;
1804         sd->output_queue_tailp = &q->next_sched;
1805         raise_softirq_irqoff(NET_TX_SOFTIRQ);
1806         local_irq_restore(flags);
1807 }
1808
1809 void __netif_schedule(struct Qdisc *q)
1810 {
1811         if (!test_and_set_bit(__QDISC_STATE_SCHED, &q->state))
1812                 __netif_reschedule(q);
1813 }
1814 EXPORT_SYMBOL(__netif_schedule);
1815
1816 void dev_kfree_skb_irq(struct sk_buff *skb)
1817 {
1818         if (atomic_dec_and_test(&skb->users)) {
1819                 struct softnet_data *sd;
1820                 unsigned long flags;
1821
1822                 local_irq_save(flags);
1823                 sd = &__get_cpu_var(softnet_data);
1824                 skb->next = sd->completion_queue;
1825                 sd->completion_queue = skb;
1826                 raise_softirq_irqoff(NET_TX_SOFTIRQ);
1827                 local_irq_restore(flags);
1828         }
1829 }
1830 EXPORT_SYMBOL(dev_kfree_skb_irq);
1831
1832 void dev_kfree_skb_any(struct sk_buff *skb)
1833 {
1834         if (in_irq() || irqs_disabled())
1835                 dev_kfree_skb_irq(skb);
1836         else
1837                 dev_kfree_skb(skb);
1838 }
1839 EXPORT_SYMBOL(dev_kfree_skb_any);
1840
1841
1842 /**
1843  * netif_device_detach - mark device as removed
1844  * @dev: network device
1845  *
1846  * Mark device as removed from system and therefore no longer available.
1847  */
1848 void netif_device_detach(struct net_device *dev)
1849 {
1850         if (test_and_clear_bit(__LINK_STATE_PRESENT, &dev->state) &&
1851             netif_running(dev)) {
1852                 netif_tx_stop_all_queues(dev);
1853         }
1854 }
1855 EXPORT_SYMBOL(netif_device_detach);
1856
1857 /**
1858  * netif_device_attach - mark device as attached
1859  * @dev: network device
1860  *
1861  * Mark device as attached from system and restart if needed.
1862  */
1863 void netif_device_attach(struct net_device *dev)
1864 {
1865         if (!test_and_set_bit(__LINK_STATE_PRESENT, &dev->state) &&
1866             netif_running(dev)) {
1867                 netif_tx_wake_all_queues(dev);
1868                 __netdev_watchdog_up(dev);
1869         }
1870 }
1871 EXPORT_SYMBOL(netif_device_attach);
1872
1873 /*
1874  * Invalidate hardware checksum when packet is to be mangled, and
1875  * complete checksum manually on outgoing path.
1876  */
1877 int skb_checksum_help(struct sk_buff *skb)
1878 {
1879         __wsum csum;
1880         int ret = 0, offset;
1881
1882         if (skb->ip_summed == CHECKSUM_COMPLETE)
1883                 goto out_set_summed;
1884
1885         if (unlikely(skb_shinfo(skb)->gso_size)) {
1886                 /* Let GSO fix up the checksum. */
1887                 goto out_set_summed;
1888         }
1889
1890         offset = skb_checksum_start_offset(skb);
1891         BUG_ON(offset >= skb_headlen(skb));
1892         csum = skb_checksum(skb, offset, skb->len - offset, 0);
1893
1894         offset += skb->csum_offset;
1895         BUG_ON(offset + sizeof(__sum16) > skb_headlen(skb));
1896
1897         if (skb_cloned(skb) &&
1898             !skb_clone_writable(skb, offset + sizeof(__sum16))) {
1899                 ret = pskb_expand_head(skb, 0, 0, GFP_ATOMIC);
1900                 if (ret)
1901                         goto out;
1902         }
1903
1904         *(__sum16 *)(skb->data + offset) = csum_fold(csum);
1905 out_set_summed:
1906         skb->ip_summed = CHECKSUM_NONE;
1907 out:
1908         return ret;
1909 }
1910 EXPORT_SYMBOL(skb_checksum_help);
1911
1912 /**
1913  *      skb_gso_segment - Perform segmentation on skb.
1914  *      @skb: buffer to segment
1915  *      @features: features for the output path (see dev->features)
1916  *
1917  *      This function segments the given skb and returns a list of segments.
1918  *
1919  *      It may return NULL if the skb requires no segmentation.  This is
1920  *      only possible when GSO is used for verifying header integrity.
1921  */
1922 struct sk_buff *skb_gso_segment(struct sk_buff *skb, u32 features)
1923 {
1924         struct sk_buff *segs = ERR_PTR(-EPROTONOSUPPORT);
1925         struct packet_type *ptype;
1926         __be16 type = skb->protocol;
1927         int vlan_depth = ETH_HLEN;
1928         int err;
1929
1930         while (type == htons(ETH_P_8021Q)) {
1931                 struct vlan_hdr *vh;
1932
1933                 if (unlikely(!pskb_may_pull(skb, vlan_depth + VLAN_HLEN)))
1934                         return ERR_PTR(-EINVAL);
1935
1936                 vh = (struct vlan_hdr *)(skb->data + vlan_depth);
1937                 type = vh->h_vlan_encapsulated_proto;
1938                 vlan_depth += VLAN_HLEN;
1939         }
1940
1941         skb_reset_mac_header(skb);
1942         skb->mac_len = skb->network_header - skb->mac_header;
1943         __skb_pull(skb, skb->mac_len);
1944
1945         if (unlikely(skb->ip_summed != CHECKSUM_PARTIAL)) {
1946                 struct net_device *dev = skb->dev;
1947                 struct ethtool_drvinfo info = {};
1948
1949                 if (dev && dev->ethtool_ops && dev->ethtool_ops->get_drvinfo)
1950                         dev->ethtool_ops->get_drvinfo(dev, &info);
1951
1952                 WARN(1, "%s: caps=(0x%lx, 0x%lx) len=%d data_len=%d ip_summed=%d\n",
1953                      info.driver, dev ? dev->features : 0L,
1954                      skb->sk ? skb->sk->sk_route_caps : 0L,
1955                      skb->len, skb->data_len, skb->ip_summed);
1956
1957                 if (skb_header_cloned(skb) &&
1958                     (err = pskb_expand_head(skb, 0, 0, GFP_ATOMIC)))
1959                         return ERR_PTR(err);
1960         }
1961
1962         rcu_read_lock();
1963         list_for_each_entry_rcu(ptype,
1964                         &ptype_base[ntohs(type) & PTYPE_HASH_MASK], list) {
1965                 if (ptype->type == type && !ptype->dev && ptype->gso_segment) {
1966                         if (unlikely(skb->ip_summed != CHECKSUM_PARTIAL)) {
1967                                 err = ptype->gso_send_check(skb);
1968                                 segs = ERR_PTR(err);
1969                                 if (err || skb_gso_ok(skb, features))
1970                                         break;
1971                                 __skb_push(skb, (skb->data -
1972                                                  skb_network_header(skb)));
1973                         }
1974                         segs = ptype->gso_segment(skb, features);
1975                         break;
1976                 }
1977         }
1978         rcu_read_unlock();
1979
1980         __skb_push(skb, skb->data - skb_mac_header(skb));
1981
1982         return segs;
1983 }
1984 EXPORT_SYMBOL(skb_gso_segment);
1985
1986 /* Take action when hardware reception checksum errors are detected. */
1987 #ifdef CONFIG_BUG
1988 void netdev_rx_csum_fault(struct net_device *dev)
1989 {
1990         if (net_ratelimit()) {
1991                 printk(KERN_ERR "%s: hw csum failure.\n",
1992                         dev ? dev->name : "<unknown>");
1993                 dump_stack();
1994         }
1995 }
1996 EXPORT_SYMBOL(netdev_rx_csum_fault);
1997 #endif
1998
1999 /* Actually, we should eliminate this check as soon as we know, that:
2000  * 1. IOMMU is present and allows to map all the memory.
2001  * 2. No high memory really exists on this machine.
2002  */
2003
2004 static int illegal_highdma(struct net_device *dev, struct sk_buff *skb)
2005 {
2006 #ifdef CONFIG_HIGHMEM
2007         int i;
2008         if (!(dev->features & NETIF_F_HIGHDMA)) {
2009                 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
2010                         skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
2011                         if (PageHighMem(skb_frag_page(frag)))
2012                                 return 1;
2013                 }
2014         }
2015
2016         if (PCI_DMA_BUS_IS_PHYS) {
2017                 struct device *pdev = dev->dev.parent;
2018
2019                 if (!pdev)
2020                         return 0;
2021                 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
2022                         skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
2023                         dma_addr_t addr = page_to_phys(skb_frag_page(frag));
2024                         if (!pdev->dma_mask || addr + PAGE_SIZE - 1 > *pdev->dma_mask)
2025                                 return 1;
2026                 }
2027         }
2028 #endif
2029         return 0;
2030 }
2031
2032 struct dev_gso_cb {
2033         void (*destructor)(struct sk_buff *skb);
2034 };
2035
2036 #define DEV_GSO_CB(skb) ((struct dev_gso_cb *)(skb)->cb)
2037
2038 static void dev_gso_skb_destructor(struct sk_buff *skb)
2039 {
2040         struct dev_gso_cb *cb;
2041
2042         do {
2043                 struct sk_buff *nskb = skb->next;
2044
2045                 skb->next = nskb->next;
2046                 nskb->next = NULL;
2047                 kfree_skb(nskb);
2048         } while (skb->next);
2049
2050         cb = DEV_GSO_CB(skb);
2051         if (cb->destructor)
2052                 cb->destructor(skb);
2053 }
2054
2055 /**
2056  *      dev_gso_segment - Perform emulated hardware segmentation on skb.
2057  *      @skb: buffer to segment
2058  *      @features: device features as applicable to this skb
2059  *
2060  *      This function segments the given skb and stores the list of segments
2061  *      in skb->next.
2062  */
2063 static int dev_gso_segment(struct sk_buff *skb, int features)
2064 {
2065         struct sk_buff *segs;
2066
2067         segs = skb_gso_segment(skb, features);
2068
2069         /* Verifying header integrity only. */
2070         if (!segs)
2071                 return 0;
2072
2073         if (IS_ERR(segs))
2074                 return PTR_ERR(segs);
2075
2076         skb->next = segs;
2077         DEV_GSO_CB(skb)->destructor = skb->destructor;
2078         skb->destructor = dev_gso_skb_destructor;
2079
2080         return 0;
2081 }
2082
2083 static bool can_checksum_protocol(unsigned long features, __be16 protocol)
2084 {
2085         return ((features & NETIF_F_GEN_CSUM) ||
2086                 ((features & NETIF_F_V4_CSUM) &&
2087                  protocol == htons(ETH_P_IP)) ||
2088                 ((features & NETIF_F_V6_CSUM) &&
2089                  protocol == htons(ETH_P_IPV6)) ||
2090                 ((features & NETIF_F_FCOE_CRC) &&
2091                  protocol == htons(ETH_P_FCOE)));
2092 }
2093
2094 static u32 harmonize_features(struct sk_buff *skb, __be16 protocol, u32 features)
2095 {
2096         if (!can_checksum_protocol(features, protocol)) {
2097                 features &= ~NETIF_F_ALL_CSUM;
2098                 features &= ~NETIF_F_SG;
2099         } else if (illegal_highdma(skb->dev, skb)) {
2100                 features &= ~NETIF_F_SG;
2101         }
2102
2103         return features;
2104 }
2105
2106 u32 netif_skb_features(struct sk_buff *skb)
2107 {
2108         __be16 protocol = skb->protocol;
2109         u32 features = skb->dev->features;
2110
2111         if (skb_shinfo(skb)->gso_segs > skb->dev->gso_max_segs)
2112                 features &= ~NETIF_F_GSO_MASK;
2113
2114         if (protocol == htons(ETH_P_8021Q)) {
2115                 struct vlan_ethhdr *veh = (struct vlan_ethhdr *)skb->data;
2116                 protocol = veh->h_vlan_encapsulated_proto;
2117         } else if (!vlan_tx_tag_present(skb)) {
2118                 return harmonize_features(skb, protocol, features);
2119         }
2120
2121         features &= (skb->dev->vlan_features | NETIF_F_HW_VLAN_TX);
2122
2123         if (protocol != htons(ETH_P_8021Q)) {
2124                 return harmonize_features(skb, protocol, features);
2125         } else {
2126                 features &= NETIF_F_SG | NETIF_F_HIGHDMA | NETIF_F_FRAGLIST |
2127                                 NETIF_F_GEN_CSUM | NETIF_F_HW_VLAN_TX;
2128                 return harmonize_features(skb, protocol, features);
2129         }
2130 }
2131 EXPORT_SYMBOL(netif_skb_features);
2132
2133 /*
2134  * Returns true if either:
2135  *      1. skb has frag_list and the device doesn't support FRAGLIST, or
2136  *      2. skb is fragmented and the device does not support SG, or if
2137  *         at least one of fragments is in highmem and device does not
2138  *         support DMA from it.
2139  */
2140 static inline int skb_needs_linearize(struct sk_buff *skb,
2141                                       int features)
2142 {
2143         return skb_is_nonlinear(skb) &&
2144                         ((skb_has_frag_list(skb) &&
2145                                 !(features & NETIF_F_FRAGLIST)) ||
2146                         (skb_shinfo(skb)->nr_frags &&
2147                                 !(features & NETIF_F_SG)));
2148 }
2149
2150 int dev_hard_start_xmit(struct sk_buff *skb, struct net_device *dev,
2151                         struct netdev_queue *txq)
2152 {
2153         const struct net_device_ops *ops = dev->netdev_ops;
2154         int rc = NETDEV_TX_OK;
2155         unsigned int skb_len;
2156
2157         if (likely(!skb->next)) {
2158                 u32 features;
2159
2160                 /*
2161                  * If device doesn't need skb->dst, release it right now while
2162                  * its hot in this cpu cache
2163                  */
2164                 if (dev->priv_flags & IFF_XMIT_DST_RELEASE)
2165                         skb_dst_drop(skb);
2166
2167                 if (!list_empty(&ptype_all))
2168                         dev_queue_xmit_nit(skb, dev);
2169
2170                 features = netif_skb_features(skb);
2171
2172                 if (vlan_tx_tag_present(skb) &&
2173                     !(features & NETIF_F_HW_VLAN_TX)) {
2174                         skb = __vlan_put_tag(skb, vlan_tx_tag_get(skb));
2175                         if (unlikely(!skb))
2176                                 goto out;
2177
2178                         skb->vlan_tci = 0;
2179                 }
2180
2181                 if (netif_needs_gso(skb, features)) {
2182                         if (unlikely(dev_gso_segment(skb, features)))
2183                                 goto out_kfree_skb;
2184                         if (skb->next)
2185                                 goto gso;
2186                 } else {
2187                         if (skb_needs_linearize(skb, features) &&
2188                             __skb_linearize(skb))
2189                                 goto out_kfree_skb;
2190
2191                         /* If packet is not checksummed and device does not
2192                          * support checksumming for this protocol, complete
2193                          * checksumming here.
2194                          */
2195                         if (skb->ip_summed == CHECKSUM_PARTIAL) {
2196                                 skb_set_transport_header(skb,
2197                                         skb_checksum_start_offset(skb));
2198                                 if (!(features & NETIF_F_ALL_CSUM) &&
2199                                      skb_checksum_help(skb))
2200                                         goto out_kfree_skb;
2201                         }
2202                 }
2203
2204                 skb_len = skb->len;
2205                 rc = ops->ndo_start_xmit(skb, dev);
2206                 trace_net_dev_xmit(skb, rc, dev, skb_len);
2207                 if (rc == NETDEV_TX_OK)
2208                         txq_trans_update(txq);
2209                 return rc;
2210         }
2211
2212 gso:
2213         do {
2214                 struct sk_buff *nskb = skb->next;
2215
2216                 skb->next = nskb->next;
2217                 nskb->next = NULL;
2218
2219                 /*
2220                  * If device doesn't need nskb->dst, release it right now while
2221                  * its hot in this cpu cache
2222                  */
2223                 if (dev->priv_flags & IFF_XMIT_DST_RELEASE)
2224                         skb_dst_drop(nskb);
2225
2226                 skb_len = nskb->len;
2227                 rc = ops->ndo_start_xmit(nskb, dev);
2228                 trace_net_dev_xmit(nskb, rc, dev, skb_len);
2229                 if (unlikely(rc != NETDEV_TX_OK)) {
2230                         if (rc & ~NETDEV_TX_MASK)
2231                                 goto out_kfree_gso_skb;
2232                         nskb->next = skb->next;
2233                         skb->next = nskb;
2234                         return rc;
2235                 }
2236                 txq_trans_update(txq);
2237                 if (unlikely(netif_tx_queue_stopped(txq) && skb->next))
2238                         return NETDEV_TX_BUSY;
2239         } while (skb->next);
2240
2241 out_kfree_gso_skb:
2242         if (likely(skb->next == NULL))
2243                 skb->destructor = DEV_GSO_CB(skb)->destructor;
2244 out_kfree_skb:
2245         kfree_skb(skb);
2246 out:
2247         return rc;
2248 }
2249
2250 static u32 hashrnd __read_mostly;
2251
2252 /*
2253  * Returns a Tx hash based on the given packet descriptor a Tx queues' number
2254  * to be used as a distribution range.
2255  */
2256 u16 __skb_tx_hash(const struct net_device *dev, const struct sk_buff *skb,
2257                   unsigned int num_tx_queues)
2258 {
2259         u32 hash;
2260         u16 qoffset = 0;
2261         u16 qcount = num_tx_queues;
2262
2263         if (skb_rx_queue_recorded(skb)) {
2264                 hash = skb_get_rx_queue(skb);
2265                 while (unlikely(hash >= num_tx_queues))
2266                         hash -= num_tx_queues;
2267                 return hash;
2268         }
2269
2270         if (dev->num_tc) {
2271                 u8 tc = netdev_get_prio_tc_map(dev, skb->priority);
2272                 qoffset = dev->tc_to_txq[tc].offset;
2273                 qcount = dev->tc_to_txq[tc].count;
2274         }
2275
2276         if (skb->sk && skb->sk->sk_hash)
2277                 hash = skb->sk->sk_hash;
2278         else
2279                 hash = (__force u16) skb->protocol;
2280         hash = jhash_1word(hash, hashrnd);
2281
2282         return (u16) (((u64) hash * qcount) >> 32) + qoffset;
2283 }
2284 EXPORT_SYMBOL(__skb_tx_hash);
2285
2286 static inline u16 dev_cap_txqueue(struct net_device *dev, u16 queue_index)
2287 {
2288         if (unlikely(queue_index >= dev->real_num_tx_queues)) {
2289                 if (net_ratelimit()) {
2290                         pr_warning("%s selects TX queue %d, but "
2291                                 "real number of TX queues is %d\n",
2292                                 dev->name, queue_index, dev->real_num_tx_queues);
2293                 }
2294                 return 0;
2295         }
2296         return queue_index;
2297 }
2298
2299 static inline int get_xps_queue(struct net_device *dev, struct sk_buff *skb)
2300 {
2301 #ifdef CONFIG_XPS
2302         struct xps_dev_maps *dev_maps;
2303         struct xps_map *map;
2304         int queue_index = -1;
2305
2306         rcu_read_lock();
2307         dev_maps = rcu_dereference(dev->xps_maps);
2308         if (dev_maps) {
2309                 map = rcu_dereference(
2310                     dev_maps->cpu_map[raw_smp_processor_id()]);
2311                 if (map) {
2312                         if (map->len == 1)
2313                                 queue_index = map->queues[0];
2314                         else {
2315                                 u32 hash;
2316                                 if (skb->sk && skb->sk->sk_hash)
2317                                         hash = skb->sk->sk_hash;
2318                                 else
2319                                         hash = (__force u16) skb->protocol ^
2320                                             skb->rxhash;
2321                                 hash = jhash_1word(hash, hashrnd);
2322                                 queue_index = map->queues[
2323                                     ((u64)hash * map->len) >> 32];
2324                         }
2325                         if (unlikely(queue_index >= dev->real_num_tx_queues))
2326                                 queue_index = -1;
2327                 }
2328         }
2329         rcu_read_unlock();
2330
2331         return queue_index;
2332 #else
2333         return -1;
2334 #endif
2335 }
2336
2337 static struct netdev_queue *dev_pick_tx(struct net_device *dev,
2338                                         struct sk_buff *skb)
2339 {
2340         int queue_index;
2341         const struct net_device_ops *ops = dev->netdev_ops;
2342
2343         if (dev->real_num_tx_queues == 1)
2344                 queue_index = 0;
2345         else if (ops->ndo_select_queue) {
2346                 queue_index = ops->ndo_select_queue(dev, skb);
2347                 queue_index = dev_cap_txqueue(dev, queue_index);
2348         } else {
2349                 struct sock *sk = skb->sk;
2350                 queue_index = sk_tx_queue_get(sk);
2351
2352                 if (queue_index < 0 || skb->ooo_okay ||
2353                     queue_index >= dev->real_num_tx_queues) {
2354                         int old_index = queue_index;
2355
2356                         queue_index = get_xps_queue(dev, skb);
2357                         if (queue_index < 0)
2358                                 queue_index = skb_tx_hash(dev, skb);
2359
2360                         if (queue_index != old_index && sk) {
2361                                 struct dst_entry *dst =
2362                                     rcu_dereference_check(sk->sk_dst_cache, 1);
2363
2364                                 if (dst && skb_dst(skb) == dst)
2365                                         sk_tx_queue_set(sk, queue_index);
2366                         }
2367                 }
2368         }
2369
2370         skb_set_queue_mapping(skb, queue_index);
2371         return netdev_get_tx_queue(dev, queue_index);
2372 }
2373
2374 static inline int __dev_xmit_skb(struct sk_buff *skb, struct Qdisc *q,
2375                                  struct net_device *dev,
2376                                  struct netdev_queue *txq)
2377 {
2378         spinlock_t *root_lock = qdisc_lock(q);
2379         bool contended;
2380         int rc;
2381
2382         qdisc_skb_cb(skb)->pkt_len = skb->len;
2383         qdisc_calculate_pkt_len(skb, q);
2384         /*
2385          * Heuristic to force contended enqueues to serialize on a
2386          * separate lock before trying to get qdisc main lock.
2387          * This permits __QDISC_STATE_RUNNING owner to get the lock more often
2388          * and dequeue packets faster.
2389          */
2390         contended = qdisc_is_running(q);
2391         if (unlikely(contended))
2392                 spin_lock(&q->busylock);
2393
2394         spin_lock(root_lock);
2395         if (unlikely(test_bit(__QDISC_STATE_DEACTIVATED, &q->state))) {
2396                 kfree_skb(skb);
2397                 rc = NET_XMIT_DROP;
2398         } else if ((q->flags & TCQ_F_CAN_BYPASS) && !qdisc_qlen(q) &&
2399                    qdisc_run_begin(q)) {
2400                 /*
2401                  * This is a work-conserving queue; there are no old skbs
2402                  * waiting to be sent out; and the qdisc is not running -
2403                  * xmit the skb directly.
2404                  */
2405                 if (!(dev->priv_flags & IFF_XMIT_DST_RELEASE))
2406                         skb_dst_force(skb);
2407
2408                 qdisc_bstats_update(q, skb);
2409
2410                 if (sch_direct_xmit(skb, q, dev, txq, root_lock)) {
2411                         if (unlikely(contended)) {
2412                                 spin_unlock(&q->busylock);
2413                                 contended = false;
2414                         }
2415                         __qdisc_run(q);
2416                 } else
2417                         qdisc_run_end(q);
2418
2419                 rc = NET_XMIT_SUCCESS;
2420         } else {
2421                 skb_dst_force(skb);
2422                 rc = q->enqueue(skb, q) & NET_XMIT_MASK;
2423                 if (qdisc_run_begin(q)) {
2424                         if (unlikely(contended)) {
2425                                 spin_unlock(&q->busylock);
2426                                 contended = false;
2427                         }
2428                         __qdisc_run(q);
2429                 }
2430         }
2431         spin_unlock(root_lock);
2432         if (unlikely(contended))
2433                 spin_unlock(&q->busylock);
2434         return rc;
2435 }
2436
2437 static DEFINE_PER_CPU(int, xmit_recursion);
2438 #define RECURSION_LIMIT 10
2439
2440 /**
2441  *      dev_queue_xmit - transmit a buffer
2442  *      @skb: buffer to transmit
2443  *
2444  *      Queue a buffer for transmission to a network device. The caller must
2445  *      have set the device and priority and built the buffer before calling
2446  *      this function. The function can be called from an interrupt.
2447  *
2448  *      A negative errno code is returned on a failure. A success does not
2449  *      guarantee the frame will be transmitted as it may be dropped due
2450  *      to congestion or traffic shaping.
2451  *
2452  * -----------------------------------------------------------------------------------
2453  *      I notice this method can also return errors from the queue disciplines,
2454  *      including NET_XMIT_DROP, which is a positive value.  So, errors can also
2455  *      be positive.
2456  *
2457  *      Regardless of the return value, the skb is consumed, so it is currently
2458  *      difficult to retry a send to this method.  (You can bump the ref count
2459  *      before sending to hold a reference for retry if you are careful.)
2460  *
2461  *      When calling this method, interrupts MUST be enabled.  This is because
2462  *      the BH enable code must have IRQs enabled so that it will not deadlock.
2463  *          --BLG
2464  */
2465 int dev_queue_xmit(struct sk_buff *skb)
2466 {
2467         struct net_device *dev = skb->dev;
2468         struct netdev_queue *txq;
2469         struct Qdisc *q;
2470         int rc = -ENOMEM;
2471
2472         /* Disable soft irqs for various locks below. Also
2473          * stops preemption for RCU.
2474          */
2475         rcu_read_lock_bh();
2476
2477         txq = dev_pick_tx(dev, skb);
2478         q = rcu_dereference_bh(txq->qdisc);
2479
2480 #ifdef CONFIG_NET_CLS_ACT
2481         skb->tc_verd = SET_TC_AT(skb->tc_verd, AT_EGRESS);
2482 #endif
2483         trace_net_dev_queue(skb);
2484         if (q->enqueue) {
2485                 rc = __dev_xmit_skb(skb, q, dev, txq);
2486                 goto out;
2487         }
2488
2489         /* The device has no queue. Common case for software devices:
2490            loopback, all the sorts of tunnels...
2491
2492            Really, it is unlikely that netif_tx_lock protection is necessary
2493            here.  (f.e. loopback and IP tunnels are clean ignoring statistics
2494            counters.)
2495            However, it is possible, that they rely on protection
2496            made by us here.
2497
2498            Check this and shot the lock. It is not prone from deadlocks.
2499            Either shot noqueue qdisc, it is even simpler 8)
2500          */
2501         if (dev->flags & IFF_UP) {
2502                 int cpu = smp_processor_id(); /* ok because BHs are off */
2503
2504                 if (txq->xmit_lock_owner != cpu) {
2505
2506                         if (__this_cpu_read(xmit_recursion) > RECURSION_LIMIT)
2507                                 goto recursion_alert;
2508
2509                         HARD_TX_LOCK(dev, txq, cpu);
2510
2511                         if (!netif_tx_queue_stopped(txq)) {
2512                                 __this_cpu_inc(xmit_recursion);
2513                                 rc = dev_hard_start_xmit(skb, dev, txq);
2514                                 __this_cpu_dec(xmit_recursion);
2515                                 if (dev_xmit_complete(rc)) {
2516                                         HARD_TX_UNLOCK(dev, txq);
2517                                         goto out;
2518                                 }
2519                         }
2520                         HARD_TX_UNLOCK(dev, txq);
2521                         if (net_ratelimit())
2522                                 printk(KERN_CRIT "Virtual device %s asks to "
2523                                        "queue packet!\n", dev->name);
2524                 } else {
2525                         /* Recursion is detected! It is possible,
2526                          * unfortunately
2527                          */
2528 recursion_alert:
2529                         if (net_ratelimit())
2530                                 printk(KERN_CRIT "Dead loop on virtual device "
2531                                        "%s, fix it urgently!\n", dev->name);
2532                 }
2533         }
2534
2535         rc = -ENETDOWN;
2536         rcu_read_unlock_bh();
2537
2538         kfree_skb(skb);
2539         return rc;
2540 out:
2541         rcu_read_unlock_bh();
2542         return rc;
2543 }
2544 EXPORT_SYMBOL(dev_queue_xmit);
2545
2546
2547 /*=======================================================================
2548                         Receiver routines
2549   =======================================================================*/
2550
2551 int netdev_max_backlog __read_mostly = 1000;
2552 int netdev_tstamp_prequeue __read_mostly = 1;
2553 int netdev_budget __read_mostly = 300;
2554 int weight_p __read_mostly = 64;            /* old backlog weight */
2555
2556 /* Called with irq disabled */
2557 static inline void ____napi_schedule(struct softnet_data *sd,
2558                                      struct napi_struct *napi)
2559 {
2560         list_add_tail(&napi->poll_list, &sd->poll_list);
2561         __raise_softirq_irqoff(NET_RX_SOFTIRQ);
2562 }
2563
2564 /*
2565  * __skb_get_rxhash: calculate a flow hash based on src/dst addresses
2566  * and src/dst port numbers.  Sets rxhash in skb to non-zero hash value
2567  * on success, zero indicates no valid hash.  Also, sets l4_rxhash in skb
2568  * if hash is a canonical 4-tuple hash over transport ports.
2569  */
2570 void __skb_get_rxhash(struct sk_buff *skb)
2571 {
2572         int nhoff, hash = 0, poff;
2573         const struct ipv6hdr *ip6;
2574         const struct iphdr *ip;
2575         const struct vlan_hdr *vlan;
2576         u8 ip_proto;
2577         u32 addr1, addr2;
2578         u16 proto;
2579         union {
2580                 u32 v32;
2581                 u16 v16[2];
2582         } ports;
2583
2584         nhoff = skb_network_offset(skb);
2585         proto = skb->protocol;
2586
2587 again:
2588         switch (proto) {
2589         case __constant_htons(ETH_P_IP):
2590 ip:
2591                 if (!pskb_may_pull(skb, sizeof(*ip) + nhoff))
2592                         goto done;
2593
2594                 ip = (const struct iphdr *) (skb->data + nhoff);
2595                 if (ip_is_fragment(ip))
2596                         ip_proto = 0;
2597                 else
2598                         ip_proto = ip->protocol;
2599                 addr1 = (__force u32) ip->saddr;
2600                 addr2 = (__force u32) ip->daddr;
2601                 nhoff += ip->ihl * 4;
2602                 break;
2603         case __constant_htons(ETH_P_IPV6):
2604 ipv6:
2605                 if (!pskb_may_pull(skb, sizeof(*ip6) + nhoff))
2606                         goto done;
2607
2608                 ip6 = (const struct ipv6hdr *) (skb->data + nhoff);
2609                 ip_proto = ip6->nexthdr;
2610                 addr1 = (__force u32) ip6->saddr.s6_addr32[3];
2611                 addr2 = (__force u32) ip6->daddr.s6_addr32[3];
2612                 nhoff += 40;
2613                 break;
2614         case __constant_htons(ETH_P_8021Q):
2615                 if (!pskb_may_pull(skb, sizeof(*vlan) + nhoff))
2616                         goto done;
2617                 vlan = (const struct vlan_hdr *) (skb->data + nhoff);
2618                 proto = vlan->h_vlan_encapsulated_proto;
2619                 nhoff += sizeof(*vlan);
2620                 goto again;
2621         case __constant_htons(ETH_P_PPP_SES):
2622                 if (!pskb_may_pull(skb, PPPOE_SES_HLEN + nhoff))
2623                         goto done;
2624                 proto = *((__be16 *) (skb->data + nhoff +
2625                                       sizeof(struct pppoe_hdr)));
2626                 nhoff += PPPOE_SES_HLEN;
2627                 switch (proto) {
2628                 case __constant_htons(PPP_IP):
2629                         goto ip;
2630                 case __constant_htons(PPP_IPV6):
2631                         goto ipv6;
2632                 default:
2633                         goto done;
2634                 }
2635         default:
2636                 goto done;
2637         }
2638
2639         switch (ip_proto) {
2640         case IPPROTO_GRE:
2641                 if (pskb_may_pull(skb, nhoff + 16)) {
2642                         u8 *h = skb->data + nhoff;
2643                         __be16 flags = *(__be16 *)h;
2644
2645                         /*
2646                          * Only look inside GRE if version zero and no
2647                          * routing
2648                          */
2649                         if (!(flags & (GRE_VERSION|GRE_ROUTING))) {
2650                                 proto = *(__be16 *)(h + 2);
2651                                 nhoff += 4;
2652                                 if (flags & GRE_CSUM)
2653                                         nhoff += 4;
2654                                 if (flags & GRE_KEY)
2655                                         nhoff += 4;
2656                                 if (flags & GRE_SEQ)
2657                                         nhoff += 4;
2658                                 goto again;
2659                         }
2660                 }
2661                 break;
2662         case IPPROTO_IPIP:
2663                 goto again;
2664         default:
2665                 break;
2666         }
2667
2668         ports.v32 = 0;
2669         poff = proto_ports_offset(ip_proto);
2670         if (poff >= 0) {
2671                 nhoff += poff;
2672                 if (pskb_may_pull(skb, nhoff + 4)) {
2673                         ports.v32 = * (__force u32 *) (skb->data + nhoff);
2674                         if (ports.v16[1] < ports.v16[0])
2675                                 swap(ports.v16[0], ports.v16[1]);
2676                         skb->l4_rxhash = 1;
2677                 }
2678         }
2679
2680         /* get a consistent hash (same value on both flow directions) */
2681         if (addr2 < addr1)
2682                 swap(addr1, addr2);
2683
2684         hash = jhash_3words(addr1, addr2, ports.v32, hashrnd);
2685         if (!hash)
2686                 hash = 1;
2687
2688 done:
2689         skb->rxhash = hash;
2690 }
2691 EXPORT_SYMBOL(__skb_get_rxhash);
2692
2693 #ifdef CONFIG_RPS
2694
2695 /* One global table that all flow-based protocols share. */
2696 struct rps_sock_flow_table __rcu *rps_sock_flow_table __read_mostly;
2697 EXPORT_SYMBOL(rps_sock_flow_table);
2698
2699 static struct rps_dev_flow *
2700 set_rps_cpu(struct net_device *dev, struct sk_buff *skb,
2701             struct rps_dev_flow *rflow, u16 next_cpu)
2702 {
2703         if (next_cpu != RPS_NO_CPU) {
2704 #ifdef CONFIG_RFS_ACCEL
2705                 struct netdev_rx_queue *rxqueue;
2706                 struct rps_dev_flow_table *flow_table;
2707                 struct rps_dev_flow *old_rflow;
2708                 u32 flow_id;
2709                 u16 rxq_index;
2710                 int rc;
2711
2712                 /* Should we steer this flow to a different hardware queue? */
2713                 if (!skb_rx_queue_recorded(skb) || !dev->rx_cpu_rmap ||
2714                     !(dev->features & NETIF_F_NTUPLE))
2715                         goto out;
2716                 rxq_index = cpu_rmap_lookup_index(dev->rx_cpu_rmap, next_cpu);
2717                 if (rxq_index == skb_get_rx_queue(skb))
2718                         goto out;
2719
2720                 rxqueue = dev->_rx + rxq_index;
2721                 flow_table = rcu_dereference(rxqueue->rps_flow_table);
2722                 if (!flow_table)
2723                         goto out;
2724                 flow_id = skb->rxhash & flow_table->mask;
2725                 rc = dev->netdev_ops->ndo_rx_flow_steer(dev, skb,
2726                                                         rxq_index, flow_id);
2727                 if (rc < 0)
2728                         goto out;
2729                 old_rflow = rflow;
2730                 rflow = &flow_table->flows[flow_id];
2731                 rflow->filter = rc;
2732                 if (old_rflow->filter == rflow->filter)
2733                         old_rflow->filter = RPS_NO_FILTER;
2734         out:
2735 #endif
2736                 rflow->last_qtail =
2737                         per_cpu(softnet_data, next_cpu).input_queue_head;
2738         }
2739
2740         rflow->cpu = next_cpu;
2741         return rflow;
2742 }
2743
2744 /*
2745  * get_rps_cpu is called from netif_receive_skb and returns the target
2746  * CPU from the RPS map of the receiving queue for a given skb.
2747  * rcu_read_lock must be held on entry.
2748  */
2749 static int get_rps_cpu(struct net_device *dev, struct sk_buff *skb,
2750                        struct rps_dev_flow **rflowp)
2751 {
2752         struct netdev_rx_queue *rxqueue;
2753         struct rps_map *map;
2754         struct rps_dev_flow_table *flow_table;
2755         struct rps_sock_flow_table *sock_flow_table;
2756         int cpu = -1;
2757         u16 tcpu;
2758
2759         if (skb_rx_queue_recorded(skb)) {
2760                 u16 index = skb_get_rx_queue(skb);
2761                 if (unlikely(index >= dev->real_num_rx_queues)) {
2762                         WARN_ONCE(dev->real_num_rx_queues > 1,
2763                                   "%s received packet on queue %u, but number "
2764                                   "of RX queues is %u\n",
2765                                   dev->name, index, dev->real_num_rx_queues);
2766                         goto done;
2767                 }
2768                 rxqueue = dev->_rx + index;
2769         } else
2770                 rxqueue = dev->_rx;
2771
2772         map = rcu_dereference(rxqueue->rps_map);
2773         if (map) {
2774                 if (map->len == 1 &&
2775                     !rcu_access_pointer(rxqueue->rps_flow_table)) {
2776                         tcpu = map->cpus[0];
2777                         if (cpu_online(tcpu))
2778                                 cpu = tcpu;
2779                         goto done;
2780                 }
2781         } else if (!rcu_access_pointer(rxqueue->rps_flow_table)) {
2782                 goto done;
2783         }
2784
2785         skb_reset_network_header(skb);
2786         if (!skb_get_rxhash(skb))
2787                 goto done;
2788
2789         flow_table = rcu_dereference(rxqueue->rps_flow_table);
2790         sock_flow_table = rcu_dereference(rps_sock_flow_table);
2791         if (flow_table && sock_flow_table) {
2792                 u16 next_cpu;
2793                 struct rps_dev_flow *rflow;
2794
2795                 rflow = &flow_table->flows[skb->rxhash & flow_table->mask];
2796                 tcpu = rflow->cpu;
2797
2798                 next_cpu = sock_flow_table->ents[skb->rxhash &
2799                     sock_flow_table->mask];
2800
2801                 /*
2802                  * If the desired CPU (where last recvmsg was done) is
2803                  * different from current CPU (one in the rx-queue flow
2804                  * table entry), switch if one of the following holds:
2805                  *   - Current CPU is unset (equal to RPS_NO_CPU).
2806                  *   - Current CPU is offline.
2807                  *   - The current CPU's queue tail has advanced beyond the
2808                  *     last packet that was enqueued using this table entry.
2809                  *     This guarantees that all previous packets for the flow
2810                  *     have been dequeued, thus preserving in order delivery.
2811                  */
2812                 if (unlikely(tcpu != next_cpu) &&
2813                     (tcpu == RPS_NO_CPU || !cpu_online(tcpu) ||
2814                      ((int)(per_cpu(softnet_data, tcpu).input_queue_head -
2815                       rflow->last_qtail)) >= 0))
2816                         rflow = set_rps_cpu(dev, skb, rflow, next_cpu);
2817
2818                 if (tcpu != RPS_NO_CPU && cpu_online(tcpu)) {
2819                         *rflowp = rflow;
2820                         cpu = tcpu;
2821                         goto done;
2822                 }
2823         }
2824
2825         if (map) {
2826                 tcpu = map->cpus[((u64) skb->rxhash * map->len) >> 32];
2827
2828                 if (cpu_online(tcpu)) {
2829                         cpu = tcpu;
2830                         goto done;
2831                 }
2832         }
2833
2834 done:
2835         return cpu;
2836 }
2837
2838 #ifdef CONFIG_RFS_ACCEL
2839
2840 /**
2841  * rps_may_expire_flow - check whether an RFS hardware filter may be removed
2842  * @dev: Device on which the filter was set
2843  * @rxq_index: RX queue index
2844  * @flow_id: Flow ID passed to ndo_rx_flow_steer()
2845  * @filter_id: Filter ID returned by ndo_rx_flow_steer()
2846  *
2847  * Drivers that implement ndo_rx_flow_steer() should periodically call
2848  * this function for each installed filter and remove the filters for
2849  * which it returns %true.
2850  */
2851 bool rps_may_expire_flow(struct net_device *dev, u16 rxq_index,
2852                          u32 flow_id, u16 filter_id)
2853 {
2854         struct netdev_rx_queue *rxqueue = dev->_rx + rxq_index;
2855         struct rps_dev_flow_table *flow_table;
2856         struct rps_dev_flow *rflow;
2857         bool expire = true;
2858         int cpu;
2859
2860         rcu_read_lock();
2861         flow_table = rcu_dereference(rxqueue->rps_flow_table);
2862         if (flow_table && flow_id <= flow_table->mask) {
2863                 rflow = &flow_table->flows[flow_id];
2864                 cpu = ACCESS_ONCE(rflow->cpu);
2865                 if (rflow->filter == filter_id && cpu != RPS_NO_CPU &&
2866                     ((int)(per_cpu(softnet_data, cpu).input_queue_head -
2867                            rflow->last_qtail) <
2868                      (int)(10 * flow_table->mask)))
2869                         expire = false;
2870         }
2871         rcu_read_unlock();
2872         return expire;
2873 }
2874 EXPORT_SYMBOL(rps_may_expire_flow);
2875
2876 #endif /* CONFIG_RFS_ACCEL */
2877
2878 /* Called from hardirq (IPI) context */
2879 static void rps_trigger_softirq(void *data)
2880 {
2881         struct softnet_data *sd = data;
2882
2883         ____napi_schedule(sd, &sd->backlog);
2884         sd->received_rps++;
2885 }
2886
2887 #endif /* CONFIG_RPS */
2888
2889 /*
2890  * Check if this softnet_data structure is another cpu one
2891  * If yes, queue it to our IPI list and return 1
2892  * If no, return 0
2893  */
2894 static int rps_ipi_queued(struct softnet_data *sd)
2895 {
2896 #ifdef CONFIG_RPS
2897         struct softnet_data *mysd = &__get_cpu_var(softnet_data);
2898
2899         if (sd != mysd) {
2900                 sd->rps_ipi_next = mysd->rps_ipi_list;
2901                 mysd->rps_ipi_list = sd;
2902
2903                 __raise_softirq_irqoff(NET_RX_SOFTIRQ);
2904                 return 1;
2905         }
2906 #endif /* CONFIG_RPS */
2907         return 0;
2908 }
2909
2910 /*
2911  * enqueue_to_backlog is called to queue an skb to a per CPU backlog
2912  * queue (may be a remote CPU queue).
2913  */
2914 static int enqueue_to_backlog(struct sk_buff *skb, int cpu,
2915                               unsigned int *qtail)
2916 {
2917         struct softnet_data *sd;
2918         unsigned long flags;
2919
2920         sd = &per_cpu(softnet_data, cpu);
2921
2922         local_irq_save(flags);
2923
2924         rps_lock(sd);
2925         if (skb_queue_len(&sd->input_pkt_queue) <= netdev_max_backlog) {
2926                 if (skb_queue_len(&sd->input_pkt_queue)) {
2927 enqueue:
2928                         __skb_queue_tail(&sd->input_pkt_queue, skb);
2929                         input_queue_tail_incr_save(sd, qtail);
2930                         rps_unlock(sd);
2931                         local_irq_restore(flags);
2932                         return NET_RX_SUCCESS;
2933                 }
2934
2935                 /* Schedule NAPI for backlog device
2936                  * We can use non atomic operation since we own the queue lock
2937                  */
2938                 if (!__test_and_set_bit(NAPI_STATE_SCHED, &sd->backlog.state)) {
2939                         if (!rps_ipi_queued(sd))
2940                                 ____napi_schedule(sd, &sd->backlog);
2941                 }
2942                 goto enqueue;
2943         }
2944
2945         sd->dropped++;
2946         rps_unlock(sd);
2947
2948         local_irq_restore(flags);
2949
2950         atomic_long_inc(&skb->dev->rx_dropped);
2951         kfree_skb(skb);
2952         return NET_RX_DROP;
2953 }
2954
2955 /**
2956  *      netif_rx        -       post buffer to the network code
2957  *      @skb: buffer to post
2958  *
2959  *      This function receives a packet from a device driver and queues it for
2960  *      the upper (protocol) levels to process.  It always succeeds. The buffer
2961  *      may be dropped during processing for congestion control or by the
2962  *      protocol layers.
2963  *
2964  *      return values:
2965  *      NET_RX_SUCCESS  (no congestion)
2966  *      NET_RX_DROP     (packet was dropped)
2967  *
2968  */
2969
2970 int netif_rx(struct sk_buff *skb)
2971 {
2972         int ret;
2973
2974         /* if netpoll wants it, pretend we never saw it */
2975         if (netpoll_rx(skb))
2976                 return NET_RX_DROP;
2977
2978         if (netdev_tstamp_prequeue)
2979                 net_timestamp_check(skb);
2980
2981         trace_netif_rx(skb);
2982 #ifdef CONFIG_RPS
2983         {
2984                 struct rps_dev_flow voidflow, *rflow = &voidflow;
2985                 int cpu;
2986
2987                 preempt_disable();
2988                 rcu_read_lock();
2989
2990                 cpu = get_rps_cpu(skb->dev, skb, &rflow);
2991                 if (cpu < 0)
2992                         cpu = smp_processor_id();
2993
2994                 ret = enqueue_to_backlog(skb, cpu, &rflow->last_qtail);
2995
2996                 rcu_read_unlock();
2997                 preempt_enable();
2998         }
2999 #else
3000         {
3001                 unsigned int qtail;
3002                 ret = enqueue_to_backlog(skb, get_cpu(), &qtail);
3003                 put_cpu();
3004         }
3005 #endif
3006         return ret;
3007 }
3008 EXPORT_SYMBOL(netif_rx);
3009
3010 int netif_rx_ni(struct sk_buff *skb)
3011 {
3012         int err;
3013
3014         preempt_disable();
3015         err = netif_rx(skb);
3016         if (local_softirq_pending())
3017                 do_softirq();
3018         preempt_enable();
3019
3020         return err;
3021 }
3022 EXPORT_SYMBOL(netif_rx_ni);
3023
3024 static void net_tx_action(struct softirq_action *h)
3025 {
3026         struct softnet_data *sd = &__get_cpu_var(softnet_data);
3027
3028         if (sd->completion_queue) {
3029                 struct sk_buff *clist;
3030
3031                 local_irq_disable();
3032                 clist = sd->completion_queue;
3033                 sd->completion_queue = NULL;
3034                 local_irq_enable();
3035
3036                 while (clist) {
3037                         struct sk_buff *skb = clist;
3038                         clist = clist->next;
3039
3040                         WARN_ON(atomic_read(&skb->users));
3041                         trace_kfree_skb(skb, net_tx_action);
3042                         __kfree_skb(skb);
3043                 }
3044         }
3045
3046         if (sd->output_queue) {
3047                 struct Qdisc *head;
3048
3049                 local_irq_disable();
3050                 head = sd->output_queue;
3051                 sd->output_queue = NULL;
3052                 sd->output_queue_tailp = &sd->output_queue;
3053                 local_irq_enable();
3054
3055                 while (head) {
3056                         struct Qdisc *q = head;
3057                         spinlock_t *root_lock;
3058
3059                         head = head->next_sched;
3060
3061                         root_lock = qdisc_lock(q);
3062                         if (spin_trylock(root_lock)) {
3063                                 smp_mb__before_clear_bit();
3064                                 clear_bit(__QDISC_STATE_SCHED,
3065                                           &q->state);
3066                                 qdisc_run(q);
3067                                 spin_unlock(root_lock);
3068                         } else {
3069                                 if (!test_bit(__QDISC_STATE_DEACTIVATED,
3070                                               &q->state)) {
3071                                         __netif_reschedule(q);
3072                                 } else {
3073                                         smp_mb__before_clear_bit();
3074                                         clear_bit(__QDISC_STATE_SCHED,
3075                                                   &q->state);
3076                                 }
3077                         }
3078                 }
3079         }
3080 }
3081
3082 #if (defined(CONFIG_BRIDGE) || defined(CONFIG_BRIDGE_MODULE)) && \
3083     (defined(CONFIG_ATM_LANE) || defined(CONFIG_ATM_LANE_MODULE))
3084 /* This hook is defined here for ATM LANE */
3085 int (*br_fdb_test_addr_hook)(struct net_device *dev,
3086                              unsigned char *addr) __read_mostly;
3087 EXPORT_SYMBOL_GPL(br_fdb_test_addr_hook);
3088 #endif
3089
3090 #ifdef CONFIG_NET_CLS_ACT
3091 /* TODO: Maybe we should just force sch_ingress to be compiled in
3092  * when CONFIG_NET_CLS_ACT is? otherwise some useless instructions
3093  * a compare and 2 stores extra right now if we dont have it on
3094  * but have CONFIG_NET_CLS_ACT
3095  * NOTE: This doesn't stop any functionality; if you dont have
3096  * the ingress scheduler, you just can't add policies on ingress.
3097  *
3098  */
3099 static int ing_filter(struct sk_buff *skb, struct netdev_queue *rxq)
3100 {
3101         struct net_device *dev = skb->dev;
3102         u32 ttl = G_TC_RTTL(skb->tc_verd);
3103         int result = TC_ACT_OK;
3104         struct Qdisc *q;
3105
3106         if (unlikely(MAX_RED_LOOP < ttl++)) {
3107                 if (net_ratelimit())
3108                         pr_warning( "Redir loop detected Dropping packet (%d->%d)\n",
3109                                skb->skb_iif, dev->ifindex);
3110                 return TC_ACT_SHOT;
3111         }
3112
3113         skb->tc_verd = SET_TC_RTTL(skb->tc_verd, ttl);
3114         skb->tc_verd = SET_TC_AT(skb->tc_verd, AT_INGRESS);
3115
3116         q = rxq->qdisc;
3117         if (q != &noop_qdisc) {
3118                 spin_lock(qdisc_lock(q));
3119                 if (likely(!test_bit(__QDISC_STATE_DEACTIVATED, &q->state)))
3120                         result = qdisc_enqueue_root(skb, q);
3121                 spin_unlock(qdisc_lock(q));
3122         }
3123
3124         return result;
3125 }
3126
3127 static inline struct sk_buff *handle_ing(struct sk_buff *skb,
3128                                          struct packet_type **pt_prev,
3129                                          int *ret, struct net_device *orig_dev)
3130 {
3131         struct netdev_queue *rxq = rcu_dereference(skb->dev->ingress_queue);
3132
3133         if (!rxq || rxq->qdisc == &noop_qdisc)
3134                 goto out;
3135
3136         if (*pt_prev) {
3137                 *ret = deliver_skb(skb, *pt_prev, orig_dev);
3138                 *pt_prev = NULL;
3139         }
3140
3141         switch (ing_filter(skb, rxq)) {
3142         case TC_ACT_SHOT:
3143         case TC_ACT_STOLEN:
3144                 kfree_skb(skb);
3145                 return NULL;
3146         }
3147
3148 out:
3149         skb->tc_verd = 0;
3150         return skb;
3151 }
3152 #endif
3153
3154 /**
3155  *      netdev_rx_handler_register - register receive handler
3156  *      @dev: device to register a handler for
3157  *      @rx_handler: receive handler to register
3158  *      @rx_handler_data: data pointer that is used by rx handler
3159  *
3160  *      Register a receive hander for a device. This handler will then be
3161  *      called from __netif_receive_skb. A negative errno code is returned
3162  *      on a failure.
3163  *
3164  *      The caller must hold the rtnl_mutex.
3165  *
3166  *      For a general description of rx_handler, see enum rx_handler_result.
3167  */
3168 int netdev_rx_handler_register(struct net_device *dev,
3169                                rx_handler_func_t *rx_handler,
3170                                void *rx_handler_data)
3171 {
3172         ASSERT_RTNL();
3173
3174         if (dev->rx_handler)
3175                 return -EBUSY;
3176
3177         rcu_assign_pointer(dev->rx_handler_data, rx_handler_data);
3178         rcu_assign_pointer(dev->rx_handler, rx_handler);
3179
3180         return 0;
3181 }
3182 EXPORT_SYMBOL_GPL(netdev_rx_handler_register);
3183
3184 /**
3185  *      netdev_rx_handler_unregister - unregister receive handler
3186  *      @dev: device to unregister a handler from
3187  *
3188  *      Unregister a receive hander from a device.
3189  *
3190  *      The caller must hold the rtnl_mutex.
3191  */
3192 void netdev_rx_handler_unregister(struct net_device *dev)
3193 {
3194
3195         ASSERT_RTNL();
3196         RCU_INIT_POINTER(dev->rx_handler, NULL);
3197         RCU_INIT_POINTER(dev->rx_handler_data, NULL);
3198 }
3199 EXPORT_SYMBOL_GPL(netdev_rx_handler_unregister);
3200
3201 static int __netif_receive_skb(struct sk_buff *skb)
3202 {
3203         struct packet_type *ptype, *pt_prev;
3204         rx_handler_func_t *rx_handler;
3205         struct net_device *orig_dev;
3206         struct net_device *null_or_dev;
3207         bool deliver_exact = false;
3208         int ret = NET_RX_DROP;
3209         __be16 type;
3210
3211         if (!netdev_tstamp_prequeue)
3212                 net_timestamp_check(skb);
3213
3214         trace_netif_receive_skb(skb);
3215
3216         /* if we've gotten here through NAPI, check netpoll */
3217         if (netpoll_receive_skb(skb))
3218                 return NET_RX_DROP;
3219
3220         if (!skb->skb_iif)
3221                 skb->skb_iif = skb->dev->ifindex;
3222         orig_dev = skb->dev;
3223
3224         skb_reset_network_header(skb);
3225         skb_reset_transport_header(skb);
3226         skb_reset_mac_len(skb);
3227
3228         pt_prev = NULL;
3229
3230         rcu_read_lock();
3231
3232 another_round:
3233
3234         __this_cpu_inc(softnet_data.processed);
3235
3236         if (skb->protocol == cpu_to_be16(ETH_P_8021Q)) {
3237                 skb = vlan_untag(skb);
3238                 if (unlikely(!skb))
3239                         goto out;
3240         }
3241
3242 #ifdef CONFIG_NET_CLS_ACT
3243         if (skb->tc_verd & TC_NCLS) {
3244                 skb->tc_verd = CLR_TC_NCLS(skb->tc_verd);
3245                 goto ncls;
3246         }
3247 #endif
3248
3249         list_for_each_entry_rcu(ptype, &ptype_all, list) {
3250                 if (!ptype->dev || ptype->dev == skb->dev) {
3251                         if (pt_prev)
3252                                 ret = deliver_skb(skb, pt_prev, orig_dev);
3253                         pt_prev = ptype;
3254                 }
3255         }
3256
3257 #ifdef CONFIG_NET_CLS_ACT
3258         skb = handle_ing(skb, &pt_prev, &ret, orig_dev);
3259         if (!skb)
3260                 goto out;
3261 ncls:
3262 #endif
3263
3264         rx_handler = rcu_dereference(skb->dev->rx_handler);
3265         if (vlan_tx_tag_present(skb)) {
3266                 if (pt_prev) {
3267                         ret = deliver_skb(skb, pt_prev, orig_dev);
3268                         pt_prev = NULL;
3269                 }
3270                 if (vlan_do_receive(&skb, !rx_handler))
3271                         goto another_round;
3272                 else if (unlikely(!skb))
3273                         goto out;
3274         }
3275
3276         if (rx_handler) {
3277                 if (pt_prev) {
3278                         ret = deliver_skb(skb, pt_prev, orig_dev);
3279                         pt_prev = NULL;
3280                 }
3281                 switch (rx_handler(&skb)) {
3282                 case RX_HANDLER_CONSUMED:
3283                         goto out;
3284                 case RX_HANDLER_ANOTHER:
3285                         goto another_round;
3286                 case RX_HANDLER_EXACT:
3287                         deliver_exact = true;
3288                 case RX_HANDLER_PASS:
3289                         break;
3290                 default:
3291                         BUG();
3292                 }
3293         }
3294
3295         /* deliver only exact match when indicated */
3296         null_or_dev = deliver_exact ? skb->dev : NULL;
3297
3298         type = skb->protocol;
3299         list_for_each_entry_rcu(ptype,
3300                         &ptype_base[ntohs(type) & PTYPE_HASH_MASK], list) {
3301                 if (ptype->type == type &&
3302                     (ptype->dev == null_or_dev || ptype->dev == skb->dev ||
3303                      ptype->dev == orig_dev)) {
3304                         if (pt_prev)
3305                                 ret = deliver_skb(skb, pt_prev, orig_dev);
3306                         pt_prev = ptype;
3307                 }
3308         }
3309
3310         if (pt_prev) {
3311                 ret = pt_prev->func(skb, skb->dev, pt_prev, orig_dev);
3312         } else {
3313                 atomic_long_inc(&skb->dev->rx_dropped);
3314                 kfree_skb(skb);
3315                 /* Jamal, now you will not able to escape explaining
3316                  * me how you were going to use this. :-)
3317                  */
3318                 ret = NET_RX_DROP;
3319         }
3320
3321 out:
3322         rcu_read_unlock();
3323         return ret;
3324 }
3325
3326 /**
3327  *      netif_receive_skb - process receive buffer from network
3328  *      @skb: buffer to process
3329  *
3330  *      netif_receive_skb() is the main receive data processing function.
3331  *      It always succeeds. The buffer may be dropped during processing
3332  *      for congestion control or by the protocol layers.
3333  *
3334  *      This function may only be called from softirq context and interrupts
3335  *      should be enabled.
3336  *
3337  *      Return values (usually ignored):
3338  *      NET_RX_SUCCESS: no congestion
3339  *      NET_RX_DROP: packet was dropped
3340  */
3341 int netif_receive_skb(struct sk_buff *skb)
3342 {
3343         if (netdev_tstamp_prequeue)
3344                 net_timestamp_check(skb);
3345
3346         if (skb_defer_rx_timestamp(skb))
3347                 return NET_RX_SUCCESS;
3348
3349 #ifdef CONFIG_RPS
3350         {
3351                 struct rps_dev_flow voidflow, *rflow = &voidflow;
3352                 int cpu, ret;
3353
3354                 rcu_read_lock();
3355
3356                 cpu = get_rps_cpu(skb->dev, skb, &rflow);
3357
3358                 if (cpu >= 0) {
3359                         ret = enqueue_to_backlog(skb, cpu, &rflow->last_qtail);
3360                         rcu_read_unlock();
3361                 } else {
3362                         rcu_read_unlock();
3363                         ret = __netif_receive_skb(skb);
3364                 }
3365
3366                 return ret;
3367         }
3368 #else
3369         return __netif_receive_skb(skb);
3370 #endif
3371 }
3372 EXPORT_SYMBOL(netif_receive_skb);
3373
3374 /* Network device is going away, flush any packets still pending
3375  * Called with irqs disabled.
3376  */
3377 static void flush_backlog(void *arg)
3378 {
3379         struct net_device *dev = arg;
3380         struct softnet_data *sd = &__get_cpu_var(softnet_data);
3381         struct sk_buff *skb, *tmp;
3382
3383         rps_lock(sd);
3384         skb_queue_walk_safe(&sd->input_pkt_queue, skb, tmp) {
3385                 if (skb->dev == dev) {
3386                         __skb_unlink(skb, &sd->input_pkt_queue);
3387                         kfree_skb(skb);
3388                         input_queue_head_incr(sd);
3389                 }
3390         }
3391         rps_unlock(sd);
3392
3393         skb_queue_walk_safe(&sd->process_queue, skb, tmp) {
3394                 if (skb->dev == dev) {
3395                         __skb_unlink(skb, &sd->process_queue);
3396                         kfree_skb(skb);
3397                         input_queue_head_incr(sd);
3398                 }
3399         }
3400 }
3401
3402 static int napi_gro_complete(struct sk_buff *skb)
3403 {
3404         struct packet_type *ptype;
3405         __be16 type = skb->protocol;
3406         struct list_head *head = &ptype_base[ntohs(type) & PTYPE_HASH_MASK];
3407         int err = -ENOENT;
3408
3409         if (NAPI_GRO_CB(skb)->count == 1) {
3410                 skb_shinfo(skb)->gso_size = 0;
3411                 goto out;
3412         }
3413
3414         rcu_read_lock();
3415         list_for_each_entry_rcu(ptype, head, list) {
3416                 if (ptype->type != type || ptype->dev || !ptype->gro_complete)
3417                         continue;
3418
3419                 err = ptype->gro_complete(skb);
3420                 break;
3421         }
3422         rcu_read_unlock();
3423
3424         if (err) {
3425                 WARN_ON(&ptype->list == head);
3426                 kfree_skb(skb);
3427                 return NET_RX_SUCCESS;
3428         }
3429
3430 out:
3431         return netif_receive_skb(skb);
3432 }
3433
3434 inline void napi_gro_flush(struct napi_struct *napi)
3435 {
3436         struct sk_buff *skb, *next;
3437
3438         for (skb = napi->gro_list; skb; skb = next) {
3439                 next = skb->next;
3440                 skb->next = NULL;
3441                 napi_gro_complete(skb);
3442         }
3443
3444         napi->gro_count = 0;
3445         napi->gro_list = NULL;
3446 }
3447 EXPORT_SYMBOL(napi_gro_flush);
3448
3449 enum gro_result dev_gro_receive(struct napi_struct *napi, struct sk_buff *skb)
3450 {
3451         struct sk_buff **pp = NULL;
3452         struct packet_type *ptype;
3453         __be16 type = skb->protocol;
3454         struct list_head *head = &ptype_base[ntohs(type) & PTYPE_HASH_MASK];
3455         int same_flow;
3456         int mac_len;
3457         enum gro_result ret;
3458
3459         if (!(skb->dev->features & NETIF_F_GRO) || netpoll_rx_on(skb))
3460                 goto normal;
3461
3462         if (skb_is_gso(skb) || skb_has_frag_list(skb))
3463                 goto normal;
3464
3465         rcu_read_lock();
3466         list_for_each_entry_rcu(ptype, head, list) {
3467                 if (ptype->type != type || ptype->dev || !ptype->gro_receive)
3468                         continue;
3469
3470                 skb_set_network_header(skb, skb_gro_offset(skb));
3471                 mac_len = skb->network_header - skb->mac_header;
3472                 skb->mac_len = mac_len;
3473                 NAPI_GRO_CB(skb)->same_flow = 0;
3474                 NAPI_GRO_CB(skb)->flush = 0;
3475                 NAPI_GRO_CB(skb)->free = 0;
3476
3477                 pp = ptype->gro_receive(&napi->gro_list, skb);
3478                 break;
3479         }
3480         rcu_read_unlock();
3481
3482         if (&ptype->list == head)
3483                 goto normal;
3484
3485         same_flow = NAPI_GRO_CB(skb)->same_flow;
3486         ret = NAPI_GRO_CB(skb)->free ? GRO_MERGED_FREE : GRO_MERGED;
3487
3488         if (pp) {
3489                 struct sk_buff *nskb = *pp;
3490
3491                 *pp = nskb->next;
3492                 nskb->next = NULL;
3493                 napi_gro_complete(nskb);
3494                 napi->gro_count--;
3495         }
3496
3497         if (same_flow)
3498                 goto ok;
3499
3500         if (NAPI_GRO_CB(skb)->flush || napi->gro_count >= MAX_GRO_SKBS)
3501                 goto normal;
3502
3503         napi->gro_count++;
3504         NAPI_GRO_CB(skb)->count = 1;
3505         skb_shinfo(skb)->gso_size = skb_gro_len(skb);
3506         skb->next = napi->gro_list;
3507         napi->gro_list = skb;
3508         ret = GRO_HELD;
3509
3510 pull:
3511         if (skb_headlen(skb) < skb_gro_offset(skb)) {
3512                 int grow = skb_gro_offset(skb) - skb_headlen(skb);
3513
3514                 BUG_ON(skb->end - skb->tail < grow);
3515
3516                 memcpy(skb_tail_pointer(skb), NAPI_GRO_CB(skb)->frag0, grow);
3517
3518                 skb->tail += grow;
3519                 skb->data_len -= grow;
3520
3521                 skb_shinfo(skb)->frags[0].page_offset += grow;
3522                 skb_frag_size_sub(&skb_shinfo(skb)->frags[0], grow);
3523
3524                 if (unlikely(!skb_frag_size(&skb_shinfo(skb)->frags[0]))) {
3525                         skb_frag_unref(skb, 0);
3526                         memmove(skb_shinfo(skb)->frags,
3527                                 skb_shinfo(skb)->frags + 1,
3528                                 --skb_shinfo(skb)->nr_frags * sizeof(skb_frag_t));
3529                 }
3530         }
3531
3532 ok:
3533         return ret;
3534
3535 normal:
3536         ret = GRO_NORMAL;
3537         goto pull;
3538 }
3539 EXPORT_SYMBOL(dev_gro_receive);
3540
3541 static inline gro_result_t
3542 __napi_gro_receive(struct napi_struct *napi, struct sk_buff *skb)
3543 {
3544         struct sk_buff *p;
3545         unsigned int maclen = skb->dev->hard_header_len;
3546
3547         for (p = napi->gro_list; p; p = p->next) {
3548                 unsigned long diffs;
3549
3550                 diffs = (unsigned long)p->dev ^ (unsigned long)skb->dev;
3551                 diffs |= p->vlan_tci ^ skb->vlan_tci;
3552                 if (maclen == ETH_HLEN)
3553                         diffs |= compare_ether_header(skb_mac_header(p),
3554                                                       skb_gro_mac_header(skb));
3555                 else if (!diffs)
3556                         diffs = memcmp(skb_mac_header(p),
3557                                        skb_gro_mac_header(skb),
3558                                        maclen);
3559                 NAPI_GRO_CB(p)->same_flow = !diffs;
3560                 NAPI_GRO_CB(p)->flush = 0;
3561         }
3562
3563         return dev_gro_receive(napi, skb);
3564 }
3565
3566 gro_result_t napi_skb_finish(gro_result_t ret, struct sk_buff *skb)
3567 {
3568         switch (ret) {
3569         case GRO_NORMAL:
3570                 if (netif_receive_skb(skb))
3571                         ret = GRO_DROP;
3572                 break;
3573
3574         case GRO_DROP:
3575         case GRO_MERGED_FREE:
3576                 kfree_skb(skb);
3577                 break;
3578
3579         case GRO_HELD:
3580         case GRO_MERGED:
3581                 break;
3582         }
3583
3584         return ret;
3585 }
3586 EXPORT_SYMBOL(napi_skb_finish);
3587
3588 void skb_gro_reset_offset(struct sk_buff *skb)
3589 {
3590         NAPI_GRO_CB(skb)->data_offset = 0;
3591         NAPI_GRO_CB(skb)->frag0 = NULL;
3592         NAPI_GRO_CB(skb)->frag0_len = 0;
3593
3594         if (skb->mac_header == skb->tail &&
3595             !PageHighMem(skb_frag_page(&skb_shinfo(skb)->frags[0]))) {
3596                 NAPI_GRO_CB(skb)->frag0 =
3597                         skb_frag_address(&skb_shinfo(skb)->frags[0]);
3598                 NAPI_GRO_CB(skb)->frag0_len = skb_frag_size(&skb_shinfo(skb)->frags[0]);
3599         }
3600 }
3601 EXPORT_SYMBOL(skb_gro_reset_offset);
3602
3603 gro_result_t napi_gro_receive(struct napi_struct *napi, struct sk_buff *skb)
3604 {
3605         skb_gro_reset_offset(skb);
3606
3607         return napi_skb_finish(__napi_gro_receive(napi, skb), skb);
3608 }
3609 EXPORT_SYMBOL(napi_gro_receive);
3610
3611 static void napi_reuse_skb(struct napi_struct *napi, struct sk_buff *skb)
3612 {
3613         __skb_pull(skb, skb_headlen(skb));
3614         /* restore the reserve we had after netdev_alloc_skb_ip_align() */
3615         skb_reserve(skb, NET_SKB_PAD + NET_IP_ALIGN - skb_headroom(skb));
3616         skb->vlan_tci = 0;
3617         skb->dev = napi->dev;
3618         skb->skb_iif = 0;
3619
3620         napi->skb = skb;
3621 }
3622
3623 struct sk_buff *napi_get_frags(struct napi_struct *napi)
3624 {
3625         struct sk_buff *skb = napi->skb;
3626
3627         if (!skb) {
3628                 skb = netdev_alloc_skb_ip_align(napi->dev, GRO_MAX_HEAD);
3629                 if (skb)
3630                         napi->skb = skb;
3631         }
3632         return skb;
3633 }
3634 EXPORT_SYMBOL(napi_get_frags);
3635
3636 gro_result_t napi_frags_finish(struct napi_struct *napi, struct sk_buff *skb,
3637                                gro_result_t ret)
3638 {
3639         switch (ret) {
3640         case GRO_NORMAL:
3641         case GRO_HELD:
3642                 skb->protocol = eth_type_trans(skb, skb->dev);
3643
3644                 if (ret == GRO_HELD)
3645                         skb_gro_pull(skb, -ETH_HLEN);
3646                 else if (netif_receive_skb(skb))
3647                         ret = GRO_DROP;
3648                 break;
3649
3650         case GRO_DROP:
3651         case GRO_MERGED_FREE:
3652                 napi_reuse_skb(napi, skb);
3653                 break;
3654
3655         case GRO_MERGED:
3656                 break;
3657         }
3658
3659         return ret;
3660 }
3661 EXPORT_SYMBOL(napi_frags_finish);
3662
3663 struct sk_buff *napi_frags_skb(struct napi_struct *napi)
3664 {
3665         struct sk_buff *skb = napi->skb;
3666         struct ethhdr *eth;
3667         unsigned int hlen;
3668         unsigned int off;
3669
3670         napi->skb = NULL;
3671
3672         skb_reset_mac_header(skb);
3673         skb_gro_reset_offset(skb);
3674
3675         off = skb_gro_offset(skb);
3676         hlen = off + sizeof(*eth);
3677         eth = skb_gro_header_fast(skb, off);
3678         if (skb_gro_header_hard(skb, hlen)) {
3679                 eth = skb_gro_header_slow(skb, hlen, off);
3680                 if (unlikely(!eth)) {
3681                         napi_reuse_skb(napi, skb);
3682                         skb = NULL;
3683                         goto out;
3684                 }
3685         }
3686
3687         skb_gro_pull(skb, sizeof(*eth));
3688
3689         /*
3690          * This works because the only protocols we care about don't require
3691          * special handling.  We'll fix it up properly at the end.
3692          */
3693         skb->protocol = eth->h_proto;
3694
3695 out:
3696         return skb;
3697 }
3698 EXPORT_SYMBOL(napi_frags_skb);
3699
3700 gro_result_t napi_gro_frags(struct napi_struct *napi)
3701 {
3702         struct sk_buff *skb = napi_frags_skb(napi);
3703
3704         if (!skb)
3705                 return GRO_DROP;
3706
3707         return napi_frags_finish(napi, skb, __napi_gro_receive(napi, skb));
3708 }
3709 EXPORT_SYMBOL(napi_gro_frags);
3710
3711 /*
3712  * net_rps_action sends any pending IPI's for rps.
3713  * Note: called with local irq disabled, but exits with local irq enabled.
3714  */
3715 static void net_rps_action_and_irq_enable(struct softnet_data *sd)
3716 {
3717 #ifdef CONFIG_RPS
3718         struct softnet_data *remsd = sd->rps_ipi_list;
3719
3720         if (remsd) {
3721                 sd->rps_ipi_list = NULL;
3722
3723                 local_irq_enable();
3724
3725                 /* Send pending IPI's to kick RPS processing on remote cpus. */
3726                 while (remsd) {
3727                         struct softnet_data *next = remsd->rps_ipi_next;
3728
3729                         if (cpu_online(remsd->cpu))
3730                                 __smp_call_function_single(remsd->cpu,
3731                                                            &remsd->csd, 0);
3732                         remsd = next;
3733                 }
3734         } else
3735 #endif
3736                 local_irq_enable();
3737 }
3738
3739 static int process_backlog(struct napi_struct *napi, int quota)
3740 {
3741         int work = 0;
3742         struct softnet_data *sd = container_of(napi, struct softnet_data, backlog);
3743
3744 #ifdef CONFIG_RPS
3745         /* Check if we have pending ipi, its better to send them now,
3746          * not waiting net_rx_action() end.
3747          */
3748         if (sd->rps_ipi_list) {
3749                 local_irq_disable();
3750                 net_rps_action_and_irq_enable(sd);
3751         }
3752 #endif
3753         napi->weight = weight_p;
3754         local_irq_disable();
3755         while (work < quota) {
3756                 struct sk_buff *skb;
3757                 unsigned int qlen;
3758
3759                 while ((skb = __skb_dequeue(&sd->process_queue))) {
3760                         local_irq_enable();
3761                         __netif_receive_skb(skb);
3762                         local_irq_disable();
3763                         input_queue_head_incr(sd);
3764                         if (++work >= quota) {
3765                                 local_irq_enable();
3766                                 return work;
3767                         }
3768                 }
3769
3770                 rps_lock(sd);
3771                 qlen = skb_queue_len(&sd->input_pkt_queue);
3772                 if (qlen)
3773                         skb_queue_splice_tail_init(&sd->input_pkt_queue,
3774                                                    &sd->process_queue);
3775
3776                 if (qlen < quota - work) {
3777                         /*
3778                          * Inline a custom version of __napi_complete().
3779                          * only current cpu owns and manipulates this napi,
3780                          * and NAPI_STATE_SCHED is the only possible flag set on backlog.
3781                          * we can use a plain write instead of clear_bit(),
3782                          * and we dont need an smp_mb() memory barrier.
3783                          */
3784                         list_del(&napi->poll_list);
3785                         napi->state = 0;
3786
3787                         quota = work + qlen;
3788                 }
3789                 rps_unlock(sd);
3790         }
3791         local_irq_enable();
3792
3793         return work;
3794 }
3795
3796 /**
3797  * __napi_schedule - schedule for receive
3798  * @n: entry to schedule
3799  *
3800  * The entry's receive function will be scheduled to run
3801  */
3802 void __napi_schedule(struct napi_struct *n)
3803 {
3804         unsigned long flags;
3805
3806         local_irq_save(flags);
3807         ____napi_schedule(&__get_cpu_var(softnet_data), n);
3808         local_irq_restore(flags);
3809 }
3810 EXPORT_SYMBOL(__napi_schedule);
3811
3812 void __napi_complete(struct napi_struct *n)
3813 {
3814         BUG_ON(!test_bit(NAPI_STATE_SCHED, &n->state));
3815         BUG_ON(n->gro_list);
3816
3817         list_del(&n->poll_list);
3818         smp_mb__before_clear_bit();
3819         clear_bit(NAPI_STATE_SCHED, &n->state);
3820 }
3821 EXPORT_SYMBOL(__napi_complete);
3822
3823 void napi_complete(struct napi_struct *n)
3824 {
3825         unsigned long flags;
3826
3827         /*
3828          * don't let napi dequeue from the cpu poll list
3829          * just in case its running on a different cpu
3830          */
3831         if (unlikely(test_bit(NAPI_STATE_NPSVC, &n->state)))
3832                 return;
3833
3834         napi_gro_flush(n);
3835         local_irq_save(flags);
3836         __napi_complete(n);
3837         local_irq_restore(flags);
3838 }
3839 EXPORT_SYMBOL(napi_complete);
3840
3841 void netif_napi_add(struct net_device *dev, struct napi_struct *napi,
3842                     int (*poll)(struct napi_struct *, int), int weight)
3843 {
3844         INIT_LIST_HEAD(&napi->poll_list);
3845         napi->gro_count = 0;
3846         napi->gro_list = NULL;
3847         napi->skb = NULL;
3848         napi->poll = poll;
3849         napi->weight = weight;
3850         list_add(&napi->dev_list, &dev->napi_list);
3851         napi->dev = dev;
3852 #ifdef CONFIG_NETPOLL
3853         spin_lock_init(&napi->poll_lock);
3854         napi->poll_owner = -1;
3855 #endif
3856         set_bit(NAPI_STATE_SCHED, &napi->state);
3857 }
3858 EXPORT_SYMBOL(netif_napi_add);
3859
3860 void netif_napi_del(struct napi_struct *napi)
3861 {
3862         struct sk_buff *skb, *next;
3863
3864         list_del_init(&napi->dev_list);
3865         napi_free_frags(napi);
3866
3867         for (skb = napi->gro_list; skb