net: Statically initialize init_net.dev_base_head
[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                 if ((__force u16)keys.port16[1] < (__force u16)keys.port16[0])
2622                         swap(keys.port16[0], keys.port16[1]);
2623                 skb->l4_rxhash = 1;
2624         }
2625
2626         /* get a consistent hash (same value on both flow directions) */
2627         if ((__force u32)keys.dst < (__force u32)keys.src)
2628                 swap(keys.dst, keys.src);
2629
2630         hash = jhash_3words((__force u32)keys.dst,
2631                             (__force u32)keys.src,
2632                             (__force u32)keys.ports, hashrnd);
2633         if (!hash)
2634                 hash = 1;
2635
2636         skb->rxhash = hash;
2637 }
2638 EXPORT_SYMBOL(__skb_get_rxhash);
2639
2640 #ifdef CONFIG_RPS
2641
2642 /* One global table that all flow-based protocols share. */
2643 struct rps_sock_flow_table __rcu *rps_sock_flow_table __read_mostly;
2644 EXPORT_SYMBOL(rps_sock_flow_table);
2645
2646 struct static_key rps_needed __read_mostly;
2647
2648 static struct rps_dev_flow *
2649 set_rps_cpu(struct net_device *dev, struct sk_buff *skb,
2650             struct rps_dev_flow *rflow, u16 next_cpu)
2651 {
2652         if (next_cpu != RPS_NO_CPU) {
2653 #ifdef CONFIG_RFS_ACCEL
2654                 struct netdev_rx_queue *rxqueue;
2655                 struct rps_dev_flow_table *flow_table;
2656                 struct rps_dev_flow *old_rflow;
2657                 u32 flow_id;
2658                 u16 rxq_index;
2659                 int rc;
2660
2661                 /* Should we steer this flow to a different hardware queue? */
2662                 if (!skb_rx_queue_recorded(skb) || !dev->rx_cpu_rmap ||
2663                     !(dev->features & NETIF_F_NTUPLE))
2664                         goto out;
2665                 rxq_index = cpu_rmap_lookup_index(dev->rx_cpu_rmap, next_cpu);
2666                 if (rxq_index == skb_get_rx_queue(skb))
2667                         goto out;
2668
2669                 rxqueue = dev->_rx + rxq_index;
2670                 flow_table = rcu_dereference(rxqueue->rps_flow_table);
2671                 if (!flow_table)
2672                         goto out;
2673                 flow_id = skb->rxhash & flow_table->mask;
2674                 rc = dev->netdev_ops->ndo_rx_flow_steer(dev, skb,
2675                                                         rxq_index, flow_id);
2676                 if (rc < 0)
2677                         goto out;
2678                 old_rflow = rflow;
2679                 rflow = &flow_table->flows[flow_id];
2680                 rflow->filter = rc;
2681                 if (old_rflow->filter == rflow->filter)
2682                         old_rflow->filter = RPS_NO_FILTER;
2683         out:
2684 #endif
2685                 rflow->last_qtail =
2686                         per_cpu(softnet_data, next_cpu).input_queue_head;
2687         }
2688
2689         rflow->cpu = next_cpu;
2690         return rflow;
2691 }
2692
2693 /*
2694  * get_rps_cpu is called from netif_receive_skb and returns the target
2695  * CPU from the RPS map of the receiving queue for a given skb.
2696  * rcu_read_lock must be held on entry.
2697  */
2698 static int get_rps_cpu(struct net_device *dev, struct sk_buff *skb,
2699                        struct rps_dev_flow **rflowp)
2700 {
2701         struct netdev_rx_queue *rxqueue;
2702         struct rps_map *map;
2703         struct rps_dev_flow_table *flow_table;
2704         struct rps_sock_flow_table *sock_flow_table;
2705         int cpu = -1;
2706         u16 tcpu;
2707
2708         if (skb_rx_queue_recorded(skb)) {
2709                 u16 index = skb_get_rx_queue(skb);
2710                 if (unlikely(index >= dev->real_num_rx_queues)) {
2711                         WARN_ONCE(dev->real_num_rx_queues > 1,
2712                                   "%s received packet on queue %u, but number "
2713                                   "of RX queues is %u\n",
2714                                   dev->name, index, dev->real_num_rx_queues);
2715                         goto done;
2716                 }
2717                 rxqueue = dev->_rx + index;
2718         } else
2719                 rxqueue = dev->_rx;
2720
2721         map = rcu_dereference(rxqueue->rps_map);
2722         if (map) {
2723                 if (map->len == 1 &&
2724                     !rcu_access_pointer(rxqueue->rps_flow_table)) {
2725                         tcpu = map->cpus[0];
2726                         if (cpu_online(tcpu))
2727                                 cpu = tcpu;
2728                         goto done;
2729                 }
2730         } else if (!rcu_access_pointer(rxqueue->rps_flow_table)) {
2731                 goto done;
2732         }
2733
2734         skb_reset_network_header(skb);
2735         if (!skb_get_rxhash(skb))
2736                 goto done;
2737
2738         flow_table = rcu_dereference(rxqueue->rps_flow_table);
2739         sock_flow_table = rcu_dereference(rps_sock_flow_table);
2740         if (flow_table && sock_flow_table) {
2741                 u16 next_cpu;
2742                 struct rps_dev_flow *rflow;
2743
2744                 rflow = &flow_table->flows[skb->rxhash & flow_table->mask];
2745                 tcpu = rflow->cpu;
2746
2747                 next_cpu = sock_flow_table->ents[skb->rxhash &
2748                     sock_flow_table->mask];
2749
2750                 /*
2751                  * If the desired CPU (where last recvmsg was done) is
2752                  * different from current CPU (one in the rx-queue flow
2753                  * table entry), switch if one of the following holds:
2754                  *   - Current CPU is unset (equal to RPS_NO_CPU).
2755                  *   - Current CPU is offline.
2756                  *   - The current CPU's queue tail has advanced beyond the
2757                  *     last packet that was enqueued using this table entry.
2758                  *     This guarantees that all previous packets for the flow
2759                  *     have been dequeued, thus preserving in order delivery.
2760                  */
2761                 if (unlikely(tcpu != next_cpu) &&
2762                     (tcpu == RPS_NO_CPU || !cpu_online(tcpu) ||
2763                      ((int)(per_cpu(softnet_data, tcpu).input_queue_head -
2764                       rflow->last_qtail)) >= 0))
2765                         rflow = set_rps_cpu(dev, skb, rflow, next_cpu);
2766
2767                 if (tcpu != RPS_NO_CPU && cpu_online(tcpu)) {
2768                         *rflowp = rflow;
2769                         cpu = tcpu;
2770                         goto done;
2771                 }
2772         }
2773
2774         if (map) {
2775                 tcpu = map->cpus[((u64) skb->rxhash * map->len) >> 32];
2776
2777                 if (cpu_online(tcpu)) {
2778                         cpu = tcpu;
2779                         goto done;
2780                 }
2781         }
2782
2783 done:
2784         return cpu;
2785 }
2786
2787 #ifdef CONFIG_RFS_ACCEL
2788
2789 /**
2790  * rps_may_expire_flow - check whether an RFS hardware filter may be removed
2791  * @dev: Device on which the filter was set
2792  * @rxq_index: RX queue index
2793  * @flow_id: Flow ID passed to ndo_rx_flow_steer()
2794  * @filter_id: Filter ID returned by ndo_rx_flow_steer()
2795  *
2796  * Drivers that implement ndo_rx_flow_steer() should periodically call
2797  * this function for each installed filter and remove the filters for
2798  * which it returns %true.
2799  */
2800 bool rps_may_expire_flow(struct net_device *dev, u16 rxq_index,
2801                          u32 flow_id, u16 filter_id)
2802 {
2803         struct netdev_rx_queue *rxqueue = dev->_rx + rxq_index;
2804         struct rps_dev_flow_table *flow_table;
2805         struct rps_dev_flow *rflow;
2806         bool expire = true;
2807         int cpu;
2808
2809         rcu_read_lock();
2810         flow_table = rcu_dereference(rxqueue->rps_flow_table);
2811         if (flow_table && flow_id <= flow_table->mask) {
2812                 rflow = &flow_table->flows[flow_id];
2813                 cpu = ACCESS_ONCE(rflow->cpu);
2814                 if (rflow->filter == filter_id && cpu != RPS_NO_CPU &&
2815                     ((int)(per_cpu(softnet_data, cpu).input_queue_head -
2816                            rflow->last_qtail) <
2817                      (int)(10 * flow_table->mask)))
2818                         expire = false;
2819         }
2820         rcu_read_unlock();
2821         return expire;
2822 }
2823 EXPORT_SYMBOL(rps_may_expire_flow);
2824
2825 #endif /* CONFIG_RFS_ACCEL */
2826
2827 /* Called from hardirq (IPI) context */
2828 static void rps_trigger_softirq(void *data)
2829 {
2830         struct softnet_data *sd = data;
2831
2832         ____napi_schedule(sd, &sd->backlog);
2833         sd->received_rps++;
2834 }
2835
2836 #endif /* CONFIG_RPS */
2837
2838 /*
2839  * Check if this softnet_data structure is another cpu one
2840  * If yes, queue it to our IPI list and return 1
2841  * If no, return 0
2842  */
2843 static int rps_ipi_queued(struct softnet_data *sd)
2844 {
2845 #ifdef CONFIG_RPS
2846         struct softnet_data *mysd = &__get_cpu_var(softnet_data);
2847
2848         if (sd != mysd) {
2849                 sd->rps_ipi_next = mysd->rps_ipi_list;
2850                 mysd->rps_ipi_list = sd;
2851
2852                 __raise_softirq_irqoff(NET_RX_SOFTIRQ);
2853                 return 1;
2854         }
2855 #endif /* CONFIG_RPS */
2856         return 0;
2857 }
2858
2859 /*
2860  * enqueue_to_backlog is called to queue an skb to a per CPU backlog
2861  * queue (may be a remote CPU queue).
2862  */
2863 static int enqueue_to_backlog(struct sk_buff *skb, int cpu,
2864                               unsigned int *qtail)
2865 {
2866         struct softnet_data *sd;
2867         unsigned long flags;
2868
2869         sd = &per_cpu(softnet_data, cpu);
2870
2871         local_irq_save(flags);
2872
2873         rps_lock(sd);
2874         if (skb_queue_len(&sd->input_pkt_queue) <= netdev_max_backlog) {
2875                 if (skb_queue_len(&sd->input_pkt_queue)) {
2876 enqueue:
2877                         __skb_queue_tail(&sd->input_pkt_queue, skb);
2878                         input_queue_tail_incr_save(sd, qtail);
2879                         rps_unlock(sd);
2880                         local_irq_restore(flags);
2881                         return NET_RX_SUCCESS;
2882                 }
2883
2884                 /* Schedule NAPI for backlog device
2885                  * We can use non atomic operation since we own the queue lock
2886                  */
2887                 if (!__test_and_set_bit(NAPI_STATE_SCHED, &sd->backlog.state)) {
2888                         if (!rps_ipi_queued(sd))
2889                                 ____napi_schedule(sd, &sd->backlog);
2890                 }
2891                 goto enqueue;
2892         }
2893
2894         sd->dropped++;
2895         rps_unlock(sd);
2896
2897         local_irq_restore(flags);
2898
2899         atomic_long_inc(&skb->dev->rx_dropped);
2900         kfree_skb(skb);
2901         return NET_RX_DROP;
2902 }
2903
2904 /**
2905  *      netif_rx        -       post buffer to the network code
2906  *      @skb: buffer to post
2907  *
2908  *      This function receives a packet from a device driver and queues it for
2909  *      the upper (protocol) levels to process.  It always succeeds. The buffer
2910  *      may be dropped during processing for congestion control or by the
2911  *      protocol layers.
2912  *
2913  *      return values:
2914  *      NET_RX_SUCCESS  (no congestion)
2915  *      NET_RX_DROP     (packet was dropped)
2916  *
2917  */
2918
2919 int netif_rx(struct sk_buff *skb)
2920 {
2921         int ret;
2922
2923         /* if netpoll wants it, pretend we never saw it */
2924         if (netpoll_rx(skb))
2925                 return NET_RX_DROP;
2926
2927         net_timestamp_check(netdev_tstamp_prequeue, skb);
2928
2929         trace_netif_rx(skb);
2930 #ifdef CONFIG_RPS
2931         if (static_key_false(&rps_needed)) {
2932                 struct rps_dev_flow voidflow, *rflow = &voidflow;
2933                 int cpu;
2934
2935                 preempt_disable();
2936                 rcu_read_lock();
2937
2938                 cpu = get_rps_cpu(skb->dev, skb, &rflow);
2939                 if (cpu < 0)
2940                         cpu = smp_processor_id();
2941
2942                 ret = enqueue_to_backlog(skb, cpu, &rflow->last_qtail);
2943
2944                 rcu_read_unlock();
2945                 preempt_enable();
2946         } else
2947 #endif
2948         {
2949                 unsigned int qtail;
2950                 ret = enqueue_to_backlog(skb, get_cpu(), &qtail);
2951                 put_cpu();
2952         }
2953         return ret;
2954 }
2955 EXPORT_SYMBOL(netif_rx);
2956
2957 int netif_rx_ni(struct sk_buff *skb)
2958 {
2959         int err;
2960
2961         preempt_disable();
2962         err = netif_rx(skb);
2963         if (local_softirq_pending())
2964                 do_softirq();
2965         preempt_enable();
2966
2967         return err;
2968 }
2969 EXPORT_SYMBOL(netif_rx_ni);
2970
2971 static void net_tx_action(struct softirq_action *h)
2972 {
2973         struct softnet_data *sd = &__get_cpu_var(softnet_data);
2974
2975         if (sd->completion_queue) {
2976                 struct sk_buff *clist;
2977
2978                 local_irq_disable();
2979                 clist = sd->completion_queue;
2980                 sd->completion_queue = NULL;
2981                 local_irq_enable();
2982
2983                 while (clist) {
2984                         struct sk_buff *skb = clist;
2985                         clist = clist->next;
2986
2987                         WARN_ON(atomic_read(&skb->users));
2988                         trace_kfree_skb(skb, net_tx_action);
2989                         __kfree_skb(skb);
2990                 }
2991         }
2992
2993         if (sd->output_queue) {
2994                 struct Qdisc *head;
2995
2996                 local_irq_disable();
2997                 head = sd->output_queue;
2998                 sd->output_queue = NULL;
2999                 sd->output_queue_tailp = &sd->output_queue;
3000                 local_irq_enable();
3001
3002                 while (head) {
3003                         struct Qdisc *q = head;
3004                         spinlock_t *root_lock;
3005
3006                         head = head->next_sched;
3007
3008                         root_lock = qdisc_lock(q);
3009                         if (spin_trylock(root_lock)) {
3010                                 smp_mb__before_clear_bit();
3011                                 clear_bit(__QDISC_STATE_SCHED,
3012                                           &q->state);
3013                                 qdisc_run(q);
3014                                 spin_unlock(root_lock);
3015                         } else {
3016                                 if (!test_bit(__QDISC_STATE_DEACTIVATED,
3017                                               &q->state)) {
3018                                         __netif_reschedule(q);
3019                                 } else {
3020                                         smp_mb__before_clear_bit();
3021                                         clear_bit(__QDISC_STATE_SCHED,
3022                                                   &q->state);
3023                                 }
3024                         }
3025                 }
3026         }
3027 }
3028
3029 #if (defined(CONFIG_BRIDGE) || defined(CONFIG_BRIDGE_MODULE)) && \
3030     (defined(CONFIG_ATM_LANE) || defined(CONFIG_ATM_LANE_MODULE))
3031 /* This hook is defined here for ATM LANE */
3032 int (*br_fdb_test_addr_hook)(struct net_device *dev,
3033                              unsigned char *addr) __read_mostly;
3034 EXPORT_SYMBOL_GPL(br_fdb_test_addr_hook);
3035 #endif
3036
3037 #ifdef CONFIG_NET_CLS_ACT
3038 /* TODO: Maybe we should just force sch_ingress to be compiled in
3039  * when CONFIG_NET_CLS_ACT is? otherwise some useless instructions
3040  * a compare and 2 stores extra right now if we dont have it on
3041  * but have CONFIG_NET_CLS_ACT
3042  * NOTE: This doesn't stop any functionality; if you dont have
3043  * the ingress scheduler, you just can't add policies on ingress.
3044  *
3045  */
3046 static int ing_filter(struct sk_buff *skb, struct netdev_queue *rxq)
3047 {
3048         struct net_device *dev = skb->dev;
3049         u32 ttl = G_TC_RTTL(skb->tc_verd);
3050         int result = TC_ACT_OK;
3051         struct Qdisc *q;
3052
3053         if (unlikely(MAX_RED_LOOP < ttl++)) {
3054                 if (net_ratelimit())
3055                         pr_warn("Redir loop detected Dropping packet (%d->%d)\n",
3056                                 skb->skb_iif, dev->ifindex);
3057                 return TC_ACT_SHOT;
3058         }
3059
3060         skb->tc_verd = SET_TC_RTTL(skb->tc_verd, ttl);
3061         skb->tc_verd = SET_TC_AT(skb->tc_verd, AT_INGRESS);
3062
3063         q = rxq->qdisc;
3064         if (q != &noop_qdisc) {
3065                 spin_lock(qdisc_lock(q));
3066                 if (likely(!test_bit(__QDISC_STATE_DEACTIVATED, &q->state)))
3067                         result = qdisc_enqueue_root(skb, q);
3068                 spin_unlock(qdisc_lock(q));
3069         }
3070
3071         return result;
3072 }
3073
3074 static inline struct sk_buff *handle_ing(struct sk_buff *skb,
3075                                          struct packet_type **pt_prev,
3076                                          int *ret, struct net_device *orig_dev)
3077 {
3078         struct netdev_queue *rxq = rcu_dereference(skb->dev->ingress_queue);
3079
3080         if (!rxq || rxq->qdisc == &noop_qdisc)
3081                 goto out;
3082
3083         if (*pt_prev) {
3084                 *ret = deliver_skb(skb, *pt_prev, orig_dev);
3085                 *pt_prev = NULL;
3086         }
3087
3088         switch (ing_filter(skb, rxq)) {
3089         case TC_ACT_SHOT:
3090         case TC_ACT_STOLEN:
3091                 kfree_skb(skb);
3092                 return NULL;
3093         }
3094
3095 out:
3096         skb->tc_verd = 0;
3097         return skb;
3098 }
3099 #endif
3100
3101 /**
3102  *      netdev_rx_handler_register - register receive handler
3103  *      @dev: device to register a handler for
3104  *      @rx_handler: receive handler to register
3105  *      @rx_handler_data: data pointer that is used by rx handler
3106  *
3107  *      Register a receive hander for a device. This handler will then be
3108  *      called from __netif_receive_skb. A negative errno code is returned
3109  *      on a failure.
3110  *
3111  *      The caller must hold the rtnl_mutex.
3112  *
3113  *      For a general description of rx_handler, see enum rx_handler_result.
3114  */
3115 int netdev_rx_handler_register(struct net_device *dev,
3116                                rx_handler_func_t *rx_handler,
3117                                void *rx_handler_data)
3118 {
3119         ASSERT_RTNL();
3120
3121         if (dev->rx_handler)
3122                 return -EBUSY;
3123
3124         rcu_assign_pointer(dev->rx_handler_data, rx_handler_data);
3125         rcu_assign_pointer(dev->rx_handler, rx_handler);
3126
3127         return 0;
3128 }
3129 EXPORT_SYMBOL_GPL(netdev_rx_handler_register);
3130
3131 /**
3132  *      netdev_rx_handler_unregister - unregister receive handler
3133  *      @dev: device to unregister a handler from
3134  *
3135  *      Unregister a receive hander from a device.
3136  *
3137  *      The caller must hold the rtnl_mutex.
3138  */
3139 void netdev_rx_handler_unregister(struct net_device *dev)
3140 {
3141
3142         ASSERT_RTNL();
3143         RCU_INIT_POINTER(dev->rx_handler, NULL);
3144         RCU_INIT_POINTER(dev->rx_handler_data, NULL);
3145 }
3146 EXPORT_SYMBOL_GPL(netdev_rx_handler_unregister);
3147
3148 static int __netif_receive_skb(struct sk_buff *skb)
3149 {
3150         struct packet_type *ptype, *pt_prev;
3151         rx_handler_func_t *rx_handler;
3152         struct net_device *orig_dev;
3153         struct net_device *null_or_dev;
3154         bool deliver_exact = false;
3155         int ret = NET_RX_DROP;
3156         __be16 type;
3157
3158         net_timestamp_check(!netdev_tstamp_prequeue, skb);
3159
3160         trace_netif_receive_skb(skb);
3161
3162         /* if we've gotten here through NAPI, check netpoll */
3163         if (netpoll_receive_skb(skb))
3164                 return NET_RX_DROP;
3165
3166         if (!skb->skb_iif)
3167                 skb->skb_iif = skb->dev->ifindex;
3168         orig_dev = skb->dev;
3169
3170         skb_reset_network_header(skb);
3171         skb_reset_transport_header(skb);
3172         skb_reset_mac_len(skb);
3173
3174         pt_prev = NULL;
3175
3176         rcu_read_lock();
3177
3178 another_round:
3179
3180         __this_cpu_inc(softnet_data.processed);
3181
3182         if (skb->protocol == cpu_to_be16(ETH_P_8021Q)) {
3183                 skb = vlan_untag(skb);
3184                 if (unlikely(!skb))
3185                         goto out;
3186         }
3187
3188 #ifdef CONFIG_NET_CLS_ACT
3189         if (skb->tc_verd & TC_NCLS) {
3190                 skb->tc_verd = CLR_TC_NCLS(skb->tc_verd);
3191                 goto ncls;
3192         }
3193 #endif
3194
3195         list_for_each_entry_rcu(ptype, &ptype_all, list) {
3196                 if (!ptype->dev || ptype->dev == skb->dev) {
3197                         if (pt_prev)
3198                                 ret = deliver_skb(skb, pt_prev, orig_dev);
3199                         pt_prev = ptype;
3200                 }
3201         }
3202
3203 #ifdef CONFIG_NET_CLS_ACT
3204         skb = handle_ing(skb, &pt_prev, &ret, orig_dev);
3205         if (!skb)
3206                 goto out;
3207 ncls:
3208 #endif
3209
3210         rx_handler = rcu_dereference(skb->dev->rx_handler);
3211         if (vlan_tx_tag_present(skb)) {
3212                 if (pt_prev) {
3213                         ret = deliver_skb(skb, pt_prev, orig_dev);
3214                         pt_prev = NULL;
3215                 }
3216                 if (vlan_do_receive(&skb, !rx_handler))
3217                         goto another_round;
3218                 else if (unlikely(!skb))
3219                         goto out;
3220         }
3221
3222         if (rx_handler) {
3223                 if (pt_prev) {
3224                         ret = deliver_skb(skb, pt_prev, orig_dev);
3225                         pt_prev = NULL;
3226                 }
3227                 switch (rx_handler(&skb)) {
3228                 case RX_HANDLER_CONSUMED:
3229                         goto out;
3230                 case RX_HANDLER_ANOTHER:
3231                         goto another_round;
3232                 case RX_HANDLER_EXACT:
3233                         deliver_exact = true;
3234                 case RX_HANDLER_PASS:
3235                         break;
3236                 default:
3237                         BUG();
3238                 }
3239         }
3240
3241         /* deliver only exact match when indicated */
3242         null_or_dev = deliver_exact ? skb->dev : NULL;
3243
3244         type = skb->protocol;
3245         list_for_each_entry_rcu(ptype,
3246                         &ptype_base[ntohs(type) & PTYPE_HASH_MASK], list) {
3247                 if (ptype->type == type &&
3248                     (ptype->dev == null_or_dev || ptype->dev == skb->dev ||
3249                      ptype->dev == orig_dev)) {
3250                         if (pt_prev)
3251                                 ret = deliver_skb(skb, pt_prev, orig_dev);
3252                         pt_prev = ptype;
3253                 }
3254         }
3255
3256         if (pt_prev) {
3257                 ret = pt_prev->func(skb, skb->dev, pt_prev, orig_dev);
3258         } else {
3259                 atomic_long_inc(&skb->dev->rx_dropped);
3260                 kfree_skb(skb);
3261                 /* Jamal, now you will not able to escape explaining
3262                  * me how you were going to use this. :-)
3263                  */
3264                 ret = NET_RX_DROP;
3265         }
3266
3267 out:
3268         rcu_read_unlock();
3269         return ret;
3270 }
3271
3272 /**
3273  *      netif_receive_skb - process receive buffer from network
3274  *      @skb: buffer to process
3275  *
3276  *      netif_receive_skb() is the main receive data processing function.
3277  *      It always succeeds. The buffer may be dropped during processing
3278  *      for congestion control or by the protocol layers.
3279  *
3280  *      This function may only be called from softirq context and interrupts
3281  *      should be enabled.
3282  *
3283  *      Return values (usually ignored):
3284  *      NET_RX_SUCCESS: no congestion
3285  *      NET_RX_DROP: packet was dropped
3286  */
3287 int netif_receive_skb(struct sk_buff *skb)
3288 {
3289         net_timestamp_check(netdev_tstamp_prequeue, skb);
3290
3291         if (skb_defer_rx_timestamp(skb))
3292                 return NET_RX_SUCCESS;
3293
3294 #ifdef CONFIG_RPS
3295         if (static_key_false(&rps_needed)) {
3296                 struct rps_dev_flow voidflow, *rflow = &voidflow;
3297                 int cpu, ret;
3298
3299                 rcu_read_lock();
3300
3301                 cpu = get_rps_cpu(skb->dev, skb, &rflow);
3302
3303                 if (cpu >= 0) {
3304                         ret = enqueue_to_backlog(skb, cpu, &rflow->last_qtail);
3305                         rcu_read_unlock();
3306                         return ret;
3307                 }
3308                 rcu_read_unlock();
3309         }
3310 #endif
3311         return __netif_receive_skb(skb);
3312 }
3313 EXPORT_SYMBOL(netif_receive_skb);
3314
3315 /* Network device is going away, flush any packets still pending
3316  * Called with irqs disabled.
3317  */
3318 static void flush_backlog(void *arg)
3319 {
3320         struct net_device *dev = arg;
3321         struct softnet_data *sd = &__get_cpu_var(softnet_data);
3322         struct sk_buff *skb, *tmp;
3323
3324         rps_lock(sd);
3325         skb_queue_walk_safe(&sd->input_pkt_queue, skb, tmp) {
3326                 if (skb->dev == dev) {
3327                         __skb_unlink(skb, &sd->input_pkt_queue);
3328                         kfree_skb(skb);
3329                         input_queue_head_incr(sd);
3330                 }
3331         }
3332         rps_unlock(sd);
3333
3334         skb_queue_walk_safe(&sd->process_queue, skb, tmp) {
3335                 if (skb->dev == dev) {
3336                         __skb_unlink(skb, &sd->process_queue);
3337                         kfree_skb(skb);
3338                         input_queue_head_incr(sd);
3339                 }
3340         }
3341 }
3342
3343 static int napi_gro_complete(struct sk_buff *skb)
3344 {
3345         struct packet_type *ptype;
3346         __be16 type = skb->protocol;
3347         struct list_head *head = &ptype_base[ntohs(type) & PTYPE_HASH_MASK];
3348         int err = -ENOENT;
3349
3350         if (NAPI_GRO_CB(skb)->count == 1) {
3351                 skb_shinfo(skb)->gso_size = 0;
3352                 goto out;
3353         }
3354
3355         rcu_read_lock();
3356         list_for_each_entry_rcu(ptype, head, list) {
3357                 if (ptype->type != type || ptype->dev || !ptype->gro_complete)
3358                         continue;
3359
3360                 err = ptype->gro_complete(skb);
3361                 break;
3362         }
3363         rcu_read_unlock();
3364
3365         if (err) {
3366                 WARN_ON(&ptype->list == head);
3367                 kfree_skb(skb);
3368                 return NET_RX_SUCCESS;
3369         }
3370
3371 out:
3372         return netif_receive_skb(skb);
3373 }
3374
3375 inline void napi_gro_flush(struct napi_struct *napi)
3376 {
3377         struct sk_buff *skb, *next;
3378
3379         for (skb = napi->gro_list; skb; skb = next) {
3380                 next = skb->next;
3381                 skb->next = NULL;
3382                 napi_gro_complete(skb);
3383         }
3384
3385         napi->gro_count = 0;
3386         napi->gro_list = NULL;
3387 }
3388 EXPORT_SYMBOL(napi_gro_flush);
3389
3390 enum gro_result dev_gro_receive(struct napi_struct *napi, struct sk_buff *skb)
3391 {
3392         struct sk_buff **pp = NULL;
3393         struct packet_type *ptype;
3394         __be16 type = skb->protocol;
3395         struct list_head *head = &ptype_base[ntohs(type) & PTYPE_HASH_MASK];
3396         int same_flow;
3397         int mac_len;
3398         enum gro_result ret;
3399
3400         if (!(skb->dev->features & NETIF_F_GRO) || netpoll_rx_on(skb))
3401                 goto normal;
3402
3403         if (skb_is_gso(skb) || skb_has_frag_list(skb))
3404                 goto normal;
3405
3406         rcu_read_lock();
3407         list_for_each_entry_rcu(ptype, head, list) {
3408                 if (ptype->type != type || ptype->dev || !ptype->gro_receive)
3409                         continue;
3410
3411                 skb_set_network_header(skb, skb_gro_offset(skb));
3412                 mac_len = skb->network_header - skb->mac_header;
3413                 skb->mac_len = mac_len;
3414                 NAPI_GRO_CB(skb)->same_flow = 0;
3415                 NAPI_GRO_CB(skb)->flush = 0;
3416                 NAPI_GRO_CB(skb)->free = 0;
3417
3418                 pp = ptype->gro_receive(&napi->gro_list, skb);
3419                 break;
3420         }
3421         rcu_read_unlock();
3422
3423         if (&ptype->list == head)
3424                 goto normal;
3425
3426         same_flow = NAPI_GRO_CB(skb)->same_flow;
3427         ret = NAPI_GRO_CB(skb)->free ? GRO_MERGED_FREE : GRO_MERGED;
3428
3429         if (pp) {
3430                 struct sk_buff *nskb = *pp;
3431
3432                 *pp = nskb->next;
3433                 nskb->next = NULL;
3434                 napi_gro_complete(nskb);
3435                 napi->gro_count--;
3436         }
3437
3438         if (same_flow)
3439                 goto ok;
3440
3441         if (NAPI_GRO_CB(skb)->flush || napi->gro_count >= MAX_GRO_SKBS)
3442                 goto normal;
3443
3444         napi->gro_count++;
3445         NAPI_GRO_CB(skb)->count = 1;
3446         skb_shinfo(skb)->gso_size = skb_gro_len(skb);
3447         skb->next = napi->gro_list;
3448         napi->gro_list = skb;
3449         ret = GRO_HELD;
3450
3451 pull:
3452         if (skb_headlen(skb) < skb_gro_offset(skb)) {
3453                 int grow = skb_gro_offset(skb) - skb_headlen(skb);
3454
3455                 BUG_ON(skb->end - skb->tail < grow);
3456
3457                 memcpy(skb_tail_pointer(skb), NAPI_GRO_CB(skb)->frag0, grow);
3458
3459                 skb->tail += grow;
3460                 skb->data_len -= grow;
3461
3462                 skb_shinfo(skb)->frags[0].page_offset += grow;
3463                 skb_frag_size_sub(&skb_shinfo(skb)->frags[0], grow);
3464
3465                 if (unlikely(!skb_frag_size(&skb_shinfo(skb)->frags[0]))) {
3466                         skb_frag_unref(skb, 0);
3467                         memmove(skb_shinfo(skb)->frags,
3468                                 skb_shinfo(skb)->frags + 1,
3469                                 --skb_shinfo(skb)->nr_frags * sizeof(skb_frag_t));
3470                 }
3471         }
3472
3473 ok:
3474         return ret;
3475
3476 normal:
3477         ret = GRO_NORMAL;
3478         goto pull;
3479 }
3480 EXPORT_SYMBOL(dev_gro_receive);
3481
3482 static inline gro_result_t
3483 __napi_gro_receive(struct napi_struct *napi, struct sk_buff *skb)
3484 {
3485         struct sk_buff *p;
3486         unsigned int maclen = skb->dev->hard_header_len;
3487
3488         for (p = napi->gro_list; p; p = p->next) {
3489                 unsigned long diffs;
3490
3491                 diffs = (unsigned long)p->dev ^ (unsigned long)skb->dev;
3492                 diffs |= p->vlan_tci ^ skb->vlan_tci;
3493                 if (maclen == ETH_HLEN)
3494                         diffs |= compare_ether_header(skb_mac_header(p),
3495                                                       skb_gro_mac_header(skb));
3496                 else if (!diffs)
3497                         diffs = memcmp(skb_mac_header(p),
3498                                        skb_gro_mac_header(skb),
3499                                        maclen);
3500                 NAPI_GRO_CB(p)->same_flow = !diffs;
3501                 NAPI_GRO_CB(p)->flush = 0;
3502         }
3503
3504         return dev_gro_receive(napi, skb);
3505 }
3506
3507 gro_result_t napi_skb_finish(gro_result_t ret, struct sk_buff *skb)
3508 {
3509         switch (ret) {
3510         case GRO_NORMAL:
3511                 if (netif_receive_skb(skb))
3512                         ret = GRO_DROP;
3513                 break;
3514
3515         case GRO_DROP:
3516         case GRO_MERGED_FREE:
3517                 kfree_skb(skb);
3518                 break;
3519
3520         case GRO_HELD:
3521         case GRO_MERGED:
3522                 break;
3523         }
3524
3525         return ret;
3526 }
3527 EXPORT_SYMBOL(napi_skb_finish);
3528
3529 void skb_gro_reset_offset(struct sk_buff *skb)
3530 {
3531         NAPI_GRO_CB(skb)->data_offset = 0;
3532         NAPI_GRO_CB(skb)->frag0 = NULL;
3533         NAPI_GRO_CB(skb)->frag0_len = 0;
3534
3535         if (skb->mac_header == skb->tail &&
3536             !PageHighMem(skb_frag_page(&skb_shinfo(skb)->frags[0]))) {
3537                 NAPI_GRO_CB(skb)->frag0 =
3538                         skb_frag_address(&skb_shinfo(skb)->frags[0]);
3539                 NAPI_GRO_CB(skb)->frag0_len = skb_frag_size(&skb_shinfo(skb)->frags[0]);
3540         }
3541 }
3542 EXPORT_SYMBOL(skb_gro_reset_offset);
3543
3544 gro_result_t napi_gro_receive(struct napi_struct *napi, struct sk_buff *skb)
3545 {
3546         skb_gro_reset_offset(skb);
3547
3548         return napi_skb_finish(__napi_gro_receive(napi, skb), skb);
3549 }
3550 EXPORT_SYMBOL(napi_gro_receive);
3551
3552 static void napi_reuse_skb(struct napi_struct *napi, struct sk_buff *skb)
3553 {
3554         __skb_pull(skb, skb_headlen(skb));
3555         /* restore the reserve we had after netdev_alloc_skb_ip_align() */
3556         skb_reserve(skb, NET_SKB_PAD + NET_IP_ALIGN - skb_headroom(skb));
3557         skb->vlan_tci = 0;
3558         skb->dev = napi->dev;
3559         skb->skb_iif = 0;
3560
3561         napi->skb = skb;
3562 }
3563
3564 struct sk_buff *napi_get_frags(struct napi_struct *napi)
3565 {
3566         struct sk_buff *skb = napi->skb;
3567
3568         if (!skb) {
3569                 skb = netdev_alloc_skb_ip_align(napi->dev, GRO_MAX_HEAD);
3570                 if (skb)
3571                         napi->skb = skb;
3572         }
3573         return skb;
3574 }
3575 EXPORT_SYMBOL(napi_get_frags);
3576
3577 gro_result_t napi_frags_finish(struct napi_struct *napi, struct sk_buff *skb,
3578                                gro_result_t ret)
3579 {
3580         switch (ret) {
3581         case GRO_NORMAL:
3582         case GRO_HELD:
3583                 skb->protocol = eth_type_trans(skb, skb->dev);
3584
3585                 if (ret == GRO_HELD)
3586                         skb_gro_pull(skb, -ETH_HLEN);
3587                 else if (netif_receive_skb(skb))
3588                         ret = GRO_DROP;
3589                 break;
3590
3591         case GRO_DROP:
3592         case GRO_MERGED_FREE:
3593                 napi_reuse_skb(napi, skb);
3594                 break;
3595
3596         case GRO_MERGED:
3597                 break;
3598         }
3599
3600         return ret;
3601 }
3602 EXPORT_SYMBOL(napi_frags_finish);
3603
3604 struct sk_buff *napi_frags_skb(struct napi_struct *napi)
3605 {
3606         struct sk_buff *skb = napi->skb;
3607         struct ethhdr *eth;
3608         unsigned int hlen;
3609         unsigned int off;
3610
3611         napi->skb = NULL;
3612
3613         skb_reset_mac_header(skb);
3614         skb_gro_reset_offset(skb);
3615
3616         off = skb_gro_offset(skb);
3617         hlen = off + sizeof(*eth);
3618         eth = skb_gro_header_fast(skb, off);
3619         if (skb_gro_header_hard(skb, hlen)) {
3620                 eth = skb_gro_header_slow(skb, hlen, off);
3621                 if (unlikely(!eth)) {
3622                         napi_reuse_skb(napi, skb);
3623                         skb = NULL;
3624                         goto out;
3625                 }
3626         }
3627
3628         skb_gro_pull(skb, sizeof(*eth));
3629
3630         /*
3631          * This works because the only protocols we care about don't require
3632          * special handling.  We'll fix it up properly at the end.
3633          */
3634         skb->protocol = eth->h_proto;
3635
3636 out:
3637         return skb;
3638 }
3639 EXPORT_SYMBOL(napi_frags_skb);
3640
3641 gro_result_t napi_gro_frags(struct napi_struct *napi)
3642 {
3643         struct sk_buff *skb = napi_frags_skb(napi);
3644
3645         if (!skb)
3646                 return GRO_DROP;
3647
3648         return napi_frags_finish(napi, skb, __napi_gro_receive(napi, skb));
3649 }
3650 EXPORT_SYMBOL(napi_gro_frags);
3651
3652 /*
3653  * net_rps_action sends any pending IPI's for rps.
3654  * Note: called with local irq disabled, but exits with local irq enabled.
3655  */
3656 static void net_rps_action_and_irq_enable(struct softnet_data *sd)
3657 {
3658 #ifdef CONFIG_RPS
3659         struct softnet_data *remsd = sd->rps_ipi_list;
3660
3661         if (remsd) {
3662                 sd->rps_ipi_list = NULL;
3663
3664                 local_irq_enable();
3665
3666                 /* Send pending IPI's to kick RPS processing on remote cpus. */
3667                 while (remsd) {
3668                         struct softnet_data *next = remsd->rps_ipi_next;
3669
3670                         if (cpu_online(remsd->cpu))
3671                                 __smp_call_function_single(remsd->cpu,
3672                                                            &remsd->csd, 0);
3673                         remsd = next;
3674                 }
3675         } else
3676 #endif
3677                 local_irq_enable();
3678 }
3679
3680 static int process_backlog(struct napi_struct *napi, int quota)
3681 {
3682         int work = 0;
3683         struct softnet_data *sd = container_of(napi, struct softnet_data, backlog);
3684
3685 #ifdef CONFIG_RPS
3686         /* Check if we have pending ipi, its better to send them now,
3687          * not waiting net_rx_action() end.
3688          */
3689         if (sd->rps_ipi_list) {
3690                 local_irq_disable();
3691                 net_rps_action_and_irq_enable(sd);
3692         }
3693 #endif
3694         napi->weight = weight_p;
3695         local_irq_disable();
3696         while (work < quota) {
3697                 struct sk_buff *skb;
3698                 unsigned int qlen;
3699
3700                 while ((skb = __skb_dequeue(&sd->process_queue))) {
3701                         local_irq_enable();
3702                         __netif_receive_skb(skb);
3703                         local_irq_disable();
3704                         input_queue_head_incr(sd);
3705                         if (++work >= quota) {
3706                                 local_irq_enable();
3707                                 return work;
3708                         }
3709                 }
3710
3711                 rps_lock(sd);
3712                 qlen = skb_queue_len(&sd->input_pkt_queue);
3713                 if (qlen)
3714                         skb_queue_splice_tail_init(&sd->input_pkt_queue,
3715                                                    &sd->process_queue);
3716
3717                 if (qlen < quota - work) {
3718                         /*
3719                          * Inline a custom version of __napi_complete().
3720                          * only current cpu owns and manipulates this napi,
3721                          * and NAPI_STATE_SCHED is the only possible flag set on backlog.
3722                          * we can use a plain write instead of clear_bit(),
3723                          * and we dont need an smp_mb() memory barrier.
3724                          */
3725                         list_del(&napi->poll_list);
3726                         napi->state = 0;
3727
3728                         quota = work + qlen;
3729                 }
3730                 rps_unlock(sd);
3731         }
3732         local_irq_enable();
3733
3734         return work;
3735 }
3736
3737 /**
3738  * __napi_schedule - schedule for receive
3739  * @n: entry to schedule
3740  *
3741  * The entry's receive function will be scheduled to run
3742  */
3743 void __napi_schedule(struct napi_struct *n)
3744 {
3745         unsigned long flags;
3746
3747         local_irq_save(flags);
3748         ____napi_schedule(&__get_cpu_var(softnet_data), n);
3749         local_irq_restore(flags);
3750 }
3751 EXPORT_SYMBOL(__napi_schedule);
3752
3753 void __napi_complete(struct napi_struct *n)
3754 {
3755         BUG_ON(!test_bit(NAPI_STATE_SCHED, &n->state));
3756         BUG_ON(n->gro_list);
3757
3758         list_del(&n->poll_list);
3759         smp_mb__before_clear_bit();
3760         clear_bit(NAPI_STATE_SCHED, &n->state);
3761 }
3762 EXPORT_SYMBOL(__napi_complete);
3763
3764 void napi_complete(struct napi_struct *n)
3765 {
3766         unsigned long flags;
3767
3768         /*
3769          * don't let napi dequeue from the cpu poll list
3770          * just in case its running on a different cpu
3771          */
3772         if (unlikely(test_bit(NAPI_STATE_NPSVC, &n->state)))
3773                 return;
3774
3775         napi_gro_flush(n);
3776         local_irq_save(flags);
3777         __napi_complete(n);
3778         local_irq_restore(flags);
3779 }
3780 EXPORT_SYMBOL(napi_complete);
3781
3782 void netif_napi_add(struct net_device *dev, struct napi_struct *napi,
3783                     int (*poll)(struct napi_struct *, int), int weight)
3784 {
3785         INIT_LIST_HEAD(&napi->poll_list);
3786         napi->gro_count = 0;
3787         napi->gro_list = NULL;
3788         napi->skb = NULL;
3789         napi->poll = poll;
3790         napi->weight = weight;
3791         list_add(&napi->dev_list, &dev->napi_list);
3792         napi->dev = dev;
3793 #ifdef CONFIG_NETPOLL
3794         spin_lock_init(&napi->poll_lock);
3795         napi->poll_owner = -1;
3796 #endif
3797         set_bit(NAPI_STATE_SCHED, &napi->state);
3798 }
3799 EXPORT_SYMBOL(netif_napi_add);
3800
3801 void netif_napi_del(struct napi_struct *napi)
3802 {
3803         struct sk_buff *skb, *next;
3804
3805         list_del_init(&napi->dev_list);
3806         napi_free_frags(napi);
3807
3808         for (skb = napi->gro_list; skb; skb = next) {
3809                 next = skb->next;
3810                 skb->next = NULL;
3811                 kfree_skb(skb);
3812         }
3813
3814         napi->gro_list = NULL;
3815         napi->gro_count = 0;
3816 }
3817 EXPORT_SYMBOL(netif_napi_del);
3818
3819 static void net_rx_action(struct softirq_action *h)
3820 {
3821         struct softnet_data *sd = &__get_cpu_var(softnet_data);
3822         unsigned long time_limit = jiffies + 2;
3823         int budget = netdev_budget;
3824         void *have;
3825
3826         local_irq_disable();
3827
3828         while (!list_empty(&sd->poll_list)) {
3829                 struct napi_struct *n;
3830                 int work, weight;
3831
3832                 /* If softirq window is exhuasted then punt.
3833                  * Allow this to run for 2 jiffies since which will allow
3834                  * an average latency of 1.5/HZ.
3835                  */
3836                 if (unlikely(budget <= 0 || time_after(jiffies, time_limit)))
3837                         goto softnet_break;
3838
3839                 local_irq_enable();
3840
3841                 /* Even though interrupts have been re-enabled, this
3842                  * access is safe because interrupts can only add new
3843                  * entries to the tail of this list, and only ->poll()
3844                  * calls can remove this head entry from the list.
3845                  */
3846                 n = list_first_entry(&sd->poll_list, struct napi_struct, poll_list);
3847
3848                 have = netpoll_poll_lock(n);
3849
3850                 weight = n->weight;
3851
3852                 /* This NAPI_STATE_SCHED test is for avoiding a race
3853                  * with netpoll's poll_napi().  Only the entity which
3854                  * obtains the lock and sees NAPI_STATE_SCHED set will
3855                  * actually make the ->poll() call.  Therefore we avoid
3856                  * accidentally calling ->poll() when NAPI is not scheduled.
3857                  */
3858                 work = 0;
3859                 if (test_bit(NAPI_STATE_SCHED, &n->state)) {
3860                         work = n->poll(n, weight);
3861                         trace_napi_poll(n);
3862                 }
3863
3864                 WARN_ON_ONCE(work > weight);
3865
3866                 budget -= work;
3867
3868                 local_irq_disable();
3869
3870                 /* Drivers must not modify the NAPI state if they
3871                  * consume the entire weight.  In such cases this code
3872                  * still "owns" the NAPI instance and therefore can
3873                  * move the instance around on the list at-will.
3874                  */
3875                 if (unlikely(work == weight)) {
3876                         if (unlikely(napi_disable_pending(n))) {
3877                                 local_irq_enable();
3878                                 napi_complete(n);
3879                                 local_irq_disable();
3880                         } else
3881                                 list_move_tail(&n->poll_list, &sd->poll_list);
3882                 }
3883
3884                 netpoll_poll_unlock(have);
3885         }
3886 out:
3887         net_rps_action_and_irq_enable(sd);
3888
3889 #ifdef CONFIG_NET_DMA
3890         /*
3891          * There may not be any more sk_buffs coming right now, so push
3892          * any pending DMA copies to hardware
3893          */
3894         dma_issue_pending_all();
3895 #endif
3896
3897         return;
3898
3899 softnet_break:
3900         sd->time_squeeze++;
3901         __raise_softirq_irqoff(NET_RX_SOFTIRQ);
3902         goto out;
3903 }
3904
3905 static gifconf_func_t *gifconf_list[NPROTO];
3906
3907 /**
3908  *      register_gifconf        -       register a SIOCGIF handler
3909  *      @family: Address family
3910  *      @gifconf: Function handler
3911  *
3912  *      Register protocol dependent address dumping routines. The handler
3913  *      that is passed must not be freed or reused until it has been replaced
3914  *      by another handler.
3915  */
3916 int register_gifconf(unsigned int family, gifconf_func_t *gifconf)
3917 {
3918         if (family >= NPROTO)
3919                 return -EINVAL;
3920         gifconf_list[family] = gifconf;
3921         return 0;
3922 }
3923 EXPORT_SYMBOL(register_gifconf);
3924
3925
3926 /*
3927  *      Map an interface index to its name (SIOCGIFNAME)
3928  */
3929
3930 /*
3931  *      We need this ioctl for efficient implementation of the
3932  *      if_indextoname() function required by the IPv6 API.  Without
3933  *      it, we would have to search all the interfaces to find a
3934  *      match.  --pb
3935  */
3936
3937 static int dev_ifname(struct net *net, struct ifreq __user *arg)
3938 {
3939         struct net_device *dev;
3940         struct ifreq ifr;
3941
3942         /*
3943          *      Fetch the caller's info block.
3944          */
3945
3946         if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
3947                 return -EFAULT;
3948
3949         rcu_read_lock();
3950         dev = dev_get_by_index_rcu(net, ifr.ifr_ifindex);
3951         if (!dev) {
3952                 rcu_read_unlock();
3953                 return -ENODEV;
3954         }
3955
3956         strcpy(ifr.ifr_name, dev->name);
3957         rcu_read_unlock();
3958
3959         if (copy_to_user(arg, &ifr, sizeof(struct ifreq)))
3960                 return -EFAULT;
3961         return 0;
3962 }
3963
3964 /*
3965  *      Perform a SIOCGIFCONF call. This structure will change
3966  *      size eventually, and there is nothing I can do about it.
3967  *      Thus we will need a 'compatibility mode'.
3968  */
3969
3970 static int dev_ifconf(struct net *net, char __user *arg)
3971 {
3972         struct ifconf ifc;
3973         struct net_device *dev;
3974         char __user *pos;
3975         int len;
3976         int total;
3977         int i;
3978
3979         /*
3980          *      Fetch the caller's info block.
3981          */
3982
3983         if (copy_from_user(&ifc, arg, sizeof(struct ifconf)))
3984                 return -EFAULT;
3985
3986         pos = ifc.ifc_buf;
3987         len = ifc.ifc_len;
3988
3989         /*
3990          *      Loop over the interfaces, and write an info block for each.
3991          */
3992
3993         total = 0;
3994         for_each_netdev(net, dev) {
3995                 for (i = 0; i < NPROTO; i++) {
3996                         if (gifconf_list[i]) {
3997                                 int done;
3998                                 if (!pos)
3999                                         done = gifconf_list[i](dev, NULL, 0);
4000                                 else
4001                                         done = gifconf_list[i](dev, pos + total,
4002                                                                len - total);
4003                                 if (done < 0)
4004                                         return -EFAULT;
4005                                 total += done;
4006                         }
4007                 }
4008         }
4009
4010         /*
4011          *      All done.  Write the updated control block back to the caller.
4012          */
4013         ifc.ifc_len = total;
4014
4015         /*
4016          *      Both BSD and Solaris return 0 here, so we do too.
4017          */
4018         return copy_to_user(arg, &ifc, sizeof(struct ifconf)) ? -EFAULT : 0;
4019 }
4020
4021 #ifdef CONFIG_PROC_FS
4022
4023 #define BUCKET_SPACE (32 - NETDEV_HASHBITS - 1)
4024
4025 #define get_bucket(x) ((x) >> BUCKET_SPACE)
4026 #define get_offset(x) ((x) & ((1 << BUCKET_SPACE) - 1))
4027 #define set_bucket_offset(b, o) ((b) << BUCKET_SPACE | (o))
4028
4029 static inline struct net_device *dev_from_same_bucket(struct seq_file *seq, loff_t *pos)
4030 {
4031         struct net *net = seq_file_net(seq);
4032         struct net_device *dev;
4033         struct hlist_node *p;
4034         struct hlist_head *h;
4035         unsigned int count = 0, offset = get_offset(*pos);
4036
4037         h = &net->dev_name_head[get_bucket(*pos)];
4038         hlist_for_each_entry_rcu(dev, p, h, name_hlist) {
4039                 if (++count == offset)
4040                         return dev;
4041         }
4042
4043         return NULL;
4044 }
4045
4046 static inline struct net_device *dev_from_bucket(struct seq_file *seq, loff_t *pos)
4047 {
4048         struct net_device *dev;
4049         unsigned int bucket;
4050
4051         do {
4052                 dev = dev_from_same_bucket(seq, pos);
4053                 if (dev)
4054                         return dev;
4055
4056                 bucket = get_bucket(*pos) + 1;
4057                 *pos = set_bucket_offset(bucket, 1);
4058         } while (bucket < NETDEV_HASHENTRIES);
4059
4060         return NULL;
4061 }
4062
4063 /*
4064  *      This is invoked by the /proc filesystem handler to display a device
4065  *      in detail.
4066  */
4067 void *dev_seq_start(struct seq_file *seq, loff_t *pos)
4068         __acquires(RCU)
4069 {
4070         rcu_read_lock();
4071         if (!*pos)
4072                 return SEQ_START_TOKEN;
4073
4074         if (get_bucket(*pos) >= NETDEV_HASHENTRIES)
4075                 return NULL;
4076
4077         return dev_from_bucket(seq, pos);
4078 }
4079
4080 void *dev_seq_next(struct seq_file *seq, void *v, loff_t *pos)
4081 {
4082         ++*pos;
4083         return dev_from_bucket(seq, pos);
4084 }
4085
4086 void dev_seq_stop(struct seq_file *seq, void *v)
4087         __releases(RCU)
4088 {
4089         rcu_read_unlock();
4090 }
4091
4092 static void dev_seq_printf_stats(struct seq_file *seq, struct net_device *dev)
4093 {
4094         struct rtnl_link_stats64 temp;
4095         const struct rtnl_link_stats64 *stats = dev_get_stats(dev, &temp);
4096
4097         seq_printf(seq, "%6s: %7llu %7llu %4llu %4llu %4llu %5llu %10llu %9llu "
4098                    "%8llu %7llu %4llu %4llu %4llu %5llu %7llu %10llu\n",
4099                    dev->name, stats->rx_bytes, stats->rx_packets,
4100                    stats->rx_errors,
4101                    stats->rx_dropped + stats->rx_missed_errors,
4102                    stats->rx_fifo_errors,
4103                    stats->rx_length_errors + stats->rx_over_errors +
4104                     stats->rx_crc_errors + stats->rx_frame_errors,
4105                    stats->rx_compressed, stats->multicast,
4106                    stats->tx_bytes, stats->tx_packets,
4107                    stats->tx_errors, stats->tx_dropped,
4108                    stats->tx_fifo_errors, stats->collisions,
4109                    stats->tx_carrier_errors +
4110                     stats->tx_aborted_errors +
4111                     stats->tx_window_errors +
4112                     stats->tx_heartbeat_errors,
4113                    stats->tx_compressed);
4114 }
4115
4116 /*
4117  *      Called from the PROCfs module. This now uses the new arbitrary sized
4118  *      /proc/net interface to create /proc/net/dev
4119  */
4120 static int dev_seq_show(struct seq_file *seq, void *v)
4121 {
4122         if (v == SEQ_START_TOKEN)
4123                 seq_puts(seq, "Inter-|   Receive                            "
4124                               "                    |  Transmit\n"
4125                               " face |bytes    packets errs drop fifo frame "
4126                               "compressed multicast|bytes    packets errs "
4127                               "drop fifo colls carrier compressed\n");
4128         else
4129                 dev_seq_printf_stats(seq, v);
4130         return 0;
4131 }
4132
4133 static struct softnet_data *softnet_get_online(loff_t *pos)
4134 {
4135         struct softnet_data *sd = NULL;
4136
4137         while (*pos < nr_cpu_ids)
4138                 if (cpu_online(*pos)) {
4139                         sd = &per_cpu(softnet_data, *pos);
4140                         break;
4141                 } else
4142                         ++*pos;
4143         return sd;
4144 }
4145
4146 static void *softnet_seq_start(struct seq_file *seq, loff_t *pos)
4147 {
4148         return softnet_get_online(pos);
4149 }
4150
4151 static void *softnet_seq_next(struct seq_file *seq, void *v, loff_t *pos)
4152 {
4153         ++*pos;
4154         return softnet_get_online(pos);
4155 }
4156
4157 static void softnet_seq_stop(struct seq_file *seq, void *v)
4158 {
4159 }
4160
4161 static int softnet_seq_show(struct seq_file *seq, void *v)
4162 {
4163         struct softnet_data *sd = v;
4164
4165         seq_printf(seq, "%08x %08x %08x %08x %08x %08x %08x %08x %08x %08x\n",
4166                    sd->processed, sd->dropped, sd->time_squeeze, 0,
4167                    0, 0, 0, 0, /* was fastroute */
4168                    sd->cpu_collision, sd->received_rps);
4169         return 0;
4170 }
4171
4172 static const struct seq_operations dev_seq_ops = {
4173         .start = dev_seq_start,
4174         .next  = dev_seq_next,
4175         .stop  = dev_seq_stop,
4176         .show  = dev_seq_show,
4177 };
4178
4179 static int dev_seq_open(struct inode *inode, struct file *file)
4180 {
4181         return seq_open_net(inode, file, &dev_seq_ops,
4182                             sizeof(struct seq_net_private));
4183 }
4184
4185 static const struct file_operations dev_seq_fops = {
4186         .owner   = THIS_MODULE,
4187         .open    = dev_seq_open,
4188         .read    = seq_read,
4189         .llseek  = seq_lseek,
4190         .release = seq_release_net,
4191 };
4192
4193 static const struct seq_operations softnet_seq_ops = {
4194         .start = softnet_seq_start,
4195         .next  = softnet_seq_next,
4196         .stop  = softnet_seq_stop,
4197         .show  = softnet_seq_show,
4198 };
4199
4200 static int softnet_seq_open(struct inode *inode, struct file *file)
4201 {
4202         return seq_open(file, &softnet_seq_ops);
4203 }
4204
4205 static const struct file_operations softnet_seq_fops = {
4206         .owner   = THIS_MODULE,
4207         .open    = softnet_seq_open,
4208         .read    = seq_read,
4209         .llseek  = seq_lseek,
4210         .release = seq_release,
4211 };
4212
4213 static void *ptype_get_idx(loff_t pos)
4214 {
4215         struct packet_type *pt = NULL;
4216         loff_t i = 0;
4217         int t;
4218
4219         list_for_each_entry_rcu(pt, &ptype_all, list) {
4220                 if (i == pos)
4221                         return pt;
4222                 ++i;
4223         }
4224
4225         for (t = 0; t < PTYPE_HASH_SIZE; t++) {
4226                 list_for_each_entry_rcu(pt, &ptype_base[t], list) {
4227                         if (i == pos)
4228                                 return pt;
4229                         ++i;
4230                 }
4231         }
4232         return NULL;
4233 }
4234
4235 static void *ptype_seq_start(struct seq_file *seq, loff_t *pos)
4236         __acquires(RCU)
4237 {
4238         rcu_read_lock();
4239         return *pos ? ptype_get_idx(*pos - 1) : SEQ_START_TOKEN;
4240 }
4241
4242 static void *ptype_seq_next(struct seq_file *seq, void *v, loff_t *pos)
4243 {
4244         struct packet_type *pt;
4245         struct list_head *nxt;
4246         int hash;
4247
4248         ++*pos;
4249         if (v == SEQ_START_TOKEN)
4250                 return ptype_get_idx(0);
4251
4252         pt = v;
4253         nxt = pt->list.next;
4254         if (pt->type == htons(ETH_P_ALL)) {
4255                 if (nxt != &ptype_all)
4256                         goto found;
4257                 hash = 0;
4258                 nxt = ptype_base[0].next;
4259         } else
4260                 hash = ntohs(pt->type) & PTYPE_HASH_MASK;
4261
4262         while (nxt == &ptype_base[hash]) {
4263                 if (++hash >= PTYPE_HASH_SIZE)
4264                         return NULL;
4265                 nxt = ptype_base[hash].next;
4266         }
4267 found:
4268         return list_entry(nxt, struct packet_type, list);
4269 }
4270
4271 static void ptype_seq_stop(struct seq_file *seq, void *v)
4272         __releases(RCU)
4273 {
4274         rcu_read_unlock();
4275 }
4276
4277 static int ptype_seq_show(struct seq_file *seq, void *v)
4278 {
4279         struct packet_type *pt = v;
4280
4281         if (v == SEQ_START_TOKEN)
4282                 seq_puts(seq, "Type Device      Function\n");
4283         else if (pt->dev == NULL || dev_net(pt->dev) == seq_file_net(seq)) {
4284                 if (pt->type == htons(ETH_P_ALL))
4285                         seq_puts(seq, "ALL ");
4286                 else
4287                         seq_printf(seq, "%04x", ntohs(pt->type));
4288
4289                 seq_printf(seq, " %-8s %pF\n",
4290                            pt->dev ? pt->dev->name : "", pt->func);
4291         }
4292
4293         return 0;
4294 }
4295
4296 static const struct seq_operations ptype_seq_ops = {
4297         .start = ptype_seq_start,
4298         .next  = ptype_seq_next,
4299         .stop  = ptype_seq_stop,
4300         .show  = ptype_seq_show,
4301 };
4302
4303 static int ptype_seq_open(struct inode *inode, struct file *file)
4304 {
4305         return seq_open_net(inode, file, &ptype_seq_ops,
4306                         sizeof(struct seq_net_private));
4307 }
4308
4309 static const struct file_operations ptype_seq_fops = {
4310         .owner   = THIS_MODULE,
4311         .open    = ptype_seq_open,
4312         .read    = seq_read,
4313         .llseek  = seq_lseek,
4314         .release = seq_release_net,
4315 };
4316
4317
4318 static int __net_init dev_proc_net_init(struct net *net)
4319 {
4320         int rc = -ENOMEM;
4321
4322         if (!proc_net_fops_create(net, "dev", S_IRUGO, &dev_seq_fops))
4323                 goto out;
4324         if (!proc_net_fops_create(net, "softnet_stat", S_IRUGO, &softnet_seq_fops))
4325                 goto out_dev;
4326         if (!proc_net_fops_create(net, "ptype", S_IRUGO, &ptype_seq_fops))
4327                 goto out_softnet;
4328
4329         if (wext_proc_init(net))
4330                 goto out_ptype;
4331         rc = 0;
4332 out:
4333         return rc;
4334 out_ptype:
4335         proc_net_remove(net, "ptype");
4336 out_softnet:
4337         proc_net_remove(net, "softnet_stat");
4338 out_dev:
4339         proc_net_remove(net, "dev");
4340         goto out;
4341 }
4342
4343 static void __net_exit dev_proc_net_exit(struct net *net)
4344 {
4345         wext_proc_exit(net);
4346
4347         proc_net_remove(net, "ptype");
4348         proc_net_remove(net, "softnet_stat");
4349         proc_net_remove(net, "dev");
4350 }
4351
4352 static struct pernet_operations __net_initdata dev_proc_ops = {
4353         .init = dev_proc_net_init,
4354         .exit = dev_proc_net_exit,
4355 };
4356
4357 static int __init dev_proc_init(void)
4358 {
4359         return register_pernet_subsys(&dev_proc_ops);
4360 }
4361 #else
4362 #define dev_proc_init() 0
4363 #endif  /* CONFIG_PROC_FS */
4364
4365
4366 /**
4367  *      netdev_set_master       -       set up master pointer
4368  *      @slave: slave device
4369  *      @master: new master device
4370  *
4371  *      Changes the master device of the slave. Pass %NULL to break the
4372  *      bonding. The caller must hold the RTNL semaphore. On a failure
4373  *      a negative errno code is returned. On success the reference counts
4374  *      are adjusted and the function returns zero.
4375  */
4376 int netdev_set_master(struct net_device *slave, struct net_device *master)
4377 {
4378         struct net_device *old = slave->master;
4379
4380         ASSERT_RTNL();
4381
4382         if (master) {
4383                 if (old)
4384                         return -EBUSY;
4385                 dev_hold(master);
4386         }
4387
4388         slave->master = master;
4389
4390         if (old)
4391                 dev_put(old);
4392         return 0;
4393 }
4394 EXPORT_SYMBOL(netdev_set_master);
4395
4396 /**
4397  *      netdev_set_bond_master  -       set up bonding master/slave pair
4398  *      @slave: slave device
4399  *      @master: new master device
4400  *
4401  *      Changes the master device of the slave. Pass %NULL to break the
4402  *      bonding. The caller must hold the RTNL semaphore. On a failure
4403  *      a negative errno code is returned. On success %RTM_NEWLINK is sent
4404  *      to the routing socket and the function returns zero.
4405  */
4406 int netdev_set_bond_master(struct net_device *slave, struct net_device *master)
4407 {
4408         int err;
4409
4410         ASSERT_RTNL();
4411
4412         err = netdev_set_master(slave, master);
4413         if (err)
4414                 return err;
4415         if (master)
4416                 slave->flags |= IFF_SLAVE;
4417         else
4418                 slave->flags &= ~IFF_SLAVE;
4419
4420         rtmsg_ifinfo(RTM_NEWLINK, slave, IFF_SLAVE);
4421         return 0;
4422 }
4423 EXPORT_SYMBOL(netdev_set_bond_master);
4424
4425 static void dev_change_rx_flags(struct net_device *dev, int flags)
4426 {
4427         const struct net_device_ops *ops = dev->netdev_ops;
4428
4429         if ((dev->flags & IFF_UP) && ops->ndo_change_rx_flags)
4430                 ops->ndo_change_rx_flags(dev, flags);
4431 }
4432
4433 static int __dev_set_promiscuity(struct net_device *dev, int inc)
4434 {
4435         unsigned int old_flags = dev->flags;
4436         uid_t uid;
4437         gid_t gid;
4438
4439         ASSERT_RTNL();
4440
4441         dev->flags |= IFF_PROMISC;
4442         dev->promiscuity += inc;
4443         if (dev->promiscuity == 0) {
4444                 /*
4445                  * Avoid overflow.
4446                  * If inc causes overflow, untouch promisc and return error.
4447                  */
4448                 if (inc < 0)
4449                         dev->flags &= ~IFF_PROMISC;
4450                 else {
4451                         dev->promiscuity -= inc;
4452                         pr_warn("%s: promiscuity touches roof, set promiscuity failed. promiscuity feature of device might be broken.\n",
4453                                 dev->name);
4454                         return -EOVERFLOW;
4455                 }
4456         }
4457         if (dev->flags != old_flags) {
4458                 pr_info("device %s %s promiscuous mode\n",
4459                         dev->name,
4460                         dev->flags & IFF_PROMISC ? "entered" : "left");
4461                 if (audit_enabled) {
4462                         current_uid_gid(&uid, &gid);
4463                         audit_log(current->audit_context, GFP_ATOMIC,
4464                                 AUDIT_ANOM_PROMISCUOUS,
4465                                 "dev=%s prom=%d old_prom=%d auid=%u uid=%u gid=%u ses=%u",
4466                                 dev->name, (dev->flags & IFF_PROMISC),
4467                                 (old_flags & IFF_PROMISC),
4468                                 audit_get_loginuid(current),
4469                                 uid, gid,
4470                                 audit_get_sessionid(current));
4471                 }
4472
4473                 dev_change_rx_flags(dev, IFF_PROMISC);
4474         }
4475         return 0;
4476 }
4477
4478 /**
4479  *      dev_set_promiscuity     - update promiscuity count on a device
4480  *      @dev: device
4481  *      @inc: modifier
4482  *
4483  *      Add or remove promiscuity from a device. While the count in the device
4484  *      remains above zero the interface remains promiscuous. Once it hits zero
4485  *      the device reverts back to normal filtering operation. A negative inc
4486  *      value is used to drop promiscuity on the device.
4487  *      Return 0 if successful or a negative errno code on error.
4488  */
4489 int dev_set_promiscuity(struct net_device *dev, int inc)
4490 {
4491         unsigned int old_flags = dev->flags;
4492         int err;
4493
4494         err = __dev_set_promiscuity(dev, inc);
4495         if (err < 0)
4496                 return err;
4497         if (dev->flags != old_flags)
4498                 dev_set_rx_mode(dev);
4499         return err;
4500 }
4501 EXPORT_SYMBOL(dev_set_promiscuity);
4502
4503 /**
4504  *      dev_set_allmulti        - update allmulti count on a device
4505  *      @dev: device
4506  *      @inc: modifier
4507  *
4508  *      Add or remove reception of all multicast frames to a device. While the
4509  *      count in the device remains above zero the interface remains listening
4510  *      to all interfaces. Once it hits zero the device reverts back to normal
4511  *      filtering operation. A negative @inc value is used to drop the counter
4512  *      when releasing a resource needing all multicasts.
4513  *      Return 0 if successful or a negative errno code on error.
4514  */
4515
4516 int dev_set_allmulti(struct net_device *dev, int inc)
4517 {
4518         unsigned int old_flags = dev->flags;
4519
4520         ASSERT_RTNL();
4521
4522         dev->flags |= IFF_ALLMULTI;
4523         dev->allmulti += inc;
4524         if (dev->allmulti == 0) {
4525                 /*
4526                  * Avoid overflow.
4527                  * If inc causes overflow, untouch allmulti and return error.
4528                  */
4529                 if (inc < 0)
4530                         dev->flags &= ~IFF_ALLMULTI;
4531                 else {
4532                         dev->allmulti -= inc;
4533                         pr_warn("%s: allmulti touches roof, set allmulti failed. allmulti feature of device might be broken.\n",
4534                                 dev->name);
4535                         return -EOVERFLOW;
4536                 }
4537         }
4538         if (dev->flags ^ old_flags) {
4539                 dev_change_rx_flags(dev, IFF_ALLMULTI);
4540                 dev_set_rx_mode(dev);
4541         }
4542         return 0;
4543 }
4544 EXPORT_SYMBOL(dev_set_allmulti);
4545
4546 /*
4547  *      Upload unicast and multicast address lists to device and
4548  *      configure RX filtering. When the device doesn't support unicast
4549  *      filtering it is put in promiscuous mode while unicast addresses
4550  *      are present.
4551  */
4552 void __dev_set_rx_mode(struct net_device *dev)
4553 {
4554         const struct net_device_ops *ops = dev->netdev_ops;
4555
4556         /* dev_open will call this function so the list will stay sane. */
4557         if (!(dev->flags&IFF_UP))
4558                 return;
4559
4560         if (!netif_device_present(dev))
4561                 return;
4562
4563         if (!(dev->priv_flags & IFF_UNICAST_FLT)) {
4564                 /* Unicast addresses changes may only happen under the rtnl,
4565                  * therefore calling __dev_set_promiscuity here is safe.
4566                  */
4567                 if (!netdev_uc_empty(dev) && !dev->uc_promisc) {
4568                         __dev_set_promiscuity(dev, 1);
4569                         dev->uc_promisc = true;
4570                 } else if (netdev_uc_empty(dev) && dev->uc_promisc) {
4571                         __dev_set_promiscuity(dev, -1);
4572                         dev->uc_promisc = false;
4573                 }
4574         }
4575
4576         if (ops->ndo_set_rx_mode)
4577                 ops->ndo_set_rx_mode(dev);
4578 }
4579
4580 void dev_set_rx_mode(struct net_device *dev)
4581 {
4582         netif_addr_lock_bh(dev);
4583         __dev_set_rx_mode(dev);
4584         netif_addr_unlock_bh(dev);
4585 }
4586
4587 /**
4588  *      dev_get_flags - get flags reported to userspace
4589  *      @dev: device
4590  *
4591  *      Get the combination of flag bits exported through APIs to userspace.
4592  */
4593 unsigned dev_get_flags(const struct net_device *dev)
4594 {
4595         unsigned flags;
4596
4597         flags = (dev->flags & ~(IFF_PROMISC |
4598                                 IFF_ALLMULTI |
4599                                 IFF_RUNNING |
4600                                 IFF_LOWER_UP |
4601                                 IFF_DORMANT)) |
4602                 (dev->gflags & (IFF_PROMISC |
4603                                 IFF_ALLMULTI));
4604
4605         if (netif_running(dev)) {
4606                 if (netif_oper_up(dev))
4607                         flags |= IFF_RUNNING;
4608                 if (netif_carrier_ok(dev))
4609                         flags |= IFF_LOWER_UP;
4610                 if (netif_dormant(dev))
4611                         flags |= IFF_DORMANT;
4612         }
4613
4614         return flags;
4615 }
4616 EXPORT_SYMBOL(dev_get_flags);
4617
4618 int __dev_change_flags(struct net_device *dev, unsigned int flags)
4619 {
4620         unsigned int old_flags = dev->flags;
4621         int ret;
4622
4623         ASSERT_RTNL();
4624
4625         /*
4626          *      Set the flags on our device.
4627          */
4628
4629         dev->flags = (flags & (IFF_DEBUG | IFF_NOTRAILERS | IFF_NOARP |
4630                                IFF_DYNAMIC | IFF_MULTICAST | IFF_PORTSEL |
4631                                IFF_AUTOMEDIA)) |
4632                      (dev->flags & (IFF_UP | IFF_VOLATILE | IFF_PROMISC |
4633                                     IFF_ALLMULTI));
4634
4635         /*
4636          *      Load in the correct multicast list now the flags have changed.
4637          */
4638
4639         if ((old_flags ^ flags) & IFF_MULTICAST)
4640                 dev_change_rx_flags(dev, IFF_MULTICAST);
4641
4642         dev_set_rx_mode(dev);
4643
4644         /*
4645          *      Have we downed the interface. We handle IFF_UP ourselves
4646          *      according to user attempts to set it, rather than blindly
4647          *      setting it.
4648          */
4649
4650         ret = 0;
4651         if ((old_flags ^ flags) & IFF_UP) {     /* Bit is different  ? */
4652                 ret = ((old_flags & IFF_UP) ? __dev_close : __dev_open)(dev);
4653
4654                 if (!ret)
4655                         dev_set_rx_mode(dev);
4656         }
4657
4658         if ((flags ^ dev->gflags) & IFF_PROMISC) {
4659                 int inc = (flags & IFF_PROMISC) ? 1 : -1;
4660
4661                 dev->gflags ^= IFF_PROMISC;
4662                 dev_set_promiscuity(dev, inc);
4663         }
4664
4665         /* NOTE: order of synchronization of IFF_PROMISC and IFF_ALLMULTI
4666            is important. Some (broken) drivers set IFF_PROMISC, when
4667            IFF_ALLMULTI is requested not asking us and not reporting.
4668          */
4669         if ((flags ^ dev->gflags) & IFF_ALLMULTI) {
4670                 int inc = (flags & IFF_ALLMULTI) ? 1 : -1;
4671
4672                 dev->gflags ^= IFF_ALLMULTI;
4673                 dev_set_allmulti(dev, inc);
4674         }
4675
4676         return ret;
4677 }
4678
4679 void __dev_notify_flags(struct net_device *dev, unsigned int old_flags)
4680 {
4681         unsigned int changes = dev->flags ^ old_flags;
4682
4683         if (changes & IFF_UP) {
4684                 if (dev->flags & IFF_UP)
4685                         call_netdevice_notifiers(NETDEV_UP, dev);
4686                 else
4687                         call_netdevice_notifiers(NETDEV_DOWN, dev);
4688         }
4689
4690         if (dev->flags & IFF_UP &&
4691             (changes & ~(IFF_UP | IFF_PROMISC | IFF_ALLMULTI | IFF_VOLATILE)))
4692                 call_netdevice_notifiers(NETDEV_CHANGE, dev);
4693 }
4694
4695 /**
4696  *      dev_change_flags - change device settings
4697  *      @dev: device
4698  *      @flags: device state flags
4699  *
4700  *      Change settings on device based state flags. The flags are
4701  *      in the userspace exported format.
4702  */
4703 int dev_change_flags(struct net_device *dev, unsigned int flags)
4704 {
4705         int ret;
4706         unsigned int changes, old_flags = dev->flags;
4707
4708         ret = __dev_change_flags(dev, flags);
4709         if (ret < 0)
4710                 return ret;
4711
4712         changes = old_flags ^ dev->flags;
4713         if (changes)
4714                 rtmsg_ifinfo(RTM_NEWLINK, dev, changes);
4715
4716         __dev_notify_flags(dev, old_flags);
4717         return ret;
4718 }
4719 EXPORT_SYMBOL(dev_change_flags);
4720
4721 /**
4722  *      dev_set_mtu - Change maximum transfer unit
4723  *      @dev: device
4724  *      @new_mtu: new transfer unit
4725  *
4726  *      Change the maximum transfer size of the network device.
4727  */
4728 int dev_set_mtu(struct net_device *dev, int new_mtu)
4729 {
4730         const struct net_device_ops *ops = dev->netdev_ops;
4731         int err;
4732
4733         if (new_mtu == dev->mtu)
4734                 return 0;
4735
4736         /*      MTU must be positive.    */
4737         if (new_mtu < 0)
4738                 return -EINVAL;
4739
4740         if (!netif_device_present(dev))
4741                 return -ENODEV;
4742
4743         err = 0;
4744         if (ops->ndo_change_mtu)
4745                 err = ops->ndo_change_mtu(dev, new_mtu);
4746         else
4747                 dev->mtu = new_mtu;
4748
4749         if (!err && dev->flags & IFF_UP)
4750                 call_netdevice_notifiers(NETDEV_CHANGEMTU, dev);
4751         return err;
4752 }
4753 EXPORT_SYMBOL(dev_set_mtu);
4754
4755 /**
4756  *      dev_set_group - Change group this device belongs to
4757  *      @dev: device
4758  *      @new_group: group this device should belong to
4759  */
4760 void dev_set_group(struct net_device *dev, int new_group)
4761 {
4762         dev->group = new_group;
4763 }
4764 EXPORT_SYMBOL(dev_set_group);
4765
4766 /**
4767  *      dev_set_mac_address - Change Media Access Control Address
4768  *      @dev: device
4769  *      @sa: new address
4770  *
4771  *      Change the hardware (MAC) address of the device
4772  */
4773 int dev_set_mac_address(struct net_device *dev, struct sockaddr *sa)
4774 {
4775         const struct net_device_ops *ops = dev->netdev_ops;
4776         int err;
4777
4778         if (!ops->ndo_set_mac_address)
4779                 return -EOPNOTSUPP;
4780         if (sa->sa_family != dev->type)
4781                 return -EINVAL;
4782         if (!netif_device_present(dev))
4783                 return -ENODEV;
4784         err = ops->ndo_set_mac_address(dev, sa);
4785         if (!err)
4786                 call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
4787         add_device_randomness(dev->dev_addr, dev->addr_len);
4788         return err;
4789 }
4790 EXPORT_SYMBOL(dev_set_mac_address);
4791
4792 /*
4793  *      Perform the SIOCxIFxxx calls, inside rcu_read_lock()
4794  */
4795 static int dev_ifsioc_locked(struct net *net, struct ifreq *ifr, unsigned int cmd)
4796 {
4797         int err;
4798         struct net_device *dev = dev_get_by_name_rcu(net, ifr->ifr_name);
4799
4800         if (!dev)
4801                 return -ENODEV;
4802
4803         switch (cmd) {
4804         case SIOCGIFFLAGS:      /* Get interface flags */
4805                 ifr->ifr_flags = (short) dev_get_flags(dev);
4806                 return 0;
4807
4808         case SIOCGIFMETRIC:     /* Get the metric on the interface
4809                                    (currently unused) */
4810                 ifr->ifr_metric = 0;
4811                 return 0;
4812
4813         case SIOCGIFMTU:        /* Get the MTU of a device */
4814                 ifr->ifr_mtu = dev->mtu;
4815                 return 0;
4816
4817         case SIOCGIFHWADDR:
4818                 if (!dev->addr_len)
4819                         memset(ifr->ifr_hwaddr.sa_data, 0, sizeof ifr->ifr_hwaddr.sa_data);
4820                 else
4821                         memcpy(ifr->ifr_hwaddr.sa_data, dev->dev_addr,
4822                                min(sizeof ifr->ifr_hwaddr.sa_data, (size_t) dev->addr_len));
4823                 ifr->ifr_hwaddr.sa_family = dev->type;
4824                 return 0;
4825
4826         case SIOCGIFSLAVE:
4827                 err = -EINVAL;
4828                 break;
4829
4830         case SIOCGIFMAP:
4831                 ifr->ifr_map.mem_start = dev->mem_start;
4832                 ifr->ifr_map.mem_end   = dev->mem_end;
4833                 ifr->ifr_map.base_addr = dev->base_addr;
4834                 ifr->ifr_map.irq       = dev->irq;
4835                 ifr->ifr_map.dma       = dev->dma;
4836                 ifr->ifr_map.port      = dev->if_port;
4837                 return 0;
4838
4839         case SIOCGIFINDEX:
4840                 ifr->ifr_ifindex = dev->ifindex;
4841                 return 0;
4842
4843         case SIOCGIFTXQLEN:
4844                 ifr->ifr_qlen = dev->tx_queue_len;
4845                 return 0;
4846
4847         default:
4848                 /* dev_ioctl() should ensure this case
4849                  * is never reached
4850                  */
4851                 WARN_ON(1);
4852                 err = -ENOTTY;
4853                 break;
4854
4855         }
4856         return err;
4857 }
4858
4859 /*
4860  *      Perform the SIOCxIFxxx calls, inside rtnl_lock()
4861  */
4862 static int dev_ifsioc(struct net *net, struct ifreq *ifr, unsigned int cmd)
4863 {
4864         int err;
4865         struct net_device *dev = __dev_get_by_name(net, ifr->ifr_name);
4866         const struct net_device_ops *ops;
4867
4868         if (!dev)
4869                 return -ENODEV;
4870
4871         ops = dev->netdev_ops;
4872
4873         switch (cmd) {
4874         case SIOCSIFFLAGS:      /* Set interface flags */
4875                 return dev_change_flags(dev, ifr->ifr_flags);
4876
4877         case SIOCSIFMETRIC:     /* Set the metric on the interface
4878                                    (currently unused) */
4879                 return -EOPNOTSUPP;
4880
4881         case SIOCSIFMTU:        /* Set the MTU of a device */
4882                 return dev_set_mtu(dev, ifr->ifr_mtu);
4883
4884         case SIOCSIFHWADDR:
4885                 return dev_set_mac_address(dev, &ifr->ifr_hwaddr);
4886
4887         case SIOCSIFHWBROADCAST:
4888                 if (ifr->ifr_hwaddr.sa_family != dev->type)
4889                         return -EINVAL;
4890                 memcpy(dev->broadcast, ifr->ifr_hwaddr.sa_data,
4891                        min(sizeof ifr->ifr_hwaddr.sa_data, (size_t) dev->addr_len));
4892                 call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
4893                 return 0;
4894
4895         case SIOCSIFMAP:
4896                 if (ops->ndo_set_config) {
4897                         if (!netif_device_present(dev))
4898                                 return -ENODEV;
4899                         return ops->ndo_set_config(dev, &ifr->ifr_map);
4900                 }
4901                 return -EOPNOTSUPP;
4902
4903         case SIOCADDMULTI:
4904                 if (!ops->ndo_set_rx_mode ||
4905                     ifr->ifr_hwaddr.sa_family != AF_UNSPEC)
4906                         return -EINVAL;
4907                 if (!netif_device_present(dev))
4908                         return -ENODEV;
4909                 return dev_mc_add_global(dev, ifr->ifr_hwaddr.sa_data);
4910
4911         case SIOCDELMULTI:
4912                 if (!ops->ndo_set_rx_mode ||
4913                     ifr->ifr_hwaddr.sa_family != AF_UNSPEC)
4914                         return -EINVAL;
4915                 if (!netif_device_present(dev))
4916                         return -ENODEV;
4917                 return dev_mc_del_global(dev, ifr->ifr_hwaddr.sa_data);
4918
4919         case SIOCSIFTXQLEN:
4920                 if (ifr->ifr_qlen < 0)
4921                         return -EINVAL;
4922                 dev->tx_queue_len = ifr->ifr_qlen;
4923                 return 0;
4924
4925         case SIOCSIFNAME:
4926                 ifr->ifr_newname[IFNAMSIZ-1] = '\0';
4927                 return dev_change_name(dev, ifr->ifr_newname);
4928
4929         case SIOCSHWTSTAMP:
4930                 err = net_hwtstamp_validate(ifr);
4931                 if (err)
4932                         return err;
4933                 /* fall through */
4934
4935         /*
4936          *      Unknown or private ioctl
4937          */
4938         default:
4939                 if ((cmd >= SIOCDEVPRIVATE &&
4940                     cmd <= SIOCDEVPRIVATE + 15) ||
4941                     cmd == SIOCBONDENSLAVE ||
4942                     cmd == SIOCBONDRELEASE ||
4943                     cmd == SIOCBONDSETHWADDR ||
4944                     cmd == SIOCBONDSLAVEINFOQUERY ||
4945                     cmd == SIOCBONDINFOQUERY ||
4946                     cmd == SIOCBONDCHANGEACTIVE ||
4947                     cmd == SIOCGMIIPHY ||
4948                     cmd == SIOCGMIIREG ||
4949                     cmd == SIOCSMIIREG ||
4950                     cmd == SIOCBRADDIF ||
4951                     cmd == SIOCBRDELIF ||
4952                     cmd == SIOCSHWTSTAMP ||
4953                     cmd == SIOCWANDEV) {
4954                         err = -EOPNOTSUPP;
4955                         if (ops->ndo_do_ioctl) {
4956                                 if (netif_device_present(dev))
4957                                         err = ops->ndo_do_ioctl(dev, ifr, cmd);
4958                                 else
4959                                         err = -ENODEV;
4960                         }
4961                 } else
4962                         err = -EINVAL;
4963
4964         }
4965         return err;
4966 }
4967
4968 /*
4969  *      This function handles all "interface"-type I/O control requests. The actual
4970  *      'doing' part of this is dev_ifsioc above.
4971  */
4972
4973 /**
4974  *      dev_ioctl       -       network device ioctl
4975  *      @net: the applicable net namespace
4976  *      @cmd: command to issue
4977  *      @arg: pointer to a struct ifreq in user space
4978  *
4979  *      Issue ioctl functions to devices. This is normally called by the
4980  *      user space syscall interfaces but can sometimes be useful for
4981  *      other purposes. The return value is the return from the syscall if
4982  *      positive or a negative errno code on error.
4983  */
4984
4985 int dev_ioctl(struct net *net, unsigned int cmd, void __user *arg)
4986 {
4987         struct ifreq ifr;
4988         int ret;
4989         char *colon;
4990
4991         /* One special case: SIOCGIFCONF takes ifconf argument
4992            and requires shared lock, because it sleeps writing
4993            to user space.
4994          */
4995
4996         if (cmd == SIOCGIFCONF) {
4997                 rtnl_lock();
4998                 ret = dev_ifconf(net, (char __user *) arg);
4999                 rtnl_unlock();
5000                 return ret;
5001         }
5002         if (cmd == SIOCGIFNAME)
5003                 return dev_ifname(net, (struct ifreq __user *)arg);
5004
5005         if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
5006                 return -EFAULT;
5007
5008         ifr.ifr_name[IFNAMSIZ-1] = 0;
5009
5010         colon = strchr(ifr.ifr_name, ':');
5011         if (colon)
5012                 *colon = 0;
5013
5014         /*
5015          *      See which interface the caller is talking about.
5016          */
5017
5018         switch (cmd) {
5019         /*
5020          *      These ioctl calls:
5021          *      - can be done by all.
5022          *      - atomic and do not require locking.
5023          *      - return a value
5024          */
5025         case SIOCGIFFLAGS:
5026         case SIOCGIFMETRIC:
5027         case SIOCGIFMTU:
5028         case SIOCGIFHWADDR:
5029         case SIOCGIFSLAVE:
5030         case SIOCGIFMAP:
5031         case SIOCGIFINDEX:
5032         case SIOCGIFTXQLEN:
5033                 dev_load(net, ifr.ifr_name);
5034                 rcu_read_lock();
5035                 ret = dev_ifsioc_locked(net, &ifr, cmd);
5036                 rcu_read_unlock();
5037                 if (!ret) {
5038                         if (colon)
5039                                 *colon = ':';
5040                         if (copy_to_user(arg, &ifr,
5041                                          sizeof(struct ifreq)))
5042                                 ret = -EFAULT;
5043                 }
5044                 return ret;
5045
5046         case SIOCETHTOOL:
5047                 dev_load(net, ifr.ifr_name);
5048                 rtnl_lock();
5049                 ret = dev_ethtool(net, &ifr);
5050                 rtnl_unlock();
5051                 if (!ret) {
5052                         if (colon)
5053                                 *colon = ':';
5054                         if (copy_to_user(arg, &ifr,
5055                                          sizeof(struct ifreq)))
5056                                 ret = -EFAULT;
5057                 }
5058                 return ret;
5059
5060         /*
5061          *      These ioctl calls:
5062          *      - require superuser power.
5063          *      - require strict serialization.
5064          *      - return a value
5065          */
5066         case SIOCGMIIPHY:
5067         case SIOCGMIIREG:
5068         case SIOCSIFNAME:
5069                 if (!capable(CAP_NET_ADMIN))
5070                         return -EPERM;
5071                 dev_load(net, ifr.ifr_name);
5072                 rtnl_lock();
5073                 ret = dev_ifsioc(net, &ifr, cmd);
5074                 rtnl_unlock();
5075                 if (!ret) {
5076                         if (colon)
5077                                 *colon = ':';
5078                         if (copy_to_user(arg, &ifr,
5079                                          sizeof(struct ifreq)))
5080                                 ret = -EFAULT;
5081                 }
5082                 return ret;
5083
5084         /*
5085          *      These ioctl calls:
5086          *      - require superuser power.
5087          *      - require strict serialization.
5088          *      - do not return a value
5089          */
5090         case SIOCSIFFLAGS:
5091         case SIOCSIFMETRIC:
5092         case SIOCSIFMTU:
5093         case SIOCSIFMAP:
5094         case SIOCSIFHWADDR:
5095         case SIOCSIFSLAVE:
5096         case SIOCADDMULTI:
5097         case SIOCDELMULTI:
5098         case SIOCSIFHWBROADCAST:
5099         case SIOCSIFTXQLEN:
5100         case SIOCSMIIREG:
5101         case SIOCBONDENSLAVE:
5102         case SIOCBONDRELEASE:
5103         case SIOCBONDSETHWADDR:
5104         case SIOCBONDCHANGEACTIVE:
5105         case SIOCBRADDIF:
5106         case SIOCBRDELIF:
5107         case SIOCSHWTSTAMP:
5108                 if (!capable(CAP_NET_ADMIN))
5109                         return -EPERM;
5110                 /* fall through */
5111         case SIOCBONDSLAVEINFOQUERY:
5112         case SIOCBONDINFOQUERY:
5113                 dev_load(net, ifr.ifr_name);
5114                 rtnl_lock();
5115                 ret = dev_ifsioc(net, &ifr, cmd);
5116                 rtnl_unlock();
5117                 return ret;
5118
5119         case SIOCGIFMEM:
5120                 /* Get the per device memory space. We can add this but
5121                  * currently do not support it */
5122         case SIOCSIFMEM:
5123                 /* Set the per device memory buffer space.
5124                  * Not applicable in our case */
5125         case SIOCSIFLINK:
5126                 return -ENOTTY;
5127
5128         /*
5129          *      Unknown or private ioctl.
5130          */
5131         default:
5132                 if (cmd == SIOCWANDEV ||
5133                     (cmd >= SIOCDEVPRIVATE &&
5134                      cmd <= SIOCDEVPRIVATE + 15)) {
5135                         dev_load(net, ifr.ifr_name);
5136                         rtnl_lock();
5137                         ret = dev_ifsioc(net, &ifr, cmd);
5138                         rtnl_unlock();
5139                         if (!ret && copy_to_user(arg, &ifr,
5140                                                  sizeof(struct ifreq)))
5141                                 ret = -EFAULT;
5142                         return ret;
5143                 }
5144                 /* Take care of Wireless Extensions */
5145                 if (cmd >= SIOCIWFIRST && cmd <= SIOCIWLAST)
5146                         return wext_handle_ioctl(net, &ifr, cmd, arg);
5147                 return -ENOTTY;
5148         }
5149 }
5150
5151
5152 /**
5153  *      dev_new_index   -       allocate an ifindex
5154  *      @net: the applicable net namespace
5155  *
5156  *      Returns a suitable unique value for a new device interface
5157  *      number.  The caller must hold the rtnl semaphore or the
5158  *      dev_base_lock to be sure it remains unique.
5159  */
5160 static int dev_new_index(struct net *net)
5161 {
5162         static int ifindex;
5163         for (;;) {
5164                 if (++ifindex <= 0)
5165                         ifindex = 1;
5166                 if (!__dev_get_by_index(net, ifindex))
5167                         return ifindex;
5168         }
5169 }
5170
5171 /* Delayed registration/unregisteration */
5172 static LIST_HEAD(net_todo_list);
5173
5174 static void net_set_todo(struct net_device *dev)
5175 {
5176         list_add_tail(&dev->todo_list, &net_todo_list);
5177 }
5178
5179 static void rollback_registered_many(struct list_head *head)
5180 {
5181         struct net_device *dev, *tmp;
5182
5183         BUG_ON(dev_boot_phase);
5184         ASSERT_RTNL();
5185
5186         list_for_each_entry_safe(dev, tmp, head, unreg_list) {
5187                 /* Some devices call without registering
5188                  * for initialization unwind. Remove those
5189                  * devices and proceed with the remaining.
5190                  */
5191                 if (dev->reg_state == NETREG_UNINITIALIZED) {
5192                         pr_debug("unregister_netdevice: device %s/%p never was registered\n",
5193                                  dev->name, dev);
5194
5195                         WARN_ON(1);
5196                         list_del(&dev->unreg_list);
5197                         continue;
5198                 }
5199                 dev->dismantle = true;
5200                 BUG_ON(dev->reg_state != NETREG_REGISTERED);
5201         }
5202
5203         /* If device is running, close it first. */
5204         dev_close_many(head);
5205
5206         list_for_each_entry(dev, head, unreg_list) {
5207                 /* And unlink it from device chain. */
5208                 unlist_netdevice(dev);
5209
5210                 dev->reg_state = NETREG_UNREGISTERING;
5211         }
5212
5213         synchronize_net();
5214
5215         list_for_each_entry(dev, head, unreg_list) {
5216                 /* Shutdown queueing discipline. */
5217                 dev_shutdown(dev);
5218
5219
5220                 /* Notify protocols, that we are about to destroy
5221                    this device. They should clean all the things.
5222                 */
5223                 call_netdevice_notifiers(NETDEV_UNREGISTER, dev);
5224
5225                 if (!dev->rtnl_link_ops ||
5226                     dev->rtnl_link_state == RTNL_LINK_INITIALIZED)
5227                         rtmsg_ifinfo(RTM_DELLINK, dev, ~0U);
5228
5229                 /*
5230                  *      Flush the unicast and multicast chains
5231                  */
5232                 dev_uc_flush(dev);
5233                 dev_mc_flush(dev);
5234
5235                 if (dev->netdev_ops->ndo_uninit)
5236                         dev->netdev_ops->ndo_uninit(dev);
5237
5238                 /* Notifier chain MUST detach us from master device. */
5239                 WARN_ON(dev->master);
5240
5241                 /* Remove entries from kobject tree */
5242                 netdev_unregister_kobject(dev);
5243         }
5244
5245         /* Process any work delayed until the end of the batch */
5246         dev = list_first_entry(head, struct net_device, unreg_list);
5247         call_netdevice_notifiers(NETDEV_UNREGISTER_BATCH, dev);
5248
5249         synchronize_net();
5250
5251         list_for_each_entry(dev, head, unreg_list)
5252                 dev_put(dev);
5253 }
5254
5255 static void rollback_registered(struct net_device *dev)
5256 {
5257         LIST_HEAD(single);
5258
5259         list_add(&dev->unreg_list, &single);
5260         rollback_registered_many(&single);
5261         list_del(&single);
5262 }
5263
5264 static netdev_features_t netdev_fix_features(struct net_device *dev,
5265         netdev_features_t features)
5266 {
5267         /* Fix illegal checksum combinations */
5268         if ((features & NETIF_F_HW_CSUM) &&
5269             (features & (NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM))) {
5270                 netdev_warn(dev, "mixed HW and IP checksum settings.\n");
5271                 features &= ~(NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM);
5272         }
5273
5274         /* Fix illegal SG+CSUM combinations. */
5275         if ((features & NETIF_F_SG) &&
5276             !(features & NETIF_F_ALL_CSUM)) {
5277                 netdev_dbg(dev,
5278                         "Dropping NETIF_F_SG since no checksum feature.\n");
5279                 features &= ~NETIF_F_SG;
5280         }
5281
5282         /* TSO requires that SG is present as well. */
5283         if ((features & NETIF_F_ALL_TSO) && !(features & NETIF_F_SG)) {
5284                 netdev_dbg(dev, "Dropping TSO features since no SG feature.\n");
5285                 features &= ~NETIF_F_ALL_TSO;
5286         }
5287
5288         /* TSO ECN requires that TSO is present as well. */
5289         if ((features & NETIF_F_ALL_TSO) == NETIF_F_TSO_ECN)
5290                 features &= ~NETIF_F_TSO_ECN;
5291
5292         /* Software GSO depends on SG. */
5293         if ((features & NETIF_F_GSO) && !(features & NETIF_F_SG)) {
5294                 netdev_dbg(dev, "Dropping NETIF_F_GSO since no SG feature.\n");
5295                 features &= ~NETIF_F_GSO;
5296         }
5297
5298         /* UFO needs SG and checksumming */
5299         if (features & NETIF_F_UFO) {
5300                 /* maybe split UFO into V4 and V6? */
5301                 if (!((features & NETIF_F_GEN_CSUM) ||
5302                     (features & (NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM))
5303                             == (NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM))) {
5304                         netdev_dbg(dev,
5305                                 "Dropping NETIF_F_UFO since no checksum offload features.\n");
5306                         features &= ~NETIF_F_UFO;
5307                 }
5308
5309                 if (!(features & NETIF_F_SG)) {
5310                         netdev_dbg(dev,
5311                                 "Dropping NETIF_F_UFO since no NETIF_F_SG feature.\n");
5312                         features &= ~NETIF_F_UFO;
5313                 }
5314         }
5315
5316         return features;
5317 }
5318
5319 int __netdev_update_features(struct net_device *dev)
5320 {
5321         netdev_features_t features;
5322         int err = 0;
5323
5324         ASSERT_RTNL();
5325
5326         features = netdev_get_wanted_features(dev);
5327
5328         if (dev->netdev_ops->ndo_fix_features)
5329                 features = dev->netdev_ops->ndo_fix_features(dev, features);
5330
5331         /* driver might be less strict about feature dependencies */
5332         features = netdev_fix_features(dev, features);
5333
5334         if (dev->features == features)
5335                 return 0;
5336
5337         netdev_dbg(dev, "Features changed: %pNF -> %pNF\n",
5338                 &dev->features, &features);
5339
5340         if (dev->netdev_ops->ndo_set_features)
5341                 err = dev->netdev_ops->ndo_set_features(dev, features);
5342
5343         if (unlikely(err < 0)) {
5344                 netdev_err(dev,
5345                         "set_features() failed (%d); wanted %pNF, left %pNF\n",
5346                         err, &features, &dev->features);
5347                 return -1;
5348         }
5349
5350         if (!err)
5351                 dev->features = features;
5352
5353         return 1;
5354 }
5355
5356 /**
5357  *      netdev_update_features - recalculate device features
5358  *      @dev: the device to check
5359  *
5360  *      Recalculate dev->features set and send notifications if it
5361  *      has changed. Should be called after driver or hardware dependent
5362  *      conditions might have changed that influence the features.
5363  */
5364 void netdev_update_features(struct net_device *dev)
5365 {
5366         if (__netdev_update_features(dev))
5367                 netdev_features_change(dev);
5368 }
5369 EXPORT_SYMBOL(netdev_update_features);
5370
5371 /**
5372  *      netdev_change_features - recalculate device features
5373  *      @dev: the device to check
5374  *
5375  *      Recalculate dev->features set and send notifications even
5376  *      if they have not changed. Should be called instead of
5377  *      netdev_update_features() if also dev->vlan_features might
5378  *      have changed to allow the changes to be propagated to stacked
5379  *      VLAN devices.
5380  */
5381 void netdev_change_features(struct net_device *dev)
5382 {
5383         __netdev_update_features(dev);
5384         netdev_features_change(dev);
5385 }
5386 EXPORT_SYMBOL(netdev_change_features);
5387
5388 /**
5389  *      netif_stacked_transfer_operstate -      transfer operstate
5390  *      @rootdev: the root or lower level device to transfer state from
5391  *      @dev: the device to transfer operstate to
5392  *
5393  *      Transfer operational state from root to device. This is normally
5394  *      called when a stacking relationship exists between the root
5395  *      device and the device(a leaf device).
5396  */
5397 void netif_stacked_transfer_operstate(const struct net_device *rootdev,
5398                                         struct net_device *dev)
5399 {
5400         if (rootdev->operstate == IF_OPER_DORMANT)
5401                 netif_dormant_on(dev);
5402         else
5403                 netif_dormant_off(dev);
5404
5405         if (netif_carrier_ok(rootdev)) {
5406                 if (!netif_carrier_ok(dev))
5407                         netif_carrier_on(dev);
5408         } else {
5409                 if (netif_carrier_ok(dev))
5410                         netif_carrier_off(dev);
5411         }
5412 }
5413 EXPORT_SYMBOL(netif_stacked_transfer_operstate);
5414
5415 #ifdef CONFIG_RPS
5416 static int netif_alloc_rx_queues(struct net_device *dev)
5417 {
5418         unsigned int i, count = dev->num_rx_queues;
5419         struct netdev_rx_queue *rx;
5420
5421         BUG_ON(count < 1);
5422
5423         rx = kcalloc(count, sizeof(struct netdev_rx_queue), GFP_KERNEL);
5424         if (!rx) {
5425                 pr_err("netdev: Unable to allocate %u rx queues\n", count);
5426                 return -ENOMEM;
5427         }
5428         dev->_rx = rx;
5429
5430         for (i = 0; i < count; i++)
5431                 rx[i].dev = dev;
5432         return 0;
5433 }
5434 #endif
5435
5436 static void netdev_init_one_queue(struct net_device *dev,
5437                                   struct netdev_queue *queue, void *_unused)
5438 {
5439         /* Initialize queue lock */
5440         spin_lock_init(&queue->_xmit_lock);
5441         netdev_set_xmit_lockdep_class(&queue->_xmit_lock, dev->type);
5442         queue->xmit_lock_owner = -1;
5443         netdev_queue_numa_node_write(queue, NUMA_NO_NODE);
5444         queue->dev = dev;
5445 #ifdef CONFIG_BQL
5446         dql_init(&queue->dql, HZ);
5447 #endif
5448 }
5449
5450 static int netif_alloc_netdev_queues(struct net_device *dev)
5451 {
5452         unsigned int count = dev->num_tx_queues;
5453         struct netdev_queue *tx;
5454
5455         BUG_ON(count < 1);
5456
5457         tx = kcalloc(count, sizeof(struct netdev_queue), GFP_KERNEL);
5458         if (!tx) {
5459                 pr_err("netdev: Unable to allocate %u tx queues\n", count);
5460                 return -ENOMEM;
5461         }
5462         dev->_tx = tx;
5463
5464         netdev_for_each_tx_queue(dev, netdev_init_one_queue, NULL);
5465         spin_lock_init(&dev->tx_global_lock);
5466
5467         return 0;
5468 }
5469
5470 /**
5471  *      register_netdevice      - register a network device
5472  *      @dev: device to register
5473  *
5474  *      Take a completed network device structure and add it to the kernel
5475  *      interfaces. A %NETDEV_REGISTER message is sent to the netdev notifier
5476  *      chain. 0 is returned on success. A negative errno code is returned
5477  *      on a failure to set up the device, or if the name is a duplicate.
5478  *
5479  *      Callers must hold the rtnl semaphore. You may want
5480  *      register_netdev() instead of this.
5481  *
5482  *      BUGS:
5483  *      The locking appears insufficient to guarantee two parallel registers
5484  *      will not get the same name.
5485  */
5486
5487 int register_netdevice(struct net_device *dev)
5488 {
5489         int ret;
5490         struct net *net = dev_net(dev);
5491
5492         BUG_ON(dev_boot_phase);
5493         ASSERT_RTNL();
5494
5495         might_sleep();
5496
5497         /* When net_device's are persistent, this will be fatal. */
5498         BUG_ON(dev->reg_state != NETREG_UNINITIALIZED);
5499         BUG_ON(!net);
5500
5501         spin_lock_init(&dev->addr_list_lock);
5502         netdev_set_addr_lockdep_class(dev);
5503
5504         dev->iflink = -1;
5505
5506         ret = dev_get_valid_name(dev, dev->name);
5507         if (ret < 0)
5508                 goto out;
5509
5510         /* Init, if this function is available */
5511         if (dev->netdev_ops->ndo_init) {
5512                 ret = dev->netdev_ops->ndo_init(dev);
5513                 if (ret) {
5514                         if (ret > 0)
5515                                 ret = -EIO;
5516                         goto out;
5517                 }
5518         }
5519
5520         dev->ifindex = dev_new_index(net);
5521         if (dev->iflink == -1)
5522                 dev->iflink = dev->ifindex;
5523
5524         /* Transfer changeable features to wanted_features and enable
5525          * software offloads (GSO and GRO).
5526          */
5527         dev->hw_features |= NETIF_F_SOFT_FEATURES;
5528         dev->features |= NETIF_F_SOFT_FEATURES;
5529         dev->wanted_features = dev->features & dev->hw_features;
5530
5531         /* Turn on no cache copy if HW is doing checksum */
5532         if (!(dev->flags & IFF_LOOPBACK)) {
5533                 dev->hw_features |= NETIF_F_NOCACHE_COPY;
5534                 if (dev->features & NETIF_F_ALL_CSUM) {
5535                         dev->wanted_features |= NETIF_F_NOCACHE_COPY;
5536                         dev->features |= NETIF_F_NOCACHE_COPY;
5537                 }
5538         }
5539
5540         /* Make NETIF_F_HIGHDMA inheritable to VLAN devices.
5541          */
5542         dev->vlan_features |= NETIF_F_HIGHDMA;
5543
5544         ret = call_netdevice_notifiers(NETDEV_POST_INIT, dev);
5545         ret = notifier_to_errno(ret);
5546         if (ret)
5547                 goto err_uninit;
5548
5549         ret = netdev_register_kobject(dev);
5550         if (ret)
5551                 goto err_uninit;
5552         dev->reg_state = NETREG_REGISTERED;
5553
5554         __netdev_update_features(dev);
5555
5556         /*
5557          *      Default initial state at registry is that the
5558          *      device is present.
5559          */
5560
5561         set_bit(__LINK_STATE_PRESENT, &dev->state);
5562
5563         dev_init_scheduler(dev);
5564         dev_hold(dev);
5565         list_netdevice(dev);
5566         add_device_randomness(dev->dev_addr, dev->addr_len);
5567
5568         /* Notify protocols, that a new device appeared. */
5569         ret = call_netdevice_notifiers(NETDEV_REGISTER, dev);
5570         ret = notifier_to_errno(ret);
5571         if (ret) {
5572                 rollback_registered(dev);
5573                 dev->reg_state = NETREG_UNREGISTERED;
5574         }
5575         /*
5576          *      Prevent userspace races by waiting until the network
5577          *      device is fully setup before sending notifications.
5578          */
5579         if (!dev->rtnl_link_ops ||
5580             dev->rtnl_link_state == RTNL_LINK_INITIALIZED)
5581                 rtmsg_ifinfo(RTM_NEWLINK, dev, ~0U);
5582
5583 out:
5584         return ret;
5585
5586 err_uninit:
5587         if (dev->netdev_ops->ndo_uninit)
5588                 dev->netdev_ops->ndo_uninit(dev);
5589         goto out;
5590 }
5591 EXPORT_SYMBOL(register_netdevice);
5592
5593 /**
5594  *      init_dummy_netdev       - init a dummy network device for NAPI
5595  *      @dev: device to init
5596  *
5597  *      This takes a network device structure and initialize the minimum
5598  *      amount of fields so it can be used to schedule NAPI polls without
5599  *      registering a full blown interface. This is to be used by drivers
5600  *      that need to tie several hardware interfaces to a single NAPI
5601  *      poll scheduler due to HW limitations.
5602  */
5603 int init_dummy_netdev(struct net_device *dev)
5604 {
5605         /* Clear everything. Note we don't initialize spinlocks
5606          * are they aren't supposed to be taken by any of the
5607          * NAPI code and this dummy netdev is supposed to be
5608          * only ever used for NAPI polls
5609          */
5610         memset(dev, 0, sizeof(struct net_device));
5611
5612         /* make sure we BUG if trying to hit standard
5613          * register/unregister code path
5614          */
5615         dev->reg_state = NETREG_DUMMY;
5616
5617         /* NAPI wants this */
5618         INIT_LIST_HEAD(&dev->napi_list);
5619
5620         /* a dummy interface is started by default */
5621         set_bit(__LINK_STATE_PRESENT, &dev->state);
5622         set_bit(__LINK_STATE_START, &dev->state);
5623
5624         /* Note : We dont allocate pcpu_refcnt for dummy devices,
5625          * because users of this 'device' dont need to change
5626          * its refcount.
5627          */
5628
5629         return 0;
5630 }
5631 EXPORT_SYMBOL_GPL(init_dummy_netdev);
5632
5633
5634 /**
5635  *      register_netdev - register a network device
5636  *      @dev: device to register
5637  *
5638  *      Take a completed network device structure and add it to the kernel
5639  *      interfaces. A %NETDEV_REGISTER message is sent to the netdev notifier
5640  *      chain. 0 is returned on success. A negative errno code is returned
5641  *      on a failure to set up the device, or if the name is a duplicate.
5642  *
5643  *      This is a wrapper around register_netdevice that takes the rtnl semaphore
5644  *      and expands the device name if you passed a format string to
5645  *      alloc_netdev.
5646  */
5647 int register_netdev(struct net_device *dev)
5648 {
5649         int err;
5650
5651         rtnl_lock();
5652         err = register_netdevice(dev);
5653         rtnl_unlock();
5654         return err;
5655 }
5656 EXPORT_SYMBOL(register_netdev);
5657
5658 int netdev_refcnt_read(const struct net_device *dev)
5659 {
5660         int i, refcnt = 0;
5661
5662         for_each_possible_cpu(i)
5663                 refcnt += *per_cpu_ptr(dev->pcpu_refcnt, i);
5664         return refcnt;
5665 }
5666 EXPORT_SYMBOL(netdev_refcnt_read);
5667
5668 /*
5669  * netdev_wait_allrefs - wait until all references are gone.
5670  *
5671  * This is called when unregistering network devices.
5672  *
5673  * Any protocol or device that holds a reference should register
5674  * for netdevice notification, and cleanup and put back the
5675  * reference if they receive an UNREGISTER event.
5676  * We can get stuck here if buggy protocols don't correctly
5677  * call dev_put.
5678  */
5679 static void netdev_wait_allrefs(struct net_device *dev)
5680 {
5681         unsigned long rebroadcast_time, warning_time;
5682         int refcnt;
5683
5684         linkwatch_forget_dev(dev);
5685
5686         rebroadcast_time = warning_time = jiffies;
5687         refcnt = netdev_refcnt_read(dev);
5688
5689         while (refcnt != 0) {
5690                 if (time_after(jiffies, rebroadcast_time + 1 * HZ)) {
5691                         rtnl_lock();
5692
5693                         /* Rebroadcast unregister notification */
5694                         call_netdevice_notifiers(NETDEV_UNREGISTER, dev);
5695                         /* don't resend NETDEV_UNREGISTER_BATCH, _BATCH users
5696                          * should have already handle it the first time */
5697
5698                         if (test_bit(__LINK_STATE_LINKWATCH_PENDING,
5699                                      &dev->state)) {
5700                                 /* We must not have linkwatch events
5701                                  * pending on unregister. If this
5702                                  * happens, we simply run the queue
5703                                  * unscheduled, resulting in a noop
5704                                  * for this device.
5705                                  */
5706                                 linkwatch_run_queue();
5707                         }
5708
5709                         __rtnl_unlock();
5710
5711                         rebroadcast_time = jiffies;
5712                 }
5713
5714                 msleep(250);
5715
5716                 refcnt = netdev_refcnt_read(dev);
5717
5718                 if (time_after(jiffies, warning_time + 10 * HZ)) {
5719                         pr_emerg("unregister_netdevice: waiting for %s to become free. Usage count = %d\n",
5720                                  dev->name, refcnt);
5721                         warning_time = jiffies;
5722                 }
5723         }
5724 }
5725
5726 /* The sequence is:
5727  *
5728  *      rtnl_lock();
5729  *      ...
5730  *      register_netdevice(x1);
5731  *      register_netdevice(x2);
5732  *      ...
5733  *      unregister_netdevice(y1);
5734  *      unregister_netdevice(y2);
5735  *      ...
5736  *      rtnl_unlock();
5737  *      free_netdev(y1);
5738  *      free_netdev(y2);
5739  *
5740  * We are invoked by rtnl_unlock().
5741  * This allows us to deal with problems:
5742  * 1) We can delete sysfs objects which invoke hotplug
5743  *    without deadlocking with linkwatch via keventd.
5744  * 2) Since we run with the RTNL semaphore not held, we can sleep
5745  *    safely in order to wait for the netdev refcnt to drop to zero.
5746  *
5747  * We must not return until all unregister events added during
5748  * the interval the lock was held have been completed.
5749  */
5750 void netdev_run_todo(void)
5751 {
5752         struct list_head list;
5753
5754         /* Snapshot list, allow later requests */
5755         list_replace_init(&net_todo_list, &list);
5756
5757         __rtnl_unlock();
5758
5759         /* Wait for rcu callbacks to finish before attempting to drain
5760          * the device list.  This usually avoids a 250ms wait.
5761          */
5762         if (!list_empty(&list))
5763                 rcu_barrier();
5764
5765         while (!list_empty(&list)) {
5766                 struct net_device *dev
5767                         = list_first_entry(&list, struct net_device, todo_list);
5768                 list_del(&dev->todo_list);
5769
5770                 if (unlikely(dev->reg_state != NETREG_UNREGISTERING)) {
5771                         pr_err("network todo '%s' but state %d\n",
5772                                dev->name, dev->reg_state);
5773                         dump_stack();
5774                         continue;
5775                 }
5776
5777                 dev->reg_state = NETREG_UNREGISTERED;
5778
5779                 on_each_cpu(flush_backlog, dev, 1);
5780
5781                 netdev_wait_allrefs(dev);
5782
5783                 /* paranoia */
5784                 BUG_ON(netdev_refcnt_read(dev));
5785                 WARN_ON(rcu_access_pointer(dev->ip_ptr));
5786                 WARN_ON(rcu_access_pointer(dev->ip6_ptr));
5787                 WARN_ON(dev->dn_ptr);
5788
5789                 if (dev->destructor)
5790                         dev->destructor(dev);
5791
5792                 /* Free network device */
5793                 kobject_put(&dev->dev.kobj);
5794         }
5795 }
5796
5797 /* Convert net_device_stats to rtnl_link_stats64.  They have the same
5798  * fields in the same order, with only the type differing.
5799  */
5800 void netdev_stats_to_stats64(struct rtnl_link_stats64 *stats64,
5801                              const struct net_device_stats *netdev_stats)
5802 {
5803 #if BITS_PER_LONG == 64
5804         BUILD_BUG_ON(sizeof(*stats64) != sizeof(*netdev_stats));
5805         memcpy(stats64, netdev_stats, sizeof(*stats64));
5806 #else
5807         size_t i, n = sizeof(*stats64) / sizeof(u64);
5808         const unsigned long *src = (const unsigned long *)netdev_stats;
5809         u64 *dst = (u64 *)stats64;
5810
5811         BUILD_BUG_ON(sizeof(*netdev_stats) / sizeof(unsigned long) !=
5812                      sizeof(*stats64) / sizeof(u64));
5813         for (i = 0; i < n; i++)
5814                 dst[i] = src[i];
5815 #endif
5816 }
5817 EXPORT_SYMBOL(netdev_stats_to_stats64);
5818
5819 /**
5820  *      dev_get_stats   - get network device statistics
5821  *      @dev: device to get statistics from
5822  *      @storage: place to store stats
5823  *
5824  *      Get network statistics from device. Return @storage.
5825  *      The device driver may provide its own method by setting
5826  *      dev->netdev_ops->get_stats64 or dev->netdev_ops->get_stats;
5827  *      otherwise the internal statistics structure is used.
5828  */
5829 struct rtnl_link_stats64 *dev_get_stats(struct net_device *dev,
5830                                         struct rtnl_link_stats64 *storage)
5831 {
5832         const struct net_device_ops *ops = dev->netdev_ops;
5833
5834         if (ops->ndo_get_stats64) {
5835                 memset(storage, 0, sizeof(*storage));
5836                 ops->ndo_get_stats64(dev, storage);
5837         } else if (ops->ndo_get_stats) {
5838                 netdev_stats_to_stats64(storage, ops->ndo_get_stats(dev));
5839         } else {
5840                 netdev_stats_to_stats64(storage, &dev->stats);
5841         }
5842         storage->rx_dropped += atomic_long_read(&dev->rx_dropped);
5843         return storage;
5844 }
5845 EXPORT_SYMBOL(dev_get_stats);
5846
5847 struct netdev_queue *dev_ingress_queue_create(struct net_device *dev)
5848 {
5849         struct netdev_queue *queue = dev_ingress_queue(dev);
5850
5851 #ifdef CONFIG_NET_CLS_ACT
5852         if (queue)
5853                 return queue;
5854         queue = kzalloc(sizeof(*queue), GFP_KERNEL);
5855         if (!queue)
5856                 return NULL;
5857         netdev_init_one_queue(dev, queue, NULL);
5858         queue->qdisc = &noop_qdisc;
5859         queue->qdisc_sleeping = &noop_qdisc;
5860         rcu_assign_pointer(dev->ingress_queue, queue);
5861 #endif
5862         return queue;
5863 }
5864
5865 /**
5866  *      alloc_netdev_mqs - allocate network device
5867  *      @sizeof_priv:   size of private data to allocate space for
5868  *      @name:          device name format string
5869  *      @setup:         callback to initialize device
5870  *      @txqs:          the number of TX subqueues to allocate
5871  *      @rxqs:          the number of RX subqueues to allocate
5872  *
5873  *      Allocates a struct net_device with private data area for driver use
5874  *      and performs basic initialization.  Also allocates subquue structs
5875  *      for each queue on the device.
5876  */
5877 struct net_device *alloc_netdev_mqs(int sizeof_priv, const char *name,
5878                 void (*setup)(struct net_device *),
5879                 unsigned int txqs, unsigned int rxqs)
5880 {
5881         struct net_device *dev;
5882         size_t alloc_size;
5883         struct net_device *p;
5884
5885         BUG_ON(strlen(name) >= sizeof(dev->name));
5886
5887         if (txqs < 1) {
5888                 pr_err("alloc_netdev: Unable to allocate device with zero queues\n");
5889                 return NULL;
5890         }
5891
5892 #ifdef CONFIG_RPS
5893         if (rxqs < 1) {
5894                 pr_err("alloc_netdev: Unable to allocate device with zero RX queues\n");
5895                 return NULL;
5896         }
5897 #endif
5898
5899         alloc_size = sizeof(struct net_device);
5900         if (sizeof_priv) {
5901                 /* ensure 32-byte alignment of private area */
5902                 alloc_size = ALIGN(alloc_size, NETDEV_ALIGN);
5903                 alloc_size += sizeof_priv;
5904         }
5905         /* ensure 32-byte alignment of whole construct */
5906         alloc_size += NETDEV_ALIGN - 1;
5907
5908         p = kzalloc(alloc_size, GFP_KERNEL);
5909         if (!p) {
5910                 pr_err("alloc_netdev: Unable to allocate device\n");
5911                 return NULL;
5912         }
5913
5914         dev = PTR_ALIGN(p, NETDEV_ALIGN);
5915         dev->padded = (char *)dev - (char *)p;
5916
5917         dev->pcpu_refcnt = alloc_percpu(int);
5918         if (!dev->pcpu_refcnt)
5919                 goto free_p;
5920
5921         if (dev_addr_init(dev))
5922                 goto free_pcpu;
5923
5924         dev_mc_init(dev);
5925         dev_uc_init(dev);
5926
5927         dev_net_set(dev, &init_net);
5928
5929         dev->gso_max_size = GSO_MAX_SIZE;
5930         dev->gso_max_segs = GSO_MAX_SEGS;
5931
5932         INIT_LIST_HEAD(&dev->napi_list);
5933         INIT_LIST_HEAD(&dev->unreg_list);
5934         INIT_LIST_HEAD(&dev->link_watch_list);
5935         dev->priv_flags = IFF_XMIT_DST_RELEASE;
5936         setup(dev);
5937
5938         dev->num_tx_queues = txqs;
5939         dev->real_num_tx_queues = txqs;
5940         if (netif_alloc_netdev_queues(dev))
5941                 goto free_all;
5942
5943 #ifdef CONFIG_RPS
5944         dev->num_rx_queues = rxqs;
5945         dev->real_num_rx_queues = rxqs;
5946         if (netif_alloc_rx_queues(dev))
5947                 goto free_all;
5948 #endif
5949
5950         strcpy(dev->name, name);
5951         dev->group = INIT_NETDEV_GROUP;
5952         return dev;
5953
5954 free_all:
5955         free_netdev(dev);
5956         return NULL;
5957
5958 free_pcpu:
5959         free_percpu(dev->pcpu_refcnt);
5960         kfree(dev->_tx);
5961 #ifdef CONFIG_RPS
5962         kfree(dev->_rx);
5963 #endif
5964
5965 free_p:
5966         kfree(p);
5967         return NULL;
5968 }
5969 EXPORT_SYMBOL(alloc_netdev_mqs);
5970
5971 /**
5972  *      free_netdev - free network device
5973  *      @dev: device
5974  *
5975  *      This function does the last stage of destroying an allocated device
5976  *      interface. The reference to the device object is released.
5977  *      If this is the last reference then it will be freed.
5978  */
5979 void free_netdev(struct net_device *dev)
5980 {
5981         struct napi_struct *p, *n;
5982
5983         release_net(dev_net(dev));
5984
5985         kfree(dev->_tx);
5986 #ifdef CONFIG_RPS
5987         kfree(dev->_rx);
5988 #endif
5989
5990         kfree(rcu_dereference_protected(dev->ingress_queue, 1));
5991
5992         /* Flush device addresses */
5993         dev_addr_flush(dev);
5994
5995         list_for_each_entry_safe(p, n, &dev->napi_list, dev_list)
5996                 netif_napi_del(p);
5997
5998         free_percpu(dev->pcpu_refcnt);
5999         dev->pcpu_refcnt = NULL;
6000
6001         /*  Compatibility with error handling in drivers */
6002         if (dev->reg_state == NETREG_UNINITIALIZED) {
6003                 kfree((char *)dev - dev->padded);
6004                 return;
6005         }
6006
6007         BUG_ON(dev->reg_state != NETREG_UNREGISTERED);
6008         dev->reg_state = NETREG_RELEASED;
6009
6010         /* will free via device release */
6011         put_device(&dev->dev);
6012 }
6013 EXPORT_SYMBOL(free_netdev);
6014
6015 /**
6016  *      synchronize_net -  Synchronize with packet receive processing
6017  *
6018  *      Wait for packets currently being received to be done.
6019  *      Does not block later packets from starting.
6020  */
6021 void synchronize_net(void)
6022 {
6023         might_sleep();
6024         if (rtnl_is_locked())
6025                 synchronize_rcu_expedited();
6026         else
6027                 synchronize_rcu();
6028 }
6029 EXPORT_SYMBOL(synchronize_net);
6030
6031 /**
6032  *      unregister_netdevice_queue - remove device from the kernel
6033  *      @dev: device
6034  *      @head: list
6035  *
6036  *      This function shuts down a device interface and removes it
6037  *      from the kernel tables.
6038  *      If head not NULL, device is queued to be unregistered later.
6039  *
6040  *      Callers must hold the rtnl semaphore.  You may want
6041  *      unregister_netdev() instead of this.
6042  */
6043
6044 void unregister_netdevice_queue(struct net_device *dev, struct list_head *head)
6045 {
6046         ASSERT_RTNL();
6047
6048         if (head) {
6049                 list_move_tail(&dev->unreg_list, head);
6050         } else {
6051                 rollback_registered(dev);
6052                 /* Finish processing unregister after unlock */
6053                 net_set_todo(dev);
6054         }
6055 }
6056 EXPORT_SYMBOL(unregister_netdevice_queue);
6057
6058 /**
6059  *      unregister_netdevice_many - unregister many devices
6060  *      @head: list of devices
6061  */
6062 void unregister_netdevice_many(struct list_head *head)
6063 {
6064         struct net_device *dev;
6065
6066         if (!list_empty(head)) {
6067                 rollback_registered_many(head);
6068                 list_for_each_entry(dev, head, unreg_list)
6069                         net_set_todo(dev);
6070         }
6071 }
6072 EXPORT_SYMBOL(unregister_netdevice_many);
6073
6074 /**
6075  *      unregister_netdev - remove device from the kernel
6076  *      @dev: device
6077  *
6078  *      This function shuts down a device interface and removes it
6079  *      from the kernel tables.
6080  *
6081  *      This is just a wrapper for unregister_netdevice that takes
6082  *      the rtnl semaphore.  In general you want to use this and not
6083  *      unregister_netdevice.
6084  */
6085 void unregister_netdev(struct net_device *dev)
6086 {
6087         rtnl_lock();
6088         unregister_netdevice(dev);
6089         rtnl_unlock();
6090 }
6091 EXPORT_SYMBOL(unregister_netdev);
6092
6093 /**
6094  *      dev_change_net_namespace - move device to different nethost namespace
6095  *      @dev: device
6096  *      @net: network namespace
6097  *      @pat: If not NULL name pattern to try if the current device name
6098  *            is already taken in the destination network namespace.
6099  *
6100  *      This function shuts down a device interface and moves it
6101  *      to a new network namespace. On success 0 is returned, on
6102  *      a failure a netagive errno code is returned.
6103  *
6104  *      Callers must hold the rtnl semaphore.
6105  */
6106
6107 int dev_change_net_namespace(struct net_device *dev, struct net *net, const char *pat)
6108 {
6109         int err;
6110
6111         ASSERT_RTNL();
6112
6113         /* Don't allow namespace local devices to be moved. */
6114         err = -EINVAL;
6115         if (dev->features & NETIF_F_NETNS_LOCAL)
6116                 goto out;
6117
6118         /* Ensure the device has been registrered */
6119         err = -EINVAL;
6120         if (dev->reg_state != NETREG_REGISTERED)
6121                 goto out;
6122
6123         /* Get out if there is nothing todo */
6124         err = 0;
6125         if (net_eq(dev_net(dev), net))
6126                 goto out;
6127
6128         /* Pick the destination device name, and ensure
6129          * we can use it in the destination network namespace.
6130          */
6131         err = -EEXIST;
6132         if (__dev_get_by_name(net, dev->name)) {
6133                 /* We get here if we can't use the current device name */
6134                 if (!pat)
6135                         goto out;
6136                 if (dev_get_valid_name(dev, pat) < 0)
6137                         goto out;
6138         }
6139
6140         /*
6141          * And now a mini version of register_netdevice unregister_netdevice.
6142          */
6143
6144         /* If device is running close it first. */
6145         dev_close(dev);
6146
6147         /* And unlink it from device chain */
6148         err = -ENODEV;
6149         unlist_netdevice(dev);
6150
6151         synchronize_net();
6152
6153         /* Shutdown queueing discipline. */
6154         dev_shutdown(dev);
6155
6156         /* Notify protocols, that we are about to destroy
6157            this device. They should clean all the things.
6158
6159            Note that dev->reg_state stays at NETREG_REGISTERED.
6160            This is wanted because this way 8021q and macvlan know
6161            the device is just moving and can keep their slaves up.
6162         */
6163         call_netdevice_notifiers(NETDEV_UNREGISTER, dev);
6164         call_netdevice_notifiers(NETDEV_UNREGISTER_BATCH, dev);
6165         rtmsg_ifinfo(RTM_DELLINK, dev, ~0U);
6166
6167         /*
6168          *      Flush the unicast and multicast chains
6169          */
6170         dev_uc_flush(dev);
6171         dev_mc_flush(dev);
6172
6173         /* Actually switch the network namespace */
6174         dev_net_set(dev, net);
6175
6176         /* If there is an ifindex conflict assign a new one */
6177         if (__dev_get_by_index(net, dev->ifindex)) {
6178                 int iflink = (dev->iflink == dev->ifindex);
6179                 dev->ifindex = dev_new_index(net);
6180                 if (iflink)
6181                         dev->iflink = dev->ifindex;
6182         }
6183
6184         /* Fixup kobjects */
6185         err = device_rename(&dev->dev, dev->name);
6186         WARN_ON(err);
6187
6188         /* Add the device back in the hashes */
6189         list_netdevice(dev);
6190
6191         /* Notify protocols, that a new device appeared. */
6192         call_netdevice_notifiers(NETDEV_REGISTER, dev);
6193
6194         /*
6195          *      Prevent userspace races by waiting until the network
6196          *      device is fully setup before sending notifications.
6197          */
6198         rtmsg_ifinfo(RTM_NEWLINK, dev, ~0U);
6199
6200         synchronize_net();
6201         err = 0;
6202 out:
6203         return err;
6204 }
6205 EXPORT_SYMBOL_GPL(dev_change_net_namespace);
6206
6207 static int dev_cpu_callback(struct notifier_block *nfb,
6208                             unsigned long action,
6209                             void *ocpu)
6210 {
6211         struct sk_buff **list_skb;
6212         struct sk_buff *skb;
6213         unsigned int cpu, oldcpu = (unsigned long)ocpu;
6214         struct softnet_data *sd, *oldsd;
6215
6216         if (action != CPU_DEAD && action != CPU_DEAD_FROZEN)
6217                 return NOTIFY_OK;
6218
6219         local_irq_disable();
6220         cpu = smp_processor_id();
6221         sd = &per_cpu(softnet_data, cpu);
6222         oldsd = &per_cpu(softnet_data, oldcpu);
6223
6224         /* Find end of our completion_queue. */
6225         list_skb = &sd->completion_queue;
6226         while (*list_skb)
6227                 list_skb = &(*list_skb)->next;
6228         /* Append completion queue from offline CPU. */
6229         *list_skb = oldsd->completion_queue;
6230         oldsd->completion_queue = NULL;
6231
6232         /* Append output queue from offline CPU. */
6233         if (oldsd->output_queue) {
6234                 *sd->output_queue_tailp = oldsd->output_queue;
6235                 sd->output_queue_tailp = oldsd->output_queue_tailp;
6236                 oldsd->output_queue = NULL;
6237                 oldsd->output_queue_tailp = &oldsd->output_queue;
6238         }
6239         /* Append NAPI poll list from offline CPU. */
6240         if (!list_empty(&oldsd->poll_list)) {
6241                 list_splice_init(&oldsd->poll_list, &sd->poll_list);
6242                 raise_softirq_irqoff(NET_RX_SOFTIRQ);
6243         }
6244
6245         raise_softirq_irqoff(NET_TX_SOFTIRQ);
6246         local_irq_enable();
6247
6248         /* Process offline CPU's input_pkt_queue */
6249         while ((skb = __skb_dequeue(&oldsd->process_queue))) {
6250                 netif_rx(skb);
6251                 input_queue_head_incr(oldsd);
6252         }
6253         while ((skb = __skb_dequeue(&oldsd->input_pkt_queue))) {
6254                 netif_rx(skb);
6255                 input_queue_head_incr(oldsd);
6256         }
6257
6258         return NOTIFY_OK;
6259 }
6260
6261
6262 /**
6263  *      netdev_increment_features - increment feature set by one
6264  *      @all: current feature set
6265  *      @one: new feature set
6266  *      @mask: mask feature set
6267  *
6268  *      Computes a new feature set after adding a device with feature set
6269  *      @one to the master device with current feature set @all.  Will not
6270  *      enable anything that is off in @mask. Returns the new feature set.
6271  */
6272 netdev_features_t netdev_increment_features(netdev_features_t all,
6273         netdev_features_t one, netdev_features_t mask)
6274 {
6275         if (mask & NETIF_F_GEN_CSUM)
6276                 mask |= NETIF_F_ALL_CSUM;
6277         mask |= NETIF_F_VLAN_CHALLENGED;
6278
6279         all |= one & (NETIF_F_ONE_FOR_ALL|NETIF_F_ALL_CSUM) & mask;
6280         all &= one | ~NETIF_F_ALL_FOR_ALL;
6281
6282         /* If one device supports hw checksumming, set for all. */
6283         if (all & NETIF_F_GEN_CSUM)
6284                 all &= ~(NETIF_F_ALL_CSUM & ~NETIF_F_GEN_CSUM);
6285
6286         return all;
6287 }
6288 EXPORT_SYMBOL(netdev_increment_features);
6289
6290 static struct hlist_head *netdev_create_hash(void)
6291 {
6292         int i;
6293         struct hlist_head *hash;
6294
6295         hash = kmalloc(sizeof(*hash) * NETDEV_HASHENTRIES, GFP_KERNEL);
6296         if (hash != NULL)
6297                 for (i = 0; i < NETDEV_HASHENTRIES; i++)
6298                         INIT_HLIST_HEAD(&hash[i]);
6299
6300         return hash;
6301 }
6302
6303 /* Initialize per network namespace state */
6304 static int __net_init netdev_init(struct net *net)
6305 {
6306         if (net != &init_net)
6307                 INIT_LIST_HEAD(&net->dev_base_head);
6308
6309         net->dev_name_head = netdev_create_hash();
6310         if (net->dev_name_head == NULL)
6311                 goto err_name;
6312
6313         net->dev_index_head = netdev_create_hash();
6314         if (net->dev_index_head == NULL)
6315                 goto err_idx;
6316
6317         return 0;
6318
6319 err_idx:
6320         kfree(net->dev_name_head);
6321 err_name:
6322         return -ENOMEM;
6323 }
6324
6325 /**
6326  *      netdev_drivername - network driver for the device
6327  *      @dev: network device
6328  *
6329  *      Determine network driver for device.
6330  */
6331 const char *netdev_drivername(const struct net_device *dev)
6332 {
6333         const struct device_driver *driver;
6334         const struct device *parent;
6335         const char *empty = "";
6336
6337         parent = dev->dev.parent;
6338         if (!parent)
6339                 return empty;
6340
6341         driver = parent->driver;
6342         if (driver && driver->name)
6343                 return driver->name;
6344         return empty;
6345 }
6346
6347 int __netdev_printk(const char *level, const struct net_device *dev,
6348                            struct va_format *vaf)
6349 {
6350         int r;
6351
6352         if (dev && dev->dev.parent)
6353                 r = dev_printk(level, dev->dev.parent, "%s: %pV",
6354                                netdev_name(dev), vaf);
6355         else if (dev)
6356                 r = printk("%s%s: %pV", level, netdev_name(dev), vaf);
6357         else
6358                 r = printk("%s(NULL net_device): %pV", level, vaf);
6359
6360         return r;
6361 }
6362 EXPORT_SYMBOL(__netdev_printk);
6363
6364 int netdev_printk(const char *level, const struct net_device *dev,
6365                   const char *format, ...)
6366 {
6367         struct va_format vaf;
6368         va_list args;
6369         int r;
6370
6371         va_start(args, format);
6372
6373         vaf.fmt = format;
6374         vaf.va = &args;
6375
6376         r = __netdev_printk(level, dev, &vaf);
6377         va_end(args);
6378
6379         return r;
6380 }
6381 EXPORT_SYMBOL(netdev_printk);
6382
6383 #define define_netdev_printk_level(func, level)                 \
6384 int func(const struct net_device *dev, const char *fmt, ...)    \
6385 {                                                               \
6386         int r;                                                  \
6387         struct va_format vaf;                                   \
6388         va_list args;                                           \
6389                                                                 \
6390         va_start(args, fmt);                                    \
6391                                                                 \
6392         vaf.fmt = fmt;                                          \
6393         vaf.va = &args;                                         \
6394                                                                 \
6395         r = __netdev_printk(level, dev, &vaf);                  \
6396         va_end(args);                                           \
6397                                                                 \
6398         return r;                                               \
6399 }                                                               \
6400 EXPORT_SYMBOL(func);
6401
6402 define_netdev_printk_level(netdev_emerg, KERN_EMERG);
6403 define_netdev_printk_level(netdev_alert, KERN_ALERT);
6404 define_netdev_printk_level(netdev_crit, KERN_CRIT);
6405 define_netdev_printk_level(netdev_err, KERN_ERR);
6406 define_netdev_printk_level(netdev_warn, KERN_WARNING);
6407 define_netdev_printk_level(netdev_notice, KERN_NOTICE);
6408 define_netdev_printk_level(netdev_info, KERN_INFO);
6409
6410 static void __net_exit netdev_exit(struct net *net)
6411 {
6412         kfree(net->dev_name_head);
6413         kfree(net->dev_index_head);
6414 }
6415
6416 static struct pernet_operations __net_initdata netdev_net_ops = {
6417         .init = netdev_init,
6418         .exit = netdev_exit,
6419 };
6420
6421 static void __net_exit default_device_exit(struct net *net)
6422 {
6423         struct net_device *dev, *aux;
6424         /*
6425          * Push all migratable network devices back to the
6426          * initial network namespace
6427          */
6428         rtnl_lock();
6429         for_each_netdev_safe(net, dev, aux) {
6430                 int err;
6431                 char fb_name[IFNAMSIZ];
6432
6433                 /* Ignore unmoveable devices (i.e. loopback) */
6434                 if (dev->features & NETIF_F_NETNS_LOCAL)
6435                         continue;
6436
6437                 /* Leave virtual devices for the generic cleanup */
6438                 if (dev->rtnl_link_ops)
6439                         continue;
6440
6441                 /* Push remaining network devices to init_net */
6442                 snprintf(fb_name, IFNAMSIZ, "dev%d", dev->ifindex);
6443                 err = dev_change_net_namespace(dev, &init_net, fb_name);
6444                 if (err) {
6445                         pr_emerg("%s: failed to move %s to init_net: %d\n",
6446                                  __func__, dev->name, err);
6447                         BUG();
6448                 }
6449         }
6450         rtnl_unlock();
6451 }
6452
6453 static void __net_exit default_device_exit_batch(struct list_head *net_list)
6454 {
6455         /* At exit all network devices most be removed from a network
6456          * namespace.  Do this in the reverse order of registration.
6457          * Do this across as many network namespaces as possible to
6458          * improve batching efficiency.
6459          */
6460         struct net_device *dev;
6461         struct net *net;
6462         LIST_HEAD(dev_kill_list);
6463
6464         rtnl_lock();
6465         list_for_each_entry(net, net_list, exit_list) {
6466                 for_each_netdev_reverse(net, dev) {
6467         &nb