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