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