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