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