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