scm: lower SCM_MAX_FD
[linux-2.6.git] / net / core / dev.c
1 /*
2  *      NET3    Protocol independent device support routines.
3  *
4  *              This program is free software; you can redistribute it and/or
5  *              modify it under the terms of the GNU General Public License
6  *              as published by the Free Software Foundation; either version
7  *              2 of the License, or (at your option) any later version.
8  *
9  *      Derived from the non IP parts of dev.c 1.0.19
10  *              Authors:        Ross Biro
11  *                              Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
12  *                              Mark Evans, <evansmp@uhura.aston.ac.uk>
13  *
14  *      Additional Authors:
15  *              Florian la Roche <rzsfl@rz.uni-sb.de>
16  *              Alan Cox <gw4pts@gw4pts.ampr.org>
17  *              David Hinds <dahinds@users.sourceforge.net>
18  *              Alexey Kuznetsov <kuznet@ms2.inr.ac.ru>
19  *              Adam Sulmicki <adam@cfar.umd.edu>
20  *              Pekka Riikonen <priikone@poesidon.pspt.fi>
21  *
22  *      Changes:
23  *              D.J. Barrow     :       Fixed bug where dev->refcnt gets set
24  *                                      to 2 if register_netdev gets called
25  *                                      before net_dev_init & also removed a
26  *                                      few lines of code in the process.
27  *              Alan Cox        :       device private ioctl copies fields back.
28  *              Alan Cox        :       Transmit queue code does relevant
29  *                                      stunts to keep the queue safe.
30  *              Alan Cox        :       Fixed double lock.
31  *              Alan Cox        :       Fixed promisc NULL pointer trap
32  *              ????????        :       Support the full private ioctl range
33  *              Alan Cox        :       Moved ioctl permission check into
34  *                                      drivers
35  *              Tim Kordas      :       SIOCADDMULTI/SIOCDELMULTI
36  *              Alan Cox        :       100 backlog just doesn't cut it when
37  *                                      you start doing multicast video 8)
38  *              Alan Cox        :       Rewrote net_bh and list manager.
39  *              Alan Cox        :       Fix ETH_P_ALL echoback lengths.
40  *              Alan Cox        :       Took out transmit every packet pass
41  *                                      Saved a few bytes in the ioctl handler
42  *              Alan Cox        :       Network driver sets packet type before
43  *                                      calling netif_rx. Saves a function
44  *                                      call a packet.
45  *              Alan Cox        :       Hashed net_bh()
46  *              Richard Kooijman:       Timestamp fixes.
47  *              Alan Cox        :       Wrong field in SIOCGIFDSTADDR
48  *              Alan Cox        :       Device lock protection.
49  *              Alan Cox        :       Fixed nasty side effect of device close
50  *                                      changes.
51  *              Rudi Cilibrasi  :       Pass the right thing to
52  *                                      set_mac_address()
53  *              Dave Miller     :       32bit quantity for the device lock to
54  *                                      make it work out on a Sparc.
55  *              Bjorn Ekwall    :       Added KERNELD hack.
56  *              Alan Cox        :       Cleaned up the backlog initialise.
57  *              Craig Metz      :       SIOCGIFCONF fix if space for under
58  *                                      1 device.
59  *          Thomas Bogendoerfer :       Return ENODEV for dev_open, if there
60  *                                      is no device open function.
61  *              Andi Kleen      :       Fix error reporting for SIOCGIFCONF
62  *          Michael Chastain    :       Fix signed/unsigned for SIOCGIFCONF
63  *              Cyrus Durgin    :       Cleaned for KMOD
64  *              Adam Sulmicki   :       Bug Fix : Network Device Unload
65  *                                      A network device unload needs to purge
66  *                                      the backlog queue.
67  *      Paul Rusty Russell      :       SIOCSIFNAME
68  *              Pekka Riikonen  :       Netdev boot-time settings code
69  *              Andrew Morton   :       Make unregister_netdevice wait
70  *                                      indefinitely on dev->refcnt
71  *              J Hadi Salim    :       - Backlog queue sampling
72  *                                      - netif_rx() feedback
73  */
74
75 #include <asm/uaccess.h>
76 #include <asm/system.h>
77 #include <linux/bitops.h>
78 #include <linux/capability.h>
79 #include <linux/cpu.h>
80 #include <linux/types.h>
81 #include <linux/kernel.h>
82 #include <linux/hash.h>
83 #include <linux/slab.h>
84 #include <linux/sched.h>
85 #include <linux/mutex.h>
86 #include <linux/string.h>
87 #include <linux/mm.h>
88 #include <linux/socket.h>
89 #include <linux/sockios.h>
90 #include <linux/errno.h>
91 #include <linux/interrupt.h>
92 #include <linux/if_ether.h>
93 #include <linux/netdevice.h>
94 #include <linux/etherdevice.h>
95 #include <linux/ethtool.h>
96 #include <linux/notifier.h>
97 #include <linux/skbuff.h>
98 #include <net/net_namespace.h>
99 #include <net/sock.h>
100 #include <linux/rtnetlink.h>
101 #include <linux/proc_fs.h>
102 #include <linux/seq_file.h>
103 #include <linux/stat.h>
104 #include <net/dst.h>
105 #include <net/pkt_sched.h>
106 #include <net/checksum.h>
107 #include <net/xfrm.h>
108 #include <linux/highmem.h>
109 #include <linux/init.h>
110 #include <linux/kmod.h>
111 #include <linux/module.h>
112 #include <linux/netpoll.h>
113 #include <linux/rcupdate.h>
114 #include <linux/delay.h>
115 #include <net/wext.h>
116 #include <net/iw_handler.h>
117 #include <asm/current.h>
118 #include <linux/audit.h>
119 #include <linux/dmaengine.h>
120 #include <linux/err.h>
121 #include <linux/ctype.h>
122 #include <linux/if_arp.h>
123 #include <linux/if_vlan.h>
124 #include <linux/ip.h>
125 #include <net/ip.h>
126 #include <linux/ipv6.h>
127 #include <linux/in.h>
128 #include <linux/jhash.h>
129 #include <linux/random.h>
130 #include <trace/events/napi.h>
131 #include <trace/events/net.h>
132 #include <trace/events/skb.h>
133 #include <linux/pci.h>
134 #include <linux/inetdevice.h>
135
136 #include "net-sysfs.h"
137
138 /* Instead of increasing this, you should create a hash table. */
139 #define MAX_GRO_SKBS 8
140
141 /* This should be increased if a protocol with a bigger head is added. */
142 #define GRO_MAX_HEAD (MAX_HEADER + 128)
143
144 /*
145  *      The list of packet types we will receive (as opposed to discard)
146  *      and the routines to invoke.
147  *
148  *      Why 16. Because with 16 the only overlap we get on a hash of the
149  *      low nibble of the protocol value is RARP/SNAP/X.25.
150  *
151  *      NOTE:  That is no longer true with the addition of VLAN tags.  Not
152  *             sure which should go first, but I bet it won't make much
153  *             difference if we are running VLANs.  The good news is that
154  *             this protocol won't be in the list unless compiled in, so
155  *             the average user (w/out VLANs) will not be adversely affected.
156  *             --BLG
157  *
158  *              0800    IP
159  *              8100    802.1Q VLAN
160  *              0001    802.3
161  *              0002    AX.25
162  *              0004    802.2
163  *              8035    RARP
164  *              0005    SNAP
165  *              0805    X.25
166  *              0806    ARP
167  *              8137    IPX
168  *              0009    Localtalk
169  *              86DD    IPv6
170  */
171
172 #define PTYPE_HASH_SIZE (16)
173 #define PTYPE_HASH_MASK (PTYPE_HASH_SIZE - 1)
174
175 static DEFINE_SPINLOCK(ptype_lock);
176 static struct list_head ptype_base[PTYPE_HASH_SIZE] __read_mostly;
177 static struct list_head ptype_all __read_mostly;        /* Taps */
178
179 /*
180  * The @dev_base_head list is protected by @dev_base_lock and the rtnl
181  * semaphore.
182  *
183  * Pure readers hold dev_base_lock for reading, or rcu_read_lock()
184  *
185  * Writers must hold the rtnl semaphore while they loop through the
186  * dev_base_head list, and hold dev_base_lock for writing when they do the
187  * actual updates.  This allows pure readers to access the list even
188  * while a writer is preparing to update it.
189  *
190  * To put it another way, dev_base_lock is held for writing only to
191  * protect against pure readers; the rtnl semaphore provides the
192  * protection against other writers.
193  *
194  * See, for example usages, register_netdevice() and
195  * unregister_netdevice(), which must be called with the rtnl
196  * semaphore held.
197  */
198 DEFINE_RWLOCK(dev_base_lock);
199 EXPORT_SYMBOL(dev_base_lock);
200
201 static inline struct hlist_head *dev_name_hash(struct net *net, const char *name)
202 {
203         unsigned hash = full_name_hash(name, strnlen(name, IFNAMSIZ));
204         return &net->dev_name_head[hash_32(hash, NETDEV_HASHBITS)];
205 }
206
207 static inline struct hlist_head *dev_index_hash(struct net *net, int ifindex)
208 {
209         return &net->dev_index_head[ifindex & (NETDEV_HASHENTRIES - 1)];
210 }
211
212 static inline void rps_lock(struct softnet_data *sd)
213 {
214 #ifdef CONFIG_RPS
215         spin_lock(&sd->input_pkt_queue.lock);
216 #endif
217 }
218
219 static inline void rps_unlock(struct softnet_data *sd)
220 {
221 #ifdef CONFIG_RPS
222         spin_unlock(&sd->input_pkt_queue.lock);
223 #endif
224 }
225
226 /* Device list insertion */
227 static int list_netdevice(struct net_device *dev)
228 {
229         struct net *net = dev_net(dev);
230
231         ASSERT_RTNL();
232
233         write_lock_bh(&dev_base_lock);
234         list_add_tail_rcu(&dev->dev_list, &net->dev_base_head);
235         hlist_add_head_rcu(&dev->name_hlist, dev_name_hash(net, dev->name));
236         hlist_add_head_rcu(&dev->index_hlist,
237                            dev_index_hash(net, dev->ifindex));
238         write_unlock_bh(&dev_base_lock);
239         return 0;
240 }
241
242 /* Device list removal
243  * caller must respect a RCU grace period before freeing/reusing dev
244  */
245 static void unlist_netdevice(struct net_device *dev)
246 {
247         ASSERT_RTNL();
248
249         /* Unlink dev from the device chain */
250         write_lock_bh(&dev_base_lock);
251         list_del_rcu(&dev->dev_list);
252         hlist_del_rcu(&dev->name_hlist);
253         hlist_del_rcu(&dev->index_hlist);
254         write_unlock_bh(&dev_base_lock);
255 }
256
257 /*
258  *      Our notifier list
259  */
260
261 static RAW_NOTIFIER_HEAD(netdev_chain);
262
263 /*
264  *      Device drivers call our routines to queue packets here. We empty the
265  *      queue in the local softnet handler.
266  */
267
268 DEFINE_PER_CPU_ALIGNED(struct softnet_data, softnet_data);
269 EXPORT_PER_CPU_SYMBOL(softnet_data);
270
271 #ifdef CONFIG_LOCKDEP
272 /*
273  * register_netdevice() inits txq->_xmit_lock and sets lockdep class
274  * according to dev->type
275  */
276 static const unsigned short netdev_lock_type[] =
277         {ARPHRD_NETROM, ARPHRD_ETHER, ARPHRD_EETHER, ARPHRD_AX25,
278          ARPHRD_PRONET, ARPHRD_CHAOS, ARPHRD_IEEE802, ARPHRD_ARCNET,
279          ARPHRD_APPLETLK, ARPHRD_DLCI, ARPHRD_ATM, ARPHRD_METRICOM,
280          ARPHRD_IEEE1394, ARPHRD_EUI64, ARPHRD_INFINIBAND, ARPHRD_SLIP,
281          ARPHRD_CSLIP, ARPHRD_SLIP6, ARPHRD_CSLIP6, ARPHRD_RSRVD,
282          ARPHRD_ADAPT, ARPHRD_ROSE, ARPHRD_X25, ARPHRD_HWX25,
283          ARPHRD_PPP, ARPHRD_CISCO, ARPHRD_LAPB, ARPHRD_DDCMP,
284          ARPHRD_RAWHDLC, ARPHRD_TUNNEL, ARPHRD_TUNNEL6, ARPHRD_FRAD,
285          ARPHRD_SKIP, ARPHRD_LOOPBACK, ARPHRD_LOCALTLK, ARPHRD_FDDI,
286          ARPHRD_BIF, ARPHRD_SIT, ARPHRD_IPDDP, ARPHRD_IPGRE,
287          ARPHRD_PIMREG, ARPHRD_HIPPI, ARPHRD_ASH, ARPHRD_ECONET,
288          ARPHRD_IRDA, ARPHRD_FCPP, ARPHRD_FCAL, ARPHRD_FCPL,
289          ARPHRD_FCFABRIC, ARPHRD_IEEE802_TR, ARPHRD_IEEE80211,
290          ARPHRD_IEEE80211_PRISM, ARPHRD_IEEE80211_RADIOTAP, ARPHRD_PHONET,
291          ARPHRD_PHONET_PIPE, ARPHRD_IEEE802154,
292          ARPHRD_VOID, ARPHRD_NONE};
293
294 static const char *const netdev_lock_name[] =
295         {"_xmit_NETROM", "_xmit_ETHER", "_xmit_EETHER", "_xmit_AX25",
296          "_xmit_PRONET", "_xmit_CHAOS", "_xmit_IEEE802", "_xmit_ARCNET",
297          "_xmit_APPLETLK", "_xmit_DLCI", "_xmit_ATM", "_xmit_METRICOM",
298          "_xmit_IEEE1394", "_xmit_EUI64", "_xmit_INFINIBAND", "_xmit_SLIP",
299          "_xmit_CSLIP", "_xmit_SLIP6", "_xmit_CSLIP6", "_xmit_RSRVD",
300          "_xmit_ADAPT", "_xmit_ROSE", "_xmit_X25", "_xmit_HWX25",
301          "_xmit_PPP", "_xmit_CISCO", "_xmit_LAPB", "_xmit_DDCMP",
302          "_xmit_RAWHDLC", "_xmit_TUNNEL", "_xmit_TUNNEL6", "_xmit_FRAD",
303          "_xmit_SKIP", "_xmit_LOOPBACK", "_xmit_LOCALTLK", "_xmit_FDDI",
304          "_xmit_BIF", "_xmit_SIT", "_xmit_IPDDP", "_xmit_IPGRE",
305          "_xmit_PIMREG", "_xmit_HIPPI", "_xmit_ASH", "_xmit_ECONET",
306          "_xmit_IRDA", "_xmit_FCPP", "_xmit_FCAL", "_xmit_FCPL",
307          "_xmit_FCFABRIC", "_xmit_IEEE802_TR", "_xmit_IEEE80211",
308          "_xmit_IEEE80211_PRISM", "_xmit_IEEE80211_RADIOTAP", "_xmit_PHONET",
309          "_xmit_PHONET_PIPE", "_xmit_IEEE802154",
310          "_xmit_VOID", "_xmit_NONE"};
311
312 static struct lock_class_key netdev_xmit_lock_key[ARRAY_SIZE(netdev_lock_type)];
313 static struct lock_class_key netdev_addr_lock_key[ARRAY_SIZE(netdev_lock_type)];
314
315 static inline unsigned short netdev_lock_pos(unsigned short dev_type)
316 {
317         int i;
318
319         for (i = 0; i < ARRAY_SIZE(netdev_lock_type); i++)
320                 if (netdev_lock_type[i] == dev_type)
321                         return i;
322         /* the last key is used by default */
323         return ARRAY_SIZE(netdev_lock_type) - 1;
324 }
325
326 static inline void netdev_set_xmit_lockdep_class(spinlock_t *lock,
327                                                  unsigned short dev_type)
328 {
329         int i;
330
331         i = netdev_lock_pos(dev_type);
332         lockdep_set_class_and_name(lock, &netdev_xmit_lock_key[i],
333                                    netdev_lock_name[i]);
334 }
335
336 static inline void netdev_set_addr_lockdep_class(struct net_device *dev)
337 {
338         int i;
339
340         i = netdev_lock_pos(dev->type);
341         lockdep_set_class_and_name(&dev->addr_list_lock,
342                                    &netdev_addr_lock_key[i],
343                                    netdev_lock_name[i]);
344 }
345 #else
346 static inline void netdev_set_xmit_lockdep_class(spinlock_t *lock,
347                                                  unsigned short dev_type)
348 {
349 }
350 static inline void netdev_set_addr_lockdep_class(struct net_device *dev)
351 {
352 }
353 #endif
354
355 /*******************************************************************************
356
357                 Protocol management and registration routines
358
359 *******************************************************************************/
360
361 /*
362  *      Add a protocol ID to the list. Now that the input handler is
363  *      smarter we can dispense with all the messy stuff that used to be
364  *      here.
365  *
366  *      BEWARE!!! Protocol handlers, mangling input packets,
367  *      MUST BE last in hash buckets and checking protocol handlers
368  *      MUST start from promiscuous ptype_all chain in net_bh.
369  *      It is true now, do not change it.
370  *      Explanation follows: if protocol handler, mangling packet, will
371  *      be the first on list, it is not able to sense, that packet
372  *      is cloned and should be copied-on-write, so that it will
373  *      change it and subsequent readers will get broken packet.
374  *                                                      --ANK (980803)
375  */
376
377 static inline struct list_head *ptype_head(const struct packet_type *pt)
378 {
379         if (pt->type == htons(ETH_P_ALL))
380                 return &ptype_all;
381         else
382                 return &ptype_base[ntohs(pt->type) & PTYPE_HASH_MASK];
383 }
384
385 /**
386  *      dev_add_pack - add packet handler
387  *      @pt: packet type declaration
388  *
389  *      Add a protocol handler to the networking stack. The passed &packet_type
390  *      is linked into kernel lists and may not be freed until it has been
391  *      removed from the kernel lists.
392  *
393  *      This call does not sleep therefore it can not
394  *      guarantee all CPU's that are in middle of receiving packets
395  *      will see the new packet type (until the next received packet).
396  */
397
398 void dev_add_pack(struct packet_type *pt)
399 {
400         struct list_head *head = ptype_head(pt);
401
402         spin_lock(&ptype_lock);
403         list_add_rcu(&pt->list, head);
404         spin_unlock(&ptype_lock);
405 }
406 EXPORT_SYMBOL(dev_add_pack);
407
408 /**
409  *      __dev_remove_pack        - remove packet handler
410  *      @pt: packet type declaration
411  *
412  *      Remove a protocol handler that was previously added to the kernel
413  *      protocol handlers by dev_add_pack(). The passed &packet_type is removed
414  *      from the kernel lists and can be freed or reused once this function
415  *      returns.
416  *
417  *      The packet type might still be in use by receivers
418  *      and must not be freed until after all the CPU's have gone
419  *      through a quiescent state.
420  */
421 void __dev_remove_pack(struct packet_type *pt)
422 {
423         struct list_head *head = ptype_head(pt);
424         struct packet_type *pt1;
425
426         spin_lock(&ptype_lock);
427
428         list_for_each_entry(pt1, head, list) {
429                 if (pt == pt1) {
430                         list_del_rcu(&pt->list);
431                         goto out;
432                 }
433         }
434
435         printk(KERN_WARNING "dev_remove_pack: %p not found.\n", pt);
436 out:
437         spin_unlock(&ptype_lock);
438 }
439 EXPORT_SYMBOL(__dev_remove_pack);
440
441 /**
442  *      dev_remove_pack  - remove packet handler
443  *      @pt: packet type declaration
444  *
445  *      Remove a protocol handler that was previously added to the kernel
446  *      protocol handlers by dev_add_pack(). The passed &packet_type is removed
447  *      from the kernel lists and can be freed or reused once this function
448  *      returns.
449  *
450  *      This call sleeps to guarantee that no CPU is looking at the packet
451  *      type after return.
452  */
453 void dev_remove_pack(struct packet_type *pt)
454 {
455         __dev_remove_pack(pt);
456
457         synchronize_net();
458 }
459 EXPORT_SYMBOL(dev_remove_pack);
460
461 /******************************************************************************
462
463                       Device Boot-time Settings Routines
464
465 *******************************************************************************/
466
467 /* Boot time configuration table */
468 static struct netdev_boot_setup dev_boot_setup[NETDEV_BOOT_SETUP_MAX];
469
470 /**
471  *      netdev_boot_setup_add   - add new setup entry
472  *      @name: name of the device
473  *      @map: configured settings for the device
474  *
475  *      Adds new setup entry to the dev_boot_setup list.  The function
476  *      returns 0 on error and 1 on success.  This is a generic routine to
477  *      all netdevices.
478  */
479 static int netdev_boot_setup_add(char *name, struct ifmap *map)
480 {
481         struct netdev_boot_setup *s;
482         int i;
483
484         s = dev_boot_setup;
485         for (i = 0; i < NETDEV_BOOT_SETUP_MAX; i++) {
486                 if (s[i].name[0] == '\0' || s[i].name[0] == ' ') {
487                         memset(s[i].name, 0, sizeof(s[i].name));
488                         strlcpy(s[i].name, name, IFNAMSIZ);
489                         memcpy(&s[i].map, map, sizeof(s[i].map));
490                         break;
491                 }
492         }
493
494         return i >= NETDEV_BOOT_SETUP_MAX ? 0 : 1;
495 }
496
497 /**
498  *      netdev_boot_setup_check - check boot time settings
499  *      @dev: the netdevice
500  *
501  *      Check boot time settings for the device.
502  *      The found settings are set for the device to be used
503  *      later in the device probing.
504  *      Returns 0 if no settings found, 1 if they are.
505  */
506 int netdev_boot_setup_check(struct net_device *dev)
507 {
508         struct netdev_boot_setup *s = dev_boot_setup;
509         int i;
510
511         for (i = 0; i < NETDEV_BOOT_SETUP_MAX; i++) {
512                 if (s[i].name[0] != '\0' && s[i].name[0] != ' ' &&
513                     !strcmp(dev->name, s[i].name)) {
514                         dev->irq        = s[i].map.irq;
515                         dev->base_addr  = s[i].map.base_addr;
516                         dev->mem_start  = s[i].map.mem_start;
517                         dev->mem_end    = s[i].map.mem_end;
518                         return 1;
519                 }
520         }
521         return 0;
522 }
523 EXPORT_SYMBOL(netdev_boot_setup_check);
524
525
526 /**
527  *      netdev_boot_base        - get address from boot time settings
528  *      @prefix: prefix for network device
529  *      @unit: id for network device
530  *
531  *      Check boot time settings for the base address of device.
532  *      The found settings are set for the device to be used
533  *      later in the device probing.
534  *      Returns 0 if no settings found.
535  */
536 unsigned long netdev_boot_base(const char *prefix, int unit)
537 {
538         const struct netdev_boot_setup *s = dev_boot_setup;
539         char name[IFNAMSIZ];
540         int i;
541
542         sprintf(name, "%s%d", prefix, unit);
543
544         /*
545          * If device already registered then return base of 1
546          * to indicate not to probe for this interface
547          */
548         if (__dev_get_by_name(&init_net, name))
549                 return 1;
550
551         for (i = 0; i < NETDEV_BOOT_SETUP_MAX; i++)
552                 if (!strcmp(name, s[i].name))
553                         return s[i].map.base_addr;
554         return 0;
555 }
556
557 /*
558  * Saves at boot time configured settings for any netdevice.
559  */
560 int __init netdev_boot_setup(char *str)
561 {
562         int ints[5];
563         struct ifmap map;
564
565         str = get_options(str, ARRAY_SIZE(ints), ints);
566         if (!str || !*str)
567                 return 0;
568
569         /* Save settings */
570         memset(&map, 0, sizeof(map));
571         if (ints[0] > 0)
572                 map.irq = ints[1];
573         if (ints[0] > 1)
574                 map.base_addr = ints[2];
575         if (ints[0] > 2)
576                 map.mem_start = ints[3];
577         if (ints[0] > 3)
578                 map.mem_end = ints[4];
579
580         /* Add new entry to the list */
581         return netdev_boot_setup_add(str, &map);
582 }
583
584 __setup("netdev=", netdev_boot_setup);
585
586 /*******************************************************************************
587
588                             Device Interface Subroutines
589
590 *******************************************************************************/
591
592 /**
593  *      __dev_get_by_name       - find a device by its name
594  *      @net: the applicable net namespace
595  *      @name: name to find
596  *
597  *      Find an interface by name. Must be called under RTNL semaphore
598  *      or @dev_base_lock. If the name is found a pointer to the device
599  *      is returned. If the name is not found then %NULL is returned. The
600  *      reference counters are not incremented so the caller must be
601  *      careful with locks.
602  */
603
604 struct net_device *__dev_get_by_name(struct net *net, const char *name)
605 {
606         struct hlist_node *p;
607         struct net_device *dev;
608         struct hlist_head *head = dev_name_hash(net, name);
609
610         hlist_for_each_entry(dev, p, head, name_hlist)
611                 if (!strncmp(dev->name, name, IFNAMSIZ))
612                         return dev;
613
614         return NULL;
615 }
616 EXPORT_SYMBOL(__dev_get_by_name);
617
618 /**
619  *      dev_get_by_name_rcu     - find a device by its name
620  *      @net: the applicable net namespace
621  *      @name: name to find
622  *
623  *      Find an interface by name.
624  *      If the name is found a pointer to the device is returned.
625  *      If the name is not found then %NULL is returned.
626  *      The reference counters are not incremented so the caller must be
627  *      careful with locks. The caller must hold RCU lock.
628  */
629
630 struct net_device *dev_get_by_name_rcu(struct net *net, const char *name)
631 {
632         struct hlist_node *p;
633         struct net_device *dev;
634         struct hlist_head *head = dev_name_hash(net, name);
635
636         hlist_for_each_entry_rcu(dev, p, head, name_hlist)
637                 if (!strncmp(dev->name, name, IFNAMSIZ))
638                         return dev;
639
640         return NULL;
641 }
642 EXPORT_SYMBOL(dev_get_by_name_rcu);
643
644 /**
645  *      dev_get_by_name         - find a device by its name
646  *      @net: the applicable net namespace
647  *      @name: name to find
648  *
649  *      Find an interface by name. This can be called from any
650  *      context and does its own locking. The returned handle has
651  *      the usage count incremented and the caller must use dev_put() to
652  *      release it when it is no longer needed. %NULL is returned if no
653  *      matching device is found.
654  */
655
656 struct net_device *dev_get_by_name(struct net *net, const char *name)
657 {
658         struct net_device *dev;
659
660         rcu_read_lock();
661         dev = dev_get_by_name_rcu(net, name);
662         if (dev)
663                 dev_hold(dev);
664         rcu_read_unlock();
665         return dev;
666 }
667 EXPORT_SYMBOL(dev_get_by_name);
668
669 /**
670  *      __dev_get_by_index - find a device by its ifindex
671  *      @net: the applicable net namespace
672  *      @ifindex: index of device
673  *
674  *      Search for an interface by index. Returns %NULL if the device
675  *      is not found or a pointer to the device. The device has not
676  *      had its reference counter increased so the caller must be careful
677  *      about locking. The caller must hold either the RTNL semaphore
678  *      or @dev_base_lock.
679  */
680
681 struct net_device *__dev_get_by_index(struct net *net, int ifindex)
682 {
683         struct hlist_node *p;
684         struct net_device *dev;
685         struct hlist_head *head = dev_index_hash(net, ifindex);
686
687         hlist_for_each_entry(dev, p, head, index_hlist)
688                 if (dev->ifindex == ifindex)
689                         return dev;
690
691         return NULL;
692 }
693 EXPORT_SYMBOL(__dev_get_by_index);
694
695 /**
696  *      dev_get_by_index_rcu - find a device by its ifindex
697  *      @net: the applicable net namespace
698  *      @ifindex: index of device
699  *
700  *      Search for an interface by index. Returns %NULL if the device
701  *      is not found or a pointer to the device. The device has not
702  *      had its reference counter increased so the caller must be careful
703  *      about locking. The caller must hold RCU lock.
704  */
705
706 struct net_device *dev_get_by_index_rcu(struct net *net, int ifindex)
707 {
708         struct hlist_node *p;
709         struct net_device *dev;
710         struct hlist_head *head = dev_index_hash(net, ifindex);
711
712         hlist_for_each_entry_rcu(dev, p, head, index_hlist)
713                 if (dev->ifindex == ifindex)
714                         return dev;
715
716         return NULL;
717 }
718 EXPORT_SYMBOL(dev_get_by_index_rcu);
719
720
721 /**
722  *      dev_get_by_index - find a device by its ifindex
723  *      @net: the applicable net namespace
724  *      @ifindex: index of device
725  *
726  *      Search for an interface by index. Returns NULL if the device
727  *      is not found or a pointer to the device. The device returned has
728  *      had a reference added and the pointer is safe until the user calls
729  *      dev_put to indicate they have finished with it.
730  */
731
732 struct net_device *dev_get_by_index(struct net *net, int ifindex)
733 {
734         struct net_device *dev;
735
736         rcu_read_lock();
737         dev = dev_get_by_index_rcu(net, ifindex);
738         if (dev)
739                 dev_hold(dev);
740         rcu_read_unlock();
741         return dev;
742 }
743 EXPORT_SYMBOL(dev_get_by_index);
744
745 /**
746  *      dev_getbyhwaddr - find a device by its hardware address
747  *      @net: the applicable net namespace
748  *      @type: media type of device
749  *      @ha: hardware address
750  *
751  *      Search for an interface by MAC address. Returns NULL if the device
752  *      is not found or a pointer to the device. The caller must hold the
753  *      rtnl semaphore. The returned device has not had its ref count increased
754  *      and the caller must therefore be careful about locking
755  *
756  *      BUGS:
757  *      If the API was consistent this would be __dev_get_by_hwaddr
758  */
759
760 struct net_device *dev_getbyhwaddr(struct net *net, unsigned short type, char *ha)
761 {
762         struct net_device *dev;
763
764         ASSERT_RTNL();
765
766         for_each_netdev(net, dev)
767                 if (dev->type == type &&
768                     !memcmp(dev->dev_addr, ha, dev->addr_len))
769                         return dev;
770
771         return NULL;
772 }
773 EXPORT_SYMBOL(dev_getbyhwaddr);
774
775 struct net_device *__dev_getfirstbyhwtype(struct net *net, unsigned short type)
776 {
777         struct net_device *dev;
778
779         ASSERT_RTNL();
780         for_each_netdev(net, dev)
781                 if (dev->type == type)
782                         return dev;
783
784         return NULL;
785 }
786 EXPORT_SYMBOL(__dev_getfirstbyhwtype);
787
788 struct net_device *dev_getfirstbyhwtype(struct net *net, unsigned short type)
789 {
790         struct net_device *dev, *ret = NULL;
791
792         rcu_read_lock();
793         for_each_netdev_rcu(net, dev)
794                 if (dev->type == type) {
795                         dev_hold(dev);
796                         ret = dev;
797                         break;
798                 }
799         rcu_read_unlock();
800         return ret;
801 }
802 EXPORT_SYMBOL(dev_getfirstbyhwtype);
803
804 /**
805  *      dev_get_by_flags_rcu - find any device with given flags
806  *      @net: the applicable net namespace
807  *      @if_flags: IFF_* values
808  *      @mask: bitmask of bits in if_flags to check
809  *
810  *      Search for any interface with the given flags. Returns NULL if a device
811  *      is not found or a pointer to the device. Must be called inside
812  *      rcu_read_lock(), and result refcount is unchanged.
813  */
814
815 struct net_device *dev_get_by_flags_rcu(struct net *net, unsigned short if_flags,
816                                     unsigned short mask)
817 {
818         struct net_device *dev, *ret;
819
820         ret = NULL;
821         for_each_netdev_rcu(net, dev) {
822                 if (((dev->flags ^ if_flags) & mask) == 0) {
823                         ret = dev;
824                         break;
825                 }
826         }
827         return ret;
828 }
829 EXPORT_SYMBOL(dev_get_by_flags_rcu);
830
831 /**
832  *      dev_valid_name - check if name is okay for network device
833  *      @name: name string
834  *
835  *      Network device names need to be valid file names to
836  *      to allow sysfs to work.  We also disallow any kind of
837  *      whitespace.
838  */
839 int dev_valid_name(const char *name)
840 {
841         if (*name == '\0')
842                 return 0;
843         if (strlen(name) >= IFNAMSIZ)
844                 return 0;
845         if (!strcmp(name, ".") || !strcmp(name, ".."))
846                 return 0;
847
848         while (*name) {
849                 if (*name == '/' || isspace(*name))
850                         return 0;
851                 name++;
852         }
853         return 1;
854 }
855 EXPORT_SYMBOL(dev_valid_name);
856
857 /**
858  *      __dev_alloc_name - allocate a name for a device
859  *      @net: network namespace to allocate the device name in
860  *      @name: name format string
861  *      @buf:  scratch buffer and result name string
862  *
863  *      Passed a format string - eg "lt%d" it will try and find a suitable
864  *      id. It scans list of devices to build up a free map, then chooses
865  *      the first empty slot. The caller must hold the dev_base or rtnl lock
866  *      while allocating the name and adding the device in order to avoid
867  *      duplicates.
868  *      Limited to bits_per_byte * page size devices (ie 32K on most platforms).
869  *      Returns the number of the unit assigned or a negative errno code.
870  */
871
872 static int __dev_alloc_name(struct net *net, const char *name, char *buf)
873 {
874         int i = 0;
875         const char *p;
876         const int max_netdevices = 8*PAGE_SIZE;
877         unsigned long *inuse;
878         struct net_device *d;
879
880         p = strnchr(name, IFNAMSIZ-1, '%');
881         if (p) {
882                 /*
883                  * Verify the string as this thing may have come from
884                  * the user.  There must be either one "%d" and no other "%"
885                  * characters.
886                  */
887                 if (p[1] != 'd' || strchr(p + 2, '%'))
888                         return -EINVAL;
889
890                 /* Use one page as a bit array of possible slots */
891                 inuse = (unsigned long *) get_zeroed_page(GFP_ATOMIC);
892                 if (!inuse)
893                         return -ENOMEM;
894
895                 for_each_netdev(net, d) {
896                         if (!sscanf(d->name, name, &i))
897                                 continue;
898                         if (i < 0 || i >= max_netdevices)
899                                 continue;
900
901                         /*  avoid cases where sscanf is not exact inverse of printf */
902                         snprintf(buf, IFNAMSIZ, name, i);
903                         if (!strncmp(buf, d->name, IFNAMSIZ))
904                                 set_bit(i, inuse);
905                 }
906
907                 i = find_first_zero_bit(inuse, max_netdevices);
908                 free_page((unsigned long) inuse);
909         }
910
911         if (buf != name)
912                 snprintf(buf, IFNAMSIZ, name, i);
913         if (!__dev_get_by_name(net, buf))
914                 return i;
915
916         /* It is possible to run out of possible slots
917          * when the name is long and there isn't enough space left
918          * for the digits, or if all bits are used.
919          */
920         return -ENFILE;
921 }
922
923 /**
924  *      dev_alloc_name - allocate a name for a device
925  *      @dev: device
926  *      @name: name format string
927  *
928  *      Passed a format string - eg "lt%d" it will try and find a suitable
929  *      id. It scans list of devices to build up a free map, then chooses
930  *      the first empty slot. The caller must hold the dev_base or rtnl lock
931  *      while allocating the name and adding the device in order to avoid
932  *      duplicates.
933  *      Limited to bits_per_byte * page size devices (ie 32K on most platforms).
934  *      Returns the number of the unit assigned or a negative errno code.
935  */
936
937 int dev_alloc_name(struct net_device *dev, const char *name)
938 {
939         char buf[IFNAMSIZ];
940         struct net *net;
941         int ret;
942
943         BUG_ON(!dev_net(dev));
944         net = dev_net(dev);
945         ret = __dev_alloc_name(net, name, buf);
946         if (ret >= 0)
947                 strlcpy(dev->name, buf, IFNAMSIZ);
948         return ret;
949 }
950 EXPORT_SYMBOL(dev_alloc_name);
951
952 static int dev_get_valid_name(struct net_device *dev, const char *name, bool fmt)
953 {
954         struct net *net;
955
956         BUG_ON(!dev_net(dev));
957         net = dev_net(dev);
958
959         if (!dev_valid_name(name))
960                 return -EINVAL;
961
962         if (fmt && strchr(name, '%'))
963                 return dev_alloc_name(dev, name);
964         else if (__dev_get_by_name(net, name))
965                 return -EEXIST;
966         else if (dev->name != name)
967                 strlcpy(dev->name, name, IFNAMSIZ);
968
969         return 0;
970 }
971
972 /**
973  *      dev_change_name - change name of a device
974  *      @dev: device
975  *      @newname: name (or format string) must be at least IFNAMSIZ
976  *
977  *      Change name of a device, can pass format strings "eth%d".
978  *      for wildcarding.
979  */
980 int dev_change_name(struct net_device *dev, const char *newname)
981 {
982         char oldname[IFNAMSIZ];
983         int err = 0;
984         int ret;
985         struct net *net;
986
987         ASSERT_RTNL();
988         BUG_ON(!dev_net(dev));
989
990         net = dev_net(dev);
991         if (dev->flags & IFF_UP)
992                 return -EBUSY;
993
994         if (strncmp(newname, dev->name, IFNAMSIZ) == 0)
995                 return 0;
996
997         memcpy(oldname, dev->name, IFNAMSIZ);
998
999         err = dev_get_valid_name(dev, newname, 1);
1000         if (err < 0)
1001                 return err;
1002
1003 rollback:
1004         ret = device_rename(&dev->dev, dev->name);
1005         if (ret) {
1006                 memcpy(dev->name, oldname, IFNAMSIZ);
1007                 return ret;
1008         }
1009
1010         write_lock_bh(&dev_base_lock);
1011         hlist_del(&dev->name_hlist);
1012         write_unlock_bh(&dev_base_lock);
1013
1014         synchronize_rcu();
1015
1016         write_lock_bh(&dev_base_lock);
1017         hlist_add_head_rcu(&dev->name_hlist, dev_name_hash(net, dev->name));
1018         write_unlock_bh(&dev_base_lock);
1019
1020         ret = call_netdevice_notifiers(NETDEV_CHANGENAME, dev);
1021         ret = notifier_to_errno(ret);
1022
1023         if (ret) {
1024                 /* err >= 0 after dev_alloc_name() or stores the first errno */
1025                 if (err >= 0) {
1026                         err = ret;
1027                         memcpy(dev->name, oldname, IFNAMSIZ);
1028                         goto rollback;
1029                 } else {
1030                         printk(KERN_ERR
1031                                "%s: name change rollback failed: %d.\n",
1032                                dev->name, ret);
1033                 }
1034         }
1035
1036         return err;
1037 }
1038
1039 /**
1040  *      dev_set_alias - change ifalias of a device
1041  *      @dev: device
1042  *      @alias: name up to IFALIASZ
1043  *      @len: limit of bytes to copy from info
1044  *
1045  *      Set ifalias for a device,
1046  */
1047 int dev_set_alias(struct net_device *dev, const char *alias, size_t len)
1048 {
1049         ASSERT_RTNL();
1050
1051         if (len >= IFALIASZ)
1052                 return -EINVAL;
1053
1054         if (!len) {
1055                 if (dev->ifalias) {
1056                         kfree(dev->ifalias);
1057                         dev->ifalias = NULL;
1058                 }
1059                 return 0;
1060         }
1061
1062         dev->ifalias = krealloc(dev->ifalias, len + 1, GFP_KERNEL);
1063         if (!dev->ifalias)
1064                 return -ENOMEM;
1065
1066         strlcpy(dev->ifalias, alias, len+1);
1067         return len;
1068 }
1069
1070
1071 /**
1072  *      netdev_features_change - device changes features
1073  *      @dev: device to cause notification
1074  *
1075  *      Called to indicate a device has changed features.
1076  */
1077 void netdev_features_change(struct net_device *dev)
1078 {
1079         call_netdevice_notifiers(NETDEV_FEAT_CHANGE, dev);
1080 }
1081 EXPORT_SYMBOL(netdev_features_change);
1082
1083 /**
1084  *      netdev_state_change - device changes state
1085  *      @dev: device to cause notification
1086  *
1087  *      Called to indicate a device has changed state. This function calls
1088  *      the notifier chains for netdev_chain and sends a NEWLINK message
1089  *      to the routing socket.
1090  */
1091 void netdev_state_change(struct net_device *dev)
1092 {
1093         if (dev->flags & IFF_UP) {
1094                 call_netdevice_notifiers(NETDEV_CHANGE, dev);
1095                 rtmsg_ifinfo(RTM_NEWLINK, dev, 0);
1096         }
1097 }
1098 EXPORT_SYMBOL(netdev_state_change);
1099
1100 int netdev_bonding_change(struct net_device *dev, unsigned long event)
1101 {
1102         return call_netdevice_notifiers(event, dev);
1103 }
1104 EXPORT_SYMBOL(netdev_bonding_change);
1105
1106 /**
1107  *      dev_load        - load a network module
1108  *      @net: the applicable net namespace
1109  *      @name: name of interface
1110  *
1111  *      If a network interface is not present and the process has suitable
1112  *      privileges this function loads the module. If module loading is not
1113  *      available in this kernel then it becomes a nop.
1114  */
1115
1116 void dev_load(struct net *net, const char *name)
1117 {
1118         struct net_device *dev;
1119
1120         rcu_read_lock();
1121         dev = dev_get_by_name_rcu(net, name);
1122         rcu_read_unlock();
1123
1124         if (!dev && capable(CAP_NET_ADMIN))
1125                 request_module("%s", name);
1126 }
1127 EXPORT_SYMBOL(dev_load);
1128
1129 static int __dev_open(struct net_device *dev)
1130 {
1131         const struct net_device_ops *ops = dev->netdev_ops;
1132         int ret;
1133
1134         ASSERT_RTNL();
1135
1136         /*
1137          *      Is it even present?
1138          */
1139         if (!netif_device_present(dev))
1140                 return -ENODEV;
1141
1142         ret = call_netdevice_notifiers(NETDEV_PRE_UP, dev);
1143         ret = notifier_to_errno(ret);
1144         if (ret)
1145                 return ret;
1146
1147         /*
1148          *      Call device private open method
1149          */
1150         set_bit(__LINK_STATE_START, &dev->state);
1151
1152         if (ops->ndo_validate_addr)
1153                 ret = ops->ndo_validate_addr(dev);
1154
1155         if (!ret && ops->ndo_open)
1156                 ret = ops->ndo_open(dev);
1157
1158         /*
1159          *      If it went open OK then:
1160          */
1161
1162         if (ret)
1163                 clear_bit(__LINK_STATE_START, &dev->state);
1164         else {
1165                 /*
1166                  *      Set the flags.
1167                  */
1168                 dev->flags |= IFF_UP;
1169
1170                 /*
1171                  *      Enable NET_DMA
1172                  */
1173                 net_dmaengine_get();
1174
1175                 /*
1176                  *      Initialize multicasting status
1177                  */
1178                 dev_set_rx_mode(dev);
1179
1180                 /*
1181                  *      Wakeup transmit queue engine
1182                  */
1183                 dev_activate(dev);
1184         }
1185
1186         return ret;
1187 }
1188
1189 /**
1190  *      dev_open        - prepare an interface for use.
1191  *      @dev:   device to open
1192  *
1193  *      Takes a device from down to up state. The device's private open
1194  *      function is invoked and then the multicast lists are loaded. Finally
1195  *      the device is moved into the up state and a %NETDEV_UP message is
1196  *      sent to the netdev notifier chain.
1197  *
1198  *      Calling this function on an active interface is a nop. On a failure
1199  *      a negative errno code is returned.
1200  */
1201 int dev_open(struct net_device *dev)
1202 {
1203         int ret;
1204
1205         /*
1206          *      Is it already up?
1207          */
1208         if (dev->flags & IFF_UP)
1209                 return 0;
1210
1211         /*
1212          *      Open device
1213          */
1214         ret = __dev_open(dev);
1215         if (ret < 0)
1216                 return ret;
1217
1218         /*
1219          *      ... and announce new interface.
1220          */
1221         rtmsg_ifinfo(RTM_NEWLINK, dev, IFF_UP|IFF_RUNNING);
1222         call_netdevice_notifiers(NETDEV_UP, dev);
1223
1224         return ret;
1225 }
1226 EXPORT_SYMBOL(dev_open);
1227
1228 static int __dev_close(struct net_device *dev)
1229 {
1230         const struct net_device_ops *ops = dev->netdev_ops;
1231
1232         ASSERT_RTNL();
1233         might_sleep();
1234
1235         /*
1236          *      Tell people we are going down, so that they can
1237          *      prepare to death, when device is still operating.
1238          */
1239         call_netdevice_notifiers(NETDEV_GOING_DOWN, dev);
1240
1241         clear_bit(__LINK_STATE_START, &dev->state);
1242
1243         /* Synchronize to scheduled poll. We cannot touch poll list,
1244          * it can be even on different cpu. So just clear netif_running().
1245          *
1246          * dev->stop() will invoke napi_disable() on all of it's
1247          * napi_struct instances on this device.
1248          */
1249         smp_mb__after_clear_bit(); /* Commit netif_running(). */
1250
1251         dev_deactivate(dev);
1252
1253         /*
1254          *      Call the device specific close. This cannot fail.
1255          *      Only if device is UP
1256          *
1257          *      We allow it to be called even after a DETACH hot-plug
1258          *      event.
1259          */
1260         if (ops->ndo_stop)
1261                 ops->ndo_stop(dev);
1262
1263         /*
1264          *      Device is now down.
1265          */
1266
1267         dev->flags &= ~IFF_UP;
1268
1269         /*
1270          *      Shutdown NET_DMA
1271          */
1272         net_dmaengine_put();
1273
1274         return 0;
1275 }
1276
1277 /**
1278  *      dev_close - shutdown an interface.
1279  *      @dev: device to shutdown
1280  *
1281  *      This function moves an active device into down state. A
1282  *      %NETDEV_GOING_DOWN is sent to the netdev notifier chain. The device
1283  *      is then deactivated and finally a %NETDEV_DOWN is sent to the notifier
1284  *      chain.
1285  */
1286 int dev_close(struct net_device *dev)
1287 {
1288         if (!(dev->flags & IFF_UP))
1289                 return 0;
1290
1291         __dev_close(dev);
1292
1293         /*
1294          * Tell people we are down
1295          */
1296         rtmsg_ifinfo(RTM_NEWLINK, dev, IFF_UP|IFF_RUNNING);
1297         call_netdevice_notifiers(NETDEV_DOWN, dev);
1298
1299         return 0;
1300 }
1301 EXPORT_SYMBOL(dev_close);
1302
1303
1304 /**
1305  *      dev_disable_lro - disable Large Receive Offload on a device
1306  *      @dev: device
1307  *
1308  *      Disable Large Receive Offload (LRO) on a net device.  Must be
1309  *      called under RTNL.  This is needed if received packets may be
1310  *      forwarded to another interface.
1311  */
1312 void dev_disable_lro(struct net_device *dev)
1313 {
1314         if (dev->ethtool_ops && dev->ethtool_ops->get_flags &&
1315             dev->ethtool_ops->set_flags) {
1316                 u32 flags = dev->ethtool_ops->get_flags(dev);
1317                 if (flags & ETH_FLAG_LRO) {
1318                         flags &= ~ETH_FLAG_LRO;
1319                         dev->ethtool_ops->set_flags(dev, flags);
1320                 }
1321         }
1322         WARN_ON(dev->features & NETIF_F_LRO);
1323 }
1324 EXPORT_SYMBOL(dev_disable_lro);
1325
1326
1327 static int dev_boot_phase = 1;
1328
1329 /*
1330  *      Device change register/unregister. These are not inline or static
1331  *      as we export them to the world.
1332  */
1333
1334 /**
1335  *      register_netdevice_notifier - register a network notifier block
1336  *      @nb: notifier
1337  *
1338  *      Register a notifier to be called when network device events occur.
1339  *      The notifier passed is linked into the kernel structures and must
1340  *      not be reused until it has been unregistered. A negative errno code
1341  *      is returned on a failure.
1342  *
1343  *      When registered all registration and up events are replayed
1344  *      to the new notifier to allow device to have a race free
1345  *      view of the network device list.
1346  */
1347
1348 int register_netdevice_notifier(struct notifier_block *nb)
1349 {
1350         struct net_device *dev;
1351         struct net_device *last;
1352         struct net *net;
1353         int err;
1354
1355         rtnl_lock();
1356         err = raw_notifier_chain_register(&netdev_chain, nb);
1357         if (err)
1358                 goto unlock;
1359         if (dev_boot_phase)
1360                 goto unlock;
1361         for_each_net(net) {
1362                 for_each_netdev(net, dev) {
1363                         err = nb->notifier_call(nb, NETDEV_REGISTER, dev);
1364                         err = notifier_to_errno(err);
1365                         if (err)
1366                                 goto rollback;
1367
1368                         if (!(dev->flags & IFF_UP))
1369                                 continue;
1370
1371                         nb->notifier_call(nb, NETDEV_UP, dev);
1372                 }
1373         }
1374
1375 unlock:
1376         rtnl_unlock();
1377         return err;
1378
1379 rollback:
1380         last = dev;
1381         for_each_net(net) {
1382                 for_each_netdev(net, dev) {
1383                         if (dev == last)
1384                                 break;
1385
1386                         if (dev->flags & IFF_UP) {
1387                                 nb->notifier_call(nb, NETDEV_GOING_DOWN, dev);
1388                                 nb->notifier_call(nb, NETDEV_DOWN, dev);
1389                         }
1390                         nb->notifier_call(nb, NETDEV_UNREGISTER, dev);
1391                         nb->notifier_call(nb, NETDEV_UNREGISTER_BATCH, dev);
1392                 }
1393         }
1394
1395         raw_notifier_chain_unregister(&netdev_chain, nb);
1396         goto unlock;
1397 }
1398 EXPORT_SYMBOL(register_netdevice_notifier);
1399
1400 /**
1401  *      unregister_netdevice_notifier - unregister a network notifier block
1402  *      @nb: notifier
1403  *
1404  *      Unregister a notifier previously registered by
1405  *      register_netdevice_notifier(). The notifier is unlinked into the
1406  *      kernel structures and may then be reused. A negative errno code
1407  *      is returned on a failure.
1408  */
1409
1410 int unregister_netdevice_notifier(struct notifier_block *nb)
1411 {
1412         int err;
1413
1414         rtnl_lock();
1415         err = raw_notifier_chain_unregister(&netdev_chain, nb);
1416         rtnl_unlock();
1417         return err;
1418 }
1419 EXPORT_SYMBOL(unregister_netdevice_notifier);
1420
1421 /**
1422  *      call_netdevice_notifiers - call all network notifier blocks
1423  *      @val: value passed unmodified to notifier function
1424  *      @dev: net_device pointer passed unmodified to notifier function
1425  *
1426  *      Call all network notifier blocks.  Parameters and return value
1427  *      are as for raw_notifier_call_chain().
1428  */
1429
1430 int call_netdevice_notifiers(unsigned long val, struct net_device *dev)
1431 {
1432         ASSERT_RTNL();
1433         return raw_notifier_call_chain(&netdev_chain, val, dev);
1434 }
1435
1436 /* When > 0 there are consumers of rx skb time stamps */
1437 static atomic_t netstamp_needed = ATOMIC_INIT(0);
1438
1439 void net_enable_timestamp(void)
1440 {
1441         atomic_inc(&netstamp_needed);
1442 }
1443 EXPORT_SYMBOL(net_enable_timestamp);
1444
1445 void net_disable_timestamp(void)
1446 {
1447         atomic_dec(&netstamp_needed);
1448 }
1449 EXPORT_SYMBOL(net_disable_timestamp);
1450
1451 static inline void net_timestamp_set(struct sk_buff *skb)
1452 {
1453         if (atomic_read(&netstamp_needed))
1454                 __net_timestamp(skb);
1455         else
1456                 skb->tstamp.tv64 = 0;
1457 }
1458
1459 static inline void net_timestamp_check(struct sk_buff *skb)
1460 {
1461         if (!skb->tstamp.tv64 && atomic_read(&netstamp_needed))
1462                 __net_timestamp(skb);
1463 }
1464
1465 /**
1466  * dev_forward_skb - loopback an skb to another netif
1467  *
1468  * @dev: destination network device
1469  * @skb: buffer to forward
1470  *
1471  * return values:
1472  *      NET_RX_SUCCESS  (no congestion)
1473  *      NET_RX_DROP     (packet was dropped, but freed)
1474  *
1475  * dev_forward_skb can be used for injecting an skb from the
1476  * start_xmit function of one device into the receive queue
1477  * of another device.
1478  *
1479  * The receiving device may be in another namespace, so
1480  * we have to clear all information in the skb that could
1481  * impact namespace isolation.
1482  */
1483 int dev_forward_skb(struct net_device *dev, struct sk_buff *skb)
1484 {
1485         skb_orphan(skb);
1486         nf_reset(skb);
1487
1488         if (unlikely(!(dev->flags & IFF_UP) ||
1489                      (skb->len > (dev->mtu + dev->hard_header_len + VLAN_HLEN)))) {
1490                 atomic_long_inc(&dev->rx_dropped);
1491                 kfree_skb(skb);
1492                 return NET_RX_DROP;
1493         }
1494         skb_set_dev(skb, dev);
1495         skb->tstamp.tv64 = 0;
1496         skb->pkt_type = PACKET_HOST;
1497         skb->protocol = eth_type_trans(skb, dev);
1498         return netif_rx(skb);
1499 }
1500 EXPORT_SYMBOL_GPL(dev_forward_skb);
1501
1502 /*
1503  *      Support routine. Sends outgoing frames to any network
1504  *      taps currently in use.
1505  */
1506
1507 static void dev_queue_xmit_nit(struct sk_buff *skb, struct net_device *dev)
1508 {
1509         struct packet_type *ptype;
1510
1511 #ifdef CONFIG_NET_CLS_ACT
1512         if (!(skb->tstamp.tv64 && (G_TC_FROM(skb->tc_verd) & AT_INGRESS)))
1513                 net_timestamp_set(skb);
1514 #else
1515         net_timestamp_set(skb);
1516 #endif
1517
1518         rcu_read_lock();
1519         list_for_each_entry_rcu(ptype, &ptype_all, list) {
1520                 /* Never send packets back to the socket
1521                  * they originated from - MvS (miquels@drinkel.ow.org)
1522                  */
1523                 if ((ptype->dev == dev || !ptype->dev) &&
1524                     (ptype->af_packet_priv == NULL ||
1525                      (struct sock *)ptype->af_packet_priv != skb->sk)) {
1526                         struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
1527                         if (!skb2)
1528                                 break;
1529
1530                         /* skb->nh should be correctly
1531                            set by sender, so that the second statement is
1532                            just protection against buggy protocols.
1533                          */
1534                         skb_reset_mac_header(skb2);
1535
1536                         if (skb_network_header(skb2) < skb2->data ||
1537                             skb2->network_header > skb2->tail) {
1538                                 if (net_ratelimit())
1539                                         printk(KERN_CRIT "protocol %04x is "
1540                                                "buggy, dev %s\n",
1541                                                ntohs(skb2->protocol),
1542                                                dev->name);
1543                                 skb_reset_network_header(skb2);
1544                         }
1545
1546                         skb2->transport_header = skb2->network_header;
1547                         skb2->pkt_type = PACKET_OUTGOING;
1548                         ptype->func(skb2, skb->dev, ptype, skb->dev);
1549                 }
1550         }
1551         rcu_read_unlock();
1552 }
1553
1554 /*
1555  * Routine to help set real_num_tx_queues. To avoid skbs mapped to queues
1556  * greater then real_num_tx_queues stale skbs on the qdisc must be flushed.
1557  */
1558 int netif_set_real_num_tx_queues(struct net_device *dev, unsigned int txq)
1559 {
1560         if (txq < 1 || txq > dev->num_tx_queues)
1561                 return -EINVAL;
1562
1563         if (dev->reg_state == NETREG_REGISTERED) {
1564                 ASSERT_RTNL();
1565
1566                 if (txq < dev->real_num_tx_queues)
1567                         qdisc_reset_all_tx_gt(dev, txq);
1568         }
1569
1570         dev->real_num_tx_queues = txq;
1571         return 0;
1572 }
1573 EXPORT_SYMBOL(netif_set_real_num_tx_queues);
1574
1575 #ifdef CONFIG_RPS
1576 /**
1577  *      netif_set_real_num_rx_queues - set actual number of RX queues used
1578  *      @dev: Network device
1579  *      @rxq: Actual number of RX queues
1580  *
1581  *      This must be called either with the rtnl_lock held or before
1582  *      registration of the net device.  Returns 0 on success, or a
1583  *      negative error code.  If called before registration, it always
1584  *      succeeds.
1585  */
1586 int netif_set_real_num_rx_queues(struct net_device *dev, unsigned int rxq)
1587 {
1588         int rc;
1589
1590         if (rxq < 1 || rxq > dev->num_rx_queues)
1591                 return -EINVAL;
1592
1593         if (dev->reg_state == NETREG_REGISTERED) {
1594                 ASSERT_RTNL();
1595
1596                 rc = net_rx_queue_update_kobjects(dev, dev->real_num_rx_queues,
1597                                                   rxq);
1598                 if (rc)
1599                         return rc;
1600         }
1601
1602         dev->real_num_rx_queues = rxq;
1603         return 0;
1604 }
1605 EXPORT_SYMBOL(netif_set_real_num_rx_queues);
1606 #endif
1607
1608 static inline void __netif_reschedule(struct Qdisc *q)
1609 {
1610         struct softnet_data *sd;
1611         unsigned long flags;
1612
1613         local_irq_save(flags);
1614         sd = &__get_cpu_var(softnet_data);
1615         q->next_sched = NULL;
1616         *sd->output_queue_tailp = q;
1617         sd->output_queue_tailp = &q->next_sched;
1618         raise_softirq_irqoff(NET_TX_SOFTIRQ);
1619         local_irq_restore(flags);
1620 }
1621
1622 void __netif_schedule(struct Qdisc *q)
1623 {
1624         if (!test_and_set_bit(__QDISC_STATE_SCHED, &q->state))
1625                 __netif_reschedule(q);
1626 }
1627 EXPORT_SYMBOL(__netif_schedule);
1628
1629 void dev_kfree_skb_irq(struct sk_buff *skb)
1630 {
1631         if (atomic_dec_and_test(&skb->users)) {
1632                 struct softnet_data *sd;
1633                 unsigned long flags;
1634
1635                 local_irq_save(flags);
1636                 sd = &__get_cpu_var(softnet_data);
1637                 skb->next = sd->completion_queue;
1638                 sd->completion_queue = skb;
1639                 raise_softirq_irqoff(NET_TX_SOFTIRQ);
1640                 local_irq_restore(flags);
1641         }
1642 }
1643 EXPORT_SYMBOL(dev_kfree_skb_irq);
1644
1645 void dev_kfree_skb_any(struct sk_buff *skb)
1646 {
1647         if (in_irq() || irqs_disabled())
1648                 dev_kfree_skb_irq(skb);
1649         else
1650                 dev_kfree_skb(skb);
1651 }
1652 EXPORT_SYMBOL(dev_kfree_skb_any);
1653
1654
1655 /**
1656  * netif_device_detach - mark device as removed
1657  * @dev: network device
1658  *
1659  * Mark device as removed from system and therefore no longer available.
1660  */
1661 void netif_device_detach(struct net_device *dev)
1662 {
1663         if (test_and_clear_bit(__LINK_STATE_PRESENT, &dev->state) &&
1664             netif_running(dev)) {
1665                 netif_tx_stop_all_queues(dev);
1666         }
1667 }
1668 EXPORT_SYMBOL(netif_device_detach);
1669
1670 /**
1671  * netif_device_attach - mark device as attached
1672  * @dev: network device
1673  *
1674  * Mark device as attached from system and restart if needed.
1675  */
1676 void netif_device_attach(struct net_device *dev)
1677 {
1678         if (!test_and_set_bit(__LINK_STATE_PRESENT, &dev->state) &&
1679             netif_running(dev)) {
1680                 netif_tx_wake_all_queues(dev);
1681                 __netdev_watchdog_up(dev);
1682         }
1683 }
1684 EXPORT_SYMBOL(netif_device_attach);
1685
1686 static bool can_checksum_protocol(unsigned long features, __be16 protocol)
1687 {
1688         return ((features & NETIF_F_NO_CSUM) ||
1689                 ((features & NETIF_F_V4_CSUM) &&
1690                  protocol == htons(ETH_P_IP)) ||
1691                 ((features & NETIF_F_V6_CSUM) &&
1692                  protocol == htons(ETH_P_IPV6)) ||
1693                 ((features & NETIF_F_FCOE_CRC) &&
1694                  protocol == htons(ETH_P_FCOE)));
1695 }
1696
1697 static bool dev_can_checksum(struct net_device *dev, struct sk_buff *skb)
1698 {
1699         __be16 protocol = skb->protocol;
1700         int features = dev->features;
1701
1702         if (vlan_tx_tag_present(skb)) {
1703                 features &= dev->vlan_features;
1704         } else if (protocol == htons(ETH_P_8021Q)) {
1705                 struct vlan_ethhdr *veh = (struct vlan_ethhdr *)skb->data;
1706                 protocol = veh->h_vlan_encapsulated_proto;
1707                 features &= dev->vlan_features;
1708         }
1709
1710         return can_checksum_protocol(features, protocol);
1711 }
1712
1713 /**
1714  * skb_dev_set -- assign a new device to a buffer
1715  * @skb: buffer for the new device
1716  * @dev: network device
1717  *
1718  * If an skb is owned by a device already, we have to reset
1719  * all data private to the namespace a device belongs to
1720  * before assigning it a new device.
1721  */
1722 #ifdef CONFIG_NET_NS
1723 void skb_set_dev(struct sk_buff *skb, struct net_device *dev)
1724 {
1725         skb_dst_drop(skb);
1726         if (skb->dev && !net_eq(dev_net(skb->dev), dev_net(dev))) {
1727                 secpath_reset(skb);
1728                 nf_reset(skb);
1729                 skb_init_secmark(skb);
1730                 skb->mark = 0;
1731                 skb->priority = 0;
1732                 skb->nf_trace = 0;
1733                 skb->ipvs_property = 0;
1734 #ifdef CONFIG_NET_SCHED
1735                 skb->tc_index = 0;
1736 #endif
1737         }
1738         skb->dev = dev;
1739 }
1740 EXPORT_SYMBOL(skb_set_dev);
1741 #endif /* CONFIG_NET_NS */
1742
1743 /*
1744  * Invalidate hardware checksum when packet is to be mangled, and
1745  * complete checksum manually on outgoing path.
1746  */
1747 int skb_checksum_help(struct sk_buff *skb)
1748 {
1749         __wsum csum;
1750         int ret = 0, offset;
1751
1752         if (skb->ip_summed == CHECKSUM_COMPLETE)
1753                 goto out_set_summed;
1754
1755         if (unlikely(skb_shinfo(skb)->gso_size)) {
1756                 /* Let GSO fix up the checksum. */
1757                 goto out_set_summed;
1758         }
1759
1760         offset = skb->csum_start - skb_headroom(skb);
1761         BUG_ON(offset >= skb_headlen(skb));
1762         csum = skb_checksum(skb, offset, skb->len - offset, 0);
1763
1764         offset += skb->csum_offset;
1765         BUG_ON(offset + sizeof(__sum16) > skb_headlen(skb));
1766
1767         if (skb_cloned(skb) &&
1768             !skb_clone_writable(skb, offset + sizeof(__sum16))) {
1769                 ret = pskb_expand_head(skb, 0, 0, GFP_ATOMIC);
1770                 if (ret)
1771                         goto out;
1772         }
1773
1774         *(__sum16 *)(skb->data + offset) = csum_fold(csum);
1775 out_set_summed:
1776         skb->ip_summed = CHECKSUM_NONE;
1777 out:
1778         return ret;
1779 }
1780 EXPORT_SYMBOL(skb_checksum_help);
1781
1782 /**
1783  *      skb_gso_segment - Perform segmentation on skb.
1784  *      @skb: buffer to segment
1785  *      @features: features for the output path (see dev->features)
1786  *
1787  *      This function segments the given skb and returns a list of segments.
1788  *
1789  *      It may return NULL if the skb requires no segmentation.  This is
1790  *      only possible when GSO is used for verifying header integrity.
1791  */
1792 struct sk_buff *skb_gso_segment(struct sk_buff *skb, int features)
1793 {
1794         struct sk_buff *segs = ERR_PTR(-EPROTONOSUPPORT);
1795         struct packet_type *ptype;
1796         __be16 type = skb->protocol;
1797         int vlan_depth = ETH_HLEN;
1798         int err;
1799
1800         while (type == htons(ETH_P_8021Q)) {
1801                 struct vlan_hdr *vh;
1802
1803                 if (unlikely(!pskb_may_pull(skb, vlan_depth + VLAN_HLEN)))
1804                         return ERR_PTR(-EINVAL);
1805
1806                 vh = (struct vlan_hdr *)(skb->data + vlan_depth);
1807                 type = vh->h_vlan_encapsulated_proto;
1808                 vlan_depth += VLAN_HLEN;
1809         }
1810
1811         skb_reset_mac_header(skb);
1812         skb->mac_len = skb->network_header - skb->mac_header;
1813         __skb_pull(skb, skb->mac_len);
1814
1815         if (unlikely(skb->ip_summed != CHECKSUM_PARTIAL)) {
1816                 struct net_device *dev = skb->dev;
1817                 struct ethtool_drvinfo info = {};
1818
1819                 if (dev && dev->ethtool_ops && dev->ethtool_ops->get_drvinfo)
1820                         dev->ethtool_ops->get_drvinfo(dev, &info);
1821
1822                 WARN(1, "%s: caps=(0x%lx, 0x%lx) len=%d data_len=%d ip_summed=%d\n",
1823                      info.driver, dev ? dev->features : 0L,
1824                      skb->sk ? skb->sk->sk_route_caps : 0L,
1825                      skb->len, skb->data_len, skb->ip_summed);
1826
1827                 if (skb_header_cloned(skb) &&
1828                     (err = pskb_expand_head(skb, 0, 0, GFP_ATOMIC)))
1829                         return ERR_PTR(err);
1830         }
1831
1832         rcu_read_lock();
1833         list_for_each_entry_rcu(ptype,
1834                         &ptype_base[ntohs(type) & PTYPE_HASH_MASK], list) {
1835                 if (ptype->type == type && !ptype->dev && ptype->gso_segment) {
1836                         if (unlikely(skb->ip_summed != CHECKSUM_PARTIAL)) {
1837                                 err = ptype->gso_send_check(skb);
1838                                 segs = ERR_PTR(err);
1839                                 if (err || skb_gso_ok(skb, features))
1840                                         break;
1841                                 __skb_push(skb, (skb->data -
1842                                                  skb_network_header(skb)));
1843                         }
1844                         segs = ptype->gso_segment(skb, features);
1845                         break;
1846                 }
1847         }
1848         rcu_read_unlock();
1849
1850         __skb_push(skb, skb->data - skb_mac_header(skb));
1851
1852         return segs;
1853 }
1854 EXPORT_SYMBOL(skb_gso_segment);
1855
1856 /* Take action when hardware reception checksum errors are detected. */
1857 #ifdef CONFIG_BUG
1858 void netdev_rx_csum_fault(struct net_device *dev)
1859 {
1860         if (net_ratelimit()) {
1861                 printk(KERN_ERR "%s: hw csum failure.\n",
1862                         dev ? dev->name : "<unknown>");
1863                 dump_stack();
1864         }
1865 }
1866 EXPORT_SYMBOL(netdev_rx_csum_fault);
1867 #endif
1868
1869 /* Actually, we should eliminate this check as soon as we know, that:
1870  * 1. IOMMU is present and allows to map all the memory.
1871  * 2. No high memory really exists on this machine.
1872  */
1873
1874 static int illegal_highdma(struct net_device *dev, struct sk_buff *skb)
1875 {
1876 #ifdef CONFIG_HIGHMEM
1877         int i;
1878         if (!(dev->features & NETIF_F_HIGHDMA)) {
1879                 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++)
1880                         if (PageHighMem(skb_shinfo(skb)->frags[i].page))
1881                                 return 1;
1882         }
1883
1884         if (PCI_DMA_BUS_IS_PHYS) {
1885                 struct device *pdev = dev->dev.parent;
1886
1887                 if (!pdev)
1888                         return 0;
1889                 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
1890                         dma_addr_t addr = page_to_phys(skb_shinfo(skb)->frags[i].page);
1891                         if (!pdev->dma_mask || addr + PAGE_SIZE - 1 > *pdev->dma_mask)
1892                                 return 1;
1893                 }
1894         }
1895 #endif
1896         return 0;
1897 }
1898
1899 struct dev_gso_cb {
1900         void (*destructor)(struct sk_buff *skb);
1901 };
1902
1903 #define DEV_GSO_CB(skb) ((struct dev_gso_cb *)(skb)->cb)
1904
1905 static void dev_gso_skb_destructor(struct sk_buff *skb)
1906 {
1907         struct dev_gso_cb *cb;
1908
1909         do {
1910                 struct sk_buff *nskb = skb->next;
1911
1912                 skb->next = nskb->next;
1913                 nskb->next = NULL;
1914                 kfree_skb(nskb);
1915         } while (skb->next);
1916
1917         cb = DEV_GSO_CB(skb);
1918         if (cb->destructor)
1919                 cb->destructor(skb);
1920 }
1921
1922 /**
1923  *      dev_gso_segment - Perform emulated hardware segmentation on skb.
1924  *      @skb: buffer to segment
1925  *
1926  *      This function segments the given skb and stores the list of segments
1927  *      in skb->next.
1928  */
1929 static int dev_gso_segment(struct sk_buff *skb)
1930 {
1931         struct net_device *dev = skb->dev;
1932         struct sk_buff *segs;
1933         int features = dev->features & ~(illegal_highdma(dev, skb) ?
1934                                          NETIF_F_SG : 0);
1935
1936         segs = skb_gso_segment(skb, features);
1937
1938         /* Verifying header integrity only. */
1939         if (!segs)
1940                 return 0;
1941
1942         if (IS_ERR(segs))
1943                 return PTR_ERR(segs);
1944
1945         skb->next = segs;
1946         DEV_GSO_CB(skb)->destructor = skb->destructor;
1947         skb->destructor = dev_gso_skb_destructor;
1948
1949         return 0;
1950 }
1951
1952 /*
1953  * Try to orphan skb early, right before transmission by the device.
1954  * We cannot orphan skb if tx timestamp is requested or the sk-reference
1955  * is needed on driver level for other reasons, e.g. see net/can/raw.c
1956  */
1957 static inline void skb_orphan_try(struct sk_buff *skb)
1958 {
1959         struct sock *sk = skb->sk;
1960
1961         if (sk && !skb_shinfo(skb)->tx_flags) {
1962                 /* skb_tx_hash() wont be able to get sk.
1963                  * We copy sk_hash into skb->rxhash
1964                  */
1965                 if (!skb->rxhash)
1966                         skb->rxhash = sk->sk_hash;
1967                 skb_orphan(skb);
1968         }
1969 }
1970
1971 int netif_get_vlan_features(struct sk_buff *skb, struct net_device *dev)
1972 {
1973         __be16 protocol = skb->protocol;
1974
1975         if (protocol == htons(ETH_P_8021Q)) {
1976                 struct vlan_ethhdr *veh = (struct vlan_ethhdr *)skb->data;
1977                 protocol = veh->h_vlan_encapsulated_proto;
1978         } else if (!skb->vlan_tci)
1979                 return dev->features;
1980
1981         if (protocol != htons(ETH_P_8021Q))
1982                 return dev->features & dev->vlan_features;
1983         else
1984                 return 0;
1985 }
1986 EXPORT_SYMBOL(netif_get_vlan_features);
1987
1988 /*
1989  * Returns true if either:
1990  *      1. skb has frag_list and the device doesn't support FRAGLIST, or
1991  *      2. skb is fragmented and the device does not support SG, or if
1992  *         at least one of fragments is in highmem and device does not
1993  *         support DMA from it.
1994  */
1995 static inline int skb_needs_linearize(struct sk_buff *skb,
1996                                       struct net_device *dev)
1997 {
1998         if (skb_is_nonlinear(skb)) {
1999                 int features = dev->features;
2000
2001                 if (vlan_tx_tag_present(skb))
2002                         features &= dev->vlan_features;
2003
2004                 return (skb_has_frag_list(skb) &&
2005                         !(features & NETIF_F_FRAGLIST)) ||
2006                         (skb_shinfo(skb)->nr_frags &&
2007                         (!(features & NETIF_F_SG) ||
2008                         illegal_highdma(dev, skb)));
2009         }
2010
2011         return 0;
2012 }
2013
2014 int dev_hard_start_xmit(struct sk_buff *skb, struct net_device *dev,
2015                         struct netdev_queue *txq)
2016 {
2017         const struct net_device_ops *ops = dev->netdev_ops;
2018         int rc = NETDEV_TX_OK;
2019
2020         if (likely(!skb->next)) {
2021                 if (!list_empty(&ptype_all))
2022                         dev_queue_xmit_nit(skb, dev);
2023
2024                 /*
2025                  * If device doesnt need skb->dst, release it right now while
2026                  * its hot in this cpu cache
2027                  */
2028                 if (dev->priv_flags & IFF_XMIT_DST_RELEASE)
2029                         skb_dst_drop(skb);
2030
2031                 skb_orphan_try(skb);
2032
2033                 if (vlan_tx_tag_present(skb) &&
2034                     !(dev->features & NETIF_F_HW_VLAN_TX)) {
2035                         skb = __vlan_put_tag(skb, vlan_tx_tag_get(skb));
2036                         if (unlikely(!skb))
2037                                 goto out;
2038
2039                         skb->vlan_tci = 0;
2040                 }
2041
2042                 if (netif_needs_gso(dev, skb)) {
2043                         if (unlikely(dev_gso_segment(skb)))
2044                                 goto out_kfree_skb;
2045                         if (skb->next)
2046                                 goto gso;
2047                 } else {
2048                         if (skb_needs_linearize(skb, dev) &&
2049                             __skb_linearize(skb))
2050                                 goto out_kfree_skb;
2051
2052                         /* If packet is not checksummed and device does not
2053                          * support checksumming for this protocol, complete
2054                          * checksumming here.
2055                          */
2056                         if (skb->ip_summed == CHECKSUM_PARTIAL) {
2057                                 skb_set_transport_header(skb, skb->csum_start -
2058                                               skb_headroom(skb));
2059                                 if (!dev_can_checksum(dev, skb) &&
2060                                      skb_checksum_help(skb))
2061                                         goto out_kfree_skb;
2062                         }
2063                 }
2064
2065                 rc = ops->ndo_start_xmit(skb, dev);
2066                 trace_net_dev_xmit(skb, rc);
2067                 if (rc == NETDEV_TX_OK)
2068                         txq_trans_update(txq);
2069                 return rc;
2070         }
2071
2072 gso:
2073         do {
2074                 struct sk_buff *nskb = skb->next;
2075
2076                 skb->next = nskb->next;
2077                 nskb->next = NULL;
2078
2079                 /*
2080                  * If device doesnt need nskb->dst, release it right now while
2081                  * its hot in this cpu cache
2082                  */
2083                 if (dev->priv_flags & IFF_XMIT_DST_RELEASE)
2084                         skb_dst_drop(nskb);
2085
2086                 rc = ops->ndo_start_xmit(nskb, dev);
2087                 trace_net_dev_xmit(nskb, rc);
2088                 if (unlikely(rc != NETDEV_TX_OK)) {
2089                         if (rc & ~NETDEV_TX_MASK)
2090                                 goto out_kfree_gso_skb;
2091                         nskb->next = skb->next;
2092                         skb->next = nskb;
2093                         return rc;
2094                 }
2095                 txq_trans_update(txq);
2096                 if (unlikely(netif_tx_queue_stopped(txq) && skb->next))
2097                         return NETDEV_TX_BUSY;
2098         } while (skb->next);
2099
2100 out_kfree_gso_skb:
2101         if (likely(skb->next == NULL))
2102                 skb->destructor = DEV_GSO_CB(skb)->destructor;
2103 out_kfree_skb:
2104         kfree_skb(skb);
2105 out:
2106         return rc;
2107 }
2108
2109 static u32 hashrnd __read_mostly;
2110
2111 u16 skb_tx_hash(const struct net_device *dev, const struct sk_buff *skb)
2112 {
2113         u32 hash;
2114
2115         if (skb_rx_queue_recorded(skb)) {
2116                 hash = skb_get_rx_queue(skb);
2117                 while (unlikely(hash >= dev->real_num_tx_queues))
2118                         hash -= dev->real_num_tx_queues;
2119                 return hash;
2120         }
2121
2122         if (skb->sk && skb->sk->sk_hash)
2123                 hash = skb->sk->sk_hash;
2124         else
2125                 hash = (__force u16) skb->protocol ^ skb->rxhash;
2126         hash = jhash_1word(hash, hashrnd);
2127
2128         return (u16) (((u64) hash * dev->real_num_tx_queues) >> 32);
2129 }
2130 EXPORT_SYMBOL(skb_tx_hash);
2131
2132 static inline u16 dev_cap_txqueue(struct net_device *dev, u16 queue_index)
2133 {
2134         if (unlikely(queue_index >= dev->real_num_tx_queues)) {
2135                 if (net_ratelimit()) {
2136                         pr_warning("%s selects TX queue %d, but "
2137                                 "real number of TX queues is %d\n",
2138                                 dev->name, queue_index, dev->real_num_tx_queues);
2139                 }
2140                 return 0;
2141         }
2142         return queue_index;
2143 }
2144
2145 static struct netdev_queue *dev_pick_tx(struct net_device *dev,
2146                                         struct sk_buff *skb)
2147 {
2148         int queue_index;
2149         const struct net_device_ops *ops = dev->netdev_ops;
2150
2151         if (ops->ndo_select_queue) {
2152                 queue_index = ops->ndo_select_queue(dev, skb);
2153                 queue_index = dev_cap_txqueue(dev, queue_index);
2154         } else {
2155                 struct sock *sk = skb->sk;
2156                 queue_index = sk_tx_queue_get(sk);
2157                 if (queue_index < 0 || queue_index >= dev->real_num_tx_queues) {
2158
2159                         queue_index = 0;
2160                         if (dev->real_num_tx_queues > 1)
2161                                 queue_index = skb_tx_hash(dev, skb);
2162
2163                         if (sk) {
2164                                 struct dst_entry *dst = rcu_dereference_check(sk->sk_dst_cache, 1);
2165
2166                                 if (dst && skb_dst(skb) == dst)
2167                                         sk_tx_queue_set(sk, queue_index);
2168                         }
2169                 }
2170         }
2171
2172         skb_set_queue_mapping(skb, queue_index);
2173         return netdev_get_tx_queue(dev, queue_index);
2174 }
2175
2176 static inline int __dev_xmit_skb(struct sk_buff *skb, struct Qdisc *q,
2177                                  struct net_device *dev,
2178                                  struct netdev_queue *txq)
2179 {
2180         spinlock_t *root_lock = qdisc_lock(q);
2181         bool contended = qdisc_is_running(q);
2182         int rc;
2183
2184         /*
2185          * Heuristic to force contended enqueues to serialize on a
2186          * separate lock before trying to get qdisc main lock.
2187          * This permits __QDISC_STATE_RUNNING owner to get the lock more often
2188          * and dequeue packets faster.
2189          */
2190         if (unlikely(contended))
2191                 spin_lock(&q->busylock);
2192
2193         spin_lock(root_lock);
2194         if (unlikely(test_bit(__QDISC_STATE_DEACTIVATED, &q->state))) {
2195                 kfree_skb(skb);
2196                 rc = NET_XMIT_DROP;
2197         } else if ((q->flags & TCQ_F_CAN_BYPASS) && !qdisc_qlen(q) &&
2198                    qdisc_run_begin(q)) {
2199                 /*
2200                  * This is a work-conserving queue; there are no old skbs
2201                  * waiting to be sent out; and the qdisc is not running -
2202                  * xmit the skb directly.
2203                  */
2204                 if (!(dev->priv_flags & IFF_XMIT_DST_RELEASE))
2205                         skb_dst_force(skb);
2206                 __qdisc_update_bstats(q, skb->len);
2207                 if (sch_direct_xmit(skb, q, dev, txq, root_lock)) {
2208                         if (unlikely(contended)) {
2209                                 spin_unlock(&q->busylock);
2210                                 contended = false;
2211                         }
2212                         __qdisc_run(q);
2213                 } else
2214                         qdisc_run_end(q);
2215
2216                 rc = NET_XMIT_SUCCESS;
2217         } else {
2218                 skb_dst_force(skb);
2219                 rc = qdisc_enqueue_root(skb, q);
2220                 if (qdisc_run_begin(q)) {
2221                         if (unlikely(contended)) {
2222                                 spin_unlock(&q->busylock);
2223                                 contended = false;
2224                         }
2225                         __qdisc_run(q);
2226                 }
2227         }
2228         spin_unlock(root_lock);
2229         if (unlikely(contended))
2230                 spin_unlock(&q->busylock);
2231         return rc;
2232 }
2233
2234 static DEFINE_PER_CPU(int, xmit_recursion);
2235 #define RECURSION_LIMIT 10
2236
2237 /**
2238  *      dev_queue_xmit - transmit a buffer
2239  *      @skb: buffer to transmit
2240  *
2241  *      Queue a buffer for transmission to a network device. The caller must
2242  *      have set the device and priority and built the buffer before calling
2243  *      this function. The function can be called from an interrupt.
2244  *
2245  *      A negative errno code is returned on a failure. A success does not
2246  *      guarantee the frame will be transmitted as it may be dropped due
2247  *      to congestion or traffic shaping.
2248  *
2249  * -----------------------------------------------------------------------------------
2250  *      I notice this method can also return errors from the queue disciplines,
2251  *      including NET_XMIT_DROP, which is a positive value.  So, errors can also
2252  *      be positive.
2253  *
2254  *      Regardless of the return value, the skb is consumed, so it is currently
2255  *      difficult to retry a send to this method.  (You can bump the ref count
2256  *      before sending to hold a reference for retry if you are careful.)
2257  *
2258  *      When calling this method, interrupts MUST be enabled.  This is because
2259  *      the BH enable code must have IRQs enabled so that it will not deadlock.
2260  *          --BLG
2261  */
2262 int dev_queue_xmit(struct sk_buff *skb)
2263 {
2264         struct net_device *dev = skb->dev;
2265         struct netdev_queue *txq;
2266         struct Qdisc *q;
2267         int rc = -ENOMEM;
2268
2269         /* Disable soft irqs for various locks below. Also
2270          * stops preemption for RCU.
2271          */
2272         rcu_read_lock_bh();
2273
2274         txq = dev_pick_tx(dev, skb);
2275         q = rcu_dereference_bh(txq->qdisc);
2276
2277 #ifdef CONFIG_NET_CLS_ACT
2278         skb->tc_verd = SET_TC_AT(skb->tc_verd, AT_EGRESS);
2279 #endif
2280         trace_net_dev_queue(skb);
2281         if (q->enqueue) {
2282                 rc = __dev_xmit_skb(skb, q, dev, txq);
2283                 goto out;
2284         }
2285
2286         /* The device has no queue. Common case for software devices:
2287            loopback, all the sorts of tunnels...
2288
2289            Really, it is unlikely that netif_tx_lock protection is necessary
2290            here.  (f.e. loopback and IP tunnels are clean ignoring statistics
2291            counters.)
2292            However, it is possible, that they rely on protection
2293            made by us here.
2294
2295            Check this and shot the lock. It is not prone from deadlocks.
2296            Either shot noqueue qdisc, it is even simpler 8)
2297          */
2298         if (dev->flags & IFF_UP) {
2299                 int cpu = smp_processor_id(); /* ok because BHs are off */
2300
2301                 if (txq->xmit_lock_owner != cpu) {
2302
2303                         if (__this_cpu_read(xmit_recursion) > RECURSION_LIMIT)
2304                                 goto recursion_alert;
2305
2306                         HARD_TX_LOCK(dev, txq, cpu);
2307
2308                         if (!netif_tx_queue_stopped(txq)) {
2309                                 __this_cpu_inc(xmit_recursion);
2310                                 rc = dev_hard_start_xmit(skb, dev, txq);
2311                                 __this_cpu_dec(xmit_recursion);
2312                                 if (dev_xmit_complete(rc)) {
2313                                         HARD_TX_UNLOCK(dev, txq);
2314                                         goto out;
2315                                 }
2316                         }
2317                         HARD_TX_UNLOCK(dev, txq);
2318                         if (net_ratelimit())
2319                                 printk(KERN_CRIT "Virtual device %s asks to "
2320                                        "queue packet!\n", dev->name);
2321                 } else {
2322                         /* Recursion is detected! It is possible,
2323                          * unfortunately
2324                          */
2325 recursion_alert:
2326                         if (net_ratelimit())
2327                                 printk(KERN_CRIT "Dead loop on virtual device "
2328                                        "%s, fix it urgently!\n", dev->name);
2329                 }
2330         }
2331
2332         rc = -ENETDOWN;
2333         rcu_read_unlock_bh();
2334
2335         kfree_skb(skb);
2336         return rc;
2337 out:
2338         rcu_read_unlock_bh();
2339         return rc;
2340 }
2341 EXPORT_SYMBOL(dev_queue_xmit);
2342
2343
2344 /*=======================================================================
2345                         Receiver routines
2346   =======================================================================*/
2347
2348 int netdev_max_backlog __read_mostly = 1000;
2349 int netdev_tstamp_prequeue __read_mostly = 1;
2350 int netdev_budget __read_mostly = 300;
2351 int weight_p __read_mostly = 64;            /* old backlog weight */
2352
2353 /* Called with irq disabled */
2354 static inline void ____napi_schedule(struct softnet_data *sd,
2355                                      struct napi_struct *napi)
2356 {
2357         list_add_tail(&napi->poll_list, &sd->poll_list);
2358         __raise_softirq_irqoff(NET_RX_SOFTIRQ);
2359 }
2360
2361 /*
2362  * __skb_get_rxhash: calculate a flow hash based on src/dst addresses
2363  * and src/dst port numbers. Returns a non-zero hash number on success
2364  * and 0 on failure.
2365  */
2366 __u32 __skb_get_rxhash(struct sk_buff *skb)
2367 {
2368         int nhoff, hash = 0, poff;
2369         struct ipv6hdr *ip6;
2370         struct iphdr *ip;
2371         u8 ip_proto;
2372         u32 addr1, addr2, ihl;
2373         union {
2374                 u32 v32;
2375                 u16 v16[2];
2376         } ports;
2377
2378         nhoff = skb_network_offset(skb);
2379
2380         switch (skb->protocol) {
2381         case __constant_htons(ETH_P_IP):
2382                 if (!pskb_may_pull(skb, sizeof(*ip) + nhoff))
2383                         goto done;
2384
2385                 ip = (struct iphdr *) (skb->data + nhoff);
2386                 if (ip->frag_off & htons(IP_MF | IP_OFFSET))
2387                         ip_proto = 0;
2388                 else
2389                         ip_proto = ip->protocol;
2390                 addr1 = (__force u32) ip->saddr;
2391                 addr2 = (__force u32) ip->daddr;
2392                 ihl = ip->ihl;
2393                 break;
2394         case __constant_htons(ETH_P_IPV6):
2395                 if (!pskb_may_pull(skb, sizeof(*ip6) + nhoff))
2396                         goto done;
2397
2398                 ip6 = (struct ipv6hdr *) (skb->data + nhoff);
2399                 ip_proto = ip6->nexthdr;
2400                 addr1 = (__force u32) ip6->saddr.s6_addr32[3];
2401                 addr2 = (__force u32) ip6->daddr.s6_addr32[3];
2402                 ihl = (40 >> 2);
2403                 break;
2404         default:
2405                 goto done;
2406         }
2407
2408         ports.v32 = 0;
2409         poff = proto_ports_offset(ip_proto);
2410         if (poff >= 0) {
2411                 nhoff += ihl * 4 + poff;
2412                 if (pskb_may_pull(skb, nhoff + 4)) {
2413                         ports.v32 = * (__force u32 *) (skb->data + nhoff);
2414                         if (ports.v16[1] < ports.v16[0])
2415                                 swap(ports.v16[0], ports.v16[1]);
2416                 }
2417         }
2418
2419         /* get a consistent hash (same value on both flow directions) */
2420         if (addr2 < addr1)
2421                 swap(addr1, addr2);
2422
2423         hash = jhash_3words(addr1, addr2, ports.v32, hashrnd);
2424         if (!hash)
2425                 hash = 1;
2426
2427 done:
2428         return hash;
2429 }
2430 EXPORT_SYMBOL(__skb_get_rxhash);
2431
2432 #ifdef CONFIG_RPS
2433
2434 /* One global table that all flow-based protocols share. */
2435 struct rps_sock_flow_table __rcu *rps_sock_flow_table __read_mostly;
2436 EXPORT_SYMBOL(rps_sock_flow_table);
2437
2438 /*
2439  * get_rps_cpu is called from netif_receive_skb and returns the target
2440  * CPU from the RPS map of the receiving queue for a given skb.
2441  * rcu_read_lock must be held on entry.
2442  */
2443 static int get_rps_cpu(struct net_device *dev, struct sk_buff *skb,
2444                        struct rps_dev_flow **rflowp)
2445 {
2446         struct netdev_rx_queue *rxqueue;
2447         struct rps_map *map;
2448         struct rps_dev_flow_table *flow_table;
2449         struct rps_sock_flow_table *sock_flow_table;
2450         int cpu = -1;
2451         u16 tcpu;
2452
2453         if (skb_rx_queue_recorded(skb)) {
2454                 u16 index = skb_get_rx_queue(skb);
2455                 if (unlikely(index >= dev->real_num_rx_queues)) {
2456                         WARN_ONCE(dev->real_num_rx_queues > 1,
2457                                   "%s received packet on queue %u, but number "
2458                                   "of RX queues is %u\n",
2459                                   dev->name, index, dev->real_num_rx_queues);
2460                         goto done;
2461                 }
2462                 rxqueue = dev->_rx + index;
2463         } else
2464                 rxqueue = dev->_rx;
2465
2466         map = rcu_dereference(rxqueue->rps_map);
2467         if (map) {
2468                 if (map->len == 1) {
2469                         tcpu = map->cpus[0];
2470                         if (cpu_online(tcpu))
2471                                 cpu = tcpu;
2472                         goto done;
2473                 }
2474         } else if (!rcu_dereference_raw(rxqueue->rps_flow_table)) {
2475                 goto done;
2476         }
2477
2478         skb_reset_network_header(skb);
2479         if (!skb_get_rxhash(skb))
2480                 goto done;
2481
2482         flow_table = rcu_dereference(rxqueue->rps_flow_table);
2483         sock_flow_table = rcu_dereference(rps_sock_flow_table);
2484         if (flow_table && sock_flow_table) {
2485                 u16 next_cpu;
2486                 struct rps_dev_flow *rflow;
2487
2488                 rflow = &flow_table->flows[skb->rxhash & flow_table->mask];
2489                 tcpu = rflow->cpu;
2490
2491                 next_cpu = sock_flow_table->ents[skb->rxhash &
2492                     sock_flow_table->mask];
2493
2494                 /*
2495                  * If the desired CPU (where last recvmsg was done) is
2496                  * different from current CPU (one in the rx-queue flow
2497                  * table entry), switch if one of the following holds:
2498                  *   - Current CPU is unset (equal to RPS_NO_CPU).
2499                  *   - Current CPU is offline.
2500                  *   - The current CPU's queue tail has advanced beyond the
2501                  *     last packet that was enqueued using this table entry.
2502                  *     This guarantees that all previous packets for the flow
2503                  *     have been dequeued, thus preserving in order delivery.
2504                  */
2505                 if (unlikely(tcpu != next_cpu) &&
2506                     (tcpu == RPS_NO_CPU || !cpu_online(tcpu) ||
2507                      ((int)(per_cpu(softnet_data, tcpu).input_queue_head -
2508                       rflow->last_qtail)) >= 0)) {
2509                         tcpu = rflow->cpu = next_cpu;
2510                         if (tcpu != RPS_NO_CPU)
2511                                 rflow->last_qtail = per_cpu(softnet_data,
2512                                     tcpu).input_queue_head;
2513                 }
2514                 if (tcpu != RPS_NO_CPU && cpu_online(tcpu)) {
2515                         *rflowp = rflow;
2516                         cpu = tcpu;
2517                         goto done;
2518                 }
2519         }
2520
2521         if (map) {
2522                 tcpu = map->cpus[((u64) skb->rxhash * map->len) >> 32];
2523
2524                 if (cpu_online(tcpu)) {
2525                         cpu = tcpu;
2526                         goto done;
2527                 }
2528         }
2529
2530 done:
2531         return cpu;
2532 }
2533
2534 /* Called from hardirq (IPI) context */
2535 static void rps_trigger_softirq(void *data)
2536 {
2537         struct softnet_data *sd = data;
2538
2539         ____napi_schedule(sd, &sd->backlog);
2540         sd->received_rps++;
2541 }
2542
2543 #endif /* CONFIG_RPS */
2544
2545 /*
2546  * Check if this softnet_data structure is another cpu one
2547  * If yes, queue it to our IPI list and return 1
2548  * If no, return 0
2549  */
2550 static int rps_ipi_queued(struct softnet_data *sd)
2551 {
2552 #ifdef CONFIG_RPS
2553         struct softnet_data *mysd = &__get_cpu_var(softnet_data);
2554
2555         if (sd != mysd) {
2556                 sd->rps_ipi_next = mysd->rps_ipi_list;
2557                 mysd->rps_ipi_list = sd;
2558
2559                 __raise_softirq_irqoff(NET_RX_SOFTIRQ);
2560                 return 1;
2561         }
2562 #endif /* CONFIG_RPS */
2563         return 0;
2564 }
2565
2566 /*
2567  * enqueue_to_backlog is called to queue an skb to a per CPU backlog
2568  * queue (may be a remote CPU queue).
2569  */
2570 static int enqueue_to_backlog(struct sk_buff *skb, int cpu,
2571                               unsigned int *qtail)
2572 {
2573         struct softnet_data *sd;
2574         unsigned long flags;
2575
2576         sd = &per_cpu(softnet_data, cpu);
2577
2578         local_irq_save(flags);
2579
2580         rps_lock(sd);
2581         if (skb_queue_len(&sd->input_pkt_queue) <= netdev_max_backlog) {
2582                 if (skb_queue_len(&sd->input_pkt_queue)) {
2583 enqueue:
2584                         __skb_queue_tail(&sd->input_pkt_queue, skb);
2585                         input_queue_tail_incr_save(sd, qtail);
2586                         rps_unlock(sd);
2587                         local_irq_restore(flags);
2588                         return NET_RX_SUCCESS;
2589                 }
2590
2591                 /* Schedule NAPI for backlog device
2592                  * We can use non atomic operation since we own the queue lock
2593                  */
2594                 if (!__test_and_set_bit(NAPI_STATE_SCHED, &sd->backlog.state)) {
2595                         if (!rps_ipi_queued(sd))
2596                                 ____napi_schedule(sd, &sd->backlog);
2597                 }
2598                 goto enqueue;
2599         }
2600
2601         sd->dropped++;
2602         rps_unlock(sd);
2603
2604         local_irq_restore(flags);
2605
2606         atomic_long_inc(&skb->dev->rx_dropped);
2607         kfree_skb(skb);
2608         return NET_RX_DROP;
2609 }
2610
2611 /**
2612  *      netif_rx        -       post buffer to the network code
2613  *      @skb: buffer to post
2614  *
2615  *      This function receives a packet from a device driver and queues it for
2616  *      the upper (protocol) levels to process.  It always succeeds. The buffer
2617  *      may be dropped during processing for congestion control or by the
2618  *      protocol layers.
2619  *
2620  *      return values:
2621  *      NET_RX_SUCCESS  (no congestion)
2622  *      NET_RX_DROP     (packet was dropped)
2623  *
2624  */
2625
2626 int netif_rx(struct sk_buff *skb)
2627 {
2628         int ret;
2629
2630         /* if netpoll wants it, pretend we never saw it */
2631         if (netpoll_rx(skb))
2632                 return NET_RX_DROP;
2633
2634         if (netdev_tstamp_prequeue)
2635                 net_timestamp_check(skb);
2636
2637         trace_netif_rx(skb);
2638 #ifdef CONFIG_RPS
2639         {
2640                 struct rps_dev_flow voidflow, *rflow = &voidflow;
2641                 int cpu;
2642
2643                 preempt_disable();
2644                 rcu_read_lock();
2645
2646                 cpu = get_rps_cpu(skb->dev, skb, &rflow);
2647                 if (cpu < 0)
2648                         cpu = smp_processor_id();
2649
2650                 ret = enqueue_to_backlog(skb, cpu, &rflow->last_qtail);
2651
2652                 rcu_read_unlock();
2653                 preempt_enable();
2654         }
2655 #else
2656         {
2657                 unsigned int qtail;
2658                 ret = enqueue_to_backlog(skb, get_cpu(), &qtail);
2659                 put_cpu();
2660         }
2661 #endif
2662         return ret;
2663 }
2664 EXPORT_SYMBOL(netif_rx);
2665
2666 int netif_rx_ni(struct sk_buff *skb)
2667 {
2668         int err;
2669
2670         preempt_disable();
2671         err = netif_rx(skb);
2672         if (local_softirq_pending())
2673                 do_softirq();
2674         preempt_enable();
2675
2676         return err;
2677 }
2678 EXPORT_SYMBOL(netif_rx_ni);
2679
2680 static void net_tx_action(struct softirq_action *h)
2681 {
2682         struct softnet_data *sd = &__get_cpu_var(softnet_data);
2683
2684         if (sd->completion_queue) {
2685                 struct sk_buff *clist;
2686
2687                 local_irq_disable();
2688                 clist = sd->completion_queue;
2689                 sd->completion_queue = NULL;
2690                 local_irq_enable();
2691
2692                 while (clist) {
2693                         struct sk_buff *skb = clist;
2694                         clist = clist->next;
2695
2696                         WARN_ON(atomic_read(&skb->users));
2697                         trace_kfree_skb(skb, net_tx_action);
2698                         __kfree_skb(skb);
2699                 }
2700         }
2701
2702         if (sd->output_queue) {
2703                 struct Qdisc *head;
2704
2705                 local_irq_disable();
2706                 head = sd->output_queue;
2707                 sd->output_queue = NULL;
2708                 sd->output_queue_tailp = &sd->output_queue;
2709                 local_irq_enable();
2710
2711                 while (head) {
2712                         struct Qdisc *q = head;
2713                         spinlock_t *root_lock;
2714
2715                         head = head->next_sched;
2716
2717                         root_lock = qdisc_lock(q);
2718                         if (spin_trylock(root_lock)) {
2719                                 smp_mb__before_clear_bit();
2720                                 clear_bit(__QDISC_STATE_SCHED,
2721                                           &q->state);
2722                                 qdisc_run(q);
2723                                 spin_unlock(root_lock);
2724                         } else {
2725                                 if (!test_bit(__QDISC_STATE_DEACTIVATED,
2726                                               &q->state)) {
2727                                         __netif_reschedule(q);
2728                                 } else {
2729                                         smp_mb__before_clear_bit();
2730                                         clear_bit(__QDISC_STATE_SCHED,
2731                                                   &q->state);
2732                                 }
2733                         }
2734                 }
2735         }
2736 }
2737
2738 static inline int deliver_skb(struct sk_buff *skb,
2739                               struct packet_type *pt_prev,
2740                               struct net_device *orig_dev)
2741 {
2742         atomic_inc(&skb->users);
2743         return pt_prev->func(skb, skb->dev, pt_prev, orig_dev);
2744 }
2745
2746 #if (defined(CONFIG_BRIDGE) || defined(CONFIG_BRIDGE_MODULE)) && \
2747     (defined(CONFIG_ATM_LANE) || defined(CONFIG_ATM_LANE_MODULE))
2748 /* This hook is defined here for ATM LANE */
2749 int (*br_fdb_test_addr_hook)(struct net_device *dev,
2750                              unsigned char *addr) __read_mostly;
2751 EXPORT_SYMBOL_GPL(br_fdb_test_addr_hook);
2752 #endif
2753
2754 #ifdef CONFIG_NET_CLS_ACT
2755 /* TODO: Maybe we should just force sch_ingress to be compiled in
2756  * when CONFIG_NET_CLS_ACT is? otherwise some useless instructions
2757  * a compare and 2 stores extra right now if we dont have it on
2758  * but have CONFIG_NET_CLS_ACT
2759  * NOTE: This doesnt stop any functionality; if you dont have
2760  * the ingress scheduler, you just cant add policies on ingress.
2761  *
2762  */
2763 static int ing_filter(struct sk_buff *skb, struct netdev_queue *rxq)
2764 {
2765         struct net_device *dev = skb->dev;
2766         u32 ttl = G_TC_RTTL(skb->tc_verd);
2767         int result = TC_ACT_OK;
2768         struct Qdisc *q;
2769
2770         if (unlikely(MAX_RED_LOOP < ttl++)) {
2771                 if (net_ratelimit())
2772                         pr_warning( "Redir loop detected Dropping packet (%d->%d)\n",
2773                                skb->skb_iif, dev->ifindex);
2774                 return TC_ACT_SHOT;
2775         }
2776
2777         skb->tc_verd = SET_TC_RTTL(skb->tc_verd, ttl);
2778         skb->tc_verd = SET_TC_AT(skb->tc_verd, AT_INGRESS);
2779
2780         q = rxq->qdisc;
2781         if (q != &noop_qdisc) {
2782                 spin_lock(qdisc_lock(q));
2783                 if (likely(!test_bit(__QDISC_STATE_DEACTIVATED, &q->state)))
2784                         result = qdisc_enqueue_root(skb, q);
2785                 spin_unlock(qdisc_lock(q));
2786         }
2787
2788         return result;
2789 }
2790
2791 static inline struct sk_buff *handle_ing(struct sk_buff *skb,
2792                                          struct packet_type **pt_prev,
2793                                          int *ret, struct net_device *orig_dev)
2794 {
2795         struct netdev_queue *rxq = rcu_dereference(skb->dev->ingress_queue);
2796
2797         if (!rxq || rxq->qdisc == &noop_qdisc)
2798                 goto out;
2799
2800         if (*pt_prev) {
2801                 *ret = deliver_skb(skb, *pt_prev, orig_dev);
2802                 *pt_prev = NULL;
2803         }
2804
2805         switch (ing_filter(skb, rxq)) {
2806         case TC_ACT_SHOT:
2807         case TC_ACT_STOLEN:
2808                 kfree_skb(skb);
2809                 return NULL;
2810         }
2811
2812 out:
2813         skb->tc_verd = 0;
2814         return skb;
2815 }
2816 #endif
2817
2818 /**
2819  *      netdev_rx_handler_register - register receive handler
2820  *      @dev: device to register a handler for
2821  *      @rx_handler: receive handler to register
2822  *      @rx_handler_data: data pointer that is used by rx handler
2823  *
2824  *      Register a receive hander for a device. This handler will then be
2825  *      called from __netif_receive_skb. A negative errno code is returned
2826  *      on a failure.
2827  *
2828  *      The caller must hold the rtnl_mutex.
2829  */
2830 int netdev_rx_handler_register(struct net_device *dev,
2831                                rx_handler_func_t *rx_handler,
2832                                void *rx_handler_data)
2833 {
2834         ASSERT_RTNL();
2835
2836         if (dev->rx_handler)
2837                 return -EBUSY;
2838
2839         rcu_assign_pointer(dev->rx_handler_data, rx_handler_data);
2840         rcu_assign_pointer(dev->rx_handler, rx_handler);
2841
2842         return 0;
2843 }
2844 EXPORT_SYMBOL_GPL(netdev_rx_handler_register);
2845
2846 /**
2847  *      netdev_rx_handler_unregister - unregister receive handler
2848  *      @dev: device to unregister a handler from
2849  *
2850  *      Unregister a receive hander from a device.
2851  *
2852  *      The caller must hold the rtnl_mutex.
2853  */
2854 void netdev_rx_handler_unregister(struct net_device *dev)
2855 {
2856
2857         ASSERT_RTNL();
2858         rcu_assign_pointer(dev->rx_handler, NULL);
2859         rcu_assign_pointer(dev->rx_handler_data, NULL);
2860 }
2861 EXPORT_SYMBOL_GPL(netdev_rx_handler_unregister);
2862
2863 static inline void skb_bond_set_mac_by_master(struct sk_buff *skb,
2864                                               struct net_device *master)
2865 {
2866         if (skb->pkt_type == PACKET_HOST) {
2867                 u16 *dest = (u16 *) eth_hdr(skb)->h_dest;
2868
2869                 memcpy(dest, master->dev_addr, ETH_ALEN);
2870         }
2871 }
2872
2873 /* On bonding slaves other than the currently active slave, suppress
2874  * duplicates except for 802.3ad ETH_P_SLOW, alb non-mcast/bcast, and
2875  * ARP on active-backup slaves with arp_validate enabled.
2876  */
2877 int __skb_bond_should_drop(struct sk_buff *skb, struct net_device *master)
2878 {
2879         struct net_device *dev = skb->dev;
2880
2881         if (master->priv_flags & IFF_MASTER_ARPMON)
2882                 dev->last_rx = jiffies;
2883
2884         if ((master->priv_flags & IFF_MASTER_ALB) &&
2885             (master->priv_flags & IFF_BRIDGE_PORT)) {
2886                 /* Do address unmangle. The local destination address
2887                  * will be always the one master has. Provides the right
2888                  * functionality in a bridge.
2889                  */
2890                 skb_bond_set_mac_by_master(skb, master);
2891         }
2892
2893         if (dev->priv_flags & IFF_SLAVE_INACTIVE) {
2894                 if ((dev->priv_flags & IFF_SLAVE_NEEDARP) &&
2895                     skb->protocol == __cpu_to_be16(ETH_P_ARP))
2896                         return 0;
2897
2898                 if (master->priv_flags & IFF_MASTER_ALB) {
2899                         if (skb->pkt_type != PACKET_BROADCAST &&
2900                             skb->pkt_type != PACKET_MULTICAST)
2901                                 return 0;
2902                 }
2903                 if (master->priv_flags & IFF_MASTER_8023AD &&
2904                     skb->protocol == __cpu_to_be16(ETH_P_SLOW))
2905                         return 0;
2906
2907                 return 1;
2908         }
2909         return 0;
2910 }
2911 EXPORT_SYMBOL(__skb_bond_should_drop);
2912
2913 static int __netif_receive_skb(struct sk_buff *skb)
2914 {
2915         struct packet_type *ptype, *pt_prev;
2916         rx_handler_func_t *rx_handler;
2917         struct net_device *orig_dev;
2918         struct net_device *master;
2919         struct net_device *null_or_orig;
2920         struct net_device *orig_or_bond;
2921         int ret = NET_RX_DROP;
2922         __be16 type;
2923
2924         if (!netdev_tstamp_prequeue)
2925                 net_timestamp_check(skb);
2926
2927         trace_netif_receive_skb(skb);
2928
2929         /* if we've gotten here through NAPI, check netpoll */
2930         if (netpoll_receive_skb(skb))
2931                 return NET_RX_DROP;
2932
2933         if (!skb->skb_iif)
2934                 skb->skb_iif = skb->dev->ifindex;
2935
2936         /*
2937          * bonding note: skbs received on inactive slaves should only
2938          * be delivered to pkt handlers that are exact matches.  Also
2939          * the deliver_no_wcard flag will be set.  If packet handlers
2940          * are sensitive to duplicate packets these skbs will need to
2941          * be dropped at the handler.
2942          */
2943         null_or_orig = NULL;
2944         orig_dev = skb->dev;
2945         master = ACCESS_ONCE(orig_dev->master);
2946         if (skb->deliver_no_wcard)
2947                 null_or_orig = orig_dev;
2948         else if (master) {
2949                 if (skb_bond_should_drop(skb, master)) {
2950                         skb->deliver_no_wcard = 1;
2951                         null_or_orig = orig_dev; /* deliver only exact match */
2952                 } else
2953                         skb->dev = master;
2954         }
2955
2956         __this_cpu_inc(softnet_data.processed);
2957         skb_reset_network_header(skb);
2958         skb_reset_transport_header(skb);
2959         skb->mac_len = skb->network_header - skb->mac_header;
2960
2961         pt_prev = NULL;
2962
2963         rcu_read_lock();
2964
2965 #ifdef CONFIG_NET_CLS_ACT
2966         if (skb->tc_verd & TC_NCLS) {
2967                 skb->tc_verd = CLR_TC_NCLS(skb->tc_verd);
2968                 goto ncls;
2969         }
2970 #endif
2971
2972         list_for_each_entry_rcu(ptype, &ptype_all, list) {
2973                 if (ptype->dev == null_or_orig || ptype->dev == skb->dev ||
2974                     ptype->dev == orig_dev) {
2975                         if (pt_prev)
2976                                 ret = deliver_skb(skb, pt_prev, orig_dev);
2977                         pt_prev = ptype;
2978                 }
2979         }
2980
2981 #ifdef CONFIG_NET_CLS_ACT
2982         skb = handle_ing(skb, &pt_prev, &ret, orig_dev);
2983         if (!skb)
2984                 goto out;
2985 ncls:
2986 #endif
2987
2988         /* Handle special case of bridge or macvlan */
2989         rx_handler = rcu_dereference(skb->dev->rx_handler);
2990         if (rx_handler) {
2991                 if (pt_prev) {
2992                         ret = deliver_skb(skb, pt_prev, orig_dev);
2993                         pt_prev = NULL;
2994                 }
2995                 skb = rx_handler(skb);
2996                 if (!skb)
2997                         goto out;
2998         }
2999
3000         if (vlan_tx_tag_present(skb)) {
3001                 if (pt_prev) {
3002                         ret = deliver_skb(skb, pt_prev, orig_dev);
3003                         pt_prev = NULL;
3004                 }
3005                 if (vlan_hwaccel_do_receive(&skb)) {
3006                         ret = __netif_receive_skb(skb);
3007                         goto out;
3008                 } else if (unlikely(!skb))
3009                         goto out;
3010         }
3011
3012         /*
3013          * Make sure frames received on VLAN interfaces stacked on
3014          * bonding interfaces still make their way to any base bonding
3015          * device that may have registered for a specific ptype.  The
3016          * handler may have to adjust skb->dev and orig_dev.
3017          */
3018         orig_or_bond = orig_dev;
3019         if ((skb->dev->priv_flags & IFF_802_1Q_VLAN) &&
3020             (vlan_dev_real_dev(skb->dev)->priv_flags & IFF_BONDING)) {
3021                 orig_or_bond = vlan_dev_real_dev(skb->dev);
3022         }
3023
3024         type = skb->protocol;
3025         list_for_each_entry_rcu(ptype,
3026                         &ptype_base[ntohs(type) & PTYPE_HASH_MASK], list) {
3027                 if (ptype->type == type && (ptype->dev == null_or_orig ||
3028                      ptype->dev == skb->dev || ptype->dev == orig_dev ||
3029                      ptype->dev == orig_or_bond)) {
3030                         if (pt_prev)
3031                                 ret = deliver_skb(skb, pt_prev, orig_dev);
3032                         pt_prev = ptype;
3033                 }
3034         }
3035
3036         if (pt_prev) {
3037                 ret = pt_prev->func(skb, skb->dev, pt_prev, orig_dev);
3038         } else {
3039                 atomic_long_inc(&skb->dev->rx_dropped);
3040                 kfree_skb(skb);
3041                 /* Jamal, now you will not able to escape explaining
3042                  * me how you were going to use this. :-)
3043                  */
3044                 ret = NET_RX_DROP;
3045         }
3046
3047 out:
3048         rcu_read_unlock();
3049         return ret;
3050 }
3051
3052 /**
3053  *      netif_receive_skb - process receive buffer from network
3054  *      @skb: buffer to process
3055  *
3056  *      netif_receive_skb() is the main receive data processing function.
3057  *      It always succeeds. The buffer may be dropped during processing
3058  *      for congestion control or by the protocol layers.
3059  *
3060  *      This function may only be called from softirq context and interrupts
3061  *      should be enabled.
3062  *
3063  *      Return values (usually ignored):
3064  *      NET_RX_SUCCESS: no congestion
3065  *      NET_RX_DROP: packet was dropped
3066  */
3067 int netif_receive_skb(struct sk_buff *skb)
3068 {
3069         if (netdev_tstamp_prequeue)
3070                 net_timestamp_check(skb);
3071
3072         if (skb_defer_rx_timestamp(skb))
3073                 return NET_RX_SUCCESS;
3074
3075 #ifdef CONFIG_RPS
3076         {
3077                 struct rps_dev_flow voidflow, *rflow = &voidflow;
3078                 int cpu, ret;
3079
3080                 rcu_read_lock();
3081
3082                 cpu = get_rps_cpu(skb->dev, skb, &rflow);
3083
3084                 if (cpu >= 0) {
3085                         ret = enqueue_to_backlog(skb, cpu, &rflow->last_qtail);
3086                         rcu_read_unlock();
3087                 } else {
3088                         rcu_read_unlock();
3089                         ret = __netif_receive_skb(skb);
3090                 }
3091
3092                 return ret;
3093         }
3094 #else
3095         return __netif_receive_skb(skb);
3096 #endif
3097 }
3098 EXPORT_SYMBOL(netif_receive_skb);
3099
3100 /* Network device is going away, flush any packets still pending
3101  * Called with irqs disabled.
3102  */
3103 static void flush_backlog(void *arg)
3104 {
3105         struct net_device *dev = arg;
3106         struct softnet_data *sd = &__get_cpu_var(softnet_data);
3107         struct sk_buff *skb, *tmp;
3108
3109         rps_lock(sd);
3110         skb_queue_walk_safe(&sd->input_pkt_queue, skb, tmp) {
3111                 if (skb->dev == dev) {
3112                         __skb_unlink(skb, &sd->input_pkt_queue);
3113                         kfree_skb(skb);
3114                         input_queue_head_incr(sd);
3115                 }
3116         }
3117         rps_unlock(sd);
3118
3119         skb_queue_walk_safe(&sd->process_queue, skb, tmp) {
3120                 if (skb->dev == dev) {
3121                         __skb_unlink(skb, &sd->process_queue);
3122                         kfree_skb(skb);
3123                         input_queue_head_incr(sd);
3124                 }
3125         }
3126 }
3127
3128 static int napi_gro_complete(struct sk_buff *skb)
3129 {
3130         struct packet_type *ptype;
3131         __be16 type = skb->protocol;
3132         struct list_head *head = &ptype_base[ntohs(type) & PTYPE_HASH_MASK];
3133         int err = -ENOENT;
3134
3135         if (NAPI_GRO_CB(skb)->count == 1) {
3136                 skb_shinfo(skb)->gso_size = 0;
3137                 goto out;
3138         }
3139
3140         rcu_read_lock();
3141         list_for_each_entry_rcu(ptype, head, list) {
3142                 if (ptype->type != type || ptype->dev || !ptype->gro_complete)
3143                         continue;
3144
3145                 err = ptype->gro_complete(skb);
3146                 break;
3147         }
3148         rcu_read_unlock();
3149
3150         if (err) {
3151                 WARN_ON(&ptype->list == head);
3152                 kfree_skb(skb);
3153                 return NET_RX_SUCCESS;
3154         }
3155
3156 out:
3157         return netif_receive_skb(skb);
3158 }
3159
3160 inline void napi_gro_flush(struct napi_struct *napi)
3161 {
3162         struct sk_buff *skb, *next;
3163
3164         for (skb = napi->gro_list; skb; skb = next) {
3165                 next = skb->next;
3166                 skb->next = NULL;
3167                 napi_gro_complete(skb);
3168         }
3169
3170         napi->gro_count = 0;
3171         napi->gro_list = NULL;
3172 }
3173 EXPORT_SYMBOL(napi_gro_flush);
3174
3175 enum gro_result dev_gro_receive(struct napi_struct *napi, struct sk_buff *skb)
3176 {
3177         struct sk_buff **pp = NULL;
3178         struct packet_type *ptype;
3179         __be16 type = skb->protocol;
3180         struct list_head *head = &ptype_base[ntohs(type) & PTYPE_HASH_MASK];
3181         int same_flow;
3182         int mac_len;
3183         enum gro_result ret;
3184
3185         if (!(skb->dev->features & NETIF_F_GRO) || netpoll_rx_on(skb))
3186                 goto normal;
3187
3188         if (skb_is_gso(skb) || skb_has_frag_list(skb))
3189                 goto normal;
3190
3191         rcu_read_lock();
3192         list_for_each_entry_rcu(ptype, head, list) {
3193                 if (ptype->type != type || ptype->dev || !ptype->gro_receive)
3194                         continue;
3195
3196                 skb_set_network_header(skb, skb_gro_offset(skb));
3197                 mac_len = skb->network_header - skb->mac_header;
3198                 skb->mac_len = mac_len;
3199                 NAPI_GRO_CB(skb)->same_flow = 0;
3200                 NAPI_GRO_CB(skb)->flush = 0;
3201                 NAPI_GRO_CB(skb)->free = 0;
3202
3203                 pp = ptype->gro_receive(&napi->gro_list, skb);
3204                 break;
3205         }
3206         rcu_read_unlock();
3207
3208         if (&ptype->list == head)
3209                 goto normal;
3210
3211         same_flow = NAPI_GRO_CB(skb)->same_flow;
3212         ret = NAPI_GRO_CB(skb)->free ? GRO_MERGED_FREE : GRO_MERGED;
3213
3214         if (pp) {
3215                 struct sk_buff *nskb = *pp;
3216
3217                 *pp = nskb->next;
3218                 nskb->next = NULL;
3219                 napi_gro_complete(nskb);
3220                 napi->gro_count--;
3221         }
3222
3223         if (same_flow)
3224                 goto ok;
3225
3226         if (NAPI_GRO_CB(skb)->flush || napi->gro_count >= MAX_GRO_SKBS)
3227                 goto normal;
3228
3229         napi->gro_count++;
3230         NAPI_GRO_CB(skb)->count = 1;
3231         skb_shinfo(skb)->gso_size = skb_gro_len(skb);
3232         skb->next = napi->gro_list;
3233         napi->gro_list = skb;
3234         ret = GRO_HELD;
3235
3236 pull:
3237         if (skb_headlen(skb) < skb_gro_offset(skb)) {
3238                 int grow = skb_gro_offset(skb) - skb_headlen(skb);
3239
3240                 BUG_ON(skb->end - skb->tail < grow);
3241
3242                 memcpy(skb_tail_pointer(skb), NAPI_GRO_CB(skb)->frag0, grow);
3243
3244                 skb->tail += grow;
3245                 skb->data_len -= grow;
3246
3247                 skb_shinfo(skb)->frags[0].page_offset += grow;
3248                 skb_shinfo(skb)->frags[0].size -= grow;
3249
3250                 if (unlikely(!skb_shinfo(skb)->frags[0].size)) {
3251                         put_page(skb_shinfo(skb)->frags[0].page);
3252                         memmove(skb_shinfo(skb)->frags,
3253                                 skb_shinfo(skb)->frags + 1,
3254                                 --skb_shinfo(skb)->nr_frags * sizeof(skb_frag_t));
3255                 }
3256         }
3257
3258 ok:
3259         return ret;
3260
3261 normal:
3262         ret = GRO_NORMAL;
3263         goto pull;
3264 }
3265 EXPORT_SYMBOL(dev_gro_receive);
3266
3267 static inline gro_result_t
3268 __napi_gro_receive(struct napi_struct *napi, struct sk_buff *skb)
3269 {
3270         struct sk_buff *p;
3271
3272         for (p = napi->gro_list; p; p = p->next) {
3273                 unsigned long diffs;
3274
3275                 diffs = (unsigned long)p->dev ^ (unsigned long)skb->dev;
3276                 diffs |= p->vlan_tci ^ skb->vlan_tci;
3277                 diffs |= compare_ether_header(skb_mac_header(p),
3278                                               skb_gro_mac_header(skb));
3279                 NAPI_GRO_CB(p)->same_flow = !diffs;
3280                 NAPI_GRO_CB(p)->flush = 0;
3281         }
3282
3283         return dev_gro_receive(napi, skb);
3284 }
3285
3286 gro_result_t napi_skb_finish(gro_result_t ret, struct sk_buff *skb)
3287 {
3288         switch (ret) {
3289         case GRO_NORMAL:
3290                 if (netif_receive_skb(skb))
3291                         ret = GRO_DROP;
3292                 break;
3293
3294         case GRO_DROP:
3295         case GRO_MERGED_FREE:
3296                 kfree_skb(skb);
3297                 break;
3298
3299         case GRO_HELD:
3300         case GRO_MERGED:
3301                 break;
3302         }
3303
3304         return ret;
3305 }
3306 EXPORT_SYMBOL(napi_skb_finish);
3307
3308 void skb_gro_reset_offset(struct sk_buff *skb)
3309 {
3310         NAPI_GRO_CB(skb)->data_offset = 0;
3311         NAPI_GRO_CB(skb)->frag0 = NULL;
3312         NAPI_GRO_CB(skb)->frag0_len = 0;
3313
3314         if (skb->mac_header == skb->tail &&
3315             !PageHighMem(skb_shinfo(skb)->frags[0].page)) {
3316                 NAPI_GRO_CB(skb)->frag0 =
3317                         page_address(skb_shinfo(skb)->frags[0].page) +
3318                         skb_shinfo(skb)->frags[0].page_offset;
3319                 NAPI_GRO_CB(skb)->frag0_len = skb_shinfo(skb)->frags[0].size;
3320         }
3321 }
3322 EXPORT_SYMBOL(skb_gro_reset_offset);
3323
3324 gro_result_t napi_gro_receive(struct napi_struct *napi, struct sk_buff *skb)
3325 {
3326         skb_gro_reset_offset(skb);
3327
3328         return napi_skb_finish(__napi_gro_receive(napi, skb), skb);
3329 }
3330 EXPORT_SYMBOL(napi_gro_receive);
3331
3332 static void napi_reuse_skb(struct napi_struct *napi, struct sk_buff *skb)
3333 {
3334         __skb_pull(skb, skb_headlen(skb));
3335         skb_reserve(skb, NET_IP_ALIGN - skb_headroom(skb));
3336         skb->vlan_tci = 0;
3337
3338         napi->skb = skb;
3339 }
3340
3341 struct sk_buff *napi_get_frags(struct napi_struct *napi)
3342 {
3343         struct sk_buff *skb = napi->skb;
3344
3345         if (!skb) {
3346                 skb = netdev_alloc_skb_ip_align(napi->dev, GRO_MAX_HEAD);
3347                 if (skb)
3348                         napi->skb = skb;
3349         }
3350         return skb;
3351 }
3352 EXPORT_SYMBOL(napi_get_frags);
3353
3354 gro_result_t napi_frags_finish(struct napi_struct *napi, struct sk_buff *skb,
3355                                gro_result_t ret)
3356 {
3357         switch (ret) {
3358         case GRO_NORMAL:
3359         case GRO_HELD:
3360                 skb->protocol = eth_type_trans(skb, skb->dev);
3361
3362                 if (ret == GRO_HELD)
3363                         skb_gro_pull(skb, -ETH_HLEN);
3364                 else if (netif_receive_skb(skb))
3365                         ret = GRO_DROP;
3366                 break;
3367
3368         case GRO_DROP:
3369         case GRO_MERGED_FREE:
3370                 napi_reuse_skb(napi, skb);
3371                 break;
3372
3373         case GRO_MERGED:
3374                 break;
3375         }
3376
3377         return ret;
3378 }
3379 EXPORT_SYMBOL(napi_frags_finish);
3380
3381 struct sk_buff *napi_frags_skb(struct napi_struct *napi)
3382 {
3383         struct sk_buff *skb = napi->skb;
3384         struct ethhdr *eth;
3385         unsigned int hlen;
3386         unsigned int off;
3387
3388         napi->skb = NULL;
3389
3390         skb_reset_mac_header(skb);
3391         skb_gro_reset_offset(skb);
3392
3393         off = skb_gro_offset(skb);
3394         hlen = off + sizeof(*eth);
3395         eth = skb_gro_header_fast(skb, off);
3396         if (skb_gro_header_hard(skb, hlen)) {
3397                 eth = skb_gro_header_slow(skb, hlen, off);
3398                 if (unlikely(!eth)) {
3399                         napi_reuse_skb(napi, skb);
3400                         skb = NULL;
3401                         goto out;
3402                 }
3403         }
3404
3405         skb_gro_pull(skb, sizeof(*eth));
3406
3407         /*
3408          * This works because the only protocols we care about don't require
3409          * special handling.  We'll fix it up properly at the end.
3410          */
3411         skb->protocol = eth->h_proto;
3412
3413 out:
3414         return skb;
3415 }
3416 EXPORT_SYMBOL(napi_frags_skb);
3417
3418 gro_result_t napi_gro_frags(struct napi_struct *napi)
3419 {
3420         struct sk_buff *skb = napi_frags_skb(napi);
3421
3422         if (!skb)
3423                 return GRO_DROP;
3424
3425         return napi_frags_finish(napi, skb, __napi_gro_receive(napi, skb));
3426 }
3427 EXPORT_SYMBOL(napi_gro_frags);
3428
3429 /*
3430  * net_rps_action sends any pending IPI's for rps.
3431  * Note: called with local irq disabled, but exits with local irq enabled.
3432  */
3433 static void net_rps_action_and_irq_enable(struct softnet_data *sd)
3434 {
3435 #ifdef CONFIG_RPS
3436         struct softnet_data *remsd = sd->rps_ipi_list;
3437
3438         if (remsd) {
3439                 sd->rps_ipi_list = NULL;
3440
3441                 local_irq_enable();
3442
3443                 /* Send pending IPI's to kick RPS processing on remote cpus. */
3444                 while (remsd) {
3445                         struct softnet_data *next = remsd->rps_ipi_next;
3446
3447                         if (cpu_online(remsd->cpu))
3448                                 __smp_call_function_single(remsd->cpu,
3449                                                            &remsd->csd, 0);
3450                         remsd = next;
3451                 }
3452         } else
3453 #endif
3454                 local_irq_enable();
3455 }
3456
3457 static int process_backlog(struct napi_struct *napi, int quota)
3458 {
3459         int work = 0;
3460         struct softnet_data *sd = container_of(napi, struct softnet_data, backlog);
3461
3462 #ifdef CONFIG_RPS
3463         /* Check if we have pending ipi, its better to send them now,
3464          * not waiting net_rx_action() end.
3465          */
3466         if (sd->rps_ipi_list) {
3467                 local_irq_disable();
3468                 net_rps_action_and_irq_enable(sd);
3469         }
3470 #endif
3471         napi->weight = weight_p;
3472         local_irq_disable();
3473         while (work < quota) {
3474                 struct sk_buff *skb;
3475                 unsigned int qlen;
3476
3477                 while ((skb = __skb_dequeue(&sd->process_queue))) {
3478                         local_irq_enable();
3479                         __netif_receive_skb(skb);
3480                         local_irq_disable();
3481                         input_queue_head_incr(sd);
3482                         if (++work >= quota) {
3483                                 local_irq_enable();
3484                                 return work;
3485                         }
3486                 }
3487
3488                 rps_lock(sd);
3489                 qlen = skb_queue_len(&sd->input_pkt_queue);
3490                 if (qlen)
3491                         skb_queue_splice_tail_init(&sd->input_pkt_queue,
3492                                                    &sd->process_queue);
3493
3494                 if (qlen < quota - work) {
3495                         /*
3496                          * Inline a custom version of __napi_complete().
3497                          * only current cpu owns and manipulates this napi,
3498                          * and NAPI_STATE_SCHED is the only possible flag set on backlog.
3499                          * we can use a plain write instead of clear_bit(),
3500                          * and we dont need an smp_mb() memory barrier.
3501                          */
3502                         list_del(&napi->poll_list);
3503                         napi->state = 0;
3504
3505                         quota = work + qlen;
3506                 }
3507                 rps_unlock(sd);
3508         }
3509         local_irq_enable();
3510
3511         return work;
3512 }
3513
3514 /**
3515  * __napi_schedule - schedule for receive
3516  * @n: entry to schedule
3517  *
3518  * The entry's receive function will be scheduled to run
3519  */
3520 void __napi_schedule(struct napi_struct *n)
3521 {
3522         unsigned long flags;
3523
3524         local_irq_save(flags);
3525         ____napi_schedule(&__get_cpu_var(softnet_data), n);
3526         local_irq_restore(flags);
3527 }
3528 EXPORT_SYMBOL(__napi_schedule);
3529
3530 void __napi_complete(struct napi_struct *n)
3531 {
3532         BUG_ON(!test_bit(NAPI_STATE_SCHED, &n->state));
3533         BUG_ON(n->gro_list);
3534
3535         list_del(&n->poll_list);
3536         smp_mb__before_clear_bit();
3537         clear_bit(NAPI_STATE_SCHED, &n->state);
3538 }
3539 EXPORT_SYMBOL(__napi_complete);
3540
3541 void napi_complete(struct napi_struct *n)
3542 {
3543         unsigned long flags;
3544
3545         /*
3546          * don't let napi dequeue from the cpu poll list
3547          * just in case its running on a different cpu
3548          */
3549         if (unlikely(test_bit(NAPI_STATE_NPSVC, &n->state)))
3550                 return;
3551
3552         napi_gro_flush(n);
3553         local_irq_save(flags);
3554         __napi_complete(n);
3555         local_irq_restore(flags);
3556 }
3557 EXPORT_SYMBOL(napi_complete);
3558
3559 void netif_napi_add(struct net_device *dev, struct napi_struct *napi,
3560                     int (*poll)(struct napi_struct *, int), int weight)
3561 {
3562         INIT_LIST_HEAD(&napi->poll_list);
3563         napi->gro_count = 0;
3564         napi->gro_list = NULL;
3565         napi->skb = NULL;
3566         napi->poll = poll;
3567         napi->weight = weight;
3568         list_add(&napi->dev_list, &dev->napi_list);
3569         napi->dev = dev;
3570 #ifdef CONFIG_NETPOLL
3571         spin_lock_init(&napi->poll_lock);
3572         napi->poll_owner = -1;
3573 #endif
3574         set_bit(NAPI_STATE_SCHED, &napi->state);
3575 }
3576 EXPORT_SYMBOL(netif_napi_add);
3577
3578 void netif_napi_del(struct napi_struct *napi)
3579 {
3580         struct sk_buff *skb, *next;
3581
3582         list_del_init(&napi->dev_list);
3583         napi_free_frags(napi);
3584
3585         for (skb = napi->gro_list; skb; skb = next) {
3586                 next = skb->next;
3587                 skb->next = NULL;
3588                 kfree_skb(skb);
3589         }
3590
3591         napi->gro_list = NULL;
3592         napi->gro_count = 0;
3593 }
3594 EXPORT_SYMBOL(netif_napi_del);
3595
3596 static void net_rx_action(struct softirq_action *h)
3597 {
3598         struct softnet_data *sd = &__get_cpu_var(softnet_data);
3599         unsigned long time_limit = jiffies + 2;
3600         int budget = netdev_budget;
3601         void *have;
3602
3603         local_irq_disable();
3604
3605         while (!list_empty(&sd->poll_list)) {
3606                 struct napi_struct *n;
3607                 int work, weight;
3608
3609                 /* If softirq window is exhuasted then punt.
3610                  * Allow this to run for 2 jiffies since which will allow
3611                  * an average latency of 1.5/HZ.
3612                  */
3613                 if (unlikely(budget <= 0 || time_after(jiffies, time_limit)))
3614                         goto softnet_break;
3615
3616                 local_irq_enable();
3617
3618                 /* Even though interrupts have been re-enabled, this
3619                  * access is safe because interrupts can only add new
3620                  * entries to the tail of this list, and only ->poll()
3621                  * calls can remove this head entry from the list.
3622                  */
3623                 n = list_first_entry(&sd->poll_list, struct napi_struct, poll_list);
3624
3625                 have = netpoll_poll_lock(n);
3626
3627                 weight = n->weight;
3628
3629                 /* This NAPI_STATE_SCHED test is for avoiding a race
3630                  * with netpoll's poll_napi().  Only the entity which
3631                  * obtains the lock and sees NAPI_STATE_SCHED set will
3632                  * actually make the ->poll() call.  Therefore we avoid
3633                  * accidently calling ->poll() when NAPI is not scheduled.
3634                  */
3635                 work = 0;
3636                 if (test_bit(NAPI_STATE_SCHED, &n->state)) {
3637                         work = n->poll(n, weight);
3638                         trace_napi_poll(n);
3639                 }
3640
3641                 WARN_ON_ONCE(work > weight);
3642
3643                 budget -= work;
3644
3645                 local_irq_disable();
3646
3647                 /* Drivers must not modify the NAPI state if they
3648                  * consume the entire weight.  In such cases this code
3649                  * still "owns" the NAPI instance and therefore can
3650                  * move the instance around on the list at-will.
3651                  */
3652                 if (unlikely(work == weight)) {
3653                         if (unlikely(napi_disable_pending(n))) {
3654                                 local_irq_enable();
3655                                 napi_complete(n);
3656                                 local_irq_disable();
3657                         } else
3658                                 list_move_tail(&n->poll_list, &sd->poll_list);
3659                 }
3660
3661                 netpoll_poll_unlock(have);
3662         }
3663 out:
3664         net_rps_action_and_irq_enable(sd);
3665
3666 #ifdef CONFIG_NET_DMA
3667         /*
3668          * There may not be any more sk_buffs coming right now, so push
3669          * any pending DMA copies to hardware
3670          */
3671         dma_issue_pending_all();
3672 #endif
3673
3674         return;
3675
3676 softnet_break:
3677         sd->time_squeeze++;
3678         __raise_softirq_irqoff(NET_RX_SOFTIRQ);
3679         goto out;
3680 }
3681
3682 static gifconf_func_t *gifconf_list[NPROTO];
3683
3684 /**
3685  *      register_gifconf        -       register a SIOCGIF handler
3686  *      @family: Address family
3687  *      @gifconf: Function handler
3688  *
3689  *      Register protocol dependent address dumping routines. The handler
3690  *      that is passed must not be freed or reused until it has been replaced
3691  *      by another handler.
3692  */
3693 int register_gifconf(unsigned int family, gifconf_func_t *gifconf)
3694 {
3695         if (family >= NPROTO)
3696                 return -EINVAL;
3697         gifconf_list[family] = gifconf;
3698         return 0;
3699 }
3700 EXPORT_SYMBOL(register_gifconf);
3701
3702
3703 /*
3704  *      Map an interface index to its name (SIOCGIFNAME)
3705  */
3706
3707 /*
3708  *      We need this ioctl for efficient implementation of the
3709  *      if_indextoname() function required by the IPv6 API.  Without
3710  *      it, we would have to search all the interfaces to find a
3711  *      match.  --pb
3712  */
3713
3714 static int dev_ifname(struct net *net, struct ifreq __user *arg)
3715 {
3716         struct net_device *dev;
3717         struct ifreq ifr;
3718
3719         /*
3720          *      Fetch the caller's info block.
3721          */
3722
3723         if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
3724                 return -EFAULT;
3725
3726         rcu_read_lock();
3727         dev = dev_get_by_index_rcu(net, ifr.ifr_ifindex);
3728         if (!dev) {
3729                 rcu_read_unlock();
3730                 return -ENODEV;
3731         }
3732
3733         strcpy(ifr.ifr_name, dev->name);
3734         rcu_read_unlock();
3735
3736         if (copy_to_user(arg, &ifr, sizeof(struct ifreq)))
3737                 return -EFAULT;
3738         return 0;
3739 }
3740
3741 /*
3742  *      Perform a SIOCGIFCONF call. This structure will change
3743  *      size eventually, and there is nothing I can do about it.
3744  *      Thus we will need a 'compatibility mode'.
3745  */
3746
3747 static int dev_ifconf(struct net *net, char __user *arg)
3748 {
3749         struct ifconf ifc;
3750         struct net_device *dev;
3751         char __user *pos;
3752         int len;
3753         int total;
3754         int i;
3755
3756         /*
3757          *      Fetch the caller's info block.
3758          */
3759
3760         if (copy_from_user(&ifc, arg, sizeof(struct ifconf)))
3761                 return -EFAULT;
3762
3763         pos = ifc.ifc_buf;
3764         len = ifc.ifc_len;
3765
3766         /*
3767          *      Loop over the interfaces, and write an info block for each.
3768          */
3769
3770         total = 0;
3771         for_each_netdev(net, dev) {
3772                 for (i = 0; i < NPROTO; i++) {
3773                         if (gifconf_list[i]) {
3774                                 int done;
3775                                 if (!pos)
3776                                         done = gifconf_list[i](dev, NULL, 0);
3777                                 else
3778                                         done = gifconf_list[i](dev, pos + total,
3779                                                                len - total);
3780                                 if (done < 0)
3781                                         return -EFAULT;
3782                                 total += done;
3783                         }
3784                 }
3785         }
3786
3787         /*
3788          *      All done.  Write the updated control block back to the caller.
3789          */
3790         ifc.ifc_len = total;
3791
3792         /*
3793          *      Both BSD and Solaris return 0 here, so we do too.
3794          */
3795         return copy_to_user(arg, &ifc, sizeof(struct ifconf)) ? -EFAULT : 0;
3796 }
3797
3798 #ifdef CONFIG_PROC_FS
3799 /*
3800  *      This is invoked by the /proc filesystem handler to display a device
3801  *      in detail.
3802  */
3803 void *dev_seq_start(struct seq_file *seq, loff_t *pos)
3804         __acquires(RCU)
3805 {
3806         struct net *net = seq_file_net(seq);
3807         loff_t off;
3808         struct net_device *dev;
3809
3810         rcu_read_lock();
3811         if (!*pos)
3812                 return SEQ_START_TOKEN;
3813
3814         off = 1;
3815         for_each_netdev_rcu(net, dev)
3816                 if (off++ == *pos)
3817                         return dev;
3818
3819         return NULL;
3820 }
3821
3822 void *dev_seq_next(struct seq_file *seq, void *v, loff_t *pos)
3823 {
3824         struct net_device *dev = (v == SEQ_START_TOKEN) ?
3825                                   first_net_device(seq_file_net(seq)) :
3826                                   next_net_device((struct net_device *)v);
3827
3828         ++*pos;
3829         return rcu_dereference(dev);
3830 }
3831
3832 void dev_seq_stop(struct seq_file *seq, void *v)
3833         __releases(RCU)
3834 {
3835         rcu_read_unlock();
3836 }
3837
3838 static void dev_seq_printf_stats(struct seq_file *seq, struct net_device *dev)
3839 {
3840         struct rtnl_link_stats64 temp;
3841         const struct rtnl_link_stats64 *stats = dev_get_stats(dev, &temp);
3842
3843         seq_printf(seq, "%6s: %7llu %7llu %4llu %4llu %4llu %5llu %10llu %9llu "
3844                    "%8llu %7llu %4llu %4llu %4llu %5llu %7llu %10llu\n",
3845                    dev->name, stats->rx_bytes, stats->rx_packets,
3846                    stats->rx_errors,
3847                    stats->rx_dropped + stats->rx_missed_errors,
3848                    stats->rx_fifo_errors,
3849                    stats->rx_length_errors + stats->rx_over_errors +
3850                     stats->rx_crc_errors + stats->rx_frame_errors,
3851                    stats->rx_compressed, stats->multicast,
3852                    stats->tx_bytes, stats->tx_packets,
3853                    stats->tx_errors, stats->tx_dropped,
3854                    stats->tx_fifo_errors, stats->collisions,
3855                    stats->tx_carrier_errors +
3856                     stats->tx_aborted_errors +
3857                     stats->tx_window_errors +
3858                     stats->tx_heartbeat_errors,
3859                    stats->tx_compressed);
3860 }
3861
3862 /*
3863  *      Called from the PROCfs module. This now uses the new arbitrary sized
3864  *      /proc/net interface to create /proc/net/dev
3865  */
3866 static int dev_seq_show(struct seq_file *seq, void *v)
3867 {
3868         if (v == SEQ_START_TOKEN)
3869                 seq_puts(seq, "Inter-|   Receive                            "
3870                               "                    |  Transmit\n"
3871                               " face |bytes    packets errs drop fifo frame "
3872                               "compressed multicast|bytes    packets errs "
3873                               "drop fifo colls carrier compressed\n");
3874         else
3875                 dev_seq_printf_stats(seq, v);
3876         return 0;
3877 }
3878
3879 static struct softnet_data *softnet_get_online(loff_t *pos)
3880 {
3881         struct softnet_data *sd = NULL;
3882
3883         while (*pos < nr_cpu_ids)
3884                 if (cpu_online(*pos)) {
3885                         sd = &per_cpu(softnet_data, *pos);
3886                         break;
3887                 } else
3888                         ++*pos;
3889         return sd;
3890 }
3891
3892 static void *softnet_seq_start(struct seq_file *seq, loff_t *pos)
3893 {
3894         return softnet_get_online(pos);
3895 }
3896
3897 static void *softnet_seq_next(struct seq_file *seq, void *v, loff_t *pos)
3898 {
3899         ++*pos;
3900         return softnet_get_online(pos);
3901 }
3902
3903 static void softnet_seq_stop(struct seq_file *seq, void *v)
3904 {
3905 }
3906
3907 static int softnet_seq_show(struct seq_file *seq, void *v)
3908 {
3909         struct softnet_data *sd = v;
3910
3911         seq_printf(seq, "%08x %08x %08x %08x %08x %08x %08x %08x %08x %08x\n",
3912                    sd->processed, sd->dropped, sd->time_squeeze, 0,
3913                    0, 0, 0, 0, /* was fastroute */
3914                    sd->cpu_collision, sd->received_rps);
3915         return 0;
3916 }
3917
3918 static const struct seq_operations dev_seq_ops = {
3919         .start = dev_seq_start,
3920         .next  = dev_seq_next,
3921         .stop  = dev_seq_stop,
3922         .show  = dev_seq_show,
3923 };
3924
3925 static int dev_seq_open(struct inode *inode, struct file *file)
3926 {
3927         return seq_open_net(inode, file, &dev_seq_ops,
3928                             sizeof(struct seq_net_private));
3929 }
3930
3931 static const struct file_operations dev_seq_fops = {
3932         .owner   = THIS_MODULE,
3933         .open    = dev_seq_open,
3934         .read    = seq_read,
3935         .llseek  = seq_lseek,
3936         .release = seq_release_net,
3937 };
3938
3939 static const struct seq_operations softnet_seq_ops = {
3940         .start = softnet_seq_start,
3941         .next  = softnet_seq_next,
3942         .stop  = softnet_seq_stop,
3943         .show  = softnet_seq_show,
3944 };
3945
3946 static int softnet_seq_open(struct inode *inode, struct file *file)
3947 {
3948         return seq_open(file, &softnet_seq_ops);
3949 }
3950
3951 static const struct file_operations softnet_seq_fops = {
3952         .owner   = THIS_MODULE,
3953         .open    = softnet_seq_open,
3954         .read    = seq_read,
3955         .llseek  = seq_lseek,
3956         .release = seq_release,
3957 };
3958
3959 static void *ptype_get_idx(loff_t pos)
3960 {
3961         struct packet_type *pt = NULL;
3962         loff_t i = 0;
3963         int t;
3964
3965         list_for_each_entry_rcu(pt, &ptype_all, list) {
3966                 if (i == pos)
3967                         return pt;
3968                 ++i;
3969         }
3970
3971         for (t = 0; t < PTYPE_HASH_SIZE; t++) {
3972                 list_for_each_entry_rcu(pt, &ptype_base[t], list) {
3973                         if (i == pos)
3974                                 return pt;
3975                         ++i;
3976                 }
3977         }
3978         return NULL;
3979 }
3980
3981 static void *ptype_seq_start(struct seq_file *seq, loff_t *pos)
3982         __acquires(RCU)
3983 {
3984         rcu_read_lock();
3985         return *pos ? ptype_get_idx(*pos - 1) : SEQ_START_TOKEN;
3986 }
3987
3988 static void *ptype_seq_next(struct seq_file *seq, void *v, loff_t *pos)
3989 {
3990         struct packet_type *pt;
3991         struct list_head *nxt;
3992         int hash;
3993
3994         ++*pos;
3995         if (v == SEQ_START_TOKEN)
3996                 return ptype_get_idx(0);
3997
3998         pt = v;
3999         nxt = pt->list.next;
4000         if (pt->type == htons(ETH_P_ALL)) {
4001                 if (nxt != &ptype_all)
4002                         goto found;
4003                 hash = 0;
4004                 nxt = ptype_base[0].next;
4005         } else
4006                 hash = ntohs(pt->type) & PTYPE_HASH_MASK;
4007
4008         while (nxt == &ptype_base[hash]) {
4009                 if (++hash >= PTYPE_HASH_SIZE)
4010                         return NULL;
4011                 nxt = ptype_base[hash].next;
4012         }
4013 found:
4014         return list_entry(nxt, struct packet_type, list);
4015 }
4016
4017 static void ptype_seq_stop(struct seq_file *seq, void *v)
4018         __releases(RCU)
4019 {
4020         rcu_read_unlock();
4021 }
4022
4023 static int ptype_seq_show(struct seq_file *seq, void *v)
4024 {
4025         struct packet_type *pt = v;
4026
4027         if (v == SEQ_START_TOKEN)
4028                 seq_puts(seq, "Type Device      Function\n");
4029         else if (pt->dev == NULL || dev_net(pt->dev) == seq_file_net(seq)) {
4030                 if (pt->type == htons(ETH_P_ALL))
4031                         seq_puts(seq, "ALL ");
4032                 else
4033                         seq_printf(seq, "%04x", ntohs(pt->type));
4034
4035                 seq_printf(seq, " %-8s %pF\n",
4036                            pt->dev ? pt->dev->name : "", pt->func);
4037         }
4038
4039         return 0;
4040 }
4041
4042 static const struct seq_operations ptype_seq_ops = {
4043         .start = ptype_seq_start,
4044         .next  = ptype_seq_next,
4045         .stop  = ptype_seq_stop,
4046         .show  = ptype_seq_show,
4047 };
4048
4049 static int ptype_seq_open(struct inode *inode, struct file *file)
4050 {
4051         return seq_open_net(inode, file, &ptype_seq_ops,
4052                         sizeof(struct seq_net_private));
4053 }
4054
4055 static const struct file_operations ptype_seq_fops = {
4056         .owner   = THIS_MODULE,
4057         .open    = ptype_seq_open,
4058         .read    = seq_read,
4059         .llseek  = seq_lseek,
4060         .release = seq_release_net,
4061 };
4062
4063
4064 static int __net_init dev_proc_net_init(struct net *net)
4065 {
4066         int rc = -ENOMEM;
4067
4068         if (!proc_net_fops_create(net, "dev", S_IRUGO, &dev_seq_fops))
4069                 goto out;
4070         if (!proc_net_fops_create(net, "softnet_stat", S_IRUGO, &softnet_seq_fops))
4071                 goto out_dev;
4072         if (!proc_net_fops_create(net, "ptype", S_IRUGO, &ptype_seq_fops))
4073                 goto out_softnet;
4074
4075         if (wext_proc_init(net))
4076                 goto out_ptype;
4077         rc = 0;
4078 out:
4079         return rc;
4080 out_ptype:
4081         proc_net_remove(net, "ptype");
4082 out_softnet:
4083         proc_net_remove(net, "softnet_stat");
4084 out_dev:
4085         proc_net_remove(net, "dev");
4086         goto out;
4087 }
4088
4089 static void __net_exit dev_proc_net_exit(struct net *net)
4090 {
4091         wext_proc_exit(net);
4092
4093         proc_net_remove(net, "ptype");
4094         proc_net_remove(net, "softnet_stat");
4095         proc_net_remove(net, "dev");
4096 }
4097
4098 static struct pernet_operations __net_initdata dev_proc_ops = {
4099         .init = dev_proc_net_init,
4100         .exit = dev_proc_net_exit,
4101 };
4102
4103 static int __init dev_proc_init(void)
4104 {
4105         return register_pernet_subsys(&dev_proc_ops);
4106 }
4107 #else
4108 #define dev_proc_init() 0
4109 #endif  /* CONFIG_PROC_FS */
4110
4111
4112 /**
4113  *      netdev_set_master       -       set up master/slave pair
4114  *      @slave: slave device
4115  *      @master: new master device
4116  *
4117  *      Changes the master device of the slave. Pass %NULL to break the
4118  *      bonding. The caller must hold the RTNL semaphore. On a failure
4119  *      a negative errno code is returned. On success the reference counts
4120  *      are adjusted, %RTM_NEWLINK is sent to the routing socket and the
4121  *      function returns zero.
4122  */
4123 int netdev_set_master(struct net_device *slave, struct net_device *master)
4124 {
4125         struct net_device *old = slave->master;
4126
4127         ASSERT_RTNL();
4128
4129         if (master) {
4130                 if (old)
4131                         return -EBUSY;
4132                 dev_hold(master);
4133         }
4134
4135         slave->master = master;
4136
4137         if (old) {
4138                 synchronize_net();
4139                 dev_put(old);
4140         }
4141         if (master)
4142                 slave->flags |= IFF_SLAVE;
4143         else
4144                 slave->flags &= ~IFF_SLAVE;
4145
4146         rtmsg_ifinfo(RTM_NEWLINK, slave, IFF_SLAVE);
4147         return 0;
4148 }
4149 EXPORT_SYMBOL(netdev_set_master);
4150
4151 static void dev_change_rx_flags(struct net_device *dev, int flags)
4152 {
4153         const struct net_device_ops *ops = dev->netdev_ops;
4154
4155         if ((dev->flags & IFF_UP) && ops->ndo_change_rx_flags)
4156                 ops->ndo_change_rx_flags(dev, flags);
4157 }
4158
4159 static int __dev_set_promiscuity(struct net_device *dev, int inc)
4160 {
4161         unsigned short old_flags = dev->flags;
4162         uid_t uid;
4163         gid_t gid;
4164
4165         ASSERT_RTNL();
4166
4167         dev->flags |= IFF_PROMISC;
4168         dev->promiscuity += inc;
4169         if (dev->promiscuity == 0) {
4170                 /*
4171                  * Avoid overflow.
4172                  * If inc causes overflow, untouch promisc and return error.
4173                  */
4174                 if (inc < 0)
4175                         dev->flags &= ~IFF_PROMISC;
4176                 else {
4177                         dev->promiscuity -= inc;
4178                         printk(KERN_WARNING "%s: promiscuity touches roof, "
4179                                 "set promiscuity failed, promiscuity feature "
4180                                 "of device might be broken.\n", dev->name);
4181                         return -EOVERFLOW;
4182                 }
4183         }
4184         if (dev->flags != old_flags) {
4185                 printk(KERN_INFO "device %s %s promiscuous mode\n",
4186                        dev->name, (dev->flags & IFF_PROMISC) ? "entered" :
4187                                                                "left");
4188                 if (audit_enabled) {
4189                         current_uid_gid(&uid, &gid);
4190                         audit_log(current->audit_context, GFP_ATOMIC,
4191                                 AUDIT_ANOM_PROMISCUOUS,
4192                                 "dev=%s prom=%d old_prom=%d auid=%u uid=%u gid=%u ses=%u",
4193                                 dev->name, (dev->flags & IFF_PROMISC),
4194                                 (old_flags & IFF_PROMISC),
4195                                 audit_get_loginuid(current),
4196                                 uid, gid,
4197                                 audit_get_sessionid(current));
4198                 }
4199
4200                 dev_change_rx_flags(dev, IFF_PROMISC);
4201         }
4202         return 0;
4203 }
4204
4205 /**
4206  *      dev_set_promiscuity     - update promiscuity count on a device
4207  *      @dev: device
4208  *      @inc: modifier
4209  *
4210  *      Add or remove promiscuity from a device. While the count in the device
4211  *      remains above zero the interface remains promiscuous. Once it hits zero
4212  *      the device reverts back to normal filtering operation. A negative inc
4213  *      value is used to drop promiscuity on the device.
4214  *      Return 0 if successful or a negative errno code on error.
4215  */
4216 int dev_set_promiscuity(struct net_device *dev, int inc)
4217 {
4218         unsigned short old_flags = dev->flags;
4219         int err;
4220
4221         err = __dev_set_promiscuity(dev, inc);
4222         if (err < 0)
4223                 return err;
4224         if (dev->flags != old_flags)
4225                 dev_set_rx_mode(dev);
4226         return err;
4227 }
4228 EXPORT_SYMBOL(dev_set_promiscuity);
4229
4230 /**
4231  *      dev_set_allmulti        - update allmulti count on a device
4232  *      @dev: device
4233  *      @inc: modifier
4234  *
4235  *      Add or remove reception of all multicast frames to a device. While the
4236  *      count in the device remains above zero the interface remains listening
4237  *      to all interfaces. Once it hits zero the device reverts back to normal
4238  *      filtering operation. A negative @inc value is used to drop the counter
4239  *      when releasing a resource needing all multicasts.
4240  *      Return 0 if successful or a negative errno code on error.
4241  */
4242
4243 int dev_set_allmulti(struct net_device *dev, int inc)
4244 {
4245         unsigned short old_flags = dev->flags;
4246
4247         ASSERT_RTNL();
4248
4249         dev->flags |= IFF_ALLMULTI;
4250         dev->allmulti += inc;
4251         if (dev->allmulti == 0) {
4252                 /*
4253                  * Avoid overflow.
4254                  * If inc causes overflow, untouch allmulti and return error.
4255                  */
4256                 if (inc < 0)
4257                         dev->flags &= ~IFF_ALLMULTI;
4258                 else {
4259                         dev->allmulti -= inc;
4260                         printk(KERN_WARNING "%s: allmulti touches roof, "
4261                                 "set allmulti failed, allmulti feature of "
4262                                 "device might be broken.\n", dev->name);
4263                         return -EOVERFLOW;
4264                 }
4265         }
4266         if (dev->flags ^ old_flags) {
4267                 dev_change_rx_flags(dev, IFF_ALLMULTI);
4268                 dev_set_rx_mode(dev);
4269         }
4270         return 0;
4271 }
4272 EXPORT_SYMBOL(dev_set_allmulti);
4273
4274 /*
4275  *      Upload unicast and multicast address lists to device and
4276  *      configure RX filtering. When the device doesn't support unicast
4277  *      filtering it is put in promiscuous mode while unicast addresses
4278  *      are present.
4279  */
4280 void __dev_set_rx_mode(struct net_device *dev)
4281 {
4282         const struct net_device_ops *ops = dev->netdev_ops;
4283
4284         /* dev_open will call this function so the list will stay sane. */
4285         if (!(dev->flags&IFF_UP))
4286                 return;
4287
4288         if (!netif_device_present(dev))
4289                 return;
4290
4291         if (ops->ndo_set_rx_mode)
4292                 ops->ndo_set_rx_mode(dev);
4293         else {
4294                 /* Unicast addresses changes may only happen under the rtnl,
4295                  * therefore calling __dev_set_promiscuity here is safe.
4296                  */
4297                 if (!netdev_uc_empty(dev) && !dev->uc_promisc) {
4298                         __dev_set_promiscuity(dev, 1);
4299                         dev->uc_promisc = 1;
4300                 } else if (netdev_uc_empty(dev) && dev->uc_promisc) {
4301                         __dev_set_promiscuity(dev, -1);
4302                         dev->uc_promisc = 0;
4303                 }
4304
4305                 if (ops->ndo_set_multicast_list)
4306                         ops->ndo_set_multicast_list(dev);
4307         }
4308 }
4309
4310 void dev_set_rx_mode(struct net_device *dev)
4311 {
4312         netif_addr_lock_bh(dev);
4313         __dev_set_rx_mode(dev);
4314         netif_addr_unlock_bh(dev);
4315 }
4316
4317 /**
4318  *      dev_get_flags - get flags reported to userspace
4319  *      @dev: device
4320  *
4321  *      Get the combination of flag bits exported through APIs to userspace.
4322  */
4323 unsigned dev_get_flags(const struct net_device *dev)
4324 {
4325         unsigned flags;
4326
4327         flags = (dev->flags & ~(IFF_PROMISC |
4328                                 IFF_ALLMULTI |
4329                                 IFF_RUNNING |
4330                                 IFF_LOWER_UP |
4331                                 IFF_DORMANT)) |
4332                 (dev->gflags & (IFF_PROMISC |
4333                                 IFF_ALLMULTI));
4334
4335         if (netif_running(dev)) {
4336                 if (netif_oper_up(dev))
4337                         flags |= IFF_RUNNING;
4338                 if (netif_carrier_ok(dev))
4339                         flags |= IFF_LOWER_UP;
4340                 if (netif_dormant(dev))
4341                         flags |= IFF_DORMANT;
4342         }
4343
4344         return flags;
4345 }
4346 EXPORT_SYMBOL(dev_get_flags);
4347
4348 int __dev_change_flags(struct net_device *dev, unsigned int flags)
4349 {
4350         int old_flags = dev->flags;
4351         int ret;
4352
4353         ASSERT_RTNL();
4354
4355         /*
4356          *      Set the flags on our device.
4357          */
4358
4359         dev->flags = (flags & (IFF_DEBUG | IFF_NOTRAILERS | IFF_NOARP |
4360                                IFF_DYNAMIC | IFF_MULTICAST | IFF_PORTSEL |
4361                                IFF_AUTOMEDIA)) |
4362                      (dev->flags & (IFF_UP | IFF_VOLATILE | IFF_PROMISC |
4363                                     IFF_ALLMULTI));
4364
4365         /*
4366          *      Load in the correct multicast list now the flags have changed.
4367          */
4368
4369         if ((old_flags ^ flags) & IFF_MULTICAST)
4370                 dev_change_rx_flags(dev, IFF_MULTICAST);
4371
4372         dev_set_rx_mode(dev);
4373
4374         /*
4375          *      Have we downed the interface. We handle IFF_UP ourselves
4376          *      according to user attempts to set it, rather than blindly
4377          *      setting it.
4378          */
4379
4380         ret = 0;
4381         if ((old_flags ^ flags) & IFF_UP) {     /* Bit is different  ? */
4382                 ret = ((old_flags & IFF_UP) ? __dev_close : __dev_open)(dev);
4383
4384                 if (!ret)
4385                         dev_set_rx_mode(dev);
4386         }
4387
4388         if ((flags ^ dev->gflags) & IFF_PROMISC) {
4389                 int inc = (flags & IFF_PROMISC) ? 1 : -1;
4390
4391                 dev->gflags ^= IFF_PROMISC;
4392                 dev_set_promiscuity(dev, inc);
4393         }
4394
4395         /* NOTE: order of synchronization of IFF_PROMISC and IFF_ALLMULTI
4396            is important. Some (broken) drivers set IFF_PROMISC, when
4397            IFF_ALLMULTI is requested not asking us and not reporting.
4398          */
4399         if ((flags ^ dev->gflags) & IFF_ALLMULTI) {
4400                 int inc = (flags & IFF_ALLMULTI) ? 1 : -1;
4401
4402                 dev->gflags ^= IFF_ALLMULTI;
4403                 dev_set_allmulti(dev, inc);
4404         }
4405
4406         return ret;
4407 }
4408
4409 void __dev_notify_flags(struct net_device *dev, unsigned int old_flags)
4410 {
4411         unsigned int changes = dev->flags ^ old_flags;
4412
4413         if (changes & IFF_UP) {
4414                 if (dev->flags & IFF_UP)
4415                         call_netdevice_notifiers(NETDEV_UP, dev);
4416                 else
4417                         call_netdevice_notifiers(NETDEV_DOWN, dev);
4418         }
4419
4420         if (dev->flags & IFF_UP &&
4421             (changes & ~(IFF_UP | IFF_PROMISC | IFF_ALLMULTI | IFF_VOLATILE)))
4422                 call_netdevice_notifiers(NETDEV_CHANGE, dev);
4423 }
4424
4425 /**
4426  *      dev_change_flags - change device settings
4427  *      @dev: device
4428  *      @flags: device state flags
4429  *
4430  *      Change settings on device based state flags. The flags are
4431  *      in the userspace exported format.
4432  */
4433 int dev_change_flags(struct net_device *dev, unsigned flags)
4434 {
4435         int ret, changes;
4436         int old_flags = dev->flags;
4437
4438         ret = __dev_change_flags(dev, flags);
4439         if (ret < 0)
4440                 return ret;
4441
4442         changes = old_flags ^ dev->flags;
4443         if (changes)
4444                 rtmsg_ifinfo(RTM_NEWLINK, dev, changes);
4445
4446         __dev_notify_flags(dev, old_flags);
4447         return ret;
4448 }
4449 EXPORT_SYMBOL(dev_change_flags);
4450
4451 /**
4452  *      dev_set_mtu - Change maximum transfer unit
4453  *      @dev: device
4454  *      @new_mtu: new transfer unit
4455  *
4456  *      Change the maximum transfer size of the network device.
4457  */
4458 int dev_set_mtu(struct net_device *dev, int new_mtu)
4459 {
4460         const struct net_device_ops *ops = dev->netdev_ops;
4461         int err;
4462
4463         if (new_mtu == dev->mtu)
4464                 return 0;
4465
4466         /*      MTU must be positive.    */
4467         if (new_mtu < 0)
4468                 return -EINVAL;
4469
4470         if (!netif_device_present(dev))
4471                 return -ENODEV;
4472
4473         err = 0;
4474         if (ops->ndo_change_mtu)
4475                 err = ops->ndo_change_mtu(dev, new_mtu);
4476         else
4477                 dev->mtu = new_mtu;
4478
4479         if (!err && dev->flags & IFF_UP)
4480                 call_netdevice_notifiers(NETDEV_CHANGEMTU, dev);
4481         return err;
4482 }
4483 EXPORT_SYMBOL(dev_set_mtu);
4484
4485 /**
4486  *      dev_set_mac_address - Change Media Access Control Address
4487  *      @dev: device
4488  *      @sa: new address
4489  *
4490  *      Change the hardware (MAC) address of the device
4491  */
4492 int dev_set_mac_address(struct net_device *dev, struct sockaddr *sa)
4493 {
4494         const struct net_device_ops *ops = dev->netdev_ops;
4495         int err;
4496
4497         if (!ops->ndo_set_mac_address)
4498                 return -EOPNOTSUPP;
4499         if (sa->sa_family != dev->type)
4500                 return -EINVAL;
4501         if (!netif_device_present(dev))
4502                 return -ENODEV;
4503         err = ops->ndo_set_mac_address(dev, sa);
4504         if (!err)
4505                 call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
4506         return err;
4507 }
4508 EXPORT_SYMBOL(dev_set_mac_address);
4509
4510 /*
4511  *      Perform the SIOCxIFxxx calls, inside rcu_read_lock()
4512  */
4513 static int dev_ifsioc_locked(struct net *net, struct ifreq *ifr, unsigned int cmd)
4514 {
4515         int err;
4516         struct net_device *dev = dev_get_by_name_rcu(net, ifr->ifr_name);
4517
4518         if (!dev)
4519                 return -ENODEV;
4520
4521         switch (cmd) {
4522         case SIOCGIFFLAGS:      /* Get interface flags */
4523                 ifr->ifr_flags = (short) dev_get_flags(dev);
4524                 return 0;
4525
4526         case SIOCGIFMETRIC:     /* Get the metric on the interface
4527                                    (currently unused) */
4528                 ifr->ifr_metric = 0;
4529                 return 0;
4530
4531         case SIOCGIFMTU:        /* Get the MTU of a device */
4532                 ifr->ifr_mtu = dev->mtu;
4533                 return 0;
4534
4535         case SIOCGIFHWADDR:
4536                 if (!dev->addr_len)
4537                         memset(ifr->ifr_hwaddr.sa_data, 0, sizeof ifr->ifr_hwaddr.sa_data);
4538                 else
4539                         memcpy(ifr->ifr_hwaddr.sa_data, dev->dev_addr,
4540                                min(sizeof ifr->ifr_hwaddr.sa_data, (size_t) dev->addr_len));
4541                 ifr->ifr_hwaddr.sa_family = dev->type;
4542                 return 0;
4543
4544         case SIOCGIFSLAVE:
4545                 err = -EINVAL;
4546                 break;
4547
4548         case SIOCGIFMAP:
4549                 ifr->ifr_map.mem_start = dev->mem_start;
4550                 ifr->ifr_map.mem_end   = dev->mem_end;
4551                 ifr->ifr_map.base_addr = dev->base_addr;
4552                 ifr->ifr_map.irq       = dev->irq;
4553                 ifr->ifr_map.dma       = dev->dma;
4554                 ifr->ifr_map.port      = dev->if_port;
4555                 return 0;
4556
4557         case SIOCGIFINDEX:
4558                 ifr->ifr_ifindex = dev->ifindex;
4559                 return 0;
4560
4561         case SIOCGIFTXQLEN:
4562                 ifr->ifr_qlen = dev->tx_queue_len;
4563                 return 0;
4564
4565         default:
4566                 /* dev_ioctl() should ensure this case
4567                  * is never reached
4568                  */
4569                 WARN_ON(1);
4570                 err = -EINVAL;
4571                 break;
4572
4573         }
4574         return err;
4575 }
4576
4577 /*
4578  *      Perform the SIOCxIFxxx calls, inside rtnl_lock()
4579  */
4580 static int dev_ifsioc(struct net *net, struct ifreq *ifr, unsigned int cmd)
4581 {
4582         int err;
4583         struct net_device *dev = __dev_get_by_name(net, ifr->ifr_name);
4584         const struct net_device_ops *ops;
4585
4586         if (!dev)
4587                 return -ENODEV;
4588
4589         ops = dev->netdev_ops;
4590
4591         switch (cmd) {
4592         case SIOCSIFFLAGS:      /* Set interface flags */
4593                 return dev_change_flags(dev, ifr->ifr_flags);
4594
4595         case SIOCSIFMETRIC:     /* Set the metric on the interface
4596                                    (currently unused) */
4597                 return -EOPNOTSUPP;
4598
4599         case SIOCSIFMTU:        /* Set the MTU of a device */
4600                 return dev_set_mtu(dev, ifr->ifr_mtu);
4601
4602         case SIOCSIFHWADDR:
4603                 return dev_set_mac_address(dev, &ifr->ifr_hwaddr);
4604
4605         case SIOCSIFHWBROADCAST:
4606                 if (ifr->ifr_hwaddr.sa_family != dev->type)
4607                         return -EINVAL;
4608                 memcpy(dev->broadcast, ifr->ifr_hwaddr.sa_data,
4609                        min(sizeof ifr->ifr_hwaddr.sa_data, (size_t) dev->addr_len));
4610                 call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
4611                 return 0;
4612
4613         case SIOCSIFMAP:
4614                 if (ops->ndo_set_config) {
4615                         if (!netif_device_present(dev))
4616                                 return -ENODEV;
4617                         return ops->ndo_set_config(dev, &ifr->ifr_map);
4618                 }
4619                 return -EOPNOTSUPP;
4620
4621         case SIOCADDMULTI:
4622                 if ((!ops->ndo_set_multicast_list && !ops->ndo_set_rx_mode) ||
4623                     ifr->ifr_hwaddr.sa_family != AF_UNSPEC)
4624                         return -EINVAL;
4625                 if (!netif_device_present(dev))
4626                         return -ENODEV;
4627                 return dev_mc_add_global(dev, ifr->ifr_hwaddr.sa_data);
4628
4629         case SIOCDELMULTI:
4630                 if ((!ops->ndo_set_multicast_list && !ops->ndo_set_rx_mode) ||
4631                     ifr->ifr_hwaddr.sa_family != AF_UNSPEC)
4632                         return -EINVAL;
4633                 if (!netif_device_present(dev))
4634                         return -ENODEV;
4635                 return dev_mc_del_global(dev, ifr->ifr_hwaddr.sa_data);
4636
4637         case SIOCSIFTXQLEN:
4638                 if (ifr->ifr_qlen < 0)
4639                         return -EINVAL;
4640                 dev->tx_queue_len = ifr->ifr_qlen;
4641                 return 0;
4642
4643         case SIOCSIFNAME:
4644                 ifr->ifr_newname[IFNAMSIZ-1] = '\0';
4645                 return dev_change_name(dev, ifr->ifr_newname);
4646
4647         /*
4648          *      Unknown or private ioctl
4649          */
4650         default:
4651                 if ((cmd >= SIOCDEVPRIVATE &&
4652                     cmd <= SIOCDEVPRIVATE + 15) ||
4653                     cmd == SIOCBONDENSLAVE ||
4654                     cmd == SIOCBONDRELEASE ||
4655                     cmd == SIOCBONDSETHWADDR ||
4656                     cmd == SIOCBONDSLAVEINFOQUERY ||
4657                     cmd == SIOCBONDINFOQUERY ||
4658                     cmd == SIOCBONDCHANGEACTIVE ||
4659                     cmd == SIOCGMIIPHY ||
4660                     cmd == SIOCGMIIREG ||
4661                     cmd == SIOCSMIIREG ||
4662                     cmd == SIOCBRADDIF ||
4663                     cmd == SIOCBRDELIF ||
4664                     cmd == SIOCSHWTSTAMP ||
4665                     cmd == SIOCWANDEV) {
4666                         err = -EOPNOTSUPP;
4667                         if (ops->ndo_do_ioctl) {
4668                                 if (netif_device_present(dev))
4669                                         err = ops->ndo_do_ioctl(dev, ifr, cmd);
4670                                 else
4671                                         err = -ENODEV;
4672                         }
4673                 } else
4674                         err = -EINVAL;
4675
4676         }
4677         return err;
4678 }
4679
4680 /*
4681  *      This function handles all "interface"-type I/O control requests. The actual
4682  *      'doing' part of this is dev_ifsioc above.
4683  */
4684
4685 /**
4686  *      dev_ioctl       -       network device ioctl
4687  *      @net: the applicable net namespace
4688  *      @cmd: command to issue
4689  *      @arg: pointer to a struct ifreq in user space
4690  *
4691  *      Issue ioctl functions to devices. This is normally called by the
4692  *      user space syscall interfaces but can sometimes be useful for
4693  *      other purposes. The return value is the return from the syscall if
4694  *      positive or a negative errno code on error.
4695  */
4696
4697 int dev_ioctl(struct net *net, unsigned int cmd, void __user *arg)
4698 {
4699         struct ifreq ifr;
4700         int ret;
4701         char *colon;
4702
4703         /* One special case: SIOCGIFCONF takes ifconf argument
4704            and requires shared lock, because it sleeps writing
4705            to user space.
4706          */
4707
4708         if (cmd == SIOCGIFCONF) {
4709                 rtnl_lock();
4710                 ret = dev_ifconf(net, (char __user *) arg);
4711                 rtnl_unlock();
4712                 return ret;
4713         }
4714         if (cmd == SIOCGIFNAME)
4715                 return dev_ifname(net, (struct ifreq __user *)arg);
4716
4717         if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
4718                 return -EFAULT;
4719
4720         ifr.ifr_name[IFNAMSIZ-1] = 0;
4721
4722         colon = strchr(ifr.ifr_name, ':');
4723         if (colon)
4724                 *colon = 0;
4725
4726         /*
4727          *      See which interface the caller is talking about.
4728          */
4729
4730         switch (cmd) {
4731         /*
4732          *      These ioctl calls:
4733          *      - can be done by all.
4734          *      - atomic and do not require locking.
4735          *      - return a value
4736          */
4737         case SIOCGIFFLAGS:
4738         case SIOCGIFMETRIC:
4739         case SIOCGIFMTU:
4740         case SIOCGIFHWADDR:
4741         case SIOCGIFSLAVE:
4742         case SIOCGIFMAP:
4743         case SIOCGIFINDEX:
4744         case SIOCGIFTXQLEN:
4745                 dev_load(net, ifr.ifr_name);
4746                 rcu_read_lock();
4747                 ret = dev_ifsioc_locked(net, &ifr, cmd);
4748                 rcu_read_unlock();
4749                 if (!ret) {
4750                         if (colon)
4751                                 *colon = ':';
4752                         if (copy_to_user(arg, &ifr,
4753                                          sizeof(struct ifreq)))
4754                                 ret = -EFAULT;
4755                 }
4756                 return ret;
4757
4758         case SIOCETHTOOL:
4759                 dev_load(net, ifr.ifr_name);
4760                 rtnl_lock();
4761                 ret = dev_ethtool(net, &ifr);
4762                 rtnl_unlock();
4763                 if (!ret) {
4764                         if (colon)
4765                                 *colon = ':';
4766                         if (copy_to_user(arg, &ifr,
4767                                          sizeof(struct ifreq)))
4768                                 ret = -EFAULT;
4769                 }
4770                 return ret;
4771
4772         /*
4773          *      These ioctl calls:
4774          *      - require superuser power.
4775          *      - require strict serialization.
4776          *      - return a value
4777          */
4778         case SIOCGMIIPHY:
4779         case SIOCGMIIREG:
4780         case SIOCSIFNAME:
4781                 if (!capable(CAP_NET_ADMIN))
4782                         return -EPERM;
4783                 dev_load(net, ifr.ifr_name);
4784                 rtnl_lock();
4785                 ret = dev_ifsioc(net, &ifr, cmd);
4786                 rtnl_unlock();
4787                 if (!ret) {
4788                         if (colon)
4789                                 *colon = ':';
4790                         if (copy_to_user(arg, &ifr,
4791                                          sizeof(struct ifreq)))
4792                                 ret = -EFAULT;
4793                 }
4794                 return ret;
4795
4796         /*
4797          *      These ioctl calls:
4798          *      - require superuser power.
4799          *      - require strict serialization.
4800          *      - do not return a value
4801          */
4802         case SIOCSIFFLAGS:
4803         case SIOCSIFMETRIC:
4804         case SIOCSIFMTU:
4805         case SIOCSIFMAP:
4806         case SIOCSIFHWADDR:
4807         case SIOCSIFSLAVE:
4808         case SIOCADDMULTI:
4809         case SIOCDELMULTI:
4810         case SIOCSIFHWBROADCAST:
4811         case SIOCSIFTXQLEN:
4812         case SIOCSMIIREG:
4813         case SIOCBONDENSLAVE:
4814         case SIOCBONDRELEASE:
4815         case SIOCBONDSETHWADDR:
4816         case SIOCBONDCHANGEACTIVE:
4817         case SIOCBRADDIF:
4818         case SIOCBRDELIF:
4819         case SIOCSHWTSTAMP:
4820                 if (!capable(CAP_NET_ADMIN))
4821                         return -EPERM;
4822                 /* fall through */
4823         case SIOCBONDSLAVEINFOQUERY:
4824         case SIOCBONDINFOQUERY:
4825                 dev_load(net, ifr.ifr_name);
4826                 rtnl_lock();
4827                 ret = dev_ifsioc(net, &ifr, cmd);
4828                 rtnl_unlock();
4829                 return ret;
4830
4831         case SIOCGIFMEM:
4832                 /* Get the per device memory space. We can add this but
4833                  * currently do not support it */
4834         case SIOCSIFMEM:
4835                 /* Set the per device memory buffer space.
4836                  * Not applicable in our case */
4837         case SIOCSIFLINK:
4838                 return -EINVAL;
4839
4840         /*
4841          *      Unknown or private ioctl.
4842          */
4843         default:
4844                 if (cmd == SIOCWANDEV ||
4845                     (cmd >= SIOCDEVPRIVATE &&
4846                      cmd <= SIOCDEVPRIVATE + 15)) {
4847                         dev_load(net, ifr.ifr_name);
4848                         rtnl_lock();
4849                         ret = dev_ifsioc(net, &ifr, cmd);
4850                         rtnl_unlock();
4851                         if (!ret && copy_to_user(arg, &ifr,
4852                                                  sizeof(struct ifreq)))
4853                                 ret = -EFAULT;
4854                         return ret;
4855                 }
4856                 /* Take care of Wireless Extensions */
4857                 if (cmd >= SIOCIWFIRST && cmd <= SIOCIWLAST)
4858                         return wext_handle_ioctl(net, &ifr, cmd, arg);
4859                 return -EINVAL;
4860         }
4861 }
4862
4863
4864 /**
4865  *      dev_new_index   -       allocate an ifindex
4866  *      @net: the applicable net namespace
4867  *
4868  *      Returns a suitable unique value for a new device interface
4869  *      number.  The caller must hold the rtnl semaphore or the
4870  *      dev_base_lock to be sure it remains unique.
4871  */
4872 static int dev_new_index(struct net *net)
4873 {
4874         static int ifindex;
4875         for (;;) {
4876                 if (++ifindex <= 0)
4877                         ifindex = 1;
4878                 if (!__dev_get_by_index(net, ifindex))
4879                         return ifindex;
4880         }
4881 }
4882
4883 /* Delayed registration/unregisteration */
4884 static LIST_HEAD(net_todo_list);
4885
4886 static void net_set_todo(struct net_device *dev)
4887 {
4888         list_add_tail(&dev->todo_list, &net_todo_list);
4889 }
4890
4891 static void rollback_registered_many(struct list_head *head)
4892 {
4893         struct net_device *dev, *tmp;
4894
4895         BUG_ON(dev_boot_phase);
4896         ASSERT_RTNL();
4897
4898         list_for_each_entry_safe(dev, tmp, head, unreg_list) {
4899                 /* Some devices call without registering
4900                  * for initialization unwind. Remove those
4901                  * devices and proceed with the remaining.
4902                  */
4903                 if (dev->reg_state == NETREG_UNINITIALIZED) {
4904                         pr_debug("unregister_netdevice: device %s/%p never "
4905                                  "was registered\n", dev->name, dev);
4906
4907                         WARN_ON(1);
4908                         list_del(&dev->unreg_list);
4909                         continue;
4910                 }
4911
4912                 BUG_ON(dev->reg_state != NETREG_REGISTERED);
4913
4914                 /* If device is running, close it first. */
4915                 dev_close(dev);
4916
4917                 /* And unlink it from device chain. */
4918                 unlist_netdevice(dev);
4919
4920                 dev->reg_state = NETREG_UNREGISTERING;
4921         }
4922
4923         synchronize_net();
4924
4925         list_for_each_entry(dev, head, unreg_list) {
4926                 /* Shutdown queueing discipline. */
4927                 dev_shutdown(dev);
4928
4929
4930                 /* Notify protocols, that we are about to destroy
4931                    this device. They should clean all the things.
4932                 */
4933                 call_netdevice_notifiers(NETDEV_UNREGISTER, dev);
4934
4935                 if (!dev->rtnl_link_ops ||
4936                     dev->rtnl_link_state == RTNL_LINK_INITIALIZED)
4937                         rtmsg_ifinfo(RTM_DELLINK, dev, ~0U);
4938
4939                 /*
4940                  *      Flush the unicast and multicast chains
4941                  */
4942                 dev_uc_flush(dev);
4943                 dev_mc_flush(dev);
4944
4945                 if (dev->netdev_ops->ndo_uninit)
4946                         dev->netdev_ops->ndo_uninit(dev);
4947
4948                 /* Notifier chain MUST detach us from master device. */
4949                 WARN_ON(dev->master);
4950
4951                 /* Remove entries from kobject tree */
4952                 netdev_unregister_kobject(dev);
4953         }
4954
4955         /* Process any work delayed until the end of the batch */
4956         dev = list_first_entry(head, struct net_device, unreg_list);
4957         call_netdevice_notifiers(NETDEV_UNREGISTER_BATCH, dev);
4958
4959         rcu_barrier();
4960
4961         list_for_each_entry(dev, head, unreg_list)
4962                 dev_put(dev);
4963 }
4964
4965 static void rollback_registered(struct net_device *dev)
4966 {
4967         LIST_HEAD(single);
4968
4969         list_add(&dev->unreg_list, &single);
4970         rollback_registered_many(&single);
4971 }
4972
4973 unsigned long netdev_fix_features(unsigned long features, const char *name)
4974 {
4975         /* Fix illegal SG+CSUM combinations. */
4976         if ((features & NETIF_F_SG) &&
4977             !(features & NETIF_F_ALL_CSUM)) {
4978                 if (name)
4979                         printk(KERN_NOTICE "%s: Dropping NETIF_F_SG since no "
4980                                "checksum feature.\n", name);
4981                 features &= ~NETIF_F_SG;
4982         }
4983
4984         /* TSO requires that SG is present as well. */
4985         if ((features & NETIF_F_TSO) && !(features & NETIF_F_SG)) {
4986                 if (name)
4987                         printk(KERN_NOTICE "%s: Dropping NETIF_F_TSO since no "
4988                                "SG feature.\n", name);
4989                 features &= ~NETIF_F_TSO;
4990         }
4991
4992         if (features & NETIF_F_UFO) {
4993                 if (!(features & NETIF_F_GEN_CSUM)) {
4994                         if (name)
4995                                 printk(KERN_ERR "%s: Dropping NETIF_F_UFO "
4996                                        "since no NETIF_F_HW_CSUM feature.\n",
4997                                        name);
4998                         features &= ~NETIF_F_UFO;
4999                 }
5000
5001                 if (!(features & NETIF_F_SG)) {
5002                         if (name)
5003                                 printk(KERN_ERR "%s: Dropping NETIF_F_UFO "
5004                                        "since no NETIF_F_SG feature.\n", name);
5005                         features &= ~NETIF_F_UFO;
5006                 }
5007         }
5008
5009         return features;
5010 }
5011 EXPORT_SYMBOL(netdev_fix_features);
5012
5013 /**
5014  *      netif_stacked_transfer_operstate -      transfer operstate
5015  *      @rootdev: the root or lower level device to transfer state from
5016  *      @dev: the device to transfer operstate to
5017  *
5018  *      Transfer operational state from root to device. This is normally
5019  *      called when a stacking relationship exists between the root
5020  *      device and the device(a leaf device).
5021  */
5022 void netif_stacked_transfer_operstate(const struct net_device *rootdev,
5023                                         struct net_device *dev)
5024 {
5025         if (rootdev->operstate == IF_OPER_DORMANT)
5026                 netif_dormant_on(dev);
5027         else
5028                 netif_dormant_off(dev);
5029
5030         if (netif_carrier_ok(rootdev)) {
5031                 if (!netif_carrier_ok(dev))
5032                         netif_carrier_on(dev);
5033         } else {
5034                 if (netif_carrier_ok(dev))
5035                         netif_carrier_off(dev);
5036         }
5037 }
5038 EXPORT_SYMBOL(netif_stacked_transfer_operstate);
5039
5040 static int netif_alloc_rx_queues(struct net_device *dev)
5041 {
5042 #ifdef CONFIG_RPS
5043         unsigned int i, count = dev->num_rx_queues;
5044         struct netdev_rx_queue *rx;
5045
5046         BUG_ON(count < 1);
5047
5048         rx = kcalloc(count, sizeof(struct netdev_rx_queue), GFP_KERNEL);
5049         if (!rx) {
5050                 pr_err("netdev: Unable to allocate %u rx queues.\n", count);
5051                 return -ENOMEM;
5052         }
5053         dev->_rx = rx;
5054
5055         for (i = 0; i < count; i++)
5056                 rx[i].dev = dev;
5057 #endif
5058         return 0;
5059 }
5060
5061 static int netif_alloc_netdev_queues(struct net_device *dev)
5062 {
5063         unsigned int count = dev->num_tx_queues;
5064         struct netdev_queue *tx;
5065
5066         BUG_ON(count < 1);
5067
5068         tx = kcalloc(count, sizeof(struct netdev_queue), GFP_KERNEL);
5069         if (!tx) {
5070                 pr_err("netdev: Unable to allocate %u tx queues.\n",
5071                        count);
5072                 return -ENOMEM;
5073         }
5074         dev->_tx = tx;
5075         return 0;
5076 }
5077
5078 static void netdev_init_one_queue(struct net_device *dev,
5079                                   struct netdev_queue *queue,
5080                                   void *_unused)
5081 {
5082         queue->dev = dev;
5083
5084         /* Initialize queue lock */
5085         spin_lock_init(&queue->_xmit_lock);
5086         netdev_set_xmit_lockdep_class(&queue->_xmit_lock, dev->type);
5087         queue->xmit_lock_owner = -1;
5088 }
5089
5090 static void netdev_init_queues(struct net_device *dev)
5091 {
5092         netdev_for_each_tx_queue(dev, netdev_init_one_queue, NULL);
5093         spin_lock_init(&dev->tx_global_lock);
5094 }
5095
5096 /**
5097  *      register_netdevice      - register a network device
5098  *      @dev: device to register
5099  *
5100  *      Take a completed network device structure and add it to the kernel
5101  *      interfaces. A %NETDEV_REGISTER message is sent to the netdev notifier
5102  *      chain. 0 is returned on success. A negative errno code is returned
5103  *      on a failure to set up the device, or if the name is a duplicate.
5104  *
5105  *      Callers must hold the rtnl semaphore. You may want
5106  *      register_netdev() instead of this.
5107  *
5108  *      BUGS:
5109  *      The locking appears insufficient to guarantee two parallel registers
5110  *      will not get the same name.
5111  */
5112
5113 int register_netdevice(struct net_device *dev)
5114 {
5115         int ret;
5116         struct net *net = dev_net(dev);
5117
5118         BUG_ON(dev_boot_phase);
5119         ASSERT_RTNL();
5120
5121         might_sleep();
5122
5123         /* When net_device's are persistent, this will be fatal. */
5124         BUG_ON(dev->reg_state != NETREG_UNINITIALIZED);
5125         BUG_ON(!net);
5126
5127         spin_lock_init(&dev->addr_list_lock);
5128         netdev_set_addr_lockdep_class(dev);
5129
5130         dev->iflink = -1;
5131
5132         netdev_init_queues(dev);
5133
5134         /* Init, if this function is available */
5135         if (dev->netdev_ops->ndo_init) {
5136                 ret = dev->netdev_ops->ndo_init(dev);
5137                 if (ret) {
5138                         if (ret > 0)
5139                                 ret = -EIO;
5140                         goto out;
5141                 }
5142         }
5143
5144         ret = dev_get_valid_name(dev, dev->name, 0);
5145         if (ret)
5146                 goto err_uninit;
5147
5148         dev->ifindex = dev_new_index(net);
5149         if (dev->iflink == -1)
5150                 dev->iflink = dev->ifindex;
5151
5152         /* Fix illegal checksum combinations */
5153         if ((dev->features & NETIF_F_HW_CSUM) &&
5154             (dev->features & (NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM))) {
5155                 printk(KERN_NOTICE "%s: mixed HW and IP checksum settings.\n",
5156                        dev->name);
5157                 dev->features &= ~(NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM);
5158         }
5159
5160         if ((dev->features & NETIF_F_NO_CSUM) &&
5161             (dev->features & (NETIF_F_HW_CSUM|NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM))) {
5162                 printk(KERN_NOTICE "%s: mixed no checksumming and other settings.\n",
5163                        dev->name);
5164                 dev->features &= ~(NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM|NETIF_F_HW_CSUM);
5165         }
5166
5167         dev->features = netdev_fix_features(dev->features, dev->name);
5168
5169         /* Enable software GSO if SG is supported. */
5170         if (dev->features & NETIF_F_SG)
5171                 dev->features |= NETIF_F_GSO;
5172
5173         /* Enable GRO and NETIF_F_HIGHDMA for vlans by default,
5174          * vlan_dev_init() will do the dev->features check, so these features
5175          * are enabled only if supported by underlying device.
5176          */
5177         dev->vlan_features |= (NETIF_F_GRO | NETIF_F_HIGHDMA);
5178
5179         ret = call_netdevice_notifiers(NETDEV_POST_INIT, dev);
5180         ret = notifier_to_errno(ret);
5181         if (ret)
5182                 goto err_uninit;
5183
5184         ret = netdev_register_kobject(dev);
5185         if (ret)
5186                 goto err_uninit;
5187         dev->reg_state = NETREG_REGISTERED;
5188
5189         /*
5190          *      Default initial state at registry is that the
5191          *      device is present.
5192          */
5193
5194         set_bit(__LINK_STATE_PRESENT, &dev->state);
5195
5196         dev_init_scheduler(dev);
5197         dev_hold(dev);
5198         list_netdevice(dev);
5199
5200         /* Notify protocols, that a new device appeared. */
5201         ret = call_netdevice_notifiers(NETDEV_REGISTER, dev);
5202         ret = notifier_to_errno(ret);
5203         if (ret) {
5204                 rollback_registered(dev);
5205                 dev->reg_state = NETREG_UNREGISTERED;
5206         }
5207         /*
5208          *      Prevent userspace races by waiting until the network
5209          *      device is fully setup before sending notifications.
5210          */
5211         if (!dev->rtnl_link_ops ||
5212             dev->rtnl_link_state == RTNL_LINK_INITIALIZED)
5213                 rtmsg_ifinfo(RTM_NEWLINK, dev, ~0U);
5214
5215 out:
5216         return ret;
5217
5218 err_uninit:
5219         if (dev->netdev_ops->ndo_uninit)
5220                 dev->netdev_ops->ndo_uninit(dev);
5221         goto out;
5222 }
5223 EXPORT_SYMBOL(register_netdevice);
5224
5225 /**
5226  *      init_dummy_netdev       - init a dummy network device for NAPI
5227  *      @dev: device to init
5228  *
5229  *      This takes a network device structure and initialize the minimum
5230  *      amount of fields so it can be used to schedule NAPI polls without
5231  *      registering a full blown interface. This is to be used by drivers
5232  *      that need to tie several hardware interfaces to a single NAPI
5233  *      poll scheduler due to HW limitations.
5234  */
5235 int init_dummy_netdev(struct net_device *dev)
5236 {
5237         /* Clear everything. Note we don't initialize spinlocks
5238          * are they aren't supposed to be taken by any of the
5239          * NAPI code and this dummy netdev is supposed to be
5240          * only ever used for NAPI polls
5241          */
5242         memset(dev, 0, sizeof(struct net_device));
5243
5244         /* make sure we BUG if trying to hit standard
5245          * register/unregister code path
5246          */
5247         dev->reg_state = NETREG_DUMMY;
5248
5249         /* NAPI wants this */
5250         INIT_LIST_HEAD(&dev->napi_list);
5251
5252         /* a dummy interface is started by default */
5253         set_bit(__LINK_STATE_PRESENT, &dev->state);
5254         set_bit(__LINK_STATE_START, &dev->state);
5255
5256         /* Note : We dont allocate pcpu_refcnt for dummy devices,
5257          * because users of this 'device' dont need to change
5258          * its refcount.
5259          */
5260
5261         return 0;
5262 }
5263 EXPORT_SYMBOL_GPL(init_dummy_netdev);
5264
5265
5266 /**
5267  *      register_netdev - register a network device
5268  *      @dev: device to register
5269  *
5270  *      Take a completed network device structure and add it to the kernel
5271  *      interfaces. A %NETDEV_REGISTER message is sent to the netdev notifier
5272  *      chain. 0 is returned on success. A negative errno code is returned
5273  *      on a failure to set up the device, or if the name is a duplicate.
5274  *
5275  *      This is a wrapper around register_netdevice that takes the rtnl semaphore
5276  *      and expands the device name if you passed a format string to
5277  *      alloc_netdev.
5278  */
5279 int register_netdev(struct net_device *dev)
5280 {
5281         int err;
5282
5283         rtnl_lock();
5284
5285         /*
5286          * If the name is a format string the caller wants us to do a
5287          * name allocation.
5288          */
5289         if (strchr(dev->name, '%')) {
5290                 err = dev_alloc_name(dev, dev->name);
5291                 if (err < 0)
5292                         goto out;
5293         }
5294
5295         err = register_netdevice(dev);
5296 out:
5297         rtnl_unlock();
5298         return err;
5299 }
5300 EXPORT_SYMBOL(register_netdev);
5301
5302 int netdev_refcnt_read(const struct net_device *dev)
5303 {
5304         int i, refcnt = 0;
5305
5306         for_each_possible_cpu(i)
5307                 refcnt += *per_cpu_ptr(dev->pcpu_refcnt, i);
5308         return refcnt;
5309 }
5310 EXPORT_SYMBOL(netdev_refcnt_read);
5311
5312 /*
5313  * netdev_wait_allrefs - wait until all references are gone.
5314  *
5315  * This is called when unregistering network devices.
5316  *
5317  * Any protocol or device that holds a reference should register
5318  * for netdevice notification, and cleanup and put back the
5319  * reference if they receive an UNREGISTER event.
5320  * We can get stuck here if buggy protocols don't correctly
5321  * call dev_put.
5322  */
5323 static void netdev_wait_allrefs(struct net_device *dev)
5324 {
5325         unsigned long rebroadcast_time, warning_time;
5326         int refcnt;
5327
5328         linkwatch_forget_dev(dev);
5329
5330         rebroadcast_time = warning_time = jiffies;
5331         refcnt = netdev_refcnt_read(dev);
5332
5333         while (refcnt != 0) {
5334                 if (time_after(jiffies, rebroadcast_time + 1 * HZ)) {
5335                         rtnl_lock();
5336
5337                         /* Rebroadcast unregister notification */
5338                         call_netdevice_notifiers(NETDEV_UNREGISTER, dev);
5339                         /* don't resend NETDEV_UNREGISTER_BATCH, _BATCH users
5340                          * should have already handle it the first time */
5341
5342                         if (test_bit(__LINK_STATE_LINKWATCH_PENDING,
5343                                      &dev->state)) {
5344                                 /* We must not have linkwatch events
5345                                  * pending on unregister. If this
5346                                  * happens, we simply run the queue
5347                                  * unscheduled, resulting in a noop
5348                                  * for this device.
5349                                  */
5350                                 linkwatch_run_queue();
5351                         }
5352
5353                         __rtnl_unlock();
5354
5355                         rebroadcast_time = jiffies;
5356                 }
5357
5358                 msleep(250);
5359
5360                 refcnt = netdev_refcnt_read(dev);
5361
5362                 if (time_after(jiffies, warning_time + 10 * HZ)) {
5363                         printk(KERN_EMERG "unregister_netdevice: "
5364                                "waiting for %s to become free. Usage "
5365                                "count = %d\n",
5366                                dev->name, refcnt);
5367                         warning_time = jiffies;
5368                 }
5369         }
5370 }
5371
5372 /* The sequence is:
5373  *
5374  *      rtnl_lock();
5375  *      ...
5376  *      register_netdevice(x1);
5377  *      register_netdevice(x2);
5378  *      ...
5379  *      unregister_netdevice(y1);
5380  *      unregister_netdevice(y2);
5381  *      ...
5382  *      rtnl_unlock();
5383  *      free_netdev(y1);
5384  *      free_netdev(y2);
5385  *
5386  * We are invoked by rtnl_unlock().
5387  * This allows us to deal with problems:
5388  * 1) We can delete sysfs objects which invoke hotplug
5389  *    without deadlocking with linkwatch via keventd.
5390  * 2) Since we run with the RTNL semaphore not held, we can sleep
5391  *    safely in order to wait for the netdev refcnt to drop to zero.
5392  *
5393  * We must not return until all unregister events added during
5394  * the interval the lock was held have been completed.
5395  */
5396 void netdev_run_todo(void)
5397 {
5398         struct list_head list;
5399
5400         /* Snapshot list, allow later requests */
5401         list_replace_init(&net_todo_list, &list);
5402
5403         __rtnl_unlock();
5404
5405         while (!list_empty(&list)) {
5406                 struct net_device *dev
5407                         = list_first_entry(&list, struct net_device, todo_list);
5408                 list_del(&dev->todo_list);
5409
5410                 if (unlikely(dev->reg_state != NETREG_UNREGISTERING)) {
5411                         printk(KERN_ERR "network todo '%s' but state %d\n",
5412                                dev->name, dev->reg_state);
5413                         dump_stack();
5414                         continue;
5415                 }
5416
5417                 dev->reg_state = NETREG_UNREGISTERED;
5418
5419                 on_each_cpu(flush_backlog, dev, 1);
5420
5421                 netdev_wait_allrefs(dev);
5422
5423                 /* paranoia */
5424                 BUG_ON(netdev_refcnt_read(dev));
5425                 WARN_ON(rcu_dereference_raw(dev->ip_ptr));
5426                 WARN_ON(rcu_dereference_raw(dev->ip6_ptr));
5427                 WARN_ON(dev->dn_ptr);
5428
5429                 if (dev->destructor)
5430                         dev->destructor(dev);
5431
5432                 /* Free network device */
5433                 kobject_put(&dev->dev.kobj);
5434         }
5435 }
5436
5437 /**
5438  *      dev_txq_stats_fold - fold tx_queues stats
5439  *      @dev: device to get statistics from
5440  *      @stats: struct rtnl_link_stats64 to hold results
5441  */
5442 void dev_txq_stats_fold(const struct net_device *dev,
5443                         struct rtnl_link_stats64 *stats)
5444 {
5445         u64 tx_bytes = 0, tx_packets = 0, tx_dropped = 0;
5446         unsigned int i;
5447         struct netdev_queue *txq;
5448
5449         for (i = 0; i < dev->num_tx_queues; i++) {
5450                 txq = netdev_get_tx_queue(dev, i);
5451                 spin_lock_bh(&txq->_xmit_lock);
5452                 tx_bytes   += txq->tx_bytes;
5453                 tx_packets += txq->tx_packets;
5454                 tx_dropped += txq->tx_dropped;
5455                 spin_unlock_bh(&txq->_xmit_lock);
5456         }
5457         if (tx_bytes || tx_packets || tx_dropped) {
5458                 stats->tx_bytes   = tx_bytes;
5459                 stats->tx_packets = tx_packets;
5460                 stats->tx_dropped = tx_dropped;
5461         }
5462 }
5463 EXPORT_SYMBOL(dev_txq_stats_fold);
5464
5465 /* Convert net_device_stats to rtnl_link_stats64.  They have the same
5466  * fields in the same order, with only the type differing.
5467  */
5468 static void netdev_stats_to_stats64(struct rtnl_link_stats64 *stats64,
5469                                     const struct net_device_stats *netdev_stats)
5470 {
5471 #if BITS_PER_LONG == 64
5472         BUILD_BUG_ON(sizeof(*stats64) != sizeof(*netdev_stats));
5473         memcpy(stats64, netdev_stats, sizeof(*stats64));
5474 #else
5475         size_t i, n = sizeof(*stats64) / sizeof(u64);
5476         const unsigned long *src = (const unsigned long *)netdev_stats;
5477         u64 *dst = (u64 *)stats64;
5478
5479         BUILD_BUG_ON(sizeof(*netdev_stats) / sizeof(unsigned long) !=
5480                      sizeof(*stats64) / sizeof(u64));
5481         for (i = 0; i < n; i++)
5482                 dst[i] = src[i];
5483 #endif
5484 }
5485
5486 /**
5487  *      dev_get_stats   - get network device statistics
5488  *      @dev: device to get statistics from
5489  *      @storage: place to store stats
5490  *
5491  *      Get network statistics from device. Return @storage.
5492  *      The device driver may provide its own method by setting
5493  *      dev->netdev_ops->get_stats64 or dev->netdev_ops->get_stats;
5494  *      otherwise the internal statistics structure is used.
5495  */
5496 struct rtnl_link_stats64 *dev_get_stats(struct net_device *dev,
5497                                         struct rtnl_link_stats64 *storage)
5498 {
5499         const struct net_device_ops *ops = dev->netdev_ops;
5500
5501         if (ops->ndo_get_stats64) {
5502                 memset(storage, 0, sizeof(*storage));
5503                 ops->ndo_get_stats64(dev, storage);
5504         } else if (ops->ndo_get_stats) {
5505                 netdev_stats_to_stats64(storage, ops->ndo_get_stats(dev));
5506         } else {
5507                 netdev_stats_to_stats64(storage, &dev->stats);
5508                 dev_txq_stats_fold(dev, storage);
5509         }
5510         storage->rx_dropped += atomic_long_read(&dev->rx_dropped);
5511         return storage;
5512 }
5513 EXPORT_SYMBOL(dev_get_stats);
5514
5515 struct netdev_queue *dev_ingress_queue_create(struct net_device *dev)
5516 {
5517         struct netdev_queue *queue = dev_ingress_queue(dev);
5518
5519 #ifdef CONFIG_NET_CLS_ACT
5520         if (queue)
5521                 return queue;
5522         queue = kzalloc(sizeof(*queue), GFP_KERNEL);
5523         if (!queue)
5524                 return NULL;
5525         netdev_init_one_queue(dev, queue, NULL);
5526         queue->qdisc = &noop_qdisc;
5527         queue->qdisc_sleeping = &noop_qdisc;
5528         rcu_assign_pointer(dev->ingress_queue, queue);
5529 #endif
5530         return queue;
5531 }
5532
5533 /**
5534  *      alloc_netdev_mq - allocate network device
5535  *      @sizeof_priv:   size of private data to allocate space for
5536  *      @name:          device name format string
5537  *      @setup:         callback to initialize device
5538  *      @queue_count:   the number of subqueues to allocate
5539  *
5540  *      Allocates a struct net_device with private data area for driver use
5541  *      and performs basic initialization.  Also allocates subquue structs
5542  *      for each queue on the device at the end of the netdevice.
5543  */
5544 struct net_device *alloc_netdev_mq(int sizeof_priv, const char *name,
5545                 void (*setup)(struct net_device *), unsigned int queue_count)
5546 {
5547         struct net_device *dev;
5548         size_t alloc_size;
5549         struct net_device *p;
5550
5551         BUG_ON(strlen(name) >= sizeof(dev->name));
5552
5553         if (queue_count < 1) {
5554                 pr_err("alloc_netdev: Unable to allocate device "
5555                        "with zero queues.\n");
5556                 return NULL;
5557         }
5558
5559         alloc_size = sizeof(struct net_device);
5560         if (sizeof_priv) {
5561                 /* ensure 32-byte alignment of private area */
5562                 alloc_size = ALIGN(alloc_size, NETDEV_ALIGN);
5563                 alloc_size += sizeof_priv;
5564         }
5565         /* ensure 32-byte alignment of whole construct */
5566         alloc_size += NETDEV_ALIGN - 1;
5567
5568         p = kzalloc(alloc_size, GFP_KERNEL);
5569         if (!p) {
5570                 printk(KERN_ERR "alloc_netdev: Unable to allocate device.\n");
5571                 return NULL;
5572         }
5573
5574         dev = PTR_ALIGN(p, NETDEV_ALIGN);
5575         dev->padded = (char *)dev - (char *)p;
5576
5577         dev->pcpu_refcnt = alloc_percpu(int);
5578         if (!dev->pcpu_refcnt)
5579                 goto free_p;
5580
5581         if (dev_addr_init(dev))
5582                 goto free_pcpu;
5583
5584         dev_mc_init(dev);
5585         dev_uc_init(dev);
5586
5587         dev_net_set(dev, &init_net);
5588
5589         dev->num_tx_queues = queue_count;
5590         dev->real_num_tx_queues = queue_count;
5591         if (netif_alloc_netdev_queues(dev))
5592                 goto free_pcpu;
5593
5594 #ifdef CONFIG_RPS
5595         dev->num_rx_queues = queue_count;
5596         dev->real_num_rx_queues = queue_count;
5597         if (netif_alloc_rx_queues(dev))
5598                 goto free_pcpu;
5599 #endif
5600
5601         dev->gso_max_size = GSO_MAX_SIZE;
5602
5603         INIT_LIST_HEAD(&dev->ethtool_ntuple_list.list);
5604         dev->ethtool_ntuple_list.count = 0;
5605         INIT_LIST_HEAD(&dev->napi_list);
5606         INIT_LIST_HEAD(&dev->unreg_list);
5607         INIT_LIST_HEAD(&dev->link_watch_list);
5608         dev->priv_flags = IFF_XMIT_DST_RELEASE;
5609         setup(dev);
5610         strcpy(dev->name, name);
5611         return dev;
5612
5613 free_pcpu:
5614         free_percpu(dev->pcpu_refcnt);
5615         kfree(dev->_tx);
5616 #ifdef CONFIG_RPS
5617         kfree(dev->_rx);
5618 #endif
5619
5620 free_p:
5621         kfree(p);
5622         return NULL;
5623 }
5624 EXPORT_SYMBOL(alloc_netdev_mq);
5625
5626 /**
5627  *      free_netdev - free network device
5628  *      @dev: device
5629  *
5630  *      This function does the last stage of destroying an allocated device
5631  *      interface. The reference to the device object is released.
5632  *      If this is the last reference then it will be freed.
5633  */
5634 void free_netdev(struct net_device *dev)
5635 {
5636         struct napi_struct *p, *n;
5637
5638         release_net(dev_net(dev));
5639
5640         kfree(dev->_tx);
5641 #ifdef CONFIG_RPS
5642         kfree(dev->_rx);
5643 #endif
5644
5645         kfree(rcu_dereference_raw(dev->ingress_queue));
5646
5647         /* Flush device addresses */
5648         dev_addr_flush(dev);
5649
5650         /* Clear ethtool n-tuple list */
5651         ethtool_ntuple_flush(dev);
5652
5653         list_for_each_entry_safe(p, n, &dev->napi_list, dev_list)
5654                 netif_napi_del(p);
5655
5656         free_percpu(dev->pcpu_refcnt);
5657         dev->pcpu_refcnt = NULL;
5658
5659         /*  Compatibility with error handling in drivers */
5660         if (dev->reg_state == NETREG_UNINITIALIZED) {
5661                 kfree((char *)dev - dev->padded);
5662                 return;
5663         }
5664
5665         BUG_ON(dev->reg_state != NETREG_UNREGISTERED);
5666         dev->reg_state = NETREG_RELEASED;
5667
5668         /* will free via device release */
5669         put_device(&dev->dev);
5670 }
5671 EXPORT_SYMBOL(free_netdev);
5672
5673 /**
5674  *      synchronize_net -  Synchronize with packet receive processing
5675  *
5676  *      Wait for packets currently being received to be done.
5677  *      Does not block later packets from starting.
5678  */
5679 void synchronize_net(void)
5680 {
5681         might_sleep();
5682         synchronize_rcu();
5683 }
5684 EXPORT_SYMBOL(synchronize_net);
5685
5686 /**
5687  *      unregister_netdevice_queue - remove device from the kernel
5688  *      @dev: device
5689  *      @head: list
5690  *
5691  *      This function shuts down a device interface and removes it
5692  *      from the kernel tables.
5693  *      If head not NULL, device is queued to be unregistered later.
5694  *
5695  *      Callers must hold the rtnl semaphore.  You may want
5696  *      unregister_netdev() instead of this.
5697  */
5698
5699 void unregister_netdevice_queue(struct net_device *dev, struct list_head *head)
5700 {
5701         ASSERT_RTNL();
5702
5703         if (head) {
5704                 list_move_tail(&dev->unreg_list, head);
5705         } else {
5706                 rollback_registered(dev);
5707                 /* Finish processing unregister after unlock */
5708                 net_set_todo(dev);
5709         }
5710 }
5711 EXPORT_SYMBOL(unregister_netdevice_queue);
5712
5713 /**
5714  *      unregister_netdevice_many - unregister many devices
5715  *      @head: list of devices
5716  */
5717 void unregister_netdevice_many(struct list_head *head)
5718 {
5719         struct net_device *dev;
5720
5721         if (!list_empty(head)) {
5722                 rollback_registered_many(head);
5723                 list_for_each_entry(dev, head, unreg_list)
5724                         net_set_todo(dev);
5725         }
5726 }
5727 EXPORT_SYMBOL(unregister_netdevice_many);
5728
5729 /**
5730  *      unregister_netdev - remove device from the kernel
5731  *      @dev: device
5732  *
5733  *      This function shuts down a device interface and removes it
5734  *      from the kernel tables.
5735  *
5736  *      This is just a wrapper for unregister_netdevice that takes
5737  *      the rtnl semaphore.  In general you want to use this and not
5738  *      unregister_netdevice.
5739  */
5740 void unregister_netdev(struct net_device *dev)
5741 {
5742         rtnl_lock();
5743         unregister_netdevice(dev);
5744         rtnl_unlock();
5745 }
5746 EXPORT_SYMBOL(unregister_netdev);
5747
5748 /**
5749  *      dev_change_net_namespace - move device to different nethost namespace
5750  *      @dev: device
5751  *      @net: network namespace
5752  *      @pat: If not NULL name pattern to try if the current device name
5753  *            is already taken in the destination network namespace.
5754  *
5755  *      This function shuts down a device interface and moves it
5756  *      to a new network namespace. On success 0 is returned, on
5757  *      a failure a netagive errno code is returned.
5758  *
5759  *      Callers must hold the rtnl semaphore.
5760  */
5761
5762 int dev_change_net_namespace(struct net_device *dev, struct net *net, const char *pat)
5763 {
5764         int err;
5765
5766         ASSERT_RTNL();
5767
5768         /* Don't allow namespace local devices to be moved. */
5769         err = -EINVAL;
5770         if (dev->features & NETIF_F_NETNS_LOCAL)
5771                 goto out;
5772
5773         /* Ensure the device has been registrered */
5774         err = -EINVAL;
5775         if (dev->reg_state != NETREG_REGISTERED)
5776                 goto out;
5777
5778         /* Get out if there is nothing todo */
5779         err = 0;
5780         if (net_eq(dev_net(dev), net))
5781                 goto out;
5782
5783         /* Pick the destination device name, and ensure
5784          * we can use it in the destination network namespace.
5785          */
5786         err = -EEXIST;
5787         if (__dev_get_by_name(net, dev->name)) {
5788                 /* We get here if we can't use the current device name */
5789                 if (!pat)
5790                         goto out;
5791                 if (dev_get_valid_name(dev, pat, 1))
5792                         goto out;
5793         }
5794
5795         /*
5796          * And now a mini version of register_netdevice unregister_netdevice.
5797          */
5798
5799         /* If device is running close it first. */
5800         dev_close(dev);
5801
5802         /* And unlink it from device chain */
5803         err = -ENODEV;
5804         unlist_netdevice(dev);
5805
5806         synchronize_net();
5807
5808         /* Shutdown queueing discipline. */
5809         dev_shutdown(dev);
5810
5811         /* Notify protocols, that we are about to destroy
5812            this device. They should clean all the things.
5813
5814            Note that dev->reg_state stays at NETREG_REGISTERED.
5815            This is wanted because this way 8021q and macvlan know
5816            the device is just moving and can keep their slaves up.
5817         */
5818         call_netdevice_notifiers(NETDEV_UNREGISTER, dev);
5819         call_netdevice_notifiers(NETDEV_UNREGISTER_BATCH, dev);
5820
5821         /*
5822          *      Flush the unicast and multicast chains
5823          */
5824         dev_uc_flush(dev);
5825         dev_mc_flush(dev);
5826
5827         /* Actually switch the network namespace */
5828         dev_net_set(dev, net);
5829
5830         /* If there is an ifindex conflict assign a new one */
5831         if (__dev_get_by_index(net, dev->ifindex)) {
5832                 int iflink = (dev->iflink == dev->ifindex);
5833                 dev->ifindex = dev_new_index(net);
5834                 if (iflink)
5835                         dev->iflink = dev->ifindex;
5836         }
5837
5838         /* Fixup kobjects */
5839         err = device_rename(&dev->dev, dev->name);
5840         WARN_ON(err);
5841
5842         /* Add the device back in the hashes */
5843         list_netdevice(dev);
5844
5845         /* Notify protocols, that a new device appeared. */
5846         call_netdevice_notifiers(NETDEV_REGISTER, dev);
5847
5848         /*
5849          *      Prevent userspace races by waiting until the network
5850          *      device is fully setup before sending notifications.
5851          */
5852         rtmsg_ifinfo(RTM_NEWLINK, dev, ~0U);
5853
5854         synchronize_net();
5855         err = 0;
5856 out:
5857         return err;
5858 }
5859 EXPORT_SYMBOL_GPL(dev_change_net_namespace);
5860
5861 static int dev_cpu_callback(struct notifier_block *nfb,
5862                             unsigned long action,
5863                             void *ocpu)
5864 {
5865         struct sk_buff **list_skb;
5866         struct sk_buff *skb;
5867         unsigned int cpu, oldcpu = (unsigned long)ocpu;
5868         struct softnet_data *sd, *oldsd;
5869
5870         if (action != CPU_DEAD && action != CPU_DEAD_FROZEN)
5871                 return NOTIFY_OK;
5872
5873         local_irq_disable();
5874         cpu = smp_processor_id();
5875         sd = &per_cpu(softnet_data, cpu);
5876         oldsd = &per_cpu(softnet_data, oldcpu);
5877
5878         /* Find end of our completion_queue. */
5879         list_skb = &sd->completion_queue;
5880         while (*list_skb)
5881                 list_skb = &(*list_skb)->next;
5882         /* Append completion queue from offline CPU. */
5883         *list_skb = oldsd->completion_queue;
5884         oldsd->completion_queue = NULL;
5885
5886         /* Append output queue from offline CPU. */
5887         if (oldsd->output_queue) {
5888                 *sd->output_queue_tailp = oldsd->output_queue;
5889                 sd->output_queue_tailp = oldsd->output_queue_tailp;
5890                 oldsd->output_queue = NULL;
5891                 oldsd->output_queue_tailp = &oldsd->output_queue;
5892         }
5893
5894         raise_softirq_irqoff(NET_TX_SOFTIRQ);
5895         local_irq_enable();
5896
5897         /* Process offline CPU's input_pkt_queue */
5898         while ((skb = __skb_dequeue(&oldsd->process_queue))) {
5899                 netif_rx(skb);
5900                 input_queue_head_incr(oldsd);
5901         }
5902         while ((skb = __skb_dequeue(&oldsd->input_pkt_queue))) {
5903                 netif_rx(skb);
5904                 input_queue_head_incr(oldsd);
5905         }
5906
5907         return NOTIFY_OK;
5908 }
5909
5910
5911 /**
5912  *      netdev_increment_features - increment feature set by one
5913  *      @all: current feature set
5914  *      @one: new feature set
5915  *      @mask: mask feature set
5916  *
5917  *      Computes a new feature set after adding a device with feature set
5918  *      @one to the master device with current feature set @all.  Will not
5919  *      enable anything that is off in @mask. Returns the new feature set.
5920  */
5921 unsigned long netdev_increment_features(unsigned long all, unsigned long one,
5922                                         unsigned long mask)
5923 {
5924         /* If device needs checksumming, downgrade to it. */
5925         if (all & NETIF_F_NO_CSUM && !(one & NETIF_F_NO_CSUM))
5926                 all ^= NETIF_F_NO_CSUM | (one & NETIF_F_ALL_CSUM);
5927         else if (mask & NETIF_F_ALL_CSUM) {
5928                 /* If one device supports v4/v6 checksumming, set for all. */
5929                 if (one & (NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM) &&
5930                     !(all & NETIF_F_GEN_CSUM)) {
5931                         all &= ~NETIF_F_ALL_CSUM;
5932                         all |= one & (NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM);
5933                 }
5934
5935                 /* If one device supports hw checksumming, set for all. */
5936                 if (one & NETIF_F_GEN_CSUM && !(all & NETIF_F_GEN_CSUM)) {
5937                         all &= ~NETIF_F_ALL_CSUM;
5938                         all |= NETIF_F_HW_CSUM;
5939                 }
5940         }
5941
5942         one |= NETIF_F_ALL_CSUM;
5943
5944         one |= all & NETIF_F_ONE_FOR_ALL;
5945         all &= one | NETIF_F_LLTX | NETIF_F_GSO | NETIF_F_UFO;
5946         all |= one & mask & NETIF_F_ONE_FOR_ALL;
5947
5948         return all;
5949 }
5950 EXPORT_SYMBOL(netdev_increment_features);
5951
5952 static struct hlist_head *netdev_create_hash(void)
5953 {
5954         int i;
5955         struct hlist_head *hash;
5956
5957         hash = kmalloc(sizeof(*hash) * NETDEV_HASHENTRIES, GFP_KERNEL);
5958         if (hash != NULL)
5959                 for (i = 0; i < NETDEV_HASHENTRIES; i++)
5960                         INIT_HLIST_HEAD(&hash[i]);
5961
5962         return hash;
5963 }
5964
5965 /* Initialize per network namespace state */
5966 static int __net_init netdev_init(struct net *net)
5967 {
5968         INIT_LIST_HEAD(&net->dev_base_head);
5969
5970         net->dev_name_head = netdev_create_hash();
5971         if (net->dev_name_head == NULL)
5972                 goto err_name;
5973
5974         net->dev_index_head = netdev_create_hash();
5975         if (net->dev_index_head == NULL)
5976                 goto err_idx;
5977
5978         return 0;
5979
5980 err_idx:
5981         kfree(net->dev_name_head);
5982 err_name:
5983         return -ENOMEM;
5984 }
5985
5986 /**
5987  *      netdev_drivername - network driver for the device
5988  *      @dev: network device
5989  *      @buffer: buffer for resulting name
5990  *      @len: size of buffer
5991  *
5992  *      Determine network driver for device.
5993  */
5994 char *netdev_drivername(const struct net_device *dev, char *buffer, int len)
5995 {
5996         const struct device_driver *driver;
5997         const struct device *parent;
5998
5999         if (len <= 0 || !buffer)
6000                 return buffer;
6001         buffer[0] = 0;
6002
6003         parent = dev->dev.parent;
6004
6005         if (!parent)
6006                 return buffer;
6007
6008         driver = parent->driver;
6009         if (driver && driver->name)
6010                 strlcpy(buffer, driver->name, len);
6011         return buffer;
6012 }
6013
6014 static int __netdev_printk(const char *level, const struct net_device *dev,
6015                            struct va_format *vaf)
6016 {
6017         int r;
6018
6019         if (dev && dev->dev.parent)
6020                 r = dev_printk(level, dev->dev.parent, "%s: %pV",
6021                                netdev_name(dev), vaf);
6022         else if (dev)
6023                 r = printk("%s%s: %pV", level, netdev_name(dev), vaf);
6024         else
6025                 r = printk("%s(NULL net_device): %pV", level, vaf);
6026
6027         return r;
6028 }
6029
6030 int netdev_printk(const char *level, const struct net_device *dev,
6031                   const char *format, ...)
6032 {
6033         struct va_format vaf;
6034         va_list args;
6035         int r;
6036
6037         va_start(args, format);
6038
6039         vaf.fmt = format;
6040         vaf.va = &args;
6041
6042         r = __netdev_printk(level, dev, &vaf);
6043         va_end(args);
6044
6045         return r;
6046 }
6047 EXPORT_SYMBOL(netdev_printk);
6048
6049 #define define_netdev_printk_level(func, level)                 \
6050 int func(const struct net_device *dev, const char *fmt, ...)    \
6051 {                                                               \
6052         int r;                                                  \
6053         struct va_format vaf;                                   \
6054         va_list args;                                           \
6055                                                                 \
6056         va_start(args, fmt);                                    \
6057                                                                 \
6058         vaf.fmt = fmt;                                          \
6059         vaf.va = &args;                                         \
6060                                                                 \
6061         r = __netdev_printk(level, dev, &vaf);                  \
6062         va_end(args);                                           \
6063                                                                 \
6064         return r;                                               \
6065 }                                                               \
6066 EXPORT_SYMBOL(func);
6067
6068 define_netdev_printk_level(netdev_emerg, KERN_EMERG);
6069 define_netdev_printk_level(netdev_alert, KERN_ALERT);
6070 define_netdev_printk_level(netdev_crit, KERN_CRIT);
6071 define_netdev_printk_level(netdev_err, KERN_ERR);
6072 define_netdev_printk_level(netdev_warn, KERN_WARNING);
6073 define_netdev_printk_level(netdev_notice, KERN_NOTICE);
6074 define_netdev_printk_level(netdev_info, KERN_INFO);
6075
6076 static void __net_exit netdev_exit(struct net *net)
6077 {
6078         kfree(net->dev_name_head);
6079         kfree(net->dev_index_head);
6080 }
6081
6082 static struct pernet_operations __net_initdata netdev_net_ops = {
6083         .init = netdev_init,
6084         .exit = netdev_exit,
6085 };
6086
6087 static void __net_exit default_device_exit(struct net *net)
6088 {
6089         struct net_device *dev, *aux;
6090         /*
6091          * Push all migratable network devices back to the
6092          * initial network namespace
6093          */
6094         rtnl_lock();
6095         for_each_netdev_safe(net, dev, aux) {
6096                 int err;
6097                 char fb_name[IFNAMSIZ];
6098
6099                 /* Ignore unmoveable devices (i.e. loopback) */
6100                 if (dev->features & NETIF_F_NETNS_LOCAL)
6101                         continue;
6102
6103                 /* Leave virtual devices for the generic cleanup */
6104                 if (dev->rtnl_link_ops)
6105                         continue;
6106
6107                 /* Push remaing network devices to init_net */
6108                 snprintf(fb_name, IFNAMSIZ, "dev%d", dev->ifindex);
6109                 err = dev_change_net_namespace(dev, &init_net, fb_name);
6110                 if (err) {
6111                         printk(KERN_EMERG "%s: failed to move %s to init_net: %d\n",
6112                                 __func__, dev->name, err);
6113                         BUG();
6114                 }
6115         }
6116         rtnl_unlock();
6117 }
6118
6119 static void __net_exit default_device_exit_batch(struct list_head *net_list)
6120 {
6121         /* At exit all network devices most be removed from a network
6122          * namespace.  Do this in the reverse order of registeration.
6123          * Do this across as many network namespaces as possible to
6124          * improve batching efficiency.
6125          */
6126         struct net_device *dev;
6127         struct net *net;
6128         LIST_HEAD(dev_kill_list);
6129
6130         rtnl_lock();
6131         list_for_each_entry(net, net_list, exit_list) {
6132                 for_each_netdev_reverse(net, dev) {
6133                         if (dev->rtnl_link_ops)
6134                                 dev->rtnl_link_ops->dellink(dev, &dev_kill_list);
6135                         else
6136                                 unregister_netdevice_queue(dev, &dev_kill_list);
6137                 }
6138         }
6139         unregister_netdevice_many(&dev_kill_list);
6140         rtnl_unlock();
6141 }
6142
6143 static struct pernet_operations __net_initdata default_device_ops = {
6144         .exit = default_device_exit,
6145         .exit_batch = default_device_exit_batch,
6146 };
6147
6148 /*
6149  *      Initialize the DEV module. At boot time this walks the device list and
6150  *      unhooks any devices that fail to initialise (normally hardware not
6151  *      present) and leaves us with a valid list of present and active devices.
6152  *
6153  */
6154
6155 /*
6156  *       This is called single threaded during boot, so no need
6157  *       to take the rtnl semaphore.
6158  */
6159 static int __init net_dev_init(void)
6160 {
6161         int i, rc = -ENOMEM;
6162
6163         BUG_ON(!dev_boot_phase);
6164
6165         if (dev_proc_init())
6166                 goto out;
6167
6168         if (netdev_kobject_init())
6169                 goto out;
6170
6171         INIT_LIST_HEAD(&ptype_all);
6172         for (i = 0; i < PTYPE_HASH_SIZE; i++)
6173                 INIT_LIST_HEAD(&ptype_base[i]);
6174
6175         if (register_pernet_subsys(&netdev_net_ops))
6176                 goto out;
6177
6178         /*
6179          *      Initialise the packet receive queues.
6180          */
6181
6182         for_each_possible_cpu(i) {
6183                 struct softnet_data *sd = &per_cpu(softnet_data, i);
6184
6185                 memset(sd, 0, sizeof(*sd));
6186                 skb_queue_head_init(&sd->input_pkt_queue);
6187                 skb_queue_head_init(&sd->process_queue);
6188                 sd->completion_queue = NULL;
6189                 INIT_LIST_HEAD(&sd->poll_list);
6190                 sd->output_queue = NULL;
6191                 sd->output_queue_tailp = &sd->output_queue;
6192 #ifdef CONFIG_RPS
6193                 sd->csd.func = rps_trigger_softirq;
6194                 sd->csd.info = sd;
6195                 sd->csd.flags = 0;
6196                 sd->cpu = i;
6197 #endif
6198
6199                 sd->backlog.poll = process_backlog;
6200                 sd->backlog.weight = weight_p;
6201                 sd->backlog.gro_list = NULL;
6202                 sd->backlog.gro_count = 0;
6203         }
6204
6205         dev_boot_phase = 0;
6206
6207         /* The loopback device is special if any other network devices
6208          * is present in a network namespace the loopback device must
6209          * be present. Since we now dynamically allocate and free the
6210          * loopback device ensure this invariant is maintained by
6211          * keeping the loopback device as the first device on the
6212          * list of network devices.  Ensuring the loopback devices
6213          * is the first device that appears and the last network device
6214          * that disappears.
6215          */
6216         if (register_pernet_device(&loopback_net_ops))
6217                 goto out;
6218
6219         if (register_pernet_device(&default_device_ops))
6220                 goto out;
6221
6222         open_softirq(NET_TX_SOFTIRQ, net_tx_action);
6223         open_softirq(NET_RX_SOFTIRQ, net_rx_action);
6224
6225         hotcpu_notifier(dev_cpu_callback, 0);
6226         dst_init();
6227         dev_mcast_init();
6228         rc = 0;
6229 out:
6230         return rc;
6231 }
6232
6233 subsys_initcall(net_dev_init);
6234
6235 static int __init initialize_hashrnd(void)
6236 {
6237         get_random_bytes(&hashrnd, sizeof(hashrnd));
6238         return 0;
6239 }
6240
6241 late_initcall_sync(initialize_hashrnd);
6242