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