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