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