net: prevent sign extension in dev_get_stats()
[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 == '/' || *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_postpull_rcsum(skb, eth_hdr(skb), ETH_HLEN);
1620         skb->mark = 0;
1621         secpath_reset(skb);
1622         nf_reset(skb);
1623         nf_reset_trace(skb);
1624         return netif_rx(skb);
1625 }
1626 EXPORT_SYMBOL_GPL(dev_forward_skb);
1627
1628 static inline int deliver_skb(struct sk_buff *skb,
1629                               struct packet_type *pt_prev,
1630                               struct net_device *orig_dev)
1631 {
1632         atomic_inc(&skb->users);
1633         return pt_prev->func(skb, skb->dev, pt_prev, orig_dev);
1634 }
1635
1636 static inline bool skb_loop_sk(struct packet_type *ptype, struct sk_buff *skb)
1637 {
1638         if (!ptype->af_packet_priv || !skb->sk)
1639                 return false;
1640
1641         if (ptype->id_match)
1642                 return ptype->id_match(ptype, skb->sk);
1643         else if ((struct sock *)ptype->af_packet_priv == skb->sk)
1644                 return true;
1645
1646         return false;
1647 }
1648
1649 /*
1650  *      Support routine. Sends outgoing frames to any network
1651  *      taps currently in use.
1652  */
1653
1654 static void dev_queue_xmit_nit(struct sk_buff *skb, struct net_device *dev)
1655 {
1656         struct packet_type *ptype;
1657         struct sk_buff *skb2 = NULL;
1658         struct packet_type *pt_prev = NULL;
1659
1660         rcu_read_lock();
1661         list_for_each_entry_rcu(ptype, &ptype_all, list) {
1662                 /* Never send packets back to the socket
1663                  * they originated from - MvS (miquels@drinkel.ow.org)
1664                  */
1665                 if ((ptype->dev == dev || !ptype->dev) &&
1666                     (!skb_loop_sk(ptype, skb))) {
1667                         if (pt_prev) {
1668                                 deliver_skb(skb2, pt_prev, skb->dev);
1669                                 pt_prev = ptype;
1670                                 continue;
1671                         }
1672
1673                         skb2 = skb_clone(skb, GFP_ATOMIC);
1674                         if (!skb2)
1675                                 break;
1676
1677                         net_timestamp_set(skb2);
1678
1679                         /* skb->nh should be correctly
1680                            set by sender, so that the second statement is
1681                            just protection against buggy protocols.
1682                          */
1683                         skb_reset_mac_header(skb2);
1684
1685                         if (skb_network_header(skb2) < skb2->data ||
1686                             skb2->network_header > skb2->tail) {
1687                                 if (net_ratelimit())
1688                                         printk(KERN_CRIT "protocol %04x is "
1689                                                "buggy, dev %s\n",
1690                                                ntohs(skb2->protocol),
1691                                                dev->name);
1692                                 skb_reset_network_header(skb2);
1693                         }
1694
1695                         skb2->transport_header = skb2->network_header;
1696                         skb2->pkt_type = PACKET_OUTGOING;
1697                         pt_prev = ptype;
1698                 }
1699         }
1700         if (pt_prev)
1701                 pt_prev->func(skb2, skb->dev, pt_prev, skb->dev);
1702         rcu_read_unlock();
1703 }
1704
1705 /* netif_setup_tc - Handle tc mappings on real_num_tx_queues change
1706  * @dev: Network device
1707  * @txq: number of queues available
1708  *
1709  * If real_num_tx_queues is changed the tc mappings may no longer be
1710  * valid. To resolve this verify the tc mapping remains valid and if
1711  * not NULL the mapping. With no priorities mapping to this
1712  * offset/count pair it will no longer be used. In the worst case TC0
1713  * is invalid nothing can be done so disable priority mappings. If is
1714  * expected that drivers will fix this mapping if they can before
1715  * calling netif_set_real_num_tx_queues.
1716  */
1717 static void netif_setup_tc(struct net_device *dev, unsigned int txq)
1718 {
1719         int i;
1720         struct netdev_tc_txq *tc = &dev->tc_to_txq[0];
1721
1722         /* If TC0 is invalidated disable TC mapping */
1723         if (tc->offset + tc->count > txq) {
1724                 pr_warning("Number of in use tx queues changed "
1725                            "invalidating tc mappings. Priority "
1726                            "traffic classification disabled!\n");
1727                 dev->num_tc = 0;
1728                 return;
1729         }
1730
1731         /* Invalidated prio to tc mappings set to TC0 */
1732         for (i = 1; i < TC_BITMASK + 1; i++) {
1733                 int q = netdev_get_prio_tc_map(dev, i);
1734
1735                 tc = &dev->tc_to_txq[q];
1736                 if (tc->offset + tc->count > txq) {
1737                         pr_warning("Number of in use tx queues "
1738                                    "changed. Priority %i to tc "
1739                                    "mapping %i is no longer valid "
1740                                    "setting map to 0\n",
1741                                    i, q);
1742                         netdev_set_prio_tc_map(dev, i, 0);
1743                 }
1744         }
1745 }
1746
1747 /*
1748  * Routine to help set real_num_tx_queues. To avoid skbs mapped to queues
1749  * greater then real_num_tx_queues stale skbs on the qdisc must be flushed.
1750  */
1751 int netif_set_real_num_tx_queues(struct net_device *dev, unsigned int txq)
1752 {
1753         int rc;
1754
1755         if (txq < 1 || txq > dev->num_tx_queues)
1756                 return -EINVAL;
1757
1758         if (dev->reg_state == NETREG_REGISTERED ||
1759             dev->reg_state == NETREG_UNREGISTERING) {
1760                 ASSERT_RTNL();
1761
1762                 rc = netdev_queue_update_kobjects(dev, dev->real_num_tx_queues,
1763                                                   txq);
1764                 if (rc)
1765                         return rc;
1766
1767                 if (dev->num_tc)
1768                         netif_setup_tc(dev, txq);
1769
1770                 if (txq < dev->real_num_tx_queues)
1771                         qdisc_reset_all_tx_gt(dev, txq);
1772         }
1773
1774         dev->real_num_tx_queues = txq;
1775         return 0;
1776 }
1777 EXPORT_SYMBOL(netif_set_real_num_tx_queues);
1778
1779 #ifdef CONFIG_RPS
1780 /**
1781  *      netif_set_real_num_rx_queues - set actual number of RX queues used
1782  *      @dev: Network device
1783  *      @rxq: Actual number of RX queues
1784  *
1785  *      This must be called either with the rtnl_lock held or before
1786  *      registration of the net device.  Returns 0 on success, or a
1787  *      negative error code.  If called before registration, it always
1788  *      succeeds.
1789  */
1790 int netif_set_real_num_rx_queues(struct net_device *dev, unsigned int rxq)
1791 {
1792         int rc;
1793
1794         if (rxq < 1 || rxq > dev->num_rx_queues)
1795                 return -EINVAL;
1796
1797         if (dev->reg_state == NETREG_REGISTERED) {
1798                 ASSERT_RTNL();
1799
1800                 rc = net_rx_queue_update_kobjects(dev, dev->real_num_rx_queues,
1801                                                   rxq);
1802                 if (rc)
1803                         return rc;
1804         }
1805
1806         dev->real_num_rx_queues = rxq;
1807         return 0;
1808 }
1809 EXPORT_SYMBOL(netif_set_real_num_rx_queues);
1810 #endif
1811
1812 static inline void __netif_reschedule(struct Qdisc *q)
1813 {
1814         struct softnet_data *sd;
1815         unsigned long flags;
1816
1817         local_irq_save(flags);
1818         sd = &__get_cpu_var(softnet_data);
1819         q->next_sched = NULL;
1820         *sd->output_queue_tailp = q;
1821         sd->output_queue_tailp = &q->next_sched;
1822         raise_softirq_irqoff(NET_TX_SOFTIRQ);
1823         local_irq_restore(flags);
1824 }
1825
1826 void __netif_schedule(struct Qdisc *q)
1827 {
1828         if (!test_and_set_bit(__QDISC_STATE_SCHED, &q->state))
1829                 __netif_reschedule(q);
1830 }
1831 EXPORT_SYMBOL(__netif_schedule);
1832
1833 void dev_kfree_skb_irq(struct sk_buff *skb)
1834 {
1835         if (atomic_dec_and_test(&skb->users)) {
1836                 struct softnet_data *sd;
1837                 unsigned long flags;
1838
1839                 local_irq_save(flags);
1840                 sd = &__get_cpu_var(softnet_data);
1841                 skb->next = sd->completion_queue;
1842                 sd->completion_queue = skb;
1843                 raise_softirq_irqoff(NET_TX_SOFTIRQ);
1844                 local_irq_restore(flags);
1845         }
1846 }
1847 EXPORT_SYMBOL(dev_kfree_skb_irq);
1848
1849 void dev_kfree_skb_any(struct sk_buff *skb)
1850 {
1851         if (in_irq() || irqs_disabled())
1852                 dev_kfree_skb_irq(skb);
1853         else
1854                 dev_kfree_skb(skb);
1855 }
1856 EXPORT_SYMBOL(dev_kfree_skb_any);
1857
1858
1859 /**
1860  * netif_device_detach - mark device as removed
1861  * @dev: network device
1862  *
1863  * Mark device as removed from system and therefore no longer available.
1864  */
1865 void netif_device_detach(struct net_device *dev)
1866 {
1867         if (test_and_clear_bit(__LINK_STATE_PRESENT, &dev->state) &&
1868             netif_running(dev)) {
1869                 netif_tx_stop_all_queues(dev);
1870         }
1871 }
1872 EXPORT_SYMBOL(netif_device_detach);
1873
1874 /**
1875  * netif_device_attach - mark device as attached
1876  * @dev: network device
1877  *
1878  * Mark device as attached from system and restart if needed.
1879  */
1880 void netif_device_attach(struct net_device *dev)
1881 {
1882         if (!test_and_set_bit(__LINK_STATE_PRESENT, &dev->state) &&
1883             netif_running(dev)) {
1884                 netif_tx_wake_all_queues(dev);
1885                 __netdev_watchdog_up(dev);
1886         }
1887 }
1888 EXPORT_SYMBOL(netif_device_attach);
1889
1890 /*
1891  * Invalidate hardware checksum when packet is to be mangled, and
1892  * complete checksum manually on outgoing path.
1893  */
1894 int skb_checksum_help(struct sk_buff *skb)
1895 {
1896         __wsum csum;
1897         int ret = 0, offset;
1898
1899         if (skb->ip_summed == CHECKSUM_COMPLETE)
1900                 goto out_set_summed;
1901
1902         if (unlikely(skb_shinfo(skb)->gso_size)) {
1903                 /* Let GSO fix up the checksum. */
1904                 goto out_set_summed;
1905         }
1906
1907         offset = skb_checksum_start_offset(skb);
1908         BUG_ON(offset >= skb_headlen(skb));
1909         csum = skb_checksum(skb, offset, skb->len - offset, 0);
1910
1911         offset += skb->csum_offset;
1912         BUG_ON(offset + sizeof(__sum16) > skb_headlen(skb));
1913
1914         if (skb_cloned(skb) &&
1915             !skb_clone_writable(skb, offset + sizeof(__sum16))) {
1916                 ret = pskb_expand_head(skb, 0, 0, GFP_ATOMIC);
1917                 if (ret)
1918                         goto out;
1919         }
1920
1921         *(__sum16 *)(skb->data + offset) = csum_fold(csum) ?: CSUM_MANGLED_0;
1922 out_set_summed:
1923         skb->ip_summed = CHECKSUM_NONE;
1924 out:
1925         return ret;
1926 }
1927 EXPORT_SYMBOL(skb_checksum_help);
1928
1929 /**
1930  *      skb_gso_segment - Perform segmentation on skb.
1931  *      @skb: buffer to segment
1932  *      @features: features for the output path (see dev->features)
1933  *
1934  *      This function segments the given skb and returns a list of segments.
1935  *
1936  *      It may return NULL if the skb requires no segmentation.  This is
1937  *      only possible when GSO is used for verifying header integrity.
1938  */
1939 struct sk_buff *skb_gso_segment(struct sk_buff *skb, u32 features)
1940 {
1941         struct sk_buff *segs = ERR_PTR(-EPROTONOSUPPORT);
1942         struct packet_type *ptype;
1943         __be16 type = skb->protocol;
1944         int vlan_depth = ETH_HLEN;
1945         int err;
1946
1947         while (type == htons(ETH_P_8021Q)) {
1948                 struct vlan_hdr *vh;
1949
1950                 if (unlikely(!pskb_may_pull(skb, vlan_depth + VLAN_HLEN)))
1951                         return ERR_PTR(-EINVAL);
1952
1953                 vh = (struct vlan_hdr *)(skb->data + vlan_depth);
1954                 type = vh->h_vlan_encapsulated_proto;
1955                 vlan_depth += VLAN_HLEN;
1956         }
1957
1958         skb_reset_mac_header(skb);
1959         skb->mac_len = skb->network_header - skb->mac_header;
1960         __skb_pull(skb, skb->mac_len);
1961
1962         if (unlikely(skb->ip_summed != CHECKSUM_PARTIAL)) {
1963                 struct net_device *dev = skb->dev;
1964                 struct ethtool_drvinfo info = {};
1965
1966                 if (dev && dev->ethtool_ops && dev->ethtool_ops->get_drvinfo)
1967                         dev->ethtool_ops->get_drvinfo(dev, &info);
1968
1969                 WARN(1, "%s: caps=(0x%lx, 0x%lx) len=%d data_len=%d ip_summed=%d\n",
1970                      info.driver, dev ? dev->features : 0L,
1971                      skb->sk ? skb->sk->sk_route_caps : 0L,
1972                      skb->len, skb->data_len, skb->ip_summed);
1973
1974                 if (skb_header_cloned(skb) &&
1975                     (err = pskb_expand_head(skb, 0, 0, GFP_ATOMIC)))
1976                         return ERR_PTR(err);
1977         }
1978
1979         rcu_read_lock();
1980         list_for_each_entry_rcu(ptype,
1981                         &ptype_base[ntohs(type) & PTYPE_HASH_MASK], list) {
1982                 if (ptype->type == type && !ptype->dev && ptype->gso_segment) {
1983                         if (unlikely(skb->ip_summed != CHECKSUM_PARTIAL)) {
1984                                 err = ptype->gso_send_check(skb);
1985                                 segs = ERR_PTR(err);
1986                                 if (err || skb_gso_ok(skb, features))
1987                                         break;
1988                                 __skb_push(skb, (skb->data -
1989                                                  skb_network_header(skb)));
1990                         }
1991                         segs = ptype->gso_segment(skb, features);
1992                         break;
1993                 }
1994         }
1995         rcu_read_unlock();
1996
1997         __skb_push(skb, skb->data - skb_mac_header(skb));
1998
1999         return segs;
2000 }
2001 EXPORT_SYMBOL(skb_gso_segment);
2002
2003 /* Take action when hardware reception checksum errors are detected. */
2004 #ifdef CONFIG_BUG
2005 void netdev_rx_csum_fault(struct net_device *dev)
2006 {
2007         if (net_ratelimit()) {
2008                 printk(KERN_ERR "%s: hw csum failure.\n",
2009                         dev ? dev->name : "<unknown>");
2010                 dump_stack();
2011         }
2012 }
2013 EXPORT_SYMBOL(netdev_rx_csum_fault);
2014 #endif
2015
2016 /* Actually, we should eliminate this check as soon as we know, that:
2017  * 1. IOMMU is present and allows to map all the memory.
2018  * 2. No high memory really exists on this machine.
2019  */
2020
2021 static int illegal_highdma(struct net_device *dev, struct sk_buff *skb)
2022 {
2023 #ifdef CONFIG_HIGHMEM
2024         int i;
2025         if (!(dev->features & NETIF_F_HIGHDMA)) {
2026                 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
2027                         skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
2028                         if (PageHighMem(skb_frag_page(frag)))
2029                                 return 1;
2030                 }
2031         }
2032
2033         if (PCI_DMA_BUS_IS_PHYS) {
2034                 struct device *pdev = dev->dev.parent;
2035
2036                 if (!pdev)
2037                         return 0;
2038                 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
2039                         skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
2040                         dma_addr_t addr = page_to_phys(skb_frag_page(frag));
2041                         if (!pdev->dma_mask || addr + PAGE_SIZE - 1 > *pdev->dma_mask)
2042                                 return 1;
2043                 }
2044         }
2045 #endif
2046         return 0;
2047 }
2048
2049 struct dev_gso_cb {
2050         void (*destructor)(struct sk_buff *skb);
2051 };
2052
2053 #define DEV_GSO_CB(skb) ((struct dev_gso_cb *)(skb)->cb)
2054
2055 static void dev_gso_skb_destructor(struct sk_buff *skb)
2056 {
2057         struct dev_gso_cb *cb;
2058
2059         do {
2060                 struct sk_buff *nskb = skb->next;
2061
2062                 skb->next = nskb->next;
2063                 nskb->next = NULL;
2064                 kfree_skb(nskb);
2065         } while (skb->next);
2066
2067         cb = DEV_GSO_CB(skb);
2068         if (cb->destructor)
2069                 cb->destructor(skb);
2070 }
2071
2072 /**
2073  *      dev_gso_segment - Perform emulated hardware segmentation on skb.
2074  *      @skb: buffer to segment
2075  *      @features: device features as applicable to this skb
2076  *
2077  *      This function segments the given skb and stores the list of segments
2078  *      in skb->next.
2079  */
2080 static int dev_gso_segment(struct sk_buff *skb, int features)
2081 {
2082         struct sk_buff *segs;
2083
2084         segs = skb_gso_segment(skb, features);
2085
2086         /* Verifying header integrity only. */
2087         if (!segs)
2088                 return 0;
2089
2090         if (IS_ERR(segs))
2091                 return PTR_ERR(segs);
2092
2093         skb->next = segs;
2094         DEV_GSO_CB(skb)->destructor = skb->destructor;
2095         skb->destructor = dev_gso_skb_destructor;
2096
2097         return 0;
2098 }
2099
2100 static bool can_checksum_protocol(unsigned long features, __be16 protocol)
2101 {
2102         return ((features & NETIF_F_GEN_CSUM) ||
2103                 ((features & NETIF_F_V4_CSUM) &&
2104                  protocol == htons(ETH_P_IP)) ||
2105                 ((features & NETIF_F_V6_CSUM) &&
2106                  protocol == htons(ETH_P_IPV6)) ||
2107                 ((features & NETIF_F_FCOE_CRC) &&
2108                  protocol == htons(ETH_P_FCOE)));
2109 }
2110
2111 static u32 harmonize_features(struct sk_buff *skb, __be16 protocol, u32 features)
2112 {
2113         if (skb->ip_summed != CHECKSUM_NONE &&
2114             !can_checksum_protocol(features, protocol)) {
2115                 features &= ~NETIF_F_ALL_CSUM;
2116                 features &= ~NETIF_F_SG;
2117         } else if (illegal_highdma(skb->dev, skb)) {
2118                 features &= ~NETIF_F_SG;
2119         }
2120
2121         return features;
2122 }
2123
2124 u32 netif_skb_features(struct sk_buff *skb)
2125 {
2126         __be16 protocol = skb->protocol;
2127         u32 features = skb->dev->features;
2128
2129         if (skb_shinfo(skb)->gso_segs > skb->dev->gso_max_segs)
2130                 features &= ~NETIF_F_GSO_MASK;
2131
2132         if (!vlan_tx_tag_present(skb)) {
2133                 if (unlikely(protocol == htons(ETH_P_8021Q))) {
2134                         struct vlan_ethhdr *veh = (struct vlan_ethhdr *)skb->data;
2135                         protocol = veh->h_vlan_encapsulated_proto;
2136                 } else {
2137                         return harmonize_features(skb, protocol, features);
2138                 }
2139         }
2140
2141         features &= (skb->dev->vlan_features | NETIF_F_HW_VLAN_TX);
2142
2143         if (protocol != htons(ETH_P_8021Q)) {
2144                 return harmonize_features(skb, protocol, features);
2145         } else {
2146                 features &= NETIF_F_SG | NETIF_F_HIGHDMA | NETIF_F_FRAGLIST |
2147                                 NETIF_F_GEN_CSUM | NETIF_F_HW_VLAN_TX;
2148                 return harmonize_features(skb, protocol, features);
2149         }
2150 }
2151 EXPORT_SYMBOL(netif_skb_features);
2152
2153 /*
2154  * Returns true if either:
2155  *      1. skb has frag_list and the device doesn't support FRAGLIST, or
2156  *      2. skb is fragmented and the device does not support SG, or if
2157  *         at least one of fragments is in highmem and device does not
2158  *         support DMA from it.
2159  */
2160 static inline int skb_needs_linearize(struct sk_buff *skb,
2161                                       int features)
2162 {
2163         return skb_is_nonlinear(skb) &&
2164                         ((skb_has_frag_list(skb) &&
2165                                 !(features & NETIF_F_FRAGLIST)) ||
2166                         (skb_shinfo(skb)->nr_frags &&
2167                                 !(features & NETIF_F_SG)));
2168 }
2169
2170 int dev_hard_start_xmit(struct sk_buff *skb, struct net_device *dev,
2171                         struct netdev_queue *txq)
2172 {
2173         const struct net_device_ops *ops = dev->netdev_ops;
2174         int rc = NETDEV_TX_OK;
2175         unsigned int skb_len;
2176
2177         if (likely(!skb->next)) {
2178                 u32 features;
2179
2180                 /*
2181                  * If device doesn't need skb->dst, release it right now while
2182                  * its hot in this cpu cache
2183                  */
2184                 if (dev->priv_flags & IFF_XMIT_DST_RELEASE)
2185                         skb_dst_drop(skb);
2186
2187                 if (!list_empty(&ptype_all))
2188                         dev_queue_xmit_nit(skb, dev);
2189
2190                 features = netif_skb_features(skb);
2191
2192                 if (vlan_tx_tag_present(skb) &&
2193                     !(features & NETIF_F_HW_VLAN_TX)) {
2194                         skb = __vlan_put_tag(skb, vlan_tx_tag_get(skb));
2195                         if (unlikely(!skb))
2196                                 goto out;
2197
2198                         skb->vlan_tci = 0;
2199                 }
2200
2201                 if (netif_needs_gso(skb, features)) {
2202                         if (unlikely(dev_gso_segment(skb, features)))
2203                                 goto out_kfree_skb;
2204                         if (skb->next)
2205                                 goto gso;
2206                 } else {
2207                         if (skb_needs_linearize(skb, features) &&
2208                             __skb_linearize(skb))
2209                                 goto out_kfree_skb;
2210
2211                         /* If packet is not checksummed and device does not
2212                          * support checksumming for this protocol, complete
2213                          * checksumming here.
2214                          */
2215                         if (skb->ip_summed == CHECKSUM_PARTIAL) {
2216                                 skb_set_transport_header(skb,
2217                                         skb_checksum_start_offset(skb));
2218                                 if (!(features & NETIF_F_ALL_CSUM) &&
2219                                      skb_checksum_help(skb))
2220                                         goto out_kfree_skb;
2221                         }
2222                 }
2223
2224                 skb_len = skb->len;
2225                 rc = ops->ndo_start_xmit(skb, dev);
2226                 trace_net_dev_xmit(skb, rc, dev, skb_len);
2227                 if (rc == NETDEV_TX_OK)
2228                         txq_trans_update(txq);
2229                 return rc;
2230         }
2231
2232 gso:
2233         do {
2234                 struct sk_buff *nskb = skb->next;
2235
2236                 skb->next = nskb->next;
2237                 nskb->next = NULL;
2238
2239                 /*
2240                  * If device doesn't need nskb->dst, release it right now while
2241                  * its hot in this cpu cache
2242                  */
2243                 if (dev->priv_flags & IFF_XMIT_DST_RELEASE)
2244                         skb_dst_drop(nskb);
2245
2246                 skb_len = nskb->len;
2247                 rc = ops->ndo_start_xmit(nskb, dev);
2248                 trace_net_dev_xmit(nskb, rc, dev, skb_len);
2249                 if (unlikely(rc != NETDEV_TX_OK)) {
2250                         if (rc & ~NETDEV_TX_MASK)
2251                                 goto out_kfree_gso_skb;
2252                         nskb->next = skb->next;
2253                         skb->next = nskb;
2254                         return rc;
2255                 }
2256                 txq_trans_update(txq);
2257                 if (unlikely(netif_tx_queue_stopped(txq) && skb->next))
2258                         return NETDEV_TX_BUSY;
2259         } while (skb->next);
2260
2261 out_kfree_gso_skb:
2262         if (likely(skb->next == NULL))
2263                 skb->destructor = DEV_GSO_CB(skb)->destructor;
2264 out_kfree_skb:
2265         kfree_skb(skb);
2266 out:
2267         return rc;
2268 }
2269
2270 static u32 hashrnd __read_mostly;
2271
2272 /*
2273  * Returns a Tx hash based on the given packet descriptor a Tx queues' number
2274  * to be used as a distribution range.
2275  */
2276 u16 __skb_tx_hash(const struct net_device *dev, const struct sk_buff *skb,
2277                   unsigned int num_tx_queues)
2278 {
2279         u32 hash;
2280         u16 qoffset = 0;
2281         u16 qcount = num_tx_queues;
2282
2283         if (skb_rx_queue_recorded(skb)) {
2284                 hash = skb_get_rx_queue(skb);
2285                 while (unlikely(hash >= num_tx_queues))
2286                         hash -= num_tx_queues;
2287                 return hash;
2288         }
2289
2290         if (dev->num_tc) {
2291                 u8 tc = netdev_get_prio_tc_map(dev, skb->priority);
2292                 qoffset = dev->tc_to_txq[tc].offset;
2293                 qcount = dev->tc_to_txq[tc].count;
2294         }
2295
2296         if (skb->sk && skb->sk->sk_hash)
2297                 hash = skb->sk->sk_hash;
2298         else
2299                 hash = (__force u16) skb->protocol;
2300         hash = jhash_1word(hash, hashrnd);
2301
2302         return (u16) (((u64) hash * qcount) >> 32) + qoffset;
2303 }
2304 EXPORT_SYMBOL(__skb_tx_hash);
2305
2306 static inline u16 dev_cap_txqueue(struct net_device *dev, u16 queue_index)
2307 {
2308         if (unlikely(queue_index >= dev->real_num_tx_queues)) {
2309                 if (net_ratelimit()) {
2310                         pr_warning("%s selects TX queue %d, but "
2311                                 "real number of TX queues is %d\n",
2312                                 dev->name, queue_index, dev->real_num_tx_queues);
2313                 }
2314                 return 0;
2315         }
2316         return queue_index;
2317 }
2318
2319 static inline int get_xps_queue(struct net_device *dev, struct sk_buff *skb)
2320 {
2321 #ifdef CONFIG_XPS
2322         struct xps_dev_maps *dev_maps;
2323         struct xps_map *map;
2324         int queue_index = -1;
2325
2326         rcu_read_lock();
2327         dev_maps = rcu_dereference(dev->xps_maps);
2328         if (dev_maps) {
2329                 map = rcu_dereference(
2330                     dev_maps->cpu_map[raw_smp_processor_id()]);
2331                 if (map) {
2332                         if (map->len == 1)
2333                                 queue_index = map->queues[0];
2334                         else {
2335                                 u32 hash;
2336                                 if (skb->sk && skb->sk->sk_hash)
2337                                         hash = skb->sk->sk_hash;
2338                                 else
2339                                         hash = (__force u16) skb->protocol ^
2340                                             skb->rxhash;
2341                                 hash = jhash_1word(hash, hashrnd);
2342                                 queue_index = map->queues[
2343                                     ((u64)hash * map->len) >> 32];
2344                         }
2345                         if (unlikely(queue_index >= dev->real_num_tx_queues))
2346                                 queue_index = -1;
2347                 }
2348         }
2349         rcu_read_unlock();
2350
2351         return queue_index;
2352 #else
2353         return -1;
2354 #endif
2355 }
2356
2357 static struct netdev_queue *dev_pick_tx(struct net_device *dev,
2358                                         struct sk_buff *skb)
2359 {
2360         int queue_index;
2361         const struct net_device_ops *ops = dev->netdev_ops;
2362
2363         if (dev->real_num_tx_queues == 1)
2364                 queue_index = 0;
2365         else if (ops->ndo_select_queue) {
2366                 queue_index = ops->ndo_select_queue(dev, skb);
2367                 queue_index = dev_cap_txqueue(dev, queue_index);
2368         } else {
2369                 struct sock *sk = skb->sk;
2370                 queue_index = sk_tx_queue_get(sk);
2371
2372                 if (queue_index < 0 || skb->ooo_okay ||
2373                     queue_index >= dev->real_num_tx_queues) {
2374                         int old_index = queue_index;
2375
2376                         queue_index = get_xps_queue(dev, skb);
2377                         if (queue_index < 0)
2378                                 queue_index = skb_tx_hash(dev, skb);
2379
2380                         if (queue_index != old_index && sk) {
2381                                 struct dst_entry *dst =
2382                                     rcu_dereference_check(sk->sk_dst_cache, 1);
2383
2384                                 if (dst && skb_dst(skb) == dst)
2385                                         sk_tx_queue_set(sk, queue_index);
2386                         }
2387                 }
2388         }
2389
2390         skb_set_queue_mapping(skb, queue_index);
2391         return netdev_get_tx_queue(dev, queue_index);
2392 }
2393
2394 static inline int __dev_xmit_skb(struct sk_buff *skb, struct Qdisc *q,
2395                                  struct net_device *dev,
2396                                  struct netdev_queue *txq)
2397 {
2398         spinlock_t *root_lock = qdisc_lock(q);
2399         bool contended;
2400         int rc;
2401
2402         qdisc_skb_cb(skb)->pkt_len = skb->len;
2403         qdisc_calculate_pkt_len(skb, q);
2404         /*
2405          * Heuristic to force contended enqueues to serialize on a
2406          * separate lock before trying to get qdisc main lock.
2407          * This permits __QDISC_STATE_RUNNING owner to get the lock more often
2408          * and dequeue packets faster.
2409          */
2410         contended = qdisc_is_running(q);
2411         if (unlikely(contended))
2412                 spin_lock(&q->busylock);
2413
2414         spin_lock(root_lock);
2415         if (unlikely(test_bit(__QDISC_STATE_DEACTIVATED, &q->state))) {
2416                 kfree_skb(skb);
2417                 rc = NET_XMIT_DROP;
2418         } else if ((q->flags & TCQ_F_CAN_BYPASS) && !qdisc_qlen(q) &&
2419                    qdisc_run_begin(q)) {
2420                 /*
2421                  * This is a work-conserving queue; there are no old skbs
2422                  * waiting to be sent out; and the qdisc is not running -
2423                  * xmit the skb directly.
2424                  */
2425                 if (!(dev->priv_flags & IFF_XMIT_DST_RELEASE))
2426                         skb_dst_force(skb);
2427
2428                 qdisc_bstats_update(q, skb);
2429
2430                 if (sch_direct_xmit(skb, q, dev, txq, root_lock)) {
2431                         if (unlikely(contended)) {
2432                                 spin_unlock(&q->busylock);
2433                                 contended = false;
2434                         }
2435                         __qdisc_run(q);
2436                 } else
2437                         qdisc_run_end(q);
2438
2439                 rc = NET_XMIT_SUCCESS;
2440         } else {
2441                 skb_dst_force(skb);
2442                 rc = q->enqueue(skb, q) & NET_XMIT_MASK;
2443                 if (qdisc_run_begin(q)) {
2444                         if (unlikely(contended)) {
2445                                 spin_unlock(&q->busylock);
2446                                 contended = false;
2447                         }
2448                         __qdisc_run(q);
2449                 }
2450         }
2451         spin_unlock(root_lock);
2452         if (unlikely(contended))
2453                 spin_unlock(&q->busylock);
2454         return rc;
2455 }
2456
2457 static DEFINE_PER_CPU(int, xmit_recursion);
2458 #define RECURSION_LIMIT 10
2459
2460 /**
2461  *      dev_queue_xmit - transmit a buffer
2462  *      @skb: buffer to transmit
2463  *
2464  *      Queue a buffer for transmission to a network device. The caller must
2465  *      have set the device and priority and built the buffer before calling
2466  *      this function. The function can be called from an interrupt.
2467  *
2468  *      A negative errno code is returned on a failure. A success does not
2469  *      guarantee the frame will be transmitted as it may be dropped due
2470  *      to congestion or traffic shaping.
2471  *
2472  * -----------------------------------------------------------------------------------
2473  *      I notice this method can also return errors from the queue disciplines,
2474  *      including NET_XMIT_DROP, which is a positive value.  So, errors can also
2475  *      be positive.
2476  *
2477  *      Regardless of the return value, the skb is consumed, so it is currently
2478  *      difficult to retry a send to this method.  (You can bump the ref count
2479  *      before sending to hold a reference for retry if you are careful.)
2480  *
2481  *      When calling this method, interrupts MUST be enabled.  This is because
2482  *      the BH enable code must have IRQs enabled so that it will not deadlock.
2483  *          --BLG
2484  */
2485 int dev_queue_xmit(struct sk_buff *skb)
2486 {
2487         struct net_device *dev = skb->dev;
2488         struct netdev_queue *txq;
2489         struct Qdisc *q;
2490         int rc = -ENOMEM;
2491
2492         /* Disable soft irqs for various locks below. Also
2493          * stops preemption for RCU.
2494          */
2495         rcu_read_lock_bh();
2496
2497         txq = dev_pick_tx(dev, skb);
2498         q = rcu_dereference_bh(txq->qdisc);
2499
2500 #ifdef CONFIG_NET_CLS_ACT
2501         skb->tc_verd = SET_TC_AT(skb->tc_verd, AT_EGRESS);
2502 #endif
2503         trace_net_dev_queue(skb);
2504         if (q->enqueue) {
2505                 rc = __dev_xmit_skb(skb, q, dev, txq);
2506                 goto out;
2507         }
2508
2509         /* The device has no queue. Common case for software devices:
2510            loopback, all the sorts of tunnels...
2511
2512            Really, it is unlikely that netif_tx_lock protection is necessary
2513            here.  (f.e. loopback and IP tunnels are clean ignoring statistics
2514            counters.)
2515            However, it is possible, that they rely on protection
2516            made by us here.
2517
2518            Check this and shot the lock. It is not prone from deadlocks.
2519            Either shot noqueue qdisc, it is even simpler 8)
2520          */
2521         if (dev->flags & IFF_UP) {
2522                 int cpu = smp_processor_id(); /* ok because BHs are off */
2523
2524                 if (txq->xmit_lock_owner != cpu) {
2525
2526                         if (__this_cpu_read(xmit_recursion) > RECURSION_LIMIT)
2527                                 goto recursion_alert;
2528
2529                         HARD_TX_LOCK(dev, txq, cpu);
2530
2531                         if (!netif_tx_queue_stopped(txq)) {
2532                                 __this_cpu_inc(xmit_recursion);
2533                                 rc = dev_hard_start_xmit(skb, dev, txq);
2534                                 __this_cpu_dec(xmit_recursion);
2535                                 if (dev_xmit_complete(rc)) {
2536                                         HARD_TX_UNLOCK(dev, txq);
2537                                         goto out;
2538                                 }
2539                         }
2540                         HARD_TX_UNLOCK(dev, txq);
2541                         if (net_ratelimit())
2542                                 printk(KERN_CRIT "Virtual device %s asks to "
2543                                        "queue packet!\n", dev->name);
2544                 } else {
2545                         /* Recursion is detected! It is possible,
2546                          * unfortunately
2547                          */
2548 recursion_alert:
2549                         if (net_ratelimit())
2550                                 printk(KERN_CRIT "Dead loop on virtual device "
2551                                        "%s, fix it urgently!\n", dev->name);
2552                 }
2553         }
2554
2555         rc = -ENETDOWN;
2556         rcu_read_unlock_bh();
2557
2558         kfree_skb(skb);
2559         return rc;
2560 out:
2561         rcu_read_unlock_bh();
2562         return rc;
2563 }
2564 EXPORT_SYMBOL(dev_queue_xmit);
2565
2566
2567 /*=======================================================================
2568                         Receiver routines
2569   =======================================================================*/
2570
2571 int netdev_max_backlog __read_mostly = 1000;
2572 int netdev_tstamp_prequeue __read_mostly = 1;
2573 int netdev_budget __read_mostly = 300;
2574 int weight_p __read_mostly = 64;            /* old backlog weight */
2575
2576 /* Called with irq disabled */
2577 static inline void ____napi_schedule(struct softnet_data *sd,
2578                                      struct napi_struct *napi)
2579 {
2580         list_add_tail(&napi->poll_list, &sd->poll_list);
2581         __raise_softirq_irqoff(NET_RX_SOFTIRQ);
2582 }
2583
2584 /*
2585  * __skb_get_rxhash: calculate a flow hash based on src/dst addresses
2586  * and src/dst port numbers.  Sets rxhash in skb to non-zero hash value
2587  * on success, zero indicates no valid hash.  Also, sets l4_rxhash in skb
2588  * if hash is a canonical 4-tuple hash over transport ports.
2589  */
2590 void __skb_get_rxhash(struct sk_buff *skb)
2591 {
2592         int nhoff, hash = 0, poff;
2593         const struct ipv6hdr *ip6;
2594         const struct iphdr *ip;
2595         const struct vlan_hdr *vlan;
2596         u8 ip_proto;
2597         u32 addr1, addr2;
2598         u16 proto;
2599         union {
2600                 u32 v32;
2601                 u16 v16[2];
2602         } ports;
2603
2604         nhoff = skb_network_offset(skb);
2605         proto = skb->protocol;
2606
2607 again:
2608         switch (proto) {
2609         case __constant_htons(ETH_P_IP):
2610 ip:
2611                 if (!pskb_may_pull(skb, sizeof(*ip) + nhoff))
2612                         goto done;
2613
2614                 ip = (const struct iphdr *) (skb->data + nhoff);
2615                 if (ip->ihl < 5)
2616                         goto done;
2617                 if (ip_is_fragment(ip))
2618                         ip_proto = 0;
2619                 else
2620                         ip_proto = ip->protocol;
2621                 addr1 = (__force u32) ip->saddr;
2622                 addr2 = (__force u32) ip->daddr;
2623                 nhoff += ip->ihl * 4;
2624                 break;
2625         case __constant_htons(ETH_P_IPV6):
2626 ipv6:
2627                 if (!pskb_may_pull(skb, sizeof(*ip6) + nhoff))
2628                         goto done;
2629
2630                 ip6 = (const struct ipv6hdr *) (skb->data + nhoff);
2631                 ip_proto = ip6->nexthdr;
2632                 addr1 = (__force u32) ip6->saddr.s6_addr32[3];
2633                 addr2 = (__force u32) ip6->daddr.s6_addr32[3];
2634                 nhoff += 40;
2635                 break;
2636         case __constant_htons(ETH_P_8021Q):
2637                 if (!pskb_may_pull(skb, sizeof(*vlan) + nhoff))
2638                         goto done;
2639                 vlan = (const struct vlan_hdr *) (skb->data + nhoff);
2640                 proto = vlan->h_vlan_encapsulated_proto;
2641                 nhoff += sizeof(*vlan);
2642                 goto again;
2643         case __constant_htons(ETH_P_PPP_SES):
2644                 if (!pskb_may_pull(skb, PPPOE_SES_HLEN + nhoff))
2645                         goto done;
2646                 proto = *((__be16 *) (skb->data + nhoff +
2647                                       sizeof(struct pppoe_hdr)));
2648                 nhoff += PPPOE_SES_HLEN;
2649                 switch (proto) {
2650                 case __constant_htons(PPP_IP):
2651                         goto ip;
2652                 case __constant_htons(PPP_IPV6):
2653                         goto ipv6;
2654                 default:
2655                         goto done;
2656                 }
2657         default:
2658                 goto done;
2659         }
2660
2661         switch (ip_proto) {
2662         case IPPROTO_GRE:
2663                 if (pskb_may_pull(skb, nhoff + 16)) {
2664                         u8 *h = skb->data + nhoff;
2665                         __be16 flags = *(__be16 *)h;
2666
2667                         /*
2668                          * Only look inside GRE if version zero and no
2669                          * routing
2670                          */
2671                         if (!(flags & (GRE_VERSION|GRE_ROUTING))) {
2672                                 proto = *(__be16 *)(h + 2);
2673                                 nhoff += 4;
2674                                 if (flags & GRE_CSUM)
2675                                         nhoff += 4;
2676                                 if (flags & GRE_KEY)
2677                                         nhoff += 4;
2678                                 if (flags & GRE_SEQ)
2679                                         nhoff += 4;
2680                                 goto again;
2681                         }
2682                 }
2683                 break;
2684         case IPPROTO_IPIP:
2685                 goto again;
2686         default:
2687                 break;
2688         }
2689
2690         ports.v32 = 0;
2691         poff = proto_ports_offset(ip_proto);
2692         if (poff >= 0) {
2693                 nhoff += poff;
2694                 if (pskb_may_pull(skb, nhoff + 4)) {
2695                         ports.v32 = * (__force u32 *) (skb->data + nhoff);
2696                         skb->l4_rxhash = 1;
2697                 }
2698         }
2699
2700         /* get a consistent hash (same value on both flow directions) */
2701         if (addr2 < addr1 ||
2702             (addr2 == addr1 &&
2703              ports.v16[1] < ports.v16[0])) {
2704                 swap(addr1, addr2);
2705                 swap(ports.v16[0], ports.v16[1]);
2706         }
2707         hash = jhash_3words(addr1, addr2, ports.v32, hashrnd);
2708         if (!hash)
2709                 hash = 1;
2710
2711 done:
2712         skb->rxhash = hash;
2713 }
2714 EXPORT_SYMBOL(__skb_get_rxhash);
2715
2716 #ifdef CONFIG_RPS
2717
2718 /* One global table that all flow-based protocols share. */
2719 struct rps_sock_flow_table __rcu *rps_sock_flow_table __read_mostly;
2720 EXPORT_SYMBOL(rps_sock_flow_table);
2721
2722 static struct rps_dev_flow *
2723 set_rps_cpu(struct net_device *dev, struct sk_buff *skb,
2724             struct rps_dev_flow *rflow, u16 next_cpu)
2725 {
2726         if (next_cpu != RPS_NO_CPU) {
2727 #ifdef CONFIG_RFS_ACCEL
2728                 struct netdev_rx_queue *rxqueue;
2729                 struct rps_dev_flow_table *flow_table;
2730                 struct rps_dev_flow *old_rflow;
2731                 u32 flow_id;
2732                 u16 rxq_index;
2733                 int rc;
2734
2735                 /* Should we steer this flow to a different hardware queue? */
2736                 if (!skb_rx_queue_recorded(skb) || !dev->rx_cpu_rmap ||
2737                     !(dev->features & NETIF_F_NTUPLE))
2738                         goto out;
2739                 rxq_index = cpu_rmap_lookup_index(dev->rx_cpu_rmap, next_cpu);
2740                 if (rxq_index == skb_get_rx_queue(skb))
2741                         goto out;
2742
2743                 rxqueue = dev->_rx + rxq_index;
2744                 flow_table = rcu_dereference(rxqueue->rps_flow_table);
2745                 if (!flow_table)
2746                         goto out;
2747                 flow_id = skb->rxhash & flow_table->mask;
2748                 rc = dev->netdev_ops->ndo_rx_flow_steer(dev, skb,
2749                                                         rxq_index, flow_id);
2750                 if (rc < 0)
2751                         goto out;
2752                 old_rflow = rflow;
2753                 rflow = &flow_table->flows[flow_id];
2754                 rflow->filter = rc;
2755                 if (old_rflow->filter == rflow->filter)
2756                         old_rflow->filter = RPS_NO_FILTER;
2757         out:
2758 #endif
2759                 rflow->last_qtail =
2760                         per_cpu(softnet_data, next_cpu).input_queue_head;
2761         }
2762
2763         rflow->cpu = next_cpu;
2764         return rflow;
2765 }
2766
2767 /*
2768  * get_rps_cpu is called from netif_receive_skb and returns the target
2769  * CPU from the RPS map of the receiving queue for a given skb.
2770  * rcu_read_lock must be held on entry.
2771  */
2772 static int get_rps_cpu(struct net_device *dev, struct sk_buff *skb,
2773                        struct rps_dev_flow **rflowp)
2774 {
2775         struct netdev_rx_queue *rxqueue;
2776         struct rps_map *map;
2777         struct rps_dev_flow_table *flow_table;
2778         struct rps_sock_flow_table *sock_flow_table;
2779         int cpu = -1;
2780         u16 tcpu;
2781
2782         if (skb_rx_queue_recorded(skb)) {
2783                 u16 index = skb_get_rx_queue(skb);
2784                 if (unlikely(index >= dev->real_num_rx_queues)) {
2785                         WARN_ONCE(dev->real_num_rx_queues > 1,
2786                                   "%s received packet on queue %u, but number "
2787                                   "of RX queues is %u\n",
2788                                   dev->name, index, dev->real_num_rx_queues);
2789                         goto done;
2790                 }
2791                 rxqueue = dev->_rx + index;
2792         } else
2793                 rxqueue = dev->_rx;
2794
2795         map = rcu_dereference(rxqueue->rps_map);
2796         if (map) {
2797                 if (map->len == 1 &&
2798                     !rcu_access_pointer(rxqueue->rps_flow_table)) {
2799                         tcpu = map->cpus[0];
2800                         if (cpu_online(tcpu))
2801                                 cpu = tcpu;
2802                         goto done;
2803                 }
2804         } else if (!rcu_access_pointer(rxqueue->rps_flow_table)) {
2805                 goto done;
2806         }
2807
2808         skb_reset_network_header(skb);
2809         if (!skb_get_rxhash(skb))
2810                 goto done;
2811
2812         flow_table = rcu_dereference(rxqueue->rps_flow_table);
2813         sock_flow_table = rcu_dereference(rps_sock_flow_table);
2814         if (flow_table && sock_flow_table) {
2815                 u16 next_cpu;
2816                 struct rps_dev_flow *rflow;
2817
2818                 rflow = &flow_table->flows[skb->rxhash & flow_table->mask];
2819                 tcpu = rflow->cpu;
2820
2821                 next_cpu = sock_flow_table->ents[skb->rxhash &
2822                     sock_flow_table->mask];
2823
2824                 /*
2825                  * If the desired CPU (where last recvmsg was done) is
2826                  * different from current CPU (one in the rx-queue flow
2827                  * table entry), switch if one of the following holds:
2828                  *   - Current CPU is unset (equal to RPS_NO_CPU).
2829                  *   - Current CPU is offline.
2830                  *   - The current CPU's queue tail has advanced beyond the
2831                  *     last packet that was enqueued using this table entry.
2832                  *     This guarantees that all previous packets for the flow
2833                  *     have been dequeued, thus preserving in order delivery.
2834                  */
2835                 if (unlikely(tcpu != next_cpu) &&
2836                     (tcpu == RPS_NO_CPU || !cpu_online(tcpu) ||
2837                      ((int)(per_cpu(softnet_data, tcpu).input_queue_head -
2838                       rflow->last_qtail)) >= 0)) {
2839                         tcpu = next_cpu;
2840                         rflow = set_rps_cpu(dev, skb, rflow, next_cpu);
2841                 }
2842
2843                 if (tcpu != RPS_NO_CPU && cpu_online(tcpu)) {
2844                         *rflowp = rflow;
2845                         cpu = tcpu;
2846                         goto done;
2847                 }
2848         }
2849
2850         if (map) {
2851                 tcpu = map->cpus[((u64) skb->rxhash * map->len) >> 32];
2852
2853                 if (cpu_online(tcpu)) {
2854                         cpu = tcpu;
2855                         goto done;
2856                 }
2857         }
2858
2859 done:
2860         return cpu;
2861 }
2862
2863 #ifdef CONFIG_RFS_ACCEL
2864
2865 /**
2866  * rps_may_expire_flow - check whether an RFS hardware filter may be removed
2867  * @dev: Device on which the filter was set
2868  * @rxq_index: RX queue index
2869  * @flow_id: Flow ID passed to ndo_rx_flow_steer()
2870  * @filter_id: Filter ID returned by ndo_rx_flow_steer()
2871  *
2872  * Drivers that implement ndo_rx_flow_steer() should periodically call
2873  * this function for each installed filter and remove the filters for
2874  * which it returns %true.
2875  */
2876 bool rps_may_expire_flow(struct net_device *dev, u16 rxq_index,
2877                          u32 flow_id, u16 filter_id)
2878 {
2879         struct netdev_rx_queue *rxqueue = dev->_rx + rxq_index;
2880         struct rps_dev_flow_table *flow_table;
2881         struct rps_dev_flow *rflow;
2882         bool expire = true;
2883         int cpu;
2884
2885         rcu_read_lock();
2886         flow_table = rcu_dereference(rxqueue->rps_flow_table);
2887         if (flow_table && flow_id <= flow_table->mask) {
2888                 rflow = &flow_table->flows[flow_id];
2889                 cpu = ACCESS_ONCE(rflow->cpu);
2890                 if (rflow->filter == filter_id && cpu != RPS_NO_CPU &&
2891                     ((int)(per_cpu(softnet_data, cpu).input_queue_head -
2892                            rflow->last_qtail) <
2893                      (int)(10 * flow_table->mask)))
2894                         expire = false;
2895         }
2896         rcu_read_unlock();
2897         return expire;
2898 }
2899 EXPORT_SYMBOL(rps_may_expire_flow);
2900
2901 #endif /* CONFIG_RFS_ACCEL */
2902
2903 /* Called from hardirq (IPI) context */
2904 static void rps_trigger_softirq(void *data)
2905 {
2906         struct softnet_data *sd = data;
2907
2908         ____napi_schedule(sd, &sd->backlog);
2909         sd->received_rps++;
2910 }
2911
2912 #endif /* CONFIG_RPS */
2913
2914 /*
2915  * Check if this softnet_data structure is another cpu one
2916  * If yes, queue it to our IPI list and return 1
2917  * If no, return 0
2918  */
2919 static int rps_ipi_queued(struct softnet_data *sd)
2920 {
2921 #ifdef CONFIG_RPS
2922         struct softnet_data *mysd = &__get_cpu_var(softnet_data);
2923
2924         if (sd != mysd) {
2925                 sd->rps_ipi_next = mysd->rps_ipi_list;
2926                 mysd->rps_ipi_list = sd;
2927
2928                 __raise_softirq_irqoff(NET_RX_SOFTIRQ);
2929                 return 1;
2930         }
2931 #endif /* CONFIG_RPS */
2932         return 0;
2933 }
2934
2935 /*
2936  * enqueue_to_backlog is called to queue an skb to a per CPU backlog
2937  * queue (may be a remote CPU queue).
2938  */
2939 static int enqueue_to_backlog(struct sk_buff *skb, int cpu,
2940                               unsigned int *qtail)
2941 {
2942         struct softnet_data *sd;
2943         unsigned long flags;
2944
2945         sd = &per_cpu(softnet_data, cpu);
2946
2947         local_irq_save(flags);
2948
2949         rps_lock(sd);
2950         if (!netif_running(skb->dev))
2951                 goto drop;
2952         if (skb_queue_len(&sd->input_pkt_queue) <= netdev_max_backlog) {
2953                 if (skb_queue_len(&sd->input_pkt_queue)) {
2954 enqueue:
2955                         __skb_queue_tail(&sd->input_pkt_queue, skb);
2956                         input_queue_tail_incr_save(sd, qtail);
2957                         rps_unlock(sd);
2958                         local_irq_restore(flags);
2959                         return NET_RX_SUCCESS;
2960                 }
2961
2962                 /* Schedule NAPI for backlog device
2963                  * We can use non atomic operation since we own the queue lock
2964                  */
2965                 if (!__test_and_set_bit(NAPI_STATE_SCHED, &sd->backlog.state)) {
2966                         if (!rps_ipi_queued(sd))
2967                                 ____napi_schedule(sd, &sd->backlog);
2968                 }
2969                 goto enqueue;
2970         }
2971
2972 drop:
2973         sd->dropped++;
2974         rps_unlock(sd);
2975
2976         local_irq_restore(flags);
2977
2978         atomic_long_inc(&skb->dev->rx_dropped);
2979         kfree_skb(skb);
2980         return NET_RX_DROP;
2981 }
2982
2983 /**
2984  *      netif_rx        -       post buffer to the network code
2985  *      @skb: buffer to post
2986  *
2987  *      This function receives a packet from a device driver and queues it for
2988  *      the upper (protocol) levels to process.  It always succeeds. The buffer
2989  *      may be dropped during processing for congestion control or by the
2990  *      protocol layers.
2991  *
2992  *      return values:
2993  *      NET_RX_SUCCESS  (no congestion)
2994  *      NET_RX_DROP     (packet was dropped)
2995  *
2996  */
2997
2998 int netif_rx(struct sk_buff *skb)
2999 {
3000         int ret;
3001
3002         /* if netpoll wants it, pretend we never saw it */
3003         if (netpoll_rx(skb))
3004                 return NET_RX_DROP;
3005
3006         if (netdev_tstamp_prequeue)
3007                 net_timestamp_check(skb);
3008
3009         trace_netif_rx(skb);
3010 #ifdef CONFIG_RPS
3011         {
3012                 struct rps_dev_flow voidflow, *rflow = &voidflow;
3013                 int cpu;
3014
3015                 preempt_disable();
3016                 rcu_read_lock();
3017
3018                 cpu = get_rps_cpu(skb->dev, skb, &rflow);
3019                 if (cpu < 0)
3020                         cpu = smp_processor_id();
3021
3022                 ret = enqueue_to_backlog(skb, cpu, &rflow->last_qtail);
3023
3024                 rcu_read_unlock();
3025                 preempt_enable();
3026         }
3027 #else
3028         {
3029                 unsigned int qtail;
3030                 ret = enqueue_to_backlog(skb, get_cpu(), &qtail);
3031                 put_cpu();
3032         }
3033 #endif
3034         return ret;
3035 }
3036 EXPORT_SYMBOL(netif_rx);
3037
3038 int netif_rx_ni(struct sk_buff *skb)
3039 {
3040         int err;
3041
3042         preempt_disable();
3043         err = netif_rx(skb);
3044         if (local_softirq_pending())
3045                 do_softirq();
3046         preempt_enable();
3047
3048         return err;
3049 }
3050 EXPORT_SYMBOL(netif_rx_ni);
3051
3052 static void net_tx_action(struct softirq_action *h)
3053 {
3054         struct softnet_data *sd = &__get_cpu_var(softnet_data);
3055
3056         if (sd->completion_queue) {
3057                 struct sk_buff *clist;
3058
3059                 local_irq_disable();
3060                 clist = sd->completion_queue;
3061                 sd->completion_queue = NULL;
3062                 local_irq_enable();
3063
3064                 while (clist) {
3065                         struct sk_buff *skb = clist;
3066                         clist = clist->next;
3067
3068                         WARN_ON(atomic_read(&skb->users));
3069                         trace_kfree_skb(skb, net_tx_action);
3070                         __kfree_skb(skb);
3071                 }
3072         }
3073
3074         if (sd->output_queue) {
3075                 struct Qdisc *head;
3076
3077                 local_irq_disable();
3078                 head = sd->output_queue;
3079                 sd->output_queue = NULL;
3080                 sd->output_queue_tailp = &sd->output_queue;
3081                 local_irq_enable();
3082
3083                 while (head) {
3084                         struct Qdisc *q = head;
3085                         spinlock_t *root_lock;
3086
3087                         head = head->next_sched;
3088
3089                         root_lock = qdisc_lock(q);
3090                         if (spin_trylock(root_lock)) {
3091                                 smp_mb__before_clear_bit();
3092                                 clear_bit(__QDISC_STATE_SCHED,
3093                                           &q->state);
3094                                 qdisc_run(q);
3095                                 spin_unlock(root_lock);
3096                         } else {
3097                                 if (!test_bit(__QDISC_STATE_DEACTIVATED,
3098                                               &q->state)) {
3099                                         __netif_reschedule(q);
3100                                 } else {
3101                                         smp_mb__before_clear_bit();
3102                                         clear_bit(__QDISC_STATE_SCHED,
3103                                                   &q->state);
3104                                 }
3105                         }
3106                 }
3107         }
3108 }
3109
3110 #if (defined(CONFIG_BRIDGE) || defined(CONFIG_BRIDGE_MODULE)) && \
3111     (defined(CONFIG_ATM_LANE) || defined(CONFIG_ATM_LANE_MODULE))
3112 /* This hook is defined here for ATM LANE */
3113 int (*br_fdb_test_addr_hook)(struct net_device *dev,
3114                              unsigned char *addr) __read_mostly;
3115 EXPORT_SYMBOL_GPL(br_fdb_test_addr_hook);
3116 #endif
3117
3118 #ifdef CONFIG_NET_CLS_ACT
3119 /* TODO: Maybe we should just force sch_ingress to be compiled in
3120  * when CONFIG_NET_CLS_ACT is? otherwise some useless instructions
3121  * a compare and 2 stores extra right now if we dont have it on
3122  * but have CONFIG_NET_CLS_ACT
3123  * NOTE: This doesn't stop any functionality; if you dont have
3124  * the ingress scheduler, you just can't add policies on ingress.
3125  *
3126  */
3127 static int ing_filter(struct sk_buff *skb, struct netdev_queue *rxq)
3128 {
3129         struct net_device *dev = skb->dev;
3130         u32 ttl = G_TC_RTTL(skb->tc_verd);
3131         int result = TC_ACT_OK;
3132         struct Qdisc *q;
3133
3134         if (unlikely(MAX_RED_LOOP < ttl++)) {
3135                 if (net_ratelimit())
3136                         pr_warning( "Redir loop detected Dropping packet (%d->%d)\n",
3137                                skb->skb_iif, dev->ifindex);
3138                 return TC_ACT_SHOT;
3139         }
3140
3141         skb->tc_verd = SET_TC_RTTL(skb->tc_verd, ttl);
3142         skb->tc_verd = SET_TC_AT(skb->tc_verd, AT_INGRESS);
3143
3144         q = rxq->qdisc;
3145         if (q != &noop_qdisc) {
3146                 spin_lock(qdisc_lock(q));
3147                 if (likely(!test_bit(__QDISC_STATE_DEACTIVATED, &q->state)))
3148                         result = qdisc_enqueue_root(skb, q);
3149                 spin_unlock(qdisc_lock(q));
3150         }
3151
3152         return result;
3153 }
3154
3155 static inline struct sk_buff *handle_ing(struct sk_buff *skb,
3156                                          struct packet_type **pt_prev,
3157                                          int *ret, struct net_device *orig_dev)
3158 {
3159         struct netdev_queue *rxq = rcu_dereference(skb->dev->ingress_queue);
3160
3161         if (!rxq || rxq->qdisc == &noop_qdisc)
3162                 goto out;
3163
3164         if (*pt_prev) {
3165                 *ret = deliver_skb(skb, *pt_prev, orig_dev);
3166                 *pt_prev = NULL;
3167         }
3168
3169         switch (ing_filter(skb, rxq)) {
3170         case TC_ACT_SHOT:
3171         case TC_ACT_STOLEN:
3172                 kfree_skb(skb);
3173                 return NULL;
3174         }
3175
3176 out:
3177         skb->tc_verd = 0;
3178         return skb;
3179 }
3180 #endif
3181
3182 /**
3183  *      netdev_rx_handler_register - register receive handler
3184  *      @dev: device to register a handler for
3185  *      @rx_handler: receive handler to register
3186  *      @rx_handler_data: data pointer that is used by rx handler
3187  *
3188  *      Register a receive hander for a device. This handler will then be
3189  *      called from __netif_receive_skb. A negative errno code is returned
3190  *      on a failure.
3191  *
3192  *      The caller must hold the rtnl_mutex.
3193  *
3194  *      For a general description of rx_handler, see enum rx_handler_result.
3195  */
3196 int netdev_rx_handler_register(struct net_device *dev,
3197                                rx_handler_func_t *rx_handler,
3198                                void *rx_handler_data)
3199 {
3200         ASSERT_RTNL();
3201
3202         if (dev->rx_handler)
3203                 return -EBUSY;
3204
3205         /* Note: rx_handler_data must be set before rx_handler */
3206         rcu_assign_pointer(dev->rx_handler_data, rx_handler_data);
3207         rcu_assign_pointer(dev->rx_handler, rx_handler);
3208
3209         return 0;
3210 }
3211 EXPORT_SYMBOL_GPL(netdev_rx_handler_register);
3212
3213 /**
3214  *      netdev_rx_handler_unregister - unregister receive handler
3215  *      @dev: device to unregister a handler from
3216  *
3217  *      Unregister a receive hander from a device.
3218  *
3219  *      The caller must hold the rtnl_mutex.
3220  */
3221 void netdev_rx_handler_unregister(struct net_device *dev)
3222 {
3223
3224         ASSERT_RTNL();
3225         RCU_INIT_POINTER(dev->rx_handler, NULL);
3226         /* a reader seeing a non NULL rx_handler in a rcu_read_lock()
3227          * section has a guarantee to see a non NULL rx_handler_data
3228          * as well.
3229          */
3230         synchronize_net();
3231         RCU_INIT_POINTER(dev->rx_handler_data, NULL);
3232 }
3233 EXPORT_SYMBOL_GPL(netdev_rx_handler_unregister);
3234
3235 static int __netif_receive_skb(struct sk_buff *skb)
3236 {
3237         struct packet_type *ptype, *pt_prev;
3238         rx_handler_func_t *rx_handler;
3239         struct net_device *orig_dev;
3240         struct net_device *null_or_dev;
3241         bool deliver_exact = false;
3242         int ret = NET_RX_DROP;
3243         __be16 type;
3244
3245         if (!netdev_tstamp_prequeue)
3246                 net_timestamp_check(skb);
3247
3248         trace_netif_receive_skb(skb);
3249
3250         /* if we've gotten here through NAPI, check netpoll */
3251         if (netpoll_receive_skb(skb))
3252                 return NET_RX_DROP;
3253
3254         if (!skb->skb_iif)
3255                 skb->skb_iif = skb->dev->ifindex;
3256         orig_dev = skb->dev;
3257
3258         skb_reset_network_header(skb);
3259         skb_reset_transport_header(skb);
3260         skb_reset_mac_len(skb);
3261
3262         pt_prev = NULL;
3263
3264 another_round:
3265
3266         __this_cpu_inc(softnet_data.processed);
3267
3268         if (skb->protocol == cpu_to_be16(ETH_P_8021Q)) {
3269                 skb = vlan_untag(skb);
3270                 if (unlikely(!skb))
3271                         goto out;
3272         }
3273
3274 #ifdef CONFIG_NET_CLS_ACT
3275         if (skb->tc_verd & TC_NCLS) {
3276                 skb->tc_verd = CLR_TC_NCLS(skb->tc_verd);
3277                 goto ncls;
3278         }
3279 #endif
3280
3281         list_for_each_entry_rcu(ptype, &ptype_all, list) {
3282                 if (!ptype->dev || ptype->dev == skb->dev) {
3283                         if (pt_prev)
3284                                 ret = deliver_skb(skb, pt_prev, orig_dev);
3285                         pt_prev = ptype;
3286                 }
3287         }
3288
3289 #ifdef CONFIG_NET_CLS_ACT
3290         skb = handle_ing(skb, &pt_prev, &ret, orig_dev);
3291         if (!skb)
3292                 goto out;
3293 ncls:
3294 #endif
3295
3296         if (vlan_tx_tag_present(skb)) {
3297                 if (pt_prev) {
3298                         ret = deliver_skb(skb, pt_prev, orig_dev);
3299                         pt_prev = NULL;
3300                 }
3301                 if (vlan_do_receive(&skb))
3302                         goto another_round;
3303                 else if (unlikely(!skb))
3304                         goto out;
3305         }
3306
3307         rx_handler = rcu_dereference(skb->dev->rx_handler);
3308         if (rx_handler) {
3309                 if (pt_prev) {
3310                         ret = deliver_skb(skb, pt_prev, orig_dev);
3311                         pt_prev