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