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