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