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