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