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