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