net: Enable 64-bit net device statistics on 32-bit architectures
[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                                                skb2->protocol, dev->name);
1541                                 skb_reset_network_header(skb2);
1542                         }
1543
1544                         skb2->transport_header = skb2->network_header;
1545                         skb2->pkt_type = PACKET_OUTGOING;
1546                         ptype->func(skb2, skb->dev, ptype, skb->dev);
1547                 }
1548         }
1549         rcu_read_unlock();
1550 }
1551
1552
1553 static inline void __netif_reschedule(struct Qdisc *q)
1554 {
1555         struct softnet_data *sd;
1556         unsigned long flags;
1557
1558         local_irq_save(flags);
1559         sd = &__get_cpu_var(softnet_data);
1560         q->next_sched = NULL;
1561         *sd->output_queue_tailp = q;
1562         sd->output_queue_tailp = &q->next_sched;
1563         raise_softirq_irqoff(NET_TX_SOFTIRQ);
1564         local_irq_restore(flags);
1565 }
1566
1567 void __netif_schedule(struct Qdisc *q)
1568 {
1569         if (!test_and_set_bit(__QDISC_STATE_SCHED, &q->state))
1570                 __netif_reschedule(q);
1571 }
1572 EXPORT_SYMBOL(__netif_schedule);
1573
1574 void dev_kfree_skb_irq(struct sk_buff *skb)
1575 {
1576         if (!skb->destructor)
1577                 dev_kfree_skb(skb);
1578         else if (atomic_dec_and_test(&skb->users)) {
1579                 struct softnet_data *sd;
1580                 unsigned long flags;
1581
1582                 local_irq_save(flags);
1583                 sd = &__get_cpu_var(softnet_data);
1584                 skb->next = sd->completion_queue;
1585                 sd->completion_queue = skb;
1586                 raise_softirq_irqoff(NET_TX_SOFTIRQ);
1587                 local_irq_restore(flags);
1588         }
1589 }
1590 EXPORT_SYMBOL(dev_kfree_skb_irq);
1591
1592 void dev_kfree_skb_any(struct sk_buff *skb)
1593 {
1594         if (in_irq() || irqs_disabled())
1595                 dev_kfree_skb_irq(skb);
1596         else
1597                 dev_kfree_skb(skb);
1598 }
1599 EXPORT_SYMBOL(dev_kfree_skb_any);
1600
1601
1602 /**
1603  * netif_device_detach - mark device as removed
1604  * @dev: network device
1605  *
1606  * Mark device as removed from system and therefore no longer available.
1607  */
1608 void netif_device_detach(struct net_device *dev)
1609 {
1610         if (test_and_clear_bit(__LINK_STATE_PRESENT, &dev->state) &&
1611             netif_running(dev)) {
1612                 netif_tx_stop_all_queues(dev);
1613         }
1614 }
1615 EXPORT_SYMBOL(netif_device_detach);
1616
1617 /**
1618  * netif_device_attach - mark device as attached
1619  * @dev: network device
1620  *
1621  * Mark device as attached from system and restart if needed.
1622  */
1623 void netif_device_attach(struct net_device *dev)
1624 {
1625         if (!test_and_set_bit(__LINK_STATE_PRESENT, &dev->state) &&
1626             netif_running(dev)) {
1627                 netif_tx_wake_all_queues(dev);
1628                 __netdev_watchdog_up(dev);
1629         }
1630 }
1631 EXPORT_SYMBOL(netif_device_attach);
1632
1633 static bool can_checksum_protocol(unsigned long features, __be16 protocol)
1634 {
1635         return ((features & NETIF_F_GEN_CSUM) ||
1636                 ((features & NETIF_F_IP_CSUM) &&
1637                  protocol == htons(ETH_P_IP)) ||
1638                 ((features & NETIF_F_IPV6_CSUM) &&
1639                  protocol == htons(ETH_P_IPV6)) ||
1640                 ((features & NETIF_F_FCOE_CRC) &&
1641                  protocol == htons(ETH_P_FCOE)));
1642 }
1643
1644 static bool dev_can_checksum(struct net_device *dev, struct sk_buff *skb)
1645 {
1646         if (can_checksum_protocol(dev->features, skb->protocol))
1647                 return true;
1648
1649         if (skb->protocol == htons(ETH_P_8021Q)) {
1650                 struct vlan_ethhdr *veh = (struct vlan_ethhdr *)skb->data;
1651                 if (can_checksum_protocol(dev->features & dev->vlan_features,
1652                                           veh->h_vlan_encapsulated_proto))
1653                         return true;
1654         }
1655
1656         return false;
1657 }
1658
1659 /**
1660  * skb_dev_set -- assign a new device to a buffer
1661  * @skb: buffer for the new device
1662  * @dev: network device
1663  *
1664  * If an skb is owned by a device already, we have to reset
1665  * all data private to the namespace a device belongs to
1666  * before assigning it a new device.
1667  */
1668 #ifdef CONFIG_NET_NS
1669 void skb_set_dev(struct sk_buff *skb, struct net_device *dev)
1670 {
1671         skb_dst_drop(skb);
1672         if (skb->dev && !net_eq(dev_net(skb->dev), dev_net(dev))) {
1673                 secpath_reset(skb);
1674                 nf_reset(skb);
1675                 skb_init_secmark(skb);
1676                 skb->mark = 0;
1677                 skb->priority = 0;
1678                 skb->nf_trace = 0;
1679                 skb->ipvs_property = 0;
1680 #ifdef CONFIG_NET_SCHED
1681                 skb->tc_index = 0;
1682 #endif
1683         }
1684         skb->dev = dev;
1685 }
1686 EXPORT_SYMBOL(skb_set_dev);
1687 #endif /* CONFIG_NET_NS */
1688
1689 /*
1690  * Invalidate hardware checksum when packet is to be mangled, and
1691  * complete checksum manually on outgoing path.
1692  */
1693 int skb_checksum_help(struct sk_buff *skb)
1694 {
1695         __wsum csum;
1696         int ret = 0, offset;
1697
1698         if (skb->ip_summed == CHECKSUM_COMPLETE)
1699                 goto out_set_summed;
1700
1701         if (unlikely(skb_shinfo(skb)->gso_size)) {
1702                 /* Let GSO fix up the checksum. */
1703                 goto out_set_summed;
1704         }
1705
1706         offset = skb->csum_start - skb_headroom(skb);
1707         BUG_ON(offset >= skb_headlen(skb));
1708         csum = skb_checksum(skb, offset, skb->len - offset, 0);
1709
1710         offset += skb->csum_offset;
1711         BUG_ON(offset + sizeof(__sum16) > skb_headlen(skb));
1712
1713         if (skb_cloned(skb) &&
1714             !skb_clone_writable(skb, offset + sizeof(__sum16))) {
1715                 ret = pskb_expand_head(skb, 0, 0, GFP_ATOMIC);
1716                 if (ret)
1717                         goto out;
1718         }
1719
1720         *(__sum16 *)(skb->data + offset) = csum_fold(csum);
1721 out_set_summed:
1722         skb->ip_summed = CHECKSUM_NONE;
1723 out:
1724         return ret;
1725 }
1726 EXPORT_SYMBOL(skb_checksum_help);
1727
1728 /**
1729  *      skb_gso_segment - Perform segmentation on skb.
1730  *      @skb: buffer to segment
1731  *      @features: features for the output path (see dev->features)
1732  *
1733  *      This function segments the given skb and returns a list of segments.
1734  *
1735  *      It may return NULL if the skb requires no segmentation.  This is
1736  *      only possible when GSO is used for verifying header integrity.
1737  */
1738 struct sk_buff *skb_gso_segment(struct sk_buff *skb, int features)
1739 {
1740         struct sk_buff *segs = ERR_PTR(-EPROTONOSUPPORT);
1741         struct packet_type *ptype;
1742         __be16 type = skb->protocol;
1743         int err;
1744
1745         skb_reset_mac_header(skb);
1746         skb->mac_len = skb->network_header - skb->mac_header;
1747         __skb_pull(skb, skb->mac_len);
1748
1749         if (unlikely(skb->ip_summed != CHECKSUM_PARTIAL)) {
1750                 struct net_device *dev = skb->dev;
1751                 struct ethtool_drvinfo info = {};
1752
1753                 if (dev && dev->ethtool_ops && dev->ethtool_ops->get_drvinfo)
1754                         dev->ethtool_ops->get_drvinfo(dev, &info);
1755
1756                 WARN(1, "%s: caps=(0x%lx, 0x%lx) len=%d data_len=%d "
1757                         "ip_summed=%d",
1758                      info.driver, dev ? dev->features : 0L,
1759                      skb->sk ? skb->sk->sk_route_caps : 0L,
1760                      skb->len, skb->data_len, skb->ip_summed);
1761
1762                 if (skb_header_cloned(skb) &&
1763                     (err = pskb_expand_head(skb, 0, 0, GFP_ATOMIC)))
1764                         return ERR_PTR(err);
1765         }
1766
1767         rcu_read_lock();
1768         list_for_each_entry_rcu(ptype,
1769                         &ptype_base[ntohs(type) & PTYPE_HASH_MASK], list) {
1770                 if (ptype->type == type && !ptype->dev && ptype->gso_segment) {
1771                         if (unlikely(skb->ip_summed != CHECKSUM_PARTIAL)) {
1772                                 err = ptype->gso_send_check(skb);
1773                                 segs = ERR_PTR(err);
1774                                 if (err || skb_gso_ok(skb, features))
1775                                         break;
1776                                 __skb_push(skb, (skb->data -
1777                                                  skb_network_header(skb)));
1778                         }
1779                         segs = ptype->gso_segment(skb, features);
1780                         break;
1781                 }
1782         }
1783         rcu_read_unlock();
1784
1785         __skb_push(skb, skb->data - skb_mac_header(skb));
1786
1787         return segs;
1788 }
1789 EXPORT_SYMBOL(skb_gso_segment);
1790
1791 /* Take action when hardware reception checksum errors are detected. */
1792 #ifdef CONFIG_BUG
1793 void netdev_rx_csum_fault(struct net_device *dev)
1794 {
1795         if (net_ratelimit()) {
1796                 printk(KERN_ERR "%s: hw csum failure.\n",
1797                         dev ? dev->name : "<unknown>");
1798                 dump_stack();
1799         }
1800 }
1801 EXPORT_SYMBOL(netdev_rx_csum_fault);
1802 #endif
1803
1804 /* Actually, we should eliminate this check as soon as we know, that:
1805  * 1. IOMMU is present and allows to map all the memory.
1806  * 2. No high memory really exists on this machine.
1807  */
1808
1809 static int illegal_highdma(struct net_device *dev, struct sk_buff *skb)
1810 {
1811 #ifdef CONFIG_HIGHMEM
1812         int i;
1813         if (!(dev->features & NETIF_F_HIGHDMA)) {
1814                 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++)
1815                         if (PageHighMem(skb_shinfo(skb)->frags[i].page))
1816                                 return 1;
1817         }
1818
1819         if (PCI_DMA_BUS_IS_PHYS) {
1820                 struct device *pdev = dev->dev.parent;
1821
1822                 if (!pdev)
1823                         return 0;
1824                 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
1825                         dma_addr_t addr = page_to_phys(skb_shinfo(skb)->frags[i].page);
1826                         if (!pdev->dma_mask || addr + PAGE_SIZE - 1 > *pdev->dma_mask)
1827                                 return 1;
1828                 }
1829         }
1830 #endif
1831         return 0;
1832 }
1833
1834 struct dev_gso_cb {
1835         void (*destructor)(struct sk_buff *skb);
1836 };
1837
1838 #define DEV_GSO_CB(skb) ((struct dev_gso_cb *)(skb)->cb)
1839
1840 static void dev_gso_skb_destructor(struct sk_buff *skb)
1841 {
1842         struct dev_gso_cb *cb;
1843
1844         do {
1845                 struct sk_buff *nskb = skb->next;
1846
1847                 skb->next = nskb->next;
1848                 nskb->next = NULL;
1849                 kfree_skb(nskb);
1850         } while (skb->next);
1851
1852         cb = DEV_GSO_CB(skb);
1853         if (cb->destructor)
1854                 cb->destructor(skb);
1855 }
1856
1857 /**
1858  *      dev_gso_segment - Perform emulated hardware segmentation on skb.
1859  *      @skb: buffer to segment
1860  *
1861  *      This function segments the given skb and stores the list of segments
1862  *      in skb->next.
1863  */
1864 static int dev_gso_segment(struct sk_buff *skb)
1865 {
1866         struct net_device *dev = skb->dev;
1867         struct sk_buff *segs;
1868         int features = dev->features & ~(illegal_highdma(dev, skb) ?
1869                                          NETIF_F_SG : 0);
1870
1871         segs = skb_gso_segment(skb, features);
1872
1873         /* Verifying header integrity only. */
1874         if (!segs)
1875                 return 0;
1876
1877         if (IS_ERR(segs))
1878                 return PTR_ERR(segs);
1879
1880         skb->next = segs;
1881         DEV_GSO_CB(skb)->destructor = skb->destructor;
1882         skb->destructor = dev_gso_skb_destructor;
1883
1884         return 0;
1885 }
1886
1887 /*
1888  * Try to orphan skb early, right before transmission by the device.
1889  * We cannot orphan skb if tx timestamp is requested, since
1890  * drivers need to call skb_tstamp_tx() to send the timestamp.
1891  */
1892 static inline void skb_orphan_try(struct sk_buff *skb)
1893 {
1894         if (!skb_tx(skb)->flags)
1895                 skb_orphan(skb);
1896 }
1897
1898 int dev_hard_start_xmit(struct sk_buff *skb, struct net_device *dev,
1899                         struct netdev_queue *txq)
1900 {
1901         const struct net_device_ops *ops = dev->netdev_ops;
1902         int rc = NETDEV_TX_OK;
1903
1904         if (likely(!skb->next)) {
1905                 if (!list_empty(&ptype_all))
1906                         dev_queue_xmit_nit(skb, dev);
1907
1908                 /*
1909                  * If device doesnt need skb->dst, release it right now while
1910                  * its hot in this cpu cache
1911                  */
1912                 if (dev->priv_flags & IFF_XMIT_DST_RELEASE)
1913                         skb_dst_drop(skb);
1914
1915                 skb_orphan_try(skb);
1916
1917                 if (netif_needs_gso(dev, skb)) {
1918                         if (unlikely(dev_gso_segment(skb)))
1919                                 goto out_kfree_skb;
1920                         if (skb->next)
1921                                 goto gso;
1922                 }
1923
1924                 rc = ops->ndo_start_xmit(skb, dev);
1925                 if (rc == NETDEV_TX_OK)
1926                         txq_trans_update(txq);
1927                 return rc;
1928         }
1929
1930 gso:
1931         do {
1932                 struct sk_buff *nskb = skb->next;
1933
1934                 skb->next = nskb->next;
1935                 nskb->next = NULL;
1936
1937                 /*
1938                  * If device doesnt need nskb->dst, release it right now while
1939                  * its hot in this cpu cache
1940                  */
1941                 if (dev->priv_flags & IFF_XMIT_DST_RELEASE)
1942                         skb_dst_drop(nskb);
1943
1944                 rc = ops->ndo_start_xmit(nskb, dev);
1945                 if (unlikely(rc != NETDEV_TX_OK)) {
1946                         if (rc & ~NETDEV_TX_MASK)
1947                                 goto out_kfree_gso_skb;
1948                         nskb->next = skb->next;
1949                         skb->next = nskb;
1950                         return rc;
1951                 }
1952                 txq_trans_update(txq);
1953                 if (unlikely(netif_tx_queue_stopped(txq) && skb->next))
1954                         return NETDEV_TX_BUSY;
1955         } while (skb->next);
1956
1957 out_kfree_gso_skb:
1958         if (likely(skb->next == NULL))
1959                 skb->destructor = DEV_GSO_CB(skb)->destructor;
1960 out_kfree_skb:
1961         kfree_skb(skb);
1962         return rc;
1963 }
1964
1965 static u32 hashrnd __read_mostly;
1966
1967 u16 skb_tx_hash(const struct net_device *dev, const struct sk_buff *skb)
1968 {
1969         u32 hash;
1970
1971         if (skb_rx_queue_recorded(skb)) {
1972                 hash = skb_get_rx_queue(skb);
1973                 while (unlikely(hash >= dev->real_num_tx_queues))
1974                         hash -= dev->real_num_tx_queues;
1975                 return hash;
1976         }
1977
1978         if (skb->sk && skb->sk->sk_hash)
1979                 hash = skb->sk->sk_hash;
1980         else
1981                 hash = (__force u16) skb->protocol;
1982
1983         hash = jhash_1word(hash, hashrnd);
1984
1985         return (u16) (((u64) hash * dev->real_num_tx_queues) >> 32);
1986 }
1987 EXPORT_SYMBOL(skb_tx_hash);
1988
1989 static inline u16 dev_cap_txqueue(struct net_device *dev, u16 queue_index)
1990 {
1991         if (unlikely(queue_index >= dev->real_num_tx_queues)) {
1992                 if (net_ratelimit()) {
1993                         pr_warning("%s selects TX queue %d, but "
1994                                 "real number of TX queues is %d\n",
1995                                 dev->name, queue_index, dev->real_num_tx_queues);
1996                 }
1997                 return 0;
1998         }
1999         return queue_index;
2000 }
2001
2002 static struct netdev_queue *dev_pick_tx(struct net_device *dev,
2003                                         struct sk_buff *skb)
2004 {
2005         u16 queue_index;
2006         struct sock *sk = skb->sk;
2007
2008         if (sk_tx_queue_recorded(sk)) {
2009                 queue_index = sk_tx_queue_get(sk);
2010         } else {
2011                 const struct net_device_ops *ops = dev->netdev_ops;
2012
2013                 if (ops->ndo_select_queue) {
2014                         queue_index = ops->ndo_select_queue(dev, skb);
2015                         queue_index = dev_cap_txqueue(dev, queue_index);
2016                 } else {
2017                         queue_index = 0;
2018                         if (dev->real_num_tx_queues > 1)
2019                                 queue_index = skb_tx_hash(dev, skb);
2020
2021                         if (sk) {
2022                                 struct dst_entry *dst = rcu_dereference_check(sk->sk_dst_cache, 1);
2023
2024                                 if (dst && skb_dst(skb) == dst)
2025                                         sk_tx_queue_set(sk, queue_index);
2026                         }
2027                 }
2028         }
2029
2030         skb_set_queue_mapping(skb, queue_index);
2031         return netdev_get_tx_queue(dev, queue_index);
2032 }
2033
2034 static inline int __dev_xmit_skb(struct sk_buff *skb, struct Qdisc *q,
2035                                  struct net_device *dev,
2036                                  struct netdev_queue *txq)
2037 {
2038         spinlock_t *root_lock = qdisc_lock(q);
2039         bool contended = qdisc_is_running(q);
2040         int rc;
2041
2042         /*
2043          * Heuristic to force contended enqueues to serialize on a
2044          * separate lock before trying to get qdisc main lock.
2045          * This permits __QDISC_STATE_RUNNING owner to get the lock more often
2046          * and dequeue packets faster.
2047          */
2048         if (unlikely(contended))
2049                 spin_lock(&q->busylock);
2050
2051         spin_lock(root_lock);
2052         if (unlikely(test_bit(__QDISC_STATE_DEACTIVATED, &q->state))) {
2053                 kfree_skb(skb);
2054                 rc = NET_XMIT_DROP;
2055         } else if ((q->flags & TCQ_F_CAN_BYPASS) && !qdisc_qlen(q) &&
2056                    qdisc_run_begin(q)) {
2057                 /*
2058                  * This is a work-conserving queue; there are no old skbs
2059                  * waiting to be sent out; and the qdisc is not running -
2060                  * xmit the skb directly.
2061                  */
2062                 if (!(dev->priv_flags & IFF_XMIT_DST_RELEASE))
2063                         skb_dst_force(skb);
2064                 __qdisc_update_bstats(q, skb->len);
2065                 if (sch_direct_xmit(skb, q, dev, txq, root_lock)) {
2066                         if (unlikely(contended)) {
2067                                 spin_unlock(&q->busylock);
2068                                 contended = false;
2069                         }
2070                         __qdisc_run(q);
2071                 } else
2072                         qdisc_run_end(q);
2073
2074                 rc = NET_XMIT_SUCCESS;
2075         } else {
2076                 skb_dst_force(skb);
2077                 rc = qdisc_enqueue_root(skb, q);
2078                 if (qdisc_run_begin(q)) {
2079                         if (unlikely(contended)) {
2080                                 spin_unlock(&q->busylock);
2081                                 contended = false;
2082                         }
2083                         __qdisc_run(q);
2084                 }
2085         }
2086         spin_unlock(root_lock);
2087         if (unlikely(contended))
2088                 spin_unlock(&q->busylock);
2089         return rc;
2090 }
2091
2092 /*
2093  * Returns true if either:
2094  *      1. skb has frag_list and the device doesn't support FRAGLIST, or
2095  *      2. skb is fragmented and the device does not support SG, or if
2096  *         at least one of fragments is in highmem and device does not
2097  *         support DMA from it.
2098  */
2099 static inline int skb_needs_linearize(struct sk_buff *skb,
2100                                       struct net_device *dev)
2101 {
2102         return skb_is_nonlinear(skb) &&
2103                ((skb_has_frags(skb) && !(dev->features & NETIF_F_FRAGLIST)) ||
2104                 (skb_shinfo(skb)->nr_frags && (!(dev->features & NETIF_F_SG) ||
2105                                               illegal_highdma(dev, skb))));
2106 }
2107
2108 /**
2109  *      dev_queue_xmit - transmit a buffer
2110  *      @skb: buffer to transmit
2111  *
2112  *      Queue a buffer for transmission to a network device. The caller must
2113  *      have set the device and priority and built the buffer before calling
2114  *      this function. The function can be called from an interrupt.
2115  *
2116  *      A negative errno code is returned on a failure. A success does not
2117  *      guarantee the frame will be transmitted as it may be dropped due
2118  *      to congestion or traffic shaping.
2119  *
2120  * -----------------------------------------------------------------------------------
2121  *      I notice this method can also return errors from the queue disciplines,
2122  *      including NET_XMIT_DROP, which is a positive value.  So, errors can also
2123  *      be positive.
2124  *
2125  *      Regardless of the return value, the skb is consumed, so it is currently
2126  *      difficult to retry a send to this method.  (You can bump the ref count
2127  *      before sending to hold a reference for retry if you are careful.)
2128  *
2129  *      When calling this method, interrupts MUST be enabled.  This is because
2130  *      the BH enable code must have IRQs enabled so that it will not deadlock.
2131  *          --BLG
2132  */
2133 int dev_queue_xmit(struct sk_buff *skb)
2134 {
2135         struct net_device *dev = skb->dev;
2136         struct netdev_queue *txq;
2137         struct Qdisc *q;
2138         int rc = -ENOMEM;
2139
2140         /* GSO will handle the following emulations directly. */
2141         if (netif_needs_gso(dev, skb))
2142                 goto gso;
2143
2144         /* Convert a paged skb to linear, if required */
2145         if (skb_needs_linearize(skb, dev) && __skb_linearize(skb))
2146                 goto out_kfree_skb;
2147
2148         /* If packet is not checksummed and device does not support
2149          * checksumming for this protocol, complete checksumming here.
2150          */
2151         if (skb->ip_summed == CHECKSUM_PARTIAL) {
2152                 skb_set_transport_header(skb, skb->csum_start -
2153                                               skb_headroom(skb));
2154                 if (!dev_can_checksum(dev, skb) && skb_checksum_help(skb))
2155                         goto out_kfree_skb;
2156         }
2157
2158 gso:
2159         /* Disable soft irqs for various locks below. Also
2160          * stops preemption for RCU.
2161          */
2162         rcu_read_lock_bh();
2163
2164         txq = dev_pick_tx(dev, skb);
2165         q = rcu_dereference_bh(txq->qdisc);
2166
2167 #ifdef CONFIG_NET_CLS_ACT
2168         skb->tc_verd = SET_TC_AT(skb->tc_verd, AT_EGRESS);
2169 #endif
2170         if (q->enqueue) {
2171                 rc = __dev_xmit_skb(skb, q, dev, txq);
2172                 goto out;
2173         }
2174
2175         /* The device has no queue. Common case for software devices:
2176            loopback, all the sorts of tunnels...
2177
2178            Really, it is unlikely that netif_tx_lock protection is necessary
2179            here.  (f.e. loopback and IP tunnels are clean ignoring statistics
2180            counters.)
2181            However, it is possible, that they rely on protection
2182            made by us here.
2183
2184            Check this and shot the lock. It is not prone from deadlocks.
2185            Either shot noqueue qdisc, it is even simpler 8)
2186          */
2187         if (dev->flags & IFF_UP) {
2188                 int cpu = smp_processor_id(); /* ok because BHs are off */
2189
2190                 if (txq->xmit_lock_owner != cpu) {
2191
2192                         HARD_TX_LOCK(dev, txq, cpu);
2193
2194                         if (!netif_tx_queue_stopped(txq)) {
2195                                 rc = dev_hard_start_xmit(skb, dev, txq);
2196                                 if (dev_xmit_complete(rc)) {
2197                                         HARD_TX_UNLOCK(dev, txq);
2198                                         goto out;
2199                                 }
2200                         }
2201                         HARD_TX_UNLOCK(dev, txq);
2202                         if (net_ratelimit())
2203                                 printk(KERN_CRIT "Virtual device %s asks to "
2204                                        "queue packet!\n", dev->name);
2205                 } else {
2206                         /* Recursion is detected! It is possible,
2207                          * unfortunately */
2208                         if (net_ratelimit())
2209                                 printk(KERN_CRIT "Dead loop on virtual device "
2210                                        "%s, fix it urgently!\n", dev->name);
2211                 }
2212         }
2213
2214         rc = -ENETDOWN;
2215         rcu_read_unlock_bh();
2216
2217 out_kfree_skb:
2218         kfree_skb(skb);
2219         return rc;
2220 out:
2221         rcu_read_unlock_bh();
2222         return rc;
2223 }
2224 EXPORT_SYMBOL(dev_queue_xmit);
2225
2226
2227 /*=======================================================================
2228                         Receiver routines
2229   =======================================================================*/
2230
2231 int netdev_max_backlog __read_mostly = 1000;
2232 int netdev_tstamp_prequeue __read_mostly = 1;
2233 int netdev_budget __read_mostly = 300;
2234 int weight_p __read_mostly = 64;            /* old backlog weight */
2235
2236 /* Called with irq disabled */
2237 static inline void ____napi_schedule(struct softnet_data *sd,
2238                                      struct napi_struct *napi)
2239 {
2240         list_add_tail(&napi->poll_list, &sd->poll_list);
2241         __raise_softirq_irqoff(NET_RX_SOFTIRQ);
2242 }
2243
2244 #ifdef CONFIG_RPS
2245
2246 /* One global table that all flow-based protocols share. */
2247 struct rps_sock_flow_table *rps_sock_flow_table __read_mostly;
2248 EXPORT_SYMBOL(rps_sock_flow_table);
2249
2250 /*
2251  * get_rps_cpu is called from netif_receive_skb and returns the target
2252  * CPU from the RPS map of the receiving queue for a given skb.
2253  * rcu_read_lock must be held on entry.
2254  */
2255 static int get_rps_cpu(struct net_device *dev, struct sk_buff *skb,
2256                        struct rps_dev_flow **rflowp)
2257 {
2258         struct ipv6hdr *ip6;
2259         struct iphdr *ip;
2260         struct netdev_rx_queue *rxqueue;
2261         struct rps_map *map;
2262         struct rps_dev_flow_table *flow_table;
2263         struct rps_sock_flow_table *sock_flow_table;
2264         int cpu = -1;
2265         u8 ip_proto;
2266         u16 tcpu;
2267         u32 addr1, addr2, ihl;
2268         union {
2269                 u32 v32;
2270                 u16 v16[2];
2271         } ports;
2272
2273         if (skb_rx_queue_recorded(skb)) {
2274                 u16 index = skb_get_rx_queue(skb);
2275                 if (unlikely(index >= dev->num_rx_queues)) {
2276                         WARN_ONCE(dev->num_rx_queues > 1, "%s received packet "
2277                                 "on queue %u, but number of RX queues is %u\n",
2278                                 dev->name, index, dev->num_rx_queues);
2279                         goto done;
2280                 }
2281                 rxqueue = dev->_rx + index;
2282         } else
2283                 rxqueue = dev->_rx;
2284
2285         if (!rxqueue->rps_map && !rxqueue->rps_flow_table)
2286                 goto done;
2287
2288         if (skb->rxhash)
2289                 goto got_hash; /* Skip hash computation on packet header */
2290
2291         switch (skb->protocol) {
2292         case __constant_htons(ETH_P_IP):
2293                 if (!pskb_may_pull(skb, sizeof(*ip)))
2294                         goto done;
2295
2296                 ip = (struct iphdr *) skb->data;
2297                 ip_proto = ip->protocol;
2298                 addr1 = (__force u32) ip->saddr;
2299                 addr2 = (__force u32) ip->daddr;
2300                 ihl = ip->ihl;
2301                 break;
2302         case __constant_htons(ETH_P_IPV6):
2303                 if (!pskb_may_pull(skb, sizeof(*ip6)))
2304                         goto done;
2305
2306                 ip6 = (struct ipv6hdr *) skb->data;
2307                 ip_proto = ip6->nexthdr;
2308                 addr1 = (__force u32) ip6->saddr.s6_addr32[3];
2309                 addr2 = (__force u32) ip6->daddr.s6_addr32[3];
2310                 ihl = (40 >> 2);
2311                 break;
2312         default:
2313                 goto done;
2314         }
2315         switch (ip_proto) {
2316         case IPPROTO_TCP:
2317         case IPPROTO_UDP:
2318         case IPPROTO_DCCP:
2319         case IPPROTO_ESP:
2320         case IPPROTO_AH:
2321         case IPPROTO_SCTP:
2322         case IPPROTO_UDPLITE:
2323                 if (pskb_may_pull(skb, (ihl * 4) + 4)) {
2324                         ports.v32 = * (__force u32 *) (skb->data + (ihl * 4));
2325                         if (ports.v16[1] < ports.v16[0])
2326                                 swap(ports.v16[0], ports.v16[1]);
2327                         break;
2328                 }
2329         default:
2330                 ports.v32 = 0;
2331                 break;
2332         }
2333
2334         /* get a consistent hash (same value on both flow directions) */
2335         if (addr2 < addr1)
2336                 swap(addr1, addr2);
2337         skb->rxhash = jhash_3words(addr1, addr2, ports.v32, hashrnd);
2338         if (!skb->rxhash)
2339                 skb->rxhash = 1;
2340
2341 got_hash:
2342         flow_table = rcu_dereference(rxqueue->rps_flow_table);
2343         sock_flow_table = rcu_dereference(rps_sock_flow_table);
2344         if (flow_table && sock_flow_table) {
2345                 u16 next_cpu;
2346                 struct rps_dev_flow *rflow;
2347
2348                 rflow = &flow_table->flows[skb->rxhash & flow_table->mask];
2349                 tcpu = rflow->cpu;
2350
2351                 next_cpu = sock_flow_table->ents[skb->rxhash &
2352                     sock_flow_table->mask];
2353
2354                 /*
2355                  * If the desired CPU (where last recvmsg was done) is
2356                  * different from current CPU (one in the rx-queue flow
2357                  * table entry), switch if one of the following holds:
2358                  *   - Current CPU is unset (equal to RPS_NO_CPU).
2359                  *   - Current CPU is offline.
2360                  *   - The current CPU's queue tail has advanced beyond the
2361                  *     last packet that was enqueued using this table entry.
2362                  *     This guarantees that all previous packets for the flow
2363                  *     have been dequeued, thus preserving in order delivery.
2364                  */
2365                 if (unlikely(tcpu != next_cpu) &&
2366                     (tcpu == RPS_NO_CPU || !cpu_online(tcpu) ||
2367                      ((int)(per_cpu(softnet_data, tcpu).input_queue_head -
2368                       rflow->last_qtail)) >= 0)) {
2369                         tcpu = rflow->cpu = next_cpu;
2370                         if (tcpu != RPS_NO_CPU)
2371                                 rflow->last_qtail = per_cpu(softnet_data,
2372                                     tcpu).input_queue_head;
2373                 }
2374                 if (tcpu != RPS_NO_CPU && cpu_online(tcpu)) {
2375                         *rflowp = rflow;
2376                         cpu = tcpu;
2377                         goto done;
2378                 }
2379         }
2380
2381         map = rcu_dereference(rxqueue->rps_map);
2382         if (map) {
2383                 tcpu = map->cpus[((u64) skb->rxhash * map->len) >> 32];
2384
2385                 if (cpu_online(tcpu)) {
2386                         cpu = tcpu;
2387                         goto done;
2388                 }
2389         }
2390
2391 done:
2392         return cpu;
2393 }
2394
2395 /* Called from hardirq (IPI) context */
2396 static void rps_trigger_softirq(void *data)
2397 {
2398         struct softnet_data *sd = data;
2399
2400         ____napi_schedule(sd, &sd->backlog);
2401         sd->received_rps++;
2402 }
2403
2404 #endif /* CONFIG_RPS */
2405
2406 /*
2407  * Check if this softnet_data structure is another cpu one
2408  * If yes, queue it to our IPI list and return 1
2409  * If no, return 0
2410  */
2411 static int rps_ipi_queued(struct softnet_data *sd)
2412 {
2413 #ifdef CONFIG_RPS
2414         struct softnet_data *mysd = &__get_cpu_var(softnet_data);
2415
2416         if (sd != mysd) {
2417                 sd->rps_ipi_next = mysd->rps_ipi_list;
2418                 mysd->rps_ipi_list = sd;
2419
2420                 __raise_softirq_irqoff(NET_RX_SOFTIRQ);
2421                 return 1;
2422         }
2423 #endif /* CONFIG_RPS */
2424         return 0;
2425 }
2426
2427 /*
2428  * enqueue_to_backlog is called to queue an skb to a per CPU backlog
2429  * queue (may be a remote CPU queue).
2430  */
2431 static int enqueue_to_backlog(struct sk_buff *skb, int cpu,
2432                               unsigned int *qtail)
2433 {
2434         struct softnet_data *sd;
2435         unsigned long flags;
2436
2437         sd = &per_cpu(softnet_data, cpu);
2438
2439         local_irq_save(flags);
2440
2441         rps_lock(sd);
2442         if (skb_queue_len(&sd->input_pkt_queue) <= netdev_max_backlog) {
2443                 if (skb_queue_len(&sd->input_pkt_queue)) {
2444 enqueue:
2445                         __skb_queue_tail(&sd->input_pkt_queue, skb);
2446                         input_queue_tail_incr_save(sd, qtail);
2447                         rps_unlock(sd);
2448                         local_irq_restore(flags);
2449                         return NET_RX_SUCCESS;
2450                 }
2451
2452                 /* Schedule NAPI for backlog device
2453                  * We can use non atomic operation since we own the queue lock
2454                  */
2455                 if (!__test_and_set_bit(NAPI_STATE_SCHED, &sd->backlog.state)) {
2456                         if (!rps_ipi_queued(sd))
2457                                 ____napi_schedule(sd, &sd->backlog);
2458                 }
2459                 goto enqueue;
2460         }
2461
2462         sd->dropped++;
2463         rps_unlock(sd);
2464
2465         local_irq_restore(flags);
2466
2467         kfree_skb(skb);
2468         return NET_RX_DROP;
2469 }
2470
2471 /**
2472  *      netif_rx        -       post buffer to the network code
2473  *      @skb: buffer to post
2474  *
2475  *      This function receives a packet from a device driver and queues it for
2476  *      the upper (protocol) levels to process.  It always succeeds. The buffer
2477  *      may be dropped during processing for congestion control or by the
2478  *      protocol layers.
2479  *
2480  *      return values:
2481  *      NET_RX_SUCCESS  (no congestion)
2482  *      NET_RX_DROP     (packet was dropped)
2483  *
2484  */
2485
2486 int netif_rx(struct sk_buff *skb)
2487 {
2488         int ret;
2489
2490         /* if netpoll wants it, pretend we never saw it */
2491         if (netpoll_rx(skb))
2492                 return NET_RX_DROP;
2493
2494         if (netdev_tstamp_prequeue)
2495                 net_timestamp_check(skb);
2496
2497 #ifdef CONFIG_RPS
2498         {
2499                 struct rps_dev_flow voidflow, *rflow = &voidflow;
2500                 int cpu;
2501
2502                 rcu_read_lock();
2503
2504                 cpu = get_rps_cpu(skb->dev, skb, &rflow);
2505                 if (cpu < 0)
2506                         cpu = smp_processor_id();
2507
2508                 ret = enqueue_to_backlog(skb, cpu, &rflow->last_qtail);
2509
2510                 rcu_read_unlock();
2511         }
2512 #else
2513         {
2514                 unsigned int qtail;
2515                 ret = enqueue_to_backlog(skb, get_cpu(), &qtail);
2516                 put_cpu();
2517         }
2518 #endif
2519         return ret;
2520 }
2521 EXPORT_SYMBOL(netif_rx);
2522
2523 int netif_rx_ni(struct sk_buff *skb)
2524 {
2525         int err;
2526
2527         preempt_disable();
2528         err = netif_rx(skb);
2529         if (local_softirq_pending())
2530                 do_softirq();
2531         preempt_enable();
2532
2533         return err;
2534 }
2535 EXPORT_SYMBOL(netif_rx_ni);
2536
2537 static void net_tx_action(struct softirq_action *h)
2538 {
2539         struct softnet_data *sd = &__get_cpu_var(softnet_data);
2540
2541         if (sd->completion_queue) {
2542                 struct sk_buff *clist;
2543
2544                 local_irq_disable();
2545                 clist = sd->completion_queue;
2546                 sd->completion_queue = NULL;
2547                 local_irq_enable();
2548
2549                 while (clist) {
2550                         struct sk_buff *skb = clist;
2551                         clist = clist->next;
2552
2553                         WARN_ON(atomic_read(&skb->users));
2554                         __kfree_skb(skb);
2555                 }
2556         }
2557
2558         if (sd->output_queue) {
2559                 struct Qdisc *head;
2560
2561                 local_irq_disable();
2562                 head = sd->output_queue;
2563                 sd->output_queue = NULL;
2564                 sd->output_queue_tailp = &sd->output_queue;
2565                 local_irq_enable();
2566
2567                 while (head) {
2568                         struct Qdisc *q = head;
2569                         spinlock_t *root_lock;
2570
2571                         head = head->next_sched;
2572
2573                         root_lock = qdisc_lock(q);
2574                         if (spin_trylock(root_lock)) {
2575                                 smp_mb__before_clear_bit();
2576                                 clear_bit(__QDISC_STATE_SCHED,
2577                                           &q->state);
2578                                 qdisc_run(q);
2579                                 spin_unlock(root_lock);
2580                         } else {
2581                                 if (!test_bit(__QDISC_STATE_DEACTIVATED,
2582                                               &q->state)) {
2583                                         __netif_reschedule(q);
2584                                 } else {
2585                                         smp_mb__before_clear_bit();
2586                                         clear_bit(__QDISC_STATE_SCHED,
2587                                                   &q->state);
2588                                 }
2589                         }
2590                 }
2591         }
2592 }
2593
2594 static inline int deliver_skb(struct sk_buff *skb,
2595                               struct packet_type *pt_prev,
2596                               struct net_device *orig_dev)
2597 {
2598         atomic_inc(&skb->users);
2599         return pt_prev->func(skb, skb->dev, pt_prev, orig_dev);
2600 }
2601
2602 #if (defined(CONFIG_BRIDGE) || defined(CONFIG_BRIDGE_MODULE)) && \
2603     (defined(CONFIG_ATM_LANE) || defined(CONFIG_ATM_LANE_MODULE))
2604 /* This hook is defined here for ATM LANE */
2605 int (*br_fdb_test_addr_hook)(struct net_device *dev,
2606                              unsigned char *addr) __read_mostly;
2607 EXPORT_SYMBOL_GPL(br_fdb_test_addr_hook);
2608 #endif
2609
2610 #ifdef CONFIG_NET_CLS_ACT
2611 /* TODO: Maybe we should just force sch_ingress to be compiled in
2612  * when CONFIG_NET_CLS_ACT is? otherwise some useless instructions
2613  * a compare and 2 stores extra right now if we dont have it on
2614  * but have CONFIG_NET_CLS_ACT
2615  * NOTE: This doesnt stop any functionality; if you dont have
2616  * the ingress scheduler, you just cant add policies on ingress.
2617  *
2618  */
2619 static int ing_filter(struct sk_buff *skb)
2620 {
2621         struct net_device *dev = skb->dev;
2622         u32 ttl = G_TC_RTTL(skb->tc_verd);
2623         struct netdev_queue *rxq;
2624         int result = TC_ACT_OK;
2625         struct Qdisc *q;
2626
2627         if (MAX_RED_LOOP < ttl++) {
2628                 printk(KERN_WARNING
2629                        "Redir loop detected Dropping packet (%d->%d)\n",
2630                        skb->skb_iif, dev->ifindex);
2631                 return TC_ACT_SHOT;
2632         }
2633
2634         skb->tc_verd = SET_TC_RTTL(skb->tc_verd, ttl);
2635         skb->tc_verd = SET_TC_AT(skb->tc_verd, AT_INGRESS);
2636
2637         rxq = &dev->rx_queue;
2638
2639         q = rxq->qdisc;
2640         if (q != &noop_qdisc) {
2641                 spin_lock(qdisc_lock(q));
2642                 if (likely(!test_bit(__QDISC_STATE_DEACTIVATED, &q->state)))
2643                         result = qdisc_enqueue_root(skb, q);
2644                 spin_unlock(qdisc_lock(q));
2645         }
2646
2647         return result;
2648 }
2649
2650 static inline struct sk_buff *handle_ing(struct sk_buff *skb,
2651                                          struct packet_type **pt_prev,
2652                                          int *ret, struct net_device *orig_dev)
2653 {
2654         if (skb->dev->rx_queue.qdisc == &noop_qdisc)
2655                 goto out;
2656
2657         if (*pt_prev) {
2658                 *ret = deliver_skb(skb, *pt_prev, orig_dev);
2659                 *pt_prev = NULL;
2660         }
2661
2662         switch (ing_filter(skb)) {
2663         case TC_ACT_SHOT:
2664         case TC_ACT_STOLEN:
2665                 kfree_skb(skb);
2666                 return NULL;
2667         }
2668
2669 out:
2670         skb->tc_verd = 0;
2671         return skb;
2672 }
2673 #endif
2674
2675 /*
2676  *      netif_nit_deliver - deliver received packets to network taps
2677  *      @skb: buffer
2678  *
2679  *      This function is used to deliver incoming packets to network
2680  *      taps. It should be used when the normal netif_receive_skb path
2681  *      is bypassed, for example because of VLAN acceleration.
2682  */
2683 void netif_nit_deliver(struct sk_buff *skb)
2684 {
2685         struct packet_type *ptype;
2686
2687         if (list_empty(&ptype_all))
2688                 return;
2689
2690         skb_reset_network_header(skb);
2691         skb_reset_transport_header(skb);
2692         skb->mac_len = skb->network_header - skb->mac_header;
2693
2694         rcu_read_lock();
2695         list_for_each_entry_rcu(ptype, &ptype_all, list) {
2696                 if (!ptype->dev || ptype->dev == skb->dev)
2697                         deliver_skb(skb, ptype, skb->dev);
2698         }
2699         rcu_read_unlock();
2700 }
2701
2702 /**
2703  *      netdev_rx_handler_register - register receive handler
2704  *      @dev: device to register a handler for
2705  *      @rx_handler: receive handler to register
2706  *
2707  *      Register a receive hander for a device. This handler will then be
2708  *      called from __netif_receive_skb. A negative errno code is returned
2709  *      on a failure.
2710  *
2711  *      The caller must hold the rtnl_mutex.
2712  */
2713 int netdev_rx_handler_register(struct net_device *dev,
2714                                rx_handler_func_t *rx_handler)
2715 {
2716         ASSERT_RTNL();
2717
2718         if (dev->rx_handler)
2719                 return -EBUSY;
2720
2721         rcu_assign_pointer(dev->rx_handler, rx_handler);
2722
2723         return 0;
2724 }
2725 EXPORT_SYMBOL_GPL(netdev_rx_handler_register);
2726
2727 /**
2728  *      netdev_rx_handler_unregister - unregister receive handler
2729  *      @dev: device to unregister a handler from
2730  *
2731  *      Unregister a receive hander from a device.
2732  *
2733  *      The caller must hold the rtnl_mutex.
2734  */
2735 void netdev_rx_handler_unregister(struct net_device *dev)
2736 {
2737
2738         ASSERT_RTNL();
2739         rcu_assign_pointer(dev->rx_handler, NULL);
2740 }
2741 EXPORT_SYMBOL_GPL(netdev_rx_handler_unregister);
2742
2743 static inline void skb_bond_set_mac_by_master(struct sk_buff *skb,
2744                                               struct net_device *master)
2745 {
2746         if (skb->pkt_type == PACKET_HOST) {
2747                 u16 *dest = (u16 *) eth_hdr(skb)->h_dest;
2748
2749                 memcpy(dest, master->dev_addr, ETH_ALEN);
2750         }
2751 }
2752
2753 /* On bonding slaves other than the currently active slave, suppress
2754  * duplicates except for 802.3ad ETH_P_SLOW, alb non-mcast/bcast, and
2755  * ARP on active-backup slaves with arp_validate enabled.
2756  */
2757 int __skb_bond_should_drop(struct sk_buff *skb, struct net_device *master)
2758 {
2759         struct net_device *dev = skb->dev;
2760
2761         if (master->priv_flags & IFF_MASTER_ARPMON)
2762                 dev->last_rx = jiffies;
2763
2764         if ((master->priv_flags & IFF_MASTER_ALB) && master->br_port) {
2765                 /* Do address unmangle. The local destination address
2766                  * will be always the one master has. Provides the right
2767                  * functionality in a bridge.
2768                  */
2769                 skb_bond_set_mac_by_master(skb, master);
2770         }
2771
2772         if (dev->priv_flags & IFF_SLAVE_INACTIVE) {
2773                 if ((dev->priv_flags & IFF_SLAVE_NEEDARP) &&
2774                     skb->protocol == __cpu_to_be16(ETH_P_ARP))
2775                         return 0;
2776
2777                 if (master->priv_flags & IFF_MASTER_ALB) {
2778                         if (skb->pkt_type != PACKET_BROADCAST &&
2779                             skb->pkt_type != PACKET_MULTICAST)
2780                                 return 0;
2781                 }
2782                 if (master->priv_flags & IFF_MASTER_8023AD &&
2783                     skb->protocol == __cpu_to_be16(ETH_P_SLOW))
2784                         return 0;
2785
2786                 return 1;
2787         }
2788         return 0;
2789 }
2790 EXPORT_SYMBOL(__skb_bond_should_drop);
2791
2792 static int __netif_receive_skb(struct sk_buff *skb)
2793 {
2794         struct packet_type *ptype, *pt_prev;
2795         rx_handler_func_t *rx_handler;
2796         struct net_device *orig_dev;
2797         struct net_device *master;
2798         struct net_device *null_or_orig;
2799         struct net_device *orig_or_bond;
2800         int ret = NET_RX_DROP;
2801         __be16 type;
2802
2803         if (!netdev_tstamp_prequeue)
2804                 net_timestamp_check(skb);
2805
2806         if (vlan_tx_tag_present(skb) && vlan_hwaccel_do_receive(skb))
2807                 return NET_RX_SUCCESS;
2808
2809         /* if we've gotten here through NAPI, check netpoll */
2810         if (netpoll_receive_skb(skb))
2811                 return NET_RX_DROP;
2812
2813         if (!skb->skb_iif)
2814                 skb->skb_iif = skb->dev->ifindex;
2815
2816         /*
2817          * bonding note: skbs received on inactive slaves should only
2818          * be delivered to pkt handlers that are exact matches.  Also
2819          * the deliver_no_wcard flag will be set.  If packet handlers
2820          * are sensitive to duplicate packets these skbs will need to
2821          * be dropped at the handler.  The vlan accel path may have
2822          * already set the deliver_no_wcard flag.
2823          */
2824         null_or_orig = NULL;
2825         orig_dev = skb->dev;
2826         master = ACCESS_ONCE(orig_dev->master);
2827         if (skb->deliver_no_wcard)
2828                 null_or_orig = orig_dev;
2829         else if (master) {
2830                 if (skb_bond_should_drop(skb, master)) {
2831                         skb->deliver_no_wcard = 1;
2832                         null_or_orig = orig_dev; /* deliver only exact match */
2833                 } else
2834                         skb->dev = master;
2835         }
2836
2837         __this_cpu_inc(softnet_data.processed);
2838         skb_reset_network_header(skb);
2839         skb_reset_transport_header(skb);
2840         skb->mac_len = skb->network_header - skb->mac_header;
2841
2842         pt_prev = NULL;
2843
2844         rcu_read_lock();
2845
2846 #ifdef CONFIG_NET_CLS_ACT
2847         if (skb->tc_verd & TC_NCLS) {
2848                 skb->tc_verd = CLR_TC_NCLS(skb->tc_verd);
2849                 goto ncls;
2850         }
2851 #endif
2852
2853         list_for_each_entry_rcu(ptype, &ptype_all, list) {
2854                 if (ptype->dev == null_or_orig || ptype->dev == skb->dev ||
2855                     ptype->dev == orig_dev) {
2856                         if (pt_prev)
2857                                 ret = deliver_skb(skb, pt_prev, orig_dev);
2858                         pt_prev = ptype;
2859                 }
2860         }
2861
2862 #ifdef CONFIG_NET_CLS_ACT
2863         skb = handle_ing(skb, &pt_prev, &ret, orig_dev);
2864         if (!skb)
2865                 goto out;
2866 ncls:
2867 #endif
2868
2869         /* Handle special case of bridge or macvlan */
2870         rx_handler = rcu_dereference(skb->dev->rx_handler);
2871         if (rx_handler) {
2872                 if (pt_prev) {
2873                         ret = deliver_skb(skb, pt_prev, orig_dev);
2874                         pt_prev = NULL;
2875                 }
2876                 skb = rx_handler(skb);
2877                 if (!skb)
2878                         goto out;
2879         }
2880
2881         /*
2882          * Make sure frames received on VLAN interfaces stacked on
2883          * bonding interfaces still make their way to any base bonding
2884          * device that may have registered for a specific ptype.  The
2885          * handler may have to adjust skb->dev and orig_dev.
2886          */
2887         orig_or_bond = orig_dev;
2888         if ((skb->dev->priv_flags & IFF_802_1Q_VLAN) &&
2889             (vlan_dev_real_dev(skb->dev)->priv_flags & IFF_BONDING)) {
2890                 orig_or_bond = vlan_dev_real_dev(skb->dev);
2891         }
2892
2893         type = skb->protocol;
2894         list_for_each_entry_rcu(ptype,
2895                         &ptype_base[ntohs(type) & PTYPE_HASH_MASK], list) {
2896                 if (ptype->type == type && (ptype->dev == null_or_orig ||
2897                      ptype->dev == skb->dev || ptype->dev == orig_dev ||
2898                      ptype->dev == orig_or_bond)) {
2899                         if (pt_prev)
2900                                 ret = deliver_skb(skb, pt_prev, orig_dev);
2901                         pt_prev = ptype;
2902                 }
2903         }
2904
2905         if (pt_prev) {
2906                 ret = pt_prev->func(skb, skb->dev, pt_prev, orig_dev);
2907         } else {
2908                 kfree_skb(skb);
2909                 /* Jamal, now you will not able to escape explaining
2910                  * me how you were going to use this. :-)
2911                  */
2912                 ret = NET_RX_DROP;
2913         }
2914
2915 out:
2916         rcu_read_unlock();
2917         return ret;
2918 }
2919
2920 /**
2921  *      netif_receive_skb - process receive buffer from network
2922  *      @skb: buffer to process
2923  *
2924  *      netif_receive_skb() is the main receive data processing function.
2925  *      It always succeeds. The buffer may be dropped during processing
2926  *      for congestion control or by the protocol layers.
2927  *
2928  *      This function may only be called from softirq context and interrupts
2929  *      should be enabled.
2930  *
2931  *      Return values (usually ignored):
2932  *      NET_RX_SUCCESS: no congestion
2933  *      NET_RX_DROP: packet was dropped
2934  */
2935 int netif_receive_skb(struct sk_buff *skb)
2936 {
2937         if (netdev_tstamp_prequeue)
2938                 net_timestamp_check(skb);
2939
2940 #ifdef CONFIG_RPS
2941         {
2942                 struct rps_dev_flow voidflow, *rflow = &voidflow;
2943                 int cpu, ret;
2944
2945                 rcu_read_lock();
2946
2947                 cpu = get_rps_cpu(skb->dev, skb, &rflow);
2948
2949                 if (cpu >= 0) {
2950                         ret = enqueue_to_backlog(skb, cpu, &rflow->last_qtail);
2951                         rcu_read_unlock();
2952                 } else {
2953                         rcu_read_unlock();
2954                         ret = __netif_receive_skb(skb);
2955                 }
2956
2957                 return ret;
2958         }
2959 #else
2960         return __netif_receive_skb(skb);
2961 #endif
2962 }
2963 EXPORT_SYMBOL(netif_receive_skb);
2964
2965 /* Network device is going away, flush any packets still pending
2966  * Called with irqs disabled.
2967  */
2968 static void flush_backlog(void *arg)
2969 {
2970         struct net_device *dev = arg;
2971         struct softnet_data *sd = &__get_cpu_var(softnet_data);
2972         struct sk_buff *skb, *tmp;
2973
2974         rps_lock(sd);
2975         skb_queue_walk_safe(&sd->input_pkt_queue, skb, tmp) {
2976                 if (skb->dev == dev) {
2977                         __skb_unlink(skb, &sd->input_pkt_queue);
2978                         kfree_skb(skb);
2979                         input_queue_head_incr(sd);
2980                 }
2981         }
2982         rps_unlock(sd);
2983
2984         skb_queue_walk_safe(&sd->process_queue, skb, tmp) {
2985                 if (skb->dev == dev) {
2986                         __skb_unlink(skb, &sd->process_queue);
2987                         kfree_skb(skb);
2988                         input_queue_head_incr(sd);
2989                 }
2990         }
2991 }
2992
2993 static int napi_gro_complete(struct sk_buff *skb)
2994 {
2995         struct packet_type *ptype;
2996         __be16 type = skb->protocol;
2997         struct list_head *head = &ptype_base[ntohs(type) & PTYPE_HASH_MASK];
2998         int err = -ENOENT;
2999
3000         if (NAPI_GRO_CB(skb)->count == 1) {
3001                 skb_shinfo(skb)->gso_size = 0;
3002                 goto out;
3003         }
3004
3005         rcu_read_lock();
3006         list_for_each_entry_rcu(ptype, head, list) {
3007                 if (ptype->type != type || ptype->dev || !ptype->gro_complete)
3008                         continue;
3009
3010                 err = ptype->gro_complete(skb);
3011                 break;
3012         }
3013         rcu_read_unlock();
3014
3015         if (err) {
3016                 WARN_ON(&ptype->list == head);
3017                 kfree_skb(skb);
3018                 return NET_RX_SUCCESS;
3019         }
3020
3021 out:
3022         return netif_receive_skb(skb);
3023 }
3024
3025 static void napi_gro_flush(struct napi_struct *napi)
3026 {
3027         struct sk_buff *skb, *next;
3028
3029         for (skb = napi->gro_list; skb; skb = next) {
3030                 next = skb->next;
3031                 skb->next = NULL;
3032                 napi_gro_complete(skb);
3033         }
3034
3035         napi->gro_count = 0;
3036         napi->gro_list = NULL;
3037 }
3038
3039 enum gro_result dev_gro_receive(struct napi_struct *napi, struct sk_buff *skb)
3040 {
3041         struct sk_buff **pp = NULL;
3042         struct packet_type *ptype;
3043         __be16 type = skb->protocol;
3044         struct list_head *head = &ptype_base[ntohs(type) & PTYPE_HASH_MASK];
3045         int same_flow;
3046         int mac_len;
3047         enum gro_result ret;
3048
3049         if (!(skb->dev->features & NETIF_F_GRO))
3050                 goto normal;
3051
3052         if (skb_is_gso(skb) || skb_has_frags(skb))
3053                 goto normal;
3054
3055         rcu_read_lock();
3056         list_for_each_entry_rcu(ptype, head, list) {
3057                 if (ptype->type != type || ptype->dev || !ptype->gro_receive)
3058                         continue;
3059
3060                 skb_set_network_header(skb, skb_gro_offset(skb));
3061                 mac_len = skb->network_header - skb->mac_header;
3062                 skb->mac_len = mac_len;
3063                 NAPI_GRO_CB(skb)->same_flow = 0;
3064                 NAPI_GRO_CB(skb)->flush = 0;
3065                 NAPI_GRO_CB(skb)->free = 0;
3066
3067                 pp = ptype->gro_receive(&napi->gro_list, skb);
3068                 break;
3069         }
3070         rcu_read_unlock();
3071
3072         if (&ptype->list == head)
3073                 goto normal;
3074
3075         same_flow = NAPI_GRO_CB(skb)->same_flow;
3076         ret = NAPI_GRO_CB(skb)->free ? GRO_MERGED_FREE : GRO_MERGED;
3077
3078         if (pp) {
3079                 struct sk_buff *nskb = *pp;
3080
3081                 *pp = nskb->next;
3082                 nskb->next = NULL;
3083                 napi_gro_complete(nskb);
3084                 napi->gro_count--;
3085         }
3086
3087         if (same_flow)
3088                 goto ok;
3089
3090         if (NAPI_GRO_CB(skb)->flush || napi->gro_count >= MAX_GRO_SKBS)
3091                 goto normal;
3092
3093         napi->gro_count++;
3094         NAPI_GRO_CB(skb)->count = 1;
3095         skb_shinfo(skb)->gso_size = skb_gro_len(skb);
3096         skb->next = napi->gro_list;
3097         napi->gro_list = skb;
3098         ret = GRO_HELD;
3099
3100 pull:
3101         if (skb_headlen(skb) < skb_gro_offset(skb)) {
3102                 int grow = skb_gro_offset(skb) - skb_headlen(skb);
3103
3104                 BUG_ON(skb->end - skb->tail < grow);
3105
3106                 memcpy(skb_tail_pointer(skb), NAPI_GRO_CB(skb)->frag0, grow);
3107
3108                 skb->tail += grow;
3109                 skb->data_len -= grow;
3110
3111                 skb_shinfo(skb)->frags[0].page_offset += grow;
3112                 skb_shinfo(skb)->frags[0].size -= grow;
3113
3114                 if (unlikely(!skb_shinfo(skb)->frags[0].size)) {
3115                         put_page(skb_shinfo(skb)->frags[0].page);
3116                         memmove(skb_shinfo(skb)->frags,
3117                                 skb_shinfo(skb)->frags + 1,
3118                                 --skb_shinfo(skb)->nr_frags);
3119                 }
3120         }
3121
3122 ok:
3123         return ret;
3124
3125 normal:
3126         ret = GRO_NORMAL;
3127         goto pull;
3128 }
3129 EXPORT_SYMBOL(dev_gro_receive);
3130
3131 static gro_result_t
3132 __napi_gro_receive(struct napi_struct *napi, struct sk_buff *skb)
3133 {
3134         struct sk_buff *p;
3135
3136         if (netpoll_rx_on(skb))
3137                 return GRO_NORMAL;
3138
3139         for (p = napi->gro_list; p; p = p->next) {
3140                 NAPI_GRO_CB(p)->same_flow =
3141                         (p->dev == skb->dev) &&
3142                         !compare_ether_header(skb_mac_header(p),
3143                                               skb_gro_mac_header(skb));
3144                 NAPI_GRO_CB(p)->flush = 0;
3145         }
3146
3147         return dev_gro_receive(napi, skb);
3148 }
3149
3150 gro_result_t napi_skb_finish(gro_result_t ret, struct sk_buff *skb)
3151 {
3152         switch (ret) {
3153         case GRO_NORMAL:
3154                 if (netif_receive_skb(skb))
3155                         ret = GRO_DROP;
3156                 break;
3157
3158         case GRO_DROP:
3159         case GRO_MERGED_FREE:
3160                 kfree_skb(skb);
3161                 break;
3162
3163         case GRO_HELD:
3164         case GRO_MERGED:
3165                 break;
3166         }
3167
3168         return ret;
3169 }
3170 EXPORT_SYMBOL(napi_skb_finish);
3171
3172 void skb_gro_reset_offset(struct sk_buff *skb)
3173 {
3174         NAPI_GRO_CB(skb)->data_offset = 0;
3175         NAPI_GRO_CB(skb)->frag0 = NULL;
3176         NAPI_GRO_CB(skb)->frag0_len = 0;
3177
3178         if (skb->mac_header == skb->tail &&
3179             !PageHighMem(skb_shinfo(skb)->frags[0].page)) {
3180                 NAPI_GRO_CB(skb)->frag0 =
3181                         page_address(skb_shinfo(skb)->frags[0].page) +
3182                         skb_shinfo(skb)->frags[0].page_offset;
3183                 NAPI_GRO_CB(skb)->frag0_len = skb_shinfo(skb)->frags[0].size;
3184         }
3185 }
3186 EXPORT_SYMBOL(skb_gro_reset_offset);
3187
3188 gro_result_t napi_gro_receive(struct napi_struct *napi, struct sk_buff *skb)
3189 {
3190         skb_gro_reset_offset(skb);
3191
3192         return napi_skb_finish(__napi_gro_receive(napi, skb), skb);
3193 }
3194 EXPORT_SYMBOL(napi_gro_receive);
3195
3196 void napi_reuse_skb(struct napi_struct *napi, struct sk_buff *skb)
3197 {
3198         __skb_pull(skb, skb_headlen(skb));
3199         skb_reserve(skb, NET_IP_ALIGN - skb_headroom(skb));
3200
3201         napi->skb = skb;
3202 }
3203 EXPORT_SYMBOL(napi_reuse_skb);
3204
3205 struct sk_buff *napi_get_frags(struct napi_struct *napi)
3206 {
3207         struct sk_buff *skb = napi->skb;
3208
3209         if (!skb) {
3210                 skb = netdev_alloc_skb_ip_align(napi->dev, GRO_MAX_HEAD);
3211                 if (skb)
3212                         napi->skb = skb;
3213         }
3214         return skb;
3215 }
3216 EXPORT_SYMBOL(napi_get_frags);
3217
3218 gro_result_t napi_frags_finish(struct napi_struct *napi, struct sk_buff *skb,
3219                                gro_result_t ret)
3220 {
3221         switch (ret) {
3222         case GRO_NORMAL:
3223         case GRO_HELD:
3224                 skb->protocol = eth_type_trans(skb, skb->dev);
3225
3226                 if (ret == GRO_HELD)
3227                         skb_gro_pull(skb, -ETH_HLEN);
3228                 else if (netif_receive_skb(skb))
3229                         ret = GRO_DROP;
3230                 break;
3231
3232         case GRO_DROP:
3233         case GRO_MERGED_FREE:
3234                 napi_reuse_skb(napi, skb);
3235                 break;
3236
3237         case GRO_MERGED:
3238                 break;
3239         }
3240
3241         return ret;
3242 }
3243 EXPORT_SYMBOL(napi_frags_finish);
3244
3245 struct sk_buff *napi_frags_skb(struct napi_struct *napi)
3246 {
3247         struct sk_buff *skb = napi->skb;
3248         struct ethhdr *eth;
3249         unsigned int hlen;
3250         unsigned int off;
3251
3252         napi->skb = NULL;
3253
3254         skb_reset_mac_header(skb);
3255         skb_gro_reset_offset(skb);
3256
3257         off = skb_gro_offset(skb);
3258         hlen = off + sizeof(*eth);
3259         eth = skb_gro_header_fast(skb, off);
3260         if (skb_gro_header_hard(skb, hlen)) {
3261                 eth = skb_gro_header_slow(skb, hlen, off);
3262                 if (unlikely(!eth)) {
3263                         napi_reuse_skb(napi, skb);
3264                         skb = NULL;
3265                         goto out;
3266                 }
3267         }
3268
3269         skb_gro_pull(skb, sizeof(*eth));
3270
3271         /*
3272          * This works because the only protocols we care about don't require
3273          * special handling.  We'll fix it up properly at the end.
3274          */
3275         skb->protocol = eth->h_proto;
3276
3277 out:
3278         return skb;
3279 }
3280 EXPORT_SYMBOL(napi_frags_skb);
3281
3282 gro_result_t napi_gro_frags(struct napi_struct *napi)
3283 {
3284         struct sk_buff *skb = napi_frags_skb(napi);
3285
3286         if (!skb)
3287                 return GRO_DROP;
3288
3289         return napi_frags_finish(napi, skb, __napi_gro_receive(napi, skb));
3290 }
3291 EXPORT_SYMBOL(napi_gro_frags);
3292
3293 /*
3294  * net_rps_action sends any pending IPI's for rps.
3295  * Note: called with local irq disabled, but exits with local irq enabled.
3296  */
3297 static void net_rps_action_and_irq_enable(struct softnet_data *sd)
3298 {
3299 #ifdef CONFIG_RPS
3300         struct softnet_data *remsd = sd->rps_ipi_list;
3301
3302         if (remsd) {
3303                 sd->rps_ipi_list = NULL;
3304
3305                 local_irq_enable();
3306
3307                 /* Send pending IPI's to kick RPS processing on remote cpus. */
3308                 while (remsd) {
3309                         struct softnet_data *next = remsd->rps_ipi_next;
3310
3311                         if (cpu_online(remsd->cpu))
3312                                 __smp_call_function_single(remsd->cpu,
3313                                                            &remsd->csd, 0);
3314                         remsd = next;
3315                 }
3316         } else
3317 #endif
3318                 local_irq_enable();
3319 }
3320
3321 static int process_backlog(struct napi_struct *napi, int quota)
3322 {
3323         int work = 0;
3324         struct softnet_data *sd = container_of(napi, struct softnet_data, backlog);
3325
3326 #ifdef CONFIG_RPS
3327         /* Check if we have pending ipi, its better to send them now,
3328          * not waiting net_rx_action() end.
3329          */
3330         if (sd->rps_ipi_list) {
3331                 local_irq_disable();
3332                 net_rps_action_and_irq_enable(sd);
3333         }
3334 #endif
3335         napi->weight = weight_p;
3336         local_irq_disable();
3337         while (work < quota) {
3338                 struct sk_buff *skb;
3339                 unsigned int qlen;
3340
3341                 while ((skb = __skb_dequeue(&sd->process_queue))) {
3342                         local_irq_enable();
3343                         __netif_receive_skb(skb);
3344                         local_irq_disable();
3345                         input_queue_head_incr(sd);
3346                         if (++work >= quota) {
3347                                 local_irq_enable();
3348                                 return work;
3349                         }
3350                 }
3351
3352                 rps_lock(sd);
3353                 qlen = skb_queue_len(&sd->input_pkt_queue);
3354                 if (qlen)
3355                         skb_queue_splice_tail_init(&sd->input_pkt_queue,
3356                                                    &sd->process_queue);
3357
3358                 if (qlen < quota - work) {
3359                         /*
3360                          * Inline a custom version of __napi_complete().
3361                          * only current cpu owns and manipulates this napi,
3362                          * and NAPI_STATE_SCHED is the only possible flag set on backlog.
3363                          * we can use a plain write instead of clear_bit(),
3364                          * and we dont need an smp_mb() memory barrier.
3365                          */
3366                         list_del(&napi->poll_list);
3367                         napi->state = 0;
3368
3369                         quota = work + qlen;
3370                 }
3371                 rps_unlock(sd);
3372         }
3373         local_irq_enable();
3374
3375         return work;
3376 }
3377
3378 /**
3379  * __napi_schedule - schedule for receive
3380  * @n: entry to schedule
3381  *
3382  * The entry's receive function will be scheduled to run
3383  */
3384 void __napi_schedule(struct napi_struct *n)
3385 {
3386         unsigned long flags;
3387
3388         local_irq_save(flags);
3389         ____napi_schedule(&__get_cpu_var(softnet_data), n);
3390         local_irq_restore(flags);
3391 }
3392 EXPORT_SYMBOL(__napi_schedule);
3393
3394 void __napi_complete(struct napi_struct *n)
3395 {
3396         BUG_ON(!test_bit(NAPI_STATE_SCHED, &n->state));
3397         BUG_ON(n->gro_list);
3398
3399         list_del(&n->poll_list);
3400         smp_mb__before_clear_bit();
3401         clear_bit(NAPI_STATE_SCHED, &n->state);
3402 }
3403 EXPORT_SYMBOL(__napi_complete);
3404
3405 void napi_complete(struct napi_struct *n)
3406 {
3407         unsigned long flags;
3408
3409         /*
3410          * don't let napi dequeue from the cpu poll list
3411          * just in case its running on a different cpu
3412          */
3413         if (unlikely(test_bit(NAPI_STATE_NPSVC, &n->state)))
3414                 return;
3415
3416         napi_gro_flush(n);
3417         local_irq_save(flags);
3418         __napi_complete(n);
3419         local_irq_restore(flags);
3420 }
3421 EXPORT_SYMBOL(napi_complete);
3422
3423 void netif_napi_add(struct net_device *dev, struct napi_struct *napi,
3424                     int (*poll)(struct napi_struct *, int), int weight)
3425 {
3426         INIT_LIST_HEAD(&napi->poll_list);
3427         napi->gro_count = 0;
3428         napi->gro_list = NULL;
3429         napi->skb = NULL;
3430         napi->poll = poll;
3431         napi->weight = weight;
3432         list_add(&napi->dev_list, &dev->napi_list);
3433         napi->dev = dev;
3434 #ifdef CONFIG_NETPOLL
3435         spin_lock_init(&napi->poll_lock);
3436         napi->poll_owner = -1;
3437 #endif
3438         set_bit(NAPI_STATE_SCHED, &napi->state);
3439 }
3440 EXPORT_SYMBOL(netif_napi_add);
3441
3442 void netif_napi_del(struct napi_struct *napi)
3443 {
3444         struct sk_buff *skb, *next;
3445
3446         list_del_init(&napi->dev_list);
3447         napi_free_frags(napi);
3448
3449         for (skb = napi->gro_list; skb; skb = next) {
3450                 next = skb->next;
3451                 skb->next = NULL;
3452                 kfree_skb(skb);
3453         }
3454
3455         napi->gro_list = NULL;
3456         napi->gro_count = 0;
3457 }
3458 EXPORT_SYMBOL(netif_napi_del);
3459
3460 static void net_rx_action(struct softirq_action *h)
3461 {
3462         struct softnet_data *sd = &__get_cpu_var(softnet_data);
3463         unsigned long time_limit = jiffies + 2;
3464         int budget = netdev_budget;
3465         void *have;
3466
3467         local_irq_disable();
3468
3469         while (!list_empty(&sd->poll_list)) {
3470                 struct napi_struct *n;
3471                 int work, weight;
3472
3473                 /* If softirq window is exhuasted then punt.
3474                  * Allow this to run for 2 jiffies since which will allow
3475                  * an average latency of 1.5/HZ.
3476                  */
3477                 if (unlikely(budget <= 0 || time_after(jiffies, time_limit)))
3478                         goto softnet_break;
3479
3480                 local_irq_enable();
3481
3482                 /* Even though interrupts have been re-enabled, this
3483                  * access is safe because interrupts can only add new
3484                  * entries to the tail of this list, and only ->poll()
3485                  * calls can remove this head entry from the list.
3486                  */
3487                 n = list_first_entry(&sd->poll_list, struct napi_struct, poll_list);
3488
3489                 have = netpoll_poll_lock(n);
3490
3491                 weight = n->weight;
3492
3493                 /* This NAPI_STATE_SCHED test is for avoiding a race
3494                  * with netpoll's poll_napi().  Only the entity which
3495                  * obtains the lock and sees NAPI_STATE_SCHED set will
3496                  * actually make the ->poll() call.  Therefore we avoid
3497                  * accidently calling ->poll() when NAPI is not scheduled.
3498                  */
3499                 work = 0;
3500                 if (test_bit(NAPI_STATE_SCHED, &n->state)) {
3501                         work = n->poll(n, weight);
3502                         trace_napi_poll(n);
3503                 }
3504
3505                 WARN_ON_ONCE(work > weight);
3506
3507                 budget -= work;
3508
3509                 local_irq_disable();
3510
3511                 /* Drivers must not modify the NAPI state if they
3512                  * consume the entire weight.  In such cases this code
3513                  * still "owns" the NAPI instance and therefore can
3514                  * move the instance around on the list at-will.
3515                  */
3516                 if (unlikely(work == weight)) {
3517                         if (unlikely(napi_disable_pending(n))) {
3518                                 local_irq_enable();
3519                                 napi_complete(n);
3520                                 local_irq_disable();
3521                         } else
3522                                 list_move_tail(&n->poll_list, &sd->poll_list);
3523                 }
3524
3525                 netpoll_poll_unlock(have);
3526         }
3527 out:
3528         net_rps_action_and_irq_enable(sd);
3529
3530 #ifdef CONFIG_NET_DMA
3531         /*
3532          * There may not be any more sk_buffs coming right now, so push
3533          * any pending DMA copies to hardware
3534          */
3535         dma_issue_pending_all();
3536 #endif
3537
3538         return;
3539
3540 softnet_break:
3541         sd->time_squeeze++;
3542         __raise_softirq_irqoff(NET_RX_SOFTIRQ);
3543         goto out;
3544 }
3545
3546 static gifconf_func_t *gifconf_list[NPROTO];
3547
3548 /**
3549  *      register_gifconf        -       register a SIOCGIF handler
3550  *      @family: Address family
3551  *      @gifconf: Function handler
3552  *
3553  *      Register protocol dependent address dumping routines. The handler
3554  *      that is passed must not be freed or reused until it has been replaced
3555  *      by another handler.
3556  */
3557 int register_gifconf(unsigned int family, gifconf_func_t *gifconf)
3558 {
3559         if (family >= NPROTO)
3560                 return -EINVAL;
3561         gifconf_list[family] = gifconf;
3562         return 0;
3563 }
3564 EXPORT_SYMBOL(register_gifconf);
3565
3566
3567 /*
3568  *      Map an interface index to its name (SIOCGIFNAME)
3569  */
3570
3571 /*
3572  *      We need this ioctl for efficient implementation of the
3573  *      if_indextoname() function required by the IPv6 API.  Without
3574  *      it, we would have to search all the interfaces to find a
3575  *      match.  --pb
3576  */
3577
3578 static int dev_ifname(struct net *net, struct ifreq __user *arg)
3579 {
3580         struct net_device *dev;
3581         struct ifreq ifr;
3582
3583         /*
3584          *      Fetch the caller's info block.
3585          */
3586
3587         if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
3588                 return -EFAULT;
3589
3590         rcu_read_lock();
3591         dev = dev_get_by_index_rcu(net, ifr.ifr_ifindex);
3592         if (!dev) {
3593                 rcu_read_unlock();
3594                 return -ENODEV;
3595         }
3596
3597         strcpy(ifr.ifr_name, dev->name);
3598         rcu_read_unlock();
3599
3600         if (copy_to_user(arg, &ifr, sizeof(struct ifreq)))
3601                 return -EFAULT;
3602         return 0;
3603 }
3604
3605 /*
3606  *      Perform a SIOCGIFCONF call. This structure will change
3607  *      size eventually, and there is nothing I can do about it.
3608  *      Thus we will need a 'compatibility mode'.
3609  */
3610
3611 static int dev_ifconf(struct net *net, char __user *arg)
3612 {
3613         struct ifconf ifc;
3614         struct net_device *dev;
3615         char __user *pos;
3616         int len;
3617         int total;
3618         int i;
3619
3620         /*
3621          *      Fetch the caller's info block.
3622          */
3623
3624         if (copy_from_user(&ifc, arg, sizeof(struct ifconf)))
3625                 return -EFAULT;
3626
3627         pos = ifc.ifc_buf;
3628         len = ifc.ifc_len;
3629
3630         /*
3631          *      Loop over the interfaces, and write an info block for each.
3632          */
3633
3634         total = 0;
3635         for_each_netdev(net, dev) {
3636                 for (i = 0; i < NPROTO; i++) {
3637                         if (gifconf_list[i]) {
3638                                 int done;
3639                                 if (!pos)
3640                                         done = gifconf_list[i](dev, NULL, 0);
3641                                 else
3642                                         done = gifconf_list[i](dev, pos + total,
3643                                                                len - total);
3644                                 if (done < 0)
3645                                         return -EFAULT;
3646                                 total += done;
3647                         }
3648                 }
3649         }
3650
3651         /*
3652          *      All done.  Write the updated control block back to the caller.
3653          */
3654         ifc.ifc_len = total;
3655
3656         /*
3657          *      Both BSD and Solaris return 0 here, so we do too.
3658          */
3659         return copy_to_user(arg, &ifc, sizeof(struct ifconf)) ? -EFAULT : 0;
3660 }
3661
3662 #ifdef CONFIG_PROC_FS
3663 /*
3664  *      This is invoked by the /proc filesystem handler to display a device
3665  *      in detail.
3666  */
3667 void *dev_seq_start(struct seq_file *seq, loff_t *pos)
3668         __acquires(RCU)
3669 {
3670         struct net *net = seq_file_net(seq);
3671         loff_t off;
3672         struct net_device *dev;
3673
3674         rcu_read_lock();
3675         if (!*pos)
3676                 return SEQ_START_TOKEN;
3677
3678         off = 1;
3679         for_each_netdev_rcu(net, dev)
3680                 if (off++ == *pos)
3681                         return dev;
3682
3683         return NULL;
3684 }
3685
3686 void *dev_seq_next(struct seq_file *seq, void *v, loff_t *pos)
3687 {
3688         struct net_device *dev = (v == SEQ_START_TOKEN) ?
3689                                   first_net_device(seq_file_net(seq)) :
3690                                   next_net_device((struct net_device *)v);
3691
3692         ++*pos;
3693         return rcu_dereference(dev);
3694 }
3695
3696 void dev_seq_stop(struct seq_file *seq, void *v)
3697         __releases(RCU)
3698 {
3699         rcu_read_unlock();
3700 }
3701
3702 static void dev_seq_printf_stats(struct seq_file *seq, struct net_device *dev)
3703 {
3704         const struct rtnl_link_stats64 *stats = dev_get_stats(dev);
3705
3706         seq_printf(seq, "%6s: %7llu %7llu %4llu %4llu %4llu %5llu %10llu %9llu "
3707                    "%8llu %7llu %4llu %4llu %4llu %5llu %7llu %10llu\n",
3708                    dev->name, stats->rx_bytes, stats->rx_packets,
3709                    stats->rx_errors,
3710                    stats->rx_dropped + stats->rx_missed_errors,
3711                    stats->rx_fifo_errors,
3712                    stats->rx_length_errors + stats->rx_over_errors +
3713                     stats->rx_crc_errors + stats->rx_frame_errors,
3714                    stats->rx_compressed, stats->multicast,
3715                    stats->tx_bytes, stats->tx_packets,
3716                    stats->tx_errors, stats->tx_dropped,
3717                    stats->tx_fifo_errors, stats->collisions,
3718                    stats->tx_carrier_errors +
3719                     stats->tx_aborted_errors +
3720                     stats->tx_window_errors +
3721                     stats->tx_heartbeat_errors,
3722                    stats->tx_compressed);
3723 }
3724
3725 /*
3726  *      Called from the PROCfs module. This now uses the new arbitrary sized
3727  *      /proc/net interface to create /proc/net/dev
3728  */
3729 static int dev_seq_show(struct seq_file *seq, void *v)
3730 {
3731         if (v == SEQ_START_TOKEN)
3732                 seq_puts(seq, "Inter-|   Receive                            "
3733                               "                    |  Transmit\n"
3734                               " face |bytes    packets errs drop fifo frame "
3735                               "compressed multicast|bytes    packets errs "
3736                               "drop fifo colls carrier compressed\n");
3737         else
3738                 dev_seq_printf_stats(seq, v);
3739         return 0;
3740 }
3741
3742 static struct softnet_data *softnet_get_online(loff_t *pos)
3743 {
3744         struct softnet_data *sd = NULL;
3745
3746         while (*pos < nr_cpu_ids)
3747                 if (cpu_online(*pos)) {
3748                         sd = &per_cpu(softnet_data, *pos);
3749                         break;
3750                 } else
3751                         ++*pos;
3752         return sd;
3753 }
3754
3755 static void *softnet_seq_start(struct seq_file *seq, loff_t *pos)
3756 {
3757         return softnet_get_online(pos);
3758 }
3759
3760 static void *softnet_seq_next(struct seq_file *seq, void *v, loff_t *pos)
3761 {
3762         ++*pos;
3763         return softnet_get_online(pos);
3764 }
3765
3766 static void softnet_seq_stop(struct seq_file *seq, void *v)
3767 {
3768 }
3769
3770 static int softnet_seq_show(struct seq_file *seq, void *v)
3771 {
3772         struct softnet_data *sd = v;
3773
3774         seq_printf(seq, "%08x %08x %08x %08x %08x %08x %08x %08x %08x %08x\n",
3775                    sd->processed, sd->dropped, sd->time_squeeze, 0,
3776                    0, 0, 0, 0, /* was fastroute */
3777                    sd->cpu_collision, sd->received_rps);
3778         return 0;
3779 }
3780
3781 static const struct seq_operations dev_seq_ops = {
3782         .start = dev_seq_start,
3783         .next  = dev_seq_next,
3784         .stop  = dev_seq_stop,
3785         .show  = dev_seq_show,
3786 };
3787
3788 static int dev_seq_open(struct inode *inode, struct file *file)
3789 {
3790         return seq_open_net(inode, file, &dev_seq_ops,
3791                             sizeof(struct seq_net_private));
3792 }
3793
3794 static const struct file_operations dev_seq_fops = {
3795         .owner   = THIS_MODULE,
3796         .open    = dev_seq_open,
3797         .read    = seq_read,
3798         .llseek  = seq_lseek,
3799         .release = seq_release_net,
3800 };
3801
3802 static const struct seq_operations softnet_seq_ops = {
3803         .start = softnet_seq_start,
3804         .next  = softnet_seq_next,
3805         .stop  = softnet_seq_stop,
3806         .show  = softnet_seq_show,
3807 };
3808
3809 static int softnet_seq_open(struct inode *inode, struct file *file)
3810 {
3811         return seq_open(file, &softnet_seq_ops);
3812 }
3813
3814 static const struct file_operations softnet_seq_fops = {
3815         .owner   = THIS_MODULE,
3816         .open    = softnet_seq_open,
3817         .read    = seq_read,
3818         .llseek  = seq_lseek,
3819         .release = seq_release,
3820 };
3821
3822 static void *ptype_get_idx(loff_t pos)
3823 {
3824         struct packet_type *pt = NULL;
3825         loff_t i = 0;
3826         int t;
3827
3828         list_for_each_entry_rcu(pt, &ptype_all, list) {
3829                 if (i == pos)
3830                         return pt;
3831                 ++i;
3832         }
3833
3834         for (t = 0; t < PTYPE_HASH_SIZE; t++) {
3835                 list_for_each_entry_rcu(pt, &ptype_base[t], list) {
3836                         if (i == pos)
3837                                 return pt;
3838                         ++i;
3839                 }
3840         }
3841         return NULL;
3842 }
3843
3844 static void *ptype_seq_start(struct seq_file *seq, loff_t *pos)
3845         __acquires(RCU)
3846 {
3847         rcu_read_lock();
3848         return *pos ? ptype_get_idx(*pos - 1) : SEQ_START_TOKEN;
3849 }
3850
3851 static void *ptype_seq_next(struct seq_file *seq, void *v, loff_t *pos)
3852 {
3853         struct packet_type *pt;
3854         struct list_head *nxt;
3855         int hash;
3856
3857         ++*pos;
3858         if (v == SEQ_START_TOKEN)
3859                 return ptype_get_idx(0);
3860
3861         pt = v;
3862         nxt = pt->list.next;
3863         if (pt->type == htons(ETH_P_ALL)) {
3864                 if (nxt != &ptype_all)
3865                         goto found;
3866                 hash = 0;
3867                 nxt = ptype_base[0].next;
3868         } else
3869                 hash = ntohs(pt->type) & PTYPE_HASH_MASK;
3870
3871         while (nxt == &ptype_base[hash]) {
3872                 if (++hash >= PTYPE_HASH_SIZE)
3873                         return NULL;
3874                 nxt = ptype_base[hash].next;
3875         }
3876 found:
3877         return list_entry(nxt, struct packet_type, list);
3878 }
3879
3880 static void ptype_seq_stop(struct seq_file *seq, void *v)
3881         __releases(RCU)
3882 {
3883         rcu_read_unlock();
3884 }
3885
3886 static int ptype_seq_show(struct seq_file *seq, void *v)
3887 {
3888         struct packet_type *pt = v;
3889
3890         if (v == SEQ_START_TOKEN)
3891                 seq_puts(seq, "Type Device      Function\n");
3892         else if (pt->dev == NULL || dev_net(pt->dev) == seq_file_net(seq)) {
3893                 if (pt->type == htons(ETH_P_ALL))
3894                         seq_puts(seq, "ALL ");
3895                 else
3896                         seq_printf(seq, "%04x", ntohs(pt->type));
3897
3898                 seq_printf(seq, " %-8s %pF\n",
3899                            pt->dev ? pt->dev->name : "", pt->func);
3900         }
3901
3902         return 0;
3903 }
3904
3905 static const struct seq_operations ptype_seq_ops = {
3906         .start = ptype_seq_start,
3907         .next  = ptype_seq_next,
3908         .stop  = ptype_seq_stop,
3909         .show  = ptype_seq_show,
3910 };
3911
3912 static int ptype_seq_open(struct inode *inode, struct file *file)
3913 {
3914         return seq_open_net(inode, file, &ptype_seq_ops,
3915                         sizeof(struct seq_net_private));
3916 }
3917
3918 static const struct file_operations ptype_seq_fops = {
3919         .owner   = THIS_MODULE,
3920         .open    = ptype_seq_open,
3921         .read    = seq_read,
3922         .llseek  = seq_lseek,
3923         .release = seq_release_net,
3924 };
3925
3926
3927 static int __net_init dev_proc_net_init(struct net *net)
3928 {
3929         int rc = -ENOMEM;
3930
3931         if (!proc_net_fops_create(net, "dev", S_IRUGO, &dev_seq_fops))
3932                 goto out;
3933         if (!proc_net_fops_create(net, "softnet_stat", S_IRUGO, &softnet_seq_fops))
3934                 goto out_dev;
3935         if (!proc_net_fops_create(net, "ptype", S_IRUGO, &ptype_seq_fops))
3936                 goto out_softnet;
3937
3938         if (wext_proc_init(net))
3939                 goto out_ptype;
3940         rc = 0;
3941 out:
3942         return rc;
3943 out_ptype:
3944         proc_net_remove(net, "ptype");
3945 out_softnet:
3946         proc_net_remove(net, "softnet_stat");
3947 out_dev:
3948         proc_net_remove(net, "dev");
3949         goto out;
3950 }
3951
3952 static void __net_exit dev_proc_net_exit(struct net *net)
3953 {
3954         wext_proc_exit(net);
3955
3956         proc_net_remove(net, "ptype");
3957         proc_net_remove(net, "softnet_stat");
3958         proc_net_remove(net, "dev");
3959 }
3960
3961 static struct pernet_operations __net_initdata dev_proc_ops = {
3962         .init = dev_proc_net_init,
3963         .exit = dev_proc_net_exit,
3964 };
3965
3966 static int __init dev_proc_init(void)
3967 {
3968         return register_pernet_subsys(&dev_proc_ops);
3969 }
3970 #else
3971 #define dev_proc_init() 0
3972 #endif  /* CONFIG_PROC_FS */
3973
3974
3975 /**
3976  *      netdev_set_master       -       set up master/slave pair
3977  *      @slave: slave device
3978  *      @master: new master device
3979  *
3980  *      Changes the master device of the slave. Pass %NULL to break the
3981  *      bonding. The caller must hold the RTNL semaphore. On a failure
3982  *      a negative errno code is returned. On success the reference counts
3983  *      are adjusted, %RTM_NEWLINK is sent to the routing socket and the
3984  *      function returns zero.
3985  */
3986 int netdev_set_master(struct net_device *slave, struct net_device *master)
3987 {
3988         struct net_device *old = slave->master;
3989
3990         ASSERT_RTNL();
3991
3992         if (master) {
3993                 if (old)
3994                         return -EBUSY;
3995                 dev_hold(master);
3996         }
3997
3998         slave->master = master;
3999
4000         if (old) {
4001                 synchronize_net();
4002                 dev_put(old);
4003         }
4004         if (master)
4005                 slave->flags |= IFF_SLAVE;
4006         else
4007                 slave->flags &= ~IFF_SLAVE;
4008
4009         rtmsg_ifinfo(RTM_NEWLINK, slave, IFF_SLAVE);
4010         return 0;
4011 }
4012 EXPORT_SYMBOL(netdev_set_master);
4013
4014 static void dev_change_rx_flags(struct net_device *dev, int flags)
4015 {
4016         const struct net_device_ops *ops = dev->netdev_ops;
4017
4018         if ((dev->flags & IFF_UP) && ops->ndo_change_rx_flags)
4019                 ops->ndo_change_rx_flags(dev, flags);
4020 }
4021
4022 static int __dev_set_promiscuity(struct net_device *dev, int inc)
4023 {
4024         unsigned short old_flags = dev->flags;
4025         uid_t uid;
4026         gid_t gid;
4027
4028         ASSERT_RTNL();
4029
4030         dev->flags |= IFF_PROMISC;
4031         dev->promiscuity += inc;
4032         if (dev->promiscuity == 0) {
4033                 /*
4034                  * Avoid overflow.
4035                  * If inc causes overflow, untouch promisc and return error.
4036                  */
4037                 if (inc < 0)
4038                         dev->flags &= ~IFF_PROMISC;
4039                 else {
4040                         dev->promiscuity -= inc;
4041                         printk(KERN_WARNING "%s: promiscuity touches roof, "
4042                                 "set promiscuity failed, promiscuity feature "
4043                                 "of device might be broken.\n", dev->name);
4044                         return -EOVERFLOW;
4045                 }
4046         }
4047         if (dev->flags != old_flags) {
4048                 printk(KERN_INFO "device %s %s promiscuous mode\n",
4049                        dev->name, (dev->flags & IFF_PROMISC) ? "entered" :
4050                                                                "left");
4051                 if (audit_enabled) {
4052                         current_uid_gid(&uid, &gid);
4053                         audit_log(current->audit_context, GFP_ATOMIC,
4054                                 AUDIT_ANOM_PROMISCUOUS,
4055                                 "dev=%s prom=%d old_prom=%d auid=%u uid=%u gid=%u ses=%u",
4056                                 dev->name, (dev->flags & IFF_PROMISC),
4057                                 (old_flags & IFF_PROMISC),
4058                                 audit_get_loginuid(current),
4059                                 uid, gid,
4060                                 audit_get_sessionid(current));
4061                 }
4062
4063                 dev_change_rx_flags(dev, IFF_PROMISC);
4064         }
4065         return 0;
4066 }
4067
4068 /**
4069  *      dev_set_promiscuity     - update promiscuity count on a device
4070  *      @dev: device
4071  *      @inc: modifier
4072  *
4073  *      Add or remove promiscuity from a device. While the count in the device
4074  *      remains above zero the interface remains promiscuous. Once it hits zero
4075  *      the device reverts back to normal filtering operation. A negative inc
4076  *      value is used to drop promiscuity on the device.
4077  *      Return 0 if successful or a negative errno code on error.
4078  */
4079 int dev_set_promiscuity(struct net_device *dev, int inc)
4080 {
4081         unsigned short old_flags = dev->flags;
4082         int err;
4083
4084         err = __dev_set_promiscuity(dev, inc);
4085         if (err < 0)
4086                 return err;
4087         if (dev->flags != old_flags)
4088                 dev_set_rx_mode(dev);
4089         return err;
4090 }
4091 EXPORT_SYMBOL(dev_set_promiscuity);
4092
4093 /**
4094  *      dev_set_allmulti        - update allmulti count on a device
4095  *      @dev: device
4096  *      @inc: modifier
4097  *
4098  *      Add or remove reception of all multicast frames to a device. While the
4099  *      count in the device remains above zero the interface remains listening
4100  *      to all interfaces. Once it hits zero the device reverts back to normal
4101  *      filtering operation. A negative @inc value is used to drop the counter
4102  *      when releasing a resource needing all multicasts.
4103  *      Return 0 if successful or a negative errno code on error.
4104  */
4105
4106 int dev_set_allmulti(struct net_device *dev, int inc)
4107 {
4108         unsigned short old_flags = dev->flags;
4109
4110         ASSERT_RTNL();
4111
4112         dev->flags |= IFF_ALLMULTI;
4113         dev->allmulti += inc;
4114         if (dev->allmulti == 0) {
4115                 /*
4116                  * Avoid overflow.
4117                  * If inc causes overflow, untouch allmulti and return error.
4118                  */
4119                 if (inc < 0)
4120                         dev->flags &= ~IFF_ALLMULTI;
4121                 else {
4122                         dev->allmulti -= inc;
4123                         printk(KERN_WARNING "%s: allmulti touches roof, "
4124                                 "set allmulti failed, allmulti feature of "
4125                                 "device might be broken.\n", dev->name);
4126                         return -EOVERFLOW;
4127                 }
4128         }
4129         if (dev->flags ^ old_flags) {
4130                 dev_change_rx_flags(dev, IFF_ALLMULTI);
4131                 dev_set_rx_mode(dev);
4132         }
4133         return 0;
4134 }
4135 EXPORT_SYMBOL(dev_set_allmulti);
4136
4137 /*
4138  *      Upload unicast and multicast address lists to device and
4139  *      configure RX filtering. When the device doesn't support unicast
4140  *      filtering it is put in promiscuous mode while unicast addresses
4141  *      are present.
4142  */
4143 void __dev_set_rx_mode(struct net_device *dev)
4144 {
4145         const struct net_device_ops *ops = dev->netdev_ops;
4146
4147         /* dev_open will call this function so the list will stay sane. */
4148         if (!(dev->flags&IFF_UP))
4149                 return;
4150
4151         if (!netif_device_present(dev))
4152                 return;
4153
4154         if (ops->ndo_set_rx_mode)
4155                 ops->ndo_set_rx_mode(dev);
4156         else {
4157                 /* Unicast addresses changes may only happen under the rtnl,
4158                  * therefore calling __dev_set_promiscuity here is safe.
4159                  */
4160                 if (!netdev_uc_empty(dev) && !dev->uc_promisc) {
4161                         __dev_set_promiscuity(dev, 1);
4162                         dev->uc_promisc = 1;
4163                 } else if (netdev_uc_empty(dev) && dev->uc_promisc) {
4164                         __dev_set_promiscuity(dev, -1);
4165                         dev->uc_promisc = 0;
4166                 }
4167
4168                 if (ops->ndo_set_multicast_list)
4169                         ops->ndo_set_multicast_list(dev);
4170         }
4171 }
4172
4173 void dev_set_rx_mode(struct net_device *dev)
4174 {
4175         netif_addr_lock_bh(dev);
4176         __dev_set_rx_mode(dev);
4177         netif_addr_unlock_bh(dev);
4178 }
4179
4180 /**
4181  *      dev_get_flags - get flags reported to userspace
4182  *      @dev: device
4183  *
4184  *      Get the combination of flag bits exported through APIs to userspace.
4185  */
4186 unsigned dev_get_flags(const struct net_device *dev)
4187 {
4188         unsigned flags;
4189
4190         flags = (dev->flags & ~(IFF_PROMISC |
4191                                 IFF_ALLMULTI |
4192                                 IFF_RUNNING |
4193                                 IFF_LOWER_UP |
4194                                 IFF_DORMANT)) |
4195                 (dev->gflags & (IFF_PROMISC |
4196                                 IFF_ALLMULTI));
4197
4198         if (netif_running(dev)) {
4199                 if (netif_oper_up(dev))
4200                         flags |= IFF_RUNNING;
4201                 if (netif_carrier_ok(dev))
4202                         flags |= IFF_LOWER_UP;
4203                 if (netif_dormant(dev))
4204                         flags |= IFF_DORMANT;
4205         }
4206
4207         return flags;
4208 }
4209 EXPORT_SYMBOL(dev_get_flags);
4210
4211 int __dev_change_flags(struct net_device *dev, unsigned int flags)
4212 {
4213         int old_flags = dev->flags;
4214         int ret;
4215
4216         ASSERT_RTNL();
4217
4218         /*
4219          *      Set the flags on our device.
4220          */
4221
4222         dev->flags = (flags & (IFF_DEBUG | IFF_NOTRAILERS | IFF_NOARP |
4223                                IFF_DYNAMIC | IFF_MULTICAST | IFF_PORTSEL |
4224                                IFF_AUTOMEDIA)) |
4225                      (dev->flags & (IFF_UP | IFF_VOLATILE | IFF_PROMISC |
4226                                     IFF_ALLMULTI));
4227
4228         /*
4229          *      Load in the correct multicast list now the flags have changed.
4230          */
4231
4232         if ((old_flags ^ flags) & IFF_MULTICAST)
4233                 dev_change_rx_flags(dev, IFF_MULTICAST);
4234
4235         dev_set_rx_mode(dev);
4236
4237         /*
4238          *      Have we downed the interface. We handle IFF_UP ourselves
4239          *      according to user attempts to set it, rather than blindly
4240          *      setting it.
4241          */
4242
4243         ret = 0;
4244         if ((old_flags ^ flags) & IFF_UP) {     /* Bit is different  ? */
4245                 ret = ((old_flags & IFF_UP) ? __dev_close : __dev_open)(dev);
4246
4247                 if (!ret)
4248                         dev_set_rx_mode(dev);
4249         }
4250
4251         if ((flags ^ dev->gflags) & IFF_PROMISC) {
4252                 int inc = (flags & IFF_PROMISC) ? 1 : -1;
4253
4254                 dev->gflags ^= IFF_PROMISC;
4255                 dev_set_promiscuity(dev, inc);
4256         }
4257
4258         /* NOTE: order of synchronization of IFF_PROMISC and IFF_ALLMULTI
4259            is important. Some (broken) drivers set IFF_PROMISC, when
4260            IFF_ALLMULTI is requested not asking us and not reporting.
4261          */
4262         if ((flags ^ dev->gflags) & IFF_ALLMULTI) {
4263                 int inc = (flags & IFF_ALLMULTI) ? 1 : -1;
4264
4265                 dev->gflags ^= IFF_ALLMULTI;
4266                 dev_set_allmulti(dev, inc);
4267         }
4268
4269         return ret;
4270 }
4271
4272 void __dev_notify_flags(struct net_device *dev, unsigned int old_flags)
4273 {
4274         unsigned int changes = dev->flags ^ old_flags;
4275
4276         if (changes & IFF_UP) {
4277                 if (dev->flags & IFF_UP)
4278                         call_netdevice_notifiers(NETDEV_UP, dev);
4279                 else
4280                         call_netdevice_notifiers(NETDEV_DOWN, dev);
4281         }
4282
4283         if (dev->flags & IFF_UP &&
4284             (changes & ~(IFF_UP | IFF_PROMISC | IFF_ALLMULTI | IFF_VOLATILE)))
4285                 call_netdevice_notifiers(NETDEV_CHANGE, dev);
4286 }
4287
4288 /**
4289  *      dev_change_flags - change device settings
4290  *      @dev: device
4291  *      @flags: device state flags
4292  *
4293  *      Change settings on device based state flags. The flags are
4294  *      in the userspace exported format.
4295  */
4296 int dev_change_flags(struct net_device *dev, unsigned flags)
4297 {
4298         int ret, changes;
4299         int old_flags = dev->flags;
4300
4301         ret = __dev_change_flags(dev, flags);
4302         if (ret < 0)
4303                 return ret;
4304
4305         changes = old_flags ^ dev->flags;
4306         if (changes)
4307                 rtmsg_ifinfo(RTM_NEWLINK, dev, changes);
4308
4309         __dev_notify_flags(dev, old_flags);
4310         return ret;
4311 }
4312 EXPORT_SYMBOL(dev_change_flags);
4313
4314 /**
4315  *      dev_set_mtu - Change maximum transfer unit
4316  *      @dev: device
4317  *      @new_mtu: new transfer unit
4318  *
4319  *      Change the maximum transfer size of the network device.
4320  */
4321 int dev_set_mtu(struct net_device *dev, int new_mtu)
4322 {
4323         const struct net_device_ops *ops = dev->netdev_ops;
4324         int err;
4325
4326         if (new_mtu == dev->mtu)
4327                 return 0;
4328
4329         /*      MTU must be positive.    */
4330         if (new_mtu < 0)
4331                 return -EINVAL;
4332
4333         if (!netif_device_present(dev))
4334                 return -ENODEV;
4335
4336         err = 0;
4337         if (ops->ndo_change_mtu)
4338                 err = ops->ndo_change_mtu(dev, new_mtu);
4339         else
4340                 dev->mtu = new_mtu;
4341
4342         if (!err && dev->flags & IFF_UP)
4343                 call_netdevice_notifiers(NETDEV_CHANGEMTU, dev);
4344         return err;
4345 }
4346 EXPORT_SYMBOL(dev_set_mtu);
4347
4348 /**
4349  *      dev_set_mac_address - Change Media Access Control Address
4350  *      @dev: device
4351  *      @sa: new address
4352  *
4353  *      Change the hardware (MAC) address of the device
4354  */
4355 int dev_set_mac_address(struct net_device *dev, struct sockaddr *sa)
4356 {
4357         const struct net_device_ops *ops = dev->netdev_ops;
4358         int err;
4359
4360         if (!ops->ndo_set_mac_address)
4361                 return -EOPNOTSUPP;
4362         if (sa->sa_family != dev->type)
4363                 return -EINVAL;
4364         if (!netif_device_present(dev))
4365                 return -ENODEV;
4366         err = ops->ndo_set_mac_address(dev, sa);
4367         if (!err)
4368                 call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
4369         return err;
4370 }
4371 EXPORT_SYMBOL(dev_set_mac_address);
4372
4373 /*
4374  *      Perform the SIOCxIFxxx calls, inside rcu_read_lock()
4375  */
4376 static int dev_ifsioc_locked(struct net *net, struct ifreq *ifr, unsigned int cmd)
4377 {
4378         int err;
4379         struct net_device *dev = dev_get_by_name_rcu(net, ifr->ifr_name);
4380
4381         if (!dev)
4382                 return -ENODEV;
4383
4384         switch (cmd) {
4385         case SIOCGIFFLAGS:      /* Get interface flags */
4386                 ifr->ifr_flags = (short) dev_get_flags(dev);
4387                 return 0;
4388
4389         case SIOCGIFMETRIC:     /* Get the metric on the interface
4390                                    (currently unused) */
4391                 ifr->ifr_metric = 0;
4392                 return 0;
4393
4394         case SIOCGIFMTU:        /* Get the MTU of a device */
4395                 ifr->ifr_mtu = dev->mtu;
4396                 return 0;
4397
4398         case SIOCGIFHWADDR:
4399                 if (!dev->addr_len)
4400                         memset(ifr->ifr_hwaddr.sa_data, 0, sizeof ifr->ifr_hwaddr.sa_data);
4401                 else
4402                         memcpy(ifr->ifr_hwaddr.sa_data, dev->dev_addr,
4403                                min(sizeof ifr->ifr_hwaddr.sa_data, (size_t) dev->addr_len));
4404                 ifr->ifr_hwaddr.sa_family = dev->type;
4405                 return 0;
4406
4407         case SIOCGIFSLAVE:
4408                 err = -EINVAL;
4409                 break;
4410
4411         case SIOCGIFMAP:
4412                 ifr->ifr_map.mem_start = dev->mem_start;
4413                 ifr->ifr_map.mem_end   = dev->mem_end;
4414                 ifr->ifr_map.base_addr = dev->base_addr;
4415                 ifr->ifr_map.irq       = dev->irq;
4416                 ifr->ifr_map.dma       = dev->dma;
4417                 ifr->ifr_map.port      = dev->if_port;
4418                 return 0;
4419
4420         case SIOCGIFINDEX:
4421                 ifr->ifr_ifindex = dev->ifindex;
4422                 return 0;
4423
4424         case SIOCGIFTXQLEN:
4425                 ifr->ifr_qlen = dev->tx_queue_len;
4426                 return 0;
4427
4428         default:
4429                 /* dev_ioctl() should ensure this case
4430                  * is never reached
4431                  */
4432                 WARN_ON(1);
4433                 err = -EINVAL;
4434                 break;
4435
4436         }
4437         return err;
4438 }
4439
4440 /*
4441  *      Perform the SIOCxIFxxx calls, inside rtnl_lock()
4442  */
4443 static int dev_ifsioc(struct net *net, struct ifreq *ifr, unsigned int cmd)
4444 {
4445         int err;
4446         struct net_device *dev = __dev_get_by_name(net, ifr->ifr_name);
4447         const struct net_device_ops *ops;
4448
4449         if (!dev)
4450                 return -ENODEV;
4451
4452         ops = dev->netdev_ops;
4453
4454         switch (cmd) {
4455         case SIOCSIFFLAGS:      /* Set interface flags */
4456                 return dev_change_flags(dev, ifr->ifr_flags);
4457
4458         case SIOCSIFMETRIC:     /* Set the metric on the interface
4459                                    (currently unused) */
4460                 return -EOPNOTSUPP;
4461
4462         case SIOCSIFMTU:        /* Set the MTU of a device */
4463                 return dev_set_mtu(dev, ifr->ifr_mtu);
4464
4465         case SIOCSIFHWADDR:
4466                 return dev_set_mac_address(dev, &ifr->ifr_hwaddr);
4467
4468         case SIOCSIFHWBROADCAST:
4469                 if (ifr->ifr_hwaddr.sa_family != dev->type)
4470                         return -EINVAL;
4471                 memcpy(dev->broadcast, ifr->ifr_hwaddr.sa_data,
4472                        min(sizeof ifr->ifr_hwaddr.sa_data, (size_t) dev->addr_len));
4473                 call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
4474                 return 0;
4475
4476         case SIOCSIFMAP:
4477                 if (ops->ndo_set_config) {
4478                         if (!netif_device_present(dev))
4479                                 return -ENODEV;
4480                         return ops->ndo_set_config(dev, &ifr->ifr_map);
4481                 }
4482                 return -EOPNOTSUPP;
4483
4484         case SIOCADDMULTI:
4485                 if ((!ops->ndo_set_multicast_list && !ops->ndo_set_rx_mode) ||
4486                     ifr->ifr_hwaddr.sa_family != AF_UNSPEC)
4487                         return -EINVAL;
4488                 if (!netif_device_present(dev))
4489                         return -ENODEV;
4490                 return dev_mc_add_global(dev, ifr->ifr_hwaddr.sa_data);
4491
4492         case SIOCDELMULTI:
4493                 if ((!ops->ndo_set_multicast_list && !ops->ndo_set_rx_mode) ||
4494                     ifr->ifr_hwaddr.sa_family != AF_UNSPEC)
4495                         return -EINVAL;
4496                 if (!netif_device_present(dev))
4497                         return -ENODEV;
4498                 return dev_mc_del_global(dev, ifr->ifr_hwaddr.sa_data);
4499
4500         case SIOCSIFTXQLEN:
4501                 if (ifr->ifr_qlen < 0)
4502                         return -EINVAL;
4503                 dev->tx_queue_len = ifr->ifr_qlen;
4504                 return 0;
4505
4506         case SIOCSIFNAME:
4507                 ifr->ifr_newname[IFNAMSIZ-1] = '\0';
4508                 return dev_change_name(dev, ifr->ifr_newname);
4509
4510         /*
4511          *      Unknown or private ioctl
4512          */
4513         default:
4514                 if ((cmd >= SIOCDEVPRIVATE &&
4515                     cmd <= SIOCDEVPRIVATE + 15) ||
4516                     cmd == SIOCBONDENSLAVE ||
4517                     cmd == SIOCBONDRELEASE ||
4518                     cmd == SIOCBONDSETHWADDR ||
4519                     cmd == SIOCBONDSLAVEINFOQUERY ||
4520                     cmd == SIOCBONDINFOQUERY ||
4521                     cmd == SIOCBONDCHANGEACTIVE ||
4522                     cmd == SIOCGMIIPHY ||
4523                     cmd == SIOCGMIIREG ||
4524                     cmd == SIOCSMIIREG ||
4525                     cmd == SIOCBRADDIF ||
4526                     cmd == SIOCBRDELIF ||
4527                     cmd == SIOCSHWTSTAMP ||
4528                     cmd == SIOCWANDEV) {
4529                         err = -EOPNOTSUPP;
4530                         if (ops->ndo_do_ioctl) {
4531                                 if (netif_device_present(dev))
4532                                         err = ops->ndo_do_ioctl(dev, ifr, cmd);
4533                                 else
4534                                         err = -ENODEV;
4535                         }
4536                 } else
4537                         err = -EINVAL;
4538
4539         }
4540         return err;
4541 }
4542
4543 /*
4544  *      This function handles all "interface"-type I/O control requests. The actual
4545  *      'doing' part of this is dev_ifsioc above.
4546  */
4547
4548 /**
4549  *      dev_ioctl       -       network device ioctl
4550  *      @net: the applicable net namespace
4551  *      @cmd: command to issue
4552  *      @arg: pointer to a struct ifreq in user space
4553  *
4554  *      Issue ioctl functions to devices. This is normally called by the
4555  *      user space syscall interfaces but can sometimes be useful for
4556  *      other purposes. The return value is the return from the syscall if
4557  *      positive or a negative errno code on error.
4558  */
4559
4560 int dev_ioctl(struct net *net, unsigned int cmd, void __user *arg)
4561 {
4562         struct ifreq ifr;
4563         int ret;
4564         char *colon;
4565
4566         /* One special case: SIOCGIFCONF takes ifconf argument
4567            and requires shared lock, because it sleeps writing
4568            to user space.
4569          */
4570
4571         if (cmd == SIOCGIFCONF) {
4572                 rtnl_lock();
4573                 ret = dev_ifconf(net, (char __user *) arg);
4574                 rtnl_unlock();
4575                 return ret;
4576         }
4577         if (cmd == SIOCGIFNAME)
4578                 return dev_ifname(net, (struct ifreq __user *)arg);
4579
4580         if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
4581                 return -EFAULT;
4582
4583         ifr.ifr_name[IFNAMSIZ-1] = 0;
4584
4585         colon = strchr(ifr.ifr_name, ':');
4586         if (colon)
4587                 *colon = 0;
4588
4589         /*
4590          *      See which interface the caller is talking about.
4591          */
4592
4593         switch (cmd) {
4594         /*
4595          *      These ioctl calls:
4596          *      - can be done by all.
4597          *      - atomic and do not require locking.
4598          *      - return a value
4599          */
4600         case SIOCGIFFLAGS:
4601         case SIOCGIFMETRIC:
4602         case SIOCGIFMTU:
4603         case SIOCGIFHWADDR:
4604         case SIOCGIFSLAVE:
4605         case SIOCGIFMAP:
4606         case SIOCGIFINDEX:
4607         case SIOCGIFTXQLEN:
4608                 dev_load(net, ifr.ifr_name);
4609                 rcu_read_lock();
4610                 ret = dev_ifsioc_locked(net, &ifr, cmd);
4611                 rcu_read_unlock();
4612                 if (!ret) {
4613                         if (colon)
4614                                 *colon = ':';
4615                         if (copy_to_user(arg, &ifr,
4616                                          sizeof(struct ifreq)))
4617                                 ret = -EFAULT;
4618                 }
4619                 return ret;
4620
4621         case SIOCETHTOOL:
4622                 dev_load(net, ifr.ifr_name);
4623                 rtnl_lock();
4624                 ret = dev_ethtool(net, &ifr);
4625                 rtnl_unlock();
4626                 if (!ret) {
4627                         if (colon)
4628                                 *colon = ':';
4629                         if (copy_to_user(arg, &ifr,
4630                                          sizeof(struct ifreq)))
4631                                 ret = -EFAULT;
4632                 }
4633                 return ret;
4634
4635         /*
4636          *      These ioctl calls:
4637          *      - require superuser power.
4638          *      - require strict serialization.
4639          *      - return a value
4640          */
4641         case SIOCGMIIPHY:
4642         case SIOCGMIIREG:
4643         case SIOCSIFNAME:
4644                 if (!capable(CAP_NET_ADMIN))
4645                         return -EPERM;
4646                 dev_load(net, ifr.ifr_name);
4647                 rtnl_lock();
4648                 ret = dev_ifsioc(net, &ifr, cmd);
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          *      - do not return a value
4664          */
4665         case SIOCSIFFLAGS:
4666         case SIOCSIFMETRIC:
4667         case SIOCSIFMTU:
4668         case SIOCSIFMAP:
4669         case SIOCSIFHWADDR:
4670         case SIOCSIFSLAVE:
4671         case SIOCADDMULTI:
4672         case SIOCDELMULTI:
4673         case SIOCSIFHWBROADCAST:
4674         case SIOCSIFTXQLEN:
4675         case SIOCSMIIREG:
4676         case SIOCBONDENSLAVE:
4677         case SIOCBONDRELEASE:
4678         case SIOCBONDSETHWADDR:
4679         case SIOCBONDCHANGEACTIVE:
4680         case SIOCBRADDIF:
4681         case SIOCBRDELIF:
4682         case SIOCSHWTSTAMP:
4683                 if (!capable(CAP_NET_ADMIN))
4684                         return -EPERM;
4685                 /* fall through */
4686         case SIOCBONDSLAVEINFOQUERY:
4687         case SIOCBONDINFOQUERY:
4688                 dev_load(net, ifr.ifr_name);
4689                 rtnl_lock();
4690                 ret = dev_ifsioc(net, &ifr, cmd);
4691                 rtnl_unlock();
4692                 return ret;
4693
4694         case SIOCGIFMEM:
4695                 /* Get the per device memory space. We can add this but
4696                  * currently do not support it */
4697         case SIOCSIFMEM:
4698                 /* Set the per device memory buffer space.
4699                  * Not applicable in our case */
4700         case SIOCSIFLINK:
4701                 return -EINVAL;
4702
4703         /*
4704          *      Unknown or private ioctl.
4705          */
4706         default:
4707                 if (cmd == SIOCWANDEV ||
4708                     (cmd >= SIOCDEVPRIVATE &&
4709                      cmd <= SIOCDEVPRIVATE + 15)) {
4710                         dev_load(net, ifr.ifr_name);
4711                         rtnl_lock();
4712                         ret = dev_ifsioc(net, &ifr, cmd);
4713                         rtnl_unlock();
4714                         if (!ret && copy_to_user(arg, &ifr,
4715                                                  sizeof(struct ifreq)))
4716                                 ret = -EFAULT;
4717                         return ret;
4718                 }
4719                 /* Take care of Wireless Extensions */
4720                 if (cmd >= SIOCIWFIRST && cmd <= SIOCIWLAST)
4721                         return wext_handle_ioctl(net, &ifr, cmd, arg);
4722                 return -EINVAL;
4723         }
4724 }
4725
4726
4727 /**
4728  *      dev_new_index   -       allocate an ifindex
4729  *      @net: the applicable net namespace
4730  *
4731  *      Returns a suitable unique value for a new device interface
4732  *      number.  The caller must hold the rtnl semaphore or the
4733  *      dev_base_lock to be sure it remains unique.
4734  */
4735 static int dev_new_index(struct net *net)
4736 {
4737         static int ifindex;
4738         for (;;) {
4739                 if (++ifindex <= 0)
4740                         ifindex = 1;
4741                 if (!__dev_get_by_index(net, ifindex))
4742                         return ifindex;
4743         }
4744 }
4745
4746 /* Delayed registration/unregisteration */
4747 static LIST_HEAD(net_todo_list);
4748
4749 static void net_set_todo(struct net_device *dev)
4750 {
4751         list_add_tail(&dev->todo_list, &net_todo_list);
4752 }
4753
4754 static void rollback_registered_many(struct list_head *head)
4755 {
4756         struct net_device *dev, *tmp;
4757
4758         BUG_ON(dev_boot_phase);
4759         ASSERT_RTNL();
4760
4761         list_for_each_entry_safe(dev, tmp, head, unreg_list) {
4762                 /* Some devices call without registering
4763                  * for initialization unwind. Remove those
4764                  * devices and proceed with the remaining.
4765                  */
4766                 if (dev->reg_state == NETREG_UNINITIALIZED) {
4767                         pr_debug("unregister_netdevice: device %s/%p never "
4768                                  "was registered\n", dev->name, dev);
4769
4770                         WARN_ON(1);
4771                         list_del(&dev->unreg_list);
4772                         continue;
4773                 }
4774
4775                 BUG_ON(dev->reg_state != NETREG_REGISTERED);
4776
4777                 /* If device is running, close it first. */
4778                 dev_close(dev);
4779
4780                 /* And unlink it from device chain. */
4781                 unlist_netdevice(dev);
4782
4783                 dev->reg_state = NETREG_UNREGISTERING;
4784         }
4785
4786         synchronize_net();
4787
4788         list_for_each_entry(dev, head, unreg_list) {
4789                 /* Shutdown queueing discipline. */
4790                 dev_shutdown(dev);
4791
4792
4793                 /* Notify protocols, that we are about to destroy
4794                    this device. They should clean all the things.
4795                 */
4796                 call_netdevice_notifiers(NETDEV_UNREGISTER, dev);
4797
4798                 if (!dev->rtnl_link_ops ||
4799                     dev->rtnl_link_state == RTNL_LINK_INITIALIZED)
4800                         rtmsg_ifinfo(RTM_DELLINK, dev, ~0U);
4801
4802                 /*
4803                  *      Flush the unicast and multicast chains
4804                  */
4805                 dev_uc_flush(dev);
4806                 dev_mc_flush(dev);
4807
4808                 if (dev->netdev_ops->ndo_uninit)
4809                         dev->netdev_ops->ndo_uninit(dev);
4810
4811                 /* Notifier chain MUST detach us from master device. */
4812                 WARN_ON(dev->master);
4813
4814                 /* Remove entries from kobject tree */
4815                 netdev_unregister_kobject(dev);
4816         }
4817
4818         /* Process any work delayed until the end of the batch */
4819         dev = list_first_entry(head, struct net_device, unreg_list);
4820         call_netdevice_notifiers(NETDEV_UNREGISTER_BATCH, dev);
4821
4822         synchronize_net();
4823
4824         list_for_each_entry(dev, head, unreg_list)
4825                 dev_put(dev);
4826 }
4827
4828 static void rollback_registered(struct net_device *dev)
4829 {
4830         LIST_HEAD(single);
4831
4832         list_add(&dev->unreg_list, &single);
4833         rollback_registered_many(&single);
4834 }
4835
4836 static void __netdev_init_queue_locks_one(struct net_device *dev,
4837                                           struct netdev_queue *dev_queue,
4838                                           void *_unused)
4839 {
4840         spin_lock_init(&dev_queue->_xmit_lock);
4841         netdev_set_xmit_lockdep_class(&dev_queue->_xmit_lock, dev->type);
4842         dev_queue->xmit_lock_owner = -1;
4843 }
4844
4845 static void netdev_init_queue_locks(struct net_device *dev)
4846 {
4847         netdev_for_each_tx_queue(dev, __netdev_init_queue_locks_one, NULL);
4848         __netdev_init_queue_locks_one(dev, &dev->rx_queue, NULL);
4849 }
4850
4851 unsigned long netdev_fix_features(unsigned long features, const char *name)
4852 {
4853         /* Fix illegal SG+CSUM combinations. */
4854         if ((features & NETIF_F_SG) &&
4855             !(features & NETIF_F_ALL_CSUM)) {
4856                 if (name)
4857                         printk(KERN_NOTICE "%s: Dropping NETIF_F_SG since no "
4858                                "checksum feature.\n", name);
4859                 features &= ~NETIF_F_SG;
4860         }
4861
4862         /* TSO requires that SG is present as well. */
4863         if ((features & NETIF_F_TSO) && !(features & NETIF_F_SG)) {
4864                 if (name)
4865                         printk(KERN_NOTICE "%s: Dropping NETIF_F_TSO since no "
4866                                "SG feature.\n", name);
4867                 features &= ~NETIF_F_TSO;
4868         }
4869
4870         if (features & NETIF_F_UFO) {
4871                 if (!(features & NETIF_F_GEN_CSUM)) {
4872                         if (name)
4873                                 printk(KERN_ERR "%s: Dropping NETIF_F_UFO "
4874                                        "since no NETIF_F_HW_CSUM feature.\n",
4875                                        name);
4876                         features &= ~NETIF_F_UFO;
4877                 }
4878
4879                 if (!(features & NETIF_F_SG)) {
4880                         if (name)
4881                                 printk(KERN_ERR "%s: Dropping NETIF_F_UFO "
4882                                        "since no NETIF_F_SG feature.\n", name);
4883                         features &= ~NETIF_F_UFO;
4884                 }
4885         }
4886
4887         return features;
4888 }
4889 EXPORT_SYMBOL(netdev_fix_features);
4890
4891 /**
4892  *      netif_stacked_transfer_operstate -      transfer operstate
4893  *      @rootdev: the root or lower level device to transfer state from
4894  *      @dev: the device to transfer operstate to
4895  *
4896  *      Transfer operational state from root to device. This is normally
4897  *      called when a stacking relationship exists between the root
4898  *      device and the device(a leaf device).
4899  */
4900 void netif_stacked_transfer_operstate(const struct net_device *rootdev,
4901                                         struct net_device *dev)
4902 {
4903         if (rootdev->operstate == IF_OPER_DORMANT)
4904                 netif_dormant_on(dev);
4905         else
4906                 netif_dormant_off(dev);
4907
4908         if (netif_carrier_ok(rootdev)) {
4909                 if (!netif_carrier_ok(dev))
4910                         netif_carrier_on(dev);
4911         } else {
4912                 if (netif_carrier_ok(dev))
4913                         netif_carrier_off(dev);
4914         }
4915 }
4916 EXPORT_SYMBOL(netif_stacked_transfer_operstate);
4917
4918 /**
4919  *      register_netdevice      - register a network device
4920  *      @dev: device to register
4921  *
4922  *      Take a completed network device structure and add it to the kernel
4923  *      interfaces. A %NETDEV_REGISTER message is sent to the netdev notifier
4924  *      chain. 0 is returned on success. A negative errno code is returned
4925  *      on a failure to set up the device, or if the name is a duplicate.
4926  *
4927  *      Callers must hold the rtnl semaphore. You may want
4928  *      register_netdev() instead of this.
4929  *
4930  *      BUGS:
4931  *      The locking appears insufficient to guarantee two parallel registers
4932  *      will not get the same name.
4933  */
4934
4935 int register_netdevice(struct net_device *dev)
4936 {
4937         int ret;
4938         struct net *net = dev_net(dev);
4939
4940         BUG_ON(dev_boot_phase);
4941         ASSERT_RTNL();
4942
4943         might_sleep();
4944
4945         /* When net_device's are persistent, this will be fatal. */
4946         BUG_ON(dev->reg_state != NETREG_UNINITIALIZED);
4947         BUG_ON(!net);
4948
4949         spin_lock_init(&dev->addr_list_lock);
4950         netdev_set_addr_lockdep_class(dev);
4951         netdev_init_queue_locks(dev);
4952
4953         dev->iflink = -1;
4954
4955 #ifdef CONFIG_RPS
4956         if (!dev->num_rx_queues) {
4957                 /*
4958                  * Allocate a single RX queue if driver never called
4959                  * alloc_netdev_mq
4960                  */
4961
4962                 dev->_rx = kzalloc(sizeof(struct netdev_rx_queue), GFP_KERNEL);
4963                 if (!dev->_rx) {
4964                         ret = -ENOMEM;
4965                         goto out;
4966                 }
4967
4968                 dev->_rx->first = dev->_rx;
4969                 atomic_set(&dev->_rx->count, 1);
4970                 dev->num_rx_queues = 1;
4971         }
4972 #endif
4973         /* Init, if this function is available */
4974         if (dev->netdev_ops->ndo_init) {
4975                 ret = dev->netdev_ops->ndo_init(dev);
4976                 if (ret) {
4977                         if (ret > 0)
4978                                 ret = -EIO;
4979                         goto out;
4980                 }
4981         }
4982
4983         ret = dev_get_valid_name(dev, dev->name, 0);
4984         if (ret)
4985                 goto err_uninit;
4986
4987         dev->ifindex = dev_new_index(net);
4988         if (dev->iflink == -1)
4989                 dev->iflink = dev->ifindex;
4990
4991         /* Fix illegal checksum combinations */
4992         if ((dev->features & NETIF_F_HW_CSUM) &&
4993             (dev->features & (NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM))) {
4994                 printk(KERN_NOTICE "%s: mixed HW and IP checksum settings.\n",
4995                        dev->name);
4996                 dev->features &= ~(NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM);
4997         }
4998
4999         if ((dev->features & NETIF_F_NO_CSUM) &&
5000             (dev->features & (NETIF_F_HW_CSUM|NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM))) {
5001                 printk(KERN_NOTICE "%s: mixed no checksumming and other settings.\n",
5002                        dev->name);
5003                 dev->features &= ~(NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM|NETIF_F_HW_CSUM);
5004         }
5005
5006         dev->features = netdev_fix_features(dev->features, dev->name);
5007
5008         /* Enable software GSO if SG is supported. */
5009         if (dev->features & NETIF_F_SG)
5010                 dev->features |= NETIF_F_GSO;
5011
5012         ret = call_netdevice_notifiers(NETDEV_POST_INIT, dev);
5013         ret = notifier_to_errno(ret);
5014         if (ret)
5015                 goto err_uninit;
5016
5017         ret = netdev_register_kobject(dev);
5018         if (ret)
5019                 goto err_uninit;
5020         dev->reg_state = NETREG_REGISTERED;
5021
5022         /*
5023          *      Default initial state at registry is that the
5024          *      device is present.
5025          */
5026
5027         set_bit(__LINK_STATE_PRESENT, &dev->state);
5028
5029         dev_init_scheduler(dev);
5030         dev_hold(dev);
5031         list_netdevice(dev);
5032
5033         /* Notify protocols, that a new device appeared. */
5034         ret = call_netdevice_notifiers(NETDEV_REGISTER, dev);
5035         ret = notifier_to_errno(ret);
5036         if (ret) {
5037                 rollback_registered(dev);
5038                 dev->reg_state = NETREG_UNREGISTERED;
5039         }
5040         /*
5041          *      Prevent userspace races by waiting until the network
5042          *      device is fully setup before sending notifications.
5043          */
5044         if (!dev->rtnl_link_ops ||
5045             dev->rtnl_link_state == RTNL_LINK_INITIALIZED)
5046                 rtmsg_ifinfo(RTM_NEWLINK, dev, ~0U);
5047
5048 out:
5049         return ret;
5050
5051 err_uninit:
5052         if (dev->netdev_ops->ndo_uninit)
5053                 dev->netdev_ops->ndo_uninit(dev);
5054         goto out;
5055 }
5056 EXPORT_SYMBOL(register_netdevice);
5057
5058 /**
5059  *      init_dummy_netdev       - init a dummy network device for NAPI
5060  *      @dev: device to init
5061  *
5062  *      This takes a network device structure and initialize the minimum
5063  *      amount of fields so it can be used to schedule NAPI polls without
5064  *      registering a full blown interface. This is to be used by drivers
5065  *      that need to tie several hardware interfaces to a single NAPI
5066  *      poll scheduler due to HW limitations.
5067  */
5068 int init_dummy_netdev(struct net_device *dev)
5069 {
5070         /* Clear everything. Note we don't initialize spinlocks
5071          * are they aren't supposed to be taken by any of the
5072          * NAPI code and this dummy netdev is supposed to be
5073          * only ever used for NAPI polls
5074          */
5075         memset(dev, 0, sizeof(struct net_device));
5076
5077         /* make sure we BUG if trying to hit standard
5078          * register/unregister code path
5079          */
5080         dev->reg_state = NETREG_DUMMY;
5081
5082         /* initialize the ref count */
5083         atomic_set(&dev->refcnt, 1);
5084
5085         /* NAPI wants this */
5086         INIT_LIST_HEAD(&dev->napi_list);
5087
5088         /* a dummy interface is started by default */
5089         set_bit(__LINK_STATE_PRESENT, &dev->state);
5090         set_bit(__LINK_STATE_START, &dev->state);
5091
5092         return 0;
5093 }
5094 EXPORT_SYMBOL_GPL(init_dummy_netdev);
5095
5096
5097 /**
5098  *      register_netdev - register a network device
5099  *      @dev: device to register
5100  *
5101  *      Take a completed network device structure and add it to the kernel
5102  *      interfaces. A %NETDEV_REGISTER message is sent to the netdev notifier
5103  *      chain. 0 is returned on success. A negative errno code is returned
5104  *      on a failure to set up the device, or if the name is a duplicate.
5105  *
5106  *      This is a wrapper around register_netdevice that takes the rtnl semaphore
5107  *      and expands the device name if you passed a format string to
5108  *      alloc_netdev.
5109  */
5110 int register_netdev(struct net_device *dev)
5111 {
5112         int err;
5113
5114         rtnl_lock();
5115
5116         /*
5117          * If the name is a format string the caller wants us to do a
5118          * name allocation.
5119          */
5120         if (strchr(dev->name, '%')) {
5121                 err = dev_alloc_name(dev, dev->name);
5122                 if (err < 0)
5123                         goto out;
5124         }
5125
5126         err = register_netdevice(dev);
5127 out:
5128         rtnl_unlock();
5129         return err;
5130 }
5131 EXPORT_SYMBOL(register_netdev);
5132
5133 /*
5134  * netdev_wait_allrefs - wait until all references are gone.
5135  *
5136  * This is called when unregistering network devices.
5137  *
5138  * Any protocol or device that holds a reference should register
5139  * for netdevice notification, and cleanup and put back the
5140  * reference if they receive an UNREGISTER event.
5141  * We can get stuck here if buggy protocols don't correctly
5142  * call dev_put.
5143  */
5144 static void netdev_wait_allrefs(struct net_device *dev)
5145 {
5146         unsigned long rebroadcast_time, warning_time;
5147
5148         linkwatch_forget_dev(dev);
5149
5150         rebroadcast_time = warning_time = jiffies;
5151         while (atomic_read(&dev->refcnt) != 0) {
5152                 if (time_after(jiffies, rebroadcast_time + 1 * HZ)) {
5153                         rtnl_lock();
5154
5155                         /* Rebroadcast unregister notification */
5156                         call_netdevice_notifiers(NETDEV_UNREGISTER, dev);
5157                         /* don't resend NETDEV_UNREGISTER_BATCH, _BATCH users
5158                          * should have already handle it the first time */
5159
5160                         if (test_bit(__LINK_STATE_LINKWATCH_PENDING,
5161                                      &dev->state)) {
5162                                 /* We must not have linkwatch events
5163                                  * pending on unregister. If this
5164                                  * happens, we simply run the queue
5165                                  * unscheduled, resulting in a noop
5166                                  * for this device.
5167                                  */
5168                                 linkwatch_run_queue();
5169                         }
5170
5171                         __rtnl_unlock();
5172
5173                         rebroadcast_time = jiffies;
5174                 }
5175
5176                 msleep(250);
5177
5178                 if (time_after(jiffies, warning_time + 10 * HZ)) {
5179                         printk(KERN_EMERG "unregister_netdevice: "
5180                                "waiting for %s to become free. Usage "
5181                                "count = %d\n",
5182                                dev->name, atomic_read(&dev->refcnt));
5183                         warning_time = jiffies;
5184                 }
5185         }
5186 }
5187
5188 /* The sequence is:
5189  *
5190  *      rtnl_lock();
5191  *      ...
5192  *      register_netdevice(x1);
5193  *      register_netdevice(x2);
5194  *      ...
5195  *      unregister_netdevice(y1);
5196  *      unregister_netdevice(y2);
5197  *      ...
5198  *      rtnl_unlock();
5199  *      free_netdev(y1);
5200  *      free_netdev(y2);
5201  *
5202  * We are invoked by rtnl_unlock().
5203  * This allows us to deal with problems:
5204  * 1) We can delete sysfs objects which invoke hotplug
5205  *    without deadlocking with linkwatch via keventd.
5206  * 2) Since we run with the RTNL semaphore not held, we can sleep
5207  *    safely in order to wait for the netdev refcnt to drop to zero.
5208  *
5209  * We must not return until all unregister events added during
5210  * the interval the lock was held have been completed.
5211  */
5212 void netdev_run_todo(void)
5213 {
5214         struct list_head list;
5215
5216         /* Snapshot list, allow later requests */
5217         list_replace_init(&net_todo_list, &list);
5218
5219         __rtnl_unlock();
5220
5221         while (!list_empty(&list)) {
5222                 struct net_device *dev
5223                         = list_first_entry(&list, struct net_device, todo_list);
5224                 list_del(&dev->todo_list);
5225
5226                 if (unlikely(dev->reg_state != NETREG_UNREGISTERING)) {
5227                         printk(KERN_ERR "network todo '%s' but state %d\n",
5228                                dev->name, dev->reg_state);
5229                         dump_stack();
5230                         continue;
5231                 }
5232
5233                 dev->reg_state = NETREG_UNREGISTERED;
5234
5235                 on_each_cpu(flush_backlog, dev, 1);
5236
5237                 netdev_wait_allrefs(dev);
5238
5239                 /* paranoia */
5240                 BUG_ON(atomic_read(&dev->refcnt));
5241                 WARN_ON(dev->ip_ptr);
5242                 WARN_ON(dev->ip6_ptr);
5243                 WARN_ON(dev->dn_ptr);
5244
5245                 if (dev->destructor)
5246                         dev->destructor(dev);
5247
5248                 /* Free network device */
5249                 kobject_put(&dev->dev.kobj);
5250         }
5251 }
5252
5253 /**
5254  *      dev_txq_stats_fold - fold tx_queues stats
5255  *      @dev: device to get statistics from
5256  *      @stats: struct net_device_stats to hold results
5257  */
5258 void dev_txq_stats_fold(const struct net_device *dev,
5259                         struct net_device_stats *stats)
5260 {
5261         unsigned long tx_bytes = 0, tx_packets = 0, tx_dropped = 0;
5262         unsigned int i;
5263         struct netdev_queue *txq;
5264
5265         for (i = 0; i < dev->num_tx_queues; i++) {
5266                 txq = netdev_get_tx_queue(dev, i);
5267                 tx_bytes   += txq->tx_bytes;
5268                 tx_packets += txq->tx_packets;
5269                 tx_dropped += txq->tx_dropped;
5270         }
5271         if (tx_bytes || tx_packets || tx_dropped) {
5272                 stats->tx_bytes   = tx_bytes;
5273                 stats->tx_packets = tx_packets;
5274                 stats->tx_dropped = tx_dropped;
5275         }
5276 }
5277 EXPORT_SYMBOL(dev_txq_stats_fold);
5278
5279 /**
5280  *      dev_get_stats   - get network device statistics
5281  *      @dev: device to get statistics from
5282  *
5283  *      Get network statistics from device. The device driver may provide
5284  *      its own method by setting dev->netdev_ops->get_stats64 or
5285  *      dev->netdev_ops->get_stats; otherwise the internal statistics
5286  *      structure is used.
5287  */
5288 const struct rtnl_link_stats64 *dev_get_stats(struct net_device *dev)
5289 {
5290         const struct net_device_ops *ops = dev->netdev_ops;
5291
5292         if (ops->ndo_get_stats64)
5293                 return ops->ndo_get_stats64(dev);
5294         if (ops->ndo_get_stats)
5295                 return (struct rtnl_link_stats64 *)ops->ndo_get_stats(dev);
5296
5297         dev_txq_stats_fold(dev, &dev->stats);
5298         return &dev->stats64;
5299 }
5300 EXPORT_SYMBOL(dev_get_stats);
5301
5302 static void netdev_init_one_queue(struct net_device *dev,
5303                                   struct netdev_queue *queue,
5304                                   void *_unused)
5305 {
5306         queue->dev = dev;
5307 }
5308
5309 static void netdev_init_queues(struct net_device *dev)
5310 {
5311         netdev_init_one_queue(dev, &dev->rx_queue, NULL);
5312         netdev_for_each_tx_queue(dev, netdev_init_one_queue, NULL);
5313         spin_lock_init(&dev->tx_global_lock);
5314 }
5315
5316 /**
5317  *      alloc_netdev_mq - allocate network device
5318  *      @sizeof_priv:   size of private data to allocate space for
5319  *      @name:          device name format string
5320  *      @setup:         callback to initialize device
5321  *      @queue_count:   the number of subqueues to allocate
5322  *
5323  *      Allocates a struct net_device with private data area for driver use
5324  *      and performs basic initialization.  Also allocates subquue structs
5325  *      for each queue on the device at the end of the netdevice.
5326  */
5327 struct net_device *alloc_netdev_mq(int sizeof_priv, const char *name,
5328                 void (*setup)(struct net_device *), unsigned int queue_count)
5329 {
5330         struct netdev_queue *tx;
5331         struct net_device *dev;
5332         size_t alloc_size;
5333         struct net_device *p;
5334 #ifdef CONFIG_RPS
5335         struct netdev_rx_queue *rx;
5336         int i;
5337 #endif
5338
5339         BUG_ON(strlen(name) >= sizeof(dev->name));
5340
5341         alloc_size = sizeof(struct net_device);
5342         if (sizeof_priv) {
5343                 /* ensure 32-byte alignment of private area */
5344                 alloc_size = ALIGN(alloc_size, NETDEV_ALIGN);
5345                 alloc_size += sizeof_priv;
5346         }
5347         /* ensure 32-byte alignment of whole construct */
5348         alloc_size += NETDEV_ALIGN - 1;
5349
5350         p = kzalloc(alloc_size, GFP_KERNEL);
5351         if (!p) {
5352                 printk(KERN_ERR "alloc_netdev: Unable to allocate device.\n");
5353                 return NULL;
5354         }
5355
5356         tx = kcalloc(queue_count, sizeof(struct netdev_queue), GFP_KERNEL);
5357         if (!tx) {
5358                 printk(KERN_ERR "alloc_netdev: Unable to allocate "
5359                        "tx qdiscs.\n");
5360                 goto free_p;
5361         }
5362
5363 #ifdef CONFIG_RPS
5364         rx = kcalloc(queue_count, sizeof(struct netdev_rx_queue), GFP_KERNEL);
5365         if (!rx) {
5366                 printk(KERN_ERR "alloc_netdev: Unable to allocate "
5367                        "rx queues.\n");
5368                 goto free_tx;
5369         }
5370
5371         atomic_set(&rx->count, queue_count);
5372
5373         /*
5374          * Set a pointer to first element in the array which holds the
5375          * reference count.
5376          */
5377         for (i = 0; i < queue_count; i++)
5378                 rx[i].first = rx;
5379 #endif
5380
5381         dev = PTR_ALIGN(p, NETDEV_ALIGN);
5382         dev->padded = (char *)dev - (char *)p;
5383
5384         if (dev_addr_init(dev))
5385                 goto free_rx;
5386
5387         dev_mc_init(dev);
5388         dev_uc_init(dev);
5389
5390         dev_net_set(dev, &init_net);
5391
5392         dev->_tx = tx;
5393         dev->num_tx_queues = queue_count;
5394         dev->real_num_tx_queues = queue_count;
5395
5396 #ifdef CONFIG_RPS
5397         dev->_rx = rx;
5398         dev->num_rx_queues = queue_count;
5399 #endif
5400
5401         dev->gso_max_size = GSO_MAX_SIZE;
5402
5403         netdev_init_queues(dev);
5404
5405         INIT_LIST_HEAD(&dev->ethtool_ntuple_list.list);
5406         dev->ethtool_ntuple_list.count = 0;
5407         INIT_LIST_HEAD(&dev->napi_list);
5408         INIT_LIST_HEAD(&dev->unreg_list);
5409         INIT_LIST_HEAD(&dev->link_watch_list);
5410         dev->priv_flags = IFF_XMIT_DST_RELEASE;
5411         setup(dev);
5412         strcpy(dev->name, name);
5413         return dev;
5414
5415 free_rx:
5416 #ifdef CONFIG_RPS
5417         kfree(rx);
5418 free_tx:
5419 #endif
5420         kfree(tx);
5421 free_p:
5422         kfree(p);
5423         return NULL;
5424 }
5425 EXPORT_SYMBOL(alloc_netdev_mq);
5426
5427 /**
5428  *      free_netdev - free network device
5429  *      @dev: device
5430  *
5431  *      This function does the last stage of destroying an allocated device
5432  *      interface. The reference to the device object is released.
5433  *      If this is the last reference then it will be freed.
5434  */
5435 void free_netdev(struct net_device *dev)
5436 {
5437         struct napi_struct *p, *n;
5438
5439         release_net(dev_net(dev));
5440
5441         kfree(dev->_tx);
5442
5443         /* Flush device addresses */
5444         dev_addr_flush(dev);
5445
5446         /* Clear ethtool n-tuple list */
5447         ethtool_ntuple_flush(dev);
5448
5449         list_for_each_entry_safe(p, n, &dev->napi_list, dev_list)
5450                 netif_napi_del(p);
5451
5452         /*  Compatibility with error handling in drivers */
5453         if (dev->reg_state == NETREG_UNINITIALIZED) {
5454                 kfree((char *)dev - dev->padded);
5455                 return;
5456         }
5457
5458         BUG_ON(dev->reg_state != NETREG_UNREGISTERED);
5459         dev->reg_state = NETREG_RELEASED;
5460
5461         /* will free via device release */
5462         put_device(&dev->dev);
5463 }
5464 EXPORT_SYMBOL(free_netdev);
5465
5466 /**
5467  *      synchronize_net -  Synchronize with packet receive processing
5468  *
5469  *      Wait for packets currently being received to be done.
5470  *      Does not block later packets from starting.
5471  */
5472 void synchronize_net(void)
5473 {
5474         might_sleep();
5475         synchronize_rcu();
5476 }
5477 EXPORT_SYMBOL(synchronize_net);
5478
5479 /**
5480  *      unregister_netdevice_queue - remove device from the kernel
5481  *      @dev: device
5482  *      @head: list
5483  *
5484  *      This function shuts down a device interface and removes it
5485  *      from the kernel tables.
5486  *      If head not NULL, device is queued to be unregistered later.
5487  *
5488  *      Callers must hold the rtnl semaphore.  You may want
5489  *      unregister_netdev() instead of this.
5490  */
5491
5492 void unregister_netdevice_queue(struct net_device *dev, struct list_head *head)
5493 {
5494         ASSERT_RTNL();
5495
5496         if (head) {
5497                 list_move_tail(&dev->unreg_list, head);
5498         } else {
5499                 rollback_registered(dev);
5500                 /* Finish processing unregister after unlock */
5501                 net_set_todo(dev);
5502         }
5503 }
5504 EXPORT_SYMBOL(unregister_netdevice_queue);
5505
5506 /**
5507  *      unregister_netdevice_many - unregister many devices
5508  *      @head: list of devices
5509  */
5510 void unregister_netdevice_many(struct list_head *head)
5511 {
5512         struct net_device *dev;
5513
5514         if (!list_empty(head)) {
5515                 rollback_registered_many(head);
5516                 list_for_each_entry(dev, head, unreg_list)
5517                         net_set_todo(dev);
5518         }
5519 }
5520 EXPORT_SYMBOL(unregister_netdevice_many);
5521
5522 /**
5523  *      unregister_netdev - remove device from the kernel
5524  *      @dev: device
5525  *
5526  *      This function shuts down a device interface and removes it
5527  *      from the kernel tables.
5528  *
5529  *      This is just a wrapper for unregister_netdevice that takes
5530  *      the rtnl semaphore.  In general you want to use this and not
5531  *      unregister_netdevice.
5532  */
5533 void unregister_netdev(struct net_device *dev)
5534 {
5535         rtnl_lock();
5536         unregister_netdevice(dev);
5537         rtnl_unlock();
5538 }
5539 EXPORT_SYMBOL(unregister_netdev);
5540
5541 /**
5542  *      dev_change_net_namespace - move device to different nethost namespace
5543  *      @dev: device
5544  *      @net: network namespace
5545  *      @pat: If not NULL name pattern to try if the current device name
5546  *            is already taken in the destination network namespace.
5547  *
5548  *      This function shuts down a device interface and moves it
5549  *      to a new network namespace. On success 0 is returned, on
5550  *      a failure a netagive errno code is returned.
5551  *
5552  *      Callers must hold the rtnl semaphore.
5553  */
5554
5555 int dev_change_net_namespace(struct net_device *dev, struct net *net, const char *pat)
5556 {
5557         int err;
5558
5559         ASSERT_RTNL();
5560
5561         /* Don't allow namespace local devices to be moved. */
5562         err = -EINVAL;
5563         if (dev->features & NETIF_F_NETNS_LOCAL)
5564                 goto out;
5565
5566         /* Ensure the device has been registrered */
5567         err = -EINVAL;
5568         if (dev->reg_state != NETREG_REGISTERED)
5569                 goto out;
5570
5571         /* Get out if there is nothing todo */
5572         err = 0;
5573         if (net_eq(dev_net(dev), net))
5574                 goto out;
5575
5576         /* Pick the destination device name, and ensure
5577          * we can use it in the destination network namespace.
5578          */
5579         err = -EEXIST;
5580         if (__dev_get_by_name(net, dev->name)) {
5581                 /* We get here if we can't use the current device name */
5582                 if (!pat)
5583                         goto out;
5584                 if (dev_get_valid_name(dev, pat, 1))
5585                         goto out;
5586         }
5587
5588         /*
5589          * And now a mini version of register_netdevice unregister_netdevice.
5590          */
5591
5592         /* If device is running close it first. */
5593         dev_close(dev);
5594
5595         /* And unlink it from device chain */
5596         err = -ENODEV;
5597         unlist_netdevice(dev);
5598
5599         synchronize_net();
5600
5601         /* Shutdown queueing discipline. */
5602         dev_shutdown(dev);
5603
5604         /* Notify protocols, that we are about to destroy
5605            this device. They should clean all the things.
5606         */
5607         call_netdevice_notifiers(NETDEV_UNREGISTER, dev);
5608         call_netdevice_notifiers(NETDEV_UNREGISTER_BATCH, dev);
5609
5610         /*
5611          *      Flush the unicast and multicast chains
5612          */
5613         dev_uc_flush(dev);
5614         dev_mc_flush(dev);
5615
5616         /* Actually switch the network namespace */
5617         dev_net_set(dev, net);
5618
5619         /* If there is an ifindex conflict assign a new one */
5620         if (__dev_get_by_index(net, dev->ifindex)) {
5621                 int iflink = (dev->iflink == dev->ifindex);
5622                 dev->ifindex = dev_new_index(net);
5623                 if (iflink)
5624                         dev->iflink = dev->ifindex;
5625         }
5626
5627         /* Fixup kobjects */
5628         err = device_rename(&dev->dev, dev->name);
5629         WARN_ON(err);
5630
5631         /* Add the device back in the hashes */
5632         list_netdevice(dev);
5633
5634         /* Notify protocols, that a new device appeared. */
5635         call_netdevice_notifiers(NETDEV_REGISTER, dev);
5636
5637         /*
5638          *      Prevent userspace races by waiting until the network
5639          *      device is fully setup before sending notifications.
5640          */
5641         rtmsg_ifinfo(RTM_NEWLINK, dev, ~0U);
5642
5643         synchronize_net();
5644         err = 0;
5645 out:
5646         return err;
5647 }
5648 EXPORT_SYMBOL_GPL(dev_change_net_namespace);
5649
5650 static int dev_cpu_callback(struct notifier_block *nfb,
5651                             unsigned long action,
5652                             void *ocpu)
5653 {
5654         struct sk_buff **list_skb;
5655         struct sk_buff *skb;
5656         unsigned int cpu, oldcpu = (unsigned long)ocpu;
5657         struct softnet_data *sd, *oldsd;
5658
5659         if (action != CPU_DEAD && action != CPU_DEAD_FROZEN)
5660                 return NOTIFY_OK;
5661
5662         local_irq_disable();
5663         cpu = smp_processor_id();
5664         sd = &per_cpu(softnet_data, cpu);
5665         oldsd = &per_cpu(softnet_data, oldcpu);
5666
5667         /* Find end of our completion_queue. */
5668         list_skb = &sd->completion_queue;
5669         while (*list_skb)
5670                 list_skb = &(*list_skb)->next;
5671         /* Append completion queue from offline CPU. */
5672         *list_skb = oldsd->completion_queue;
5673         oldsd->completion_queue = NULL;
5674
5675         /* Append output queue from offline CPU. */
5676         if (oldsd->output_queue) {
5677                 *sd->output_queue_tailp = oldsd->output_queue;
5678                 sd->output_queue_tailp = oldsd->output_queue_tailp;
5679                 oldsd->output_queue = NULL;
5680                 oldsd->output_queue_tailp = &oldsd->output_queue;
5681         }
5682
5683         raise_softirq_irqoff(NET_TX_SOFTIRQ);
5684         local_irq_enable();
5685
5686         /* Process offline CPU's input_pkt_queue */
5687         while ((skb = __skb_dequeue(&oldsd->process_queue))) {
5688                 netif_rx(skb);
5689                 input_queue_head_incr(oldsd);
5690         }
5691         while ((skb = __skb_dequeue(&oldsd->input_pkt_queue))) {
5692                 netif_rx(skb);
5693                 input_queue_head_incr(oldsd);
5694         }
5695
5696         return NOTIFY_OK;
5697 }
5698
5699
5700 /**
5701  *      netdev_increment_features - increment feature set by one
5702  *      @all: current feature set
5703  *      @one: new feature set
5704  *      @mask: mask feature set
5705  *
5706  *      Computes a new feature set after adding a device with feature set
5707  *      @one to the master device with current feature set @all.  Will not
5708  *      enable anything that is off in @mask. Returns the new feature set.
5709  */
5710 unsigned long netdev_increment_features(unsigned long all, unsigned long one,
5711                                         unsigned long mask)
5712 {
5713         /* If device needs checksumming, downgrade to it. */
5714         if (all & NETIF_F_NO_CSUM && !(one & NETIF_F_NO_CSUM))
5715                 all ^= NETIF_F_NO_CSUM | (one & NETIF_F_ALL_CSUM);
5716         else if (mask & NETIF_F_ALL_CSUM) {
5717                 /* If one device supports v4/v6 checksumming, set for all. */
5718                 if (one & (NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM) &&
5719                     !(all & NETIF_F_GEN_CSUM)) {
5720                         all &= ~NETIF_F_ALL_CSUM;
5721                         all |= one & (NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM);
5722                 }
5723
5724                 /* If one device supports hw checksumming, set for all. */
5725                 if (one & NETIF_F_GEN_CSUM && !(all & NETIF_F_GEN_CSUM)) {
5726                         all &= ~NETIF_F_ALL_CSUM;
5727                         all |= NETIF_F_HW_CSUM;
5728                 }
5729         }
5730
5731         one |= NETIF_F_ALL_CSUM;
5732
5733         one |= all & NETIF_F_ONE_FOR_ALL;
5734         all &= one | NETIF_F_LLTX | NETIF_F_GSO | NETIF_F_UFO;
5735         all |= one & mask & NETIF_F_ONE_FOR_ALL;
5736
5737         return all;
5738 }
5739 EXPORT_SYMBOL(netdev_increment_features);
5740
5741 static struct hlist_head *netdev_create_hash(void)
5742 {
5743         int i;
5744         struct hlist_head *hash;
5745
5746         hash = kmalloc(sizeof(*hash) * NETDEV_HASHENTRIES, GFP_KERNEL);
5747         if (hash != NULL)
5748                 for (i = 0; i < NETDEV_HASHENTRIES; i++)
5749                         INIT_HLIST_HEAD(&hash[i]);
5750
5751         return hash;
5752 }
5753
5754 /* Initialize per network namespace state */
5755 static int __net_init netdev_init(struct net *net)
5756 {
5757         INIT_LIST_HEAD(&net->dev_base_head);
5758
5759         net->dev_name_head = netdev_create_hash();
5760         if (net->dev_name_head == NULL)
5761                 goto err_name;
5762
5763         net->dev_index_head = netdev_create_hash();
5764         if (net->dev_index_head == NULL)
5765                 goto err_idx;
5766
5767         return 0;
5768
5769 err_idx:
5770         kfree(net->dev_name_head);
5771 err_name:
5772         return -ENOMEM;
5773 }
5774
5775 /**
5776  *      netdev_drivername - network driver for the device
5777  *      @dev: network device
5778  *      @buffer: buffer for resulting name
5779  *      @len: size of buffer
5780  *
5781  *      Determine network driver for device.
5782  */
5783 char *netdev_drivername(const struct net_device *dev, char *buffer, int len)
5784 {
5785         const struct device_driver *driver;
5786         const struct device *parent;
5787
5788         if (len <= 0 || !buffer)
5789                 return buffer;
5790         buffer[0] = 0;
5791
5792         parent = dev->dev.parent;
5793
5794         if (!parent)
5795                 return buffer;
5796
5797         driver = parent->driver;
5798         if (driver && driver->name)
5799                 strlcpy(buffer, driver->name, len);
5800         return buffer;
5801 }
5802
5803 static void __net_exit netdev_exit(struct net *net)
5804 {
5805         kfree(net->dev_name_head);
5806         kfree(net->dev_index_head);
5807 }
5808
5809 static struct pernet_operations __net_initdata netdev_net_ops = {
5810         .init = netdev_init,
5811         .exit = netdev_exit,
5812 };
5813
5814 static void __net_exit default_device_exit(struct net *net)
5815 {
5816         struct net_device *dev, *aux;
5817         /*
5818          * Push all migratable network devices back to the
5819          * initial network namespace
5820          */
5821         rtnl_lock();
5822         for_each_netdev_safe(net, dev, aux) {
5823                 int err;
5824                 char fb_name[IFNAMSIZ];
5825
5826                 /* Ignore unmoveable devices (i.e. loopback) */
5827                 if (dev->features & NETIF_F_NETNS_LOCAL)
5828                         continue;
5829
5830                 /* Leave virtual devices for the generic cleanup */
5831                 if (dev->rtnl_link_ops)
5832                         continue;
5833
5834                 /* Push remaing network devices to init_net */
5835                 snprintf(fb_name, IFNAMSIZ, "dev%d", dev->ifindex);
5836                 err = dev_change_net_namespace(dev, &init_net, fb_name);
5837                 if (err) {
5838                         printk(KERN_EMERG "%s: failed to move %s to init_net: %d\n",
5839                                 __func__, dev->name, err);
5840                         BUG();
5841                 }
5842         }
5843         rtnl_unlock();
5844 }
5845
5846 static void __net_exit default_device_exit_batch(struct list_head *net_list)
5847 {
5848         /* At exit all network devices most be removed from a network
5849          * namespace.  Do this in the reverse order of registeration.
5850          * Do this across as many network namespaces as possible to
5851          * improve batching efficiency.
5852          */
5853         struct net_device *dev;
5854         struct net *net;
5855         LIST_HEAD(dev_kill_list);
5856
5857         rtnl_lock();
5858         list_for_each_entry(net, net_list, exit_list) {
5859                 for_each_netdev_reverse(net, dev) {
5860                         if (dev->rtnl_link_ops)
5861                                 dev->rtnl_link_ops->dellink(dev, &dev_kill_list);
5862                         else
5863                                 unregister_netdevice_queue(dev, &dev_kill_list);
5864                 }
5865         }
5866         unregister_netdevice_many(&dev_kill_list);
5867         rtnl_unlock();
5868 }
5869
5870 static struct pernet_operations __net_initdata default_device_ops = {
5871         .exit = default_device_exit,
5872         .exit_batch = default_device_exit_batch,
5873 };
5874
5875 /*
5876  *      Initialize the DEV module. At boot time this walks the device list and
5877  *      unhooks any devices that fail to initialise (normally hardware not
5878  *      present) and leaves us with a valid list of present and active devices.
5879  *
5880  */
5881
5882 /*
5883  *       This is called single threaded during boot, so no need
5884  *       to take the rtnl semaphore.
5885  */
5886 static int __init net_dev_init(void)
5887 {
5888         int i, rc = -ENOMEM;
5889
5890         BUG_ON(!dev_boot_phase);
5891
5892         if (dev_proc_init())
5893                 goto out;
5894
5895         if (netdev_kobject_init())
5896                 goto out;
5897
5898         INIT_LIST_HEAD(&ptype_all);
5899         for (i = 0; i < PTYPE_HASH_SIZE; i++)
5900                 INIT_LIST_HEAD(&ptype_base[i]);
5901
5902         if (register_pernet_subsys(&netdev_net_ops))
5903                 goto out;
5904
5905         /*
5906          *      Initialise the packet receive queues.
5907          */
5908
5909         for_each_possible_cpu(i) {
5910                 struct softnet_data *sd = &per_cpu(softnet_data, i);
5911
5912                 memset(sd, 0, sizeof(*sd));
5913                 skb_queue_head_init(&sd->input_pkt_queue);
5914                 skb_queue_head_init(&sd->process_queue);
5915                 sd->completion_queue = NULL;
5916                 INIT_LIST_HEAD(&sd->poll_list);
5917                 sd->output_queue = NULL;
5918                 sd->output_queue_tailp = &sd->output_queue;
5919 #ifdef CONFIG_RPS
5920                 sd->csd.func = rps_trigger_softirq;
5921                 sd->csd.info = sd;
5922                 sd->csd.flags = 0;
5923                 sd->cpu = i;
5924 #endif
5925
5926                 sd->backlog.poll = process_backlog;
5927                 sd->backlog.weight = weight_p;
5928                 sd->backlog.gro_list = NULL;
5929                 sd->backlog.gro_count = 0;
5930         }
5931
5932         dev_boot_phase = 0;
5933
5934         /* The loopback device is special if any other network devices
5935          * is present in a network namespace the loopback device must
5936          * be present. Since we now dynamically allocate and free the
5937          * loopback device ensure this invariant is maintained by
5938          * keeping the loopback device as the first device on the
5939          * list of network devices.  Ensuring the loopback devices
5940          * is the first device that appears and the last network device
5941          * that disappears.
5942          */
5943         if (register_pernet_device(&loopback_net_ops))
5944                 goto out;
5945
5946         if (register_pernet_device(&default_device_ops))
5947                 goto out;
5948
5949         open_softirq(NET_TX_SOFTIRQ, net_tx_action);
5950         open_softirq(NET_RX_SOFTIRQ, net_rx_action);
5951
5952         hotcpu_notifier(dev_cpu_callback, 0);
5953         dst_init();
5954         dev_mcast_init();
5955         rc = 0;
5956 out:
5957         return rc;
5958 }
5959
5960 subsys_initcall(net_dev_init);
5961
5962 static int __init initialize_hashrnd(void)
5963 {
5964         get_random_bytes(&hashrnd, sizeof(hashrnd));
5965         return 0;
5966 }
5967
5968 late_initcall_sync(initialize_hashrnd);
5969