f1c52cbd6ef7bfa8ae13ff04913b585b0c9be286
[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  *      @sg: whether scatter-gather is supported on the target.
1194  *
1195  *      This function segments the given skb and returns a list of segments.
1196  */
1197 struct sk_buff *skb_gso_segment(struct sk_buff *skb, int sg)
1198 {
1199         struct sk_buff *segs = ERR_PTR(-EPROTONOSUPPORT);
1200         struct packet_type *ptype;
1201         int type = skb->protocol;
1202
1203         BUG_ON(skb_shinfo(skb)->frag_list);
1204         BUG_ON(skb->ip_summed != CHECKSUM_HW);
1205
1206         skb->mac.raw = skb->data;
1207         skb->mac_len = skb->nh.raw - skb->data;
1208         __skb_pull(skb, skb->mac_len);
1209
1210         rcu_read_lock();
1211         list_for_each_entry_rcu(ptype, &ptype_base[ntohs(type) & 15], list) {
1212                 if (ptype->type == type && !ptype->dev && ptype->gso_segment) {
1213                         segs = ptype->gso_segment(skb, sg);
1214                         break;
1215                 }
1216         }
1217         rcu_read_unlock();
1218
1219         return segs;
1220 }
1221
1222 EXPORT_SYMBOL(skb_gso_segment);
1223
1224 /* Take action when hardware reception checksum errors are detected. */
1225 #ifdef CONFIG_BUG
1226 void netdev_rx_csum_fault(struct net_device *dev)
1227 {
1228         if (net_ratelimit()) {
1229                 printk(KERN_ERR "%s: hw csum failure.\n", 
1230                         dev ? dev->name : "<unknown>");
1231                 dump_stack();
1232         }
1233 }
1234 EXPORT_SYMBOL(netdev_rx_csum_fault);
1235 #endif
1236
1237 #ifdef CONFIG_HIGHMEM
1238 /* Actually, we should eliminate this check as soon as we know, that:
1239  * 1. IOMMU is present and allows to map all the memory.
1240  * 2. No high memory really exists on this machine.
1241  */
1242
1243 static inline int illegal_highdma(struct net_device *dev, struct sk_buff *skb)
1244 {
1245         int i;
1246
1247         if (dev->features & NETIF_F_HIGHDMA)
1248                 return 0;
1249
1250         for (i = 0; i < skb_shinfo(skb)->nr_frags; i++)
1251                 if (PageHighMem(skb_shinfo(skb)->frags[i].page))
1252                         return 1;
1253
1254         return 0;
1255 }
1256 #else
1257 #define illegal_highdma(dev, skb)       (0)
1258 #endif
1259
1260 struct dev_gso_cb {
1261         void (*destructor)(struct sk_buff *skb);
1262 };
1263
1264 #define DEV_GSO_CB(skb) ((struct dev_gso_cb *)(skb)->cb)
1265
1266 static void dev_gso_skb_destructor(struct sk_buff *skb)
1267 {
1268         struct dev_gso_cb *cb;
1269
1270         do {
1271                 struct sk_buff *nskb = skb->next;
1272
1273                 skb->next = nskb->next;
1274                 nskb->next = NULL;
1275                 kfree_skb(nskb);
1276         } while (skb->next);
1277
1278         cb = DEV_GSO_CB(skb);
1279         if (cb->destructor)
1280                 cb->destructor(skb);
1281 }
1282
1283 /**
1284  *      dev_gso_segment - Perform emulated hardware segmentation on skb.
1285  *      @skb: buffer to segment
1286  *
1287  *      This function segments the given skb and stores the list of segments
1288  *      in skb->next.
1289  */
1290 static int dev_gso_segment(struct sk_buff *skb)
1291 {
1292         struct net_device *dev = skb->dev;
1293         struct sk_buff *segs;
1294
1295         segs = skb_gso_segment(skb, dev->features & NETIF_F_SG &&
1296                                     !illegal_highdma(dev, skb));
1297         if (unlikely(IS_ERR(segs)))
1298                 return PTR_ERR(segs);
1299
1300         skb->next = segs;
1301         DEV_GSO_CB(skb)->destructor = skb->destructor;
1302         skb->destructor = dev_gso_skb_destructor;
1303
1304         return 0;
1305 }
1306
1307 int dev_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
1308 {
1309         if (likely(!skb->next)) {
1310                 if (netdev_nit)
1311                         dev_queue_xmit_nit(skb, dev);
1312
1313                 if (!netif_needs_gso(dev, skb))
1314                         return dev->hard_start_xmit(skb, dev);
1315
1316                 if (unlikely(dev_gso_segment(skb)))
1317                         goto out_kfree_skb;
1318         }
1319
1320         do {
1321                 struct sk_buff *nskb = skb->next;
1322                 int rc;
1323
1324                 skb->next = nskb->next;
1325                 nskb->next = NULL;
1326                 rc = dev->hard_start_xmit(nskb, dev);
1327                 if (unlikely(rc)) {
1328                         nskb->next = skb->next;
1329                         skb->next = nskb;
1330                         return rc;
1331                 }
1332                 if (unlikely(netif_queue_stopped(dev) && skb->next))
1333                         return NETDEV_TX_BUSY;
1334         } while (skb->next);
1335         
1336         skb->destructor = DEV_GSO_CB(skb)->destructor;
1337
1338 out_kfree_skb:
1339         kfree_skb(skb);
1340         return 0;
1341 }
1342
1343 #define HARD_TX_LOCK(dev, cpu) {                        \
1344         if ((dev->features & NETIF_F_LLTX) == 0) {      \
1345                 netif_tx_lock(dev);                     \
1346         }                                               \
1347 }
1348
1349 #define HARD_TX_UNLOCK(dev) {                           \
1350         if ((dev->features & NETIF_F_LLTX) == 0) {      \
1351                 netif_tx_unlock(dev);                   \
1352         }                                               \
1353 }
1354
1355 /**
1356  *      dev_queue_xmit - transmit a buffer
1357  *      @skb: buffer to transmit
1358  *
1359  *      Queue a buffer for transmission to a network device. The caller must
1360  *      have set the device and priority and built the buffer before calling
1361  *      this function. The function can be called from an interrupt.
1362  *
1363  *      A negative errno code is returned on a failure. A success does not
1364  *      guarantee the frame will be transmitted as it may be dropped due
1365  *      to congestion or traffic shaping.
1366  *
1367  * -----------------------------------------------------------------------------------
1368  *      I notice this method can also return errors from the queue disciplines,
1369  *      including NET_XMIT_DROP, which is a positive value.  So, errors can also
1370  *      be positive.
1371  *
1372  *      Regardless of the return value, the skb is consumed, so it is currently
1373  *      difficult to retry a send to this method.  (You can bump the ref count
1374  *      before sending to hold a reference for retry if you are careful.)
1375  *
1376  *      When calling this method, interrupts MUST be enabled.  This is because
1377  *      the BH enable code must have IRQs enabled so that it will not deadlock.
1378  *          --BLG
1379  */
1380
1381 int dev_queue_xmit(struct sk_buff *skb)
1382 {
1383         struct net_device *dev = skb->dev;
1384         struct Qdisc *q;
1385         int rc = -ENOMEM;
1386
1387         /* GSO will handle the following emulations directly. */
1388         if (netif_needs_gso(dev, skb))
1389                 goto gso;
1390
1391         if (skb_shinfo(skb)->frag_list &&
1392             !(dev->features & NETIF_F_FRAGLIST) &&
1393             __skb_linearize(skb))
1394                 goto out_kfree_skb;
1395
1396         /* Fragmented skb is linearized if device does not support SG,
1397          * or if at least one of fragments is in highmem and device
1398          * does not support DMA from it.
1399          */
1400         if (skb_shinfo(skb)->nr_frags &&
1401             (!(dev->features & NETIF_F_SG) || illegal_highdma(dev, skb)) &&
1402             __skb_linearize(skb))
1403                 goto out_kfree_skb;
1404
1405         /* If packet is not checksummed and device does not support
1406          * checksumming for this protocol, complete checksumming here.
1407          */
1408         if (skb->ip_summed == CHECKSUM_HW &&
1409             (!(dev->features & NETIF_F_GEN_CSUM) &&
1410              (!(dev->features & NETIF_F_IP_CSUM) ||
1411               skb->protocol != htons(ETH_P_IP))))
1412                 if (skb_checksum_help(skb, 0))
1413                         goto out_kfree_skb;
1414
1415 gso:
1416         spin_lock_prefetch(&dev->queue_lock);
1417
1418         /* Disable soft irqs for various locks below. Also 
1419          * stops preemption for RCU. 
1420          */
1421         rcu_read_lock_bh(); 
1422
1423         /* Updates of qdisc are serialized by queue_lock. 
1424          * The struct Qdisc which is pointed to by qdisc is now a 
1425          * rcu structure - it may be accessed without acquiring 
1426          * a lock (but the structure may be stale.) The freeing of the
1427          * qdisc will be deferred until it's known that there are no 
1428          * more references to it.
1429          * 
1430          * If the qdisc has an enqueue function, we still need to 
1431          * hold the queue_lock before calling it, since queue_lock
1432          * also serializes access to the device queue.
1433          */
1434
1435         q = rcu_dereference(dev->qdisc);
1436 #ifdef CONFIG_NET_CLS_ACT
1437         skb->tc_verd = SET_TC_AT(skb->tc_verd,AT_EGRESS);
1438 #endif
1439         if (q->enqueue) {
1440                 /* Grab device queue */
1441                 spin_lock(&dev->queue_lock);
1442
1443                 rc = q->enqueue(skb, q);
1444
1445                 qdisc_run(dev);
1446
1447                 spin_unlock(&dev->queue_lock);
1448                 rc = rc == NET_XMIT_BYPASS ? NET_XMIT_SUCCESS : rc;
1449                 goto out;
1450         }
1451
1452         /* The device has no queue. Common case for software devices:
1453            loopback, all the sorts of tunnels...
1454
1455            Really, it is unlikely that netif_tx_lock protection is necessary
1456            here.  (f.e. loopback and IP tunnels are clean ignoring statistics
1457            counters.)
1458            However, it is possible, that they rely on protection
1459            made by us here.
1460
1461            Check this and shot the lock. It is not prone from deadlocks.
1462            Either shot noqueue qdisc, it is even simpler 8)
1463          */
1464         if (dev->flags & IFF_UP) {
1465                 int cpu = smp_processor_id(); /* ok because BHs are off */
1466
1467                 if (dev->xmit_lock_owner != cpu) {
1468
1469                         HARD_TX_LOCK(dev, cpu);
1470
1471                         if (!netif_queue_stopped(dev)) {
1472                                 rc = 0;
1473                                 if (!dev_hard_start_xmit(skb, dev)) {
1474                                         HARD_TX_UNLOCK(dev);
1475                                         goto out;
1476                                 }
1477                         }
1478                         HARD_TX_UNLOCK(dev);
1479                         if (net_ratelimit())
1480                                 printk(KERN_CRIT "Virtual device %s asks to "
1481                                        "queue packet!\n", dev->name);
1482                 } else {
1483                         /* Recursion is detected! It is possible,
1484                          * unfortunately */
1485                         if (net_ratelimit())
1486                                 printk(KERN_CRIT "Dead loop on virtual device "
1487                                        "%s, fix it urgently!\n", dev->name);
1488                 }
1489         }
1490
1491         rc = -ENETDOWN;
1492         rcu_read_unlock_bh();
1493
1494 out_kfree_skb:
1495         kfree_skb(skb);
1496         return rc;
1497 out:
1498         rcu_read_unlock_bh();
1499         return rc;
1500 }
1501
1502
1503 /*=======================================================================
1504                         Receiver routines
1505   =======================================================================*/
1506
1507 int netdev_max_backlog = 1000;
1508 int netdev_budget = 300;
1509 int weight_p = 64;            /* old backlog weight */
1510
1511 DEFINE_PER_CPU(struct netif_rx_stats, netdev_rx_stat) = { 0, };
1512
1513
1514 /**
1515  *      netif_rx        -       post buffer to the network code
1516  *      @skb: buffer to post
1517  *
1518  *      This function receives a packet from a device driver and queues it for
1519  *      the upper (protocol) levels to process.  It always succeeds. The buffer
1520  *      may be dropped during processing for congestion control or by the
1521  *      protocol layers.
1522  *
1523  *      return values:
1524  *      NET_RX_SUCCESS  (no congestion)
1525  *      NET_RX_CN_LOW   (low congestion)
1526  *      NET_RX_CN_MOD   (moderate congestion)
1527  *      NET_RX_CN_HIGH  (high congestion)
1528  *      NET_RX_DROP     (packet was dropped)
1529  *
1530  */
1531
1532 int netif_rx(struct sk_buff *skb)
1533 {
1534         struct softnet_data *queue;
1535         unsigned long flags;
1536
1537         /* if netpoll wants it, pretend we never saw it */
1538         if (netpoll_rx(skb))
1539                 return NET_RX_DROP;
1540
1541         if (!skb->tstamp.off_sec)
1542                 net_timestamp(skb);
1543
1544         /*
1545          * The code is rearranged so that the path is the most
1546          * short when CPU is congested, but is still operating.
1547          */
1548         local_irq_save(flags);
1549         queue = &__get_cpu_var(softnet_data);
1550
1551         __get_cpu_var(netdev_rx_stat).total++;
1552         if (queue->input_pkt_queue.qlen <= netdev_max_backlog) {
1553                 if (queue->input_pkt_queue.qlen) {
1554 enqueue:
1555                         dev_hold(skb->dev);
1556                         __skb_queue_tail(&queue->input_pkt_queue, skb);
1557                         local_irq_restore(flags);
1558                         return NET_RX_SUCCESS;
1559                 }
1560
1561                 netif_rx_schedule(&queue->backlog_dev);
1562                 goto enqueue;
1563         }
1564
1565         __get_cpu_var(netdev_rx_stat).dropped++;
1566         local_irq_restore(flags);
1567
1568         kfree_skb(skb);
1569         return NET_RX_DROP;
1570 }
1571
1572 int netif_rx_ni(struct sk_buff *skb)
1573 {
1574         int err;
1575
1576         preempt_disable();
1577         err = netif_rx(skb);
1578         if (local_softirq_pending())
1579                 do_softirq();
1580         preempt_enable();
1581
1582         return err;
1583 }
1584
1585 EXPORT_SYMBOL(netif_rx_ni);
1586
1587 static inline struct net_device *skb_bond(struct sk_buff *skb)
1588 {
1589         struct net_device *dev = skb->dev;
1590
1591         if (dev->master) {
1592                 /*
1593                  * On bonding slaves other than the currently active
1594                  * slave, suppress duplicates except for 802.3ad
1595                  * ETH_P_SLOW and alb non-mcast/bcast.
1596                  */
1597                 if (dev->priv_flags & IFF_SLAVE_INACTIVE) {
1598                         if (dev->master->priv_flags & IFF_MASTER_ALB) {
1599                                 if (skb->pkt_type != PACKET_BROADCAST &&
1600                                     skb->pkt_type != PACKET_MULTICAST)
1601                                         goto keep;
1602                         }
1603
1604                         if (dev->master->priv_flags & IFF_MASTER_8023AD &&
1605                             skb->protocol == __constant_htons(ETH_P_SLOW))
1606                                 goto keep;
1607                 
1608                         kfree_skb(skb);
1609                         return NULL;
1610                 }
1611 keep:
1612                 skb->dev = dev->master;
1613         }
1614
1615         return dev;
1616 }
1617
1618 static void net_tx_action(struct softirq_action *h)
1619 {
1620         struct softnet_data *sd = &__get_cpu_var(softnet_data);
1621
1622         if (sd->completion_queue) {
1623                 struct sk_buff *clist;
1624
1625                 local_irq_disable();
1626                 clist = sd->completion_queue;
1627                 sd->completion_queue = NULL;
1628                 local_irq_enable();
1629
1630                 while (clist) {
1631                         struct sk_buff *skb = clist;
1632                         clist = clist->next;
1633
1634                         BUG_TRAP(!atomic_read(&skb->users));
1635                         __kfree_skb(skb);
1636                 }
1637         }
1638
1639         if (sd->output_queue) {
1640                 struct net_device *head;
1641
1642                 local_irq_disable();
1643                 head = sd->output_queue;
1644                 sd->output_queue = NULL;
1645                 local_irq_enable();
1646
1647                 while (head) {
1648                         struct net_device *dev = head;
1649                         head = head->next_sched;
1650
1651                         smp_mb__before_clear_bit();
1652                         clear_bit(__LINK_STATE_SCHED, &dev->state);
1653
1654                         if (spin_trylock(&dev->queue_lock)) {
1655                                 qdisc_run(dev);
1656                                 spin_unlock(&dev->queue_lock);
1657                         } else {
1658                                 netif_schedule(dev);
1659                         }
1660                 }
1661         }
1662 }
1663
1664 static __inline__ int deliver_skb(struct sk_buff *skb,
1665                                   struct packet_type *pt_prev,
1666                                   struct net_device *orig_dev)
1667 {
1668         atomic_inc(&skb->users);
1669         return pt_prev->func(skb, skb->dev, pt_prev, orig_dev);
1670 }
1671
1672 #if defined(CONFIG_BRIDGE) || defined (CONFIG_BRIDGE_MODULE)
1673 int (*br_handle_frame_hook)(struct net_bridge_port *p, struct sk_buff **pskb);
1674 struct net_bridge;
1675 struct net_bridge_fdb_entry *(*br_fdb_get_hook)(struct net_bridge *br,
1676                                                 unsigned char *addr);
1677 void (*br_fdb_put_hook)(struct net_bridge_fdb_entry *ent);
1678
1679 static __inline__ int handle_bridge(struct sk_buff **pskb,
1680                                     struct packet_type **pt_prev, int *ret,
1681                                     struct net_device *orig_dev)
1682 {
1683         struct net_bridge_port *port;
1684
1685         if ((*pskb)->pkt_type == PACKET_LOOPBACK ||
1686             (port = rcu_dereference((*pskb)->dev->br_port)) == NULL)
1687                 return 0;
1688
1689         if (*pt_prev) {
1690                 *ret = deliver_skb(*pskb, *pt_prev, orig_dev);
1691                 *pt_prev = NULL;
1692         } 
1693         
1694         return br_handle_frame_hook(port, pskb);
1695 }
1696 #else
1697 #define handle_bridge(skb, pt_prev, ret, orig_dev)      (0)
1698 #endif
1699
1700 #ifdef CONFIG_NET_CLS_ACT
1701 /* TODO: Maybe we should just force sch_ingress to be compiled in
1702  * when CONFIG_NET_CLS_ACT is? otherwise some useless instructions
1703  * a compare and 2 stores extra right now if we dont have it on
1704  * but have CONFIG_NET_CLS_ACT
1705  * NOTE: This doesnt stop any functionality; if you dont have 
1706  * the ingress scheduler, you just cant add policies on ingress.
1707  *
1708  */
1709 static int ing_filter(struct sk_buff *skb) 
1710 {
1711         struct Qdisc *q;
1712         struct net_device *dev = skb->dev;
1713         int result = TC_ACT_OK;
1714         
1715         if (dev->qdisc_ingress) {
1716                 __u32 ttl = (__u32) G_TC_RTTL(skb->tc_verd);
1717                 if (MAX_RED_LOOP < ttl++) {
1718                         printk("Redir loop detected Dropping packet (%s->%s)\n",
1719                                 skb->input_dev->name, skb->dev->name);
1720                         return TC_ACT_SHOT;
1721                 }
1722
1723                 skb->tc_verd = SET_TC_RTTL(skb->tc_verd,ttl);
1724
1725                 skb->tc_verd = SET_TC_AT(skb->tc_verd,AT_INGRESS);
1726
1727                 spin_lock(&dev->ingress_lock);
1728                 if ((q = dev->qdisc_ingress) != NULL)
1729                         result = q->enqueue(skb, q);
1730                 spin_unlock(&dev->ingress_lock);
1731
1732         }
1733
1734         return result;
1735 }
1736 #endif
1737
1738 int netif_receive_skb(struct sk_buff *skb)
1739 {
1740         struct packet_type *ptype, *pt_prev;
1741         struct net_device *orig_dev;
1742         int ret = NET_RX_DROP;
1743         unsigned short type;
1744
1745         /* if we've gotten here through NAPI, check netpoll */
1746         if (skb->dev->poll && netpoll_rx(skb))
1747                 return NET_RX_DROP;
1748
1749         if (!skb->tstamp.off_sec)
1750                 net_timestamp(skb);
1751
1752         if (!skb->input_dev)
1753                 skb->input_dev = skb->dev;
1754
1755         orig_dev = skb_bond(skb);
1756
1757         if (!orig_dev)
1758                 return NET_RX_DROP;
1759
1760         __get_cpu_var(netdev_rx_stat).total++;
1761
1762         skb->h.raw = skb->nh.raw = skb->data;
1763         skb->mac_len = skb->nh.raw - skb->mac.raw;
1764
1765         pt_prev = NULL;
1766
1767         rcu_read_lock();
1768
1769 #ifdef CONFIG_NET_CLS_ACT
1770         if (skb->tc_verd & TC_NCLS) {
1771                 skb->tc_verd = CLR_TC_NCLS(skb->tc_verd);
1772                 goto ncls;
1773         }
1774 #endif
1775
1776         list_for_each_entry_rcu(ptype, &ptype_all, list) {
1777                 if (!ptype->dev || ptype->dev == skb->dev) {
1778                         if (pt_prev) 
1779                                 ret = deliver_skb(skb, pt_prev, orig_dev);
1780                         pt_prev = ptype;
1781                 }
1782         }
1783
1784 #ifdef CONFIG_NET_CLS_ACT
1785         if (pt_prev) {
1786                 ret = deliver_skb(skb, pt_prev, orig_dev);
1787                 pt_prev = NULL; /* noone else should process this after*/
1788         } else {
1789                 skb->tc_verd = SET_TC_OK2MUNGE(skb->tc_verd);
1790         }
1791
1792         ret = ing_filter(skb);
1793
1794         if (ret == TC_ACT_SHOT || (ret == TC_ACT_STOLEN)) {
1795                 kfree_skb(skb);
1796                 goto out;
1797         }
1798
1799         skb->tc_verd = 0;
1800 ncls:
1801 #endif
1802
1803         handle_diverter(skb);
1804
1805         if (handle_bridge(&skb, &pt_prev, &ret, orig_dev))
1806                 goto out;
1807
1808         type = skb->protocol;
1809         list_for_each_entry_rcu(ptype, &ptype_base[ntohs(type)&15], list) {
1810                 if (ptype->type == type &&
1811                     (!ptype->dev || ptype->dev == skb->dev)) {
1812                         if (pt_prev) 
1813                                 ret = deliver_skb(skb, pt_prev, orig_dev);
1814                         pt_prev = ptype;
1815                 }
1816         }
1817
1818         if (pt_prev) {
1819                 ret = pt_prev->func(skb, skb->dev, pt_prev, orig_dev);
1820         } else {
1821                 kfree_skb(skb);
1822                 /* Jamal, now you will not able to escape explaining
1823                  * me how you were going to use this. :-)
1824                  */
1825                 ret = NET_RX_DROP;
1826         }
1827
1828 out:
1829         rcu_read_unlock();
1830         return ret;
1831 }
1832
1833 static int process_backlog(struct net_device *backlog_dev, int *budget)
1834 {
1835         int work = 0;
1836         int quota = min(backlog_dev->quota, *budget);
1837         struct softnet_data *queue = &__get_cpu_var(softnet_data);
1838         unsigned long start_time = jiffies;
1839
1840         backlog_dev->weight = weight_p;
1841         for (;;) {
1842                 struct sk_buff *skb;
1843                 struct net_device *dev;
1844
1845                 local_irq_disable();
1846                 skb = __skb_dequeue(&queue->input_pkt_queue);
1847                 if (!skb)
1848                         goto job_done;
1849                 local_irq_enable();
1850
1851                 dev = skb->dev;
1852
1853                 netif_receive_skb(skb);
1854
1855                 dev_put(dev);
1856
1857                 work++;
1858
1859                 if (work >= quota || jiffies - start_time > 1)
1860                         break;
1861
1862         }
1863
1864         backlog_dev->quota -= work;
1865         *budget -= work;
1866         return -1;
1867
1868 job_done:
1869         backlog_dev->quota -= work;
1870         *budget -= work;
1871
1872         list_del(&backlog_dev->poll_list);
1873         smp_mb__before_clear_bit();
1874         netif_poll_enable(backlog_dev);
1875
1876         local_irq_enable();
1877         return 0;
1878 }
1879
1880 static void net_rx_action(struct softirq_action *h)
1881 {
1882         struct softnet_data *queue = &__get_cpu_var(softnet_data);
1883         unsigned long start_time = jiffies;
1884         int budget = netdev_budget;
1885         void *have;
1886
1887         local_irq_disable();
1888
1889         while (!list_empty(&queue->poll_list)) {
1890                 struct net_device *dev;
1891
1892                 if (budget <= 0 || jiffies - start_time > 1)
1893                         goto softnet_break;
1894
1895                 local_irq_enable();
1896
1897                 dev = list_entry(queue->poll_list.next,
1898                                  struct net_device, poll_list);
1899                 have = netpoll_poll_lock(dev);
1900
1901                 if (dev->quota <= 0 || dev->poll(dev, &budget)) {
1902                         netpoll_poll_unlock(have);
1903                         local_irq_disable();
1904                         list_move_tail(&dev->poll_list, &queue->poll_list);
1905                         if (dev->quota < 0)
1906                                 dev->quota += dev->weight;
1907                         else
1908                                 dev->quota = dev->weight;
1909                 } else {
1910                         netpoll_poll_unlock(have);
1911                         dev_put(dev);
1912                         local_irq_disable();
1913                 }
1914         }
1915 out:
1916 #ifdef CONFIG_NET_DMA
1917         /*
1918          * There may not be any more sk_buffs coming right now, so push
1919          * any pending DMA copies to hardware
1920          */
1921         if (net_dma_client) {
1922                 struct dma_chan *chan;
1923                 rcu_read_lock();
1924                 list_for_each_entry_rcu(chan, &net_dma_client->channels, client_node)
1925                         dma_async_memcpy_issue_pending(chan);
1926                 rcu_read_unlock();
1927         }
1928 #endif
1929         local_irq_enable();
1930         return;
1931
1932 softnet_break:
1933         __get_cpu_var(netdev_rx_stat).time_squeeze++;
1934         __raise_softirq_irqoff(NET_RX_SOFTIRQ);
1935         goto out;
1936 }
1937
1938 static gifconf_func_t * gifconf_list [NPROTO];
1939
1940 /**
1941  *      register_gifconf        -       register a SIOCGIF handler
1942  *      @family: Address family
1943  *      @gifconf: Function handler
1944  *
1945  *      Register protocol dependent address dumping routines. The handler
1946  *      that is passed must not be freed or reused until it has been replaced
1947  *      by another handler.
1948  */
1949 int register_gifconf(unsigned int family, gifconf_func_t * gifconf)
1950 {
1951         if (family >= NPROTO)
1952                 return -EINVAL;
1953         gifconf_list[family] = gifconf;
1954         return 0;
1955 }
1956
1957
1958 /*
1959  *      Map an interface index to its name (SIOCGIFNAME)
1960  */
1961
1962 /*
1963  *      We need this ioctl for efficient implementation of the
1964  *      if_indextoname() function required by the IPv6 API.  Without
1965  *      it, we would have to search all the interfaces to find a
1966  *      match.  --pb
1967  */
1968
1969 static int dev_ifname(struct ifreq __user *arg)
1970 {
1971         struct net_device *dev;
1972         struct ifreq ifr;
1973
1974         /*
1975          *      Fetch the caller's info block.
1976          */
1977
1978         if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
1979                 return -EFAULT;
1980
1981         read_lock(&dev_base_lock);
1982         dev = __dev_get_by_index(ifr.ifr_ifindex);
1983         if (!dev) {
1984                 read_unlock(&dev_base_lock);
1985                 return -ENODEV;
1986         }
1987
1988         strcpy(ifr.ifr_name, dev->name);
1989         read_unlock(&dev_base_lock);
1990
1991         if (copy_to_user(arg, &ifr, sizeof(struct ifreq)))
1992                 return -EFAULT;
1993         return 0;
1994 }
1995
1996 /*
1997  *      Perform a SIOCGIFCONF call. This structure will change
1998  *      size eventually, and there is nothing I can do about it.
1999  *      Thus we will need a 'compatibility mode'.
2000  */
2001
2002 static int dev_ifconf(char __user *arg)
2003 {
2004         struct ifconf ifc;
2005         struct net_device *dev;
2006         char __user *pos;
2007         int len;
2008         int total;
2009         int i;
2010
2011         /*
2012          *      Fetch the caller's info block.
2013          */
2014
2015         if (copy_from_user(&ifc, arg, sizeof(struct ifconf)))
2016                 return -EFAULT;
2017
2018         pos = ifc.ifc_buf;
2019         len = ifc.ifc_len;
2020
2021         /*
2022          *      Loop over the interfaces, and write an info block for each.
2023          */
2024
2025         total = 0;
2026         for (dev = dev_base; dev; dev = dev->next) {
2027                 for (i = 0; i < NPROTO; i++) {
2028                         if (gifconf_list[i]) {
2029                                 int done;
2030                                 if (!pos)
2031                                         done = gifconf_list[i](dev, NULL, 0);
2032                                 else
2033                                         done = gifconf_list[i](dev, pos + total,
2034                                                                len - total);
2035                                 if (done < 0)
2036                                         return -EFAULT;
2037                                 total += done;
2038                         }
2039                 }
2040         }
2041
2042         /*
2043          *      All done.  Write the updated control block back to the caller.
2044          */
2045         ifc.ifc_len = total;
2046
2047         /*
2048          *      Both BSD and Solaris return 0 here, so we do too.
2049          */
2050         return copy_to_user(arg, &ifc, sizeof(struct ifconf)) ? -EFAULT : 0;
2051 }
2052
2053 #ifdef CONFIG_PROC_FS
2054 /*
2055  *      This is invoked by the /proc filesystem handler to display a device
2056  *      in detail.
2057  */
2058 static __inline__ struct net_device *dev_get_idx(loff_t pos)
2059 {
2060         struct net_device *dev;
2061         loff_t i;
2062
2063         for (i = 0, dev = dev_base; dev && i < pos; ++i, dev = dev->next);
2064
2065         return i == pos ? dev : NULL;
2066 }
2067
2068 void *dev_seq_start(struct seq_file *seq, loff_t *pos)
2069 {
2070         read_lock(&dev_base_lock);
2071         return *pos ? dev_get_idx(*pos - 1) : SEQ_START_TOKEN;
2072 }
2073
2074 void *dev_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2075 {
2076         ++*pos;
2077         return v == SEQ_START_TOKEN ? dev_base : ((struct net_device *)v)->next;
2078 }
2079
2080 void dev_seq_stop(struct seq_file *seq, void *v)
2081 {
2082         read_unlock(&dev_base_lock);
2083 }
2084
2085 static void dev_seq_printf_stats(struct seq_file *seq, struct net_device *dev)
2086 {
2087         if (dev->get_stats) {
2088                 struct net_device_stats *stats = dev->get_stats(dev);
2089
2090                 seq_printf(seq, "%6s:%8lu %7lu %4lu %4lu %4lu %5lu %10lu %9lu "
2091                                 "%8lu %7lu %4lu %4lu %4lu %5lu %7lu %10lu\n",
2092                            dev->name, stats->rx_bytes, stats->rx_packets,
2093                            stats->rx_errors,
2094                            stats->rx_dropped + stats->rx_missed_errors,
2095                            stats->rx_fifo_errors,
2096                            stats->rx_length_errors + stats->rx_over_errors +
2097                              stats->rx_crc_errors + stats->rx_frame_errors,
2098                            stats->rx_compressed, stats->multicast,
2099                            stats->tx_bytes, stats->tx_packets,
2100                            stats->tx_errors, stats->tx_dropped,
2101                            stats->tx_fifo_errors, stats->collisions,
2102                            stats->tx_carrier_errors +
2103                              stats->tx_aborted_errors +
2104                              stats->tx_window_errors +
2105                              stats->tx_heartbeat_errors,
2106                            stats->tx_compressed);
2107         } else
2108                 seq_printf(seq, "%6s: No statistics available.\n", dev->name);
2109 }
2110
2111 /*
2112  *      Called from the PROCfs module. This now uses the new arbitrary sized
2113  *      /proc/net interface to create /proc/net/dev
2114  */
2115 static int dev_seq_show(struct seq_file *seq, void *v)
2116 {
2117         if (v == SEQ_START_TOKEN)
2118                 seq_puts(seq, "Inter-|   Receive                            "
2119                               "                    |  Transmit\n"
2120                               " face |bytes    packets errs drop fifo frame "
2121                               "compressed multicast|bytes    packets errs "
2122                               "drop fifo colls carrier compressed\n");
2123         else
2124                 dev_seq_printf_stats(seq, v);
2125         return 0;
2126 }
2127
2128 static struct netif_rx_stats *softnet_get_online(loff_t *pos)
2129 {
2130         struct netif_rx_stats *rc = NULL;
2131
2132         while (*pos < NR_CPUS)
2133                 if (cpu_online(*pos)) {
2134                         rc = &per_cpu(netdev_rx_stat, *pos);
2135                         break;
2136                 } else
2137                         ++*pos;
2138         return rc;
2139 }
2140
2141 static void *softnet_seq_start(struct seq_file *seq, loff_t *pos)
2142 {
2143         return softnet_get_online(pos);
2144 }
2145
2146 static void *softnet_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2147 {
2148         ++*pos;
2149         return softnet_get_online(pos);
2150 }
2151
2152 static void softnet_seq_stop(struct seq_file *seq, void *v)
2153 {
2154 }
2155
2156 static int softnet_seq_show(struct seq_file *seq, void *v)
2157 {
2158         struct netif_rx_stats *s = v;
2159
2160         seq_printf(seq, "%08x %08x %08x %08x %08x %08x %08x %08x %08x\n",
2161                    s->total, s->dropped, s->time_squeeze, 0,
2162                    0, 0, 0, 0, /* was fastroute */
2163                    s->cpu_collision );
2164         return 0;
2165 }
2166
2167 static struct seq_operations dev_seq_ops = {
2168         .start = dev_seq_start,
2169         .next  = dev_seq_next,
2170         .stop  = dev_seq_stop,
2171         .show  = dev_seq_show,
2172 };
2173
2174 static int dev_seq_open(struct inode *inode, struct file *file)
2175 {
2176         return seq_open(file, &dev_seq_ops);
2177 }
2178
2179 static struct file_operations dev_seq_fops = {
2180         .owner   = THIS_MODULE,
2181         .open    = dev_seq_open,
2182         .read    = seq_read,
2183         .llseek  = seq_lseek,
2184         .release = seq_release,
2185 };
2186
2187 static struct seq_operations softnet_seq_ops = {
2188         .start = softnet_seq_start,
2189         .next  = softnet_seq_next,
2190         .stop  = softnet_seq_stop,
2191         .show  = softnet_seq_show,
2192 };
2193
2194 static int softnet_seq_open(struct inode *inode, struct file *file)
2195 {
2196         return seq_open(file, &softnet_seq_ops);
2197 }
2198
2199 static struct file_operations softnet_seq_fops = {
2200         .owner   = THIS_MODULE,
2201         .open    = softnet_seq_open,
2202         .read    = seq_read,
2203         .llseek  = seq_lseek,
2204         .release = seq_release,
2205 };
2206
2207 #ifdef CONFIG_WIRELESS_EXT
2208 extern int wireless_proc_init(void);
2209 #else
2210 #define wireless_proc_init() 0
2211 #endif
2212
2213 static int __init dev_proc_init(void)
2214 {
2215         int rc = -ENOMEM;
2216
2217         if (!proc_net_fops_create("dev", S_IRUGO, &dev_seq_fops))
2218                 goto out;
2219         if (!proc_net_fops_create("softnet_stat", S_IRUGO, &softnet_seq_fops))
2220                 goto out_dev;
2221         if (wireless_proc_init())
2222                 goto out_softnet;
2223         rc = 0;
2224 out:
2225         return rc;
2226 out_softnet:
2227         proc_net_remove("softnet_stat");
2228 out_dev:
2229         proc_net_remove("dev");
2230         goto out;
2231 }
2232 #else
2233 #define dev_proc_init() 0
2234 #endif  /* CONFIG_PROC_FS */
2235
2236
2237 /**
2238  *      netdev_set_master       -       set up master/slave pair
2239  *      @slave: slave device
2240  *      @master: new master device
2241  *
2242  *      Changes the master device of the slave. Pass %NULL to break the
2243  *      bonding. The caller must hold the RTNL semaphore. On a failure
2244  *      a negative errno code is returned. On success the reference counts
2245  *      are adjusted, %RTM_NEWLINK is sent to the routing socket and the
2246  *      function returns zero.
2247  */
2248 int netdev_set_master(struct net_device *slave, struct net_device *master)
2249 {
2250         struct net_device *old = slave->master;
2251
2252         ASSERT_RTNL();
2253
2254         if (master) {
2255                 if (old)
2256                         return -EBUSY;
2257                 dev_hold(master);
2258         }
2259
2260         slave->master = master;
2261         
2262         synchronize_net();
2263
2264         if (old)
2265                 dev_put(old);
2266
2267         if (master)
2268                 slave->flags |= IFF_SLAVE;
2269         else
2270                 slave->flags &= ~IFF_SLAVE;
2271
2272         rtmsg_ifinfo(RTM_NEWLINK, slave, IFF_SLAVE);
2273         return 0;
2274 }
2275
2276 /**
2277  *      dev_set_promiscuity     - update promiscuity count on a device
2278  *      @dev: device
2279  *      @inc: modifier
2280  *
2281  *      Add or remove promiscuity from a device. While the count in the device
2282  *      remains above zero the interface remains promiscuous. Once it hits zero
2283  *      the device reverts back to normal filtering operation. A negative inc
2284  *      value is used to drop promiscuity on the device.
2285  */
2286 void dev_set_promiscuity(struct net_device *dev, int inc)
2287 {
2288         unsigned short old_flags = dev->flags;
2289
2290         if ((dev->promiscuity += inc) == 0)
2291                 dev->flags &= ~IFF_PROMISC;
2292         else
2293                 dev->flags |= IFF_PROMISC;
2294         if (dev->flags != old_flags) {
2295                 dev_mc_upload(dev);
2296                 printk(KERN_INFO "device %s %s promiscuous mode\n",
2297                        dev->name, (dev->flags & IFF_PROMISC) ? "entered" :
2298                                                                "left");
2299                 audit_log(current->audit_context, GFP_ATOMIC,
2300                         AUDIT_ANOM_PROMISCUOUS,
2301                         "dev=%s prom=%d old_prom=%d auid=%u",
2302                         dev->name, (dev->flags & IFF_PROMISC),
2303                         (old_flags & IFF_PROMISC),
2304                         audit_get_loginuid(current->audit_context)); 
2305         }
2306 }
2307
2308 /**
2309  *      dev_set_allmulti        - update allmulti count on a device
2310  *      @dev: device
2311  *      @inc: modifier
2312  *
2313  *      Add or remove reception of all multicast frames to a device. While the
2314  *      count in the device remains above zero the interface remains listening
2315  *      to all interfaces. Once it hits zero the device reverts back to normal
2316  *      filtering operation. A negative @inc value is used to drop the counter
2317  *      when releasing a resource needing all multicasts.
2318  */
2319
2320 void dev_set_allmulti(struct net_device *dev, int inc)
2321 {
2322         unsigned short old_flags = dev->flags;
2323
2324         dev->flags |= IFF_ALLMULTI;
2325         if ((dev->allmulti += inc) == 0)
2326                 dev->flags &= ~IFF_ALLMULTI;
2327         if (dev->flags ^ old_flags)
2328                 dev_mc_upload(dev);
2329 }
2330
2331 unsigned dev_get_flags(const struct net_device *dev)
2332 {
2333         unsigned flags;
2334
2335         flags = (dev->flags & ~(IFF_PROMISC |
2336                                 IFF_ALLMULTI |
2337                                 IFF_RUNNING |
2338                                 IFF_LOWER_UP |
2339                                 IFF_DORMANT)) |
2340                 (dev->gflags & (IFF_PROMISC |
2341                                 IFF_ALLMULTI));
2342
2343         if (netif_running(dev)) {
2344                 if (netif_oper_up(dev))
2345                         flags |= IFF_RUNNING;
2346                 if (netif_carrier_ok(dev))
2347                         flags |= IFF_LOWER_UP;
2348                 if (netif_dormant(dev))
2349                         flags |= IFF_DORMANT;
2350         }
2351
2352         return flags;
2353 }
2354
2355 int dev_change_flags(struct net_device *dev, unsigned flags)
2356 {
2357         int ret;
2358         int old_flags = dev->flags;
2359
2360         /*
2361          *      Set the flags on our device.
2362          */
2363
2364         dev->flags = (flags & (IFF_DEBUG | IFF_NOTRAILERS | IFF_NOARP |
2365                                IFF_DYNAMIC | IFF_MULTICAST | IFF_PORTSEL |
2366                                IFF_AUTOMEDIA)) |
2367                      (dev->flags & (IFF_UP | IFF_VOLATILE | IFF_PROMISC |
2368                                     IFF_ALLMULTI));
2369
2370         /*
2371          *      Load in the correct multicast list now the flags have changed.
2372          */
2373
2374         dev_mc_upload(dev);
2375
2376         /*
2377          *      Have we downed the interface. We handle IFF_UP ourselves
2378          *      according to user attempts to set it, rather than blindly
2379          *      setting it.
2380          */
2381
2382         ret = 0;
2383         if ((old_flags ^ flags) & IFF_UP) {     /* Bit is different  ? */
2384                 ret = ((old_flags & IFF_UP) ? dev_close : dev_open)(dev);
2385
2386                 if (!ret)
2387                         dev_mc_upload(dev);
2388         }
2389
2390         if (dev->flags & IFF_UP &&
2391             ((old_flags ^ dev->flags) &~ (IFF_UP | IFF_PROMISC | IFF_ALLMULTI |
2392                                           IFF_VOLATILE)))
2393                 raw_notifier_call_chain(&netdev_chain,
2394                                 NETDEV_CHANGE, dev);
2395
2396         if ((flags ^ dev->gflags) & IFF_PROMISC) {
2397                 int inc = (flags & IFF_PROMISC) ? +1 : -1;
2398                 dev->gflags ^= IFF_PROMISC;
2399                 dev_set_promiscuity(dev, inc);
2400         }
2401
2402         /* NOTE: order of synchronization of IFF_PROMISC and IFF_ALLMULTI
2403            is important. Some (broken) drivers set IFF_PROMISC, when
2404            IFF_ALLMULTI is requested not asking us and not reporting.
2405          */
2406         if ((flags ^ dev->gflags) & IFF_ALLMULTI) {
2407                 int inc = (flags & IFF_ALLMULTI) ? +1 : -1;
2408                 dev->gflags ^= IFF_ALLMULTI;
2409                 dev_set_allmulti(dev, inc);
2410         }
2411
2412         if (old_flags ^ dev->flags)
2413                 rtmsg_ifinfo(RTM_NEWLINK, dev, old_flags ^ dev->flags);
2414
2415         return ret;
2416 }
2417
2418 int dev_set_mtu(struct net_device *dev, int new_mtu)
2419 {
2420         int err;
2421
2422         if (new_mtu == dev->mtu)
2423                 return 0;
2424
2425         /*      MTU must be positive.    */
2426         if (new_mtu < 0)
2427                 return -EINVAL;
2428
2429         if (!netif_device_present(dev))
2430                 return -ENODEV;
2431
2432         err = 0;
2433         if (dev->change_mtu)
2434                 err = dev->change_mtu(dev, new_mtu);
2435         else
2436                 dev->mtu = new_mtu;
2437         if (!err && dev->flags & IFF_UP)
2438                 raw_notifier_call_chain(&netdev_chain,
2439                                 NETDEV_CHANGEMTU, dev);
2440         return err;
2441 }
2442
2443 int dev_set_mac_address(struct net_device *dev, struct sockaddr *sa)
2444 {
2445         int err;
2446
2447         if (!dev->set_mac_address)
2448                 return -EOPNOTSUPP;
2449         if (sa->sa_family != dev->type)
2450                 return -EINVAL;
2451         if (!netif_device_present(dev))
2452                 return -ENODEV;
2453         err = dev->set_mac_address(dev, sa);
2454         if (!err)
2455                 raw_notifier_call_chain(&netdev_chain,
2456                                 NETDEV_CHANGEADDR, dev);
2457         return err;
2458 }
2459
2460 /*
2461  *      Perform the SIOCxIFxxx calls.
2462  */
2463 static int dev_ifsioc(struct ifreq *ifr, unsigned int cmd)
2464 {
2465         int err;
2466         struct net_device *dev = __dev_get_by_name(ifr->ifr_name);
2467
2468         if (!dev)
2469                 return -ENODEV;
2470
2471         switch (cmd) {
2472                 case SIOCGIFFLAGS:      /* Get interface flags */
2473                         ifr->ifr_flags = dev_get_flags(dev);
2474                         return 0;
2475
2476                 case SIOCSIFFLAGS:      /* Set interface flags */
2477                         return dev_change_flags(dev, ifr->ifr_flags);
2478
2479                 case SIOCGIFMETRIC:     /* Get the metric on the interface
2480                                            (currently unused) */
2481                         ifr->ifr_metric = 0;
2482                         return 0;
2483
2484                 case SIOCSIFMETRIC:     /* Set the metric on the interface
2485                                            (currently unused) */
2486                         return -EOPNOTSUPP;
2487
2488                 case SIOCGIFMTU:        /* Get the MTU of a device */
2489                         ifr->ifr_mtu = dev->mtu;
2490                         return 0;
2491
2492                 case SIOCSIFMTU:        /* Set the MTU of a device */
2493                         return dev_set_mtu(dev, ifr->ifr_mtu);
2494
2495                 case SIOCGIFHWADDR:
2496                         if (!dev->addr_len)
2497                                 memset(ifr->ifr_hwaddr.sa_data, 0, sizeof ifr->ifr_hwaddr.sa_data);
2498                         else
2499                                 memcpy(ifr->ifr_hwaddr.sa_data, dev->dev_addr,
2500                                        min(sizeof ifr->ifr_hwaddr.sa_data, (size_t) dev->addr_len));
2501                         ifr->ifr_hwaddr.sa_family = dev->type;
2502                         return 0;
2503
2504                 case SIOCSIFHWADDR:
2505                         return dev_set_mac_address(dev, &ifr->ifr_hwaddr);
2506
2507                 case SIOCSIFHWBROADCAST:
2508                         if (ifr->ifr_hwaddr.sa_family != dev->type)
2509                                 return -EINVAL;
2510                         memcpy(dev->broadcast, ifr->ifr_hwaddr.sa_data,
2511                                min(sizeof ifr->ifr_hwaddr.sa_data, (size_t) dev->addr_len));
2512                         raw_notifier_call_chain(&netdev_chain,
2513                                             NETDEV_CHANGEADDR, dev);
2514                         return 0;
2515
2516                 case SIOCGIFMAP:
2517                         ifr->ifr_map.mem_start = dev->mem_start;
2518                         ifr->ifr_map.mem_end   = dev->mem_end;
2519                         ifr->ifr_map.base_addr = dev->base_addr;
2520                         ifr->ifr_map.irq       = dev->irq;
2521                         ifr->ifr_map.dma       = dev->dma;
2522                         ifr->ifr_map.port      = dev->if_port;
2523                         return 0;
2524
2525                 case SIOCSIFMAP:
2526                         if (dev->set_config) {
2527                                 if (!netif_device_present(dev))
2528                                         return -ENODEV;
2529                                 return dev->set_config(dev, &ifr->ifr_map);
2530                         }
2531                         return -EOPNOTSUPP;
2532
2533                 case SIOCADDMULTI:
2534                         if (!dev->set_multicast_list ||
2535                             ifr->ifr_hwaddr.sa_family != AF_UNSPEC)
2536                                 return -EINVAL;
2537                         if (!netif_device_present(dev))
2538                                 return -ENODEV;
2539                         return dev_mc_add(dev, ifr->ifr_hwaddr.sa_data,
2540                                           dev->addr_len, 1);
2541
2542                 case SIOCDELMULTI:
2543                         if (!dev->set_multicast_list ||
2544                             ifr->ifr_hwaddr.sa_family != AF_UNSPEC)
2545                                 return -EINVAL;
2546                         if (!netif_device_present(dev))
2547                                 return -ENODEV;
2548                         return dev_mc_delete(dev, ifr->ifr_hwaddr.sa_data,
2549                                              dev->addr_len, 1);
2550
2551                 case SIOCGIFINDEX:
2552                         ifr->ifr_ifindex = dev->ifindex;
2553                         return 0;
2554
2555                 case SIOCGIFTXQLEN:
2556                         ifr->ifr_qlen = dev->tx_queue_len;
2557                         return 0;
2558
2559                 case SIOCSIFTXQLEN:
2560                         if (ifr->ifr_qlen < 0)
2561                                 return -EINVAL;
2562                         dev->tx_queue_len = ifr->ifr_qlen;
2563                         return 0;
2564
2565                 case SIOCSIFNAME:
2566                         ifr->ifr_newname[IFNAMSIZ-1] = '\0';
2567                         return dev_change_name(dev, ifr->ifr_newname);
2568
2569                 /*
2570                  *      Unknown or private ioctl
2571                  */
2572
2573                 default:
2574                         if ((cmd >= SIOCDEVPRIVATE &&
2575                             cmd <= SIOCDEVPRIVATE + 15) ||
2576                             cmd == SIOCBONDENSLAVE ||
2577                             cmd == SIOCBONDRELEASE ||
2578                             cmd == SIOCBONDSETHWADDR ||
2579                             cmd == SIOCBONDSLAVEINFOQUERY ||
2580                             cmd == SIOCBONDINFOQUERY ||
2581                             cmd == SIOCBONDCHANGEACTIVE ||
2582                             cmd == SIOCGMIIPHY ||
2583                             cmd == SIOCGMIIREG ||
2584                             cmd == SIOCSMIIREG ||
2585                             cmd == SIOCBRADDIF ||
2586                             cmd == SIOCBRDELIF ||
2587                             cmd == SIOCWANDEV) {
2588                                 err = -EOPNOTSUPP;
2589                                 if (dev->do_ioctl) {
2590                                         if (netif_device_present(dev))
2591                                                 err = dev->do_ioctl(dev, ifr,
2592                                                                     cmd);
2593                                         else
2594                                                 err = -ENODEV;
2595                                 }
2596                         } else
2597                                 err = -EINVAL;
2598
2599         }
2600         return err;
2601 }
2602
2603 /*
2604  *      This function handles all "interface"-type I/O control requests. The actual
2605  *      'doing' part of this is dev_ifsioc above.
2606  */
2607
2608 /**
2609  *      dev_ioctl       -       network device ioctl
2610  *      @cmd: command to issue
2611  *      @arg: pointer to a struct ifreq in user space
2612  *
2613  *      Issue ioctl functions to devices. This is normally called by the
2614  *      user space syscall interfaces but can sometimes be useful for
2615  *      other purposes. The return value is the return from the syscall if
2616  *      positive or a negative errno code on error.
2617  */
2618
2619 int dev_ioctl(unsigned int cmd, void __user *arg)
2620 {
2621         struct ifreq ifr;
2622         int ret;
2623         char *colon;
2624
2625         /* One special case: SIOCGIFCONF takes ifconf argument
2626            and requires shared lock, because it sleeps writing
2627            to user space.
2628          */
2629
2630         if (cmd == SIOCGIFCONF) {
2631                 rtnl_lock();
2632                 ret = dev_ifconf((char __user *) arg);
2633                 rtnl_unlock();
2634                 return ret;
2635         }
2636         if (cmd == SIOCGIFNAME)
2637                 return dev_ifname((struct ifreq __user *)arg);
2638
2639         if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
2640                 return -EFAULT;
2641
2642         ifr.ifr_name[IFNAMSIZ-1] = 0;
2643
2644         colon = strchr(ifr.ifr_name, ':');
2645         if (colon)
2646                 *colon = 0;
2647
2648         /*
2649          *      See which interface the caller is talking about.
2650          */
2651
2652         switch (cmd) {
2653                 /*
2654                  *      These ioctl calls:
2655                  *      - can be done by all.
2656                  *      - atomic and do not require locking.
2657                  *      - return a value
2658                  */
2659                 case SIOCGIFFLAGS:
2660                 case SIOCGIFMETRIC:
2661                 case SIOCGIFMTU:
2662                 case SIOCGIFHWADDR:
2663                 case SIOCGIFSLAVE:
2664                 case SIOCGIFMAP:
2665                 case SIOCGIFINDEX:
2666                 case SIOCGIFTXQLEN:
2667                         dev_load(ifr.ifr_name);
2668                         read_lock(&dev_base_lock);
2669                         ret = dev_ifsioc(&ifr, cmd);
2670                         read_unlock(&dev_base_lock);
2671                         if (!ret) {
2672                                 if (colon)
2673                                         *colon = ':';
2674                                 if (copy_to_user(arg, &ifr,
2675                                                  sizeof(struct ifreq)))
2676                                         ret = -EFAULT;
2677                         }
2678                         return ret;
2679
2680                 case SIOCETHTOOL:
2681                         dev_load(ifr.ifr_name);
2682                         rtnl_lock();
2683                         ret = dev_ethtool(&ifr);
2684                         rtnl_unlock();
2685                         if (!ret) {
2686                                 if (colon)
2687                                         *colon = ':';
2688                                 if (copy_to_user(arg, &ifr,
2689                                                  sizeof(struct ifreq)))
2690                                         ret = -EFAULT;
2691                         }
2692                         return ret;
2693
2694                 /*
2695                  *      These ioctl calls:
2696                  *      - require superuser power.
2697                  *      - require strict serialization.
2698                  *      - return a value
2699                  */
2700                 case SIOCGMIIPHY:
2701                 case SIOCGMIIREG:
2702                 case SIOCSIFNAME:
2703                         if (!capable(CAP_NET_ADMIN))
2704                                 return -EPERM;
2705                         dev_load(ifr.ifr_name);
2706                         rtnl_lock();
2707                         ret = dev_ifsioc(&ifr, cmd);
2708                         rtnl_unlock();
2709                         if (!ret) {
2710                                 if (colon)
2711                                         *colon = ':';
2712                                 if (copy_to_user(arg, &ifr,
2713                                                  sizeof(struct ifreq)))
2714                                         ret = -EFAULT;
2715                         }
2716                         return ret;
2717
2718                 /*
2719                  *      These ioctl calls:
2720                  *      - require superuser power.
2721                  *      - require strict serialization.
2722                  *      - do not return a value
2723                  */
2724                 case SIOCSIFFLAGS:
2725                 case SIOCSIFMETRIC:
2726                 case SIOCSIFMTU:
2727                 case SIOCSIFMAP:
2728                 case SIOCSIFHWADDR:
2729                 case SIOCSIFSLAVE:
2730                 case SIOCADDMULTI:
2731                 case SIOCDELMULTI:
2732                 case SIOCSIFHWBROADCAST:
2733                 case SIOCSIFTXQLEN:
2734                 case SIOCSMIIREG:
2735                 case SIOCBONDENSLAVE:
2736                 case SIOCBONDRELEASE:
2737                 case SIOCBONDSETHWADDR:
2738                 case SIOCBONDCHANGEACTIVE:
2739                 case SIOCBRADDIF:
2740                 case SIOCBRDELIF:
2741                         if (!capable(CAP_NET_ADMIN))
2742                                 return -EPERM;
2743                         /* fall through */
2744                 case SIOCBONDSLAVEINFOQUERY:
2745                 case SIOCBONDINFOQUERY:
2746                         dev_load(ifr.ifr_name);
2747                         rtnl_lock();
2748                         ret = dev_ifsioc(&ifr, cmd);
2749                         rtnl_unlock();
2750                         return ret;
2751
2752                 case SIOCGIFMEM:
2753                         /* Get the per device memory space. We can add this but
2754                          * currently do not support it */
2755                 case SIOCSIFMEM:
2756                         /* Set the per device memory buffer space.
2757                          * Not applicable in our case */
2758                 case SIOCSIFLINK:
2759                         return -EINVAL;
2760
2761                 /*
2762                  *      Unknown or private ioctl.
2763                  */
2764                 default:
2765                         if (cmd == SIOCWANDEV ||
2766                             (cmd >= SIOCDEVPRIVATE &&
2767                              cmd <= SIOCDEVPRIVATE + 15)) {
2768                                 dev_load(ifr.ifr_name);
2769                                 rtnl_lock();
2770                                 ret = dev_ifsioc(&ifr, cmd);
2771                                 rtnl_unlock();
2772                                 if (!ret && copy_to_user(arg, &ifr,
2773                                                          sizeof(struct ifreq)))
2774                                         ret = -EFAULT;
2775                                 return ret;
2776                         }
2777 #ifdef CONFIG_WIRELESS_EXT
2778                         /* Take care of Wireless Extensions */
2779                         if (cmd >= SIOCIWFIRST && cmd <= SIOCIWLAST) {
2780                                 /* If command is `set a parameter', or
2781                                  * `get the encoding parameters', check if
2782                                  * the user has the right to do it */
2783                                 if (IW_IS_SET(cmd) || cmd == SIOCGIWENCODE
2784                                     || cmd == SIOCGIWENCODEEXT) {
2785                                         if (!capable(CAP_NET_ADMIN))
2786                                                 return -EPERM;
2787                                 }
2788                                 dev_load(ifr.ifr_name);
2789                                 rtnl_lock();
2790                                 /* Follow me in net/core/wireless.c */
2791                                 ret = wireless_process_ioctl(&ifr, cmd);
2792                                 rtnl_unlock();
2793                                 if (IW_IS_GET(cmd) &&
2794                                     copy_to_user(arg, &ifr,
2795                                                  sizeof(struct ifreq)))
2796                                         ret = -EFAULT;
2797                                 return ret;
2798                         }
2799 #endif  /* CONFIG_WIRELESS_EXT */
2800                         return -EINVAL;
2801         }
2802 }
2803
2804
2805 /**
2806  *      dev_new_index   -       allocate an ifindex
2807  *
2808  *      Returns a suitable unique value for a new device interface
2809  *      number.  The caller must hold the rtnl semaphore or the
2810  *      dev_base_lock to be sure it remains unique.
2811  */
2812 static int dev_new_index(void)
2813 {
2814         static int ifindex;
2815         for (;;) {
2816                 if (++ifindex <= 0)
2817                         ifindex = 1;
2818                 if (!__dev_get_by_index(ifindex))
2819                         return ifindex;
2820         }
2821 }
2822
2823 static int dev_boot_phase = 1;
2824
2825 /* Delayed registration/unregisteration */
2826 static DEFINE_SPINLOCK(net_todo_list_lock);
2827 static struct list_head net_todo_list = LIST_HEAD_INIT(net_todo_list);
2828
2829 static inline void net_set_todo(struct net_device *dev)
2830 {
2831         spin_lock(&net_todo_list_lock);
2832         list_add_tail(&dev->todo_list, &net_todo_list);
2833         spin_unlock(&net_todo_list_lock);
2834 }
2835
2836 /**
2837  *      register_netdevice      - register a network device
2838  *      @dev: device to register
2839  *
2840  *      Take a completed network device structure and add it to the kernel
2841  *      interfaces. A %NETDEV_REGISTER message is sent to the netdev notifier
2842  *      chain. 0 is returned on success. A negative errno code is returned
2843  *      on a failure to set up the device, or if the name is a duplicate.
2844  *
2845  *      Callers must hold the rtnl semaphore. You may want
2846  *      register_netdev() instead of this.
2847  *
2848  *      BUGS:
2849  *      The locking appears insufficient to guarantee two parallel registers
2850  *      will not get the same name.
2851  */
2852
2853 int register_netdevice(struct net_device *dev)
2854 {
2855         struct hlist_head *head;
2856         struct hlist_node *p;
2857         int ret;
2858
2859         BUG_ON(dev_boot_phase);
2860         ASSERT_RTNL();
2861
2862         might_sleep();
2863
2864         /* When net_device's are persistent, this will be fatal. */
2865         BUG_ON(dev->reg_state != NETREG_UNINITIALIZED);
2866
2867         spin_lock_init(&dev->queue_lock);
2868         spin_lock_init(&dev->_xmit_lock);
2869         dev->xmit_lock_owner = -1;
2870 #ifdef CONFIG_NET_CLS_ACT
2871         spin_lock_init(&dev->ingress_lock);
2872 #endif
2873
2874         ret = alloc_divert_blk(dev);
2875         if (ret)
2876                 goto out;
2877
2878         dev->iflink = -1;
2879
2880         /* Init, if this function is available */
2881         if (dev->init) {
2882                 ret = dev->init(dev);
2883                 if (ret) {
2884                         if (ret > 0)
2885                                 ret = -EIO;
2886                         goto out_err;
2887                 }
2888         }
2889  
2890         if (!dev_valid_name(dev->name)) {
2891                 ret = -EINVAL;
2892                 goto out_err;
2893         }
2894
2895         dev->ifindex = dev_new_index();
2896         if (dev->iflink == -1)
2897                 dev->iflink = dev->ifindex;
2898
2899         /* Check for existence of name */
2900         head = dev_name_hash(dev->name);
2901         hlist_for_each(p, head) {
2902                 struct net_device *d
2903                         = hlist_entry(p, struct net_device, name_hlist);
2904                 if (!strncmp(d->name, dev->name, IFNAMSIZ)) {
2905                         ret = -EEXIST;
2906                         goto out_err;
2907                 }
2908         }
2909
2910         /* Fix illegal SG+CSUM combinations. */
2911         if ((dev->features & NETIF_F_SG) &&
2912             !(dev->features & NETIF_F_ALL_CSUM)) {
2913                 printk("%s: Dropping NETIF_F_SG since no checksum feature.\n",
2914                        dev->name);
2915                 dev->features &= ~NETIF_F_SG;
2916         }
2917
2918         /* TSO requires that SG is present as well. */
2919         if ((dev->features & NETIF_F_TSO) &&
2920             !(dev->features & NETIF_F_SG)) {
2921                 printk("%s: Dropping NETIF_F_TSO since no SG feature.\n",
2922                        dev->name);
2923                 dev->features &= ~NETIF_F_TSO;
2924         }
2925         if (dev->features & NETIF_F_UFO) {
2926                 if (!(dev->features & NETIF_F_HW_CSUM)) {
2927                         printk(KERN_ERR "%s: Dropping NETIF_F_UFO since no "
2928                                         "NETIF_F_HW_CSUM feature.\n",
2929                                                         dev->name);
2930                         dev->features &= ~NETIF_F_UFO;
2931                 }
2932                 if (!(dev->features & NETIF_F_SG)) {
2933                         printk(KERN_ERR "%s: Dropping NETIF_F_UFO since no "
2934                                         "NETIF_F_SG feature.\n",
2935                                         dev->name);
2936                         dev->features &= ~NETIF_F_UFO;
2937                 }
2938         }
2939
2940         /*
2941          *      nil rebuild_header routine,
2942          *      that should be never called and used as just bug trap.
2943          */
2944
2945         if (!dev->rebuild_header)
2946                 dev->rebuild_header = default_rebuild_header;
2947
2948         ret = netdev_register_sysfs(dev);
2949         if (ret)
2950                 goto out_err;
2951         dev->reg_state = NETREG_REGISTERED;
2952
2953         /*
2954          *      Default initial state at registry is that the
2955          *      device is present.
2956          */
2957
2958         set_bit(__LINK_STATE_PRESENT, &dev->state);
2959
2960         dev->next = NULL;
2961         dev_init_scheduler(dev);
2962         write_lock_bh(&dev_base_lock);
2963         *dev_tail = dev;
2964         dev_tail = &dev->next;
2965         hlist_add_head(&dev->name_hlist, head);
2966         hlist_add_head(&dev->index_hlist, dev_index_hash(dev->ifindex));
2967         dev_hold(dev);
2968         write_unlock_bh(&dev_base_lock);
2969
2970         /* Notify protocols, that a new device appeared. */
2971         raw_notifier_call_chain(&netdev_chain, NETDEV_REGISTER, dev);
2972
2973         ret = 0;
2974
2975 out:
2976         return ret;
2977 out_err:
2978         free_divert_blk(dev);
2979         goto out;
2980 }
2981
2982 /**
2983  *      register_netdev - register a network device
2984  *      @dev: device to register
2985  *
2986  *      Take a completed network device structure and add it to the kernel
2987  *      interfaces. A %NETDEV_REGISTER message is sent to the netdev notifier
2988  *      chain. 0 is returned on success. A negative errno code is returned
2989  *      on a failure to set up the device, or if the name is a duplicate.
2990  *
2991  *      This is a wrapper around register_netdev that takes the rtnl semaphore
2992  *      and expands the device name if you passed a format string to
2993  *      alloc_netdev.
2994  */
2995 int register_netdev(struct net_device *dev)
2996 {
2997         int err;
2998
2999         rtnl_lock();
3000
3001         /*
3002          * If the name is a format string the caller wants us to do a
3003          * name allocation.
3004          */
3005         if (strchr(dev->name, '%')) {
3006                 err = dev_alloc_name(dev, dev->name);
3007                 if (err < 0)
3008                         goto out;
3009         }
3010         
3011         /*
3012          * Back compatibility hook. Kill this one in 2.5
3013          */
3014         if (dev->name[0] == 0 || dev->name[0] == ' ') {
3015                 err = dev_alloc_name(dev, "eth%d");
3016                 if (err < 0)
3017                         goto out;
3018         }
3019
3020         err = register_netdevice(dev);
3021 out:
3022         rtnl_unlock();
3023         return err;
3024 }
3025 EXPORT_SYMBOL(register_netdev);
3026
3027 /*
3028  * netdev_wait_allrefs - wait until all references are gone.
3029  *
3030  * This is called when unregistering network devices.
3031  *
3032  * Any protocol or device that holds a reference should register
3033  * for netdevice notification, and cleanup and put back the
3034  * reference if they receive an UNREGISTER event.
3035  * We can get stuck here if buggy protocols don't correctly
3036  * call dev_put. 
3037  */
3038 static void netdev_wait_allrefs(struct net_device *dev)
3039 {
3040         unsigned long rebroadcast_time, warning_time;
3041
3042         rebroadcast_time = warning_time = jiffies;
3043         while (atomic_read(&dev->refcnt) != 0) {
3044                 if (time_after(jiffies, rebroadcast_time + 1 * HZ)) {
3045                         rtnl_lock();
3046
3047                         /* Rebroadcast unregister notification */
3048                         raw_notifier_call_chain(&netdev_chain,
3049                                             NETDEV_UNREGISTER, dev);
3050
3051                         if (test_bit(__LINK_STATE_LINKWATCH_PENDING,
3052                                      &dev->state)) {
3053                                 /* We must not have linkwatch events
3054                                  * pending on unregister. If this
3055                                  * happens, we simply run the queue
3056                                  * unscheduled, resulting in a noop
3057                                  * for this device.
3058                                  */
3059                                 linkwatch_run_queue();
3060                         }
3061
3062                         __rtnl_unlock();
3063
3064                         rebroadcast_time = jiffies;
3065                 }
3066
3067                 msleep(250);
3068
3069                 if (time_after(jiffies, warning_time + 10 * HZ)) {
3070                         printk(KERN_EMERG "unregister_netdevice: "
3071                                "waiting for %s to become free. Usage "
3072                                "count = %d\n",
3073                                dev->name, atomic_read(&dev->refcnt));
3074                         warning_time = jiffies;
3075                 }
3076         }
3077 }
3078
3079 /* The sequence is:
3080  *
3081  *      rtnl_lock();
3082  *      ...
3083  *      register_netdevice(x1);
3084  *      register_netdevice(x2);
3085  *      ...
3086  *      unregister_netdevice(y1);
3087  *      unregister_netdevice(y2);
3088  *      ...
3089  *      rtnl_unlock();
3090  *      free_netdev(y1);
3091  *      free_netdev(y2);
3092  *
3093  * We are invoked by rtnl_unlock() after it drops the semaphore.
3094  * This allows us to deal with problems:
3095  * 1) We can delete sysfs objects which invoke hotplug
3096  *    without deadlocking with linkwatch via keventd.
3097  * 2) Since we run with the RTNL semaphore not held, we can sleep
3098  *    safely in order to wait for the netdev refcnt to drop to zero.
3099  */
3100 static DEFINE_MUTEX(net_todo_run_mutex);
3101 void netdev_run_todo(void)
3102 {
3103         struct list_head list;
3104
3105         /* Need to guard against multiple cpu's getting out of order. */
3106         mutex_lock(&net_todo_run_mutex);
3107
3108         /* Not safe to do outside the semaphore.  We must not return
3109          * until all unregister events invoked by the local processor
3110          * have been completed (either by this todo run, or one on
3111          * another cpu).
3112          */
3113         if (list_empty(&net_todo_list))
3114                 goto out;
3115
3116         /* Snapshot list, allow later requests */
3117         spin_lock(&net_todo_list_lock);
3118         list_replace_init(&net_todo_list, &list);
3119         spin_unlock(&net_todo_list_lock);
3120
3121         while (!list_empty(&list)) {
3122                 struct net_device *dev
3123                         = list_entry(list.next, struct net_device, todo_list);
3124                 list_del(&dev->todo_list);
3125
3126                 if (unlikely(dev->reg_state != NETREG_UNREGISTERING)) {
3127                         printk(KERN_ERR "network todo '%s' but state %d\n",
3128                                dev->name, dev->reg_state);
3129                         dump_stack();
3130                         continue;
3131                 }
3132
3133                 netdev_unregister_sysfs(dev);
3134                 dev->reg_state = NETREG_UNREGISTERED;
3135
3136                 netdev_wait_allrefs(dev);
3137
3138                 /* paranoia */
3139                 BUG_ON(atomic_read(&dev->refcnt));
3140                 BUG_TRAP(!dev->ip_ptr);
3141                 BUG_TRAP(!dev->ip6_ptr);
3142                 BUG_TRAP(!dev->dn_ptr);
3143
3144                 /* It must be the very last action,
3145                  * after this 'dev' may point to freed up memory.
3146                  */
3147                 if (dev->destructor)
3148                         dev->destructor(dev);
3149         }
3150
3151 out:
3152         mutex_unlock(&net_todo_run_mutex);
3153 }
3154
3155 /**
3156  *      alloc_netdev - allocate network device
3157  *      @sizeof_priv:   size of private data to allocate space for
3158  *      @name:          device name format string
3159  *      @setup:         callback to initialize device
3160  *
3161  *      Allocates a struct net_device with private data area for driver use
3162  *      and performs basic initialization.
3163  */
3164 struct net_device *alloc_netdev(int sizeof_priv, const char *name,
3165                 void (*setup)(struct net_device *))
3166 {
3167         void *p;
3168         struct net_device *dev;
3169         int alloc_size;
3170
3171         /* ensure 32-byte alignment of both the device and private area */
3172         alloc_size = (sizeof(*dev) + NETDEV_ALIGN_CONST) & ~NETDEV_ALIGN_CONST;
3173         alloc_size += sizeof_priv + NETDEV_ALIGN_CONST;
3174
3175         p = kzalloc(alloc_size, GFP_KERNEL);
3176         if (!p) {
3177                 printk(KERN_ERR "alloc_dev: Unable to allocate device.\n");
3178                 return NULL;
3179         }
3180
3181         dev = (struct net_device *)
3182                 (((long)p + NETDEV_ALIGN_CONST) & ~NETDEV_ALIGN_CONST);
3183         dev->padded = (char *)dev - (char *)p;
3184
3185         if (sizeof_priv)
3186                 dev->priv = netdev_priv(dev);
3187
3188         setup(dev);
3189         strcpy(dev->name, name);
3190         return dev;
3191 }
3192 EXPORT_SYMBOL(alloc_netdev);
3193
3194 /**
3195  *      free_netdev - free network device
3196  *      @dev: device
3197  *
3198  *      This function does the last stage of destroying an allocated device 
3199  *      interface. The reference to the device object is released.  
3200  *      If this is the last reference then it will be freed.
3201  */
3202 void free_netdev(struct net_device *dev)
3203 {
3204 #ifdef CONFIG_SYSFS
3205         /*  Compatibility with error handling in drivers */
3206         if (dev->reg_state == NETREG_UNINITIALIZED) {
3207                 kfree((char *)dev - dev->padded);
3208                 return;
3209         }
3210
3211         BUG_ON(dev->reg_state != NETREG_UNREGISTERED);
3212         dev->reg_state = NETREG_RELEASED;
3213
3214         /* will free via class release */
3215         class_device_put(&dev->class_dev);
3216 #else
3217         kfree((char *)dev - dev->padded);
3218 #endif
3219 }
3220  
3221 /* Synchronize with packet receive processing. */
3222 void synchronize_net(void) 
3223 {
3224         might_sleep();
3225         synchronize_rcu();
3226 }
3227
3228 /**
3229  *      unregister_netdevice - remove device from the kernel
3230  *      @dev: device
3231  *
3232  *      This function shuts down a device interface and removes it
3233  *      from the kernel tables. On success 0 is returned, on a failure
3234  *      a negative errno code is returned.
3235  *
3236  *      Callers must hold the rtnl semaphore.  You may want
3237  *      unregister_netdev() instead of this.
3238  */
3239
3240 int unregister_netdevice(struct net_device *dev)
3241 {
3242         struct net_device *d, **dp;
3243
3244         BUG_ON(dev_boot_phase);
3245         ASSERT_RTNL();
3246
3247         /* Some devices call without registering for initialization unwind. */
3248         if (dev->reg_state == NETREG_UNINITIALIZED) {
3249                 printk(KERN_DEBUG "unregister_netdevice: device %s/%p never "
3250                                   "was registered\n", dev->name, dev);
3251                 return -ENODEV;
3252         }
3253
3254         BUG_ON(dev->reg_state != NETREG_REGISTERED);
3255
3256         /* If device is running, close it first. */
3257         if (dev->flags & IFF_UP)
3258                 dev_close(dev);
3259
3260         /* And unlink it from device chain. */
3261         for (dp = &dev_base; (d = *dp) != NULL; dp = &d->next) {
3262                 if (d == dev) {
3263                         write_lock_bh(&dev_base_lock);
3264                         hlist_del(&dev->name_hlist);
3265                         hlist_del(&dev->index_hlist);
3266                         if (dev_tail == &dev->next)
3267                                 dev_tail = dp;
3268                         *dp = d->next;
3269                         write_unlock_bh(&dev_base_lock);
3270                         break;
3271                 }
3272         }
3273         if (!d) {
3274                 printk(KERN_ERR "unregister net_device: '%s' not found\n",
3275                        dev->name);
3276                 return -ENODEV;
3277         }
3278
3279         dev->reg_state = NETREG_UNREGISTERING;
3280
3281         synchronize_net();
3282
3283         /* Shutdown queueing discipline. */
3284         dev_shutdown(dev);
3285
3286         
3287         /* Notify protocols, that we are about to destroy
3288            this device. They should clean all the things.
3289         */
3290         raw_notifier_call_chain(&netdev_chain, NETDEV_UNREGISTER, dev);
3291         
3292         /*
3293          *      Flush the multicast chain
3294          */
3295         dev_mc_discard(dev);
3296
3297         if (dev->uninit)
3298                 dev->uninit(dev);
3299
3300         /* Notifier chain MUST detach us from master device. */
3301         BUG_TRAP(!dev->master);
3302
3303         free_divert_blk(dev);
3304
3305         /* Finish processing unregister after unlock */
3306         net_set_todo(dev);
3307
3308         synchronize_net();
3309
3310         dev_put(dev);
3311         return 0;
3312 }
3313
3314 /**
3315  *      unregister_netdev - remove device from the kernel
3316  *      @dev: device
3317  *
3318  *      This function shuts down a device interface and removes it
3319  *      from the kernel tables. On success 0 is returned, on a failure
3320  *      a negative errno code is returned.
3321  *
3322  *      This is just a wrapper for unregister_netdevice that takes
3323  *      the rtnl semaphore.  In general you want to use this and not
3324  *      unregister_netdevice.
3325  */
3326 void unregister_netdev(struct net_device *dev)
3327 {
3328         rtnl_lock();
3329         unregister_netdevice(dev);
3330         rtnl_unlock();
3331 }
3332
3333 EXPORT_SYMBOL(unregister_netdev);
3334
3335 #ifdef CONFIG_HOTPLUG_CPU
3336 static int dev_cpu_callback(struct notifier_block *nfb,
3337                             unsigned long action,
3338                             void *ocpu)
3339 {
3340         struct sk_buff **list_skb;
3341         struct net_device **list_net;
3342         struct sk_buff *skb;
3343         unsigned int cpu, oldcpu = (unsigned long)ocpu;
3344         struct softnet_data *sd, *oldsd;
3345
3346         if (action != CPU_DEAD)
3347                 return NOTIFY_OK;
3348
3349         local_irq_disable();
3350         cpu = smp_processor_id();
3351         sd = &per_cpu(softnet_data, cpu);
3352         oldsd = &per_cpu(softnet_data, oldcpu);
3353
3354         /* Find end of our completion_queue. */
3355         list_skb = &sd->completion_queue;
3356         while (*list_skb)
3357                 list_skb = &(*list_skb)->next;
3358         /* Append completion queue from offline CPU. */
3359         *list_skb = oldsd->completion_queue;
3360         oldsd->completion_queue = NULL;
3361
3362         /* Find end of our output_queue. */
3363         list_net = &sd->output_queue;
3364         while (*list_net)
3365                 list_net = &(*list_net)->next_sched;
3366         /* Append output queue from offline CPU. */
3367         *list_net = oldsd->output_queue;
3368         oldsd->output_queue = NULL;
3369
3370         raise_softirq_irqoff(NET_TX_SOFTIRQ);
3371         local_irq_enable();
3372
3373         /* Process offline CPU's input_pkt_queue */
3374         while ((skb = __skb_dequeue(&oldsd->input_pkt_queue)))
3375                 netif_rx(skb);
3376
3377         return NOTIFY_OK;
3378 }
3379 #endif /* CONFIG_HOTPLUG_CPU */
3380
3381 #ifdef CONFIG_NET_DMA
3382 /**
3383  * net_dma_rebalance -
3384  * This is called when the number of channels allocated to the net_dma_client
3385  * changes.  The net_dma_client tries to have one DMA channel per CPU.
3386  */
3387 static void net_dma_rebalance(void)
3388 {
3389         unsigned int cpu, i, n;
3390         struct dma_chan *chan;
3391
3392         lock_cpu_hotplug();
3393
3394         if (net_dma_count == 0) {
3395                 for_each_online_cpu(cpu)
3396                         rcu_assign_pointer(per_cpu(softnet_data.net_dma, cpu), NULL);
3397                 unlock_cpu_hotplug();
3398                 return;
3399         }
3400
3401         i = 0;
3402         cpu = first_cpu(cpu_online_map);
3403
3404         rcu_read_lock();
3405         list_for_each_entry(chan, &net_dma_client->channels, client_node) {
3406                 n = ((num_online_cpus() / net_dma_count)
3407                    + (i < (num_online_cpus() % net_dma_count) ? 1 : 0));
3408
3409                 while(n) {
3410                         per_cpu(softnet_data.net_dma, cpu) = chan;
3411                         cpu = next_cpu(cpu, cpu_online_map);
3412                         n--;
3413                 }
3414                 i++;
3415         }
3416         rcu_read_unlock();
3417
3418         unlock_cpu_hotplug();
3419 }
3420
3421 /**
3422  * netdev_dma_event - event callback for the net_dma_client
3423  * @client: should always be net_dma_client
3424  * @chan: DMA channel for the event
3425  * @event: event type
3426  */
3427 static void netdev_dma_event(struct dma_client *client, struct dma_chan *chan,
3428         enum dma_event event)
3429 {
3430         spin_lock(&net_dma_event_lock);
3431         switch (event) {
3432         case DMA_RESOURCE_ADDED:
3433                 net_dma_count++;
3434                 net_dma_rebalance();
3435                 break;
3436         case DMA_RESOURCE_REMOVED:
3437                 net_dma_count--;
3438                 net_dma_rebalance();
3439                 break;
3440         default:
3441                 break;
3442         }
3443         spin_unlock(&net_dma_event_lock);
3444 }
3445
3446 /**
3447  * netdev_dma_regiser - register the networking subsystem as a DMA client
3448  */
3449 static int __init netdev_dma_register(void)
3450 {
3451         spin_lock_init(&net_dma_event_lock);
3452         net_dma_client = dma_async_client_register(netdev_dma_event);
3453         if (net_dma_client == NULL)
3454                 return -ENOMEM;
3455
3456         dma_async_client_chan_request(net_dma_client, num_online_cpus());
3457         return 0;
3458 }
3459
3460 #else
3461 static int __init netdev_dma_register(void) { return -ENODEV; }
3462 #endif /* CONFIG_NET_DMA */
3463
3464 /*
3465  *      Initialize the DEV module. At boot time this walks the device list and
3466  *      unhooks any devices that fail to initialise (normally hardware not
3467  *      present) and leaves us with a valid list of present and active devices.
3468  *
3469  */
3470
3471 /*
3472  *       This is called single threaded during boot, so no need
3473  *       to take the rtnl semaphore.
3474  */
3475 static int __init net_dev_init(void)
3476 {
3477         int i, rc = -ENOMEM;
3478
3479         BUG_ON(!dev_boot_phase);
3480
3481         net_random_init();
3482
3483         if (dev_proc_init())
3484                 goto out;
3485
3486         if (netdev_sysfs_init())
3487                 goto out;
3488
3489         INIT_LIST_HEAD(&ptype_all);
3490         for (i = 0; i < 16; i++) 
3491                 INIT_LIST_HEAD(&ptype_base[i]);
3492
3493         for (i = 0; i < ARRAY_SIZE(dev_name_head); i++)
3494                 INIT_HLIST_HEAD(&dev_name_head[i]);
3495
3496         for (i = 0; i < ARRAY_SIZE(dev_index_head); i++)
3497                 INIT_HLIST_HEAD(&dev_index_head[i]);
3498
3499         /*
3500          *      Initialise the packet receive queues.
3501          */
3502
3503         for_each_possible_cpu(i) {
3504                 struct softnet_data *queue;
3505
3506                 queue = &per_cpu(softnet_data, i);
3507                 skb_queue_head_init(&queue->input_pkt_queue);
3508                 queue->completion_queue = NULL;
3509                 INIT_LIST_HEAD(&queue->poll_list);
3510                 set_bit(__LINK_STATE_START, &queue->backlog_dev.state);
3511                 queue->backlog_dev.weight = weight_p;
3512                 queue->backlog_dev.poll = process_backlog;
3513                 atomic_set(&queue->backlog_dev.refcnt, 1);
3514         }
3515
3516         netdev_dma_register();
3517
3518         dev_boot_phase = 0;
3519
3520         open_softirq(NET_TX_SOFTIRQ, net_tx_action, NULL);
3521         open_softirq(NET_RX_SOFTIRQ, net_rx_action, NULL);
3522
3523         hotcpu_notifier(dev_cpu_callback, 0);
3524         dst_init();
3525         dev_mcast_init();
3526         rc = 0;
3527 out:
3528         return rc;
3529 }
3530
3531 subsys_initcall(net_dev_init);
3532
3533 EXPORT_SYMBOL(__dev_get_by_index);
3534 EXPORT_SYMBOL(__dev_get_by_name);
3535 EXPORT_SYMBOL(__dev_remove_pack);
3536 EXPORT_SYMBOL(dev_valid_name);
3537 EXPORT_SYMBOL(dev_add_pack);
3538 EXPORT_SYMBOL(dev_alloc_name);
3539 EXPORT_SYMBOL(dev_close);
3540 EXPORT_SYMBOL(dev_get_by_flags);
3541 EXPORT_SYMBOL(dev_get_by_index);
3542 EXPORT_SYMBOL(dev_get_by_name);
3543 EXPORT_SYMBOL(dev_open);
3544 EXPORT_SYMBOL(dev_queue_xmit);
3545 EXPORT_SYMBOL(dev_remove_pack);
3546 EXPORT_SYMBOL(dev_set_allmulti);
3547 EXPORT_SYMBOL(dev_set_promiscuity);
3548 EXPORT_SYMBOL(dev_change_flags);
3549 EXPORT_SYMBOL(dev_set_mtu);
3550 EXPORT_SYMBOL(dev_set_mac_address);
3551 EXPORT_SYMBOL(free_netdev);
3552 EXPORT_SYMBOL(netdev_boot_setup_check);
3553 EXPORT_SYMBOL(netdev_set_master);
3554 EXPORT_SYMBOL(netdev_state_change);
3555 EXPORT_SYMBOL(netif_receive_skb);
3556 EXPORT_SYMBOL(netif_rx);
3557 EXPORT_SYMBOL(register_gifconf);
3558 EXPORT_SYMBOL(register_netdevice);
3559 EXPORT_SYMBOL(register_netdevice_notifier);
3560 EXPORT_SYMBOL(skb_checksum_help);
3561 EXPORT_SYMBOL(synchronize_net);
3562 EXPORT_SYMBOL(unregister_netdevice);
3563 EXPORT_SYMBOL(unregister_netdevice_notifier);
3564 EXPORT_SYMBOL(net_enable_timestamp);
3565 EXPORT_SYMBOL(net_disable_timestamp);
3566 EXPORT_SYMBOL(dev_get_flags);
3567
3568 #if defined(CONFIG_BRIDGE) || defined(CONFIG_BRIDGE_MODULE)
3569 EXPORT_SYMBOL(br_handle_frame_hook);
3570 EXPORT_SYMBOL(br_fdb_get_hook);
3571 EXPORT_SYMBOL(br_fdb_put_hook);
3572 #endif
3573
3574 #ifdef CONFIG_KMOD
3575 EXPORT_SYMBOL(dev_load);
3576 #endif
3577
3578 EXPORT_PER_CPU_SYMBOL(softnet_data);