2 * NET3 Protocol independent device support routines.
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.
9 * Derived from the non IP parts of dev.c 1.0.19
10 * Authors: Ross Biro, <bir7@leland.Stanford.Edu>
11 * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
12 * Mark Evans, <evansmp@uhura.aston.ac.uk>
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>
23 * D.J. Barrow : Fixed bug where dev->refcnt gets set to 2
24 * if register_netdev gets called before
25 * net_dev_init & also removed a few lines
26 * of code in the process.
27 * Alan Cox : device private ioctl copies fields back.
28 * Alan Cox : Transmit queue code does relevant stunts to
29 * 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 drivers
34 * Tim Kordas : SIOCADDMULTI/SIOCDELMULTI
35 * Alan Cox : 100 backlog just doesn't cut it when
36 * you start doing multicast video 8)
37 * Alan Cox : Rewrote net_bh and list manager.
38 * Alan Cox : Fix ETH_P_ALL echoback lengths.
39 * Alan Cox : Took out transmit every packet pass
40 * Saved a few bytes in the ioctl handler
41 * Alan Cox : Network driver sets packet type before calling netif_rx. Saves
42 * a function call a packet.
43 * Alan Cox : Hashed net_bh()
44 * Richard Kooijman: Timestamp fixes.
45 * Alan Cox : Wrong field in SIOCGIFDSTADDR
46 * Alan Cox : Device lock protection.
47 * Alan Cox : Fixed nasty side effect of device close changes.
48 * Rudi Cilibrasi : Pass the right thing to set_mac_address()
49 * Dave Miller : 32bit quantity for the device lock to make it work out
51 * Bjorn Ekwall : Added KERNELD hack.
52 * Alan Cox : Cleaned up the backlog initialise.
53 * Craig Metz : SIOCGIFCONF fix if space for under
55 * Thomas Bogendoerfer : Return ENODEV for dev_open, if there
56 * is no device open function.
57 * Andi Kleen : Fix error reporting for SIOCGIFCONF
58 * Michael Chastain : Fix signed/unsigned for SIOCGIFCONF
59 * Cyrus Durgin : Cleaned for KMOD
60 * Adam Sulmicki : Bug Fix : Network Device Unload
61 * A network device unload needs to purge
63 * Paul Rusty Russell : SIOCSIFNAME
64 * Pekka Riikonen : Netdev boot-time settings code
65 * Andrew Morton : Make unregister_netdevice wait indefinitely on dev->refcnt
66 * J Hadi Salim : - Backlog queue sampling
67 * - netif_rx() feedback
70 #include <asm/uaccess.h>
71 #include <asm/system.h>
72 #include <asm/bitops.h>
73 #include <linux/config.h>
74 #include <linux/types.h>
75 #include <linux/kernel.h>
76 #include <linux/sched.h>
77 #include <linux/string.h>
79 #include <linux/socket.h>
80 #include <linux/sockios.h>
81 #include <linux/errno.h>
82 #include <linux/interrupt.h>
83 #include <linux/if_ether.h>
84 #include <linux/netdevice.h>
85 #include <linux/etherdevice.h>
86 #include <linux/notifier.h>
87 #include <linux/skbuff.h>
88 #include <linux/brlock.h>
90 #include <linux/rtnetlink.h>
91 #include <linux/proc_fs.h>
92 #include <linux/stat.h>
93 #include <linux/if_bridge.h>
94 #include <linux/divert.h>
96 #include <net/pkt_sched.h>
97 #include <net/profile.h>
98 #include <net/checksum.h>
99 #include <linux/highmem.h>
100 #include <linux/init.h>
101 #include <linux/kmod.h>
102 #include <linux/module.h>
103 #if defined(CONFIG_NET_RADIO) || defined(CONFIG_NET_PCMCIA_RADIO)
104 #include <linux/wireless.h> /* Note : will define WIRELESS_EXT */
105 #include <net/iw_handler.h>
106 #endif /* CONFIG_NET_RADIO || CONFIG_NET_PCMCIA_RADIO */
108 extern int plip_init(void);
112 /* This define, if set, will randomly drop a packet when congestion
113 * is more than moderate. It helps fairness in the multi-interface
114 * case when one of them is a hog, but it kills performance for the
115 * single interface case so it is off now by default.
119 /* Setting this will sample the queue lengths and thus congestion
120 * via a timer instead of as each packet is received.
122 #undef OFFLINE_SAMPLE
124 NET_PROFILE_DEFINE(dev_queue_xmit)
125 NET_PROFILE_DEFINE(softnet_process)
127 const char *if_port_text[] = {
138 * The list of packet types we will receive (as opposed to discard)
139 * and the routines to invoke.
141 * Why 16. Because with 16 the only overlap we get on a hash of the
142 * low nibble of the protocol value is RARP/SNAP/X.25.
144 * NOTE: That is no longer true with the addition of VLAN tags. Not
145 * sure which should go first, but I bet it won't make much
146 * difference if we are running VLANs. The good news is that
147 * this protocol won't be in the list unless compiled in, so
148 * the average user (w/out VLANs) will not be adversly affected.
165 static struct packet_type *ptype_base[16]; /* 16 way hashed list */
166 static struct packet_type *ptype_all = NULL; /* Taps */
168 #ifdef OFFLINE_SAMPLE
169 static void sample_queue(unsigned long dummy);
170 static struct timer_list samp_timer = { function: sample_queue };
173 #ifdef CONFIG_HOTPLUG
174 static int net_run_sbin_hotplug(struct net_device *dev, char *action);
176 #define net_run_sbin_hotplug(dev, action) ({ 0; })
183 static struct notifier_block *netdev_chain=NULL;
186 * Device drivers call our routines to queue packets here. We empty the
187 * queue in the local softnet handler.
189 struct softnet_data softnet_data[NR_CPUS] __cacheline_aligned;
191 #ifdef CONFIG_NET_FASTROUTE
192 int netdev_fastroute;
193 int netdev_fastroute_obstacles;
197 /******************************************************************************************
199 Protocol management and registration routines
201 *******************************************************************************************/
210 * Add a protocol ID to the list. Now that the input handler is
211 * smarter we can dispense with all the messy stuff that used to be
214 * BEWARE!!! Protocol handlers, mangling input packets,
215 * MUST BE last in hash buckets and checking protocol handlers
216 * MUST start from promiscous ptype_all chain in net_bh.
217 * It is true now, do not change it.
218 * Explantion follows: if protocol handler, mangling packet, will
219 * be the first on list, it is not able to sense, that packet
220 * is cloned and should be copied-on-write, so that it will
221 * change it and subsequent readers will get broken packet.
226 * dev_add_pack - add packet handler
227 * @pt: packet type declaration
229 * Add a protocol handler to the networking stack. The passed &packet_type
230 * is linked into kernel lists and may not be freed until it has been
231 * removed from the kernel lists.
234 void dev_add_pack(struct packet_type *pt)
238 br_write_lock_bh(BR_NETPROTO_LOCK);
240 #ifdef CONFIG_NET_FASTROUTE
241 /* Hack to detect packet socket */
242 if ((pt->data) && ((int)(pt->data)!=1)) {
243 netdev_fastroute_obstacles++;
244 dev_clear_fastroute(pt->dev);
247 if (pt->type == htons(ETH_P_ALL)) {
252 hash=ntohs(pt->type)&15;
253 pt->next = ptype_base[hash];
254 ptype_base[hash] = pt;
256 br_write_unlock_bh(BR_NETPROTO_LOCK);
261 * dev_remove_pack - remove packet handler
262 * @pt: packet type declaration
264 * Remove a protocol handler that was previously added to the kernel
265 * protocol handlers by dev_add_pack(). The passed &packet_type is removed
266 * from the kernel lists and can be freed or reused once this function
270 void dev_remove_pack(struct packet_type *pt)
272 struct packet_type **pt1;
274 br_write_lock_bh(BR_NETPROTO_LOCK);
276 if (pt->type == htons(ETH_P_ALL)) {
280 pt1=&ptype_base[ntohs(pt->type)&15];
283 for (; (*pt1) != NULL; pt1 = &((*pt1)->next)) {
286 #ifdef CONFIG_NET_FASTROUTE
288 netdev_fastroute_obstacles--;
290 br_write_unlock_bh(BR_NETPROTO_LOCK);
294 br_write_unlock_bh(BR_NETPROTO_LOCK);
295 printk(KERN_WARNING "dev_remove_pack: %p not found.\n", pt);
298 /******************************************************************************
300 Device Boot-time Settings Routines
302 *******************************************************************************/
304 /* Boot time configuration table */
305 static struct netdev_boot_setup dev_boot_setup[NETDEV_BOOT_SETUP_MAX];
308 * netdev_boot_setup_add - add new setup entry
309 * @name: name of the device
310 * @map: configured settings for the device
312 * Adds new setup entry to the dev_boot_setup list. The function
313 * returns 0 on error and 1 on success. This is a generic routine to
316 int netdev_boot_setup_add(char *name, struct ifmap *map)
318 struct netdev_boot_setup *s;
322 for (i = 0; i < NETDEV_BOOT_SETUP_MAX; i++) {
323 if (s[i].name[0] == '\0' || s[i].name[0] == ' ') {
324 memset(s[i].name, 0, sizeof(s[i].name));
325 strcpy(s[i].name, name);
326 memcpy(&s[i].map, map, sizeof(s[i].map));
331 if (i >= NETDEV_BOOT_SETUP_MAX)
338 * netdev_boot_setup_check - check boot time settings
339 * @dev: the netdevice
341 * Check boot time settings for the device.
342 * The found settings are set for the device to be used
343 * later in the device probing.
344 * Returns 0 if no settings found, 1 if they are.
346 int netdev_boot_setup_check(struct net_device *dev)
348 struct netdev_boot_setup *s;
352 for (i = 0; i < NETDEV_BOOT_SETUP_MAX; i++) {
353 if (s[i].name[0] != '\0' && s[i].name[0] != ' ' &&
354 !strncmp(dev->name, s[i].name, strlen(s[i].name))) {
355 dev->irq = s[i].map.irq;
356 dev->base_addr = s[i].map.base_addr;
357 dev->mem_start = s[i].map.mem_start;
358 dev->mem_end = s[i].map.mem_end;
366 * Saves at boot time configured settings for any netdevice.
368 int __init netdev_boot_setup(char *str)
373 str = get_options(str, ARRAY_SIZE(ints), ints);
378 memset(&map, 0, sizeof(map));
382 map.base_addr = ints[2];
384 map.mem_start = ints[3];
386 map.mem_end = ints[4];
388 /* Add new entry to the list */
389 return netdev_boot_setup_add(str, &map);
392 __setup("netdev=", netdev_boot_setup);
394 /*****************************************************************************************
396 Device Interface Subroutines
398 ******************************************************************************************/
401 * __dev_get_by_name - find a device by its name
402 * @name: name to find
404 * Find an interface by name. Must be called under RTNL semaphore
405 * or @dev_base_lock. If the name is found a pointer to the device
406 * is returned. If the name is not found then %NULL is returned. The
407 * reference counters are not incremented so the caller must be
408 * careful with locks.
412 struct net_device *__dev_get_by_name(const char *name)
414 struct net_device *dev;
416 for (dev = dev_base; dev != NULL; dev = dev->next) {
417 if (strncmp(dev->name, name, IFNAMSIZ) == 0)
424 * dev_get_by_name - find a device by its name
425 * @name: name to find
427 * Find an interface by name. This can be called from any
428 * context and does its own locking. The returned handle has
429 * the usage count incremented and the caller must use dev_put() to
430 * release it when it is no longer needed. %NULL is returned if no
431 * matching device is found.
434 struct net_device *dev_get_by_name(const char *name)
436 struct net_device *dev;
438 read_lock(&dev_base_lock);
439 dev = __dev_get_by_name(name);
442 read_unlock(&dev_base_lock);
447 Return value is changed to int to prevent illegal usage in future.
448 It is still legal to use to check for device existence.
450 User should understand, that the result returned by this function
451 is meaningless, if it was not issued under rtnl semaphore.
455 * dev_get - test if a device exists
456 * @name: name to test for
458 * Test if a name exists. Returns true if the name is found. In order
459 * to be sure the name is not allocated or removed during the test the
460 * caller must hold the rtnl semaphore.
462 * This function primarily exists for back compatibility with older
466 int dev_get(const char *name)
468 struct net_device *dev;
470 read_lock(&dev_base_lock);
471 dev = __dev_get_by_name(name);
472 read_unlock(&dev_base_lock);
477 * __dev_get_by_index - find a device by its ifindex
478 * @ifindex: index of device
480 * Search for an interface by index. Returns %NULL if the device
481 * is not found or a pointer to the device. The device has not
482 * had its reference counter increased so the caller must be careful
483 * about locking. The caller must hold either the RTNL semaphore
487 struct net_device * __dev_get_by_index(int ifindex)
489 struct net_device *dev;
491 for (dev = dev_base; dev != NULL; dev = dev->next) {
492 if (dev->ifindex == ifindex)
500 * dev_get_by_index - find a device by its ifindex
501 * @ifindex: index of device
503 * Search for an interface by index. Returns NULL if the device
504 * is not found or a pointer to the device. The device returned has
505 * had a reference added and the pointer is safe until the user calls
506 * dev_put to indicate they have finished with it.
509 struct net_device * dev_get_by_index(int ifindex)
511 struct net_device *dev;
513 read_lock(&dev_base_lock);
514 dev = __dev_get_by_index(ifindex);
517 read_unlock(&dev_base_lock);
522 * dev_getbyhwaddr - find a device by its hardware address
523 * @type: media type of device
524 * @ha: hardware address
526 * Search for an interface by MAC address. Returns NULL if the device
527 * is not found or a pointer to the device. The caller must hold the
528 * rtnl semaphore. The returned device has not had its ref count increased
529 * and the caller must therefore be careful about locking
532 * If the API was consistent this would be __dev_get_by_hwaddr
535 struct net_device *dev_getbyhwaddr(unsigned short type, char *ha)
537 struct net_device *dev;
541 for (dev = dev_base; dev != NULL; dev = dev->next) {
542 if (dev->type == type &&
543 memcmp(dev->dev_addr, ha, dev->addr_len) == 0)
550 * dev_get_by_flags - find any device with given flags
551 * @if_flags: IFF_* values
552 * @mask: bitmask of bits in if_flags to check
554 * Search for any interface with the given flags. Returns NULL if a device
555 * is not found or a pointer to the device. The device returned has
556 * had a reference added and the pointer is safe until the user calls
557 * dev_put to indicate they have finished with it.
560 struct net_device * dev_get_by_flags(unsigned short if_flags, unsigned short mask)
562 struct net_device *dev;
564 read_lock(&dev_base_lock);
565 dev = __dev_get_by_flags(if_flags, mask);
568 read_unlock(&dev_base_lock);
573 * __dev_get_by_flags - find any device with given flags
574 * @if_flags: IFF_* values
575 * @mask: bitmask of bits in if_flags to check
577 * Search for any interface with the given flags. Returns NULL if a device
578 * is not found or a pointer to the device. The caller must hold either
579 * the RTNL semaphore or @dev_base_lock.
582 struct net_device *__dev_get_by_flags(unsigned short if_flags, unsigned short mask)
584 struct net_device *dev;
586 for (dev = dev_base; dev != NULL; dev = dev->next) {
587 if (((dev->flags ^ if_flags) & mask) == 0)
594 * dev_alloc_name - allocate a name for a device
596 * @name: name format string
598 * Passed a format string - eg "lt%d" it will try and find a suitable
599 * id. Not efficient for many devices, not called a lot. The caller
600 * must hold the dev_base or rtnl lock while allocating the name and
601 * adding the device in order to avoid duplicates. Returns the number
602 * of the unit assigned or a negative errno code.
605 int dev_alloc_name(struct net_device *dev, const char *name)
612 * Verify the string as this thing may have come from
613 * the user. There must be either one "%d" and no other "%"
614 * characters, or no "%" characters at all.
616 p = strchr(name, '%');
617 if (p && (p[1] != 'd' || strchr(p+2, '%')))
621 * If you need over 100 please also fix the algorithm...
623 for (i = 0; i < 100; i++) {
624 snprintf(buf,sizeof(buf),name,i);
625 if (__dev_get_by_name(buf) == NULL) {
626 strcpy(dev->name, buf);
630 return -ENFILE; /* Over 100 of the things .. bail out! */
634 * dev_alloc - allocate a network device and name
635 * @name: name format string
636 * @err: error return pointer
638 * Passed a format string, eg. "lt%d", it will allocate a network device
639 * and space for the name. %NULL is returned if no memory is available.
640 * If the allocation succeeds then the name is assigned and the
641 * device pointer returned. %NULL is returned if the name allocation
642 * failed. The cause of an error is returned as a negative errno code
643 * in the variable @err points to.
645 * The caller must hold the @dev_base or RTNL locks when doing this in
646 * order to avoid duplicate name allocations.
649 struct net_device *dev_alloc(const char *name, int *err)
651 struct net_device *dev=kmalloc(sizeof(struct net_device), GFP_KERNEL);
656 memset(dev, 0, sizeof(struct net_device));
657 *err = dev_alloc_name(dev, name);
666 * netdev_state_change - device changes state
667 * @dev: device to cause notification
669 * Called to indicate a device has changed state. This function calls
670 * the notifier chains for netdev_chain and sends a NEWLINK message
671 * to the routing socket.
674 void netdev_state_change(struct net_device *dev)
676 if (dev->flags&IFF_UP) {
677 notifier_call_chain(&netdev_chain, NETDEV_CHANGE, dev);
678 rtmsg_ifinfo(RTM_NEWLINK, dev, 0);
686 * dev_load - load a network module
687 * @name: name of interface
689 * If a network interface is not present and the process has suitable
690 * privileges this function loads the module. If module loading is not
691 * available in this kernel then it becomes a nop.
694 void dev_load(const char *name)
696 if (!dev_get(name) && capable(CAP_SYS_MODULE))
697 request_module(name);
702 extern inline void dev_load(const char *unused){;}
706 static int default_rebuild_header(struct sk_buff *skb)
708 printk(KERN_DEBUG "%s: default_rebuild_header called -- BUG!\n", skb->dev ? skb->dev->name : "NULL!!!");
714 * dev_open - prepare an interface for use.
715 * @dev: device to open
717 * Takes a device from down to up state. The device's private open
718 * function is invoked and then the multicast lists are loaded. Finally
719 * the device is moved into the up state and a %NETDEV_UP message is
720 * sent to the netdev notifier chain.
722 * Calling this function on an active interface is a nop. On a failure
723 * a negative errno code is returned.
726 int dev_open(struct net_device *dev)
734 if (dev->flags&IFF_UP)
738 * Is it even present?
740 if (!netif_device_present(dev))
744 * Call device private open method
746 if (try_inc_mod_count(dev->owner)) {
747 set_bit(__LINK_STATE_START, &dev->state);
749 ret = dev->open(dev);
751 clear_bit(__LINK_STATE_START, &dev->state);
753 __MOD_DEC_USE_COUNT(dev->owner);
761 * If it went open OK then:
769 dev->flags |= IFF_UP;
772 * Initialize multicasting status
777 * Wakeup transmit queue engine
782 * ... and announce new interface.
784 notifier_call_chain(&netdev_chain, NETDEV_UP, dev);
789 #ifdef CONFIG_NET_FASTROUTE
791 static void dev_do_clear_fastroute(struct net_device *dev)
793 if (dev->accept_fastpath) {
796 for (i=0; i<=NETDEV_FASTROUTE_HMASK; i++) {
797 struct dst_entry *dst;
799 write_lock_irq(&dev->fastpath_lock);
800 dst = dev->fastpath[i];
801 dev->fastpath[i] = NULL;
802 write_unlock_irq(&dev->fastpath_lock);
809 void dev_clear_fastroute(struct net_device *dev)
812 dev_do_clear_fastroute(dev);
814 read_lock(&dev_base_lock);
815 for (dev = dev_base; dev; dev = dev->next)
816 dev_do_clear_fastroute(dev);
817 read_unlock(&dev_base_lock);
823 * dev_close - shutdown an interface.
824 * @dev: device to shutdown
826 * This function moves an active device into down state. A
827 * %NETDEV_GOING_DOWN is sent to the netdev notifier chain. The device
828 * is then deactivated and finally a %NETDEV_DOWN is sent to the notifier
832 int dev_close(struct net_device *dev)
834 if (!(dev->flags&IFF_UP))
838 * Tell people we are going down, so that they can
839 * prepare to death, when device is still operating.
841 notifier_call_chain(&netdev_chain, NETDEV_GOING_DOWN, dev);
845 clear_bit(__LINK_STATE_START, &dev->state);
847 /* Synchronize to scheduled poll. We cannot touch poll list,
848 * it can be even on different cpu. So just clear netif_running(),
849 * and wait when poll really will happen. Actually, the best place
850 * for this is inside dev->stop() after device stopped its irq
851 * engine, but this requires more changes in devices. */
853 smp_mb__after_clear_bit(); /* Commit netif_running(). */
854 while (test_bit(__LINK_STATE_RX_SCHED, &dev->state)) {
856 current->state = TASK_INTERRUPTIBLE;
861 * Call the device specific close. This cannot fail.
862 * Only if device is UP
864 * We allow it to be called even after a DETACH hot-plug
872 * Device is now down.
875 dev->flags &= ~IFF_UP;
876 #ifdef CONFIG_NET_FASTROUTE
877 dev_clear_fastroute(dev);
881 * Tell people we are down
883 notifier_call_chain(&netdev_chain, NETDEV_DOWN, dev);
886 * Drop the module refcount
889 __MOD_DEC_USE_COUNT(dev->owner);
896 * Device change register/unregister. These are not inline or static
897 * as we export them to the world.
901 * register_netdevice_notifier - register a network notifier block
904 * Register a notifier to be called when network device events occur.
905 * The notifier passed is linked into the kernel structures and must
906 * not be reused until it has been unregistered. A negative errno code
907 * is returned on a failure.
910 int register_netdevice_notifier(struct notifier_block *nb)
912 return notifier_chain_register(&netdev_chain, nb);
916 * unregister_netdevice_notifier - unregister a network notifier block
919 * Unregister a notifier previously registered by
920 * register_netdevice_notifier(). The notifier is unlinked into the
921 * kernel structures and may then be reused. A negative errno code
922 * is returned on a failure.
925 int unregister_netdevice_notifier(struct notifier_block *nb)
927 return notifier_chain_unregister(&netdev_chain,nb);
931 * Support routine. Sends outgoing frames to any network
932 * taps currently in use.
935 void dev_queue_xmit_nit(struct sk_buff *skb, struct net_device *dev)
937 struct packet_type *ptype;
938 do_gettimeofday(&skb->stamp);
940 br_read_lock(BR_NETPROTO_LOCK);
941 for (ptype = ptype_all; ptype!=NULL; ptype = ptype->next)
943 /* Never send packets back to the socket
944 * they originated from - MvS (miquels@drinkel.ow.org)
946 if ((ptype->dev == dev || !ptype->dev) &&
947 ((struct sock *)ptype->data != skb->sk))
949 struct sk_buff *skb2;
950 if ((skb2 = skb_clone(skb, GFP_ATOMIC)) == NULL)
953 /* skb->nh should be correctly
954 set by sender, so that the second statement is
955 just protection against buggy protocols.
957 skb2->mac.raw = skb2->data;
959 if (skb2->nh.raw < skb2->data || skb2->nh.raw > skb2->tail) {
961 printk(KERN_CRIT "protocol %04x is buggy, dev %s\n", skb2->protocol, dev->name);
962 skb2->nh.raw = skb2->data;
965 skb2->h.raw = skb2->nh.raw;
966 skb2->pkt_type = PACKET_OUTGOING;
967 ptype->func(skb2, skb->dev, ptype);
970 br_read_unlock(BR_NETPROTO_LOCK);
973 /* Calculate csum in the case, when packet is misrouted.
974 * If it failed by some reason, ignore and send skb with wrong
977 struct sk_buff * skb_checksum_help(struct sk_buff *skb)
982 offset = skb->h.raw - skb->data;
983 if (offset > (int)skb->len)
985 csum = skb_checksum(skb, offset, skb->len-offset, 0);
987 offset = skb->tail - skb->h.raw;
990 if (skb->csum+2 > offset)
993 *(u16*)(skb->h.raw + skb->csum) = csum_fold(csum);
994 skb->ip_summed = CHECKSUM_NONE;
998 #ifdef CONFIG_HIGHMEM
999 /* Actually, we should eliminate this check as soon as we know, that:
1000 * 1. IOMMU is present and allows to map all the memory.
1001 * 2. No high memory really exists on this machine.
1005 illegal_highdma(struct net_device *dev, struct sk_buff *skb)
1009 if (dev->features&NETIF_F_HIGHDMA)
1012 for (i=0; i<skb_shinfo(skb)->nr_frags; i++)
1013 if (skb_shinfo(skb)->frags[i].page >= highmem_start_page)
1019 #define illegal_highdma(dev, skb) (0)
1023 * dev_queue_xmit - transmit a buffer
1024 * @skb: buffer to transmit
1026 * Queue a buffer for transmission to a network device. The caller must
1027 * have set the device and priority and built the buffer before calling this
1028 * function. The function can be called from an interrupt.
1030 * A negative errno code is returned on a failure. A success does not
1031 * guarantee the frame will be transmitted as it may be dropped due
1032 * to congestion or traffic shaping.
1035 int dev_queue_xmit(struct sk_buff *skb)
1037 struct net_device *dev = skb->dev;
1040 if (skb_shinfo(skb)->frag_list &&
1041 !(dev->features&NETIF_F_FRAGLIST) &&
1042 skb_linearize(skb, GFP_ATOMIC) != 0) {
1047 /* Fragmented skb is linearized if device does not support SG,
1048 * or if at least one of fragments is in highmem and device
1049 * does not support DMA from it.
1051 if (skb_shinfo(skb)->nr_frags &&
1052 (!(dev->features&NETIF_F_SG) || illegal_highdma(dev, skb)) &&
1053 skb_linearize(skb, GFP_ATOMIC) != 0) {
1058 /* If packet is not checksummed and device does not support
1059 * checksumming for this protocol, complete checksumming here.
1061 if (skb->ip_summed == CHECKSUM_HW &&
1062 (!(dev->features&(NETIF_F_HW_CSUM|NETIF_F_NO_CSUM)) &&
1063 (!(dev->features&NETIF_F_IP_CSUM) ||
1064 skb->protocol != htons(ETH_P_IP)))) {
1065 if ((skb = skb_checksum_help(skb)) == NULL)
1069 /* Grab device queue */
1070 spin_lock_bh(&dev->queue_lock);
1073 int ret = q->enqueue(skb, q);
1077 spin_unlock_bh(&dev->queue_lock);
1078 return ret == NET_XMIT_BYPASS ? NET_XMIT_SUCCESS : ret;
1081 /* The device has no queue. Common case for software devices:
1082 loopback, all the sorts of tunnels...
1084 Really, it is unlikely that xmit_lock protection is necessary here.
1085 (f.e. loopback and IP tunnels are clean ignoring statistics counters.)
1086 However, it is possible, that they rely on protection
1089 Check this and shot the lock. It is not prone from deadlocks.
1090 Either shot noqueue qdisc, it is even simpler 8)
1092 if (dev->flags&IFF_UP) {
1093 int cpu = smp_processor_id();
1095 if (dev->xmit_lock_owner != cpu) {
1096 spin_unlock(&dev->queue_lock);
1097 spin_lock(&dev->xmit_lock);
1098 dev->xmit_lock_owner = cpu;
1100 if (!netif_queue_stopped(dev)) {
1102 dev_queue_xmit_nit(skb,dev);
1104 if (dev->hard_start_xmit(skb, dev) == 0) {
1105 dev->xmit_lock_owner = -1;
1106 spin_unlock_bh(&dev->xmit_lock);
1110 dev->xmit_lock_owner = -1;
1111 spin_unlock_bh(&dev->xmit_lock);
1112 if (net_ratelimit())
1113 printk(KERN_CRIT "Virtual device %s asks to queue packet!\n", dev->name);
1117 /* Recursion is detected! It is possible, unfortunately */
1118 if (net_ratelimit())
1119 printk(KERN_CRIT "Dead loop on virtual device %s, fix it urgently!\n", dev->name);
1122 spin_unlock_bh(&dev->queue_lock);
1129 /*=======================================================================
1131 =======================================================================*/
1133 int netdev_max_backlog = 300;
1134 int weight_p = 64; /* old backlog weight */
1135 /* These numbers are selected based on intuition and some
1136 * experimentatiom, if you have more scientific way of doing this
1137 * please go ahead and fix things.
1139 int no_cong_thresh = 10;
1144 struct netif_rx_stats netdev_rx_stat[NR_CPUS];
1147 #ifdef CONFIG_NET_HW_FLOWCONTROL
1148 atomic_t netdev_dropping = ATOMIC_INIT(0);
1149 static unsigned long netdev_fc_mask = 1;
1150 unsigned long netdev_fc_xoff = 0;
1151 spinlock_t netdev_fc_lock = SPIN_LOCK_UNLOCKED;
1155 void (*stimul)(struct net_device *);
1156 struct net_device *dev;
1157 } netdev_fc_slots[BITS_PER_LONG];
1159 int netdev_register_fc(struct net_device *dev, void (*stimul)(struct net_device *dev))
1162 unsigned long flags;
1164 spin_lock_irqsave(&netdev_fc_lock, flags);
1165 if (netdev_fc_mask != ~0UL) {
1166 bit = ffz(netdev_fc_mask);
1167 netdev_fc_slots[bit].stimul = stimul;
1168 netdev_fc_slots[bit].dev = dev;
1169 set_bit(bit, &netdev_fc_mask);
1170 clear_bit(bit, &netdev_fc_xoff);
1172 spin_unlock_irqrestore(&netdev_fc_lock, flags);
1176 void netdev_unregister_fc(int bit)
1178 unsigned long flags;
1180 spin_lock_irqsave(&netdev_fc_lock, flags);
1182 netdev_fc_slots[bit].stimul = NULL;
1183 netdev_fc_slots[bit].dev = NULL;
1184 clear_bit(bit, &netdev_fc_mask);
1185 clear_bit(bit, &netdev_fc_xoff);
1187 spin_unlock_irqrestore(&netdev_fc_lock, flags);
1190 static void netdev_wakeup(void)
1194 spin_lock(&netdev_fc_lock);
1195 xoff = netdev_fc_xoff;
1200 netdev_fc_slots[i].stimul(netdev_fc_slots[i].dev);
1202 spin_unlock(&netdev_fc_lock);
1206 static void get_sample_stats(int cpu)
1212 int blog = softnet_data[cpu].input_pkt_queue.qlen;
1213 int avg_blog = softnet_data[cpu].avg_blog;
1215 avg_blog = (avg_blog >> 1)+ (blog >> 1);
1217 if (avg_blog > mod_cong) {
1218 /* Above moderate congestion levels. */
1219 softnet_data[cpu].cng_level = NET_RX_CN_HIGH;
1222 rq = rd % netdev_max_backlog;
1223 if (rq < avg_blog) /* unlucky bastard */
1224 softnet_data[cpu].cng_level = NET_RX_DROP;
1226 } else if (avg_blog > lo_cong) {
1227 softnet_data[cpu].cng_level = NET_RX_CN_MOD;
1230 rq = rd % netdev_max_backlog;
1231 if (rq < avg_blog) /* unlucky bastard */
1232 softnet_data[cpu].cng_level = NET_RX_CN_HIGH;
1234 } else if (avg_blog > no_cong)
1235 softnet_data[cpu].cng_level = NET_RX_CN_LOW;
1236 else /* no congestion */
1237 softnet_data[cpu].cng_level = NET_RX_SUCCESS;
1239 softnet_data[cpu].avg_blog = avg_blog;
1242 #ifdef OFFLINE_SAMPLE
1243 static void sample_queue(unsigned long dummy)
1245 /* 10 ms 0r 1ms -- i dont care -- JHS */
1247 int cpu = smp_processor_id();
1249 get_sample_stats(cpu);
1250 next_tick += jiffies;
1251 mod_timer(&samp_timer, next_tick);
1257 * netif_rx - post buffer to the network code
1258 * @skb: buffer to post
1260 * This function receives a packet from a device driver and queues it for
1261 * the upper (protocol) levels to process. It always succeeds. The buffer
1262 * may be dropped during processing for congestion control or by the
1266 * NET_RX_SUCCESS (no congestion)
1267 * NET_RX_CN_LOW (low congestion)
1268 * NET_RX_CN_MOD (moderate congestion)
1269 * NET_RX_CN_HIGH (high congestion)
1270 * NET_RX_DROP (packet was dropped)
1275 int netif_rx(struct sk_buff *skb)
1277 int this_cpu = smp_processor_id();
1278 struct softnet_data *queue;
1279 unsigned long flags;
1281 if (skb->stamp.tv_sec == 0)
1282 do_gettimeofday(&skb->stamp);
1284 /* The code is rearranged so that the path is the most
1285 short when CPU is congested, but is still operating.
1287 queue = &softnet_data[this_cpu];
1289 local_irq_save(flags);
1291 netdev_rx_stat[this_cpu].total++;
1292 if (queue->input_pkt_queue.qlen <= netdev_max_backlog) {
1293 if (queue->input_pkt_queue.qlen) {
1294 if (queue->throttle)
1299 __skb_queue_tail(&queue->input_pkt_queue,skb);
1300 local_irq_restore(flags);
1301 #ifndef OFFLINE_SAMPLE
1302 get_sample_stats(this_cpu);
1304 return queue->cng_level;
1307 if (queue->throttle) {
1308 queue->throttle = 0;
1309 #ifdef CONFIG_NET_HW_FLOWCONTROL
1310 if (atomic_dec_and_test(&netdev_dropping))
1315 netif_rx_schedule(&queue->blog_dev);
1319 if (queue->throttle == 0) {
1320 queue->throttle = 1;
1321 netdev_rx_stat[this_cpu].throttled++;
1322 #ifdef CONFIG_NET_HW_FLOWCONTROL
1323 atomic_inc(&netdev_dropping);
1328 netdev_rx_stat[this_cpu].dropped++;
1329 local_irq_restore(flags);
1335 /* Deliver skb to an old protocol, which is not threaded well
1336 or which do not understand shared skbs.
1338 static int deliver_to_old_ones(struct packet_type *pt, struct sk_buff *skb, int last)
1340 static spinlock_t net_bh_lock = SPIN_LOCK_UNLOCKED;
1341 int ret = NET_RX_DROP;
1345 skb = skb_clone(skb, GFP_ATOMIC);
1349 if (skb_is_nonlinear(skb) && skb_linearize(skb, GFP_ATOMIC) != 0) {
1354 /* The assumption (correct one) is that old protocols
1355 did not depened on BHs different of NET_BH and TIMER_BH.
1358 /* Emulate NET_BH with special spinlock */
1359 spin_lock(&net_bh_lock);
1361 /* Disable timers and wait for all timers completion */
1362 tasklet_disable(bh_task_vec+TIMER_BH);
1364 ret = pt->func(skb, skb->dev, pt);
1366 tasklet_hi_enable(bh_task_vec+TIMER_BH);
1367 spin_unlock(&net_bh_lock);
1371 static __inline__ void skb_bond(struct sk_buff *skb)
1373 struct net_device *dev = skb->dev;
1376 skb->real_dev = skb->dev;
1377 skb->dev = dev->master;
1381 static void net_tx_action(struct softirq_action *h)
1383 int cpu = smp_processor_id();
1385 if (softnet_data[cpu].completion_queue) {
1386 struct sk_buff *clist;
1388 local_irq_disable();
1389 clist = softnet_data[cpu].completion_queue;
1390 softnet_data[cpu].completion_queue = NULL;
1393 while (clist != NULL) {
1394 struct sk_buff *skb = clist;
1395 clist = clist->next;
1397 BUG_TRAP(atomic_read(&skb->users) == 0);
1402 if (softnet_data[cpu].output_queue) {
1403 struct net_device *head;
1405 local_irq_disable();
1406 head = softnet_data[cpu].output_queue;
1407 softnet_data[cpu].output_queue = NULL;
1410 while (head != NULL) {
1411 struct net_device *dev = head;
1412 head = head->next_sched;
1414 smp_mb__before_clear_bit();
1415 clear_bit(__LINK_STATE_SCHED, &dev->state);
1417 if (spin_trylock(&dev->queue_lock)) {
1419 spin_unlock(&dev->queue_lock);
1421 netif_schedule(dev);
1428 #if defined(CONFIG_BRIDGE) || defined(CONFIG_BRIDGE_MODULE)
1429 void (*br_handle_frame_hook)(struct sk_buff *skb) = NULL;
1432 static __inline__ int handle_bridge(struct sk_buff *skb,
1433 struct packet_type *pt_prev)
1435 int ret = NET_RX_DROP;
1439 ret = deliver_to_old_ones(pt_prev, skb, 0);
1441 atomic_inc(&skb->users);
1442 ret = pt_prev->func(skb, skb->dev, pt_prev);
1446 br_handle_frame_hook(skb);
1451 #ifdef CONFIG_NET_DIVERT
1452 static inline int handle_diverter(struct sk_buff *skb)
1454 /* if diversion is supported on device, then divert */
1455 if (skb->dev->divert && skb->dev->divert->divert)
1459 #endif /* CONFIG_NET_DIVERT */
1461 int netif_receive_skb(struct sk_buff *skb)
1463 struct packet_type *ptype, *pt_prev;
1464 int ret = NET_RX_DROP;
1465 unsigned short type;
1467 if (skb->stamp.tv_sec == 0)
1468 do_gettimeofday(&skb->stamp);
1472 netdev_rx_stat[smp_processor_id()].total++;
1474 #ifdef CONFIG_NET_FASTROUTE
1475 if (skb->pkt_type == PACKET_FASTROUTE) {
1476 netdev_rx_stat[smp_processor_id()].fastroute_deferred_out++;
1477 return dev_queue_xmit(skb);
1481 skb->h.raw = skb->nh.raw = skb->data;
1484 for (ptype = ptype_all; ptype; ptype = ptype->next) {
1485 if (!ptype->dev || ptype->dev == skb->dev) {
1487 if (!pt_prev->data) {
1488 ret = deliver_to_old_ones(pt_prev, skb, 0);
1490 atomic_inc(&skb->users);
1491 ret = pt_prev->func(skb, skb->dev, pt_prev);
1498 #ifdef CONFIG_NET_DIVERT
1499 if (skb->dev->divert && skb->dev->divert->divert)
1500 ret = handle_diverter(skb);
1501 #endif /* CONFIG_NET_DIVERT */
1503 #if defined(CONFIG_BRIDGE) || defined(CONFIG_BRIDGE_MODULE)
1504 if (skb->dev->br_port != NULL && br_handle_frame_hook != NULL &&
1505 skb->pkt_type != PACKET_LOOPBACK) {
1506 return handle_bridge(skb, pt_prev);
1510 type = skb->protocol;
1511 for (ptype=ptype_base[ntohs(type)&15];ptype;ptype=ptype->next) {
1512 if (ptype->type == type &&
1513 (!ptype->dev || ptype->dev == skb->dev)) {
1515 if (!pt_prev->data) {
1516 ret = deliver_to_old_ones(pt_prev, skb, 0);
1518 atomic_inc(&skb->users);
1519 ret = pt_prev->func(skb, skb->dev, pt_prev);
1527 if (!pt_prev->data) {
1528 ret = deliver_to_old_ones(pt_prev, skb, 1);
1530 ret = pt_prev->func(skb, skb->dev, pt_prev);
1534 /* Jamal, now you will not able to escape explaining
1535 * me how you were going to use this. :-)
1543 static int process_backlog(struct net_device *backlog_dev, int *budget)
1546 int quota = min(backlog_dev->quota, *budget);
1547 int this_cpu = smp_processor_id();
1548 struct softnet_data *queue = &softnet_data[this_cpu];
1549 unsigned long start_time = jiffies;
1552 struct sk_buff *skb;
1553 struct net_device *dev;
1555 local_irq_disable();
1556 skb = __skb_dequeue(&queue->input_pkt_queue);
1563 netif_receive_skb(skb);
1569 if (work >= quota || jiffies - start_time > 1)
1572 #ifdef CONFIG_NET_HW_FLOWCONTROL
1573 if (queue->throttle && queue->input_pkt_queue.qlen < no_cong_thresh ) {
1574 queue->throttle = 0;
1575 if (atomic_dec_and_test(&netdev_dropping)) {
1583 backlog_dev->quota -= work;
1588 backlog_dev->quota -= work;
1591 list_del(&backlog_dev->poll_list);
1592 smp_mb__before_clear_bit();
1593 netif_poll_enable(backlog_dev);
1595 if (queue->throttle) {
1596 queue->throttle = 0;
1597 #ifdef CONFIG_NET_HW_FLOWCONTROL
1598 if (atomic_dec_and_test(&netdev_dropping))
1606 static void net_rx_action(struct softirq_action *h)
1608 int this_cpu = smp_processor_id();
1609 struct softnet_data *queue = &softnet_data[this_cpu];
1610 unsigned long start_time = jiffies;
1611 int budget = netdev_max_backlog;
1613 br_read_lock(BR_NETPROTO_LOCK);
1614 local_irq_disable();
1616 while (!list_empty(&queue->poll_list)) {
1617 struct net_device *dev;
1619 if (budget <= 0 || jiffies - start_time > 1)
1624 dev = list_entry(queue->poll_list.next, struct net_device, poll_list);
1626 if (dev->quota <= 0 || dev->poll(dev, &budget)) {
1627 local_irq_disable();
1628 list_del(&dev->poll_list);
1629 list_add_tail(&dev->poll_list, &queue->poll_list);
1631 dev->quota += dev->weight;
1633 dev->quota = dev->weight;
1636 local_irq_disable();
1641 br_read_unlock(BR_NETPROTO_LOCK);
1645 netdev_rx_stat[this_cpu].time_squeeze++;
1646 __cpu_raise_softirq(this_cpu, NET_RX_SOFTIRQ);
1649 br_read_unlock(BR_NETPROTO_LOCK);
1652 static gifconf_func_t * gifconf_list [NPROTO];
1655 * register_gifconf - register a SIOCGIF handler
1656 * @family: Address family
1657 * @gifconf: Function handler
1659 * Register protocol dependent address dumping routines. The handler
1660 * that is passed must not be freed or reused until it has been replaced
1661 * by another handler.
1664 int register_gifconf(unsigned int family, gifconf_func_t * gifconf)
1668 gifconf_list[family] = gifconf;
1674 * Map an interface index to its name (SIOCGIFNAME)
1678 * We need this ioctl for efficient implementation of the
1679 * if_indextoname() function required by the IPv6 API. Without
1680 * it, we would have to search all the interfaces to find a
1684 static int dev_ifname(struct ifreq *arg)
1686 struct net_device *dev;
1690 * Fetch the caller's info block.
1693 if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
1696 read_lock(&dev_base_lock);
1697 dev = __dev_get_by_index(ifr.ifr_ifindex);
1699 read_unlock(&dev_base_lock);
1703 strcpy(ifr.ifr_name, dev->name);
1704 read_unlock(&dev_base_lock);
1706 if (copy_to_user(arg, &ifr, sizeof(struct ifreq)))
1712 * Perform a SIOCGIFCONF call. This structure will change
1713 * size eventually, and there is nothing I can do about it.
1714 * Thus we will need a 'compatibility mode'.
1717 static int dev_ifconf(char *arg)
1720 struct net_device *dev;
1727 * Fetch the caller's info block.
1730 if (copy_from_user(&ifc, arg, sizeof(struct ifconf)))
1737 * Loop over the interfaces, and write an info block for each.
1741 for (dev = dev_base; dev != NULL; dev = dev->next) {
1742 for (i=0; i<NPROTO; i++) {
1743 if (gifconf_list[i]) {
1746 done = gifconf_list[i](dev, NULL, 0);
1748 done = gifconf_list[i](dev, pos+total, len-total);
1759 * All done. Write the updated control block back to the caller.
1761 ifc.ifc_len = total;
1763 if (copy_to_user(arg, &ifc, sizeof(struct ifconf)))
1767 * Both BSD and Solaris return 0 here, so we do too.
1773 * This is invoked by the /proc filesystem handler to display a device
1777 #ifdef CONFIG_PROC_FS
1779 static int sprintf_stats(char *buffer, struct net_device *dev)
1781 struct net_device_stats *stats = (dev->get_stats ? dev->get_stats(dev): NULL);
1785 size = sprintf(buffer, "%6s:%8lu %7lu %4lu %4lu %4lu %5lu %10lu %9lu %8lu %7lu %4lu %4lu %4lu %5lu %7lu %10lu\n",
1788 stats->rx_packets, stats->rx_errors,
1789 stats->rx_dropped + stats->rx_missed_errors,
1790 stats->rx_fifo_errors,
1791 stats->rx_length_errors + stats->rx_over_errors
1792 + stats->rx_crc_errors + stats->rx_frame_errors,
1793 stats->rx_compressed, stats->multicast,
1795 stats->tx_packets, stats->tx_errors, stats->tx_dropped,
1796 stats->tx_fifo_errors, stats->collisions,
1797 stats->tx_carrier_errors + stats->tx_aborted_errors
1798 + stats->tx_window_errors + stats->tx_heartbeat_errors,
1799 stats->tx_compressed);
1801 size = sprintf(buffer, "%6s: No statistics available.\n", dev->name);
1807 * Called from the PROCfs module. This now uses the new arbitrary sized /proc/net interface
1808 * to create /proc/net/dev
1811 static int dev_get_info(char *buffer, char **start, off_t offset, int length)
1817 struct net_device *dev;
1820 size = sprintf(buffer,
1821 "Inter-| Receive | Transmit\n"
1822 " face |bytes packets errs drop fifo frame compressed multicast|bytes packets errs drop fifo colls carrier compressed\n");
1828 read_lock(&dev_base_lock);
1829 for (dev = dev_base; dev != NULL; dev = dev->next) {
1830 size = sprintf_stats(buffer+len, dev);
1838 if (pos > offset + length)
1841 read_unlock(&dev_base_lock);
1843 *start = buffer + (offset - begin); /* Start of wanted data */
1844 len -= (offset - begin); /* Start slop */
1846 len = length; /* Ending slop */
1852 static int dev_proc_stats(char *buffer, char **start, off_t offset,
1853 int length, int *eof, void *data)
1858 for (lcpu=0; lcpu<smp_num_cpus; lcpu++) {
1859 i = cpu_logical_map(lcpu);
1860 len += sprintf(buffer+len, "%08x %08x %08x %08x %08x %08x %08x %08x %08x\n",
1861 netdev_rx_stat[i].total,
1862 netdev_rx_stat[i].dropped,
1863 netdev_rx_stat[i].time_squeeze,
1864 netdev_rx_stat[i].throttled,
1865 netdev_rx_stat[i].fastroute_hit,
1866 netdev_rx_stat[i].fastroute_success,
1867 netdev_rx_stat[i].fastroute_defer,
1868 netdev_rx_stat[i].fastroute_deferred_out,
1870 netdev_rx_stat[i].fastroute_latency_reduction
1872 netdev_rx_stat[i].cpu_collision
1884 *start = buffer + offset;
1890 #endif /* CONFIG_PROC_FS */
1894 * netdev_set_master - set up master/slave pair
1895 * @slave: slave device
1896 * @master: new master device
1898 * Changes the master device of the slave. Pass %NULL to break the
1899 * bonding. The caller must hold the RTNL semaphore. On a failure
1900 * a negative errno code is returned. On success the reference counts
1901 * are adjusted, %RTM_NEWLINK is sent to the routing socket and the
1902 * function returns zero.
1905 int netdev_set_master(struct net_device *slave, struct net_device *master)
1907 struct net_device *old = slave->master;
1917 br_write_lock_bh(BR_NETPROTO_LOCK);
1918 slave->master = master;
1919 br_write_unlock_bh(BR_NETPROTO_LOCK);
1925 slave->flags |= IFF_SLAVE;
1927 slave->flags &= ~IFF_SLAVE;
1929 rtmsg_ifinfo(RTM_NEWLINK, slave, IFF_SLAVE);
1934 * dev_set_promiscuity - update promiscuity count on a device
1938 * Add or remove promsicuity from a device. While the count in the device
1939 * remains above zero the interface remains promiscuous. Once it hits zero
1940 * the device reverts back to normal filtering operation. A negative inc
1941 * value is used to drop promiscuity on the device.
1944 void dev_set_promiscuity(struct net_device *dev, int inc)
1946 unsigned short old_flags = dev->flags;
1948 dev->flags |= IFF_PROMISC;
1949 if ((dev->promiscuity += inc) == 0)
1950 dev->flags &= ~IFF_PROMISC;
1951 if (dev->flags^old_flags) {
1952 #ifdef CONFIG_NET_FASTROUTE
1953 if (dev->flags&IFF_PROMISC) {
1954 netdev_fastroute_obstacles++;
1955 dev_clear_fastroute(dev);
1957 netdev_fastroute_obstacles--;
1960 printk(KERN_INFO "device %s %s promiscuous mode\n",
1961 dev->name, (dev->flags&IFF_PROMISC) ? "entered" : "left");
1966 * dev_set_allmulti - update allmulti count on a device
1970 * Add or remove reception of all multicast frames to a device. While the
1971 * count in the device remains above zero the interface remains listening
1972 * to all interfaces. Once it hits zero the device reverts back to normal
1973 * filtering operation. A negative @inc value is used to drop the counter
1974 * when releasing a resource needing all multicasts.
1977 void dev_set_allmulti(struct net_device *dev, int inc)
1979 unsigned short old_flags = dev->flags;
1981 dev->flags |= IFF_ALLMULTI;
1982 if ((dev->allmulti += inc) == 0)
1983 dev->flags &= ~IFF_ALLMULTI;
1984 if (dev->flags^old_flags)
1988 int dev_change_flags(struct net_device *dev, unsigned flags)
1991 int old_flags = dev->flags;
1994 * Set the flags on our device.
1997 dev->flags = (flags & (IFF_DEBUG|IFF_NOTRAILERS|IFF_NOARP|IFF_DYNAMIC|
1998 IFF_MULTICAST|IFF_PORTSEL|IFF_AUTOMEDIA)) |
1999 (dev->flags & (IFF_UP|IFF_VOLATILE|IFF_PROMISC|IFF_ALLMULTI));
2002 * Load in the correct multicast list now the flags have changed.
2008 * Have we downed the interface. We handle IFF_UP ourselves
2009 * according to user attempts to set it, rather than blindly
2014 if ((old_flags^flags)&IFF_UP) /* Bit is different ? */
2016 ret = ((old_flags & IFF_UP) ? dev_close : dev_open)(dev);
2022 if (dev->flags&IFF_UP &&
2023 ((old_flags^dev->flags)&~(IFF_UP|IFF_PROMISC|IFF_ALLMULTI|IFF_VOLATILE)))
2024 notifier_call_chain(&netdev_chain, NETDEV_CHANGE, dev);
2026 if ((flags^dev->gflags)&IFF_PROMISC) {
2027 int inc = (flags&IFF_PROMISC) ? +1 : -1;
2028 dev->gflags ^= IFF_PROMISC;
2029 dev_set_promiscuity(dev, inc);
2032 /* NOTE: order of synchronization of IFF_PROMISC and IFF_ALLMULTI
2033 is important. Some (broken) drivers set IFF_PROMISC, when
2034 IFF_ALLMULTI is requested not asking us and not reporting.
2036 if ((flags^dev->gflags)&IFF_ALLMULTI) {
2037 int inc = (flags&IFF_ALLMULTI) ? +1 : -1;
2038 dev->gflags ^= IFF_ALLMULTI;
2039 dev_set_allmulti(dev, inc);
2042 if (old_flags^dev->flags)
2043 rtmsg_ifinfo(RTM_NEWLINK, dev, old_flags^dev->flags);
2049 * Perform the SIOCxIFxxx calls.
2052 static int dev_ifsioc(struct ifreq *ifr, unsigned int cmd)
2054 struct net_device *dev;
2057 if ((dev = __dev_get_by_name(ifr->ifr_name)) == NULL)
2062 case SIOCGIFFLAGS: /* Get interface flags */
2063 ifr->ifr_flags = (dev->flags&~(IFF_PROMISC|IFF_ALLMULTI|IFF_RUNNING))
2064 |(dev->gflags&(IFF_PROMISC|IFF_ALLMULTI));
2065 if (netif_running(dev) && netif_carrier_ok(dev))
2066 ifr->ifr_flags |= IFF_RUNNING;
2069 case SIOCSIFFLAGS: /* Set interface flags */
2070 return dev_change_flags(dev, ifr->ifr_flags);
2072 case SIOCGIFMETRIC: /* Get the metric on the interface (currently unused) */
2073 ifr->ifr_metric = 0;
2076 case SIOCSIFMETRIC: /* Set the metric on the interface (currently unused) */
2079 case SIOCGIFMTU: /* Get the MTU of a device */
2080 ifr->ifr_mtu = dev->mtu;
2083 case SIOCSIFMTU: /* Set the MTU of a device */
2084 if (ifr->ifr_mtu == dev->mtu)
2088 * MTU must be positive.
2094 if (!netif_device_present(dev))
2097 if (dev->change_mtu)
2098 err = dev->change_mtu(dev, ifr->ifr_mtu);
2100 dev->mtu = ifr->ifr_mtu;
2103 if (!err && dev->flags&IFF_UP)
2104 notifier_call_chain(&netdev_chain, NETDEV_CHANGEMTU, dev);
2108 memcpy(ifr->ifr_hwaddr.sa_data,dev->dev_addr, MAX_ADDR_LEN);
2109 ifr->ifr_hwaddr.sa_family=dev->type;
2113 if (dev->set_mac_address == NULL)
2115 if (ifr->ifr_hwaddr.sa_family!=dev->type)
2117 if (!netif_device_present(dev))
2119 err = dev->set_mac_address(dev, &ifr->ifr_hwaddr);
2121 notifier_call_chain(&netdev_chain, NETDEV_CHANGEADDR, dev);
2124 case SIOCSIFHWBROADCAST:
2125 if (ifr->ifr_hwaddr.sa_family!=dev->type)
2127 memcpy(dev->broadcast, ifr->ifr_hwaddr.sa_data, MAX_ADDR_LEN);
2128 notifier_call_chain(&netdev_chain, NETDEV_CHANGEADDR, dev);
2132 ifr->ifr_map.mem_start=dev->mem_start;
2133 ifr->ifr_map.mem_end=dev->mem_end;
2134 ifr->ifr_map.base_addr=dev->base_addr;
2135 ifr->ifr_map.irq=dev->irq;
2136 ifr->ifr_map.dma=dev->dma;
2137 ifr->ifr_map.port=dev->if_port;
2141 if (dev->set_config) {
2142 if (!netif_device_present(dev))
2144 return dev->set_config(dev,&ifr->ifr_map);
2149 if (dev->set_multicast_list == NULL ||
2150 ifr->ifr_hwaddr.sa_family != AF_UNSPEC)
2152 if (!netif_device_present(dev))
2154 dev_mc_add(dev,ifr->ifr_hwaddr.sa_data, dev->addr_len, 1);
2158 if (dev->set_multicast_list == NULL ||
2159 ifr->ifr_hwaddr.sa_family!=AF_UNSPEC)
2161 if (!netif_device_present(dev))
2163 dev_mc_delete(dev,ifr->ifr_hwaddr.sa_data,dev->addr_len, 1);
2167 ifr->ifr_ifindex = dev->ifindex;
2171 ifr->ifr_qlen = dev->tx_queue_len;
2175 if (ifr->ifr_qlen<0)
2177 dev->tx_queue_len = ifr->ifr_qlen;
2181 if (dev->flags&IFF_UP)
2183 /* Check if name contains a wildcard */
2184 if (strchr(ifr->ifr_newname, '%')) {
2185 char format[IFNAMSIZ + 1];
2187 memcpy(format, ifr->ifr_newname, IFNAMSIZ);
2188 format[IFNAMSIZ-1] = 0;
2189 /* Find a free name based on format.
2190 * dev_alloc_name() replaces "%d" with at max
2191 * 2 digits, so no name overflow. - Jean II */
2192 ret = dev_alloc_name(dev, format);
2195 /* Copy the new name back to caller. */
2196 strncpy(ifr->ifr_newname, dev->name, IFNAMSIZ);
2198 if (__dev_get_by_name(ifr->ifr_newname))
2200 memcpy(dev->name, ifr->ifr_newname, IFNAMSIZ);
2201 dev->name[IFNAMSIZ-1] = 0;
2203 notifier_call_chain(&netdev_chain, NETDEV_CHANGENAME, dev);
2207 * Unknown or private ioctl
2211 if ((cmd >= SIOCDEVPRIVATE &&
2212 cmd <= SIOCDEVPRIVATE + 15) ||
2213 cmd == SIOCBONDENSLAVE ||
2214 cmd == SIOCBONDRELEASE ||
2215 cmd == SIOCBONDSETHWADDR ||
2216 cmd == SIOCBONDSLAVEINFOQUERY ||
2217 cmd == SIOCBONDINFOQUERY ||
2218 cmd == SIOCBONDCHANGEACTIVE ||
2219 cmd == SIOCGMIIPHY ||
2220 cmd == SIOCGMIIREG ||
2221 cmd == SIOCSMIIREG ||
2222 cmd == SIOCWANDEV) {
2223 if (dev->do_ioctl) {
2224 if (!netif_device_present(dev))
2226 return dev->do_ioctl(dev, ifr, cmd);
2236 * This function handles all "interface"-type I/O control requests. The actual
2237 * 'doing' part of this is dev_ifsioc above.
2241 * dev_ioctl - network device ioctl
2242 * @cmd: command to issue
2243 * @arg: pointer to a struct ifreq in user space
2245 * Issue ioctl functions to devices. This is normally called by the
2246 * user space syscall interfaces but can sometimes be useful for
2247 * other purposes. The return value is the return from the syscall if
2248 * positive or a negative errno code on error.
2251 int dev_ioctl(unsigned int cmd, void *arg)
2257 /* One special case: SIOCGIFCONF takes ifconf argument
2258 and requires shared lock, because it sleeps writing
2262 if (cmd == SIOCGIFCONF) {
2264 ret = dev_ifconf((char *) arg);
2268 if (cmd == SIOCGIFNAME) {
2269 return dev_ifname((struct ifreq *)arg);
2272 if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
2275 ifr.ifr_name[IFNAMSIZ-1] = 0;
2277 colon = strchr(ifr.ifr_name, ':');
2282 * See which interface the caller is talking about.
2288 * These ioctl calls:
2289 * - can be done by all.
2290 * - atomic and do not require locking.
2302 dev_load(ifr.ifr_name);
2303 read_lock(&dev_base_lock);
2304 ret = dev_ifsioc(&ifr, cmd);
2305 read_unlock(&dev_base_lock);
2309 if (copy_to_user(arg, &ifr, sizeof(struct ifreq)))
2315 dev_load(ifr.ifr_name);
2317 ret = dev_ethtool(&ifr);
2322 if (copy_to_user(arg, &ifr,
2323 sizeof(struct ifreq)))
2329 * These ioctl calls:
2330 * - require superuser power.
2331 * - require strict serialization.
2338 if (!capable(CAP_NET_ADMIN))
2340 dev_load(ifr.ifr_name);
2343 ret = dev_ifsioc(&ifr, cmd);
2349 if (copy_to_user(arg, &ifr, sizeof(struct ifreq)))
2355 * These ioctl calls:
2356 * - require superuser power.
2357 * - require strict serialization.
2358 * - do not return a value
2369 case SIOCSIFHWBROADCAST:
2372 case SIOCBONDENSLAVE:
2373 case SIOCBONDRELEASE:
2374 case SIOCBONDSETHWADDR:
2375 case SIOCBONDSLAVEINFOQUERY:
2376 case SIOCBONDINFOQUERY:
2377 case SIOCBONDCHANGEACTIVE:
2378 if (!capable(CAP_NET_ADMIN))
2380 dev_load(ifr.ifr_name);
2383 ret = dev_ifsioc(&ifr, cmd);
2389 /* Get the per device memory space. We can add this but currently
2390 do not support it */
2392 /* Set the per device memory buffer space. Not applicable in our case */
2397 * Unknown or private ioctl.
2401 if (cmd == SIOCWANDEV ||
2402 (cmd >= SIOCDEVPRIVATE &&
2403 cmd <= SIOCDEVPRIVATE + 15)) {
2404 dev_load(ifr.ifr_name);
2407 ret = dev_ifsioc(&ifr, cmd);
2410 if (!ret && copy_to_user(arg, &ifr, sizeof(struct ifreq)))
2415 /* Take care of Wireless Extensions */
2416 if (cmd >= SIOCIWFIRST && cmd <= SIOCIWLAST) {
2417 /* If command is `set a parameter', or
2418 * `get the encoding parameters', check if
2419 * the user has the right to do it */
2420 if (IW_IS_SET(cmd) || (cmd == SIOCGIWENCODE)) {
2421 if(!capable(CAP_NET_ADMIN))
2424 dev_load(ifr.ifr_name);
2426 /* Follow me in net/core/wireless.c */
2427 ret = wireless_process_ioctl(&ifr, cmd);
2429 if (!ret && IW_IS_GET(cmd) &&
2430 copy_to_user(arg, &ifr, sizeof(struct ifreq)))
2434 #endif /* WIRELESS_EXT */
2441 * dev_new_index - allocate an ifindex
2443 * Returns a suitable unique value for a new device interface
2444 * number. The caller must hold the rtnl semaphore or the
2445 * dev_base_lock to be sure it remains unique.
2448 int dev_new_index(void)
2454 if (__dev_get_by_index(ifindex) == NULL)
2459 static int dev_boot_phase = 1;
2462 * register_netdevice - register a network device
2463 * @dev: device to register
2465 * Take a completed network device structure and add it to the kernel
2466 * interfaces. A %NETDEV_REGISTER message is sent to the netdev notifier
2467 * chain. 0 is returned on success. A negative errno code is returned
2468 * on a failure to set up the device, or if the name is a duplicate.
2470 * Callers must hold the rtnl semaphore. See the comment at the
2471 * end of Space.c for details about the locking. You may want
2472 * register_netdev() instead of this.
2475 * The locking appears insufficient to guarantee two parallel registers
2476 * will not get the same name.
2479 int net_dev_init(void);
2481 int register_netdevice(struct net_device *dev)
2483 struct net_device *d, **dp;
2484 #ifdef CONFIG_NET_DIVERT
2488 spin_lock_init(&dev->queue_lock);
2489 spin_lock_init(&dev->xmit_lock);
2490 dev->xmit_lock_owner = -1;
2491 #ifdef CONFIG_NET_FASTROUTE
2492 dev->fastpath_lock=RW_LOCK_UNLOCKED;
2498 #ifdef CONFIG_NET_DIVERT
2499 ret = alloc_divert_blk(dev);
2502 #endif /* CONFIG_NET_DIVERT */
2506 /* Init, if this function is available */
2507 if (dev->init && dev->init(dev) != 0) {
2508 #ifdef CONFIG_NET_DIVERT
2509 free_divert_blk(dev);
2514 dev->ifindex = dev_new_index();
2515 if (dev->iflink == -1)
2516 dev->iflink = dev->ifindex;
2518 /* Check for existence, and append to tail of chain */
2519 for (dp=&dev_base; (d=*dp) != NULL; dp=&d->next) {
2520 if (d == dev || strcmp(d->name, dev->name) == 0) {
2521 #ifdef CONFIG_NET_DIVERT
2522 free_divert_blk(dev);
2528 /* Fix illegal SG+CSUM combinations. */
2529 if ((dev->features & NETIF_F_SG) &&
2530 !(dev->features & (NETIF_F_IP_CSUM |
2532 NETIF_F_HW_CSUM))) {
2533 printk("%s: Dropping NETIF_F_SG since no checksum feature.\n",
2535 dev->features &= ~NETIF_F_SG;
2539 * nil rebuild_header routine,
2540 * that should be never called and used as just bug trap.
2543 if (dev->rebuild_header == NULL)
2544 dev->rebuild_header = default_rebuild_header;
2547 * Default initial state at registry is that the
2548 * device is present.
2551 set_bit(__LINK_STATE_PRESENT, &dev->state);
2554 dev_init_scheduler(dev);
2555 write_lock_bh(&dev_base_lock);
2559 write_unlock_bh(&dev_base_lock);
2561 /* Notify protocols, that a new device appeared. */
2562 notifier_call_chain(&netdev_chain, NETDEV_REGISTER, dev);
2564 net_run_sbin_hotplug(dev, "register");
2570 * netdev_finish_unregister - complete unregistration
2573 * Destroy and free a dead device. A value of zero is returned on
2577 int netdev_finish_unregister(struct net_device *dev)
2579 BUG_TRAP(dev->ip_ptr==NULL);
2580 BUG_TRAP(dev->ip6_ptr==NULL);
2581 BUG_TRAP(dev->dn_ptr==NULL);
2583 if (!dev->deadbeaf) {
2584 printk(KERN_ERR "Freeing alive device %p, %s\n", dev, dev->name);
2587 #ifdef NET_REFCNT_DEBUG
2588 printk(KERN_DEBUG "netdev_finish_unregister: %s%s.\n", dev->name,
2589 (dev->features & NETIF_F_DYNALLOC)?"":", old style");
2591 if (dev->destructor)
2592 dev->destructor(dev);
2593 if (dev->features & NETIF_F_DYNALLOC)
2599 * unregister_netdevice - remove device from the kernel
2602 * This function shuts down a device interface and removes it
2603 * from the kernel tables. On success 0 is returned, on a failure
2604 * a negative errno code is returned.
2606 * Callers must hold the rtnl semaphore. See the comment at the
2607 * end of Space.c for details about the locking. You may want
2608 * unregister_netdev() instead of this.
2611 int unregister_netdevice(struct net_device *dev)
2613 unsigned long now, warning_time;
2614 struct net_device *d, **dp;
2616 /* If device is running, close it first. */
2617 if (dev->flags & IFF_UP)
2620 BUG_TRAP(dev->deadbeaf==0);
2623 /* And unlink it from device chain. */
2624 for (dp = &dev_base; (d=*dp) != NULL; dp=&d->next) {
2626 write_lock_bh(&dev_base_lock);
2628 write_unlock_bh(&dev_base_lock);
2633 printk(KERN_DEBUG "unregister_netdevice: device %s/%p never was registered\n", dev->name, dev);
2637 /* Synchronize to net_rx_action. */
2638 br_write_lock_bh(BR_NETPROTO_LOCK);
2639 br_write_unlock_bh(BR_NETPROTO_LOCK);
2641 if (dev_boot_phase == 0) {
2642 #ifdef CONFIG_NET_FASTROUTE
2643 dev_clear_fastroute(dev);
2646 /* Shutdown queueing discipline. */
2649 net_run_sbin_hotplug(dev, "unregister");
2651 /* Notify protocols, that we are about to destroy
2652 this device. They should clean all the things.
2654 notifier_call_chain(&netdev_chain, NETDEV_UNREGISTER, dev);
2657 * Flush the multicast chain
2659 dev_mc_discard(dev);
2665 /* Notifier chain MUST detach us from master device. */
2666 BUG_TRAP(dev->master==NULL);
2668 #ifdef CONFIG_NET_DIVERT
2669 free_divert_blk(dev);
2672 if (dev->features & NETIF_F_DYNALLOC) {
2673 #ifdef NET_REFCNT_DEBUG
2674 if (atomic_read(&dev->refcnt) != 1)
2675 printk(KERN_DEBUG "unregister_netdevice: holding %s refcnt=%d\n", dev->name, atomic_read(&dev->refcnt)-1);
2681 /* Last reference is our one */
2682 if (atomic_read(&dev->refcnt) == 1) {
2687 #ifdef NET_REFCNT_DEBUG
2688 printk("unregister_netdevice: waiting %s refcnt=%d\n", dev->name, atomic_read(&dev->refcnt));
2691 /* EXPLANATION. If dev->refcnt is not now 1 (our own reference)
2692 it means that someone in the kernel still has a reference
2693 to this device and we cannot release it.
2695 "New style" devices have destructors, hence we can return from this
2696 function and destructor will do all the work later. As of kernel 2.4.0
2697 there are very few "New Style" devices.
2699 "Old style" devices expect that the device is free of any references
2700 upon exit from this function.
2701 We cannot return from this function until all such references have
2702 fallen away. This is because the caller of this function will probably
2703 immediately kfree(*dev) and then be unloaded via sys_delete_module.
2705 So, we linger until all references fall away. The duration of the
2706 linger is basically unbounded! It is driven by, for example, the
2707 current setting of sysctl_ipfrag_time.
2709 After 1 second, we start to rebroadcast unregister notifications
2710 in hope that careless clients will release the device.
2714 now = warning_time = jiffies;
2715 while (atomic_read(&dev->refcnt) != 1) {
2716 if ((jiffies - now) > 1*HZ) {
2717 /* Rebroadcast unregister notification */
2718 notifier_call_chain(&netdev_chain, NETDEV_UNREGISTER, dev);
2720 current->state = TASK_INTERRUPTIBLE;
2721 schedule_timeout(HZ/4);
2722 current->state = TASK_RUNNING;
2723 if ((jiffies - warning_time) > 10*HZ) {
2724 printk(KERN_EMERG "unregister_netdevice: waiting for %s to "
2725 "become free. Usage count = %d\n",
2726 dev->name, atomic_read(&dev->refcnt));
2727 warning_time = jiffies;
2736 * Initialize the DEV module. At boot time this walks the device list and
2737 * unhooks any devices that fail to initialise (normally hardware not
2738 * present) and leaves us with a valid list of present and active devices.
2742 extern void net_device_init(void);
2743 extern void ip_auto_config(void);
2744 struct proc_dir_entry *proc_net_drivers;
2745 #ifdef CONFIG_NET_DIVERT
2746 extern void dv_init(void);
2747 #endif /* CONFIG_NET_DIVERT */
2751 * Callers must hold the rtnl semaphore. See the comment at the
2752 * end of Space.c for details about the locking.
2754 int __init net_dev_init(void)
2756 struct net_device *dev, **dp;
2759 if (!dev_boot_phase)
2763 #ifdef CONFIG_NET_DIVERT
2765 #endif /* CONFIG_NET_DIVERT */
2768 * Initialise the packet receive queues.
2771 for (i = 0; i < NR_CPUS; i++) {
2772 struct softnet_data *queue;
2774 queue = &softnet_data[i];
2775 skb_queue_head_init(&queue->input_pkt_queue);
2776 queue->throttle = 0;
2777 queue->cng_level = 0;
2778 queue->avg_blog = 10; /* arbitrary non-zero */
2779 queue->completion_queue = NULL;
2780 INIT_LIST_HEAD(&queue->poll_list);
2781 set_bit(__LINK_STATE_START, &queue->blog_dev.state);
2782 queue->blog_dev.weight = weight_p;
2783 queue->blog_dev.poll = process_backlog;
2784 atomic_set(&queue->blog_dev.refcnt, 1);
2787 #ifdef CONFIG_NET_PROFILE
2789 NET_PROFILE_REGISTER(dev_queue_xmit);
2790 NET_PROFILE_REGISTER(softnet_process);
2793 #ifdef OFFLINE_SAMPLE
2794 samp_timer.expires = jiffies + (10 * HZ);
2795 add_timer(&samp_timer);
2800 * If the call to dev->init fails, the dev is removed
2801 * from the chain disconnecting the device until the
2804 * NB At boot phase networking is dead. No locking is required.
2805 * But we still preserve dev_base_lock for sanity.
2809 while ((dev = *dp) != NULL) {
2810 spin_lock_init(&dev->queue_lock);
2811 spin_lock_init(&dev->xmit_lock);
2812 #ifdef CONFIG_NET_FASTROUTE
2813 dev->fastpath_lock = RW_LOCK_UNLOCKED;
2815 dev->xmit_lock_owner = -1;
2820 * Allocate name. If the init() fails
2821 * the name will be reissued correctly.
2823 if (strchr(dev->name, '%'))
2824 dev_alloc_name(dev, dev->name);
2827 * Check boot time settings for the device.
2829 netdev_boot_setup_check(dev);
2831 if (dev->init && dev->init(dev)) {
2833 * It failed to come up. It will be unhooked later.
2834 * dev_alloc_name can now advance to next suitable
2835 * name that is checked next.
2841 dev->ifindex = dev_new_index();
2842 if (dev->iflink == -1)
2843 dev->iflink = dev->ifindex;
2844 if (dev->rebuild_header == NULL)
2845 dev->rebuild_header = default_rebuild_header;
2846 dev_init_scheduler(dev);
2847 set_bit(__LINK_STATE_PRESENT, &dev->state);
2852 * Unhook devices that failed to come up
2855 while ((dev = *dp) != NULL) {
2856 if (dev->deadbeaf) {
2857 write_lock_bh(&dev_base_lock);
2859 write_unlock_bh(&dev_base_lock);
2866 #ifdef CONFIG_PROC_FS
2867 proc_net_create("dev", 0, dev_get_info);
2868 create_proc_read_entry("net/softnet_stat", 0, 0, dev_proc_stats, NULL);
2869 proc_net_drivers = proc_mkdir("net/drivers", 0);
2871 /* Available in net/core/wireless.c */
2872 proc_net_create("wireless", 0, dev_get_wireless_info);
2873 #endif /* WIRELESS_EXT */
2874 #endif /* CONFIG_PROC_FS */
2878 open_softirq(NET_TX_SOFTIRQ, net_tx_action, NULL);
2879 open_softirq(NET_RX_SOFTIRQ, net_rx_action, NULL);
2884 #ifdef CONFIG_NET_SCHED
2888 * Initialise network devices
2896 #ifdef CONFIG_HOTPLUG
2898 /* Notify userspace when a netdevice event occurs,
2899 * by running '/sbin/hotplug net' with certain
2900 * environment variables set.
2903 static int net_run_sbin_hotplug(struct net_device *dev, char *action)
2905 char *argv[3], *envp[5], ifname[12 + IFNAMSIZ], action_str[32];
2908 sprintf(ifname, "INTERFACE=%s", dev->name);
2909 sprintf(action_str, "ACTION=%s", action);
2912 argv[i++] = hotplug_path;
2917 /* minimal command environment */
2918 envp [i++] = "HOME=/";
2919 envp [i++] = "PATH=/sbin:/bin:/usr/sbin:/usr/bin";
2920 envp [i++] = ifname;
2921 envp [i++] = action_str;
2924 return call_usermodehelper(argv [0], argv, envp);