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