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