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