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