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