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