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