4f2014994a847ce7066a7c8deee9d12befb9e354
[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/config.h>
80 #include <linux/cpu.h>
81 #include <linux/types.h>
82 #include <linux/kernel.h>
83 #include <linux/sched.h>
84 #include <linux/mutex.h>
85 #include <linux/string.h>
86 #include <linux/mm.h>
87 #include <linux/socket.h>
88 #include <linux/sockios.h>
89 #include <linux/errno.h>
90 #include <linux/interrupt.h>
91 #include <linux/if_ether.h>
92 #include <linux/netdevice.h>
93 #include <linux/etherdevice.h>
94 #include <linux/notifier.h>
95 #include <linux/skbuff.h>
96 #include <net/sock.h>
97 #include <linux/rtnetlink.h>
98 #include <linux/proc_fs.h>
99 #include <linux/seq_file.h>
100 #include <linux/stat.h>
101 #include <linux/if_bridge.h>
102 #include <linux/divert.h>
103 #include <net/dst.h>
104 #include <net/pkt_sched.h>
105 #include <net/checksum.h>
106 #include <linux/highmem.h>
107 #include <linux/init.h>
108 #include <linux/kmod.h>
109 #include <linux/module.h>
110 #include <linux/kallsyms.h>
111 #include <linux/netpoll.h>
112 #include <linux/rcupdate.h>
113 #include <linux/delay.h>
114 #include <linux/wireless.h>
115 #include <net/iw_handler.h>
116 #include <asm/current.h>
117 #include <linux/audit.h>
118 #include <linux/dmaengine.h>
119 #include <linux/err.h>
120
121 /*
122  *      The list of packet types we will receive (as opposed to discard)
123  *      and the routines to invoke.
124  *
125  *      Why 16. Because with 16 the only overlap we get on a hash of the
126  *      low nibble of the protocol value is RARP/SNAP/X.25.
127  *
128  *      NOTE:  That is no longer true with the addition of VLAN tags.  Not
129  *             sure which should go first, but I bet it won't make much
130  *             difference if we are running VLANs.  The good news is that
131  *             this protocol won't be in the list unless compiled in, so
132  *             the average user (w/out VLANs) will not be adversely affected.
133  *             --BLG
134  *
135  *              0800    IP
136  *              8100    802.1Q VLAN
137  *              0001    802.3
138  *              0002    AX.25
139  *              0004    802.2
140  *              8035    RARP
141  *              0005    SNAP
142  *              0805    X.25
143  *              0806    ARP
144  *              8137    IPX
145  *              0009    Localtalk
146  *              86DD    IPv6
147  */
148
149 static DEFINE_SPINLOCK(ptype_lock);
150 static struct list_head ptype_base[16]; /* 16 way hashed list */
151 static struct list_head ptype_all;              /* Taps */
152
153 #ifdef CONFIG_NET_DMA
154 static struct dma_client *net_dma_client;
155 static unsigned int net_dma_count;
156 static spinlock_t net_dma_event_lock;
157 #endif
158
159 /*
160  * The @dev_base list is protected by @dev_base_lock and the rtnl
161  * semaphore.
162  *
163  * Pure readers hold dev_base_lock for reading.
164  *
165  * Writers must hold the rtnl semaphore while they loop through the
166  * dev_base list, and hold dev_base_lock for writing when they do the
167  * actual updates.  This allows pure readers to access the list even
168  * while a writer is preparing to update it.
169  *
170  * To put it another way, dev_base_lock is held for writing only to
171  * protect against pure readers; the rtnl semaphore provides the
172  * protection against other writers.
173  *
174  * See, for example usages, register_netdevice() and
175  * unregister_netdevice(), which must be called with the rtnl
176  * semaphore held.
177  */
178 struct net_device *dev_base;
179 static struct net_device **dev_tail = &dev_base;
180 DEFINE_RWLOCK(dev_base_lock);
181
182 EXPORT_SYMBOL(dev_base);
183 EXPORT_SYMBOL(dev_base_lock);
184
185 #define NETDEV_HASHBITS 8
186 static struct hlist_head dev_name_head[1<<NETDEV_HASHBITS];
187 static struct hlist_head dev_index_head[1<<NETDEV_HASHBITS];
188
189 static inline struct hlist_head *dev_name_hash(const char *name)
190 {
191         unsigned hash = full_name_hash(name, strnlen(name, IFNAMSIZ));
192         return &dev_name_head[hash & ((1<<NETDEV_HASHBITS)-1)];
193 }
194
195 static inline struct hlist_head *dev_index_hash(int ifindex)
196 {
197         return &dev_index_head[ifindex & ((1<<NETDEV_HASHBITS)-1)];
198 }
199
200 /*
201  *      Our notifier list
202  */
203
204 static RAW_NOTIFIER_HEAD(netdev_chain);
205
206 /*
207  *      Device drivers call our routines to queue packets here. We empty the
208  *      queue in the local softnet handler.
209  */
210 DEFINE_PER_CPU(struct softnet_data, softnet_data) = { NULL };
211
212 #ifdef CONFIG_SYSFS
213 extern int netdev_sysfs_init(void);
214 extern int netdev_register_sysfs(struct net_device *);
215 extern void netdev_unregister_sysfs(struct net_device *);
216 #else
217 #define netdev_sysfs_init()             (0)
218 #define netdev_register_sysfs(dev)      (0)
219 #define netdev_unregister_sysfs(dev)    do { } while(0)
220 #endif
221
222
223 /*******************************************************************************
224
225                 Protocol management and registration routines
226
227 *******************************************************************************/
228
229 /*
230  *      For efficiency
231  */
232
233 static int netdev_nit;
234
235 /*
236  *      Add a protocol ID to the list. Now that the input handler is
237  *      smarter we can dispense with all the messy stuff that used to be
238  *      here.
239  *
240  *      BEWARE!!! Protocol handlers, mangling input packets,
241  *      MUST BE last in hash buckets and checking protocol handlers
242  *      MUST start from promiscuous ptype_all chain in net_bh.
243  *      It is true now, do not change it.
244  *      Explanation follows: if protocol handler, mangling packet, will
245  *      be the first on list, it is not able to sense, that packet
246  *      is cloned and should be copied-on-write, so that it will
247  *      change it and subsequent readers will get broken packet.
248  *                                                      --ANK (980803)
249  */
250
251 /**
252  *      dev_add_pack - add packet handler
253  *      @pt: packet type declaration
254  *
255  *      Add a protocol handler to the networking stack. The passed &packet_type
256  *      is linked into kernel lists and may not be freed until it has been
257  *      removed from the kernel lists.
258  *
259  *      This call does not sleep therefore it can not 
260  *      guarantee all CPU's that are in middle of receiving packets
261  *      will see the new packet type (until the next received packet).
262  */
263
264 void dev_add_pack(struct packet_type *pt)
265 {
266         int hash;
267
268         spin_lock_bh(&ptype_lock);
269         if (pt->type == htons(ETH_P_ALL)) {
270                 netdev_nit++;
271                 list_add_rcu(&pt->list, &ptype_all);
272         } else {
273                 hash = ntohs(pt->type) & 15;
274                 list_add_rcu(&pt->list, &ptype_base[hash]);
275         }
276         spin_unlock_bh(&ptype_lock);
277 }
278
279 /**
280  *      __dev_remove_pack        - remove packet handler
281  *      @pt: packet type declaration
282  *
283  *      Remove a protocol handler that was previously added to the kernel
284  *      protocol handlers by dev_add_pack(). The passed &packet_type is removed
285  *      from the kernel lists and can be freed or reused once this function
286  *      returns. 
287  *
288  *      The packet type might still be in use by receivers
289  *      and must not be freed until after all the CPU's have gone
290  *      through a quiescent state.
291  */
292 void __dev_remove_pack(struct packet_type *pt)
293 {
294         struct list_head *head;
295         struct packet_type *pt1;
296
297         spin_lock_bh(&ptype_lock);
298
299         if (pt->type == htons(ETH_P_ALL)) {
300                 netdev_nit--;
301                 head = &ptype_all;
302         } else
303                 head = &ptype_base[ntohs(pt->type) & 15];
304
305         list_for_each_entry(pt1, head, list) {
306                 if (pt == pt1) {
307                         list_del_rcu(&pt->list);
308                         goto out;
309                 }
310         }
311
312         printk(KERN_WARNING "dev_remove_pack: %p not found.\n", pt);
313 out:
314         spin_unlock_bh(&ptype_lock);
315 }
316 /**
317  *      dev_remove_pack  - remove packet handler
318  *      @pt: packet type declaration
319  *
320  *      Remove a protocol handler that was previously added to the kernel
321  *      protocol handlers by dev_add_pack(). The passed &packet_type is removed
322  *      from the kernel lists and can be freed or reused once this function
323  *      returns.
324  *
325  *      This call sleeps to guarantee that no CPU is looking at the packet
326  *      type after return.
327  */
328 void dev_remove_pack(struct packet_type *pt)
329 {
330         __dev_remove_pack(pt);
331         
332         synchronize_net();
333 }
334
335 /******************************************************************************
336
337                       Device Boot-time Settings Routines
338
339 *******************************************************************************/
340
341 /* Boot time configuration table */
342 static struct netdev_boot_setup dev_boot_setup[NETDEV_BOOT_SETUP_MAX];
343
344 /**
345  *      netdev_boot_setup_add   - add new setup entry
346  *      @name: name of the device
347  *      @map: configured settings for the device
348  *
349  *      Adds new setup entry to the dev_boot_setup list.  The function
350  *      returns 0 on error and 1 on success.  This is a generic routine to
351  *      all netdevices.
352  */
353 static int netdev_boot_setup_add(char *name, struct ifmap *map)
354 {
355         struct netdev_boot_setup *s;
356         int i;
357
358         s = dev_boot_setup;
359         for (i = 0; i < NETDEV_BOOT_SETUP_MAX; i++) {
360                 if (s[i].name[0] == '\0' || s[i].name[0] == ' ') {
361                         memset(s[i].name, 0, sizeof(s[i].name));
362                         strcpy(s[i].name, name);
363                         memcpy(&s[i].map, map, sizeof(s[i].map));
364                         break;
365                 }
366         }
367
368         return i >= NETDEV_BOOT_SETUP_MAX ? 0 : 1;
369 }
370
371 /**
372  *      netdev_boot_setup_check - check boot time settings
373  *      @dev: the netdevice
374  *
375  *      Check boot time settings for the device.
376  *      The found settings are set for the device to be used
377  *      later in the device probing.
378  *      Returns 0 if no settings found, 1 if they are.
379  */
380 int netdev_boot_setup_check(struct net_device *dev)
381 {
382         struct netdev_boot_setup *s = dev_boot_setup;
383         int i;
384
385         for (i = 0; i < NETDEV_BOOT_SETUP_MAX; i++) {
386                 if (s[i].name[0] != '\0' && s[i].name[0] != ' ' &&
387                     !strncmp(dev->name, s[i].name, strlen(s[i].name))) {
388                         dev->irq        = s[i].map.irq;
389                         dev->base_addr  = s[i].map.base_addr;
390                         dev->mem_start  = s[i].map.mem_start;
391                         dev->mem_end    = s[i].map.mem_end;
392                         return 1;
393                 }
394         }
395         return 0;
396 }
397
398
399 /**
400  *      netdev_boot_base        - get address from boot time settings
401  *      @prefix: prefix for network device
402  *      @unit: id for network device
403  *
404  *      Check boot time settings for the base address of device.
405  *      The found settings are set for the device to be used
406  *      later in the device probing.
407  *      Returns 0 if no settings found.
408  */
409 unsigned long netdev_boot_base(const char *prefix, int unit)
410 {
411         const struct netdev_boot_setup *s = dev_boot_setup;
412         char name[IFNAMSIZ];
413         int i;
414
415         sprintf(name, "%s%d", prefix, unit);
416
417         /*
418          * If device already registered then return base of 1
419          * to indicate not to probe for this interface
420          */
421         if (__dev_get_by_name(name))
422                 return 1;
423
424         for (i = 0; i < NETDEV_BOOT_SETUP_MAX; i++)
425                 if (!strcmp(name, s[i].name))
426                         return s[i].map.base_addr;
427         return 0;
428 }
429
430 /*
431  * Saves at boot time configured settings for any netdevice.
432  */
433 int __init netdev_boot_setup(char *str)
434 {
435         int ints[5];
436         struct ifmap map;
437
438         str = get_options(str, ARRAY_SIZE(ints), ints);
439         if (!str || !*str)
440                 return 0;
441
442         /* Save settings */
443         memset(&map, 0, sizeof(map));
444         if (ints[0] > 0)
445                 map.irq = ints[1];
446         if (ints[0] > 1)
447                 map.base_addr = ints[2];
448         if (ints[0] > 2)
449                 map.mem_start = ints[3];
450         if (ints[0] > 3)
451                 map.mem_end = ints[4];
452
453         /* Add new entry to the list */
454         return netdev_boot_setup_add(str, &map);
455 }
456
457 __setup("netdev=", netdev_boot_setup);
458
459 /*******************************************************************************
460
461                             Device Interface Subroutines
462
463 *******************************************************************************/
464
465 /**
466  *      __dev_get_by_name       - find a device by its name
467  *      @name: name to find
468  *
469  *      Find an interface by name. Must be called under RTNL semaphore
470  *      or @dev_base_lock. If the name is found a pointer to the device
471  *      is returned. If the name is not found then %NULL is returned. The
472  *      reference counters are not incremented so the caller must be
473  *      careful with locks.
474  */
475
476 struct net_device *__dev_get_by_name(const char *name)
477 {
478         struct hlist_node *p;
479
480         hlist_for_each(p, dev_name_hash(name)) {
481                 struct net_device *dev
482                         = hlist_entry(p, struct net_device, name_hlist);
483                 if (!strncmp(dev->name, name, IFNAMSIZ))
484                         return dev;
485         }
486         return NULL;
487 }
488
489 /**
490  *      dev_get_by_name         - find a device by its name
491  *      @name: name to find
492  *
493  *      Find an interface by name. This can be called from any
494  *      context and does its own locking. The returned handle has
495  *      the usage count incremented and the caller must use dev_put() to
496  *      release it when it is no longer needed. %NULL is returned if no
497  *      matching device is found.
498  */
499
500 struct net_device *dev_get_by_name(const char *name)
501 {
502         struct net_device *dev;
503
504         read_lock(&dev_base_lock);
505         dev = __dev_get_by_name(name);
506         if (dev)
507                 dev_hold(dev);
508         read_unlock(&dev_base_lock);
509         return dev;
510 }
511
512 /**
513  *      __dev_get_by_index - find a device by its ifindex
514  *      @ifindex: index of device
515  *
516  *      Search for an interface by index. Returns %NULL if the device
517  *      is not found or a pointer to the device. The device has not
518  *      had its reference counter increased so the caller must be careful
519  *      about locking. The caller must hold either the RTNL semaphore
520  *      or @dev_base_lock.
521  */
522
523 struct net_device *__dev_get_by_index(int ifindex)
524 {
525         struct hlist_node *p;
526
527         hlist_for_each(p, dev_index_hash(ifindex)) {
528                 struct net_device *dev
529                         = hlist_entry(p, struct net_device, index_hlist);
530                 if (dev->ifindex == ifindex)
531                         return dev;
532         }
533         return NULL;
534 }
535
536
537 /**
538  *      dev_get_by_index - find a device by its ifindex
539  *      @ifindex: index of device
540  *
541  *      Search for an interface by index. Returns NULL if the device
542  *      is not found or a pointer to the device. The device returned has
543  *      had a reference added and the pointer is safe until the user calls
544  *      dev_put to indicate they have finished with it.
545  */
546
547 struct net_device *dev_get_by_index(int ifindex)
548 {
549         struct net_device *dev;
550
551         read_lock(&dev_base_lock);
552         dev = __dev_get_by_index(ifindex);
553         if (dev)
554                 dev_hold(dev);
555         read_unlock(&dev_base_lock);
556         return dev;
557 }
558
559 /**
560  *      dev_getbyhwaddr - find a device by its hardware address
561  *      @type: media type of device
562  *      @ha: hardware address
563  *
564  *      Search for an interface by MAC address. Returns NULL if the device
565  *      is not found or a pointer to the device. The caller must hold the
566  *      rtnl semaphore. The returned device has not had its ref count increased
567  *      and the caller must therefore be careful about locking
568  *
569  *      BUGS:
570  *      If the API was consistent this would be __dev_get_by_hwaddr
571  */
572
573 struct net_device *dev_getbyhwaddr(unsigned short type, char *ha)
574 {
575         struct net_device *dev;
576
577         ASSERT_RTNL();
578
579         for (dev = dev_base; dev; dev = dev->next)
580                 if (dev->type == type &&
581                     !memcmp(dev->dev_addr, ha, dev->addr_len))
582                         break;
583         return dev;
584 }
585
586 EXPORT_SYMBOL(dev_getbyhwaddr);
587
588 struct net_device *dev_getfirstbyhwtype(unsigned short type)
589 {
590         struct net_device *dev;
591
592         rtnl_lock();
593         for (dev = dev_base; dev; dev = dev->next) {
594                 if (dev->type == type) {
595                         dev_hold(dev);
596                         break;
597                 }
598         }
599         rtnl_unlock();
600         return dev;
601 }
602
603 EXPORT_SYMBOL(dev_getfirstbyhwtype);
604
605 /**
606  *      dev_get_by_flags - find any device with given flags
607  *      @if_flags: IFF_* values
608  *      @mask: bitmask of bits in if_flags to check
609  *
610  *      Search for any interface with the given flags. Returns NULL if a device
611  *      is not found or a pointer to the device. The device returned has 
612  *      had a reference added and the pointer is safe until the user calls
613  *      dev_put to indicate they have finished with it.
614  */
615
616 struct net_device * dev_get_by_flags(unsigned short if_flags, unsigned short mask)
617 {
618         struct net_device *dev;
619
620         read_lock(&dev_base_lock);
621         for (dev = dev_base; dev != NULL; dev = dev->next) {
622                 if (((dev->flags ^ if_flags) & mask) == 0) {
623                         dev_hold(dev);
624                         break;
625                 }
626         }
627         read_unlock(&dev_base_lock);
628         return dev;
629 }
630
631 /**
632  *      dev_valid_name - check if name is okay for network device
633  *      @name: name string
634  *
635  *      Network device names need to be valid file names to
636  *      to allow sysfs to work
637  */
638 int dev_valid_name(const char *name)
639 {
640         return !(*name == '\0' 
641                  || !strcmp(name, ".")
642                  || !strcmp(name, "..")
643                  || strchr(name, '/'));
644 }
645
646 /**
647  *      dev_alloc_name - allocate a name for a device
648  *      @dev: device
649  *      @name: name format string
650  *
651  *      Passed a format string - eg "lt%d" it will try and find a suitable
652  *      id. It scans list of devices to build up a free map, then chooses
653  *      the first empty slot. The caller must hold the dev_base or rtnl lock
654  *      while allocating the name and adding the device in order to avoid
655  *      duplicates.
656  *      Limited to bits_per_byte * page size devices (ie 32K on most platforms).
657  *      Returns the number of the unit assigned or a negative errno code.
658  */
659
660 int dev_alloc_name(struct net_device *dev, const char *name)
661 {
662         int i = 0;
663         char buf[IFNAMSIZ];
664         const char *p;
665         const int max_netdevices = 8*PAGE_SIZE;
666         long *inuse;
667         struct net_device *d;
668
669         p = strnchr(name, IFNAMSIZ-1, '%');
670         if (p) {
671                 /*
672                  * Verify the string as this thing may have come from
673                  * the user.  There must be either one "%d" and no other "%"
674                  * characters.
675                  */
676                 if (p[1] != 'd' || strchr(p + 2, '%'))
677                         return -EINVAL;
678
679                 /* Use one page as a bit array of possible slots */
680                 inuse = (long *) get_zeroed_page(GFP_ATOMIC);
681                 if (!inuse)
682                         return -ENOMEM;
683
684                 for (d = dev_base; d; d = d->next) {
685                         if (!sscanf(d->name, name, &i))
686                                 continue;
687                         if (i < 0 || i >= max_netdevices)
688                                 continue;
689
690                         /*  avoid cases where sscanf is not exact inverse of printf */
691                         snprintf(buf, sizeof(buf), name, i);
692                         if (!strncmp(buf, d->name, IFNAMSIZ))
693                                 set_bit(i, inuse);
694                 }
695
696                 i = find_first_zero_bit(inuse, max_netdevices);
697                 free_page((unsigned long) inuse);
698         }
699
700         snprintf(buf, sizeof(buf), name, i);
701         if (!__dev_get_by_name(buf)) {
702                 strlcpy(dev->name, buf, IFNAMSIZ);
703                 return i;
704         }
705
706         /* It is possible to run out of possible slots
707          * when the name is long and there isn't enough space left
708          * for the digits, or if all bits are used.
709          */
710         return -ENFILE;
711 }
712
713
714 /**
715  *      dev_change_name - change name of a device
716  *      @dev: device
717  *      @newname: name (or format string) must be at least IFNAMSIZ
718  *
719  *      Change name of a device, can pass format strings "eth%d".
720  *      for wildcarding.
721  */
722 int dev_change_name(struct net_device *dev, char *newname)
723 {
724         int err = 0;
725
726         ASSERT_RTNL();
727
728         if (dev->flags & IFF_UP)
729                 return -EBUSY;
730
731         if (!dev_valid_name(newname))
732                 return -EINVAL;
733
734         if (strchr(newname, '%')) {
735                 err = dev_alloc_name(dev, newname);
736                 if (err < 0)
737                         return err;
738                 strcpy(newname, dev->name);
739         }
740         else if (__dev_get_by_name(newname))
741                 return -EEXIST;
742         else
743                 strlcpy(dev->name, newname, IFNAMSIZ);
744
745         err = class_device_rename(&dev->class_dev, dev->name);
746         if (!err) {
747                 hlist_del(&dev->name_hlist);
748                 hlist_add_head(&dev->name_hlist, dev_name_hash(dev->name));
749                 raw_notifier_call_chain(&netdev_chain,
750                                 NETDEV_CHANGENAME, dev);
751         }
752
753         return err;
754 }
755
756 /**
757  *      netdev_features_change - device changes features
758  *      @dev: device to cause notification
759  *
760  *      Called to indicate a device has changed features.
761  */
762 void netdev_features_change(struct net_device *dev)
763 {
764         raw_notifier_call_chain(&netdev_chain, NETDEV_FEAT_CHANGE, dev);
765 }
766 EXPORT_SYMBOL(netdev_features_change);
767
768 /**
769  *      netdev_state_change - device changes state
770  *      @dev: device to cause notification
771  *
772  *      Called to indicate a device has changed state. This function calls
773  *      the notifier chains for netdev_chain and sends a NEWLINK message
774  *      to the routing socket.
775  */
776 void netdev_state_change(struct net_device *dev)
777 {
778         if (dev->flags & IFF_UP) {
779                 raw_notifier_call_chain(&netdev_chain,
780                                 NETDEV_CHANGE, dev);
781                 rtmsg_ifinfo(RTM_NEWLINK, dev, 0);
782         }
783 }
784
785 /**
786  *      dev_load        - load a network module
787  *      @name: name of interface
788  *
789  *      If a network interface is not present and the process has suitable
790  *      privileges this function loads the module. If module loading is not
791  *      available in this kernel then it becomes a nop.
792  */
793
794 void dev_load(const char *name)
795 {
796         struct net_device *dev;  
797
798         read_lock(&dev_base_lock);
799         dev = __dev_get_by_name(name);
800         read_unlock(&dev_base_lock);
801
802         if (!dev && capable(CAP_SYS_MODULE))
803                 request_module("%s", name);
804 }
805
806 static int default_rebuild_header(struct sk_buff *skb)
807 {
808         printk(KERN_DEBUG "%s: default_rebuild_header called -- BUG!\n",
809                skb->dev ? skb->dev->name : "NULL!!!");
810         kfree_skb(skb);
811         return 1;
812 }
813
814
815 /**
816  *      dev_open        - prepare an interface for use.
817  *      @dev:   device to open
818  *
819  *      Takes a device from down to up state. The device's private open
820  *      function is invoked and then the multicast lists are loaded. Finally
821  *      the device is moved into the up state and a %NETDEV_UP message is
822  *      sent to the netdev notifier chain.
823  *
824  *      Calling this function on an active interface is a nop. On a failure
825  *      a negative errno code is returned.
826  */
827 int dev_open(struct net_device *dev)
828 {
829         int ret = 0;
830
831         /*
832          *      Is it already up?
833          */
834
835         if (dev->flags & IFF_UP)
836                 return 0;
837
838         /*
839          *      Is it even present?
840          */
841         if (!netif_device_present(dev))
842                 return -ENODEV;
843
844         /*
845          *      Call device private open method
846          */
847         set_bit(__LINK_STATE_START, &dev->state);
848         if (dev->open) {
849                 ret = dev->open(dev);
850                 if (ret)
851                         clear_bit(__LINK_STATE_START, &dev->state);
852         }
853
854         /*
855          *      If it went open OK then:
856          */
857
858         if (!ret) {
859                 /*
860                  *      Set the flags.
861                  */
862                 dev->flags |= IFF_UP;
863
864                 /*
865                  *      Initialize multicasting status
866                  */
867                 dev_mc_upload(dev);
868
869                 /*
870                  *      Wakeup transmit queue engine
871                  */
872                 dev_activate(dev);
873
874                 /*
875                  *      ... and announce new interface.
876                  */
877                 raw_notifier_call_chain(&netdev_chain, NETDEV_UP, dev);
878         }
879         return ret;
880 }
881
882 /**
883  *      dev_close - shutdown an interface.
884  *      @dev: device to shutdown
885  *
886  *      This function moves an active device into down state. A
887  *      %NETDEV_GOING_DOWN is sent to the netdev notifier chain. The device
888  *      is then deactivated and finally a %NETDEV_DOWN is sent to the notifier
889  *      chain.
890  */
891 int dev_close(struct net_device *dev)
892 {
893         if (!(dev->flags & IFF_UP))
894                 return 0;
895
896         /*
897          *      Tell people we are going down, so that they can
898          *      prepare to death, when device is still operating.
899          */
900         raw_notifier_call_chain(&netdev_chain, NETDEV_GOING_DOWN, dev);
901
902         dev_deactivate(dev);
903
904         clear_bit(__LINK_STATE_START, &dev->state);
905
906         /* Synchronize to scheduled poll. We cannot touch poll list,
907          * it can be even on different cpu. So just clear netif_running(),
908          * and wait when poll really will happen. Actually, the best place
909          * for this is inside dev->stop() after device stopped its irq
910          * engine, but this requires more changes in devices. */
911
912         smp_mb__after_clear_bit(); /* Commit netif_running(). */
913         while (test_bit(__LINK_STATE_RX_SCHED, &dev->state)) {
914                 /* No hurry. */
915                 msleep(1);
916         }
917
918         /*
919          *      Call the device specific close. This cannot fail.
920          *      Only if device is UP
921          *
922          *      We allow it to be called even after a DETACH hot-plug
923          *      event.
924          */
925         if (dev->stop)
926                 dev->stop(dev);
927
928         /*
929          *      Device is now down.
930          */
931
932         dev->flags &= ~IFF_UP;
933
934         /*
935          * Tell people we are down
936          */
937         raw_notifier_call_chain(&netdev_chain, NETDEV_DOWN, dev);
938
939         return 0;
940 }
941
942
943 /*
944  *      Device change register/unregister. These are not inline or static
945  *      as we export them to the world.
946  */
947
948 /**
949  *      register_netdevice_notifier - register a network notifier block
950  *      @nb: notifier
951  *
952  *      Register a notifier to be called when network device events occur.
953  *      The notifier passed is linked into the kernel structures and must
954  *      not be reused until it has been unregistered. A negative errno code
955  *      is returned on a failure.
956  *
957  *      When registered all registration and up events are replayed
958  *      to the new notifier to allow device to have a race free 
959  *      view of the network device list.
960  */
961
962 int register_netdevice_notifier(struct notifier_block *nb)
963 {
964         struct net_device *dev;
965         int err;
966
967         rtnl_lock();
968         err = raw_notifier_chain_register(&netdev_chain, nb);
969         if (!err) {
970                 for (dev = dev_base; dev; dev = dev->next) {
971                         nb->notifier_call(nb, NETDEV_REGISTER, dev);
972
973                         if (dev->flags & IFF_UP) 
974                                 nb->notifier_call(nb, NETDEV_UP, dev);
975                 }
976         }
977         rtnl_unlock();
978         return err;
979 }
980
981 /**
982  *      unregister_netdevice_notifier - unregister a network notifier block
983  *      @nb: notifier
984  *
985  *      Unregister a notifier previously registered by
986  *      register_netdevice_notifier(). The notifier is unlinked into the
987  *      kernel structures and may then be reused. A negative errno code
988  *      is returned on a failure.
989  */
990
991 int unregister_netdevice_notifier(struct notifier_block *nb)
992 {
993         int err;
994
995         rtnl_lock();
996         err = raw_notifier_chain_unregister(&netdev_chain, nb);
997         rtnl_unlock();
998         return err;
999 }
1000
1001 /**
1002  *      call_netdevice_notifiers - call all network notifier blocks
1003  *      @val: value passed unmodified to notifier function
1004  *      @v:   pointer passed unmodified to notifier function
1005  *
1006  *      Call all network notifier blocks.  Parameters and return value
1007  *      are as for raw_notifier_call_chain().
1008  */
1009
1010 int call_netdevice_notifiers(unsigned long val, void *v)
1011 {
1012         return raw_notifier_call_chain(&netdev_chain, val, v);
1013 }
1014
1015 /* When > 0 there are consumers of rx skb time stamps */
1016 static atomic_t netstamp_needed = ATOMIC_INIT(0);
1017
1018 void net_enable_timestamp(void)
1019 {
1020         atomic_inc(&netstamp_needed);
1021 }
1022
1023 void net_disable_timestamp(void)
1024 {
1025         atomic_dec(&netstamp_needed);
1026 }
1027
1028 void __net_timestamp(struct sk_buff *skb)
1029 {
1030         struct timeval tv;
1031
1032         do_gettimeofday(&tv);
1033         skb_set_timestamp(skb, &tv);
1034 }
1035 EXPORT_SYMBOL(__net_timestamp);
1036
1037 static inline void net_timestamp(struct sk_buff *skb)
1038 {
1039         if (atomic_read(&netstamp_needed))
1040                 __net_timestamp(skb);
1041         else {
1042                 skb->tstamp.off_sec = 0;
1043                 skb->tstamp.off_usec = 0;
1044         }
1045 }
1046
1047 /*
1048  *      Support routine. Sends outgoing frames to any network
1049  *      taps currently in use.
1050  */
1051
1052 static void dev_queue_xmit_nit(struct sk_buff *skb, struct net_device *dev)
1053 {
1054         struct packet_type *ptype;
1055
1056         net_timestamp(skb);
1057
1058         rcu_read_lock();
1059         list_for_each_entry_rcu(ptype, &ptype_all, list) {
1060                 /* Never send packets back to the socket
1061                  * they originated from - MvS (miquels@drinkel.ow.org)
1062                  */
1063                 if ((ptype->dev == dev || !ptype->dev) &&
1064                     (ptype->af_packet_priv == NULL ||
1065                      (struct sock *)ptype->af_packet_priv != skb->sk)) {
1066                         struct sk_buff *skb2= skb_clone(skb, GFP_ATOMIC);
1067                         if (!skb2)
1068                                 break;
1069
1070                         /* skb->nh should be correctly
1071                            set by sender, so that the second statement is
1072                            just protection against buggy protocols.
1073                          */
1074                         skb2->mac.raw = skb2->data;
1075
1076                         if (skb2->nh.raw < skb2->data ||
1077                             skb2->nh.raw > skb2->tail) {
1078                                 if (net_ratelimit())
1079                                         printk(KERN_CRIT "protocol %04x is "
1080                                                "buggy, dev %s\n",
1081                                                skb2->protocol, dev->name);
1082                                 skb2->nh.raw = skb2->data;
1083                         }
1084
1085                         skb2->h.raw = skb2->nh.raw;
1086                         skb2->pkt_type = PACKET_OUTGOING;
1087                         ptype->func(skb2, skb->dev, ptype, skb->dev);
1088                 }
1089         }
1090         rcu_read_unlock();
1091 }
1092
1093
1094 void __netif_schedule(struct net_device *dev)
1095 {
1096         if (!test_and_set_bit(__LINK_STATE_SCHED, &dev->state)) {
1097                 unsigned long flags;
1098                 struct softnet_data *sd;
1099
1100                 local_irq_save(flags);
1101                 sd = &__get_cpu_var(softnet_data);
1102                 dev->next_sched = sd->output_queue;
1103                 sd->output_queue = dev;
1104                 raise_softirq_irqoff(NET_TX_SOFTIRQ);
1105                 local_irq_restore(flags);
1106         }
1107 }
1108 EXPORT_SYMBOL(__netif_schedule);
1109
1110 void __netif_rx_schedule(struct net_device *dev)
1111 {
1112         unsigned long flags;
1113
1114         local_irq_save(flags);
1115         dev_hold(dev);
1116         list_add_tail(&dev->poll_list, &__get_cpu_var(softnet_data).poll_list);
1117         if (dev->quota < 0)
1118                 dev->quota += dev->weight;
1119         else
1120                 dev->quota = dev->weight;
1121         __raise_softirq_irqoff(NET_RX_SOFTIRQ);
1122         local_irq_restore(flags);
1123 }
1124 EXPORT_SYMBOL(__netif_rx_schedule);
1125
1126 void dev_kfree_skb_any(struct sk_buff *skb)
1127 {
1128         if (in_irq() || irqs_disabled())
1129                 dev_kfree_skb_irq(skb);
1130         else
1131                 dev_kfree_skb(skb);
1132 }
1133 EXPORT_SYMBOL(dev_kfree_skb_any);
1134
1135
1136 /* Hot-plugging. */
1137 void netif_device_detach(struct net_device *dev)
1138 {
1139         if (test_and_clear_bit(__LINK_STATE_PRESENT, &dev->state) &&
1140             netif_running(dev)) {
1141                 netif_stop_queue(dev);
1142         }
1143 }
1144 EXPORT_SYMBOL(netif_device_detach);
1145
1146 void netif_device_attach(struct net_device *dev)
1147 {
1148         if (!test_and_set_bit(__LINK_STATE_PRESENT, &dev->state) &&
1149             netif_running(dev)) {
1150                 netif_wake_queue(dev);
1151                 __netdev_watchdog_up(dev);
1152         }
1153 }
1154 EXPORT_SYMBOL(netif_device_attach);
1155
1156
1157 /*
1158  * Invalidate hardware checksum when packet is to be mangled, and
1159  * complete checksum manually on outgoing path.
1160  */
1161 int skb_checksum_help(struct sk_buff *skb, int inward)
1162 {
1163         unsigned int csum;
1164         int ret = 0, offset = skb->h.raw - skb->data;
1165
1166         if (inward) {
1167                 skb->ip_summed = CHECKSUM_NONE;
1168                 goto out;
1169         }
1170
1171         if (skb_cloned(skb)) {
1172                 ret = pskb_expand_head(skb, 0, 0, GFP_ATOMIC);
1173                 if (ret)
1174                         goto out;
1175         }
1176
1177         BUG_ON(offset > (int)skb->len);
1178         csum = skb_checksum(skb, offset, skb->len-offset, 0);
1179
1180         offset = skb->tail - skb->h.raw;
1181         BUG_ON(offset <= 0);
1182         BUG_ON(skb->csum + 2 > offset);
1183
1184         *(u16*)(skb->h.raw + skb->csum) = csum_fold(csum);
1185         skb->ip_summed = CHECKSUM_NONE;
1186 out:    
1187         return ret;
1188 }
1189
1190 /**
1191  *      skb_gso_segment - Perform segmentation on skb.
1192  *      @skb: buffer to segment
1193  *      @features: features for the output path (see dev->features)
1194  *
1195  *      This function segments the given skb and returns a list of segments.
1196  *
1197  *      It may return NULL if the skb requires no segmentation.  This is
1198  *      only possible when GSO is used for verifying header integrity.
1199  */
1200 struct sk_buff *skb_gso_segment(struct sk_buff *skb, int features)
1201 {
1202         struct sk_buff *segs = ERR_PTR(-EPROTONOSUPPORT);
1203         struct packet_type *ptype;
1204         int type = skb->protocol;
1205
1206         BUG_ON(skb_shinfo(skb)->frag_list);
1207         BUG_ON(skb->ip_summed != CHECKSUM_HW);
1208
1209         skb->mac.raw = skb->data;
1210         skb->mac_len = skb->nh.raw - skb->data;
1211         __skb_pull(skb, skb->mac_len);
1212
1213         rcu_read_lock();
1214         list_for_each_entry_rcu(ptype, &ptype_base[ntohs(type) & 15], list) {
1215                 if (ptype->type == type && !ptype->dev && ptype->gso_segment) {
1216                         segs = ptype->gso_segment(skb, features);
1217                         break;
1218                 }
1219         }
1220         rcu_read_unlock();
1221
1222         __skb_push(skb, skb->data - skb->mac.raw);
1223
1224         return segs;
1225 }
1226
1227 EXPORT_SYMBOL(skb_gso_segment);
1228
1229 /* Take action when hardware reception checksum errors are detected. */
1230 #ifdef CONFIG_BUG
1231 void netdev_rx_csum_fault(struct net_device *dev)
1232 {
1233         if (net_ratelimit()) {
1234                 printk(KERN_ERR "%s: hw csum failure.\n", 
1235                         dev ? dev->name : "<unknown>");
1236                 dump_stack();
1237         }
1238 }
1239 EXPORT_SYMBOL(netdev_rx_csum_fault);
1240 #endif
1241
1242 #ifdef CONFIG_HIGHMEM
1243 /* Actually, we should eliminate this check as soon as we know, that:
1244  * 1. IOMMU is present and allows to map all the memory.
1245  * 2. No high memory really exists on this machine.
1246  */
1247
1248 static inline int illegal_highdma(struct net_device *dev, struct sk_buff *skb)
1249 {
1250         int i;
1251
1252         if (dev->features & NETIF_F_HIGHDMA)
1253                 return 0;
1254
1255         for (i = 0; i < skb_shinfo(skb)->nr_frags; i++)
1256                 if (PageHighMem(skb_shinfo(skb)->frags[i].page))
1257                         return 1;
1258
1259         return 0;
1260 }
1261 #else
1262 #define illegal_highdma(dev, skb)       (0)
1263 #endif
1264
1265 struct dev_gso_cb {
1266         void (*destructor)(struct sk_buff *skb);
1267 };
1268
1269 #define DEV_GSO_CB(skb) ((struct dev_gso_cb *)(skb)->cb)
1270
1271 static void dev_gso_skb_destructor(struct sk_buff *skb)
1272 {
1273         struct dev_gso_cb *cb;
1274
1275         do {
1276                 struct sk_buff *nskb = skb->next;
1277
1278                 skb->next = nskb->next;
1279                 nskb->next = NULL;
1280                 kfree_skb(nskb);
1281         } while (skb->next);
1282
1283         cb = DEV_GSO_CB(skb);
1284         if (cb->destructor)
1285                 cb->destructor(skb);
1286 }
1287
1288 /**
1289  *      dev_gso_segment - Perform emulated hardware segmentation on skb.
1290  *      @skb: buffer to segment
1291  *
1292  *      This function segments the given skb and stores the list of segments
1293  *      in skb->next.
1294  */
1295 static int dev_gso_segment(struct sk_buff *skb)
1296 {
1297         struct net_device *dev = skb->dev;
1298         struct sk_buff *segs;
1299         int features = dev->features & ~(illegal_highdma(dev, skb) ?
1300                                          NETIF_F_SG : 0);
1301
1302         segs = skb_gso_segment(skb, features);
1303
1304         /* Verifying header integrity only. */
1305         if (!segs)
1306                 return 0;
1307
1308         if (unlikely(IS_ERR(segs)))
1309                 return PTR_ERR(segs);
1310
1311         skb->next = segs;
1312         DEV_GSO_CB(skb)->destructor = skb->destructor;
1313         skb->destructor = dev_gso_skb_destructor;
1314
1315         return 0;
1316 }
1317
1318 int dev_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
1319 {
1320         if (likely(!skb->next)) {
1321                 if (netdev_nit)
1322                         dev_queue_xmit_nit(skb, dev);
1323
1324                 if (netif_needs_gso(dev, skb)) {
1325                         if (unlikely(dev_gso_segment(skb)))
1326                                 goto out_kfree_skb;
1327                         if (skb->next)
1328                                 goto gso;
1329                 }
1330
1331                 return dev->hard_start_xmit(skb, dev);
1332         }
1333
1334 gso:
1335         do {
1336                 struct sk_buff *nskb = skb->next;
1337                 int rc;
1338
1339                 skb->next = nskb->next;
1340                 nskb->next = NULL;
1341                 rc = dev->hard_start_xmit(nskb, dev);
1342                 if (unlikely(rc)) {
1343                         nskb->next = skb->next;
1344                         skb->next = nskb;
1345                         return rc;
1346                 }
1347                 if (unlikely(netif_queue_stopped(dev) && skb->next))
1348                         return NETDEV_TX_BUSY;
1349         } while (skb->next);
1350         
1351         skb->destructor = DEV_GSO_CB(skb)->destructor;
1352
1353 out_kfree_skb:
1354         kfree_skb(skb);
1355         return 0;
1356 }
1357
1358 #define HARD_TX_LOCK(dev, cpu) {                        \
1359         if ((dev->features & NETIF_F_LLTX) == 0) {      \
1360                 netif_tx_lock(dev);                     \
1361         }                                               \
1362 }
1363
1364 #define HARD_TX_UNLOCK(dev) {                           \
1365         if ((dev->features & NETIF_F_LLTX) == 0) {      \
1366                 netif_tx_unlock(dev);                   \
1367         }                                               \
1368 }
1369
1370 /**
1371  *      dev_queue_xmit - transmit a buffer
1372  *      @skb: buffer to transmit
1373  *
1374  *      Queue a buffer for transmission to a network device. The caller must
1375  *      have set the device and priority and built the buffer before calling
1376  *      this function. The function can be called from an interrupt.
1377  *
1378  *      A negative errno code is returned on a failure. A success does not
1379  *      guarantee the frame will be transmitted as it may be dropped due
1380  *      to congestion or traffic shaping.
1381  *
1382  * -----------------------------------------------------------------------------------
1383  *      I notice this method can also return errors from the queue disciplines,
1384  *      including NET_XMIT_DROP, which is a positive value.  So, errors can also
1385  *      be positive.
1386  *
1387  *      Regardless of the return value, the skb is consumed, so it is currently
1388  *      difficult to retry a send to this method.  (You can bump the ref count
1389  *      before sending to hold a reference for retry if you are careful.)
1390  *
1391  *      When calling this method, interrupts MUST be enabled.  This is because
1392  *      the BH enable code must have IRQs enabled so that it will not deadlock.
1393  *          --BLG
1394  */
1395
1396 int dev_queue_xmit(struct sk_buff *skb)
1397 {
1398         struct net_device *dev = skb->dev;
1399         struct Qdisc *q;
1400         int rc = -ENOMEM;
1401
1402         /* GSO will handle the following emulations directly. */
1403         if (netif_needs_gso(dev, skb))
1404                 goto gso;
1405
1406         if (skb_shinfo(skb)->frag_list &&
1407             !(dev->features & NETIF_F_FRAGLIST) &&
1408             __skb_linearize(skb))
1409                 goto out_kfree_skb;
1410
1411         /* Fragmented skb is linearized if device does not support SG,
1412          * or if at least one of fragments is in highmem and device
1413          * does not support DMA from it.
1414          */
1415         if (skb_shinfo(skb)->nr_frags &&
1416             (!(dev->features & NETIF_F_SG) || illegal_highdma(dev, skb)) &&
1417             __skb_linearize(skb))
1418                 goto out_kfree_skb;
1419
1420         /* If packet is not checksummed and device does not support
1421          * checksumming for this protocol, complete checksumming here.
1422          */
1423         if (skb->ip_summed == CHECKSUM_HW &&
1424             (!(dev->features & NETIF_F_GEN_CSUM) &&
1425              (!(dev->features & NETIF_F_IP_CSUM) ||
1426               skb->protocol != htons(ETH_P_IP))))
1427                 if (skb_checksum_help(skb, 0))
1428                         goto out_kfree_skb;
1429
1430 gso:
1431         spin_lock_prefetch(&dev->queue_lock);
1432
1433         /* Disable soft irqs for various locks below. Also 
1434          * stops preemption for RCU. 
1435          */
1436         rcu_read_lock_bh(); 
1437
1438         /* Updates of qdisc are serialized by queue_lock. 
1439          * The struct Qdisc which is pointed to by qdisc is now a 
1440          * rcu structure - it may be accessed without acquiring 
1441          * a lock (but the structure may be stale.) The freeing of the
1442          * qdisc will be deferred until it's known that there are no 
1443          * more references to it.
1444          * 
1445          * If the qdisc has an enqueue function, we still need to 
1446          * hold the queue_lock before calling it, since queue_lock
1447          * also serializes access to the device queue.
1448          */
1449
1450         q = rcu_dereference(dev->qdisc);
1451 #ifdef CONFIG_NET_CLS_ACT
1452         skb->tc_verd = SET_TC_AT(skb->tc_verd,AT_EGRESS);
1453 #endif
1454         if (q->enqueue) {
1455                 /* Grab device queue */
1456                 spin_lock(&dev->queue_lock);
1457
1458                 rc = q->enqueue(skb, q);
1459
1460                 qdisc_run(dev);
1461
1462                 spin_unlock(&dev->queue_lock);
1463                 rc = rc == NET_XMIT_BYPASS ? NET_XMIT_SUCCESS : rc;
1464                 goto out;
1465         }
1466
1467         /* The device has no queue. Common case for software devices:
1468            loopback, all the sorts of tunnels...
1469
1470            Really, it is unlikely that netif_tx_lock protection is necessary
1471            here.  (f.e. loopback and IP tunnels are clean ignoring statistics
1472            counters.)
1473            However, it is possible, that they rely on protection
1474            made by us here.
1475
1476            Check this and shot the lock. It is not prone from deadlocks.
1477            Either shot noqueue qdisc, it is even simpler 8)
1478          */
1479         if (dev->flags & IFF_UP) {
1480                 int cpu = smp_processor_id(); /* ok because BHs are off */
1481
1482                 if (dev->xmit_lock_owner != cpu) {
1483
1484                         HARD_TX_LOCK(dev, cpu);
1485
1486                         if (!netif_queue_stopped(dev)) {
1487                                 rc = 0;
1488                                 if (!dev_hard_start_xmit(skb, dev)) {
1489                                         HARD_TX_UNLOCK(dev);
1490                                         goto out;
1491                                 }
1492                         }
1493                         HARD_TX_UNLOCK(dev);
1494                         if (net_ratelimit())
1495                                 printk(KERN_CRIT "Virtual device %s asks to "
1496                                        "queue packet!\n", dev->name);
1497                 } else {
1498                         /* Recursion is detected! It is possible,
1499                          * unfortunately */
1500                         if (net_ratelimit())
1501                                 printk(KERN_CRIT "Dead loop on virtual device "
1502                                        "%s, fix it urgently!\n", dev->name);
1503                 }
1504         }
1505
1506         rc = -ENETDOWN;
1507         rcu_read_unlock_bh();
1508
1509 out_kfree_skb:
1510         kfree_skb(skb);
1511         return rc;
1512 out:
1513         rcu_read_unlock_bh();
1514         return rc;
1515 }
1516
1517
1518 /*=======================================================================
1519                         Receiver routines
1520   =======================================================================*/
1521
1522 int netdev_max_backlog = 1000;
1523 int netdev_budget = 300;
1524 int weight_p = 64;            /* old backlog weight */
1525
1526 DEFINE_PER_CPU(struct netif_rx_stats, netdev_rx_stat) = { 0, };
1527
1528
1529 /**
1530  *      netif_rx        -       post buffer to the network code
1531  *      @skb: buffer to post
1532  *
1533  *      This function receives a packet from a device driver and queues it for
1534  *      the upper (protocol) levels to process.  It always succeeds. The buffer
1535  *      may be dropped during processing for congestion control or by the
1536  *      protocol layers.
1537  *
1538  *      return values:
1539  *      NET_RX_SUCCESS  (no congestion)
1540  *      NET_RX_CN_LOW   (low congestion)
1541  *      NET_RX_CN_MOD   (moderate congestion)
1542  *      NET_RX_CN_HIGH  (high congestion)
1543  *      NET_RX_DROP     (packet was dropped)
1544  *
1545  */
1546
1547 int netif_rx(struct sk_buff *skb)
1548 {
1549         struct softnet_data *queue;
1550         unsigned long flags;
1551
1552         /* if netpoll wants it, pretend we never saw it */
1553         if (netpoll_rx(skb))
1554                 return NET_RX_DROP;
1555
1556         if (!skb->tstamp.off_sec)
1557                 net_timestamp(skb);
1558
1559         /*
1560          * The code is rearranged so that the path is the most
1561          * short when CPU is congested, but is still operating.
1562          */
1563         local_irq_save(flags);
1564         queue = &__get_cpu_var(softnet_data);
1565
1566         __get_cpu_var(netdev_rx_stat).total++;
1567         if (queue->input_pkt_queue.qlen <= netdev_max_backlog) {
1568                 if (queue->input_pkt_queue.qlen) {
1569 enqueue:
1570                         dev_hold(skb->dev);
1571                         __skb_queue_tail(&queue->input_pkt_queue, skb);
1572                         local_irq_restore(flags);
1573                         return NET_RX_SUCCESS;
1574                 }
1575
1576                 netif_rx_schedule(&queue->backlog_dev);
1577                 goto enqueue;
1578         }
1579
1580         __get_cpu_var(netdev_rx_stat).dropped++;
1581         local_irq_restore(flags);
1582
1583         kfree_skb(skb);
1584         return NET_RX_DROP;
1585 }
1586
1587 int netif_rx_ni(struct sk_buff *skb)
1588 {
1589         int err;
1590
1591         preempt_disable();
1592         err = netif_rx(skb);
1593         if (local_softirq_pending())
1594                 do_softirq();
1595         preempt_enable();
1596
1597         return err;
1598 }
1599
1600 EXPORT_SYMBOL(netif_rx_ni);
1601
1602 static inline struct net_device *skb_bond(struct sk_buff *skb)
1603 {
1604         struct net_device *dev = skb->dev;
1605
1606         if (dev->master) {
1607                 /*
1608                  * On bonding slaves other than the currently active
1609                  * slave, suppress duplicates except for 802.3ad
1610                  * ETH_P_SLOW and alb non-mcast/bcast.
1611                  */
1612                 if (dev->priv_flags & IFF_SLAVE_INACTIVE) {
1613                         if (dev->master->priv_flags & IFF_MASTER_ALB) {
1614                                 if (skb->pkt_type != PACKET_BROADCAST &&
1615                                     skb->pkt_type != PACKET_MULTICAST)
1616                                         goto keep;
1617                         }
1618
1619                         if (dev->master->priv_flags & IFF_MASTER_8023AD &&
1620                             skb->protocol == __constant_htons(ETH_P_SLOW))
1621                                 goto keep;
1622                 
1623                         kfree_skb(skb);
1624                         return NULL;
1625                 }
1626 keep:
1627                 skb->dev = dev->master;
1628         }
1629
1630         return dev;
1631 }
1632
1633 static void net_tx_action(struct softirq_action *h)
1634 {
1635         struct softnet_data *sd = &__get_cpu_var(softnet_data);
1636
1637         if (sd->completion_queue) {
1638                 struct sk_buff *clist;
1639
1640                 local_irq_disable();
1641                 clist = sd->completion_queue;
1642                 sd->completion_queue = NULL;
1643                 local_irq_enable();
1644
1645                 while (clist) {
1646                         struct sk_buff *skb = clist;
1647                         clist = clist->next;
1648
1649                         BUG_TRAP(!atomic_read(&skb->users));
1650                         __kfree_skb(skb);
1651                 }
1652         }
1653
1654         if (sd->output_queue) {
1655                 struct net_device *head;
1656
1657                 local_irq_disable();
1658                 head = sd->output_queue;
1659                 sd->output_queue = NULL;
1660                 local_irq_enable();
1661
1662                 while (head) {
1663                         struct net_device *dev = head;
1664                         head = head->next_sched;
1665
1666                         smp_mb__before_clear_bit();
1667                         clear_bit(__LINK_STATE_SCHED, &dev->state);
1668
1669                         if (spin_trylock(&dev->queue_lock)) {
1670                                 qdisc_run(dev);
1671                                 spin_unlock(&dev->queue_lock);
1672                         } else {
1673                                 netif_schedule(dev);
1674                         }
1675                 }
1676         }
1677 }
1678
1679 static __inline__ int deliver_skb(struct sk_buff *skb,
1680                                   struct packet_type *pt_prev,
1681                                   struct net_device *orig_dev)
1682 {
1683         atomic_inc(&skb->users);
1684         return pt_prev->func(skb, skb->dev, pt_prev, orig_dev);
1685 }
1686
1687 #if defined(CONFIG_BRIDGE) || defined (CONFIG_BRIDGE_MODULE)
1688 int (*br_handle_frame_hook)(struct net_bridge_port *p, struct sk_buff **pskb);
1689 struct net_bridge;
1690 struct net_bridge_fdb_entry *(*br_fdb_get_hook)(struct net_bridge *br,
1691                                                 unsigned char *addr);
1692 void (*br_fdb_put_hook)(struct net_bridge_fdb_entry *ent);
1693
1694 static __inline__ int handle_bridge(struct sk_buff **pskb,
1695                                     struct packet_type **pt_prev, int *ret,
1696                                     struct net_device *orig_dev)
1697 {
1698         struct net_bridge_port *port;
1699
1700         if ((*pskb)->pkt_type == PACKET_LOOPBACK ||
1701             (port = rcu_dereference((*pskb)->dev->br_port)) == NULL)
1702                 return 0;
1703
1704         if (*pt_prev) {
1705                 *ret = deliver_skb(*pskb, *pt_prev, orig_dev);
1706                 *pt_prev = NULL;
1707         } 
1708         
1709         return br_handle_frame_hook(port, pskb);
1710 }
1711 #else
1712 #define handle_bridge(skb, pt_prev, ret, orig_dev)      (0)
1713 #endif
1714
1715 #ifdef CONFIG_NET_CLS_ACT
1716 /* TODO: Maybe we should just force sch_ingress to be compiled in
1717  * when CONFIG_NET_CLS_ACT is? otherwise some useless instructions
1718  * a compare and 2 stores extra right now if we dont have it on
1719  * but have CONFIG_NET_CLS_ACT
1720  * NOTE: This doesnt stop any functionality; if you dont have 
1721  * the ingress scheduler, you just cant add policies on ingress.
1722  *
1723  */
1724 static int ing_filter(struct sk_buff *skb) 
1725 {
1726         struct Qdisc *q;
1727         struct net_device *dev = skb->dev;
1728         int result = TC_ACT_OK;
1729         
1730         if (dev->qdisc_ingress) {
1731                 __u32 ttl = (__u32) G_TC_RTTL(skb->tc_verd);
1732                 if (MAX_RED_LOOP < ttl++) {
1733                         printk("Redir loop detected Dropping packet (%s->%s)\n",
1734                                 skb->input_dev->name, skb->dev->name);
1735                         return TC_ACT_SHOT;
1736                 }
1737
1738                 skb->tc_verd = SET_TC_RTTL(skb->tc_verd,ttl);
1739
1740                 skb->tc_verd = SET_TC_AT(skb->tc_verd,AT_INGRESS);
1741
1742                 spin_lock(&dev->ingress_lock);
1743                 if ((q = dev->qdisc_ingress) != NULL)
1744                         result = q->enqueue(skb, q);
1745                 spin_unlock(&dev->ingress_lock);
1746
1747         }
1748
1749         return result;
1750 }
1751 #endif
1752
1753 int netif_receive_skb(struct sk_buff *skb)
1754 {
1755         struct packet_type *ptype, *pt_prev;
1756         struct net_device *orig_dev;
1757         int ret = NET_RX_DROP;
1758         unsigned short type;
1759
1760         /* if we've gotten here through NAPI, check netpoll */
1761         if (skb->dev->poll && netpoll_rx(skb))
1762                 return NET_RX_DROP;
1763
1764         if (!skb->tstamp.off_sec)
1765                 net_timestamp(skb);
1766
1767         if (!skb->input_dev)
1768                 skb->input_dev = skb->dev;
1769
1770         orig_dev = skb_bond(skb);
1771
1772         if (!orig_dev)
1773                 return NET_RX_DROP;
1774
1775         __get_cpu_var(netdev_rx_stat).total++;
1776
1777         skb->h.raw = skb->nh.raw = skb->data;
1778         skb->mac_len = skb->nh.raw - skb->mac.raw;
1779
1780         pt_prev = NULL;
1781
1782         rcu_read_lock();
1783
1784 #ifdef CONFIG_NET_CLS_ACT
1785         if (skb->tc_verd & TC_NCLS) {
1786                 skb->tc_verd = CLR_TC_NCLS(skb->tc_verd);
1787                 goto ncls;
1788         }
1789 #endif
1790
1791         list_for_each_entry_rcu(ptype, &ptype_all, list) {
1792                 if (!ptype->dev || ptype->dev == skb->dev) {
1793                         if (pt_prev) 
1794                                 ret = deliver_skb(skb, pt_prev, orig_dev);
1795                         pt_prev = ptype;
1796                 }
1797         }
1798
1799 #ifdef CONFIG_NET_CLS_ACT
1800         if (pt_prev) {
1801                 ret = deliver_skb(skb, pt_prev, orig_dev);
1802                 pt_prev = NULL; /* noone else should process this after*/
1803         } else {
1804                 skb->tc_verd = SET_TC_OK2MUNGE(skb->tc_verd);
1805         }
1806
1807         ret = ing_filter(skb);
1808
1809         if (ret == TC_ACT_SHOT || (ret == TC_ACT_STOLEN)) {
1810                 kfree_skb(skb);
1811                 goto out;
1812         }
1813
1814         skb->tc_verd = 0;
1815 ncls:
1816 #endif
1817
1818         handle_diverter(skb);
1819
1820         if (handle_bridge(&skb, &pt_prev, &ret, orig_dev))
1821                 goto out;
1822
1823         type = skb->protocol;
1824         list_for_each_entry_rcu(ptype, &ptype_base[ntohs(type)&15], list) {
1825                 if (ptype->type == type &&
1826                     (!ptype->dev || ptype->dev == skb->dev)) {
1827                         if (pt_prev) 
1828                                 ret = deliver_skb(skb, pt_prev, orig_dev);
1829                         pt_prev = ptype;
1830                 }
1831         }
1832
1833         if (pt_prev) {
1834                 ret = pt_prev->func(skb, skb->dev, pt_prev, orig_dev);
1835         } else {
1836                 kfree_skb(skb);
1837                 /* Jamal, now you will not able to escape explaining
1838                  * me how you were going to use this. :-)
1839                  */
1840                 ret = NET_RX_DROP;
1841         }
1842
1843 out:
1844         rcu_read_unlock();
1845         return ret;
1846 }
1847
1848 static int process_backlog(struct net_device *backlog_dev, int *budget)
1849 {
1850         int work = 0;
1851         int quota = min(backlog_dev->quota, *budget);
1852         struct softnet_data *queue = &__get_cpu_var(softnet_data);
1853         unsigned long start_time = jiffies;
1854
1855         backlog_dev->weight = weight_p;
1856         for (;;) {
1857                 struct sk_buff *skb;
1858                 struct net_device *dev;
1859
1860                 local_irq_disable();
1861                 skb = __skb_dequeue(&queue->input_pkt_queue);
1862                 if (!skb)
1863                         goto job_done;
1864                 local_irq_enable();
1865
1866                 dev = skb->dev;
1867
1868                 netif_receive_skb(skb);
1869
1870                 dev_put(dev);
1871
1872                 work++;
1873
1874                 if (work >= quota || jiffies - start_time > 1)
1875                         break;
1876
1877         }
1878
1879         backlog_dev->quota -= work;
1880         *budget -= work;
1881         return -1;
1882
1883 job_done:
1884         backlog_dev->quota -= work;
1885         *budget -= work;
1886
1887         list_del(&backlog_dev->poll_list);
1888         smp_mb__before_clear_bit();
1889         netif_poll_enable(backlog_dev);
1890
1891         local_irq_enable();
1892         return 0;
1893 }
1894
1895 static void net_rx_action(struct softirq_action *h)
1896 {
1897         struct softnet_data *queue = &__get_cpu_var(softnet_data);
1898         unsigned long start_time = jiffies;
1899         int budget = netdev_budget;
1900         void *have;
1901
1902         local_irq_disable();
1903
1904         while (!list_empty(&queue->poll_list)) {
1905                 struct net_device *dev;
1906
1907                 if (budget <= 0 || jiffies - start_time > 1)
1908                         goto softnet_break;
1909
1910                 local_irq_enable();
1911
1912                 dev = list_entry(queue->poll_list.next,
1913                                  struct net_device, poll_list);
1914                 have = netpoll_poll_lock(dev);
1915
1916                 if (dev->quota <= 0 || dev->poll(dev, &budget)) {
1917                         netpoll_poll_unlock(have);
1918                         local_irq_disable();
1919                         list_move_tail(&dev->poll_list, &queue->poll_list);
1920                         if (dev->quota < 0)
1921                                 dev->quota += dev->weight;
1922                         else
1923                                 dev->quota = dev->weight;
1924                 } else {
1925                         netpoll_poll_unlock(have);
1926                         dev_put(dev);
1927                         local_irq_disable();
1928                 }
1929         }
1930 out:
1931 #ifdef CONFIG_NET_DMA
1932         /*
1933          * There may not be any more sk_buffs coming right now, so push
1934          * any pending DMA copies to hardware
1935          */
1936         if (net_dma_client) {
1937                 struct dma_chan *chan;
1938                 rcu_read_lock();
1939                 list_for_each_entry_rcu(chan, &net_dma_client->channels, client_node)
1940                         dma_async_memcpy_issue_pending(chan);
1941                 rcu_read_unlock();
1942         }
1943 #endif
1944         local_irq_enable();
1945         return;
1946
1947 softnet_break:
1948         __get_cpu_var(netdev_rx_stat).time_squeeze++;
1949         __raise_softirq_irqoff(NET_RX_SOFTIRQ);
1950         goto out;
1951 }
1952
1953 static gifconf_func_t * gifconf_list [NPROTO];
1954
1955 /**
1956  *      register_gifconf        -       register a SIOCGIF handler
1957  *      @family: Address family
1958  *      @gifconf: Function handler
1959  *
1960  *      Register protocol dependent address dumping routines. The handler
1961  *      that is passed must not be freed or reused until it has been replaced
1962  *      by another handler.
1963  */
1964 int register_gifconf(unsigned int family, gifconf_func_t * gifconf)
1965 {
1966         if (family >= NPROTO)
1967                 return -EINVAL;
1968         gifconf_list[family] = gifconf;
1969         return 0;
1970 }
1971
1972
1973 /*
1974  *      Map an interface index to its name (SIOCGIFNAME)
1975  */
1976
1977 /*
1978  *      We need this ioctl for efficient implementation of the
1979  *      if_indextoname() function required by the IPv6 API.  Without
1980  *      it, we would have to search all the interfaces to find a
1981  *      match.  --pb
1982  */
1983
1984 static int dev_ifname(struct ifreq __user *arg)
1985 {
1986         struct net_device *dev;
1987         struct ifreq ifr;
1988
1989         /*
1990          *      Fetch the caller's info block.
1991          */
1992
1993         if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
1994                 return -EFAULT;
1995
1996         read_lock(&dev_base_lock);
1997         dev = __dev_get_by_index(ifr.ifr_ifindex);
1998         if (!dev) {
1999                 read_unlock(&dev_base_lock);
2000                 return -ENODEV;
2001         }
2002
2003         strcpy(ifr.ifr_name, dev->name);
2004         read_unlock(&dev_base_lock);
2005
2006         if (copy_to_user(arg, &ifr, sizeof(struct ifreq)))
2007                 return -EFAULT;
2008         return 0;
2009 }
2010
2011 /*
2012  *      Perform a SIOCGIFCONF call. This structure will change
2013  *      size eventually, and there is nothing I can do about it.
2014  *      Thus we will need a 'compatibility mode'.
2015  */
2016
2017 static int dev_ifconf(char __user *arg)
2018 {
2019         struct ifconf ifc;
2020         struct net_device *dev;
2021         char __user *pos;
2022         int len;
2023         int total;
2024         int i;
2025
2026         /*
2027          *      Fetch the caller's info block.
2028          */
2029
2030         if (copy_from_user(&ifc, arg, sizeof(struct ifconf)))
2031                 return -EFAULT;
2032
2033         pos = ifc.ifc_buf;
2034         len = ifc.ifc_len;
2035
2036         /*
2037          *      Loop over the interfaces, and write an info block for each.
2038          */
2039
2040         total = 0;
2041         for (dev = dev_base; dev; dev = dev->next) {
2042                 for (i = 0; i < NPROTO; i++) {
2043                         if (gifconf_list[i]) {
2044                                 int done;
2045                                 if (!pos)
2046                                         done = gifconf_list[i](dev, NULL, 0);
2047                                 else
2048                                         done = gifconf_list[i](dev, pos + total,
2049                                                                len - total);
2050                                 if (done < 0)
2051                                         return -EFAULT;
2052                                 total += done;
2053                         }
2054                 }
2055         }
2056
2057         /*
2058          *      All done.  Write the updated control block back to the caller.
2059          */
2060         ifc.ifc_len = total;
2061
2062         /*
2063          *      Both BSD and Solaris return 0 here, so we do too.
2064          */
2065         return copy_to_user(arg, &ifc, sizeof(struct ifconf)) ? -EFAULT : 0;
2066 }
2067
2068 #ifdef CONFIG_PROC_FS
2069 /*
2070  *      This is invoked by the /proc filesystem handler to display a device
2071  *      in detail.
2072  */
2073 static __inline__ struct net_device *dev_get_idx(loff_t pos)
2074 {
2075         struct net_device *dev;
2076         loff_t i;
2077
2078         for (i = 0, dev = dev_base; dev && i < pos; ++i, dev = dev->next);
2079
2080         return i == pos ? dev : NULL;
2081 }
2082
2083 void *dev_seq_start(struct seq_file *seq, loff_t *pos)
2084 {
2085         read_lock(&dev_base_lock);
2086         return *pos ? dev_get_idx(*pos - 1) : SEQ_START_TOKEN;
2087 }
2088
2089 void *dev_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2090 {
2091         ++*pos;
2092         return v == SEQ_START_TOKEN ? dev_base : ((struct net_device *)v)->next;
2093 }
2094
2095 void dev_seq_stop(struct seq_file *seq, void *v)
2096 {
2097         read_unlock(&dev_base_lock);
2098 }
2099
2100 static void dev_seq_printf_stats(struct seq_file *seq, struct net_device *dev)
2101 {
2102         if (dev->get_stats) {
2103                 struct net_device_stats *stats = dev->get_stats(dev);
2104
2105                 seq_printf(seq, "%6s:%8lu %7lu %4lu %4lu %4lu %5lu %10lu %9lu "
2106                                 "%8lu %7lu %4lu %4lu %4lu %5lu %7lu %10lu\n",
2107                            dev->name, stats->rx_bytes, stats->rx_packets,
2108                            stats->rx_errors,
2109                            stats->rx_dropped + stats->rx_missed_errors,
2110                            stats->rx_fifo_errors,
2111                            stats->rx_length_errors + stats->rx_over_errors +
2112                              stats->rx_crc_errors + stats->rx_frame_errors,
2113                            stats->rx_compressed, stats->multicast,
2114                            stats->tx_bytes, stats->tx_packets,
2115                            stats->tx_errors, stats->tx_dropped,
2116                            stats->tx_fifo_errors, stats->collisions,
2117                            stats->tx_carrier_errors +
2118                              stats->tx_aborted_errors +
2119                              stats->tx_window_errors +
2120                              stats->tx_heartbeat_errors,
2121                            stats->tx_compressed);
2122         } else
2123                 seq_printf(seq, "%6s: No statistics available.\n", dev->name);
2124 }
2125
2126 /*
2127  *      Called from the PROCfs module. This now uses the new arbitrary sized
2128  *      /proc/net interface to create /proc/net/dev
2129  */
2130 static int dev_seq_show(struct seq_file *seq, void *v)
2131 {
2132         if (v == SEQ_START_TOKEN)
2133                 seq_puts(seq, "Inter-|   Receive                            "
2134                               "                    |  Transmit\n"
2135                               " face |bytes    packets errs drop fifo frame "
2136                               "compressed multicast|bytes    packets errs "
2137                               "drop fifo colls carrier compressed\n");
2138         else
2139                 dev_seq_printf_stats(seq, v);
2140         return 0;
2141 }
2142
2143 static struct netif_rx_stats *softnet_get_online(loff_t *pos)
2144 {
2145         struct netif_rx_stats *rc = NULL;
2146
2147         while (*pos < NR_CPUS)
2148                 if (cpu_online(*pos)) {
2149                         rc = &per_cpu(netdev_rx_stat, *pos);
2150                         break;
2151                 } else
2152                         ++*pos;
2153         return rc;
2154 }
2155
2156 static void *softnet_seq_start(struct seq_file *seq, loff_t *pos)
2157 {
2158         return softnet_get_online(pos);
2159 }
2160
2161 static void *softnet_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2162 {
2163         ++*pos;
2164         return softnet_get_online(pos);
2165 }
2166
2167 static void softnet_seq_stop(struct seq_file *seq, void *v)
2168 {
2169 }
2170
2171 static int softnet_seq_show(struct seq_file *seq, void *v)
2172 {
2173         struct netif_rx_stats *s = v;
2174
2175         seq_printf(seq, "%08x %08x %08x %08x %08x %08x %08x %08x %08x\n",
2176                    s->total, s->dropped, s->time_squeeze, 0,
2177                    0, 0, 0, 0, /* was fastroute */
2178                    s->cpu_collision );
2179         return 0;
2180 }
2181
2182 static struct seq_operations dev_seq_ops = {
2183         .start = dev_seq_start,
2184         .next  = dev_seq_next,
2185         .stop  = dev_seq_stop,
2186         .show  = dev_seq_show,
2187 };
2188
2189 static int dev_seq_open(struct inode *inode, struct file *file)
2190 {
2191         return seq_open(file, &dev_seq_ops);
2192 }
2193
2194 static struct file_operations dev_seq_fops = {
2195         .owner   = THIS_MODULE,
2196         .open    = dev_seq_open,
2197         .read    = seq_read,
2198         .llseek  = seq_lseek,
2199         .release = seq_release,
2200 };
2201
2202 static struct seq_operations softnet_seq_ops = {
2203         .start = softnet_seq_start,
2204         .next  = softnet_seq_next,
2205         .stop  = softnet_seq_stop,
2206         .show  = softnet_seq_show,
2207 };
2208
2209 static int softnet_seq_open(struct inode *inode, struct file *file)
2210 {
2211         return seq_open(file, &softnet_seq_ops);
2212 }
2213
2214 static struct file_operations softnet_seq_fops = {
2215         .owner   = THIS_MODULE,
2216         .open    = softnet_seq_open,
2217         .read    = seq_read,
2218         .llseek  = seq_lseek,
2219         .release = seq_release,
2220 };
2221
2222 #ifdef CONFIG_WIRELESS_EXT
2223 extern int wireless_proc_init(void);
2224 #else
2225 #define wireless_proc_init() 0
2226 #endif
2227
2228 static int __init dev_proc_init(void)
2229 {
2230         int rc = -ENOMEM;
2231
2232         if (!proc_net_fops_create("dev", S_IRUGO, &dev_seq_fops))
2233                 goto out;
2234         if (!proc_net_fops_create("softnet_stat", S_IRUGO, &softnet_seq_fops))
2235                 goto out_dev;
2236         if (wireless_proc_init())
2237                 goto out_softnet;
2238         rc = 0;
2239 out:
2240         return rc;
2241 out_softnet:
2242         proc_net_remove("softnet_stat");
2243 out_dev:
2244         proc_net_remove("dev");
2245         goto out;
2246 }
2247 #else
2248 #define dev_proc_init() 0
2249 #endif  /* CONFIG_PROC_FS */
2250
2251
2252 /**
2253  *      netdev_set_master       -       set up master/slave pair
2254  *      @slave: slave device
2255  *      @master: new master device
2256  *
2257  *      Changes the master device of the slave. Pass %NULL to break the
2258  *      bonding. The caller must hold the RTNL semaphore. On a failure
2259  *      a negative errno code is returned. On success the reference counts
2260  *      are adjusted, %RTM_NEWLINK is sent to the routing socket and the
2261  *      function returns zero.
2262  */
2263 int netdev_set_master(struct net_device *slave, struct net_device *master)
2264 {
2265         struct net_device *old = slave->master;
2266
2267         ASSERT_RTNL();
2268
2269         if (master) {
2270                 if (old)
2271                         return -EBUSY;
2272                 dev_hold(master);
2273         }
2274
2275         slave->master = master;
2276         
2277         synchronize_net();
2278
2279         if (old)
2280                 dev_put(old);
2281
2282         if (master)
2283                 slave->flags |= IFF_SLAVE;
2284         else
2285                 slave->flags &= ~IFF_SLAVE;
2286
2287         rtmsg_ifinfo(RTM_NEWLINK, slave, IFF_SLAVE);
2288         return 0;
2289 }
2290
2291 /**
2292  *      dev_set_promiscuity     - update promiscuity count on a device
2293  *      @dev: device
2294  *      @inc: modifier
2295  *
2296  *      Add or remove promiscuity from a device. While the count in the device
2297  *      remains above zero the interface remains promiscuous. Once it hits zero
2298  *      the device reverts back to normal filtering operation. A negative inc
2299  *      value is used to drop promiscuity on the device.
2300  */
2301 void dev_set_promiscuity(struct net_device *dev, int inc)
2302 {
2303         unsigned short old_flags = dev->flags;
2304
2305         if ((dev->promiscuity += inc) == 0)
2306                 dev->flags &= ~IFF_PROMISC;
2307         else
2308                 dev->flags |= IFF_PROMISC;
2309         if (dev->flags != old_flags) {
2310                 dev_mc_upload(dev);
2311                 printk(KERN_INFO "device %s %s promiscuous mode\n",
2312                        dev->name, (dev->flags & IFF_PROMISC) ? "entered" :
2313                                                                "left");
2314                 audit_log(current->audit_context, GFP_ATOMIC,
2315                         AUDIT_ANOM_PROMISCUOUS,
2316                         "dev=%s prom=%d old_prom=%d auid=%u",
2317                         dev->name, (dev->flags & IFF_PROMISC),
2318                         (old_flags & IFF_PROMISC),
2319                         audit_get_loginuid(current->audit_context)); 
2320         }
2321 }
2322
2323 /**
2324  *      dev_set_allmulti        - update allmulti count on a device
2325  *      @dev: device
2326  *      @inc: modifier
2327  *
2328  *      Add or remove reception of all multicast frames to a device. While the
2329  *      count in the device remains above zero the interface remains listening
2330  *      to all interfaces. Once it hits zero the device reverts back to normal
2331  *      filtering operation. A negative @inc value is used to drop the counter
2332  *      when releasing a resource needing all multicasts.
2333  */
2334
2335 void dev_set_allmulti(struct net_device *dev, int inc)
2336 {
2337         unsigned short old_flags = dev->flags;
2338
2339         dev->flags |= IFF_ALLMULTI;
2340         if ((dev->allmulti += inc) == 0)
2341                 dev->flags &= ~IFF_ALLMULTI;
2342         if (dev->flags ^ old_flags)
2343                 dev_mc_upload(dev);
2344 }
2345
2346 unsigned dev_get_flags(const struct net_device *dev)
2347 {
2348         unsigned flags;
2349
2350         flags = (dev->flags & ~(IFF_PROMISC |
2351                                 IFF_ALLMULTI |
2352                                 IFF_RUNNING |
2353                                 IFF_LOWER_UP |
2354                                 IFF_DORMANT)) |
2355                 (dev->gflags & (IFF_PROMISC |
2356                                 IFF_ALLMULTI));
2357
2358         if (netif_running(dev)) {
2359                 if (netif_oper_up(dev))
2360                         flags |= IFF_RUNNING;
2361                 if (netif_carrier_ok(dev))
2362                         flags |= IFF_LOWER_UP;
2363                 if (netif_dormant(dev))
2364                         flags |= IFF_DORMANT;
2365         }
2366
2367         return flags;
2368 }
2369
2370 int dev_change_flags(struct net_device *dev, unsigned flags)
2371 {
2372         int ret;
2373         int old_flags = dev->flags;
2374
2375         /*
2376          *      Set the flags on our device.
2377          */
2378
2379         dev->flags = (flags & (IFF_DEBUG | IFF_NOTRAILERS | IFF_NOARP |
2380                                IFF_DYNAMIC | IFF_MULTICAST | IFF_PORTSEL |
2381                                IFF_AUTOMEDIA)) |
2382                      (dev->flags & (IFF_UP | IFF_VOLATILE | IFF_PROMISC |
2383                                     IFF_ALLMULTI));
2384
2385         /*
2386          *      Load in the correct multicast list now the flags have changed.
2387          */
2388
2389         dev_mc_upload(dev);
2390
2391         /*
2392          *      Have we downed the interface. We handle IFF_UP ourselves
2393          *      according to user attempts to set it, rather than blindly
2394          *      setting it.
2395          */
2396
2397         ret = 0;
2398         if ((old_flags ^ flags) & IFF_UP) {     /* Bit is different  ? */
2399                 ret = ((old_flags & IFF_UP) ? dev_close : dev_open)(dev);
2400
2401                 if (!ret)
2402                         dev_mc_upload(dev);
2403         }
2404
2405         if (dev->flags & IFF_UP &&
2406             ((old_flags ^ dev->flags) &~ (IFF_UP | IFF_PROMISC | IFF_ALLMULTI |
2407                                           IFF_VOLATILE)))
2408                 raw_notifier_call_chain(&netdev_chain,
2409                                 NETDEV_CHANGE, dev);
2410
2411         if ((flags ^ dev->gflags) & IFF_PROMISC) {
2412                 int inc = (flags & IFF_PROMISC) ? +1 : -1;
2413                 dev->gflags ^= IFF_PROMISC;
2414                 dev_set_promiscuity(dev, inc);
2415         }
2416
2417         /* NOTE: order of synchronization of IFF_PROMISC and IFF_ALLMULTI
2418            is important. Some (broken) drivers set IFF_PROMISC, when
2419            IFF_ALLMULTI is requested not asking us and not reporting.
2420          */
2421         if ((flags ^ dev->gflags) & IFF_ALLMULTI) {
2422                 int inc = (flags & IFF_ALLMULTI) ? +1 : -1;
2423                 dev->gflags ^= IFF_ALLMULTI;
2424                 dev_set_allmulti(dev, inc);
2425         }
2426
2427         if (old_flags ^ dev->flags)
2428                 rtmsg_ifinfo(RTM_NEWLINK, dev, old_flags ^ dev->flags);
2429
2430         return ret;
2431 }
2432
2433 int dev_set_mtu(struct net_device *dev, int new_mtu)
2434 {
2435         int err;
2436
2437         if (new_mtu == dev->mtu)
2438                 return 0;
2439
2440         /*      MTU must be positive.    */
2441         if (new_mtu < 0)
2442                 return -EINVAL;
2443
2444         if (!netif_device_present(dev))
2445                 return -ENODEV;
2446
2447         err = 0;
2448         if (dev->change_mtu)
2449                 err = dev->change_mtu(dev, new_mtu);
2450         else
2451                 dev->mtu = new_mtu;
2452         if (!err && dev->flags & IFF_UP)
2453                 raw_notifier_call_chain(&netdev_chain,
2454                                 NETDEV_CHANGEMTU, dev);
2455         return err;
2456 }
2457
2458 int dev_set_mac_address(struct net_device *dev, struct sockaddr *sa)
2459 {
2460         int err;
2461
2462         if (!dev->set_mac_address)
2463                 return -EOPNOTSUPP;
2464         if (sa->sa_family != dev->type)
2465                 return -EINVAL;
2466         if (!netif_device_present(dev))
2467                 return -ENODEV;
2468         err = dev->set_mac_address(dev, sa);
2469         if (!err)
2470                 raw_notifier_call_chain(&netdev_chain,
2471                                 NETDEV_CHANGEADDR, dev);
2472         return err;
2473 }
2474
2475 /*
2476  *      Perform the SIOCxIFxxx calls.
2477  */
2478 static int dev_ifsioc(struct ifreq *ifr, unsigned int cmd)
2479 {
2480         int err;
2481         struct net_device *dev = __dev_get_by_name(ifr->ifr_name);
2482
2483         if (!dev)
2484                 return -ENODEV;
2485
2486         switch (cmd) {
2487                 case SIOCGIFFLAGS:      /* Get interface flags */
2488                         ifr->ifr_flags = dev_get_flags(dev);
2489                         return 0;
2490
2491                 case SIOCSIFFLAGS:      /* Set interface flags */
2492                         return dev_change_flags(dev, ifr->ifr_flags);
2493
2494                 case SIOCGIFMETRIC:     /* Get the metric on the interface
2495                                            (currently unused) */
2496                         ifr->ifr_metric = 0;
2497                         return 0;
2498
2499                 case SIOCSIFMETRIC:     /* Set the metric on the interface
2500                                            (currently unused) */
2501                         return -EOPNOTSUPP;
2502
2503                 case SIOCGIFMTU:        /* Get the MTU of a device */
2504                         ifr->ifr_mtu = dev->mtu;
2505                         return 0;
2506
2507                 case SIOCSIFMTU:        /* Set the MTU of a device */
2508                         return dev_set_mtu(dev, ifr->ifr_mtu);
2509
2510                 case SIOCGIFHWADDR:
2511                         if (!dev->addr_len)
2512                                 memset(ifr->ifr_hwaddr.sa_data, 0, sizeof ifr->ifr_hwaddr.sa_data);
2513                         else
2514                                 memcpy(ifr->ifr_hwaddr.sa_data, dev->dev_addr,
2515                                        min(sizeof ifr->ifr_hwaddr.sa_data, (size_t) dev->addr_len));
2516                         ifr->ifr_hwaddr.sa_family = dev->type;
2517                         return 0;
2518
2519                 case SIOCSIFHWADDR:
2520                         return dev_set_mac_address(dev, &ifr->ifr_hwaddr);
2521
2522                 case SIOCSIFHWBROADCAST:
2523                         if (ifr->ifr_hwaddr.sa_family != dev->type)
2524                                 return -EINVAL;
2525                         memcpy(dev->broadcast, ifr->ifr_hwaddr.sa_data,
2526                                min(sizeof ifr->ifr_hwaddr.sa_data, (size_t) dev->addr_len));
2527                         raw_notifier_call_chain(&netdev_chain,
2528                                             NETDEV_CHANGEADDR, dev);
2529                         return 0;
2530
2531                 case SIOCGIFMAP:
2532                         ifr->ifr_map.mem_start = dev->mem_start;
2533                         ifr->ifr_map.mem_end   = dev->mem_end;
2534                         ifr->ifr_map.base_addr = dev->base_addr;
2535                         ifr->ifr_map.irq       = dev->irq;
2536                         ifr->ifr_map.dma       = dev->dma;
2537                         ifr->ifr_map.port      = dev->if_port;
2538                         return 0;
2539
2540                 case SIOCSIFMAP:
2541                         if (dev->set_config) {
2542                                 if (!netif_device_present(dev))
2543                                         return -ENODEV;
2544                                 return dev->set_config(dev, &ifr->ifr_map);
2545                         }
2546                         return -EOPNOTSUPP;
2547
2548                 case SIOCADDMULTI:
2549                         if (!dev->set_multicast_list ||
2550                             ifr->ifr_hwaddr.sa_family != AF_UNSPEC)
2551                                 return -EINVAL;
2552                         if (!netif_device_present(dev))
2553                                 return -ENODEV;
2554                         return dev_mc_add(dev, ifr->ifr_hwaddr.sa_data,
2555                                           dev->addr_len, 1);
2556
2557                 case SIOCDELMULTI:
2558                         if (!dev->set_multicast_list ||
2559                             ifr->ifr_hwaddr.sa_family != AF_UNSPEC)
2560                                 return -EINVAL;
2561                         if (!netif_device_present(dev))
2562                                 return -ENODEV;
2563                         return dev_mc_delete(dev, ifr->ifr_hwaddr.sa_data,
2564                                              dev->addr_len, 1);
2565
2566                 case SIOCGIFINDEX:
2567                         ifr->ifr_ifindex = dev->ifindex;
2568                         return 0;
2569
2570                 case SIOCGIFTXQLEN:
2571                         ifr->ifr_qlen = dev->tx_queue_len;
2572                         return 0;
2573
2574                 case SIOCSIFTXQLEN:
2575                         if (ifr->ifr_qlen < 0)
2576                                 return -EINVAL;
2577                         dev->tx_queue_len = ifr->ifr_qlen;
2578                         return 0;
2579
2580                 case SIOCSIFNAME:
2581                         ifr->ifr_newname[IFNAMSIZ-1] = '\0';
2582                         return dev_change_name(dev, ifr->ifr_newname);
2583
2584                 /*
2585                  *      Unknown or private ioctl
2586                  */
2587
2588                 default:
2589                         if ((cmd >= SIOCDEVPRIVATE &&
2590                             cmd <= SIOCDEVPRIVATE + 15) ||
2591                             cmd == SIOCBONDENSLAVE ||
2592                             cmd == SIOCBONDRELEASE ||
2593                             cmd == SIOCBONDSETHWADDR ||
2594                             cmd == SIOCBONDSLAVEINFOQUERY ||
2595                             cmd == SIOCBONDINFOQUERY ||
2596                             cmd == SIOCBONDCHANGEACTIVE ||
2597                             cmd == SIOCGMIIPHY ||
2598                             cmd == SIOCGMIIREG ||
2599                             cmd == SIOCSMIIREG ||
2600                             cmd == SIOCBRADDIF ||
2601                             cmd == SIOCBRDELIF ||
2602                             cmd == SIOCWANDEV) {
2603                                 err = -EOPNOTSUPP;
2604                                 if (dev->do_ioctl) {
2605                                         if (netif_device_present(dev))
2606                                                 err = dev->do_ioctl(dev, ifr,
2607                                                                     cmd);
2608                                         else
2609                                                 err = -ENODEV;
2610                                 }
2611                         } else
2612                                 err = -EINVAL;
2613
2614         }
2615         return err;
2616 }
2617
2618 /*
2619  *      This function handles all "interface"-type I/O control requests. The actual
2620  *      'doing' part of this is dev_ifsioc above.
2621  */
2622
2623 /**
2624  *      dev_ioctl       -       network device ioctl
2625  *      @cmd: command to issue
2626  *      @arg: pointer to a struct ifreq in user space
2627  *
2628  *      Issue ioctl functions to devices. This is normally called by the
2629  *      user space syscall interfaces but can sometimes be useful for
2630  *      other purposes. The return value is the return from the syscall if
2631  *      positive or a negative errno code on error.
2632  */
2633
2634 int dev_ioctl(unsigned int cmd, void __user *arg)
2635 {
2636         struct ifreq ifr;
2637         int ret;
2638         char *colon;
2639
2640         /* One special case: SIOCGIFCONF takes ifconf argument
2641            and requires shared lock, because it sleeps writing
2642            to user space.
2643          */
2644
2645         if (cmd == SIOCGIFCONF) {
2646                 rtnl_lock();
2647                 ret = dev_ifconf((char __user *) arg);
2648                 rtnl_unlock();
2649                 return ret;
2650         }
2651         if (cmd == SIOCGIFNAME)
2652                 return dev_ifname((struct ifreq __user *)arg);
2653
2654         if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
2655                 return -EFAULT;
2656
2657         ifr.ifr_name[IFNAMSIZ-1] = 0;
2658
2659         colon = strchr(ifr.ifr_name, ':');
2660         if (colon)
2661                 *colon = 0;
2662
2663         /*
2664          *      See which interface the caller is talking about.
2665          */
2666
2667         switch (cmd) {
2668                 /*
2669                  *      These ioctl calls:
2670                  *      - can be done by all.
2671                  *      - atomic and do not require locking.
2672                  *      - return a value
2673                  */
2674                 case SIOCGIFFLAGS:
2675                 case SIOCGIFMETRIC:
2676                 case SIOCGIFMTU:
2677                 case SIOCGIFHWADDR:
2678                 case SIOCGIFSLAVE:
2679                 case SIOCGIFMAP:
2680                 case SIOCGIFINDEX:
2681                 case SIOCGIFTXQLEN:
2682                         dev_load(ifr.ifr_name);
2683                         read_lock(&dev_base_lock);
2684                         ret = dev_ifsioc(&ifr, cmd);
2685                         read_unlock(&dev_base_lock);
2686                         if (!ret) {
2687                                 if (colon)
2688                                         *colon = ':';
2689                                 if (copy_to_user(arg, &ifr,
2690                                                  sizeof(struct ifreq)))
2691                                         ret = -EFAULT;
2692                         }
2693                         return ret;
2694
2695                 case SIOCETHTOOL:
2696                         dev_load(ifr.ifr_name);
2697                         rtnl_lock();
2698                         ret = dev_ethtool(&ifr);
2699                         rtnl_unlock();
2700                         if (!ret) {
2701                                 if (colon)
2702                                         *colon = ':';
2703                                 if (copy_to_user(arg, &ifr,
2704                                                  sizeof(struct ifreq)))
2705                                         ret = -EFAULT;
2706                         }
2707                         return ret;
2708
2709                 /*
2710                  *      These ioctl calls:
2711                  *      - require superuser power.
2712                  *      - require strict serialization.
2713                  *      - return a value
2714                  */
2715                 case SIOCGMIIPHY:
2716                 case SIOCGMIIREG:
2717                 case SIOCSIFNAME:
2718                         if (!capable(CAP_NET_ADMIN))
2719                                 return -EPERM;
2720                         dev_load(ifr.ifr_name);
2721                         rtnl_lock();
2722                         ret = dev_ifsioc(&ifr, cmd);
2723                         rtnl_unlock();
2724                         if (!ret) {
2725                                 if (colon)
2726                                         *colon = ':';
2727                                 if (copy_to_user(arg, &ifr,
2728                                                  sizeof(struct ifreq)))
2729                                         ret = -EFAULT;
2730                         }
2731                         return ret;
2732
2733                 /*
2734                  *      These ioctl calls:
2735                  *      - require superuser power.
2736                  *      - require strict serialization.
2737                  *      - do not return a value
2738                  */
2739                 case SIOCSIFFLAGS:
2740                 case SIOCSIFMETRIC:
2741                 case SIOCSIFMTU:
2742                 case SIOCSIFMAP:
2743                 case SIOCSIFHWADDR:
2744                 case SIOCSIFSLAVE:
2745                 case SIOCADDMULTI:
2746                 case SIOCDELMULTI:
2747                 case SIOCSIFHWBROADCAST:
2748                 case SIOCSIFTXQLEN:
2749                 case SIOCSMIIREG:
2750                 case SIOCBONDENSLAVE:
2751                 case SIOCBONDRELEASE:
2752                 case SIOCBONDSETHWADDR:
2753                 case SIOCBONDCHANGEACTIVE:
2754                 case SIOCBRADDIF:
2755                 case SIOCBRDELIF:
2756                         if (!capable(CAP_NET_ADMIN))
2757                                 return -EPERM;
2758                         /* fall through */
2759                 case SIOCBONDSLAVEINFOQUERY:
2760                 case SIOCBONDINFOQUERY:
2761                         dev_load(ifr.ifr_name);
2762                         rtnl_lock();
2763                         ret = dev_ifsioc(&ifr, cmd);
2764                         rtnl_unlock();
2765                         return ret;
2766
2767                 case SIOCGIFMEM:
2768                         /* Get the per device memory space. We can add this but
2769                          * currently do not support it */
2770                 case SIOCSIFMEM:
2771                         /* Set the per device memory buffer space.
2772                          * Not applicable in our case */
2773                 case SIOCSIFLINK:
2774                         return -EINVAL;
2775
2776                 /*
2777                  *      Unknown or private ioctl.
2778                  */
2779                 default:
2780                         if (cmd == SIOCWANDEV ||
2781                             (cmd >= SIOCDEVPRIVATE &&
2782                              cmd <= SIOCDEVPRIVATE + 15)) {
2783                                 dev_load(ifr.ifr_name);
2784                                 rtnl_lock();
2785                                 ret = dev_ifsioc(&ifr, cmd);
2786                                 rtnl_unlock();
2787                                 if (!ret && copy_to_user(arg, &ifr,
2788                                                          sizeof(struct ifreq)))
2789                                         ret = -EFAULT;
2790                                 return ret;
2791                         }
2792 #ifdef CONFIG_WIRELESS_EXT
2793                         /* Take care of Wireless Extensions */
2794                         if (cmd >= SIOCIWFIRST && cmd <= SIOCIWLAST) {
2795                                 /* If command is `set a parameter', or
2796                                  * `get the encoding parameters', check if
2797                                  * the user has the right to do it */
2798                                 if (IW_IS_SET(cmd) || cmd == SIOCGIWENCODE
2799                                     || cmd == SIOCGIWENCODEEXT) {
2800                                         if (!capable(CAP_NET_ADMIN))
2801                                                 return -EPERM;
2802                                 }
2803                                 dev_load(ifr.ifr_name);
2804                                 rtnl_lock();
2805                                 /* Follow me in net/core/wireless.c */
2806                                 ret = wireless_process_ioctl(&ifr, cmd);
2807                                 rtnl_unlock();
2808                                 if (IW_IS_GET(cmd) &&
2809                                     copy_to_user(arg, &ifr,
2810                                                  sizeof(struct ifreq)))
2811                                         ret = -EFAULT;
2812                                 return ret;
2813                         }
2814 #endif  /* CONFIG_WIRELESS_EXT */
2815                         return -EINVAL;
2816         }
2817 }
2818
2819
2820 /**
2821  *      dev_new_index   -       allocate an ifindex
2822  *
2823  *      Returns a suitable unique value for a new device interface
2824  *      number.  The caller must hold the rtnl semaphore or the
2825  *      dev_base_lock to be sure it remains unique.
2826  */
2827 static int dev_new_index(void)
2828 {
2829         static int ifindex;
2830         for (;;) {
2831                 if (++ifindex <= 0)
2832                         ifindex = 1;
2833                 if (!__dev_get_by_index(ifindex))
2834                         return ifindex;
2835         }
2836 }
2837
2838 static int dev_boot_phase = 1;
2839
2840 /* Delayed registration/unregisteration */
2841 static DEFINE_SPINLOCK(net_todo_list_lock);
2842 static struct list_head net_todo_list = LIST_HEAD_INIT(net_todo_list);
2843
2844 static inline void net_set_todo(struct net_device *dev)
2845 {
2846         spin_lock(&net_todo_list_lock);
2847         list_add_tail(&dev->todo_list, &net_todo_list);
2848         spin_unlock(&net_todo_list_lock);
2849 }
2850
2851 /**
2852  *      register_netdevice      - register a network device
2853  *      @dev: device to register
2854  *
2855  *      Take a completed network device structure and add it to the kernel
2856  *      interfaces. A %NETDEV_REGISTER message is sent to the netdev notifier
2857  *      chain. 0 is returned on success. A negative errno code is returned
2858  *      on a failure to set up the device, or if the name is a duplicate.
2859  *
2860  *      Callers must hold the rtnl semaphore. You may want
2861  *      register_netdev() instead of this.
2862  *
2863  *      BUGS:
2864  *      The locking appears insufficient to guarantee two parallel registers
2865  *      will not get the same name.
2866  */
2867
2868 int register_netdevice(struct net_device *dev)
2869 {
2870         struct hlist_head *head;
2871         struct hlist_node *p;
2872         int ret;
2873
2874         BUG_ON(dev_boot_phase);
2875         ASSERT_RTNL();
2876
2877         might_sleep();
2878
2879         /* When net_device's are persistent, this will be fatal. */
2880         BUG_ON(dev->reg_state != NETREG_UNINITIALIZED);
2881
2882         spin_lock_init(&dev->queue_lock);
2883         spin_lock_init(&dev->_xmit_lock);
2884         dev->xmit_lock_owner = -1;
2885 #ifdef CONFIG_NET_CLS_ACT
2886         spin_lock_init(&dev->ingress_lock);
2887 #endif
2888
2889         ret = alloc_divert_blk(dev);
2890         if (ret)
2891                 goto out;
2892
2893         dev->iflink = -1;
2894
2895         /* Init, if this function is available */
2896         if (dev->init) {
2897                 ret = dev->init(dev);
2898                 if (ret) {
2899                         if (ret > 0)
2900                                 ret = -EIO;
2901                         goto out_err;
2902                 }
2903         }
2904  
2905         if (!dev_valid_name(dev->name)) {
2906                 ret = -EINVAL;
2907                 goto out_err;
2908         }
2909
2910         dev->ifindex = dev_new_index();
2911         if (dev->iflink == -1)
2912                 dev->iflink = dev->ifindex;
2913
2914         /* Check for existence of name */
2915         head = dev_name_hash(dev->name);
2916         hlist_for_each(p, head) {
2917                 struct net_device *d
2918                         = hlist_entry(p, struct net_device, name_hlist);
2919                 if (!strncmp(d->name, dev->name, IFNAMSIZ)) {
2920                         ret = -EEXIST;
2921                         goto out_err;
2922                 }
2923         }
2924
2925         /* Fix illegal SG+CSUM combinations. */
2926         if ((dev->features & NETIF_F_SG) &&
2927             !(dev->features & NETIF_F_ALL_CSUM)) {
2928                 printk("%s: Dropping NETIF_F_SG since no checksum feature.\n",
2929                        dev->name);
2930                 dev->features &= ~NETIF_F_SG;
2931         }
2932
2933         /* TSO requires that SG is present as well. */
2934         if ((dev->features & NETIF_F_TSO) &&
2935             !(dev->features & NETIF_F_SG)) {
2936                 printk("%s: Dropping NETIF_F_TSO since no SG feature.\n",
2937                        dev->name);
2938                 dev->features &= ~NETIF_F_TSO;
2939         }
2940         if (dev->features & NETIF_F_UFO) {
2941                 if (!(dev->features & NETIF_F_HW_CSUM)) {
2942                         printk(KERN_ERR "%s: Dropping NETIF_F_UFO since no "
2943                                         "NETIF_F_HW_CSUM feature.\n",
2944                                                         dev->name);
2945                         dev->features &= ~NETIF_F_UFO;
2946                 }
2947                 if (!(dev->features & NETIF_F_SG)) {
2948                         printk(KERN_ERR "%s: Dropping NETIF_F_UFO since no "
2949                                         "NETIF_F_SG feature.\n",
2950                                         dev->name);
2951                         dev->features &= ~NETIF_F_UFO;
2952                 }
2953         }
2954
2955         /*
2956          *      nil rebuild_header routine,
2957          *      that should be never called and used as just bug trap.
2958          */
2959
2960         if (!dev->rebuild_header)
2961                 dev->rebuild_header = default_rebuild_header;
2962
2963         ret = netdev_register_sysfs(dev);
2964         if (ret)
2965                 goto out_err;
2966         dev->reg_state = NETREG_REGISTERED;
2967
2968         /*
2969          *      Default initial state at registry is that the
2970          *      device is present.
2971          */
2972
2973         set_bit(__LINK_STATE_PRESENT, &dev->state);
2974
2975         dev->next = NULL;
2976         dev_init_scheduler(dev);
2977         write_lock_bh(&dev_base_lock);
2978         *dev_tail = dev;
2979         dev_tail = &dev->next;
2980         hlist_add_head(&dev->name_hlist, head);
2981         hlist_add_head(&dev->index_hlist, dev_index_hash(dev->ifindex));
2982         dev_hold(dev);
2983         write_unlock_bh(&dev_base_lock);
2984
2985         /* Notify protocols, that a new device appeared. */
2986         raw_notifier_call_chain(&netdev_chain, NETDEV_REGISTER, dev);
2987
2988         ret = 0;
2989
2990 out:
2991         return ret;
2992 out_err:
2993         free_divert_blk(dev);
2994         goto out;
2995 }
2996
2997 /**
2998  *      register_netdev - register a network device
2999  *      @dev: device to register
3000  *
3001  *      Take a completed network device structure and add it to the kernel
3002  *      interfaces. A %NETDEV_REGISTER message is sent to the netdev notifier
3003  *      chain. 0 is returned on success. A negative errno code is returned
3004  *      on a failure to set up the device, or if the name is a duplicate.
3005  *
3006  *      This is a wrapper around register_netdev that takes the rtnl semaphore
3007  *      and expands the device name if you passed a format string to
3008  *      alloc_netdev.
3009  */
3010 int register_netdev(struct net_device *dev)
3011 {
3012         int err;
3013
3014         rtnl_lock();
3015
3016         /*
3017          * If the name is a format string the caller wants us to do a
3018          * name allocation.
3019          */
3020         if (strchr(dev->name, '%')) {
3021                 err = dev_alloc_name(dev, dev->name);
3022                 if (err < 0)
3023                         goto out;
3024         }
3025         
3026         /*
3027          * Back compatibility hook. Kill this one in 2.5
3028          */
3029         if (dev->name[0] == 0 || dev->name[0] == ' ') {
3030                 err = dev_alloc_name(dev, "eth%d");
3031                 if (err < 0)
3032                         goto out;
3033         }
3034
3035         err = register_netdevice(dev);
3036 out:
3037         rtnl_unlock();
3038         return err;
3039 }
3040 EXPORT_SYMBOL(register_netdev);
3041
3042 /*
3043  * netdev_wait_allrefs - wait until all references are gone.
3044  *
3045  * This is called when unregistering network devices.
3046  *
3047  * Any protocol or device that holds a reference should register
3048  * for netdevice notification, and cleanup and put back the
3049  * reference if they receive an UNREGISTER event.
3050  * We can get stuck here if buggy protocols don't correctly
3051  * call dev_put. 
3052  */
3053 static void netdev_wait_allrefs(struct net_device *dev)
3054 {
3055         unsigned long rebroadcast_time, warning_time;
3056
3057         rebroadcast_time = warning_time = jiffies;
3058         while (atomic_read(&dev->refcnt) != 0) {
3059                 if (time_after(jiffies, rebroadcast_time + 1 * HZ)) {
3060                         rtnl_lock();
3061
3062                         /* Rebroadcast unregister notification */
3063                         raw_notifier_call_chain(&netdev_chain,
3064                                             NETDEV_UNREGISTER, dev);
3065
3066                         if (test_bit(__LINK_STATE_LINKWATCH_PENDING,
3067                                      &dev->state)) {
3068                                 /* We must not have linkwatch events
3069                                  * pending on unregister. If this
3070                                  * happens, we simply run the queue
3071                                  * unscheduled, resulting in a noop
3072                                  * for this device.
3073                                  */
3074                                 linkwatch_run_queue();
3075                         }
3076
3077                         __rtnl_unlock();
3078
3079                         rebroadcast_time = jiffies;
3080                 }
3081
3082                 msleep(250);
3083
3084                 if (time_after(jiffies, warning_time + 10 * HZ)) {
3085                         printk(KERN_EMERG "unregister_netdevice: "
3086                                "waiting for %s to become free. Usage "
3087                                "count = %d\n",
3088                                dev->name, atomic_read(&dev->refcnt));
3089                         warning_time = jiffies;
3090                 }
3091         }
3092 }
3093
3094 /* The sequence is:
3095  *
3096  *      rtnl_lock();
3097  *      ...
3098  *      register_netdevice(x1);
3099  *      register_netdevice(x2);
3100  *      ...
3101  *      unregister_netdevice(y1);
3102  *      unregister_netdevice(y2);
3103  *      ...
3104  *      rtnl_unlock();
3105  *      free_netdev(y1);
3106  *      free_netdev(y2);
3107  *
3108  * We are invoked by rtnl_unlock() after it drops the semaphore.
3109  * This allows us to deal with problems:
3110  * 1) We can delete sysfs objects which invoke hotplug
3111  *    without deadlocking with linkwatch via keventd.
3112  * 2) Since we run with the RTNL semaphore not held, we can sleep
3113  *    safely in order to wait for the netdev refcnt to drop to zero.
3114  */
3115 static DEFINE_MUTEX(net_todo_run_mutex);
3116 void netdev_run_todo(void)
3117 {
3118         struct list_head list;
3119
3120         /* Need to guard against multiple cpu's getting out of order. */
3121         mutex_lock(&net_todo_run_mutex);
3122
3123         /* Not safe to do outside the semaphore.  We must not return
3124          * until all unregister events invoked by the local processor
3125          * have been completed (either by this todo run, or one on
3126          * another cpu).
3127          */
3128         if (list_empty(&net_todo_list))
3129                 goto out;
3130
3131         /* Snapshot list, allow later requests */
3132         spin_lock(&net_todo_list_lock);
3133         list_replace_init(&net_todo_list, &list);
3134         spin_unlock(&net_todo_list_lock);
3135
3136         while (!list_empty(&list)) {
3137                 struct net_device *dev
3138                         = list_entry(list.next, struct net_device, todo_list);
3139                 list_del(&dev->todo_list);
3140
3141                 if (unlikely(dev->reg_state != NETREG_UNREGISTERING)) {
3142                         printk(KERN_ERR "network todo '%s' but state %d\n",
3143                                dev->name, dev->reg_state);
3144                         dump_stack();
3145                         continue;
3146                 }
3147
3148                 netdev_unregister_sysfs(dev);
3149                 dev->reg_state = NETREG_UNREGISTERED;
3150
3151                 netdev_wait_allrefs(dev);
3152
3153                 /* paranoia */
3154                 BUG_ON(atomic_read(&dev->refcnt));
3155                 BUG_TRAP(!dev->ip_ptr);
3156                 BUG_TRAP(!dev->ip6_ptr);
3157                 BUG_TRAP(!dev->dn_ptr);
3158
3159                 /* It must be the very last action,
3160                  * after this 'dev' may point to freed up memory.
3161                  */
3162                 if (dev->destructor)
3163                         dev->destructor(dev);
3164         }
3165
3166 out:
3167         mutex_unlock(&net_todo_run_mutex);
3168 }
3169
3170 /**
3171  *      alloc_netdev - allocate network device
3172  *      @sizeof_priv:   size of private data to allocate space for
3173  *      @name:          device name format string
3174  *      @setup:         callback to initialize device
3175  *
3176  *      Allocates a struct net_device with private data area for driver use
3177  *      and performs basic initialization.
3178  */
3179 struct net_device *alloc_netdev(int sizeof_priv, const char *name,
3180                 void (*setup)(struct net_device *))
3181 {
3182         void *p;
3183         struct net_device *dev;
3184         int alloc_size;
3185
3186         /* ensure 32-byte alignment of both the device and private area */
3187         alloc_size = (sizeof(*dev) + NETDEV_ALIGN_CONST) & ~NETDEV_ALIGN_CONST;
3188         alloc_size += sizeof_priv + NETDEV_ALIGN_CONST;
3189
3190         p = kzalloc(alloc_size, GFP_KERNEL);
3191         if (!p) {
3192                 printk(KERN_ERR "alloc_dev: Unable to allocate device.\n");
3193                 return NULL;
3194         }
3195
3196         dev = (struct net_device *)
3197                 (((long)p + NETDEV_ALIGN_CONST) & ~NETDEV_ALIGN_CONST);
3198         dev->padded = (char *)dev - (char *)p;
3199
3200         if (sizeof_priv)
3201                 dev->priv = netdev_priv(dev);
3202
3203         setup(dev);
3204         strcpy(dev->name, name);
3205         return dev;
3206 }
3207 EXPORT_SYMBOL(alloc_netdev);
3208
3209 /**
3210  *      free_netdev - free network device
3211  *      @dev: device
3212  *
3213  *      This function does the last stage of destroying an allocated device 
3214  *      interface. The reference to the device object is released.  
3215  *      If this is the last reference then it will be freed.
3216  */
3217 void free_netdev(struct net_device *dev)
3218 {
3219 #ifdef CONFIG_SYSFS
3220         /*  Compatibility with error handling in drivers */
3221         if (dev->reg_state == NETREG_UNINITIALIZED) {
3222                 kfree((char *)dev - dev->padded);
3223                 return;
3224         }
3225
3226         BUG_ON(dev->reg_state != NETREG_UNREGISTERED);
3227         dev->reg_state = NETREG_RELEASED;
3228
3229         /* will free via class release */
3230         class_device_put(&dev->class_dev);
3231 #else
3232         kfree((char *)dev - dev->padded);
3233 #endif
3234 }
3235  
3236 /* Synchronize with packet receive processing. */
3237 void synchronize_net(void) 
3238 {
3239         might_sleep();
3240         synchronize_rcu();
3241 }
3242
3243 /**
3244  *      unregister_netdevice - remove device from the kernel
3245  *      @dev: device
3246  *
3247  *      This function shuts down a device interface and removes it
3248  *      from the kernel tables. On success 0 is returned, on a failure
3249  *      a negative errno code is returned.
3250  *
3251  *      Callers must hold the rtnl semaphore.  You may want
3252  *      unregister_netdev() instead of this.
3253  */
3254
3255 int unregister_netdevice(struct net_device *dev)
3256 {
3257         struct net_device *d, **dp;
3258
3259         BUG_ON(dev_boot_phase);
3260         ASSERT_RTNL();
3261
3262         /* Some devices call without registering for initialization unwind. */
3263         if (dev->reg_state == NETREG_UNINITIALIZED) {
3264                 printk(KERN_DEBUG "unregister_netdevice: device %s/%p never "
3265                                   "was registered\n", dev->name, dev);
3266                 return -ENODEV;
3267         }
3268
3269         BUG_ON(dev->reg_state != NETREG_REGISTERED);
3270
3271         /* If device is running, close it first. */
3272         if (dev->flags & IFF_UP)
3273                 dev_close(dev);
3274
3275         /* And unlink it from device chain. */
3276         for (dp = &dev_base; (d = *dp) != NULL; dp = &d->next) {
3277                 if (d == dev) {
3278                         write_lock_bh(&dev_base_lock);
3279                         hlist_del(&dev->name_hlist);
3280                         hlist_del(&dev->index_hlist);
3281                         if (dev_tail == &dev->next)
3282                                 dev_tail = dp;
3283                         *dp = d->next;
3284                         write_unlock_bh(&dev_base_lock);
3285                         break;
3286                 }
3287         }
3288         if (!d) {
3289                 printk(KERN_ERR "unregister net_device: '%s' not found\n",
3290                        dev->name);
3291                 return -ENODEV;
3292         }
3293
3294         dev->reg_state = NETREG_UNREGISTERING;
3295
3296         synchronize_net();
3297
3298         /* Shutdown queueing discipline. */
3299         dev_shutdown(dev);
3300
3301         
3302         /* Notify protocols, that we are about to destroy
3303            this device. They should clean all the things.
3304         */
3305         raw_notifier_call_chain(&netdev_chain, NETDEV_UNREGISTER, dev);
3306         
3307         /*
3308          *      Flush the multicast chain
3309          */
3310         dev_mc_discard(dev);
3311
3312         if (dev->uninit)
3313                 dev->uninit(dev);
3314
3315         /* Notifier chain MUST detach us from master device. */
3316         BUG_TRAP(!dev->master);
3317
3318         free_divert_blk(dev);
3319
3320         /* Finish processing unregister after unlock */
3321         net_set_todo(dev);
3322
3323         synchronize_net();
3324
3325         dev_put(dev);
3326         return 0;
3327 }
3328
3329 /**
3330  *      unregister_netdev - remove device from the kernel
3331  *      @dev: device
3332  *
3333  *      This function shuts down a device interface and removes it
3334  *      from the kernel tables. On success 0 is returned, on a failure
3335  *      a negative errno code is returned.
3336  *
3337  *      This is just a wrapper for unregister_netdevice that takes
3338  *      the rtnl semaphore.  In general you want to use this and not
3339  *      unregister_netdevice.
3340  */
3341 void unregister_netdev(struct net_device *dev)
3342 {
3343         rtnl_lock();
3344         unregister_netdevice(dev);
3345         rtnl_unlock();
3346 }
3347
3348 EXPORT_SYMBOL(unregister_netdev);
3349
3350 #ifdef CONFIG_HOTPLUG_CPU
3351 static int dev_cpu_callback(struct notifier_block *nfb,
3352                             unsigned long action,
3353                             void *ocpu)
3354 {
3355         struct sk_buff **list_skb;
3356         struct net_device **list_net;
3357         struct sk_buff *skb;
3358         unsigned int cpu, oldcpu = (unsigned long)ocpu;
3359         struct softnet_data *sd, *oldsd;
3360
3361         if (action != CPU_DEAD)
3362                 return NOTIFY_OK;
3363
3364         local_irq_disable();
3365         cpu = smp_processor_id();
3366         sd = &per_cpu(softnet_data, cpu);
3367         oldsd = &per_cpu(softnet_data, oldcpu);
3368
3369         /* Find end of our completion_queue. */
3370         list_skb = &sd->completion_queue;
3371         while (*list_skb)
3372                 list_skb = &(*list_skb)->next;
3373         /* Append completion queue from offline CPU. */
3374         *list_skb = oldsd->completion_queue;
3375         oldsd->completion_queue = NULL;
3376
3377         /* Find end of our output_queue. */
3378         list_net = &sd->output_queue;
3379         while (*list_net)
3380                 list_net = &(*list_net)->next_sched;
3381         /* Append output queue from offline CPU. */
3382         *list_net = oldsd->output_queue;
3383         oldsd->output_queue = NULL;
3384
3385         raise_softirq_irqoff(NET_TX_SOFTIRQ);
3386         local_irq_enable();
3387
3388         /* Process offline CPU's input_pkt_queue */
3389         while ((skb = __skb_dequeue(&oldsd->input_pkt_queue)))
3390                 netif_rx(skb);
3391
3392         return NOTIFY_OK;
3393 }
3394 #endif /* CONFIG_HOTPLUG_CPU */
3395
3396 #ifdef CONFIG_NET_DMA
3397 /**
3398  * net_dma_rebalance -
3399  * This is called when the number of channels allocated to the net_dma_client
3400  * changes.  The net_dma_client tries to have one DMA channel per CPU.
3401  */
3402 static void net_dma_rebalance(void)
3403 {
3404         unsigned int cpu, i, n;
3405         struct dma_chan *chan;
3406
3407         lock_cpu_hotplug();
3408
3409         if (net_dma_count == 0) {
3410                 for_each_online_cpu(cpu)
3411                         rcu_assign_pointer(per_cpu(softnet_data.net_dma, cpu), NULL);
3412                 unlock_cpu_hotplug();
3413                 return;
3414         }
3415
3416         i = 0;
3417         cpu = first_cpu(cpu_online_map);
3418
3419         rcu_read_lock();
3420         list_for_each_entry(chan, &net_dma_client->channels, client_node) {
3421                 n = ((num_online_cpus() / net_dma_count)
3422                    + (i < (num_online_cpus() % net_dma_count) ? 1 : 0));
3423
3424                 while(n) {
3425                         per_cpu(softnet_data.net_dma, cpu) = chan;
3426                         cpu = next_cpu(cpu, cpu_online_map);
3427                         n--;
3428                 }
3429                 i++;
3430         }
3431         rcu_read_unlock();
3432
3433         unlock_cpu_hotplug();
3434 }
3435
3436 /**
3437  * netdev_dma_event - event callback for the net_dma_client
3438  * @client: should always be net_dma_client
3439  * @chan: DMA channel for the event
3440  * @event: event type
3441  */
3442 static void netdev_dma_event(struct dma_client *client, struct dma_chan *chan,
3443         enum dma_event event)
3444 {
3445         spin_lock(&net_dma_event_lock);
3446         switch (event) {
3447         case DMA_RESOURCE_ADDED:
3448                 net_dma_count++;
3449                 net_dma_rebalance();
3450                 break;
3451         case DMA_RESOURCE_REMOVED:
3452                 net_dma_count--;
3453                 net_dma_rebalance();
3454                 break;
3455         default:
3456                 break;
3457         }
3458         spin_unlock(&net_dma_event_lock);
3459 }
3460
3461 /**
3462  * netdev_dma_regiser - register the networking subsystem as a DMA client
3463  */
3464 static int __init netdev_dma_register(void)
3465 {
3466         spin_lock_init(&net_dma_event_lock);
3467         net_dma_client = dma_async_client_register(netdev_dma_event);
3468         if (net_dma_client == NULL)
3469                 return -ENOMEM;
3470
3471         dma_async_client_chan_request(net_dma_client, num_online_cpus());
3472         return 0;
3473 }
3474
3475 #else
3476 static int __init netdev_dma_register(void) { return -ENODEV; }
3477 #endif /* CONFIG_NET_DMA */
3478
3479 /*
3480  *      Initialize the DEV module. At boot time this walks the device list and
3481  *      unhooks any devices that fail to initialise (normally hardware not
3482  *      present) and leaves us with a valid list of present and active devices.
3483  *
3484  */
3485
3486 /*
3487  *       This is called single threaded during boot, so no need
3488  *       to take the rtnl semaphore.
3489  */
3490 static int __init net_dev_init(void)
3491 {
3492         int i, rc = -ENOMEM;
3493
3494         BUG_ON(!dev_boot_phase);
3495
3496         net_random_init();
3497
3498         if (dev_proc_init())
3499                 goto out;
3500
3501         if (netdev_sysfs_init())
3502                 goto out;
3503
3504         INIT_LIST_HEAD(&ptype_all);
3505         for (i = 0; i < 16; i++) 
3506                 INIT_LIST_HEAD(&ptype_base[i]);
3507
3508         for (i = 0; i < ARRAY_SIZE(dev_name_head); i++)
3509                 INIT_HLIST_HEAD(&dev_name_head[i]);
3510
3511         for (i = 0; i < ARRAY_SIZE(dev_index_head); i++)
3512                 INIT_HLIST_HEAD(&dev_index_head[i]);
3513
3514         /*
3515          *      Initialise the packet receive queues.
3516          */
3517
3518         for_each_possible_cpu(i) {
3519                 struct softnet_data *queue;
3520
3521                 queue = &per_cpu(softnet_data, i);
3522                 skb_queue_head_init(&queue->input_pkt_queue);
3523                 queue->completion_queue = NULL;
3524                 INIT_LIST_HEAD(&queue->poll_list);
3525                 set_bit(__LINK_STATE_START, &queue->backlog_dev.state);
3526                 queue->backlog_dev.weight = weight_p;
3527                 queue->backlog_dev.poll = process_backlog;
3528                 atomic_set(&queue->backlog_dev.refcnt, 1);
3529         }
3530
3531         netdev_dma_register();
3532
3533         dev_boot_phase = 0;
3534
3535         open_softirq(NET_TX_SOFTIRQ, net_tx_action, NULL);
3536         open_softirq(NET_RX_SOFTIRQ, net_rx_action, NULL);
3537
3538         hotcpu_notifier(dev_cpu_callback, 0);
3539         dst_init();
3540         dev_mcast_init();
3541         rc = 0;
3542 out:
3543         return rc;
3544 }
3545
3546 subsys_initcall(net_dev_init);
3547
3548 EXPORT_SYMBOL(__dev_get_by_index);
3549 EXPORT_SYMBOL(__dev_get_by_name);
3550 EXPORT_SYMBOL(__dev_remove_pack);
3551 EXPORT_SYMBOL(dev_valid_name);
3552 EXPORT_SYMBOL(dev_add_pack);
3553 EXPORT_SYMBOL(dev_alloc_name);
3554 EXPORT_SYMBOL(dev_close);
3555 EXPORT_SYMBOL(dev_get_by_flags);
3556 EXPORT_SYMBOL(dev_get_by_index);
3557 EXPORT_SYMBOL(dev_get_by_name);
3558 EXPORT_SYMBOL(dev_open);
3559 EXPORT_SYMBOL(dev_queue_xmit);
3560 EXPORT_SYMBOL(dev_remove_pack);
3561 EXPORT_SYMBOL(dev_set_allmulti);
3562 EXPORT_SYMBOL(dev_set_promiscuity);
3563 EXPORT_SYMBOL(dev_change_flags);
3564 EXPORT_SYMBOL(dev_set_mtu);
3565 EXPORT_SYMBOL(dev_set_mac_address);
3566 EXPORT_SYMBOL(free_netdev);
3567 EXPORT_SYMBOL(netdev_boot_setup_check);
3568 EXPORT_SYMBOL(netdev_set_master);
3569 EXPORT_SYMBOL(netdev_state_change);
3570 EXPORT_SYMBOL(netif_receive_skb);
3571 EXPORT_SYMBOL(netif_rx);
3572 EXPORT_SYMBOL(register_gifconf);
3573 EXPORT_SYMBOL(register_netdevice);
3574 EXPORT_SYMBOL(register_netdevice_notifier);
3575 EXPORT_SYMBOL(skb_checksum_help);
3576 EXPORT_SYMBOL(synchronize_net);
3577 EXPORT_SYMBOL(unregister_netdevice);
3578 EXPORT_SYMBOL(unregister_netdevice_notifier);
3579 EXPORT_SYMBOL(net_enable_timestamp);
3580 EXPORT_SYMBOL(net_disable_timestamp);
3581 EXPORT_SYMBOL(dev_get_flags);
3582
3583 #if defined(CONFIG_BRIDGE) || defined(CONFIG_BRIDGE_MODULE)
3584 EXPORT_SYMBOL(br_handle_frame_hook);
3585 EXPORT_SYMBOL(br_fdb_get_hook);
3586 EXPORT_SYMBOL(br_fdb_put_hook);
3587 #endif
3588
3589 #ifdef CONFIG_KMOD
3590 EXPORT_SYMBOL(dev_load);
3591 #endif
3592
3593 EXPORT_PER_CPU_SYMBOL(softnet_data);