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