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