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