Merge branch 'master' of master.kernel.org:/pub/scm/linux/kernel/git/davem/net-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. The caller must hold RCU
753  *      The returned device has not had its ref count increased
754  *      and the caller must therefore be careful about locking
755  *
756  */
757
758 struct net_device *dev_getbyhwaddr_rcu(struct net *net, unsigned short type,
759                                        const char *ha)
760 {
761         struct net_device *dev;
762
763         for_each_netdev_rcu(net, dev)
764                 if (dev->type == type &&
765                     !memcmp(dev->dev_addr, ha, dev->addr_len))
766                         return dev;
767
768         return NULL;
769 }
770 EXPORT_SYMBOL(dev_getbyhwaddr_rcu);
771
772 struct net_device *__dev_getfirstbyhwtype(struct net *net, unsigned short type)
773 {
774         struct net_device *dev;
775
776         ASSERT_RTNL();
777         for_each_netdev(net, dev)
778                 if (dev->type == type)
779                         return dev;
780
781         return NULL;
782 }
783 EXPORT_SYMBOL(__dev_getfirstbyhwtype);
784
785 struct net_device *dev_getfirstbyhwtype(struct net *net, unsigned short type)
786 {
787         struct net_device *dev, *ret = NULL;
788
789         rcu_read_lock();
790         for_each_netdev_rcu(net, dev)
791                 if (dev->type == type) {
792                         dev_hold(dev);
793                         ret = dev;
794                         break;
795                 }
796         rcu_read_unlock();
797         return ret;
798 }
799 EXPORT_SYMBOL(dev_getfirstbyhwtype);
800
801 /**
802  *      dev_get_by_flags_rcu - find any device with given flags
803  *      @net: the applicable net namespace
804  *      @if_flags: IFF_* values
805  *      @mask: bitmask of bits in if_flags to check
806  *
807  *      Search for any interface with the given flags. Returns NULL if a device
808  *      is not found or a pointer to the device. Must be called inside
809  *      rcu_read_lock(), and result refcount is unchanged.
810  */
811
812 struct net_device *dev_get_by_flags_rcu(struct net *net, unsigned short if_flags,
813                                     unsigned short mask)
814 {
815         struct net_device *dev, *ret;
816
817         ret = NULL;
818         for_each_netdev_rcu(net, dev) {
819                 if (((dev->flags ^ if_flags) & mask) == 0) {
820                         ret = dev;
821                         break;
822                 }
823         }
824         return ret;
825 }
826 EXPORT_SYMBOL(dev_get_by_flags_rcu);
827
828 /**
829  *      dev_valid_name - check if name is okay for network device
830  *      @name: name string
831  *
832  *      Network device names need to be valid file names to
833  *      to allow sysfs to work.  We also disallow any kind of
834  *      whitespace.
835  */
836 int dev_valid_name(const char *name)
837 {
838         if (*name == '\0')
839                 return 0;
840         if (strlen(name) >= IFNAMSIZ)
841                 return 0;
842         if (!strcmp(name, ".") || !strcmp(name, ".."))
843                 return 0;
844
845         while (*name) {
846                 if (*name == '/' || isspace(*name))
847                         return 0;
848                 name++;
849         }
850         return 1;
851 }
852 EXPORT_SYMBOL(dev_valid_name);
853
854 /**
855  *      __dev_alloc_name - allocate a name for a device
856  *      @net: network namespace to allocate the device name in
857  *      @name: name format string
858  *      @buf:  scratch buffer and result name string
859  *
860  *      Passed a format string - eg "lt%d" it will try and find a suitable
861  *      id. It scans list of devices to build up a free map, then chooses
862  *      the first empty slot. The caller must hold the dev_base or rtnl lock
863  *      while allocating the name and adding the device in order to avoid
864  *      duplicates.
865  *      Limited to bits_per_byte * page size devices (ie 32K on most platforms).
866  *      Returns the number of the unit assigned or a negative errno code.
867  */
868
869 static int __dev_alloc_name(struct net *net, const char *name, char *buf)
870 {
871         int i = 0;
872         const char *p;
873         const int max_netdevices = 8*PAGE_SIZE;
874         unsigned long *inuse;
875         struct net_device *d;
876
877         p = strnchr(name, IFNAMSIZ-1, '%');
878         if (p) {
879                 /*
880                  * Verify the string as this thing may have come from
881                  * the user.  There must be either one "%d" and no other "%"
882                  * characters.
883                  */
884                 if (p[1] != 'd' || strchr(p + 2, '%'))
885                         return -EINVAL;
886
887                 /* Use one page as a bit array of possible slots */
888                 inuse = (unsigned long *) get_zeroed_page(GFP_ATOMIC);
889                 if (!inuse)
890                         return -ENOMEM;
891
892                 for_each_netdev(net, d) {
893                         if (!sscanf(d->name, name, &i))
894                                 continue;
895                         if (i < 0 || i >= max_netdevices)
896                                 continue;
897
898                         /*  avoid cases where sscanf is not exact inverse of printf */
899                         snprintf(buf, IFNAMSIZ, name, i);
900                         if (!strncmp(buf, d->name, IFNAMSIZ))
901                                 set_bit(i, inuse);
902                 }
903
904                 i = find_first_zero_bit(inuse, max_netdevices);
905                 free_page((unsigned long) inuse);
906         }
907
908         if (buf != name)
909                 snprintf(buf, IFNAMSIZ, name, i);
910         if (!__dev_get_by_name(net, buf))
911                 return i;
912
913         /* It is possible to run out of possible slots
914          * when the name is long and there isn't enough space left
915          * for the digits, or if all bits are used.
916          */
917         return -ENFILE;
918 }
919
920 /**
921  *      dev_alloc_name - allocate a name for a device
922  *      @dev: device
923  *      @name: name format string
924  *
925  *      Passed a format string - eg "lt%d" it will try and find a suitable
926  *      id. It scans list of devices to build up a free map, then chooses
927  *      the first empty slot. The caller must hold the dev_base or rtnl lock
928  *      while allocating the name and adding the device in order to avoid
929  *      duplicates.
930  *      Limited to bits_per_byte * page size devices (ie 32K on most platforms).
931  *      Returns the number of the unit assigned or a negative errno code.
932  */
933
934 int dev_alloc_name(struct net_device *dev, const char *name)
935 {
936         char buf[IFNAMSIZ];
937         struct net *net;
938         int ret;
939
940         BUG_ON(!dev_net(dev));
941         net = dev_net(dev);
942         ret = __dev_alloc_name(net, name, buf);
943         if (ret >= 0)
944                 strlcpy(dev->name, buf, IFNAMSIZ);
945         return ret;
946 }
947 EXPORT_SYMBOL(dev_alloc_name);
948
949 static int dev_get_valid_name(struct net_device *dev, const char *name, bool fmt)
950 {
951         struct net *net;
952
953         BUG_ON(!dev_net(dev));
954         net = dev_net(dev);
955
956         if (!dev_valid_name(name))
957                 return -EINVAL;
958
959         if (fmt && strchr(name, '%'))
960                 return dev_alloc_name(dev, name);
961         else if (__dev_get_by_name(net, name))
962                 return -EEXIST;
963         else if (dev->name != name)
964                 strlcpy(dev->name, name, IFNAMSIZ);
965
966         return 0;
967 }
968
969 /**
970  *      dev_change_name - change name of a device
971  *      @dev: device
972  *      @newname: name (or format string) must be at least IFNAMSIZ
973  *
974  *      Change name of a device, can pass format strings "eth%d".
975  *      for wildcarding.
976  */
977 int dev_change_name(struct net_device *dev, const char *newname)
978 {
979         char oldname[IFNAMSIZ];
980         int err = 0;
981         int ret;
982         struct net *net;
983
984         ASSERT_RTNL();
985         BUG_ON(!dev_net(dev));
986
987         net = dev_net(dev);
988         if (dev->flags & IFF_UP)
989                 return -EBUSY;
990
991         if (strncmp(newname, dev->name, IFNAMSIZ) == 0)
992                 return 0;
993
994         memcpy(oldname, dev->name, IFNAMSIZ);
995
996         err = dev_get_valid_name(dev, newname, 1);
997         if (err < 0)
998                 return err;
999
1000 rollback:
1001         ret = device_rename(&dev->dev, dev->name);
1002         if (ret) {
1003                 memcpy(dev->name, oldname, IFNAMSIZ);
1004                 return ret;
1005         }
1006
1007         write_lock_bh(&dev_base_lock);
1008         hlist_del(&dev->name_hlist);
1009         write_unlock_bh(&dev_base_lock);
1010
1011         synchronize_rcu();
1012
1013         write_lock_bh(&dev_base_lock);
1014         hlist_add_head_rcu(&dev->name_hlist, dev_name_hash(net, dev->name));
1015         write_unlock_bh(&dev_base_lock);
1016
1017         ret = call_netdevice_notifiers(NETDEV_CHANGENAME, dev);
1018         ret = notifier_to_errno(ret);
1019
1020         if (ret) {
1021                 /* err >= 0 after dev_alloc_name() or stores the first errno */
1022                 if (err >= 0) {
1023                         err = ret;
1024                         memcpy(dev->name, oldname, IFNAMSIZ);
1025                         goto rollback;
1026                 } else {
1027                         printk(KERN_ERR
1028                                "%s: name change rollback failed: %d.\n",
1029                                dev->name, ret);
1030                 }
1031         }
1032
1033         return err;
1034 }
1035
1036 /**
1037  *      dev_set_alias - change ifalias of a device
1038  *      @dev: device
1039  *      @alias: name up to IFALIASZ
1040  *      @len: limit of bytes to copy from info
1041  *
1042  *      Set ifalias for a device,
1043  */
1044 int dev_set_alias(struct net_device *dev, const char *alias, size_t len)
1045 {
1046         ASSERT_RTNL();
1047
1048         if (len >= IFALIASZ)
1049                 return -EINVAL;
1050
1051         if (!len) {
1052                 if (dev->ifalias) {
1053                         kfree(dev->ifalias);
1054                         dev->ifalias = NULL;
1055                 }
1056                 return 0;
1057         }
1058
1059         dev->ifalias = krealloc(dev->ifalias, len + 1, GFP_KERNEL);
1060         if (!dev->ifalias)
1061                 return -ENOMEM;
1062
1063         strlcpy(dev->ifalias, alias, len+1);
1064         return len;
1065 }
1066
1067
1068 /**
1069  *      netdev_features_change - device changes features
1070  *      @dev: device to cause notification
1071  *
1072  *      Called to indicate a device has changed features.
1073  */
1074 void netdev_features_change(struct net_device *dev)
1075 {
1076         call_netdevice_notifiers(NETDEV_FEAT_CHANGE, dev);
1077 }
1078 EXPORT_SYMBOL(netdev_features_change);
1079
1080 /**
1081  *      netdev_state_change - device changes state
1082  *      @dev: device to cause notification
1083  *
1084  *      Called to indicate a device has changed state. This function calls
1085  *      the notifier chains for netdev_chain and sends a NEWLINK message
1086  *      to the routing socket.
1087  */
1088 void netdev_state_change(struct net_device *dev)
1089 {
1090         if (dev->flags & IFF_UP) {
1091                 call_netdevice_notifiers(NETDEV_CHANGE, dev);
1092                 rtmsg_ifinfo(RTM_NEWLINK, dev, 0);
1093         }
1094 }
1095 EXPORT_SYMBOL(netdev_state_change);
1096
1097 int netdev_bonding_change(struct net_device *dev, unsigned long event)
1098 {
1099         return call_netdevice_notifiers(event, dev);
1100 }
1101 EXPORT_SYMBOL(netdev_bonding_change);
1102
1103 /**
1104  *      dev_load        - load a network module
1105  *      @net: the applicable net namespace
1106  *      @name: name of interface
1107  *
1108  *      If a network interface is not present and the process has suitable
1109  *      privileges this function loads the module. If module loading is not
1110  *      available in this kernel then it becomes a nop.
1111  */
1112
1113 void dev_load(struct net *net, const char *name)
1114 {
1115         struct net_device *dev;
1116
1117         rcu_read_lock();
1118         dev = dev_get_by_name_rcu(net, name);
1119         rcu_read_unlock();
1120
1121         if (!dev && capable(CAP_NET_ADMIN))
1122                 request_module("%s", name);
1123 }
1124 EXPORT_SYMBOL(dev_load);
1125
1126 static int __dev_open(struct net_device *dev)
1127 {
1128         const struct net_device_ops *ops = dev->netdev_ops;
1129         int ret;
1130
1131         ASSERT_RTNL();
1132
1133         /*
1134          *      Is it even present?
1135          */
1136         if (!netif_device_present(dev))
1137                 return -ENODEV;
1138
1139         ret = call_netdevice_notifiers(NETDEV_PRE_UP, dev);
1140         ret = notifier_to_errno(ret);
1141         if (ret)
1142                 return ret;
1143
1144         /*
1145          *      Call device private open method
1146          */
1147         set_bit(__LINK_STATE_START, &dev->state);
1148
1149         if (ops->ndo_validate_addr)
1150                 ret = ops->ndo_validate_addr(dev);
1151
1152         if (!ret && ops->ndo_open)
1153                 ret = ops->ndo_open(dev);
1154
1155         /*
1156          *      If it went open OK then:
1157          */
1158
1159         if (ret)
1160                 clear_bit(__LINK_STATE_START, &dev->state);
1161         else {
1162                 /*
1163                  *      Set the flags.
1164                  */
1165                 dev->flags |= IFF_UP;
1166
1167                 /*
1168                  *      Enable NET_DMA
1169                  */
1170                 net_dmaengine_get();
1171
1172                 /*
1173                  *      Initialize multicasting status
1174                  */
1175                 dev_set_rx_mode(dev);
1176
1177                 /*
1178                  *      Wakeup transmit queue engine
1179                  */
1180                 dev_activate(dev);
1181         }
1182
1183         return ret;
1184 }
1185
1186 /**
1187  *      dev_open        - prepare an interface for use.
1188  *      @dev:   device to open
1189  *
1190  *      Takes a device from down to up state. The device's private open
1191  *      function is invoked and then the multicast lists are loaded. Finally
1192  *      the device is moved into the up state and a %NETDEV_UP message is
1193  *      sent to the netdev notifier chain.
1194  *
1195  *      Calling this function on an active interface is a nop. On a failure
1196  *      a negative errno code is returned.
1197  */
1198 int dev_open(struct net_device *dev)
1199 {
1200         int ret;
1201
1202         /*
1203          *      Is it already up?
1204          */
1205         if (dev->flags & IFF_UP)
1206                 return 0;
1207
1208         /*
1209          *      Open device
1210          */
1211         ret = __dev_open(dev);
1212         if (ret < 0)
1213                 return ret;
1214
1215         /*
1216          *      ... and announce new interface.
1217          */
1218         rtmsg_ifinfo(RTM_NEWLINK, dev, IFF_UP|IFF_RUNNING);
1219         call_netdevice_notifiers(NETDEV_UP, dev);
1220
1221         return ret;
1222 }
1223 EXPORT_SYMBOL(dev_open);
1224
1225 static int __dev_close_many(struct list_head *head)
1226 {
1227         struct net_device *dev;
1228
1229         ASSERT_RTNL();
1230         might_sleep();
1231
1232         list_for_each_entry(dev, head, unreg_list) {
1233                 /*
1234                  *      Tell people we are going down, so that they can
1235                  *      prepare to death, when device is still operating.
1236                  */
1237                 call_netdevice_notifiers(NETDEV_GOING_DOWN, dev);
1238
1239                 clear_bit(__LINK_STATE_START, &dev->state);
1240
1241                 /* Synchronize to scheduled poll. We cannot touch poll list, it
1242                  * can be even on different cpu. So just clear netif_running().
1243                  *
1244                  * dev->stop() will invoke napi_disable() on all of it's
1245                  * napi_struct instances on this device.
1246                  */
1247                 smp_mb__after_clear_bit(); /* Commit netif_running(). */
1248         }
1249
1250         dev_deactivate_many(head);
1251
1252         list_for_each_entry(dev, head, unreg_list) {
1253                 const struct net_device_ops *ops = dev->netdev_ops;
1254
1255                 /*
1256                  *      Call the device specific close. This cannot fail.
1257                  *      Only if device is UP
1258                  *
1259                  *      We allow it to be called even after a DETACH hot-plug
1260                  *      event.
1261                  */
1262                 if (ops->ndo_stop)
1263                         ops->ndo_stop(dev);
1264
1265                 /*
1266                  *      Device is now down.
1267                  */
1268
1269                 dev->flags &= ~IFF_UP;
1270
1271                 /*
1272                  *      Shutdown NET_DMA
1273                  */
1274                 net_dmaengine_put();
1275         }
1276
1277         return 0;
1278 }
1279
1280 static int __dev_close(struct net_device *dev)
1281 {
1282         LIST_HEAD(single);
1283
1284         list_add(&dev->unreg_list, &single);
1285         return __dev_close_many(&single);
1286 }
1287
1288 int dev_close_many(struct list_head *head)
1289 {
1290         struct net_device *dev, *tmp;
1291         LIST_HEAD(tmp_list);
1292
1293         list_for_each_entry_safe(dev, tmp, head, unreg_list)
1294                 if (!(dev->flags & IFF_UP))
1295                         list_move(&dev->unreg_list, &tmp_list);
1296
1297         __dev_close_many(head);
1298
1299         /*
1300          * Tell people we are down
1301          */
1302         list_for_each_entry(dev, head, unreg_list) {
1303                 rtmsg_ifinfo(RTM_NEWLINK, dev, IFF_UP|IFF_RUNNING);
1304                 call_netdevice_notifiers(NETDEV_DOWN, dev);
1305         }
1306
1307         /* rollback_registered_many needs the complete original list */
1308         list_splice(&tmp_list, head);
1309         return 0;
1310 }
1311
1312 /**
1313  *      dev_close - shutdown an interface.
1314  *      @dev: device to shutdown
1315  *
1316  *      This function moves an active device into down state. A
1317  *      %NETDEV_GOING_DOWN is sent to the netdev notifier chain. The device
1318  *      is then deactivated and finally a %NETDEV_DOWN is sent to the notifier
1319  *      chain.
1320  */
1321 int dev_close(struct net_device *dev)
1322 {
1323         LIST_HEAD(single);
1324
1325         list_add(&dev->unreg_list, &single);
1326         dev_close_many(&single);
1327
1328         return 0;
1329 }
1330 EXPORT_SYMBOL(dev_close);
1331
1332
1333 /**
1334  *      dev_disable_lro - disable Large Receive Offload on a device
1335  *      @dev: device
1336  *
1337  *      Disable Large Receive Offload (LRO) on a net device.  Must be
1338  *      called under RTNL.  This is needed if received packets may be
1339  *      forwarded to another interface.
1340  */
1341 void dev_disable_lro(struct net_device *dev)
1342 {
1343         if (dev->ethtool_ops && dev->ethtool_ops->get_flags &&
1344             dev->ethtool_ops->set_flags) {
1345                 u32 flags = dev->ethtool_ops->get_flags(dev);
1346                 if (flags & ETH_FLAG_LRO) {
1347                         flags &= ~ETH_FLAG_LRO;
1348                         dev->ethtool_ops->set_flags(dev, flags);
1349                 }
1350         }
1351         WARN_ON(dev->features & NETIF_F_LRO);
1352 }
1353 EXPORT_SYMBOL(dev_disable_lro);
1354
1355
1356 static int dev_boot_phase = 1;
1357
1358 /*
1359  *      Device change register/unregister. These are not inline or static
1360  *      as we export them to the world.
1361  */
1362
1363 /**
1364  *      register_netdevice_notifier - register a network notifier block
1365  *      @nb: notifier
1366  *
1367  *      Register a notifier to be called when network device events occur.
1368  *      The notifier passed is linked into the kernel structures and must
1369  *      not be reused until it has been unregistered. A negative errno code
1370  *      is returned on a failure.
1371  *
1372  *      When registered all registration and up events are replayed
1373  *      to the new notifier to allow device to have a race free
1374  *      view of the network device list.
1375  */
1376
1377 int register_netdevice_notifier(struct notifier_block *nb)
1378 {
1379         struct net_device *dev;
1380         struct net_device *last;
1381         struct net *net;
1382         int err;
1383
1384         rtnl_lock();
1385         err = raw_notifier_chain_register(&netdev_chain, nb);
1386         if (err)
1387                 goto unlock;
1388         if (dev_boot_phase)
1389                 goto unlock;
1390         for_each_net(net) {
1391                 for_each_netdev(net, dev) {
1392                         err = nb->notifier_call(nb, NETDEV_REGISTER, dev);
1393                         err = notifier_to_errno(err);
1394                         if (err)
1395                                 goto rollback;
1396
1397                         if (!(dev->flags & IFF_UP))
1398                                 continue;
1399
1400                         nb->notifier_call(nb, NETDEV_UP, dev);
1401                 }
1402         }
1403
1404 unlock:
1405         rtnl_unlock();
1406         return err;
1407
1408 rollback:
1409         last = dev;
1410         for_each_net(net) {
1411                 for_each_netdev(net, dev) {
1412                         if (dev == last)
1413                                 break;
1414
1415                         if (dev->flags & IFF_UP) {
1416                                 nb->notifier_call(nb, NETDEV_GOING_DOWN, dev);
1417                                 nb->notifier_call(nb, NETDEV_DOWN, dev);
1418                         }
1419                         nb->notifier_call(nb, NETDEV_UNREGISTER, dev);
1420                         nb->notifier_call(nb, NETDEV_UNREGISTER_BATCH, dev);
1421                 }
1422         }
1423
1424         raw_notifier_chain_unregister(&netdev_chain, nb);
1425         goto unlock;
1426 }
1427 EXPORT_SYMBOL(register_netdevice_notifier);
1428
1429 /**
1430  *      unregister_netdevice_notifier - unregister a network notifier block
1431  *      @nb: notifier
1432  *
1433  *      Unregister a notifier previously registered by
1434  *      register_netdevice_notifier(). The notifier is unlinked into the
1435  *      kernel structures and may then be reused. A negative errno code
1436  *      is returned on a failure.
1437  */
1438
1439 int unregister_netdevice_notifier(struct notifier_block *nb)
1440 {
1441         int err;
1442
1443         rtnl_lock();
1444         err = raw_notifier_chain_unregister(&netdev_chain, nb);
1445         rtnl_unlock();
1446         return err;
1447 }
1448 EXPORT_SYMBOL(unregister_netdevice_notifier);
1449
1450 /**
1451  *      call_netdevice_notifiers - call all network notifier blocks
1452  *      @val: value passed unmodified to notifier function
1453  *      @dev: net_device pointer passed unmodified to notifier function
1454  *
1455  *      Call all network notifier blocks.  Parameters and return value
1456  *      are as for raw_notifier_call_chain().
1457  */
1458
1459 int call_netdevice_notifiers(unsigned long val, struct net_device *dev)
1460 {
1461         ASSERT_RTNL();
1462         return raw_notifier_call_chain(&netdev_chain, val, dev);
1463 }
1464
1465 /* When > 0 there are consumers of rx skb time stamps */
1466 static atomic_t netstamp_needed = ATOMIC_INIT(0);
1467
1468 void net_enable_timestamp(void)
1469 {
1470         atomic_inc(&netstamp_needed);
1471 }
1472 EXPORT_SYMBOL(net_enable_timestamp);
1473
1474 void net_disable_timestamp(void)
1475 {
1476         atomic_dec(&netstamp_needed);
1477 }
1478 EXPORT_SYMBOL(net_disable_timestamp);
1479
1480 static inline void net_timestamp_set(struct sk_buff *skb)
1481 {
1482         if (atomic_read(&netstamp_needed))
1483                 __net_timestamp(skb);
1484         else
1485                 skb->tstamp.tv64 = 0;
1486 }
1487
1488 static inline void net_timestamp_check(struct sk_buff *skb)
1489 {
1490         if (!skb->tstamp.tv64 && atomic_read(&netstamp_needed))
1491                 __net_timestamp(skb);
1492 }
1493
1494 /**
1495  * dev_forward_skb - loopback an skb to another netif
1496  *
1497  * @dev: destination network device
1498  * @skb: buffer to forward
1499  *
1500  * return values:
1501  *      NET_RX_SUCCESS  (no congestion)
1502  *      NET_RX_DROP     (packet was dropped, but freed)
1503  *
1504  * dev_forward_skb can be used for injecting an skb from the
1505  * start_xmit function of one device into the receive queue
1506  * of another device.
1507  *
1508  * The receiving device may be in another namespace, so
1509  * we have to clear all information in the skb that could
1510  * impact namespace isolation.
1511  */
1512 int dev_forward_skb(struct net_device *dev, struct sk_buff *skb)
1513 {
1514         skb_orphan(skb);
1515         nf_reset(skb);
1516
1517         if (unlikely(!(dev->flags & IFF_UP) ||
1518                      (skb->len > (dev->mtu + dev->hard_header_len + VLAN_HLEN)))) {
1519                 atomic_long_inc(&dev->rx_dropped);
1520                 kfree_skb(skb);
1521                 return NET_RX_DROP;
1522         }
1523         skb_set_dev(skb, dev);
1524         skb->tstamp.tv64 = 0;
1525         skb->pkt_type = PACKET_HOST;
1526         skb->protocol = eth_type_trans(skb, dev);
1527         return netif_rx(skb);
1528 }
1529 EXPORT_SYMBOL_GPL(dev_forward_skb);
1530
1531 static inline int deliver_skb(struct sk_buff *skb,
1532                               struct packet_type *pt_prev,
1533                               struct net_device *orig_dev)
1534 {
1535         atomic_inc(&skb->users);
1536         return pt_prev->func(skb, skb->dev, pt_prev, orig_dev);
1537 }
1538
1539 /*
1540  *      Support routine. Sends outgoing frames to any network
1541  *      taps currently in use.
1542  */
1543
1544 static void dev_queue_xmit_nit(struct sk_buff *skb, struct net_device *dev)
1545 {
1546         struct packet_type *ptype;
1547         struct sk_buff *skb2 = NULL;
1548         struct packet_type *pt_prev = NULL;
1549
1550         rcu_read_lock();
1551         list_for_each_entry_rcu(ptype, &ptype_all, list) {
1552                 /* Never send packets back to the socket
1553                  * they originated from - MvS (miquels@drinkel.ow.org)
1554                  */
1555                 if ((ptype->dev == dev || !ptype->dev) &&
1556                     (ptype->af_packet_priv == NULL ||
1557                      (struct sock *)ptype->af_packet_priv != skb->sk)) {
1558                         if (pt_prev) {
1559                                 deliver_skb(skb2, pt_prev, skb->dev);
1560                                 pt_prev = ptype;
1561                                 continue;
1562                         }
1563
1564                         skb2 = skb_clone(skb, GFP_ATOMIC);
1565                         if (!skb2)
1566                                 break;
1567
1568                         net_timestamp_set(skb2);
1569
1570                         /* skb->nh should be correctly
1571                            set by sender, so that the second statement is
1572                            just protection against buggy protocols.
1573                          */
1574                         skb_reset_mac_header(skb2);
1575
1576                         if (skb_network_header(skb2) < skb2->data ||
1577                             skb2->network_header > skb2->tail) {
1578                                 if (net_ratelimit())
1579                                         printk(KERN_CRIT "protocol %04x is "
1580                                                "buggy, dev %s\n",
1581                                                ntohs(skb2->protocol),
1582                                                dev->name);
1583                                 skb_reset_network_header(skb2);
1584                         }
1585
1586                         skb2->transport_header = skb2->network_header;
1587                         skb2->pkt_type = PACKET_OUTGOING;
1588                         pt_prev = ptype;
1589                 }
1590         }
1591         if (pt_prev)
1592                 pt_prev->func(skb2, skb->dev, pt_prev, skb->dev);
1593         rcu_read_unlock();
1594 }
1595
1596 /*
1597  * Routine to help set real_num_tx_queues. To avoid skbs mapped to queues
1598  * greater then real_num_tx_queues stale skbs on the qdisc must be flushed.
1599  */
1600 int netif_set_real_num_tx_queues(struct net_device *dev, unsigned int txq)
1601 {
1602         int rc;
1603
1604         if (txq < 1 || txq > dev->num_tx_queues)
1605                 return -EINVAL;
1606
1607         if (dev->reg_state == NETREG_REGISTERED) {
1608                 ASSERT_RTNL();
1609
1610                 rc = netdev_queue_update_kobjects(dev, dev->real_num_tx_queues,
1611                                                   txq);
1612                 if (rc)
1613                         return rc;
1614
1615                 if (txq < dev->real_num_tx_queues)
1616                         qdisc_reset_all_tx_gt(dev, txq);
1617         }
1618
1619         dev->real_num_tx_queues = txq;
1620         return 0;
1621 }
1622 EXPORT_SYMBOL(netif_set_real_num_tx_queues);
1623
1624 #ifdef CONFIG_RPS
1625 /**
1626  *      netif_set_real_num_rx_queues - set actual number of RX queues used
1627  *      @dev: Network device
1628  *      @rxq: Actual number of RX queues
1629  *
1630  *      This must be called either with the rtnl_lock held or before
1631  *      registration of the net device.  Returns 0 on success, or a
1632  *      negative error code.  If called before registration, it always
1633  *      succeeds.
1634  */
1635 int netif_set_real_num_rx_queues(struct net_device *dev, unsigned int rxq)
1636 {
1637         int rc;
1638
1639         if (rxq < 1 || rxq > dev->num_rx_queues)
1640                 return -EINVAL;
1641
1642         if (dev->reg_state == NETREG_REGISTERED) {
1643                 ASSERT_RTNL();
1644
1645                 rc = net_rx_queue_update_kobjects(dev, dev->real_num_rx_queues,
1646                                                   rxq);
1647                 if (rc)
1648                         return rc;
1649         }
1650
1651         dev->real_num_rx_queues = rxq;
1652         return 0;
1653 }
1654 EXPORT_SYMBOL(netif_set_real_num_rx_queues);
1655 #endif
1656
1657 static inline void __netif_reschedule(struct Qdisc *q)
1658 {
1659         struct softnet_data *sd;
1660         unsigned long flags;
1661
1662         local_irq_save(flags);
1663         sd = &__get_cpu_var(softnet_data);
1664         q->next_sched = NULL;
1665         *sd->output_queue_tailp = q;
1666         sd->output_queue_tailp = &q->next_sched;
1667         raise_softirq_irqoff(NET_TX_SOFTIRQ);
1668         local_irq_restore(flags);
1669 }
1670
1671 void __netif_schedule(struct Qdisc *q)
1672 {
1673         if (!test_and_set_bit(__QDISC_STATE_SCHED, &q->state))
1674                 __netif_reschedule(q);
1675 }
1676 EXPORT_SYMBOL(__netif_schedule);
1677
1678 void dev_kfree_skb_irq(struct sk_buff *skb)
1679 {
1680         if (atomic_dec_and_test(&skb->users)) {
1681                 struct softnet_data *sd;
1682                 unsigned long flags;
1683
1684                 local_irq_save(flags);
1685                 sd = &__get_cpu_var(softnet_data);
1686                 skb->next = sd->completion_queue;
1687                 sd->completion_queue = skb;
1688                 raise_softirq_irqoff(NET_TX_SOFTIRQ);
1689                 local_irq_restore(flags);
1690         }
1691 }
1692 EXPORT_SYMBOL(dev_kfree_skb_irq);
1693
1694 void dev_kfree_skb_any(struct sk_buff *skb)
1695 {
1696         if (in_irq() || irqs_disabled())
1697                 dev_kfree_skb_irq(skb);
1698         else
1699                 dev_kfree_skb(skb);
1700 }
1701 EXPORT_SYMBOL(dev_kfree_skb_any);
1702
1703
1704 /**
1705  * netif_device_detach - mark device as removed
1706  * @dev: network device
1707  *
1708  * Mark device as removed from system and therefore no longer available.
1709  */
1710 void netif_device_detach(struct net_device *dev)
1711 {
1712         if (test_and_clear_bit(__LINK_STATE_PRESENT, &dev->state) &&
1713             netif_running(dev)) {
1714                 netif_tx_stop_all_queues(dev);
1715         }
1716 }
1717 EXPORT_SYMBOL(netif_device_detach);
1718
1719 /**
1720  * netif_device_attach - mark device as attached
1721  * @dev: network device
1722  *
1723  * Mark device as attached from system and restart if needed.
1724  */
1725 void netif_device_attach(struct net_device *dev)
1726 {
1727         if (!test_and_set_bit(__LINK_STATE_PRESENT, &dev->state) &&
1728             netif_running(dev)) {
1729                 netif_tx_wake_all_queues(dev);
1730                 __netdev_watchdog_up(dev);
1731         }
1732 }
1733 EXPORT_SYMBOL(netif_device_attach);
1734
1735 /**
1736  * skb_dev_set -- assign a new device to a buffer
1737  * @skb: buffer for the new device
1738  * @dev: network device
1739  *
1740  * If an skb is owned by a device already, we have to reset
1741  * all data private to the namespace a device belongs to
1742  * before assigning it a new device.
1743  */
1744 #ifdef CONFIG_NET_NS
1745 void skb_set_dev(struct sk_buff *skb, struct net_device *dev)
1746 {
1747         skb_dst_drop(skb);
1748         if (skb->dev && !net_eq(dev_net(skb->dev), dev_net(dev))) {
1749                 secpath_reset(skb);
1750                 nf_reset(skb);
1751                 skb_init_secmark(skb);
1752                 skb->mark = 0;
1753                 skb->priority = 0;
1754                 skb->nf_trace = 0;
1755                 skb->ipvs_property = 0;
1756 #ifdef CONFIG_NET_SCHED
1757                 skb->tc_index = 0;
1758 #endif
1759         }
1760         skb->dev = dev;
1761 }
1762 EXPORT_SYMBOL(skb_set_dev);
1763 #endif /* CONFIG_NET_NS */
1764
1765 /*
1766  * Invalidate hardware checksum when packet is to be mangled, and
1767  * complete checksum manually on outgoing path.
1768  */
1769 int skb_checksum_help(struct sk_buff *skb)
1770 {
1771         __wsum csum;
1772         int ret = 0, offset;
1773
1774         if (skb->ip_summed == CHECKSUM_COMPLETE)
1775                 goto out_set_summed;
1776
1777         if (unlikely(skb_shinfo(skb)->gso_size)) {
1778                 /* Let GSO fix up the checksum. */
1779                 goto out_set_summed;
1780         }
1781
1782         offset = skb_checksum_start_offset(skb);
1783         BUG_ON(offset >= skb_headlen(skb));
1784         csum = skb_checksum(skb, offset, skb->len - offset, 0);
1785
1786         offset += skb->csum_offset;
1787         BUG_ON(offset + sizeof(__sum16) > skb_headlen(skb));
1788
1789         if (skb_cloned(skb) &&
1790             !skb_clone_writable(skb, offset + sizeof(__sum16))) {
1791                 ret = pskb_expand_head(skb, 0, 0, GFP_ATOMIC);
1792                 if (ret)
1793                         goto out;
1794         }
1795
1796         *(__sum16 *)(skb->data + offset) = csum_fold(csum);
1797 out_set_summed:
1798         skb->ip_summed = CHECKSUM_NONE;
1799 out:
1800         return ret;
1801 }
1802 EXPORT_SYMBOL(skb_checksum_help);
1803
1804 /**
1805  *      skb_gso_segment - Perform segmentation on skb.
1806  *      @skb: buffer to segment
1807  *      @features: features for the output path (see dev->features)
1808  *
1809  *      This function segments the given skb and returns a list of segments.
1810  *
1811  *      It may return NULL if the skb requires no segmentation.  This is
1812  *      only possible when GSO is used for verifying header integrity.
1813  */
1814 struct sk_buff *skb_gso_segment(struct sk_buff *skb, int features)
1815 {
1816         struct sk_buff *segs = ERR_PTR(-EPROTONOSUPPORT);
1817         struct packet_type *ptype;
1818         __be16 type = skb->protocol;
1819         int vlan_depth = ETH_HLEN;
1820         int err;
1821
1822         while (type == htons(ETH_P_8021Q)) {
1823                 struct vlan_hdr *vh;
1824
1825                 if (unlikely(!pskb_may_pull(skb, vlan_depth + VLAN_HLEN)))
1826                         return ERR_PTR(-EINVAL);
1827
1828                 vh = (struct vlan_hdr *)(skb->data + vlan_depth);
1829                 type = vh->h_vlan_encapsulated_proto;
1830                 vlan_depth += VLAN_HLEN;
1831         }
1832
1833         skb_reset_mac_header(skb);
1834         skb->mac_len = skb->network_header - skb->mac_header;
1835         __skb_pull(skb, skb->mac_len);
1836
1837         if (unlikely(skb->ip_summed != CHECKSUM_PARTIAL)) {
1838                 struct net_device *dev = skb->dev;
1839                 struct ethtool_drvinfo info = {};
1840
1841                 if (dev && dev->ethtool_ops && dev->ethtool_ops->get_drvinfo)
1842                         dev->ethtool_ops->get_drvinfo(dev, &info);
1843
1844                 WARN(1, "%s: caps=(0x%lx, 0x%lx) len=%d data_len=%d ip_summed=%d\n",
1845                      info.driver, dev ? dev->features : 0L,
1846                      skb->sk ? skb->sk->sk_route_caps : 0L,
1847                      skb->len, skb->data_len, skb->ip_summed);
1848
1849                 if (skb_header_cloned(skb) &&
1850                     (err = pskb_expand_head(skb, 0, 0, GFP_ATOMIC)))
1851                         return ERR_PTR(err);
1852         }
1853
1854         rcu_read_lock();
1855         list_for_each_entry_rcu(ptype,
1856                         &ptype_base[ntohs(type) & PTYPE_HASH_MASK], list) {
1857                 if (ptype->type == type && !ptype->dev && ptype->gso_segment) {
1858                         if (unlikely(skb->ip_summed != CHECKSUM_PARTIAL)) {
1859                                 err = ptype->gso_send_check(skb);
1860                                 segs = ERR_PTR(err);
1861                                 if (err || skb_gso_ok(skb, features))
1862                                         break;
1863                                 __skb_push(skb, (skb->data -
1864                                                  skb_network_header(skb)));
1865                         }
1866                         segs = ptype->gso_segment(skb, features);
1867                         break;
1868                 }
1869         }
1870         rcu_read_unlock();
1871
1872         __skb_push(skb, skb->data - skb_mac_header(skb));
1873
1874         return segs;
1875 }
1876 EXPORT_SYMBOL(skb_gso_segment);
1877
1878 /* Take action when hardware reception checksum errors are detected. */
1879 #ifdef CONFIG_BUG
1880 void netdev_rx_csum_fault(struct net_device *dev)
1881 {
1882         if (net_ratelimit()) {
1883                 printk(KERN_ERR "%s: hw csum failure.\n",
1884                         dev ? dev->name : "<unknown>");
1885                 dump_stack();
1886         }
1887 }
1888 EXPORT_SYMBOL(netdev_rx_csum_fault);
1889 #endif
1890
1891 /* Actually, we should eliminate this check as soon as we know, that:
1892  * 1. IOMMU is present and allows to map all the memory.
1893  * 2. No high memory really exists on this machine.
1894  */
1895
1896 static int illegal_highdma(struct net_device *dev, struct sk_buff *skb)
1897 {
1898 #ifdef CONFIG_HIGHMEM
1899         int i;
1900         if (!(dev->features & NETIF_F_HIGHDMA)) {
1901                 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++)
1902                         if (PageHighMem(skb_shinfo(skb)->frags[i].page))
1903                                 return 1;
1904         }
1905
1906         if (PCI_DMA_BUS_IS_PHYS) {
1907                 struct device *pdev = dev->dev.parent;
1908
1909                 if (!pdev)
1910                         return 0;
1911                 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
1912                         dma_addr_t addr = page_to_phys(skb_shinfo(skb)->frags[i].page);
1913                         if (!pdev->dma_mask || addr + PAGE_SIZE - 1 > *pdev->dma_mask)
1914                                 return 1;
1915                 }
1916         }
1917 #endif
1918         return 0;
1919 }
1920
1921 struct dev_gso_cb {
1922         void (*destructor)(struct sk_buff *skb);
1923 };
1924
1925 #define DEV_GSO_CB(skb) ((struct dev_gso_cb *)(skb)->cb)
1926
1927 static void dev_gso_skb_destructor(struct sk_buff *skb)
1928 {
1929         struct dev_gso_cb *cb;
1930
1931         do {
1932                 struct sk_buff *nskb = skb->next;
1933
1934                 skb->next = nskb->next;
1935                 nskb->next = NULL;
1936                 kfree_skb(nskb);
1937         } while (skb->next);
1938
1939         cb = DEV_GSO_CB(skb);
1940         if (cb->destructor)
1941                 cb->destructor(skb);
1942 }
1943
1944 /**
1945  *      dev_gso_segment - Perform emulated hardware segmentation on skb.
1946  *      @skb: buffer to segment
1947  *      @features: device features as applicable to this skb
1948  *
1949  *      This function segments the given skb and stores the list of segments
1950  *      in skb->next.
1951  */
1952 static int dev_gso_segment(struct sk_buff *skb, int features)
1953 {
1954         struct sk_buff *segs;
1955
1956         segs = skb_gso_segment(skb, features);
1957
1958         /* Verifying header integrity only. */
1959         if (!segs)
1960                 return 0;
1961
1962         if (IS_ERR(segs))
1963                 return PTR_ERR(segs);
1964
1965         skb->next = segs;
1966         DEV_GSO_CB(skb)->destructor = skb->destructor;
1967         skb->destructor = dev_gso_skb_destructor;
1968
1969         return 0;
1970 }
1971
1972 /*
1973  * Try to orphan skb early, right before transmission by the device.
1974  * We cannot orphan skb if tx timestamp is requested or the sk-reference
1975  * is needed on driver level for other reasons, e.g. see net/can/raw.c
1976  */
1977 static inline void skb_orphan_try(struct sk_buff *skb)
1978 {
1979         struct sock *sk = skb->sk;
1980
1981         if (sk && !skb_shinfo(skb)->tx_flags) {
1982                 /* skb_tx_hash() wont be able to get sk.
1983                  * We copy sk_hash into skb->rxhash
1984                  */
1985                 if (!skb->rxhash)
1986                         skb->rxhash = sk->sk_hash;
1987                 skb_orphan(skb);
1988         }
1989 }
1990
1991 static bool can_checksum_protocol(unsigned long features, __be16 protocol)
1992 {
1993         return ((features & NETIF_F_GEN_CSUM) ||
1994                 ((features & NETIF_F_V4_CSUM) &&
1995                  protocol == htons(ETH_P_IP)) ||
1996                 ((features & NETIF_F_V6_CSUM) &&
1997                  protocol == htons(ETH_P_IPV6)) ||
1998                 ((features & NETIF_F_FCOE_CRC) &&
1999                  protocol == htons(ETH_P_FCOE)));
2000 }
2001
2002 static int harmonize_features(struct sk_buff *skb, __be16 protocol, int features)
2003 {
2004         if (!can_checksum_protocol(protocol, features)) {
2005                 features &= ~NETIF_F_ALL_CSUM;
2006                 features &= ~NETIF_F_SG;
2007         } else if (illegal_highdma(skb->dev, skb)) {
2008                 features &= ~NETIF_F_SG;
2009         }
2010
2011         return features;
2012 }
2013
2014 int netif_skb_features(struct sk_buff *skb)
2015 {
2016         __be16 protocol = skb->protocol;
2017         int features = skb->dev->features;
2018
2019         if (protocol == htons(ETH_P_8021Q)) {
2020                 struct vlan_ethhdr *veh = (struct vlan_ethhdr *)skb->data;
2021                 protocol = veh->h_vlan_encapsulated_proto;
2022         } else if (!vlan_tx_tag_present(skb)) {
2023                 return harmonize_features(skb, protocol, features);
2024         }
2025
2026         features &= (skb->dev->vlan_features | NETIF_F_HW_VLAN_TX);
2027
2028         if (protocol != htons(ETH_P_8021Q)) {
2029                 return harmonize_features(skb, protocol, features);
2030         } else {
2031                 features &= NETIF_F_SG | NETIF_F_HIGHDMA | NETIF_F_FRAGLIST |
2032                                 NETIF_F_GEN_CSUM | NETIF_F_HW_VLAN_TX;
2033                 return harmonize_features(skb, protocol, features);
2034         }
2035 }
2036 EXPORT_SYMBOL(netif_skb_features);
2037
2038 /*
2039  * Returns true if either:
2040  *      1. skb has frag_list and the device doesn't support FRAGLIST, or
2041  *      2. skb is fragmented and the device does not support SG, or if
2042  *         at least one of fragments is in highmem and device does not
2043  *         support DMA from it.
2044  */
2045 static inline int skb_needs_linearize(struct sk_buff *skb,
2046                                       int features)
2047 {
2048         return skb_is_nonlinear(skb) &&
2049                         ((skb_has_frag_list(skb) &&
2050                                 !(features & NETIF_F_FRAGLIST)) ||
2051                         (skb_shinfo(skb)->nr_frags &&
2052                                 !(features & NETIF_F_SG)));
2053 }
2054
2055 int dev_hard_start_xmit(struct sk_buff *skb, struct net_device *dev,
2056                         struct netdev_queue *txq)
2057 {
2058         const struct net_device_ops *ops = dev->netdev_ops;
2059         int rc = NETDEV_TX_OK;
2060
2061         if (likely(!skb->next)) {
2062                 int features;
2063
2064                 /*
2065                  * If device doesnt need skb->dst, release it right now while
2066                  * its hot in this cpu cache
2067                  */
2068                 if (dev->priv_flags & IFF_XMIT_DST_RELEASE)
2069                         skb_dst_drop(skb);
2070
2071                 if (!list_empty(&ptype_all))
2072                         dev_queue_xmit_nit(skb, dev);
2073
2074                 skb_orphan_try(skb);
2075
2076                 features = netif_skb_features(skb);
2077
2078                 if (vlan_tx_tag_present(skb) &&
2079                     !(features & NETIF_F_HW_VLAN_TX)) {
2080                         skb = __vlan_put_tag(skb, vlan_tx_tag_get(skb));
2081                         if (unlikely(!skb))
2082                                 goto out;
2083
2084                         skb->vlan_tci = 0;
2085                 }
2086
2087                 if (netif_needs_gso(skb, features)) {
2088                         if (unlikely(dev_gso_segment(skb, features)))
2089                                 goto out_kfree_skb;
2090                         if (skb->next)
2091                                 goto gso;
2092                 } else {
2093                         if (skb_needs_linearize(skb, features) &&
2094                             __skb_linearize(skb))
2095                                 goto out_kfree_skb;
2096
2097                         /* If packet is not checksummed and device does not
2098                          * support checksumming for this protocol, complete
2099                          * checksumming here.
2100                          */
2101                         if (skb->ip_summed == CHECKSUM_PARTIAL) {
2102                                 skb_set_transport_header(skb,
2103                                         skb_checksum_start_offset(skb));
2104                                 if (!(features & NETIF_F_ALL_CSUM) &&
2105                                      skb_checksum_help(skb))
2106                                         goto out_kfree_skb;
2107                         }
2108                 }
2109
2110                 rc = ops->ndo_start_xmit(skb, dev);
2111                 trace_net_dev_xmit(skb, rc);
2112                 if (rc == NETDEV_TX_OK)
2113                         txq_trans_update(txq);
2114                 return rc;
2115         }
2116
2117 gso:
2118         do {
2119                 struct sk_buff *nskb = skb->next;
2120
2121                 skb->next = nskb->next;
2122                 nskb->next = NULL;
2123
2124                 /*
2125                  * If device doesnt need nskb->dst, release it right now while
2126                  * its hot in this cpu cache
2127                  */
2128                 if (dev->priv_flags & IFF_XMIT_DST_RELEASE)
2129                         skb_dst_drop(nskb);
2130
2131                 rc = ops->ndo_start_xmit(nskb, dev);
2132                 trace_net_dev_xmit(nskb, rc);
2133                 if (unlikely(rc != NETDEV_TX_OK)) {
2134                         if (rc & ~NETDEV_TX_MASK)
2135                                 goto out_kfree_gso_skb;
2136                         nskb->next = skb->next;
2137                         skb->next = nskb;
2138                         return rc;
2139                 }
2140                 txq_trans_update(txq);
2141                 if (unlikely(netif_tx_queue_stopped(txq) && skb->next))
2142                         return NETDEV_TX_BUSY;
2143         } while (skb->next);
2144
2145 out_kfree_gso_skb:
2146         if (likely(skb->next == NULL))
2147                 skb->destructor = DEV_GSO_CB(skb)->destructor;
2148 out_kfree_skb:
2149         kfree_skb(skb);
2150 out:
2151         return rc;
2152 }
2153
2154 static u32 hashrnd __read_mostly;
2155
2156 /*
2157  * Returns a Tx hash based on the given packet descriptor a Tx queues' number
2158  * to be used as a distribution range.
2159  */
2160 u16 __skb_tx_hash(const struct net_device *dev, const struct sk_buff *skb,
2161                   unsigned int num_tx_queues)
2162 {
2163         u32 hash;
2164
2165         if (skb_rx_queue_recorded(skb)) {
2166                 hash = skb_get_rx_queue(skb);
2167                 while (unlikely(hash >= num_tx_queues))
2168                         hash -= num_tx_queues;
2169                 return hash;
2170         }
2171
2172         if (skb->sk && skb->sk->sk_hash)
2173                 hash = skb->sk->sk_hash;
2174         else
2175                 hash = (__force u16) skb->protocol ^ skb->rxhash;
2176         hash = jhash_1word(hash, hashrnd);
2177
2178         return (u16) (((u64) hash * num_tx_queues) >> 32);
2179 }
2180 EXPORT_SYMBOL(__skb_tx_hash);
2181
2182 static inline u16 dev_cap_txqueue(struct net_device *dev, u16 queue_index)
2183 {
2184         if (unlikely(queue_index >= dev->real_num_tx_queues)) {
2185                 if (net_ratelimit()) {
2186                         pr_warning("%s selects TX queue %d, but "
2187                                 "real number of TX queues is %d\n",
2188                                 dev->name, queue_index, dev->real_num_tx_queues);
2189                 }
2190                 return 0;
2191         }
2192         return queue_index;
2193 }
2194
2195 static inline int get_xps_queue(struct net_device *dev, struct sk_buff *skb)
2196 {
2197 #ifdef CONFIG_XPS
2198         struct xps_dev_maps *dev_maps;
2199         struct xps_map *map;
2200         int queue_index = -1;
2201
2202         rcu_read_lock();
2203         dev_maps = rcu_dereference(dev->xps_maps);
2204         if (dev_maps) {
2205                 map = rcu_dereference(
2206                     dev_maps->cpu_map[raw_smp_processor_id()]);
2207                 if (map) {
2208                         if (map->len == 1)
2209                                 queue_index = map->queues[0];
2210                         else {
2211                                 u32 hash;
2212                                 if (skb->sk && skb->sk->sk_hash)
2213                                         hash = skb->sk->sk_hash;
2214                                 else
2215                                         hash = (__force u16) skb->protocol ^
2216                                             skb->rxhash;
2217                                 hash = jhash_1word(hash, hashrnd);
2218                                 queue_index = map->queues[
2219                                     ((u64)hash * map->len) >> 32];
2220                         }
2221                         if (unlikely(queue_index >= dev->real_num_tx_queues))
2222                                 queue_index = -1;
2223                 }
2224         }
2225         rcu_read_unlock();
2226
2227         return queue_index;
2228 #else
2229         return -1;
2230 #endif
2231 }
2232
2233 static struct netdev_queue *dev_pick_tx(struct net_device *dev,
2234                                         struct sk_buff *skb)
2235 {
2236         int queue_index;
2237         const struct net_device_ops *ops = dev->netdev_ops;
2238
2239         if (dev->real_num_tx_queues == 1)
2240                 queue_index = 0;
2241         else if (ops->ndo_select_queue) {
2242                 queue_index = ops->ndo_select_queue(dev, skb);
2243                 queue_index = dev_cap_txqueue(dev, queue_index);
2244         } else {
2245                 struct sock *sk = skb->sk;
2246                 queue_index = sk_tx_queue_get(sk);
2247
2248                 if (queue_index < 0 || skb->ooo_okay ||
2249                     queue_index >= dev->real_num_tx_queues) {
2250                         int old_index = queue_index;
2251
2252                         queue_index = get_xps_queue(dev, skb);
2253                         if (queue_index < 0)
2254                                 queue_index = skb_tx_hash(dev, skb);
2255
2256                         if (queue_index != old_index && sk) {
2257                                 struct dst_entry *dst =
2258                                     rcu_dereference_check(sk->sk_dst_cache, 1);
2259
2260                                 if (dst && skb_dst(skb) == dst)
2261                                         sk_tx_queue_set(sk, queue_index);
2262                         }
2263                 }
2264         }
2265
2266         skb_set_queue_mapping(skb, queue_index);
2267         return netdev_get_tx_queue(dev, queue_index);
2268 }
2269
2270 static inline int __dev_xmit_skb(struct sk_buff *skb, struct Qdisc *q,
2271                                  struct net_device *dev,
2272                                  struct netdev_queue *txq)
2273 {
2274         spinlock_t *root_lock = qdisc_lock(q);
2275         bool contended = qdisc_is_running(q);
2276         int rc;
2277
2278         /*
2279          * Heuristic to force contended enqueues to serialize on a
2280          * separate lock before trying to get qdisc main lock.
2281          * This permits __QDISC_STATE_RUNNING owner to get the lock more often
2282          * and dequeue packets faster.
2283          */
2284         if (unlikely(contended))
2285                 spin_lock(&q->busylock);
2286
2287         spin_lock(root_lock);
2288         if (unlikely(test_bit(__QDISC_STATE_DEACTIVATED, &q->state))) {
2289                 kfree_skb(skb);
2290                 rc = NET_XMIT_DROP;
2291         } else if ((q->flags & TCQ_F_CAN_BYPASS) && !qdisc_qlen(q) &&
2292                    qdisc_run_begin(q)) {
2293                 /*
2294                  * This is a work-conserving queue; there are no old skbs
2295                  * waiting to be sent out; and the qdisc is not running -
2296                  * xmit the skb directly.
2297                  */
2298                 if (!(dev->priv_flags & IFF_XMIT_DST_RELEASE))
2299                         skb_dst_force(skb);
2300
2301                 qdisc_skb_cb(skb)->pkt_len = skb->len;
2302                 qdisc_bstats_update(q, skb);
2303
2304                 if (sch_direct_xmit(skb, q, dev, txq, root_lock)) {
2305                         if (unlikely(contended)) {
2306                                 spin_unlock(&q->busylock);
2307                                 contended = false;
2308                         }
2309                         __qdisc_run(q);
2310                 } else
2311                         qdisc_run_end(q);
2312
2313                 rc = NET_XMIT_SUCCESS;
2314         } else {
2315                 skb_dst_force(skb);
2316                 rc = qdisc_enqueue_root(skb, q);
2317                 if (qdisc_run_begin(q)) {
2318                         if (unlikely(contended)) {
2319                                 spin_unlock(&q->busylock);
2320                                 contended = false;
2321                         }
2322                         __qdisc_run(q);
2323                 }
2324         }
2325         spin_unlock(root_lock);
2326         if (unlikely(contended))
2327                 spin_unlock(&q->busylock);
2328         return rc;
2329 }
2330
2331 static DEFINE_PER_CPU(int, xmit_recursion);
2332 #define RECURSION_LIMIT 10
2333
2334 /**
2335  *      dev_queue_xmit - transmit a buffer
2336  *      @skb: buffer to transmit
2337  *
2338  *      Queue a buffer for transmission to a network device. The caller must
2339  *      have set the device and priority and built the buffer before calling
2340  *      this function. The function can be called from an interrupt.
2341  *
2342  *      A negative errno code is returned on a failure. A success does not
2343  *      guarantee the frame will be transmitted as it may be dropped due
2344  *      to congestion or traffic shaping.
2345  *
2346  * -----------------------------------------------------------------------------------
2347  *      I notice this method can also return errors from the queue disciplines,
2348  *      including NET_XMIT_DROP, which is a positive value.  So, errors can also
2349  *      be positive.
2350  *
2351  *      Regardless of the return value, the skb is consumed, so it is currently
2352  *      difficult to retry a send to this method.  (You can bump the ref count
2353  *      before sending to hold a reference for retry if you are careful.)
2354  *
2355  *      When calling this method, interrupts MUST be enabled.  This is because
2356  *      the BH enable code must have IRQs enabled so that it will not deadlock.
2357  *          --BLG
2358  */
2359 int dev_queue_xmit(struct sk_buff *skb)
2360 {
2361         struct net_device *dev = skb->dev;
2362         struct netdev_queue *txq;
2363         struct Qdisc *q;
2364         int rc = -ENOMEM;
2365
2366         /* Disable soft irqs for various locks below. Also
2367          * stops preemption for RCU.
2368          */
2369         rcu_read_lock_bh();
2370
2371         txq = dev_pick_tx(dev, skb);
2372         q = rcu_dereference_bh(txq->qdisc);
2373
2374 #ifdef CONFIG_NET_CLS_ACT
2375         skb->tc_verd = SET_TC_AT(skb->tc_verd, AT_EGRESS);
2376 #endif
2377         trace_net_dev_queue(skb);
2378         if (q->enqueue) {
2379                 rc = __dev_xmit_skb(skb, q, dev, txq);
2380                 goto out;
2381         }
2382
2383         /* The device has no queue. Common case for software devices:
2384            loopback, all the sorts of tunnels...
2385
2386            Really, it is unlikely that netif_tx_lock protection is necessary
2387            here.  (f.e. loopback and IP tunnels are clean ignoring statistics
2388            counters.)
2389            However, it is possible, that they rely on protection
2390            made by us here.
2391
2392            Check this and shot the lock. It is not prone from deadlocks.
2393            Either shot noqueue qdisc, it is even simpler 8)
2394          */
2395         if (dev->flags & IFF_UP) {
2396                 int cpu = smp_processor_id(); /* ok because BHs are off */
2397
2398                 if (txq->xmit_lock_owner != cpu) {
2399
2400                         if (__this_cpu_read(xmit_recursion) > RECURSION_LIMIT)
2401                                 goto recursion_alert;
2402
2403                         HARD_TX_LOCK(dev, txq, cpu);
2404
2405                         if (!netif_tx_queue_stopped(txq)) {
2406                                 __this_cpu_inc(xmit_recursion);
2407                                 rc = dev_hard_start_xmit(skb, dev, txq);
2408                                 __this_cpu_dec(xmit_recursion);
2409                                 if (dev_xmit_complete(rc)) {
2410                                         HARD_TX_UNLOCK(dev, txq);
2411                                         goto out;
2412                                 }
2413                         }
2414                         HARD_TX_UNLOCK(dev, txq);
2415                         if (net_ratelimit())
2416                                 printk(KERN_CRIT "Virtual device %s asks to "
2417                                        "queue packet!\n", dev->name);
2418                 } else {
2419                         /* Recursion is detected! It is possible,
2420                          * unfortunately
2421                          */
2422 recursion_alert:
2423                         if (net_ratelimit())
2424                                 printk(KERN_CRIT "Dead loop on virtual device "
2425                                        "%s, fix it urgently!\n", dev->name);
2426                 }
2427         }
2428
2429         rc = -ENETDOWN;
2430         rcu_read_unlock_bh();
2431
2432         kfree_skb(skb);
2433         return rc;
2434 out:
2435         rcu_read_unlock_bh();
2436         return rc;
2437 }
2438 EXPORT_SYMBOL(dev_queue_xmit);
2439
2440
2441 /*=======================================================================
2442                         Receiver routines
2443   =======================================================================*/
2444
2445 int netdev_max_backlog __read_mostly = 1000;
2446 int netdev_tstamp_prequeue __read_mostly = 1;
2447 int netdev_budget __read_mostly = 300;
2448 int weight_p __read_mostly = 64;            /* old backlog weight */
2449
2450 /* Called with irq disabled */
2451 static inline void ____napi_schedule(struct softnet_data *sd,
2452                                      struct napi_struct *napi)
2453 {
2454         list_add_tail(&napi->poll_list, &sd->poll_list);
2455         __raise_softirq_irqoff(NET_RX_SOFTIRQ);
2456 }
2457
2458 /*
2459  * __skb_get_rxhash: calculate a flow hash based on src/dst addresses
2460  * and src/dst port numbers. Returns a non-zero hash number on success
2461  * and 0 on failure.
2462  */
2463 __u32 __skb_get_rxhash(struct sk_buff *skb)
2464 {
2465         int nhoff, hash = 0, poff;
2466         struct ipv6hdr *ip6;
2467         struct iphdr *ip;
2468         u8 ip_proto;
2469         u32 addr1, addr2, ihl;
2470         union {
2471                 u32 v32;
2472                 u16 v16[2];
2473         } ports;
2474
2475         nhoff = skb_network_offset(skb);
2476
2477         switch (skb->protocol) {
2478         case __constant_htons(ETH_P_IP):
2479                 if (!pskb_may_pull(skb, sizeof(*ip) + nhoff))
2480                         goto done;
2481
2482                 ip = (struct iphdr *) (skb->data + nhoff);
2483                 if (ip->frag_off & htons(IP_MF | IP_OFFSET))
2484                         ip_proto = 0;
2485                 else
2486                         ip_proto = ip->protocol;
2487                 addr1 = (__force u32) ip->saddr;
2488                 addr2 = (__force u32) ip->daddr;
2489                 ihl = ip->ihl;
2490                 break;
2491         case __constant_htons(ETH_P_IPV6):
2492                 if (!pskb_may_pull(skb, sizeof(*ip6) + nhoff))
2493                         goto done;
2494
2495                 ip6 = (struct ipv6hdr *) (skb->data + nhoff);
2496                 ip_proto = ip6->nexthdr;
2497                 addr1 = (__force u32) ip6->saddr.s6_addr32[3];
2498                 addr2 = (__force u32) ip6->daddr.s6_addr32[3];
2499                 ihl = (40 >> 2);
2500                 break;
2501         default:
2502                 goto done;
2503         }
2504
2505         ports.v32 = 0;
2506         poff = proto_ports_offset(ip_proto);
2507         if (poff >= 0) {
2508                 nhoff += ihl * 4 + poff;
2509                 if (pskb_may_pull(skb, nhoff + 4)) {
2510                         ports.v32 = * (__force u32 *) (skb->data + nhoff);
2511                         if (ports.v16[1] < ports.v16[0])
2512                                 swap(ports.v16[0], ports.v16[1]);
2513                 }
2514         }
2515
2516         /* get a consistent hash (same value on both flow directions) */
2517         if (addr2 < addr1)
2518                 swap(addr1, addr2);
2519
2520         hash = jhash_3words(addr1, addr2, ports.v32, hashrnd);
2521         if (!hash)
2522                 hash = 1;
2523
2524 done:
2525         return hash;
2526 }
2527 EXPORT_SYMBOL(__skb_get_rxhash);
2528
2529 #ifdef CONFIG_RPS
2530
2531 /* One global table that all flow-based protocols share. */
2532 struct rps_sock_flow_table __rcu *rps_sock_flow_table __read_mostly;
2533 EXPORT_SYMBOL(rps_sock_flow_table);
2534
2535 /*
2536  * get_rps_cpu is called from netif_receive_skb and returns the target
2537  * CPU from the RPS map of the receiving queue for a given skb.
2538  * rcu_read_lock must be held on entry.
2539  */
2540 static int get_rps_cpu(struct net_device *dev, struct sk_buff *skb,
2541                        struct rps_dev_flow **rflowp)
2542 {
2543         struct netdev_rx_queue *rxqueue;
2544         struct rps_map *map;
2545         struct rps_dev_flow_table *flow_table;
2546         struct rps_sock_flow_table *sock_flow_table;
2547         int cpu = -1;
2548         u16 tcpu;
2549
2550         if (skb_rx_queue_recorded(skb)) {
2551                 u16 index = skb_get_rx_queue(skb);
2552                 if (unlikely(index >= dev->real_num_rx_queues)) {
2553                         WARN_ONCE(dev->real_num_rx_queues > 1,
2554                                   "%s received packet on queue %u, but number "
2555                                   "of RX queues is %u\n",
2556                                   dev->name, index, dev->real_num_rx_queues);
2557                         goto done;
2558                 }
2559                 rxqueue = dev->_rx + index;
2560         } else
2561                 rxqueue = dev->_rx;
2562
2563         map = rcu_dereference(rxqueue->rps_map);
2564         if (map) {
2565                 if (map->len == 1) {
2566                         tcpu = map->cpus[0];
2567                         if (cpu_online(tcpu))
2568                                 cpu = tcpu;
2569                         goto done;
2570                 }
2571         } else if (!rcu_dereference_raw(rxqueue->rps_flow_table)) {
2572                 goto done;
2573         }
2574
2575         skb_reset_network_header(skb);
2576         if (!skb_get_rxhash(skb))
2577                 goto done;
2578
2579         flow_table = rcu_dereference(rxqueue->rps_flow_table);
2580         sock_flow_table = rcu_dereference(rps_sock_flow_table);
2581         if (flow_table && sock_flow_table) {
2582                 u16 next_cpu;
2583                 struct rps_dev_flow *rflow;
2584
2585                 rflow = &flow_table->flows[skb->rxhash & flow_table->mask];
2586                 tcpu = rflow->cpu;
2587
2588                 next_cpu = sock_flow_table->ents[skb->rxhash &
2589                     sock_flow_table->mask];
2590
2591                 /*
2592                  * If the desired CPU (where last recvmsg was done) is
2593                  * different from current CPU (one in the rx-queue flow
2594                  * table entry), switch if one of the following holds:
2595                  *   - Current CPU is unset (equal to RPS_NO_CPU).
2596                  *   - Current CPU is offline.
2597                  *   - The current CPU's queue tail has advanced beyond the
2598                  *     last packet that was enqueued using this table entry.
2599                  *     This guarantees that all previous packets for the flow
2600                  *     have been dequeued, thus preserving in order delivery.
2601                  */
2602                 if (unlikely(tcpu != next_cpu) &&
2603                     (tcpu == RPS_NO_CPU || !cpu_online(tcpu) ||
2604                      ((int)(per_cpu(softnet_data, tcpu).input_queue_head -
2605                       rflow->last_qtail)) >= 0)) {
2606                         tcpu = rflow->cpu = next_cpu;
2607                         if (tcpu != RPS_NO_CPU)
2608                                 rflow->last_qtail = per_cpu(softnet_data,
2609                                     tcpu).input_queue_head;
2610                 }
2611                 if (tcpu != RPS_NO_CPU && cpu_online(tcpu)) {
2612                         *rflowp = rflow;
2613                         cpu = tcpu;
2614                         goto done;
2615                 }
2616         }
2617
2618         if (map) {
2619                 tcpu = map->cpus[((u64) skb->rxhash * map->len) >> 32];
2620
2621                 if (cpu_online(tcpu)) {
2622                         cpu = tcpu;
2623                         goto done;
2624                 }
2625         }
2626
2627 done:
2628         return cpu;
2629 }
2630
2631 /* Called from hardirq (IPI) context */
2632 static void rps_trigger_softirq(void *data)
2633 {
2634         struct softnet_data *sd = data;
2635
2636         ____napi_schedule(sd, &sd->backlog);
2637         sd->received_rps++;
2638 }
2639
2640 #endif /* CONFIG_RPS */
2641
2642 /*
2643  * Check if this softnet_data structure is another cpu one
2644  * If yes, queue it to our IPI list and return 1
2645  * If no, return 0
2646  */
2647 static int rps_ipi_queued(struct softnet_data *sd)
2648 {
2649 #ifdef CONFIG_RPS
2650         struct softnet_data *mysd = &__get_cpu_var(softnet_data);
2651
2652         if (sd != mysd) {
2653                 sd->rps_ipi_next = mysd->rps_ipi_list;
2654                 mysd->rps_ipi_list = sd;
2655
2656                 __raise_softirq_irqoff(NET_RX_SOFTIRQ);
2657                 return 1;
2658         }
2659 #endif /* CONFIG_RPS */
2660         return 0;
2661 }
2662
2663 /*
2664  * enqueue_to_backlog is called to queue an skb to a per CPU backlog
2665  * queue (may be a remote CPU queue).
2666  */
2667 static int enqueue_to_backlog(struct sk_buff *skb, int cpu,
2668                               unsigned int *qtail)
2669 {
2670         struct softnet_data *sd;
2671         unsigned long flags;
2672
2673         sd = &per_cpu(softnet_data, cpu);
2674
2675         local_irq_save(flags);
2676
2677         rps_lock(sd);
2678         if (skb_queue_len(&sd->input_pkt_queue) <= netdev_max_backlog) {
2679                 if (skb_queue_len(&sd->input_pkt_queue)) {
2680 enqueue:
2681                         __skb_queue_tail(&sd->input_pkt_queue, skb);
2682                         input_queue_tail_incr_save(sd, qtail);
2683                         rps_unlock(sd);
2684                         local_irq_restore(flags);
2685                         return NET_RX_SUCCESS;
2686                 }
2687
2688                 /* Schedule NAPI for backlog device
2689                  * We can use non atomic operation since we own the queue lock
2690                  */
2691                 if (!__test_and_set_bit(NAPI_STATE_SCHED, &sd->backlog.state)) {
2692                         if (!rps_ipi_queued(sd))
2693                                 ____napi_schedule(sd, &sd->backlog);
2694                 }
2695                 goto enqueue;
2696         }
2697
2698         sd->dropped++;
2699         rps_unlock(sd);
2700
2701         local_irq_restore(flags);
2702
2703         atomic_long_inc(&skb->dev->rx_dropped);
2704         kfree_skb(skb);
2705         return NET_RX_DROP;
2706 }
2707
2708 /**
2709  *      netif_rx        -       post buffer to the network code
2710  *      @skb: buffer to post
2711  *
2712  *      This function receives a packet from a device driver and queues it for
2713  *      the upper (protocol) levels to process.  It always succeeds. The buffer
2714  *      may be dropped during processing for congestion control or by the
2715  *      protocol layers.
2716  *
2717  *      return values:
2718  *      NET_RX_SUCCESS  (no congestion)
2719  *      NET_RX_DROP     (packet was dropped)
2720  *
2721  */
2722
2723 int netif_rx(struct sk_buff *skb)
2724 {
2725         int ret;
2726
2727         /* if netpoll wants it, pretend we never saw it */
2728         if (netpoll_rx(skb))
2729                 return NET_RX_DROP;
2730
2731         if (netdev_tstamp_prequeue)
2732                 net_timestamp_check(skb);
2733
2734         trace_netif_rx(skb);
2735 #ifdef CONFIG_RPS
2736         {
2737                 struct rps_dev_flow voidflow, *rflow = &voidflow;
2738                 int cpu;
2739
2740                 preempt_disable();
2741                 rcu_read_lock();
2742
2743                 cpu = get_rps_cpu(skb->dev, skb, &rflow);
2744                 if (cpu < 0)
2745                         cpu = smp_processor_id();
2746
2747                 ret = enqueue_to_backlog(skb, cpu, &rflow->last_qtail);
2748
2749                 rcu_read_unlock();
2750                 preempt_enable();
2751         }
2752 #else
2753         {
2754                 unsigned int qtail;
2755                 ret = enqueue_to_backlog(skb, get_cpu(), &qtail);
2756                 put_cpu();
2757         }
2758 #endif
2759         return ret;
2760 }
2761 EXPORT_SYMBOL(netif_rx);
2762
2763 int netif_rx_ni(struct sk_buff *skb)
2764 {
2765         int err;
2766
2767         preempt_disable();
2768         err = netif_rx(skb);
2769         if (local_softirq_pending())
2770                 do_softirq();
2771         preempt_enable();
2772
2773         return err;
2774 }
2775 EXPORT_SYMBOL(netif_rx_ni);
2776
2777 static void net_tx_action(struct softirq_action *h)
2778 {
2779         struct softnet_data *sd = &__get_cpu_var(softnet_data);
2780
2781         if (sd->completion_queue) {
2782                 struct sk_buff *clist;
2783
2784                 local_irq_disable();
2785                 clist = sd->completion_queue;
2786                 sd->completion_queue = NULL;
2787                 local_irq_enable();
2788
2789                 while (clist) {
2790                         struct sk_buff *skb = clist;
2791                         clist = clist->next;
2792
2793                         WARN_ON(atomic_read(&skb->users));
2794                         trace_kfree_skb(skb, net_tx_action);
2795                         __kfree_skb(skb);
2796                 }
2797         }
2798
2799         if (sd->output_queue) {
2800                 struct Qdisc *head;
2801
2802                 local_irq_disable();
2803                 head = sd->output_queue;
2804                 sd->output_queue = NULL;
2805                 sd->output_queue_tailp = &sd->output_queue;
2806                 local_irq_enable();
2807
2808                 while (head) {
2809                         struct Qdisc *q = head;
2810                         spinlock_t *root_lock;
2811
2812                         head = head->next_sched;
2813
2814                         root_lock = qdisc_lock(q);
2815                         if (spin_trylock(root_lock)) {
2816                                 smp_mb__before_clear_bit();
2817                                 clear_bit(__QDISC_STATE_SCHED,
2818                                           &q->state);
2819                                 qdisc_run(q);
2820                                 spin_unlock(root_lock);
2821                         } else {
2822                                 if (!test_bit(__QDISC_STATE_DEACTIVATED,
2823                                               &q->state)) {
2824                                         __netif_reschedule(q);
2825                                 } else {
2826                                         smp_mb__before_clear_bit();
2827                                         clear_bit(__QDISC_STATE_SCHED,
2828                                                   &q->state);
2829                                 }
2830                         }
2831                 }
2832         }
2833 }
2834
2835 #if (defined(CONFIG_BRIDGE) || defined(CONFIG_BRIDGE_MODULE)) && \
2836     (defined(CONFIG_ATM_LANE) || defined(CONFIG_ATM_LANE_MODULE))
2837 /* This hook is defined here for ATM LANE */
2838 int (*br_fdb_test_addr_hook)(struct net_device *dev,
2839                              unsigned char *addr) __read_mostly;
2840 EXPORT_SYMBOL_GPL(br_fdb_test_addr_hook);
2841 #endif
2842
2843 #ifdef CONFIG_NET_CLS_ACT
2844 /* TODO: Maybe we should just force sch_ingress to be compiled in
2845  * when CONFIG_NET_CLS_ACT is? otherwise some useless instructions
2846  * a compare and 2 stores extra right now if we dont have it on
2847  * but have CONFIG_NET_CLS_ACT
2848  * NOTE: This doesnt stop any functionality; if you dont have
2849  * the ingress scheduler, you just cant add policies on ingress.
2850  *
2851  */
2852 static int ing_filter(struct sk_buff *skb, struct netdev_queue *rxq)
2853 {
2854         struct net_device *dev = skb->dev;
2855         u32 ttl = G_TC_RTTL(skb->tc_verd);
2856         int result = TC_ACT_OK;
2857         struct Qdisc *q;
2858
2859         if (unlikely(MAX_RED_LOOP < ttl++)) {
2860                 if (net_ratelimit())
2861                         pr_warning( "Redir loop detected Dropping packet (%d->%d)\n",
2862                                skb->skb_iif, dev->ifindex);
2863                 return TC_ACT_SHOT;
2864         }
2865
2866         skb->tc_verd = SET_TC_RTTL(skb->tc_verd, ttl);
2867         skb->tc_verd = SET_TC_AT(skb->tc_verd, AT_INGRESS);
2868
2869         q = rxq->qdisc;
2870         if (q != &noop_qdisc) {
2871                 spin_lock(qdisc_lock(q));
2872                 if (likely(!test_bit(__QDISC_STATE_DEACTIVATED, &q->state)))
2873                         result = qdisc_enqueue_root(skb, q);
2874                 spin_unlock(qdisc_lock(q));
2875         }
2876
2877         return result;
2878 }
2879
2880 static inline struct sk_buff *handle_ing(struct sk_buff *skb,
2881                                          struct packet_type **pt_prev,
2882                                          int *ret, struct net_device *orig_dev)
2883 {
2884         struct netdev_queue *rxq = rcu_dereference(skb->dev->ingress_queue);
2885
2886         if (!rxq || rxq->qdisc == &noop_qdisc)
2887                 goto out;
2888
2889         if (*pt_prev) {
2890                 *ret = deliver_skb(skb, *pt_prev, orig_dev);
2891                 *pt_prev = NULL;
2892         }
2893
2894         switch (ing_filter(skb, rxq)) {
2895         case TC_ACT_SHOT:
2896         case TC_ACT_STOLEN:
2897                 kfree_skb(skb);
2898                 return NULL;
2899         }
2900
2901 out:
2902         skb->tc_verd = 0;
2903         return skb;
2904 }
2905 #endif
2906
2907 /**
2908  *      netdev_rx_handler_register - register receive handler
2909  *      @dev: device to register a handler for
2910  *      @rx_handler: receive handler to register
2911  *      @rx_handler_data: data pointer that is used by rx handler
2912  *
2913  *      Register a receive hander for a device. This handler will then be
2914  *      called from __netif_receive_skb. A negative errno code is returned
2915  *      on a failure.
2916  *
2917  *      The caller must hold the rtnl_mutex.
2918  */
2919 int netdev_rx_handler_register(struct net_device *dev,
2920                                rx_handler_func_t *rx_handler,
2921                                void *rx_handler_data)
2922 {
2923         ASSERT_RTNL();
2924
2925         if (dev->rx_handler)
2926                 return -EBUSY;
2927
2928         rcu_assign_pointer(dev->rx_handler_data, rx_handler_data);
2929         rcu_assign_pointer(dev->rx_handler, rx_handler);
2930
2931         return 0;
2932 }
2933 EXPORT_SYMBOL_GPL(netdev_rx_handler_register);
2934
2935 /**
2936  *      netdev_rx_handler_unregister - unregister receive handler
2937  *      @dev: device to unregister a handler from
2938  *
2939  *      Unregister a receive hander from a device.
2940  *
2941  *      The caller must hold the rtnl_mutex.
2942  */
2943 void netdev_rx_handler_unregister(struct net_device *dev)
2944 {
2945
2946         ASSERT_RTNL();
2947         rcu_assign_pointer(dev->rx_handler, NULL);
2948         rcu_assign_pointer(dev->rx_handler_data, NULL);
2949 }
2950 EXPORT_SYMBOL_GPL(netdev_rx_handler_unregister);
2951
2952 static inline void skb_bond_set_mac_by_master(struct sk_buff *skb,
2953                                               struct net_device *master)
2954 {
2955         if (skb->pkt_type == PACKET_HOST) {
2956                 u16 *dest = (u16 *) eth_hdr(skb)->h_dest;
2957
2958                 memcpy(dest, master->dev_addr, ETH_ALEN);
2959         }
2960 }
2961
2962 /* On bonding slaves other than the currently active slave, suppress
2963  * duplicates except for 802.3ad ETH_P_SLOW, alb non-mcast/bcast, and
2964  * ARP on active-backup slaves with arp_validate enabled.
2965  */
2966 int __skb_bond_should_drop(struct sk_buff *skb, struct net_device *master)
2967 {
2968         struct net_device *dev = skb->dev;
2969
2970         if (master->priv_flags & IFF_MASTER_ARPMON)
2971                 dev->last_rx = jiffies;
2972
2973         if ((master->priv_flags & IFF_MASTER_ALB) &&
2974             (master->priv_flags & IFF_BRIDGE_PORT)) {
2975                 /* Do address unmangle. The local destination address
2976                  * will be always the one master has. Provides the right
2977                  * functionality in a bridge.
2978                  */
2979                 skb_bond_set_mac_by_master(skb, master);
2980         }
2981
2982         if (dev->priv_flags & IFF_SLAVE_INACTIVE) {
2983                 if ((dev->priv_flags & IFF_SLAVE_NEEDARP) &&
2984                     skb->protocol == __cpu_to_be16(ETH_P_ARP))
2985                         return 0;
2986
2987                 if (master->priv_flags & IFF_MASTER_ALB) {
2988                         if (skb->pkt_type != PACKET_BROADCAST &&
2989                             skb->pkt_type != PACKET_MULTICAST)
2990                                 return 0;
2991                 }
2992                 if (master->priv_flags & IFF_MASTER_8023AD &&
2993                     skb->protocol == __cpu_to_be16(ETH_P_SLOW))
2994                         return 0;
2995
2996                 return 1;
2997         }
2998         return 0;
2999 }
3000 EXPORT_SYMBOL(__skb_bond_should_drop);
3001
3002 static int __netif_receive_skb(struct sk_buff *skb)
3003 {
3004         struct packet_type *ptype, *pt_prev;
3005         rx_handler_func_t *rx_handler;
3006         struct net_device *orig_dev;
3007         struct net_device *master;
3008         struct net_device *null_or_orig;
3009         struct net_device *orig_or_bond;
3010         int ret = NET_RX_DROP;
3011         __be16 type;
3012
3013         if (!netdev_tstamp_prequeue)
3014                 net_timestamp_check(skb);
3015
3016         trace_netif_receive_skb(skb);
3017
3018         /* if we've gotten here through NAPI, check netpoll */
3019         if (netpoll_receive_skb(skb))
3020                 return NET_RX_DROP;
3021
3022         if (!skb->skb_iif)
3023                 skb->skb_iif = skb->dev->ifindex;
3024
3025         /*
3026          * bonding note: skbs received on inactive slaves should only
3027          * be delivered to pkt handlers that are exact matches.  Also
3028          * the deliver_no_wcard flag will be set.  If packet handlers
3029          * are sensitive to duplicate packets these skbs will need to
3030          * be dropped at the handler.
3031          */
3032         null_or_orig = NULL;
3033         orig_dev = skb->dev;
3034         master = ACCESS_ONCE(orig_dev->master);
3035         if (skb->deliver_no_wcard)
3036                 null_or_orig = orig_dev;
3037         else if (master) {
3038                 if (skb_bond_should_drop(skb, master)) {
3039                         skb->deliver_no_wcard = 1;
3040                         null_or_orig = orig_dev; /* deliver only exact match */
3041                 } else
3042                         skb->dev = master;
3043         }
3044
3045         __this_cpu_inc(softnet_data.processed);
3046         skb_reset_network_header(skb);
3047         skb_reset_transport_header(skb);
3048         skb->mac_len = skb->network_header - skb->mac_header;
3049
3050         pt_prev = NULL;
3051
3052         rcu_read_lock();
3053
3054 #ifdef CONFIG_NET_CLS_ACT
3055         if (skb->tc_verd & TC_NCLS) {
3056                 skb->tc_verd = CLR_TC_NCLS(skb->tc_verd);
3057                 goto ncls;
3058         }
3059 #endif
3060
3061         list_for_each_entry_rcu(ptype, &ptype_all, list) {
3062                 if (ptype->dev == null_or_orig || ptype->dev == skb->dev ||
3063                     ptype->dev == orig_dev) {
3064                         if (pt_prev)
3065                                 ret = deliver_skb(skb, pt_prev, orig_dev);
3066                         pt_prev = ptype;
3067                 }
3068         }
3069
3070 #ifdef CONFIG_NET_CLS_ACT
3071         skb = handle_ing(skb, &pt_prev, &ret, orig_dev);
3072         if (!skb)
3073                 goto out;
3074 ncls:
3075 #endif
3076
3077         /* Handle special case of bridge or macvlan */
3078         rx_handler = rcu_dereference(skb->dev->rx_handler);
3079         if (rx_handler) {
3080                 if (pt_prev) {
3081                         ret = deliver_skb(skb, pt_prev, orig_dev);
3082                         pt_prev = NULL;
3083                 }
3084                 skb = rx_handler(skb);
3085                 if (!skb)
3086                         goto out;
3087         }
3088
3089         if (vlan_tx_tag_present(skb)) {
3090                 if (pt_prev) {
3091                         ret = deliver_skb(skb, pt_prev, orig_dev);
3092                         pt_prev = NULL;
3093                 }
3094                 if (vlan_hwaccel_do_receive(&skb)) {
3095                         ret = __netif_receive_skb(skb);
3096                         goto out;
3097                 } else if (unlikely(!skb))
3098                         goto out;
3099         }
3100
3101         /*
3102          * Make sure frames received on VLAN interfaces stacked on
3103          * bonding interfaces still make their way to any base bonding
3104          * device that may have registered for a specific ptype.  The
3105          * handler may have to adjust skb->dev and orig_dev.
3106          */
3107         orig_or_bond = orig_dev;
3108         if ((skb->dev->priv_flags & IFF_802_1Q_VLAN) &&
3109             (vlan_dev_real_dev(skb->dev)->priv_flags & IFF_BONDING)) {
3110                 orig_or_bond = vlan_dev_real_dev(skb->dev);
3111         }
3112
3113         type = skb->protocol;
3114         list_for_each_entry_rcu(ptype,
3115                         &ptype_base[ntohs(type) & PTYPE_HASH_MASK], list) {
3116                 if (ptype->type == type && (ptype->dev == null_or_orig ||
3117                      ptype->dev == skb->dev || ptype->dev == orig_dev ||
3118                      ptype->dev == orig_or_bond)) {
3119                         if (pt_prev)
3120                                 ret = deliver_skb(skb, pt_prev, orig_dev);
3121                         pt_prev = ptype;
3122                 }
3123         }
3124
3125         if (pt_prev) {
3126                 ret = pt_prev->func(skb, skb->dev, pt_prev, orig_dev);
3127         } else {
3128                 atomic_long_inc(&skb->dev->rx_dropped);
3129                 kfree_skb(skb);
3130                 /* Jamal, now you will not able to escape explaining
3131                  * me how you were going to use this. :-)
3132                  */
3133                 ret = NET_RX_DROP;
3134         }
3135
3136 out:
3137         rcu_read_unlock();
3138         return ret;
3139 }
3140
3141 /**
3142  *      netif_receive_skb - process receive buffer from network
3143  *      @skb: buffer to process
3144  *
3145  *      netif_receive_skb() is the main receive data processing function.
3146  *      It always succeeds. The buffer may be dropped during processing
3147  *      for congestion control or by the protocol layers.
3148  *
3149  *      This function may only be called from softirq context and interrupts
3150  *      should be enabled.
3151  *
3152  *      Return values (usually ignored):
3153  *      NET_RX_SUCCESS: no congestion
3154  *      NET_RX_DROP: packet was dropped
3155  */
3156 int netif_receive_skb(struct sk_buff *skb)
3157 {
3158         if (netdev_tstamp_prequeue)
3159                 net_timestamp_check(skb);
3160
3161         if (skb_defer_rx_timestamp(skb))
3162                 return NET_RX_SUCCESS;
3163
3164 #ifdef CONFIG_RPS
3165         {
3166                 struct rps_dev_flow voidflow, *rflow = &voidflow;
3167                 int cpu, ret;
3168
3169                 rcu_read_lock();
3170
3171                 cpu = get_rps_cpu(skb->dev, skb, &rflow);
3172
3173                 if (cpu >= 0) {
3174                         ret = enqueue_to_backlog(skb, cpu, &rflow->last_qtail);
3175                         rcu_read_unlock();
3176                 } else {
3177                         rcu_read_unlock();
3178                         ret = __netif_receive_skb(skb);
3179                 }
3180
3181                 return ret;
3182         }
3183 #else
3184         return __netif_receive_skb(skb);
3185 #endif
3186 }
3187 EXPORT_SYMBOL(netif_receive_skb);
3188
3189 /* Network device is going away, flush any packets still pending
3190  * Called with irqs disabled.
3191  */
3192 static void flush_backlog(void *arg)
3193 {
3194         struct net_device *dev = arg;
3195         struct softnet_data *sd = &__get_cpu_var(softnet_data);
3196         struct sk_buff *skb, *tmp;
3197
3198         rps_lock(sd);
3199         skb_queue_walk_safe(&sd->input_pkt_queue, skb, tmp) {
3200                 if (skb->dev == dev) {
3201                         __skb_unlink(skb, &sd->input_pkt_queue);
3202                         kfree_skb(skb);
3203                         input_queue_head_incr(sd);
3204                 }
3205         }
3206         rps_unlock(sd);
3207
3208         skb_queue_walk_safe(&sd->process_queue, skb, tmp) {
3209                 if (skb->dev == dev) {
3210                         __skb_unlink(skb, &sd->process_queue);
3211                         kfree_skb(skb);
3212                         input_queue_head_incr(sd);
3213                 }
3214         }
3215 }
3216
3217 static int napi_gro_complete(struct sk_buff *skb)
3218 {
3219         struct packet_type *ptype;
3220         __be16 type = skb->protocol;
3221         struct list_head *head = &ptype_base[ntohs(type) & PTYPE_HASH_MASK];
3222         int err = -ENOENT;
3223
3224         if (NAPI_GRO_CB(skb)->count == 1) {
3225                 skb_shinfo(skb)->gso_size = 0;
3226                 goto out;
3227         }
3228
3229         rcu_read_lock();
3230         list_for_each_entry_rcu(ptype, head, list) {
3231                 if (ptype->type != type || ptype->dev || !ptype->gro_complete)
3232                         continue;
3233
3234                 err = ptype->gro_complete(skb);
3235                 break;
3236         }
3237         rcu_read_unlock();
3238
3239         if (err) {
3240                 WARN_ON(&ptype->list == head);
3241                 kfree_skb(skb);
3242                 return NET_RX_SUCCESS;
3243         }
3244
3245 out:
3246         return netif_receive_skb(skb);
3247 }
3248
3249 inline void napi_gro_flush(struct napi_struct *napi)
3250 {
3251         struct sk_buff *skb, *next;
3252
3253         for (skb = napi->gro_list; skb; skb = next) {
3254                 next = skb->next;
3255                 skb->next = NULL;
3256                 napi_gro_complete(skb);
3257         }
3258
3259         napi->gro_count = 0;
3260         napi->gro_list = NULL;
3261 }
3262 EXPORT_SYMBOL(napi_gro_flush);
3263
3264 enum gro_result dev_gro_receive(struct napi_struct *napi, struct sk_buff *skb)
3265 {
3266         struct sk_buff **pp = NULL;
3267         struct packet_type *ptype;
3268         __be16 type = skb->protocol;
3269         struct list_head *head = &ptype_base[ntohs(type) & PTYPE_HASH_MASK];
3270         int same_flow;
3271         int mac_len;
3272         enum gro_result ret;
3273
3274         if (!(skb->dev->features & NETIF_F_GRO) || netpoll_rx_on(skb))
3275                 goto normal;
3276
3277         if (skb_is_gso(skb) || skb_has_frag_list(skb))
3278                 goto normal;
3279
3280         rcu_read_lock();
3281         list_for_each_entry_rcu(ptype, head, list) {
3282                 if (ptype->type != type || ptype->dev || !ptype->gro_receive)
3283                         continue;
3284
3285                 skb_set_network_header(skb, skb_gro_offset(skb));
3286                 mac_len = skb->network_header - skb->mac_header;
3287                 skb->mac_len = mac_len;
3288                 NAPI_GRO_CB(skb)->same_flow = 0;
3289                 NAPI_GRO_CB(skb)->flush = 0;
3290                 NAPI_GRO_CB(skb)->free = 0;
3291
3292                 pp = ptype->gro_receive(&napi->gro_list, skb);
3293                 break;
3294         }
3295         rcu_read_unlock();
3296
3297         if (&ptype->list == head)
3298                 goto normal;
3299
3300         same_flow = NAPI_GRO_CB(skb)->same_flow;
3301         ret = NAPI_GRO_CB(skb)->free ? GRO_MERGED_FREE : GRO_MERGED;
3302
3303         if (pp) {
3304                 struct sk_buff *nskb = *pp;
3305
3306                 *pp = nskb->next;
3307                 nskb->next = NULL;
3308                 napi_gro_complete(nskb);
3309                 napi->gro_count--;
3310         }
3311
3312         if (same_flow)
3313                 goto ok;
3314
3315         if (NAPI_GRO_CB(skb)->flush || napi->gro_count >= MAX_GRO_SKBS)
3316                 goto normal;
3317
3318         napi->gro_count++;
3319         NAPI_GRO_CB(skb)->count = 1;
3320         skb_shinfo(skb)->gso_size = skb_gro_len(skb);
3321         skb->next = napi->gro_list;
3322         napi->gro_list = skb;