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