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