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
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
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
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
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
51 * Rudi Cilibrasi : Pass the right thing to
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
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
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
75 #include <asm/uaccess.h>
76 #include <asm/system.h>
77 #include <linux/bitops.h>
78 #include <linux/capability.h>
79 #include <linux/cpu.h>
80 #include <linux/types.h>
81 #include <linux/kernel.h>
82 #include <linux/sched.h>
83 #include <linux/mutex.h>
84 #include <linux/string.h>
86 #include <linux/socket.h>
87 #include <linux/sockios.h>
88 #include <linux/errno.h>
89 #include <linux/interrupt.h>
90 #include <linux/if_ether.h>
91 #include <linux/netdevice.h>
92 #include <linux/etherdevice.h>
93 #include <linux/notifier.h>
94 #include <linux/skbuff.h>
96 #include <linux/rtnetlink.h>
97 #include <linux/proc_fs.h>
98 #include <linux/seq_file.h>
99 #include <linux/stat.h>
100 #include <linux/if_bridge.h>
102 #include <net/pkt_sched.h>
103 #include <net/checksum.h>
104 #include <linux/highmem.h>
105 #include <linux/init.h>
106 #include <linux/kmod.h>
107 #include <linux/module.h>
108 #include <linux/kallsyms.h>
109 #include <linux/netpoll.h>
110 #include <linux/rcupdate.h>
111 #include <linux/delay.h>
112 #include <linux/wireless.h>
113 #include <net/iw_handler.h>
114 #include <asm/current.h>
115 #include <linux/audit.h>
116 #include <linux/dmaengine.h>
117 #include <linux/err.h>
118 #include <linux/ctype.h>
121 * The list of packet types we will receive (as opposed to discard)
122 * and the routines to invoke.
124 * Why 16. Because with 16 the only overlap we get on a hash of the
125 * low nibble of the protocol value is RARP/SNAP/X.25.
127 * NOTE: That is no longer true with the addition of VLAN tags. Not
128 * sure which should go first, but I bet it won't make much
129 * difference if we are running VLANs. The good news is that
130 * this protocol won't be in the list unless compiled in, so
131 * the average user (w/out VLANs) will not be adversely affected.
148 static DEFINE_SPINLOCK(ptype_lock
);
149 static struct list_head ptype_base
[16] __read_mostly
; /* 16 way hashed list */
150 static struct list_head ptype_all __read_mostly
; /* Taps */
152 #ifdef CONFIG_NET_DMA
153 static struct dma_client
*net_dma_client
;
154 static unsigned int net_dma_count
;
155 static spinlock_t net_dma_event_lock
;
159 * The @dev_base list is protected by @dev_base_lock and the rtnl
162 * Pure readers hold dev_base_lock for reading.
164 * Writers must hold the rtnl semaphore while they loop through the
165 * dev_base list, and hold dev_base_lock for writing when they do the
166 * actual updates. This allows pure readers to access the list even
167 * while a writer is preparing to update it.
169 * To put it another way, dev_base_lock is held for writing only to
170 * protect against pure readers; the rtnl semaphore provides the
171 * protection against other writers.
173 * See, for example usages, register_netdevice() and
174 * unregister_netdevice(), which must be called with the rtnl
177 struct net_device
*dev_base
;
178 static struct net_device
**dev_tail
= &dev_base
;
179 DEFINE_RWLOCK(dev_base_lock
);
181 EXPORT_SYMBOL(dev_base
);
182 EXPORT_SYMBOL(dev_base_lock
);
184 #define NETDEV_HASHBITS 8
185 static struct hlist_head dev_name_head
[1<<NETDEV_HASHBITS
];
186 static struct hlist_head dev_index_head
[1<<NETDEV_HASHBITS
];
188 static inline struct hlist_head
*dev_name_hash(const char *name
)
190 unsigned hash
= full_name_hash(name
, strnlen(name
, IFNAMSIZ
));
191 return &dev_name_head
[hash
& ((1<<NETDEV_HASHBITS
)-1)];
194 static inline struct hlist_head
*dev_index_hash(int ifindex
)
196 return &dev_index_head
[ifindex
& ((1<<NETDEV_HASHBITS
)-1)];
203 static RAW_NOTIFIER_HEAD(netdev_chain
);
206 * Device drivers call our routines to queue packets here. We empty the
207 * queue in the local softnet handler.
209 DEFINE_PER_CPU(struct softnet_data
, softnet_data
) = { NULL
};
212 extern int netdev_sysfs_init(void);
213 extern int netdev_register_sysfs(struct net_device
*);
214 extern void netdev_unregister_sysfs(struct net_device
*);
216 #define netdev_sysfs_init() (0)
217 #define netdev_register_sysfs(dev) (0)
218 #define netdev_unregister_sysfs(dev) do { } while(0)
222 /*******************************************************************************
224 Protocol management and registration routines
226 *******************************************************************************/
229 * Add a protocol ID to the list. Now that the input handler is
230 * smarter we can dispense with all the messy stuff that used to be
233 * BEWARE!!! Protocol handlers, mangling input packets,
234 * MUST BE last in hash buckets and checking protocol handlers
235 * MUST start from promiscuous ptype_all chain in net_bh.
236 * It is true now, do not change it.
237 * Explanation follows: if protocol handler, mangling packet, will
238 * be the first on list, it is not able to sense, that packet
239 * is cloned and should be copied-on-write, so that it will
240 * change it and subsequent readers will get broken packet.
245 * dev_add_pack - add packet handler
246 * @pt: packet type declaration
248 * Add a protocol handler to the networking stack. The passed &packet_type
249 * is linked into kernel lists and may not be freed until it has been
250 * removed from the kernel lists.
252 * This call does not sleep therefore it can not
253 * guarantee all CPU's that are in middle of receiving packets
254 * will see the new packet type (until the next received packet).
257 void dev_add_pack(struct packet_type
*pt
)
261 spin_lock_bh(&ptype_lock
);
262 if (pt
->type
== htons(ETH_P_ALL
))
263 list_add_rcu(&pt
->list
, &ptype_all
);
265 hash
= ntohs(pt
->type
) & 15;
266 list_add_rcu(&pt
->list
, &ptype_base
[hash
]);
268 spin_unlock_bh(&ptype_lock
);
272 * __dev_remove_pack - remove packet handler
273 * @pt: packet type declaration
275 * Remove a protocol handler that was previously added to the kernel
276 * protocol handlers by dev_add_pack(). The passed &packet_type is removed
277 * from the kernel lists and can be freed or reused once this function
280 * The packet type might still be in use by receivers
281 * and must not be freed until after all the CPU's have gone
282 * through a quiescent state.
284 void __dev_remove_pack(struct packet_type
*pt
)
286 struct list_head
*head
;
287 struct packet_type
*pt1
;
289 spin_lock_bh(&ptype_lock
);
291 if (pt
->type
== htons(ETH_P_ALL
))
294 head
= &ptype_base
[ntohs(pt
->type
) & 15];
296 list_for_each_entry(pt1
, head
, list
) {
298 list_del_rcu(&pt
->list
);
303 printk(KERN_WARNING
"dev_remove_pack: %p not found.\n", pt
);
305 spin_unlock_bh(&ptype_lock
);
308 * dev_remove_pack - remove packet handler
309 * @pt: packet type declaration
311 * Remove a protocol handler that was previously added to the kernel
312 * protocol handlers by dev_add_pack(). The passed &packet_type is removed
313 * from the kernel lists and can be freed or reused once this function
316 * This call sleeps to guarantee that no CPU is looking at the packet
319 void dev_remove_pack(struct packet_type
*pt
)
321 __dev_remove_pack(pt
);
326 /******************************************************************************
328 Device Boot-time Settings Routines
330 *******************************************************************************/
332 /* Boot time configuration table */
333 static struct netdev_boot_setup dev_boot_setup
[NETDEV_BOOT_SETUP_MAX
];
336 * netdev_boot_setup_add - add new setup entry
337 * @name: name of the device
338 * @map: configured settings for the device
340 * Adds new setup entry to the dev_boot_setup list. The function
341 * returns 0 on error and 1 on success. This is a generic routine to
344 static int netdev_boot_setup_add(char *name
, struct ifmap
*map
)
346 struct netdev_boot_setup
*s
;
350 for (i
= 0; i
< NETDEV_BOOT_SETUP_MAX
; i
++) {
351 if (s
[i
].name
[0] == '\0' || s
[i
].name
[0] == ' ') {
352 memset(s
[i
].name
, 0, sizeof(s
[i
].name
));
353 strcpy(s
[i
].name
, name
);
354 memcpy(&s
[i
].map
, map
, sizeof(s
[i
].map
));
359 return i
>= NETDEV_BOOT_SETUP_MAX
? 0 : 1;
363 * netdev_boot_setup_check - check boot time settings
364 * @dev: the netdevice
366 * Check boot time settings for the device.
367 * The found settings are set for the device to be used
368 * later in the device probing.
369 * Returns 0 if no settings found, 1 if they are.
371 int netdev_boot_setup_check(struct net_device
*dev
)
373 struct netdev_boot_setup
*s
= dev_boot_setup
;
376 for (i
= 0; i
< NETDEV_BOOT_SETUP_MAX
; i
++) {
377 if (s
[i
].name
[0] != '\0' && s
[i
].name
[0] != ' ' &&
378 !strncmp(dev
->name
, s
[i
].name
, strlen(s
[i
].name
))) {
379 dev
->irq
= s
[i
].map
.irq
;
380 dev
->base_addr
= s
[i
].map
.base_addr
;
381 dev
->mem_start
= s
[i
].map
.mem_start
;
382 dev
->mem_end
= s
[i
].map
.mem_end
;
391 * netdev_boot_base - get address from boot time settings
392 * @prefix: prefix for network device
393 * @unit: id for network device
395 * Check boot time settings for the base address of device.
396 * The found settings are set for the device to be used
397 * later in the device probing.
398 * Returns 0 if no settings found.
400 unsigned long netdev_boot_base(const char *prefix
, int unit
)
402 const struct netdev_boot_setup
*s
= dev_boot_setup
;
406 sprintf(name
, "%s%d", prefix
, unit
);
409 * If device already registered then return base of 1
410 * to indicate not to probe for this interface
412 if (__dev_get_by_name(name
))
415 for (i
= 0; i
< NETDEV_BOOT_SETUP_MAX
; i
++)
416 if (!strcmp(name
, s
[i
].name
))
417 return s
[i
].map
.base_addr
;
422 * Saves at boot time configured settings for any netdevice.
424 int __init
netdev_boot_setup(char *str
)
429 str
= get_options(str
, ARRAY_SIZE(ints
), ints
);
434 memset(&map
, 0, sizeof(map
));
438 map
.base_addr
= ints
[2];
440 map
.mem_start
= ints
[3];
442 map
.mem_end
= ints
[4];
444 /* Add new entry to the list */
445 return netdev_boot_setup_add(str
, &map
);
448 __setup("netdev=", netdev_boot_setup
);
450 /*******************************************************************************
452 Device Interface Subroutines
454 *******************************************************************************/
457 * __dev_get_by_name - find a device by its name
458 * @name: name to find
460 * Find an interface by name. Must be called under RTNL semaphore
461 * or @dev_base_lock. If the name is found a pointer to the device
462 * is returned. If the name is not found then %NULL is returned. The
463 * reference counters are not incremented so the caller must be
464 * careful with locks.
467 struct net_device
*__dev_get_by_name(const char *name
)
469 struct hlist_node
*p
;
471 hlist_for_each(p
, dev_name_hash(name
)) {
472 struct net_device
*dev
473 = hlist_entry(p
, struct net_device
, name_hlist
);
474 if (!strncmp(dev
->name
, name
, IFNAMSIZ
))
481 * dev_get_by_name - find a device by its name
482 * @name: name to find
484 * Find an interface by name. This can be called from any
485 * context and does its own locking. The returned handle has
486 * the usage count incremented and the caller must use dev_put() to
487 * release it when it is no longer needed. %NULL is returned if no
488 * matching device is found.
491 struct net_device
*dev_get_by_name(const char *name
)
493 struct net_device
*dev
;
495 read_lock(&dev_base_lock
);
496 dev
= __dev_get_by_name(name
);
499 read_unlock(&dev_base_lock
);
504 * __dev_get_by_index - find a device by its ifindex
505 * @ifindex: index of device
507 * Search for an interface by index. Returns %NULL if the device
508 * is not found or a pointer to the device. The device has not
509 * had its reference counter increased so the caller must be careful
510 * about locking. The caller must hold either the RTNL semaphore
514 struct net_device
*__dev_get_by_index(int ifindex
)
516 struct hlist_node
*p
;
518 hlist_for_each(p
, dev_index_hash(ifindex
)) {
519 struct net_device
*dev
520 = hlist_entry(p
, struct net_device
, index_hlist
);
521 if (dev
->ifindex
== ifindex
)
529 * dev_get_by_index - find a device by its ifindex
530 * @ifindex: index of device
532 * Search for an interface by index. Returns NULL if the device
533 * is not found or a pointer to the device. The device returned has
534 * had a reference added and the pointer is safe until the user calls
535 * dev_put to indicate they have finished with it.
538 struct net_device
*dev_get_by_index(int ifindex
)
540 struct net_device
*dev
;
542 read_lock(&dev_base_lock
);
543 dev
= __dev_get_by_index(ifindex
);
546 read_unlock(&dev_base_lock
);
551 * dev_getbyhwaddr - find a device by its hardware address
552 * @type: media type of device
553 * @ha: hardware address
555 * Search for an interface by MAC address. Returns NULL if the device
556 * is not found or a pointer to the device. The caller must hold the
557 * rtnl semaphore. The returned device has not had its ref count increased
558 * and the caller must therefore be careful about locking
561 * If the API was consistent this would be __dev_get_by_hwaddr
564 struct net_device
*dev_getbyhwaddr(unsigned short type
, char *ha
)
566 struct net_device
*dev
;
570 for (dev
= dev_base
; dev
; dev
= dev
->next
)
571 if (dev
->type
== type
&&
572 !memcmp(dev
->dev_addr
, ha
, dev
->addr_len
))
577 EXPORT_SYMBOL(dev_getbyhwaddr
);
579 struct net_device
*dev_getfirstbyhwtype(unsigned short type
)
581 struct net_device
*dev
;
584 for (dev
= dev_base
; dev
; dev
= dev
->next
) {
585 if (dev
->type
== type
) {
594 EXPORT_SYMBOL(dev_getfirstbyhwtype
);
597 * dev_get_by_flags - find any device with given flags
598 * @if_flags: IFF_* values
599 * @mask: bitmask of bits in if_flags to check
601 * Search for any interface with the given flags. Returns NULL if a device
602 * is not found or a pointer to the device. The device returned has
603 * had a reference added and the pointer is safe until the user calls
604 * dev_put to indicate they have finished with it.
607 struct net_device
* dev_get_by_flags(unsigned short if_flags
, unsigned short mask
)
609 struct net_device
*dev
;
611 read_lock(&dev_base_lock
);
612 for (dev
= dev_base
; dev
!= NULL
; dev
= dev
->next
) {
613 if (((dev
->flags
^ if_flags
) & mask
) == 0) {
618 read_unlock(&dev_base_lock
);
623 * dev_valid_name - check if name is okay for network device
626 * Network device names need to be valid file names to
627 * to allow sysfs to work. We also disallow any kind of
630 int dev_valid_name(const char *name
)
634 if (strlen(name
) >= IFNAMSIZ
)
636 if (!strcmp(name
, ".") || !strcmp(name
, ".."))
640 if (*name
== '/' || isspace(*name
))
648 * dev_alloc_name - allocate a name for a device
650 * @name: name format string
652 * Passed a format string - eg "lt%d" it will try and find a suitable
653 * id. It scans list of devices to build up a free map, then chooses
654 * the first empty slot. The caller must hold the dev_base or rtnl lock
655 * while allocating the name and adding the device in order to avoid
657 * Limited to bits_per_byte * page size devices (ie 32K on most platforms).
658 * Returns the number of the unit assigned or a negative errno code.
661 int dev_alloc_name(struct net_device
*dev
, const char *name
)
666 const int max_netdevices
= 8*PAGE_SIZE
;
668 struct net_device
*d
;
670 p
= strnchr(name
, IFNAMSIZ
-1, '%');
673 * Verify the string as this thing may have come from
674 * the user. There must be either one "%d" and no other "%"
677 if (p
[1] != 'd' || strchr(p
+ 2, '%'))
680 /* Use one page as a bit array of possible slots */
681 inuse
= (long *) get_zeroed_page(GFP_ATOMIC
);
685 for (d
= dev_base
; d
; d
= d
->next
) {
686 if (!sscanf(d
->name
, name
, &i
))
688 if (i
< 0 || i
>= max_netdevices
)
691 /* avoid cases where sscanf is not exact inverse of printf */
692 snprintf(buf
, sizeof(buf
), name
, i
);
693 if (!strncmp(buf
, d
->name
, IFNAMSIZ
))
697 i
= find_first_zero_bit(inuse
, max_netdevices
);
698 free_page((unsigned long) inuse
);
701 snprintf(buf
, sizeof(buf
), name
, i
);
702 if (!__dev_get_by_name(buf
)) {
703 strlcpy(dev
->name
, buf
, IFNAMSIZ
);
707 /* It is possible to run out of possible slots
708 * when the name is long and there isn't enough space left
709 * for the digits, or if all bits are used.
716 * dev_change_name - change name of a device
718 * @newname: name (or format string) must be at least IFNAMSIZ
720 * Change name of a device, can pass format strings "eth%d".
723 int dev_change_name(struct net_device
*dev
, char *newname
)
729 if (dev
->flags
& IFF_UP
)
732 if (!dev_valid_name(newname
))
735 if (strchr(newname
, '%')) {
736 err
= dev_alloc_name(dev
, newname
);
739 strcpy(newname
, dev
->name
);
741 else if (__dev_get_by_name(newname
))
744 strlcpy(dev
->name
, newname
, IFNAMSIZ
);
746 device_rename(&dev
->dev
, dev
->name
);
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
, NETDEV_CHANGENAME
, dev
);
755 * netdev_features_change - device changes features
756 * @dev: device to cause notification
758 * Called to indicate a device has changed features.
760 void netdev_features_change(struct net_device
*dev
)
762 raw_notifier_call_chain(&netdev_chain
, NETDEV_FEAT_CHANGE
, dev
);
764 EXPORT_SYMBOL(netdev_features_change
);
767 * netdev_state_change - device changes state
768 * @dev: device to cause notification
770 * Called to indicate a device has changed state. This function calls
771 * the notifier chains for netdev_chain and sends a NEWLINK message
772 * to the routing socket.
774 void netdev_state_change(struct net_device
*dev
)
776 if (dev
->flags
& IFF_UP
) {
777 raw_notifier_call_chain(&netdev_chain
,
779 rtmsg_ifinfo(RTM_NEWLINK
, dev
, 0);
784 * dev_load - load a network module
785 * @name: name of interface
787 * If a network interface is not present and the process has suitable
788 * privileges this function loads the module. If module loading is not
789 * available in this kernel then it becomes a nop.
792 void dev_load(const char *name
)
794 struct net_device
*dev
;
796 read_lock(&dev_base_lock
);
797 dev
= __dev_get_by_name(name
);
798 read_unlock(&dev_base_lock
);
800 if (!dev
&& capable(CAP_SYS_MODULE
))
801 request_module("%s", name
);
804 static int default_rebuild_header(struct sk_buff
*skb
)
806 printk(KERN_DEBUG
"%s: default_rebuild_header called -- BUG!\n",
807 skb
->dev
? skb
->dev
->name
: "NULL!!!");
813 * dev_open - prepare an interface for use.
814 * @dev: device to open
816 * Takes a device from down to up state. The device's private open
817 * function is invoked and then the multicast lists are loaded. Finally
818 * the device is moved into the up state and a %NETDEV_UP message is
819 * sent to the netdev notifier chain.
821 * Calling this function on an active interface is a nop. On a failure
822 * a negative errno code is returned.
824 int dev_open(struct net_device
*dev
)
832 if (dev
->flags
& IFF_UP
)
836 * Is it even present?
838 if (!netif_device_present(dev
))
842 * Call device private open method
844 set_bit(__LINK_STATE_START
, &dev
->state
);
846 ret
= dev
->open(dev
);
848 clear_bit(__LINK_STATE_START
, &dev
->state
);
852 * If it went open OK then:
859 dev
->flags
|= IFF_UP
;
862 * Initialize multicasting status
867 * Wakeup transmit queue engine
872 * ... and announce new interface.
874 raw_notifier_call_chain(&netdev_chain
, NETDEV_UP
, dev
);
880 * dev_close - shutdown an interface.
881 * @dev: device to shutdown
883 * This function moves an active device into down state. A
884 * %NETDEV_GOING_DOWN is sent to the netdev notifier chain. The device
885 * is then deactivated and finally a %NETDEV_DOWN is sent to the notifier
888 int dev_close(struct net_device
*dev
)
890 if (!(dev
->flags
& IFF_UP
))
894 * Tell people we are going down, so that they can
895 * prepare to death, when device is still operating.
897 raw_notifier_call_chain(&netdev_chain
, NETDEV_GOING_DOWN
, dev
);
901 clear_bit(__LINK_STATE_START
, &dev
->state
);
903 /* Synchronize to scheduled poll. We cannot touch poll list,
904 * it can be even on different cpu. So just clear netif_running(),
905 * and wait when poll really will happen. Actually, the best place
906 * for this is inside dev->stop() after device stopped its irq
907 * engine, but this requires more changes in devices. */
909 smp_mb__after_clear_bit(); /* Commit netif_running(). */
910 while (test_bit(__LINK_STATE_RX_SCHED
, &dev
->state
)) {
916 * Call the device specific close. This cannot fail.
917 * Only if device is UP
919 * We allow it to be called even after a DETACH hot-plug
926 * Device is now down.
929 dev
->flags
&= ~IFF_UP
;
932 * Tell people we are down
934 raw_notifier_call_chain(&netdev_chain
, NETDEV_DOWN
, dev
);
941 * Device change register/unregister. These are not inline or static
942 * as we export them to the world.
946 * register_netdevice_notifier - register a network notifier block
949 * Register a notifier to be called when network device events occur.
950 * The notifier passed is linked into the kernel structures and must
951 * not be reused until it has been unregistered. A negative errno code
952 * is returned on a failure.
954 * When registered all registration and up events are replayed
955 * to the new notifier to allow device to have a race free
956 * view of the network device list.
959 int register_netdevice_notifier(struct notifier_block
*nb
)
961 struct net_device
*dev
;
965 err
= raw_notifier_chain_register(&netdev_chain
, nb
);
967 for (dev
= dev_base
; dev
; dev
= dev
->next
) {
968 nb
->notifier_call(nb
, NETDEV_REGISTER
, dev
);
970 if (dev
->flags
& IFF_UP
)
971 nb
->notifier_call(nb
, NETDEV_UP
, dev
);
979 * unregister_netdevice_notifier - unregister a network notifier block
982 * Unregister a notifier previously registered by
983 * register_netdevice_notifier(). The notifier is unlinked into the
984 * kernel structures and may then be reused. A negative errno code
985 * is returned on a failure.
988 int unregister_netdevice_notifier(struct notifier_block
*nb
)
993 err
= raw_notifier_chain_unregister(&netdev_chain
, nb
);
999 * call_netdevice_notifiers - call all network notifier blocks
1000 * @val: value passed unmodified to notifier function
1001 * @v: pointer passed unmodified to notifier function
1003 * Call all network notifier blocks. Parameters and return value
1004 * are as for raw_notifier_call_chain().
1007 int call_netdevice_notifiers(unsigned long val
, void *v
)
1009 return raw_notifier_call_chain(&netdev_chain
, val
, v
);
1012 /* When > 0 there are consumers of rx skb time stamps */
1013 static atomic_t netstamp_needed
= ATOMIC_INIT(0);
1015 void net_enable_timestamp(void)
1017 atomic_inc(&netstamp_needed
);
1020 void net_disable_timestamp(void)
1022 atomic_dec(&netstamp_needed
);
1025 static inline void net_timestamp(struct sk_buff
*skb
)
1027 if (atomic_read(&netstamp_needed
))
1028 __net_timestamp(skb
);
1030 skb
->tstamp
.tv64
= 0;
1034 * Support routine. Sends outgoing frames to any network
1035 * taps currently in use.
1038 static void dev_queue_xmit_nit(struct sk_buff
*skb
, struct net_device
*dev
)
1040 struct packet_type
*ptype
;
1045 list_for_each_entry_rcu(ptype
, &ptype_all
, list
) {
1046 /* Never send packets back to the socket
1047 * they originated from - MvS (miquels@drinkel.ow.org)
1049 if ((ptype
->dev
== dev
|| !ptype
->dev
) &&
1050 (ptype
->af_packet_priv
== NULL
||
1051 (struct sock
*)ptype
->af_packet_priv
!= skb
->sk
)) {
1052 struct sk_buff
*skb2
= skb_clone(skb
, GFP_ATOMIC
);
1056 /* skb->nh should be correctly
1057 set by sender, so that the second statement is
1058 just protection against buggy protocols.
1060 skb_reset_mac_header(skb2
);
1062 if (skb_network_header(skb2
) < skb2
->data
||
1063 skb2
->network_header
> skb2
->tail
) {
1064 if (net_ratelimit())
1065 printk(KERN_CRIT
"protocol %04x is "
1067 skb2
->protocol
, dev
->name
);
1068 skb_reset_network_header(skb2
);
1071 skb2
->transport_header
= skb2
->network_header
;
1072 skb2
->pkt_type
= PACKET_OUTGOING
;
1073 ptype
->func(skb2
, skb
->dev
, ptype
, skb
->dev
);
1080 void __netif_schedule(struct net_device
*dev
)
1082 if (!test_and_set_bit(__LINK_STATE_SCHED
, &dev
->state
)) {
1083 unsigned long flags
;
1084 struct softnet_data
*sd
;
1086 local_irq_save(flags
);
1087 sd
= &__get_cpu_var(softnet_data
);
1088 dev
->next_sched
= sd
->output_queue
;
1089 sd
->output_queue
= dev
;
1090 raise_softirq_irqoff(NET_TX_SOFTIRQ
);
1091 local_irq_restore(flags
);
1094 EXPORT_SYMBOL(__netif_schedule
);
1096 void __netif_rx_schedule(struct net_device
*dev
)
1098 unsigned long flags
;
1100 local_irq_save(flags
);
1102 list_add_tail(&dev
->poll_list
, &__get_cpu_var(softnet_data
).poll_list
);
1104 dev
->quota
+= dev
->weight
;
1106 dev
->quota
= dev
->weight
;
1107 __raise_softirq_irqoff(NET_RX_SOFTIRQ
);
1108 local_irq_restore(flags
);
1110 EXPORT_SYMBOL(__netif_rx_schedule
);
1112 void dev_kfree_skb_any(struct sk_buff
*skb
)
1114 if (in_irq() || irqs_disabled())
1115 dev_kfree_skb_irq(skb
);
1119 EXPORT_SYMBOL(dev_kfree_skb_any
);
1123 void netif_device_detach(struct net_device
*dev
)
1125 if (test_and_clear_bit(__LINK_STATE_PRESENT
, &dev
->state
) &&
1126 netif_running(dev
)) {
1127 netif_stop_queue(dev
);
1130 EXPORT_SYMBOL(netif_device_detach
);
1132 void netif_device_attach(struct net_device
*dev
)
1134 if (!test_and_set_bit(__LINK_STATE_PRESENT
, &dev
->state
) &&
1135 netif_running(dev
)) {
1136 netif_wake_queue(dev
);
1137 __netdev_watchdog_up(dev
);
1140 EXPORT_SYMBOL(netif_device_attach
);
1144 * Invalidate hardware checksum when packet is to be mangled, and
1145 * complete checksum manually on outgoing path.
1147 int skb_checksum_help(struct sk_buff
*skb
)
1150 int ret
= 0, offset
;
1152 if (skb
->ip_summed
== CHECKSUM_COMPLETE
)
1153 goto out_set_summed
;
1155 if (unlikely(skb_shinfo(skb
)->gso_size
)) {
1156 /* Let GSO fix up the checksum. */
1157 goto out_set_summed
;
1160 if (skb_cloned(skb
)) {
1161 ret
= pskb_expand_head(skb
, 0, 0, GFP_ATOMIC
);
1166 offset
= skb
->csum_start
- skb_headroom(skb
);
1167 BUG_ON(offset
> (int)skb
->len
);
1168 csum
= skb_checksum(skb
, offset
, skb
->len
-offset
, 0);
1170 offset
= skb_headlen(skb
) - offset
;
1171 BUG_ON(offset
<= 0);
1172 BUG_ON(skb
->csum_offset
+ 2 > offset
);
1174 *(__sum16
*)(skb
->head
+ skb
->csum_start
+ skb
->csum_offset
) =
1177 skb
->ip_summed
= CHECKSUM_NONE
;
1183 * skb_gso_segment - Perform segmentation on skb.
1184 * @skb: buffer to segment
1185 * @features: features for the output path (see dev->features)
1187 * This function segments the given skb and returns a list of segments.
1189 * It may return NULL if the skb requires no segmentation. This is
1190 * only possible when GSO is used for verifying header integrity.
1192 struct sk_buff
*skb_gso_segment(struct sk_buff
*skb
, int features
)
1194 struct sk_buff
*segs
= ERR_PTR(-EPROTONOSUPPORT
);
1195 struct packet_type
*ptype
;
1196 __be16 type
= skb
->protocol
;
1199 BUG_ON(skb_shinfo(skb
)->frag_list
);
1201 skb_reset_mac_header(skb
);
1202 skb
->mac_len
= skb
->network_header
- skb
->mac_header
;
1203 __skb_pull(skb
, skb
->mac_len
);
1205 if (WARN_ON(skb
->ip_summed
!= CHECKSUM_PARTIAL
)) {
1206 if (skb_header_cloned(skb
) &&
1207 (err
= pskb_expand_head(skb
, 0, 0, GFP_ATOMIC
)))
1208 return ERR_PTR(err
);
1212 list_for_each_entry_rcu(ptype
, &ptype_base
[ntohs(type
) & 15], list
) {
1213 if (ptype
->type
== type
&& !ptype
->dev
&& ptype
->gso_segment
) {
1214 if (unlikely(skb
->ip_summed
!= CHECKSUM_PARTIAL
)) {
1215 err
= ptype
->gso_send_check(skb
);
1216 segs
= ERR_PTR(err
);
1217 if (err
|| skb_gso_ok(skb
, features
))
1219 __skb_push(skb
, (skb
->data
-
1220 skb_network_header(skb
)));
1222 segs
= ptype
->gso_segment(skb
, features
);
1228 __skb_push(skb
, skb
->data
- skb_mac_header(skb
));
1233 EXPORT_SYMBOL(skb_gso_segment
);
1235 /* Take action when hardware reception checksum errors are detected. */
1237 void netdev_rx_csum_fault(struct net_device
*dev
)
1239 if (net_ratelimit()) {
1240 printk(KERN_ERR
"%s: hw csum failure.\n",
1241 dev
? dev
->name
: "<unknown>");
1245 EXPORT_SYMBOL(netdev_rx_csum_fault
);
1248 /* Actually, we should eliminate this check as soon as we know, that:
1249 * 1. IOMMU is present and allows to map all the memory.
1250 * 2. No high memory really exists on this machine.
1253 static inline int illegal_highdma(struct net_device
*dev
, struct sk_buff
*skb
)
1255 #ifdef CONFIG_HIGHMEM
1258 if (dev
->features
& NETIF_F_HIGHDMA
)
1261 for (i
= 0; i
< skb_shinfo(skb
)->nr_frags
; i
++)
1262 if (PageHighMem(skb_shinfo(skb
)->frags
[i
].page
))
1270 void (*destructor
)(struct sk_buff
*skb
);
1273 #define DEV_GSO_CB(skb) ((struct dev_gso_cb *)(skb)->cb)
1275 static void dev_gso_skb_destructor(struct sk_buff
*skb
)
1277 struct dev_gso_cb
*cb
;
1280 struct sk_buff
*nskb
= skb
->next
;
1282 skb
->next
= nskb
->next
;
1285 } while (skb
->next
);
1287 cb
= DEV_GSO_CB(skb
);
1289 cb
->destructor(skb
);
1293 * dev_gso_segment - Perform emulated hardware segmentation on skb.
1294 * @skb: buffer to segment
1296 * This function segments the given skb and stores the list of segments
1299 static int dev_gso_segment(struct sk_buff
*skb
)
1301 struct net_device
*dev
= skb
->dev
;
1302 struct sk_buff
*segs
;
1303 int features
= dev
->features
& ~(illegal_highdma(dev
, skb
) ?
1306 segs
= skb_gso_segment(skb
, features
);
1308 /* Verifying header integrity only. */
1312 if (unlikely(IS_ERR(segs
)))
1313 return PTR_ERR(segs
);
1316 DEV_GSO_CB(skb
)->destructor
= skb
->destructor
;
1317 skb
->destructor
= dev_gso_skb_destructor
;
1322 int dev_hard_start_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
1324 if (likely(!skb
->next
)) {
1325 if (!list_empty(&ptype_all
))
1326 dev_queue_xmit_nit(skb
, dev
);
1328 if (netif_needs_gso(dev
, skb
)) {
1329 if (unlikely(dev_gso_segment(skb
)))
1335 return dev
->hard_start_xmit(skb
, dev
);
1340 struct sk_buff
*nskb
= skb
->next
;
1343 skb
->next
= nskb
->next
;
1345 rc
= dev
->hard_start_xmit(nskb
, dev
);
1347 nskb
->next
= skb
->next
;
1351 if (unlikely(netif_queue_stopped(dev
) && skb
->next
))
1352 return NETDEV_TX_BUSY
;
1353 } while (skb
->next
);
1355 skb
->destructor
= DEV_GSO_CB(skb
)->destructor
;
1362 #define HARD_TX_LOCK(dev, cpu) { \
1363 if ((dev->features & NETIF_F_LLTX) == 0) { \
1364 netif_tx_lock(dev); \
1368 #define HARD_TX_UNLOCK(dev) { \
1369 if ((dev->features & NETIF_F_LLTX) == 0) { \
1370 netif_tx_unlock(dev); \
1375 * dev_queue_xmit - transmit a buffer
1376 * @skb: buffer to transmit
1378 * Queue a buffer for transmission to a network device. The caller must
1379 * have set the device and priority and built the buffer before calling
1380 * this function. The function can be called from an interrupt.
1382 * A negative errno code is returned on a failure. A success does not
1383 * guarantee the frame will be transmitted as it may be dropped due
1384 * to congestion or traffic shaping.
1386 * -----------------------------------------------------------------------------------
1387 * I notice this method can also return errors from the queue disciplines,
1388 * including NET_XMIT_DROP, which is a positive value. So, errors can also
1391 * Regardless of the return value, the skb is consumed, so it is currently
1392 * difficult to retry a send to this method. (You can bump the ref count
1393 * before sending to hold a reference for retry if you are careful.)
1395 * When calling this method, interrupts MUST be enabled. This is because
1396 * the BH enable code must have IRQs enabled so that it will not deadlock.
1400 int dev_queue_xmit(struct sk_buff
*skb
)
1402 struct net_device
*dev
= skb
->dev
;
1406 /* GSO will handle the following emulations directly. */
1407 if (netif_needs_gso(dev
, skb
))
1410 if (skb_shinfo(skb
)->frag_list
&&
1411 !(dev
->features
& NETIF_F_FRAGLIST
) &&
1412 __skb_linearize(skb
))
1415 /* Fragmented skb is linearized if device does not support SG,
1416 * or if at least one of fragments is in highmem and device
1417 * does not support DMA from it.
1419 if (skb_shinfo(skb
)->nr_frags
&&
1420 (!(dev
->features
& NETIF_F_SG
) || illegal_highdma(dev
, skb
)) &&
1421 __skb_linearize(skb
))
1424 /* If packet is not checksummed and device does not support
1425 * checksumming for this protocol, complete checksumming here.
1427 if (skb
->ip_summed
== CHECKSUM_PARTIAL
) {
1428 skb_set_transport_header(skb
, skb
->csum_start
-
1431 if (!(dev
->features
& NETIF_F_GEN_CSUM
) &&
1432 (!(dev
->features
& NETIF_F_IP_CSUM
) ||
1433 skb
->protocol
!= htons(ETH_P_IP
)))
1434 if (skb_checksum_help(skb
))
1439 spin_lock_prefetch(&dev
->queue_lock
);
1441 /* Disable soft irqs for various locks below. Also
1442 * stops preemption for RCU.
1446 /* Updates of qdisc are serialized by queue_lock.
1447 * The struct Qdisc which is pointed to by qdisc is now a
1448 * rcu structure - it may be accessed without acquiring
1449 * a lock (but the structure may be stale.) The freeing of the
1450 * qdisc will be deferred until it's known that there are no
1451 * more references to it.
1453 * If the qdisc has an enqueue function, we still need to
1454 * hold the queue_lock before calling it, since queue_lock
1455 * also serializes access to the device queue.
1458 q
= rcu_dereference(dev
->qdisc
);
1459 #ifdef CONFIG_NET_CLS_ACT
1460 skb
->tc_verd
= SET_TC_AT(skb
->tc_verd
,AT_EGRESS
);
1463 /* Grab device queue */
1464 spin_lock(&dev
->queue_lock
);
1467 rc
= q
->enqueue(skb
, q
);
1469 spin_unlock(&dev
->queue_lock
);
1471 rc
= rc
== NET_XMIT_BYPASS
? NET_XMIT_SUCCESS
: rc
;
1474 spin_unlock(&dev
->queue_lock
);
1477 /* The device has no queue. Common case for software devices:
1478 loopback, all the sorts of tunnels...
1480 Really, it is unlikely that netif_tx_lock protection is necessary
1481 here. (f.e. loopback and IP tunnels are clean ignoring statistics
1483 However, it is possible, that they rely on protection
1486 Check this and shot the lock. It is not prone from deadlocks.
1487 Either shot noqueue qdisc, it is even simpler 8)
1489 if (dev
->flags
& IFF_UP
) {
1490 int cpu
= smp_processor_id(); /* ok because BHs are off */
1492 if (dev
->xmit_lock_owner
!= cpu
) {
1494 HARD_TX_LOCK(dev
, cpu
);
1496 if (!netif_queue_stopped(dev
)) {
1498 if (!dev_hard_start_xmit(skb
, dev
)) {
1499 HARD_TX_UNLOCK(dev
);
1503 HARD_TX_UNLOCK(dev
);
1504 if (net_ratelimit())
1505 printk(KERN_CRIT
"Virtual device %s asks to "
1506 "queue packet!\n", dev
->name
);
1508 /* Recursion is detected! It is possible,
1510 if (net_ratelimit())
1511 printk(KERN_CRIT
"Dead loop on virtual device "
1512 "%s, fix it urgently!\n", dev
->name
);
1517 rcu_read_unlock_bh();
1523 rcu_read_unlock_bh();
1528 /*=======================================================================
1530 =======================================================================*/
1532 int netdev_max_backlog __read_mostly
= 1000;
1533 int netdev_budget __read_mostly
= 300;
1534 int weight_p __read_mostly
= 64; /* old backlog weight */
1536 DEFINE_PER_CPU(struct netif_rx_stats
, netdev_rx_stat
) = { 0, };
1540 * netif_rx - post buffer to the network code
1541 * @skb: buffer to post
1543 * This function receives a packet from a device driver and queues it for
1544 * the upper (protocol) levels to process. It always succeeds. The buffer
1545 * may be dropped during processing for congestion control or by the
1549 * NET_RX_SUCCESS (no congestion)
1550 * NET_RX_CN_LOW (low congestion)
1551 * NET_RX_CN_MOD (moderate congestion)
1552 * NET_RX_CN_HIGH (high congestion)
1553 * NET_RX_DROP (packet was dropped)
1557 int netif_rx(struct sk_buff
*skb
)
1559 struct softnet_data
*queue
;
1560 unsigned long flags
;
1562 /* if netpoll wants it, pretend we never saw it */
1563 if (netpoll_rx(skb
))
1566 if (!skb
->tstamp
.tv64
)
1570 * The code is rearranged so that the path is the most
1571 * short when CPU is congested, but is still operating.
1573 local_irq_save(flags
);
1574 queue
= &__get_cpu_var(softnet_data
);
1576 __get_cpu_var(netdev_rx_stat
).total
++;
1577 if (queue
->input_pkt_queue
.qlen
<= netdev_max_backlog
) {
1578 if (queue
->input_pkt_queue
.qlen
) {
1581 __skb_queue_tail(&queue
->input_pkt_queue
, skb
);
1582 local_irq_restore(flags
);
1583 return NET_RX_SUCCESS
;
1586 netif_rx_schedule(&queue
->backlog_dev
);
1590 __get_cpu_var(netdev_rx_stat
).dropped
++;
1591 local_irq_restore(flags
);
1597 int netif_rx_ni(struct sk_buff
*skb
)
1602 err
= netif_rx(skb
);
1603 if (local_softirq_pending())
1610 EXPORT_SYMBOL(netif_rx_ni
);
1612 static inline struct net_device
*skb_bond(struct sk_buff
*skb
)
1614 struct net_device
*dev
= skb
->dev
;
1617 if (skb_bond_should_drop(skb
)) {
1621 skb
->dev
= dev
->master
;
1627 static void net_tx_action(struct softirq_action
*h
)
1629 struct softnet_data
*sd
= &__get_cpu_var(softnet_data
);
1631 if (sd
->completion_queue
) {
1632 struct sk_buff
*clist
;
1634 local_irq_disable();
1635 clist
= sd
->completion_queue
;
1636 sd
->completion_queue
= NULL
;
1640 struct sk_buff
*skb
= clist
;
1641 clist
= clist
->next
;
1643 BUG_TRAP(!atomic_read(&skb
->users
));
1648 if (sd
->output_queue
) {
1649 struct net_device
*head
;
1651 local_irq_disable();
1652 head
= sd
->output_queue
;
1653 sd
->output_queue
= NULL
;
1657 struct net_device
*dev
= head
;
1658 head
= head
->next_sched
;
1660 smp_mb__before_clear_bit();
1661 clear_bit(__LINK_STATE_SCHED
, &dev
->state
);
1663 if (spin_trylock(&dev
->queue_lock
)) {
1665 spin_unlock(&dev
->queue_lock
);
1667 netif_schedule(dev
);
1673 static inline int deliver_skb(struct sk_buff
*skb
,
1674 struct packet_type
*pt_prev
,
1675 struct net_device
*orig_dev
)
1677 atomic_inc(&skb
->users
);
1678 return pt_prev
->func(skb
, skb
->dev
, pt_prev
, orig_dev
);
1681 #if defined(CONFIG_BRIDGE) || defined (CONFIG_BRIDGE_MODULE)
1682 /* These hooks defined here for ATM */
1684 struct net_bridge_fdb_entry
*(*br_fdb_get_hook
)(struct net_bridge
*br
,
1685 unsigned char *addr
);
1686 void (*br_fdb_put_hook
)(struct net_bridge_fdb_entry
*ent
) __read_mostly
;
1689 * If bridge module is loaded call bridging hook.
1690 * returns NULL if packet was consumed.
1692 struct sk_buff
*(*br_handle_frame_hook
)(struct net_bridge_port
*p
,
1693 struct sk_buff
*skb
) __read_mostly
;
1694 static inline struct sk_buff
*handle_bridge(struct sk_buff
*skb
,
1695 struct packet_type
**pt_prev
, int *ret
,
1696 struct net_device
*orig_dev
)
1698 struct net_bridge_port
*port
;
1700 if (skb
->pkt_type
== PACKET_LOOPBACK
||
1701 (port
= rcu_dereference(skb
->dev
->br_port
)) == NULL
)
1705 *ret
= deliver_skb(skb
, *pt_prev
, orig_dev
);
1709 return br_handle_frame_hook(port
, skb
);
1712 #define handle_bridge(skb, pt_prev, ret, orig_dev) (skb)
1715 #ifdef CONFIG_NET_CLS_ACT
1716 /* TODO: Maybe we should just force sch_ingress to be compiled in
1717 * when CONFIG_NET_CLS_ACT is? otherwise some useless instructions
1718 * a compare and 2 stores extra right now if we dont have it on
1719 * but have CONFIG_NET_CLS_ACT
1720 * NOTE: This doesnt stop any functionality; if you dont have
1721 * the ingress scheduler, you just cant add policies on ingress.
1724 static int ing_filter(struct sk_buff
*skb
)
1727 struct net_device
*dev
= skb
->dev
;
1728 int result
= TC_ACT_OK
;
1730 if (dev
->qdisc_ingress
) {
1731 __u32 ttl
= (__u32
) G_TC_RTTL(skb
->tc_verd
);
1732 if (MAX_RED_LOOP
< ttl
++) {
1733 printk(KERN_WARNING
"Redir loop detected Dropping packet (%d->%d)\n",
1734 skb
->iif
, skb
->dev
->ifindex
);
1738 skb
->tc_verd
= SET_TC_RTTL(skb
->tc_verd
,ttl
);
1740 skb
->tc_verd
= SET_TC_AT(skb
->tc_verd
,AT_INGRESS
);
1742 spin_lock(&dev
->ingress_lock
);
1743 if ((q
= dev
->qdisc_ingress
) != NULL
)
1744 result
= q
->enqueue(skb
, q
);
1745 spin_unlock(&dev
->ingress_lock
);
1753 int netif_receive_skb(struct sk_buff
*skb
)
1755 struct packet_type
*ptype
, *pt_prev
;
1756 struct net_device
*orig_dev
;
1757 int ret
= NET_RX_DROP
;
1760 /* if we've gotten here through NAPI, check netpoll */
1761 if (skb
->dev
->poll
&& netpoll_rx(skb
))
1764 if (!skb
->tstamp
.tv64
)
1768 skb
->iif
= skb
->dev
->ifindex
;
1770 orig_dev
= skb_bond(skb
);
1775 __get_cpu_var(netdev_rx_stat
).total
++;
1777 skb_reset_network_header(skb
);
1778 skb_reset_transport_header(skb
);
1779 skb
->mac_len
= skb
->network_header
- skb
->mac_header
;
1785 #ifdef CONFIG_NET_CLS_ACT
1786 if (skb
->tc_verd
& TC_NCLS
) {
1787 skb
->tc_verd
= CLR_TC_NCLS(skb
->tc_verd
);
1792 list_for_each_entry_rcu(ptype
, &ptype_all
, list
) {
1793 if (!ptype
->dev
|| ptype
->dev
== skb
->dev
) {
1795 ret
= deliver_skb(skb
, pt_prev
, orig_dev
);
1800 #ifdef CONFIG_NET_CLS_ACT
1802 ret
= deliver_skb(skb
, pt_prev
, orig_dev
);
1803 pt_prev
= NULL
; /* noone else should process this after*/
1805 skb
->tc_verd
= SET_TC_OK2MUNGE(skb
->tc_verd
);
1808 ret
= ing_filter(skb
);
1810 if (ret
== TC_ACT_SHOT
|| (ret
== TC_ACT_STOLEN
)) {
1819 skb
= handle_bridge(skb
, &pt_prev
, &ret
, orig_dev
);
1823 type
= skb
->protocol
;
1824 list_for_each_entry_rcu(ptype
, &ptype_base
[ntohs(type
)&15], list
) {
1825 if (ptype
->type
== type
&&
1826 (!ptype
->dev
|| ptype
->dev
== skb
->dev
)) {
1828 ret
= deliver_skb(skb
, pt_prev
, orig_dev
);
1834 ret
= pt_prev
->func(skb
, skb
->dev
, pt_prev
, orig_dev
);
1837 /* Jamal, now you will not able to escape explaining
1838 * me how you were going to use this. :-)
1848 static int process_backlog(struct net_device
*backlog_dev
, int *budget
)
1851 int quota
= min(backlog_dev
->quota
, *budget
);
1852 struct softnet_data
*queue
= &__get_cpu_var(softnet_data
);
1853 unsigned long start_time
= jiffies
;
1855 backlog_dev
->weight
= weight_p
;
1857 struct sk_buff
*skb
;
1858 struct net_device
*dev
;
1860 local_irq_disable();
1861 skb
= __skb_dequeue(&queue
->input_pkt_queue
);
1868 netif_receive_skb(skb
);
1874 if (work
>= quota
|| jiffies
- start_time
> 1)
1879 backlog_dev
->quota
-= work
;
1884 backlog_dev
->quota
-= work
;
1887 list_del(&backlog_dev
->poll_list
);
1888 smp_mb__before_clear_bit();
1889 netif_poll_enable(backlog_dev
);
1895 static void net_rx_action(struct softirq_action
*h
)
1897 struct softnet_data
*queue
= &__get_cpu_var(softnet_data
);
1898 unsigned long start_time
= jiffies
;
1899 int budget
= netdev_budget
;
1902 local_irq_disable();
1904 while (!list_empty(&queue
->poll_list
)) {
1905 struct net_device
*dev
;
1907 if (budget
<= 0 || jiffies
- start_time
> 1)
1912 dev
= list_entry(queue
->poll_list
.next
,
1913 struct net_device
, poll_list
);
1914 have
= netpoll_poll_lock(dev
);
1916 if (dev
->quota
<= 0 || dev
->poll(dev
, &budget
)) {
1917 netpoll_poll_unlock(have
);
1918 local_irq_disable();
1919 list_move_tail(&dev
->poll_list
, &queue
->poll_list
);
1921 dev
->quota
+= dev
->weight
;
1923 dev
->quota
= dev
->weight
;
1925 netpoll_poll_unlock(have
);
1927 local_irq_disable();
1931 #ifdef CONFIG_NET_DMA
1933 * There may not be any more sk_buffs coming right now, so push
1934 * any pending DMA copies to hardware
1936 if (net_dma_client
) {
1937 struct dma_chan
*chan
;
1939 list_for_each_entry_rcu(chan
, &net_dma_client
->channels
, client_node
)
1940 dma_async_memcpy_issue_pending(chan
);
1948 __get_cpu_var(netdev_rx_stat
).time_squeeze
++;
1949 __raise_softirq_irqoff(NET_RX_SOFTIRQ
);
1953 static gifconf_func_t
* gifconf_list
[NPROTO
];
1956 * register_gifconf - register a SIOCGIF handler
1957 * @family: Address family
1958 * @gifconf: Function handler
1960 * Register protocol dependent address dumping routines. The handler
1961 * that is passed must not be freed or reused until it has been replaced
1962 * by another handler.
1964 int register_gifconf(unsigned int family
, gifconf_func_t
* gifconf
)
1966 if (family
>= NPROTO
)
1968 gifconf_list
[family
] = gifconf
;
1974 * Map an interface index to its name (SIOCGIFNAME)
1978 * We need this ioctl for efficient implementation of the
1979 * if_indextoname() function required by the IPv6 API. Without
1980 * it, we would have to search all the interfaces to find a
1984 static int dev_ifname(struct ifreq __user
*arg
)
1986 struct net_device
*dev
;
1990 * Fetch the caller's info block.
1993 if (copy_from_user(&ifr
, arg
, sizeof(struct ifreq
)))
1996 read_lock(&dev_base_lock
);
1997 dev
= __dev_get_by_index(ifr
.ifr_ifindex
);
1999 read_unlock(&dev_base_lock
);
2003 strcpy(ifr
.ifr_name
, dev
->name
);
2004 read_unlock(&dev_base_lock
);
2006 if (copy_to_user(arg
, &ifr
, sizeof(struct ifreq
)))
2012 * Perform a SIOCGIFCONF call. This structure will change
2013 * size eventually, and there is nothing I can do about it.
2014 * Thus we will need a 'compatibility mode'.
2017 static int dev_ifconf(char __user
*arg
)
2020 struct net_device
*dev
;
2027 * Fetch the caller's info block.
2030 if (copy_from_user(&ifc
, arg
, sizeof(struct ifconf
)))
2037 * Loop over the interfaces, and write an info block for each.
2041 for (dev
= dev_base
; dev
; dev
= dev
->next
) {
2042 for (i
= 0; i
< NPROTO
; i
++) {
2043 if (gifconf_list
[i
]) {
2046 done
= gifconf_list
[i
](dev
, NULL
, 0);
2048 done
= gifconf_list
[i
](dev
, pos
+ total
,
2058 * All done. Write the updated control block back to the caller.
2060 ifc
.ifc_len
= total
;
2063 * Both BSD and Solaris return 0 here, so we do too.
2065 return copy_to_user(arg
, &ifc
, sizeof(struct ifconf
)) ? -EFAULT
: 0;
2068 #ifdef CONFIG_PROC_FS
2070 * This is invoked by the /proc filesystem handler to display a device
2073 static struct net_device
*dev_get_idx(loff_t pos
)
2075 struct net_device
*dev
;
2078 for (i
= 0, dev
= dev_base
; dev
&& i
< pos
; ++i
, dev
= dev
->next
);
2080 return i
== pos
? dev
: NULL
;
2083 void *dev_seq_start(struct seq_file
*seq
, loff_t
*pos
)
2085 read_lock(&dev_base_lock
);
2086 return *pos
? dev_get_idx(*pos
- 1) : SEQ_START_TOKEN
;
2089 void *dev_seq_next(struct seq_file
*seq
, void *v
, loff_t
*pos
)
2092 return v
== SEQ_START_TOKEN
? dev_base
: ((struct net_device
*)v
)->next
;
2095 void dev_seq_stop(struct seq_file
*seq
, void *v
)
2097 read_unlock(&dev_base_lock
);
2100 static void dev_seq_printf_stats(struct seq_file
*seq
, struct net_device
*dev
)
2102 struct net_device_stats
*stats
= dev
->get_stats(dev
);
2105 seq_printf(seq
, "%6s:%8lu %7lu %4lu %4lu %4lu %5lu %10lu %9lu "
2106 "%8lu %7lu %4lu %4lu %4lu %5lu %7lu %10lu\n",
2107 dev
->name
, stats
->rx_bytes
, stats
->rx_packets
,
2109 stats
->rx_dropped
+ stats
->rx_missed_errors
,
2110 stats
->rx_fifo_errors
,
2111 stats
->rx_length_errors
+ stats
->rx_over_errors
+
2112 stats
->rx_crc_errors
+ stats
->rx_frame_errors
,
2113 stats
->rx_compressed
, stats
->multicast
,
2114 stats
->tx_bytes
, stats
->tx_packets
,
2115 stats
->tx_errors
, stats
->tx_dropped
,
2116 stats
->tx_fifo_errors
, stats
->collisions
,
2117 stats
->tx_carrier_errors
+
2118 stats
->tx_aborted_errors
+
2119 stats
->tx_window_errors
+
2120 stats
->tx_heartbeat_errors
,
2121 stats
->tx_compressed
);
2123 seq_printf(seq
, "%6s: No statistics available.\n", dev
->name
);
2127 * Called from the PROCfs module. This now uses the new arbitrary sized
2128 * /proc/net interface to create /proc/net/dev
2130 static int dev_seq_show(struct seq_file
*seq
, void *v
)
2132 if (v
== SEQ_START_TOKEN
)
2133 seq_puts(seq
, "Inter-| Receive "
2135 " face |bytes packets errs drop fifo frame "
2136 "compressed multicast|bytes packets errs "
2137 "drop fifo colls carrier compressed\n");
2139 dev_seq_printf_stats(seq
, v
);
2143 static struct netif_rx_stats
*softnet_get_online(loff_t
*pos
)
2145 struct netif_rx_stats
*rc
= NULL
;
2147 while (*pos
< NR_CPUS
)
2148 if (cpu_online(*pos
)) {
2149 rc
= &per_cpu(netdev_rx_stat
, *pos
);
2156 static void *softnet_seq_start(struct seq_file
*seq
, loff_t
*pos
)
2158 return softnet_get_online(pos
);
2161 static void *softnet_seq_next(struct seq_file
*seq
, void *v
, loff_t
*pos
)
2164 return softnet_get_online(pos
);
2167 static void softnet_seq_stop(struct seq_file
*seq
, void *v
)
2171 static int softnet_seq_show(struct seq_file
*seq
, void *v
)
2173 struct netif_rx_stats
*s
= v
;
2175 seq_printf(seq
, "%08x %08x %08x %08x %08x %08x %08x %08x %08x\n",
2176 s
->total
, s
->dropped
, s
->time_squeeze
, 0,
2177 0, 0, 0, 0, /* was fastroute */
2182 static const struct seq_operations dev_seq_ops
= {
2183 .start
= dev_seq_start
,
2184 .next
= dev_seq_next
,
2185 .stop
= dev_seq_stop
,
2186 .show
= dev_seq_show
,
2189 static int dev_seq_open(struct inode
*inode
, struct file
*file
)
2191 return seq_open(file
, &dev_seq_ops
);
2194 static const struct file_operations dev_seq_fops
= {
2195 .owner
= THIS_MODULE
,
2196 .open
= dev_seq_open
,
2198 .llseek
= seq_lseek
,
2199 .release
= seq_release
,
2202 static const struct seq_operations softnet_seq_ops
= {
2203 .start
= softnet_seq_start
,
2204 .next
= softnet_seq_next
,
2205 .stop
= softnet_seq_stop
,
2206 .show
= softnet_seq_show
,
2209 static int softnet_seq_open(struct inode
*inode
, struct file
*file
)
2211 return seq_open(file
, &softnet_seq_ops
);
2214 static const struct file_operations softnet_seq_fops
= {
2215 .owner
= THIS_MODULE
,
2216 .open
= softnet_seq_open
,
2218 .llseek
= seq_lseek
,
2219 .release
= seq_release
,
2222 static void *ptype_get_idx(loff_t pos
)
2224 struct packet_type
*pt
= NULL
;
2228 list_for_each_entry_rcu(pt
, &ptype_all
, list
) {
2234 for (t
= 0; t
< 16; t
++) {
2235 list_for_each_entry_rcu(pt
, &ptype_base
[t
], list
) {
2244 static void *ptype_seq_start(struct seq_file
*seq
, loff_t
*pos
)
2247 return *pos
? ptype_get_idx(*pos
- 1) : SEQ_START_TOKEN
;
2250 static void *ptype_seq_next(struct seq_file
*seq
, void *v
, loff_t
*pos
)
2252 struct packet_type
*pt
;
2253 struct list_head
*nxt
;
2257 if (v
== SEQ_START_TOKEN
)
2258 return ptype_get_idx(0);
2261 nxt
= pt
->list
.next
;
2262 if (pt
->type
== htons(ETH_P_ALL
)) {
2263 if (nxt
!= &ptype_all
)
2266 nxt
= ptype_base
[0].next
;
2268 hash
= ntohs(pt
->type
) & 15;
2270 while (nxt
== &ptype_base
[hash
]) {
2273 nxt
= ptype_base
[hash
].next
;
2276 return list_entry(nxt
, struct packet_type
, list
);
2279 static void ptype_seq_stop(struct seq_file
*seq
, void *v
)
2284 static void ptype_seq_decode(struct seq_file
*seq
, void *sym
)
2286 #ifdef CONFIG_KALLSYMS
2287 unsigned long offset
= 0, symsize
;
2288 const char *symname
;
2292 symname
= kallsyms_lookup((unsigned long)sym
, &symsize
, &offset
,
2299 modname
= delim
= "";
2300 seq_printf(seq
, "%s%s%s%s+0x%lx", delim
, modname
, delim
,
2306 seq_printf(seq
, "[%p]", sym
);
2309 static int ptype_seq_show(struct seq_file
*seq
, void *v
)
2311 struct packet_type
*pt
= v
;
2313 if (v
== SEQ_START_TOKEN
)
2314 seq_puts(seq
, "Type Device Function\n");
2316 if (pt
->type
== htons(ETH_P_ALL
))
2317 seq_puts(seq
, "ALL ");
2319 seq_printf(seq
, "%04x", ntohs(pt
->type
));
2321 seq_printf(seq
, " %-8s ",
2322 pt
->dev
? pt
->dev
->name
: "");
2323 ptype_seq_decode(seq
, pt
->func
);
2324 seq_putc(seq
, '\n');
2330 static const struct seq_operations ptype_seq_ops
= {
2331 .start
= ptype_seq_start
,
2332 .next
= ptype_seq_next
,
2333 .stop
= ptype_seq_stop
,
2334 .show
= ptype_seq_show
,
2337 static int ptype_seq_open(struct inode
*inode
, struct file
*file
)
2339 return seq_open(file
, &ptype_seq_ops
);
2342 static const struct file_operations ptype_seq_fops
= {
2343 .owner
= THIS_MODULE
,
2344 .open
= ptype_seq_open
,
2346 .llseek
= seq_lseek
,
2347 .release
= seq_release
,
2351 #ifdef CONFIG_WIRELESS_EXT
2352 extern int wireless_proc_init(void);
2354 #define wireless_proc_init() 0
2357 static int __init
dev_proc_init(void)
2361 if (!proc_net_fops_create("dev", S_IRUGO
, &dev_seq_fops
))
2363 if (!proc_net_fops_create("softnet_stat", S_IRUGO
, &softnet_seq_fops
))
2365 if (!proc_net_fops_create("ptype", S_IRUGO
, &ptype_seq_fops
))
2368 if (wireless_proc_init())
2374 proc_net_remove("softnet_stat");
2376 proc_net_remove("ptype");
2378 proc_net_remove("dev");
2382 #define dev_proc_init() 0
2383 #endif /* CONFIG_PROC_FS */
2387 * netdev_set_master - set up master/slave pair
2388 * @slave: slave device
2389 * @master: new master device
2391 * Changes the master device of the slave. Pass %NULL to break the
2392 * bonding. The caller must hold the RTNL semaphore. On a failure
2393 * a negative errno code is returned. On success the reference counts
2394 * are adjusted, %RTM_NEWLINK is sent to the routing socket and the
2395 * function returns zero.
2397 int netdev_set_master(struct net_device
*slave
, struct net_device
*master
)
2399 struct net_device
*old
= slave
->master
;
2409 slave
->master
= master
;
2417 slave
->flags
|= IFF_SLAVE
;
2419 slave
->flags
&= ~IFF_SLAVE
;
2421 rtmsg_ifinfo(RTM_NEWLINK
, slave
, IFF_SLAVE
);
2426 * dev_set_promiscuity - update promiscuity count on a device
2430 * Add or remove promiscuity from a device. While the count in the device
2431 * remains above zero the interface remains promiscuous. Once it hits zero
2432 * the device reverts back to normal filtering operation. A negative inc
2433 * value is used to drop promiscuity on the device.
2435 void dev_set_promiscuity(struct net_device
*dev
, int inc
)
2437 unsigned short old_flags
= dev
->flags
;
2439 if ((dev
->promiscuity
+= inc
) == 0)
2440 dev
->flags
&= ~IFF_PROMISC
;
2442 dev
->flags
|= IFF_PROMISC
;
2443 if (dev
->flags
!= old_flags
) {
2445 printk(KERN_INFO
"device %s %s promiscuous mode\n",
2446 dev
->name
, (dev
->flags
& IFF_PROMISC
) ? "entered" :
2448 audit_log(current
->audit_context
, GFP_ATOMIC
,
2449 AUDIT_ANOM_PROMISCUOUS
,
2450 "dev=%s prom=%d old_prom=%d auid=%u",
2451 dev
->name
, (dev
->flags
& IFF_PROMISC
),
2452 (old_flags
& IFF_PROMISC
),
2453 audit_get_loginuid(current
->audit_context
));
2458 * dev_set_allmulti - update allmulti count on a device
2462 * Add or remove reception of all multicast frames to a device. While the
2463 * count in the device remains above zero the interface remains listening
2464 * to all interfaces. Once it hits zero the device reverts back to normal
2465 * filtering operation. A negative @inc value is used to drop the counter
2466 * when releasing a resource needing all multicasts.
2469 void dev_set_allmulti(struct net_device
*dev
, int inc
)
2471 unsigned short old_flags
= dev
->flags
;
2473 dev
->flags
|= IFF_ALLMULTI
;
2474 if ((dev
->allmulti
+= inc
) == 0)
2475 dev
->flags
&= ~IFF_ALLMULTI
;
2476 if (dev
->flags
^ old_flags
)
2480 unsigned dev_get_flags(const struct net_device
*dev
)
2484 flags
= (dev
->flags
& ~(IFF_PROMISC
|
2489 (dev
->gflags
& (IFF_PROMISC
|
2492 if (netif_running(dev
)) {
2493 if (netif_oper_up(dev
))
2494 flags
|= IFF_RUNNING
;
2495 if (netif_carrier_ok(dev
))
2496 flags
|= IFF_LOWER_UP
;
2497 if (netif_dormant(dev
))
2498 flags
|= IFF_DORMANT
;
2504 int dev_change_flags(struct net_device
*dev
, unsigned flags
)
2507 int old_flags
= dev
->flags
;
2510 * Set the flags on our device.
2513 dev
->flags
= (flags
& (IFF_DEBUG
| IFF_NOTRAILERS
| IFF_NOARP
|
2514 IFF_DYNAMIC
| IFF_MULTICAST
| IFF_PORTSEL
|
2516 (dev
->flags
& (IFF_UP
| IFF_VOLATILE
| IFF_PROMISC
|
2520 * Load in the correct multicast list now the flags have changed.
2526 * Have we downed the interface. We handle IFF_UP ourselves
2527 * according to user attempts to set it, rather than blindly
2532 if ((old_flags
^ flags
) & IFF_UP
) { /* Bit is different ? */
2533 ret
= ((old_flags
& IFF_UP
) ? dev_close
: dev_open
)(dev
);
2539 if (dev
->flags
& IFF_UP
&&
2540 ((old_flags
^ dev
->flags
) &~ (IFF_UP
| IFF_PROMISC
| IFF_ALLMULTI
|
2542 raw_notifier_call_chain(&netdev_chain
,
2543 NETDEV_CHANGE
, dev
);
2545 if ((flags
^ dev
->gflags
) & IFF_PROMISC
) {
2546 int inc
= (flags
& IFF_PROMISC
) ? +1 : -1;
2547 dev
->gflags
^= IFF_PROMISC
;
2548 dev_set_promiscuity(dev
, inc
);
2551 /* NOTE: order of synchronization of IFF_PROMISC and IFF_ALLMULTI
2552 is important. Some (broken) drivers set IFF_PROMISC, when
2553 IFF_ALLMULTI is requested not asking us and not reporting.
2555 if ((flags
^ dev
->gflags
) & IFF_ALLMULTI
) {
2556 int inc
= (flags
& IFF_ALLMULTI
) ? +1 : -1;
2557 dev
->gflags
^= IFF_ALLMULTI
;
2558 dev_set_allmulti(dev
, inc
);
2561 if (old_flags
^ dev
->flags
)
2562 rtmsg_ifinfo(RTM_NEWLINK
, dev
, old_flags
^ dev
->flags
);
2567 int dev_set_mtu(struct net_device
*dev
, int new_mtu
)
2571 if (new_mtu
== dev
->mtu
)
2574 /* MTU must be positive. */
2578 if (!netif_device_present(dev
))
2582 if (dev
->change_mtu
)
2583 err
= dev
->change_mtu(dev
, new_mtu
);
2586 if (!err
&& dev
->flags
& IFF_UP
)
2587 raw_notifier_call_chain(&netdev_chain
,
2588 NETDEV_CHANGEMTU
, dev
);
2592 int dev_set_mac_address(struct net_device
*dev
, struct sockaddr
*sa
)
2596 if (!dev
->set_mac_address
)
2598 if (sa
->sa_family
!= dev
->type
)
2600 if (!netif_device_present(dev
))
2602 err
= dev
->set_mac_address(dev
, sa
);
2604 raw_notifier_call_chain(&netdev_chain
,
2605 NETDEV_CHANGEADDR
, dev
);
2610 * Perform the SIOCxIFxxx calls.
2612 static int dev_ifsioc(struct ifreq
*ifr
, unsigned int cmd
)
2615 struct net_device
*dev
= __dev_get_by_name(ifr
->ifr_name
);
2621 case SIOCGIFFLAGS
: /* Get interface flags */
2622 ifr
->ifr_flags
= dev_get_flags(dev
);
2625 case SIOCSIFFLAGS
: /* Set interface flags */
2626 return dev_change_flags(dev
, ifr
->ifr_flags
);
2628 case SIOCGIFMETRIC
: /* Get the metric on the interface
2629 (currently unused) */
2630 ifr
->ifr_metric
= 0;
2633 case SIOCSIFMETRIC
: /* Set the metric on the interface
2634 (currently unused) */
2637 case SIOCGIFMTU
: /* Get the MTU of a device */
2638 ifr
->ifr_mtu
= dev
->mtu
;
2641 case SIOCSIFMTU
: /* Set the MTU of a device */
2642 return dev_set_mtu(dev
, ifr
->ifr_mtu
);
2646 memset(ifr
->ifr_hwaddr
.sa_data
, 0, sizeof ifr
->ifr_hwaddr
.sa_data
);
2648 memcpy(ifr
->ifr_hwaddr
.sa_data
, dev
->dev_addr
,
2649 min(sizeof ifr
->ifr_hwaddr
.sa_data
, (size_t) dev
->addr_len
));
2650 ifr
->ifr_hwaddr
.sa_family
= dev
->type
;
2654 return dev_set_mac_address(dev
, &ifr
->ifr_hwaddr
);
2656 case SIOCSIFHWBROADCAST
:
2657 if (ifr
->ifr_hwaddr
.sa_family
!= dev
->type
)
2659 memcpy(dev
->broadcast
, ifr
->ifr_hwaddr
.sa_data
,
2660 min(sizeof ifr
->ifr_hwaddr
.sa_data
, (size_t) dev
->addr_len
));
2661 raw_notifier_call_chain(&netdev_chain
,
2662 NETDEV_CHANGEADDR
, dev
);
2666 ifr
->ifr_map
.mem_start
= dev
->mem_start
;
2667 ifr
->ifr_map
.mem_end
= dev
->mem_end
;
2668 ifr
->ifr_map
.base_addr
= dev
->base_addr
;
2669 ifr
->ifr_map
.irq
= dev
->irq
;
2670 ifr
->ifr_map
.dma
= dev
->dma
;
2671 ifr
->ifr_map
.port
= dev
->if_port
;
2675 if (dev
->set_config
) {
2676 if (!netif_device_present(dev
))
2678 return dev
->set_config(dev
, &ifr
->ifr_map
);
2683 if (!dev
->set_multicast_list
||
2684 ifr
->ifr_hwaddr
.sa_family
!= AF_UNSPEC
)
2686 if (!netif_device_present(dev
))
2688 return dev_mc_add(dev
, ifr
->ifr_hwaddr
.sa_data
,
2692 if (!dev
->set_multicast_list
||
2693 ifr
->ifr_hwaddr
.sa_family
!= AF_UNSPEC
)
2695 if (!netif_device_present(dev
))
2697 return dev_mc_delete(dev
, ifr
->ifr_hwaddr
.sa_data
,
2701 ifr
->ifr_ifindex
= dev
->ifindex
;
2705 ifr
->ifr_qlen
= dev
->tx_queue_len
;
2709 if (ifr
->ifr_qlen
< 0)
2711 dev
->tx_queue_len
= ifr
->ifr_qlen
;
2715 ifr
->ifr_newname
[IFNAMSIZ
-1] = '\0';
2716 return dev_change_name(dev
, ifr
->ifr_newname
);
2719 * Unknown or private ioctl
2723 if ((cmd
>= SIOCDEVPRIVATE
&&
2724 cmd
<= SIOCDEVPRIVATE
+ 15) ||
2725 cmd
== SIOCBONDENSLAVE
||
2726 cmd
== SIOCBONDRELEASE
||
2727 cmd
== SIOCBONDSETHWADDR
||
2728 cmd
== SIOCBONDSLAVEINFOQUERY
||
2729 cmd
== SIOCBONDINFOQUERY
||
2730 cmd
== SIOCBONDCHANGEACTIVE
||
2731 cmd
== SIOCGMIIPHY
||
2732 cmd
== SIOCGMIIREG
||
2733 cmd
== SIOCSMIIREG
||
2734 cmd
== SIOCBRADDIF
||
2735 cmd
== SIOCBRDELIF
||
2736 cmd
== SIOCWANDEV
) {
2738 if (dev
->do_ioctl
) {
2739 if (netif_device_present(dev
))
2740 err
= dev
->do_ioctl(dev
, ifr
,
2753 * This function handles all "interface"-type I/O control requests. The actual
2754 * 'doing' part of this is dev_ifsioc above.
2758 * dev_ioctl - network device ioctl
2759 * @cmd: command to issue
2760 * @arg: pointer to a struct ifreq in user space
2762 * Issue ioctl functions to devices. This is normally called by the
2763 * user space syscall interfaces but can sometimes be useful for
2764 * other purposes. The return value is the return from the syscall if
2765 * positive or a negative errno code on error.
2768 int dev_ioctl(unsigned int cmd
, void __user
*arg
)
2774 /* One special case: SIOCGIFCONF takes ifconf argument
2775 and requires shared lock, because it sleeps writing
2779 if (cmd
== SIOCGIFCONF
) {
2781 ret
= dev_ifconf((char __user
*) arg
);
2785 if (cmd
== SIOCGIFNAME
)
2786 return dev_ifname((struct ifreq __user
*)arg
);
2788 if (copy_from_user(&ifr
, arg
, sizeof(struct ifreq
)))
2791 ifr
.ifr_name
[IFNAMSIZ
-1] = 0;
2793 colon
= strchr(ifr
.ifr_name
, ':');
2798 * See which interface the caller is talking about.
2803 * These ioctl calls:
2804 * - can be done by all.
2805 * - atomic and do not require locking.
2816 dev_load(ifr
.ifr_name
);
2817 read_lock(&dev_base_lock
);
2818 ret
= dev_ifsioc(&ifr
, cmd
);
2819 read_unlock(&dev_base_lock
);
2823 if (copy_to_user(arg
, &ifr
,
2824 sizeof(struct ifreq
)))
2830 dev_load(ifr
.ifr_name
);
2832 ret
= dev_ethtool(&ifr
);
2837 if (copy_to_user(arg
, &ifr
,
2838 sizeof(struct ifreq
)))
2844 * These ioctl calls:
2845 * - require superuser power.
2846 * - require strict serialization.
2852 if (!capable(CAP_NET_ADMIN
))
2854 dev_load(ifr
.ifr_name
);
2856 ret
= dev_ifsioc(&ifr
, cmd
);
2861 if (copy_to_user(arg
, &ifr
,
2862 sizeof(struct ifreq
)))
2868 * These ioctl calls:
2869 * - require superuser power.
2870 * - require strict serialization.
2871 * - do not return a value
2881 case SIOCSIFHWBROADCAST
:
2884 case SIOCBONDENSLAVE
:
2885 case SIOCBONDRELEASE
:
2886 case SIOCBONDSETHWADDR
:
2887 case SIOCBONDCHANGEACTIVE
:
2890 if (!capable(CAP_NET_ADMIN
))
2893 case SIOCBONDSLAVEINFOQUERY
:
2894 case SIOCBONDINFOQUERY
:
2895 dev_load(ifr
.ifr_name
);
2897 ret
= dev_ifsioc(&ifr
, cmd
);
2902 /* Get the per device memory space. We can add this but
2903 * currently do not support it */
2905 /* Set the per device memory buffer space.
2906 * Not applicable in our case */
2911 * Unknown or private ioctl.
2914 if (cmd
== SIOCWANDEV
||
2915 (cmd
>= SIOCDEVPRIVATE
&&
2916 cmd
<= SIOCDEVPRIVATE
+ 15)) {
2917 dev_load(ifr
.ifr_name
);
2919 ret
= dev_ifsioc(&ifr
, cmd
);
2921 if (!ret
&& copy_to_user(arg
, &ifr
,
2922 sizeof(struct ifreq
)))
2926 #ifdef CONFIG_WIRELESS_EXT
2927 /* Take care of Wireless Extensions */
2928 if (cmd
>= SIOCIWFIRST
&& cmd
<= SIOCIWLAST
) {
2929 /* If command is `set a parameter', or
2930 * `get the encoding parameters', check if
2931 * the user has the right to do it */
2932 if (IW_IS_SET(cmd
) || cmd
== SIOCGIWENCODE
2933 || cmd
== SIOCGIWENCODEEXT
) {
2934 if (!capable(CAP_NET_ADMIN
))
2937 dev_load(ifr
.ifr_name
);
2939 /* Follow me in net/core/wireless.c */
2940 ret
= wireless_process_ioctl(&ifr
, cmd
);
2942 if (IW_IS_GET(cmd
) &&
2943 copy_to_user(arg
, &ifr
,
2944 sizeof(struct ifreq
)))
2948 #endif /* CONFIG_WIRELESS_EXT */
2955 * dev_new_index - allocate an ifindex
2957 * Returns a suitable unique value for a new device interface
2958 * number. The caller must hold the rtnl semaphore or the
2959 * dev_base_lock to be sure it remains unique.
2961 static int dev_new_index(void)
2967 if (!__dev_get_by_index(ifindex
))
2972 static int dev_boot_phase
= 1;
2974 /* Delayed registration/unregisteration */
2975 static DEFINE_SPINLOCK(net_todo_list_lock
);
2976 static struct list_head net_todo_list
= LIST_HEAD_INIT(net_todo_list
);
2978 static void net_set_todo(struct net_device
*dev
)
2980 spin_lock(&net_todo_list_lock
);
2981 list_add_tail(&dev
->todo_list
, &net_todo_list
);
2982 spin_unlock(&net_todo_list_lock
);
2986 * register_netdevice - register a network device
2987 * @dev: device to register
2989 * Take a completed network device structure and add it to the kernel
2990 * interfaces. A %NETDEV_REGISTER message is sent to the netdev notifier
2991 * chain. 0 is returned on success. A negative errno code is returned
2992 * on a failure to set up the device, or if the name is a duplicate.
2994 * Callers must hold the rtnl semaphore. You may want
2995 * register_netdev() instead of this.
2998 * The locking appears insufficient to guarantee two parallel registers
2999 * will not get the same name.
3002 int register_netdevice(struct net_device
*dev
)
3004 struct hlist_head
*head
;
3005 struct hlist_node
*p
;
3008 BUG_ON(dev_boot_phase
);
3013 /* When net_device's are persistent, this will be fatal. */
3014 BUG_ON(dev
->reg_state
!= NETREG_UNINITIALIZED
);
3016 spin_lock_init(&dev
->queue_lock
);
3017 spin_lock_init(&dev
->_xmit_lock
);
3018 dev
->xmit_lock_owner
= -1;
3019 spin_lock_init(&dev
->ingress_lock
);
3023 /* Init, if this function is available */
3025 ret
= dev
->init(dev
);
3033 if (!dev_valid_name(dev
->name
)) {
3038 dev
->ifindex
= dev_new_index();
3039 if (dev
->iflink
== -1)
3040 dev
->iflink
= dev
->ifindex
;
3042 /* Check for existence of name */
3043 head
= dev_name_hash(dev
->name
);
3044 hlist_for_each(p
, head
) {
3045 struct net_device
*d
3046 = hlist_entry(p
, struct net_device
, name_hlist
);
3047 if (!strncmp(d
->name
, dev
->name
, IFNAMSIZ
)) {
3053 /* Fix illegal SG+CSUM combinations. */
3054 if ((dev
->features
& NETIF_F_SG
) &&
3055 !(dev
->features
& NETIF_F_ALL_CSUM
)) {
3056 printk(KERN_NOTICE
"%s: Dropping NETIF_F_SG since no checksum feature.\n",
3058 dev
->features
&= ~NETIF_F_SG
;
3061 /* TSO requires that SG is present as well. */
3062 if ((dev
->features
& NETIF_F_TSO
) &&
3063 !(dev
->features
& NETIF_F_SG
)) {
3064 printk(KERN_NOTICE
"%s: Dropping NETIF_F_TSO since no SG feature.\n",
3066 dev
->features
&= ~NETIF_F_TSO
;
3068 if (dev
->features
& NETIF_F_UFO
) {
3069 if (!(dev
->features
& NETIF_F_HW_CSUM
)) {
3070 printk(KERN_ERR
"%s: Dropping NETIF_F_UFO since no "
3071 "NETIF_F_HW_CSUM feature.\n",
3073 dev
->features
&= ~NETIF_F_UFO
;
3075 if (!(dev
->features
& NETIF_F_SG
)) {
3076 printk(KERN_ERR
"%s: Dropping NETIF_F_UFO since no "
3077 "NETIF_F_SG feature.\n",
3079 dev
->features
&= ~NETIF_F_UFO
;
3084 * nil rebuild_header routine,
3085 * that should be never called and used as just bug trap.
3088 if (!dev
->rebuild_header
)
3089 dev
->rebuild_header
= default_rebuild_header
;
3091 ret
= netdev_register_sysfs(dev
);
3094 dev
->reg_state
= NETREG_REGISTERED
;
3097 * Default initial state at registry is that the
3098 * device is present.
3101 set_bit(__LINK_STATE_PRESENT
, &dev
->state
);
3104 dev_init_scheduler(dev
);
3105 write_lock_bh(&dev_base_lock
);
3107 dev_tail
= &dev
->next
;
3108 hlist_add_head(&dev
->name_hlist
, head
);
3109 hlist_add_head(&dev
->index_hlist
, dev_index_hash(dev
->ifindex
));
3111 write_unlock_bh(&dev_base_lock
);
3113 /* Notify protocols, that a new device appeared. */
3114 raw_notifier_call_chain(&netdev_chain
, NETDEV_REGISTER
, dev
);
3123 * register_netdev - register a network device
3124 * @dev: device to register
3126 * Take a completed network device structure and add it to the kernel
3127 * interfaces. A %NETDEV_REGISTER message is sent to the netdev notifier
3128 * chain. 0 is returned on success. A negative errno code is returned
3129 * on a failure to set up the device, or if the name is a duplicate.
3131 * This is a wrapper around register_netdevice that takes the rtnl semaphore
3132 * and expands the device name if you passed a format string to
3135 int register_netdev(struct net_device
*dev
)
3142 * If the name is a format string the caller wants us to do a
3145 if (strchr(dev
->name
, '%')) {
3146 err
= dev_alloc_name(dev
, dev
->name
);
3151 err
= register_netdevice(dev
);
3156 EXPORT_SYMBOL(register_netdev
);
3159 * netdev_wait_allrefs - wait until all references are gone.
3161 * This is called when unregistering network devices.
3163 * Any protocol or device that holds a reference should register
3164 * for netdevice notification, and cleanup and put back the
3165 * reference if they receive an UNREGISTER event.
3166 * We can get stuck here if buggy protocols don't correctly
3169 static void netdev_wait_allrefs(struct net_device
*dev
)
3171 unsigned long rebroadcast_time
, warning_time
;
3173 rebroadcast_time
= warning_time
= jiffies
;
3174 while (atomic_read(&dev
->refcnt
) != 0) {
3175 if (time_after(jiffies
, rebroadcast_time
+ 1 * HZ
)) {
3178 /* Rebroadcast unregister notification */
3179 raw_notifier_call_chain(&netdev_chain
,
3180 NETDEV_UNREGISTER
, dev
);
3182 if (test_bit(__LINK_STATE_LINKWATCH_PENDING
,
3184 /* We must not have linkwatch events
3185 * pending on unregister. If this
3186 * happens, we simply run the queue
3187 * unscheduled, resulting in a noop
3190 linkwatch_run_queue();
3195 rebroadcast_time
= jiffies
;
3200 if (time_after(jiffies
, warning_time
+ 10 * HZ
)) {
3201 printk(KERN_EMERG
"unregister_netdevice: "
3202 "waiting for %s to become free. Usage "
3204 dev
->name
, atomic_read(&dev
->refcnt
));
3205 warning_time
= jiffies
;
3214 * register_netdevice(x1);
3215 * register_netdevice(x2);
3217 * unregister_netdevice(y1);
3218 * unregister_netdevice(y2);
3224 * We are invoked by rtnl_unlock() after it drops the semaphore.
3225 * This allows us to deal with problems:
3226 * 1) We can delete sysfs objects which invoke hotplug
3227 * without deadlocking with linkwatch via keventd.
3228 * 2) Since we run with the RTNL semaphore not held, we can sleep
3229 * safely in order to wait for the netdev refcnt to drop to zero.
3231 static DEFINE_MUTEX(net_todo_run_mutex
);
3232 void netdev_run_todo(void)
3234 struct list_head list
;
3236 /* Need to guard against multiple cpu's getting out of order. */
3237 mutex_lock(&net_todo_run_mutex
);
3239 /* Not safe to do outside the semaphore. We must not return
3240 * until all unregister events invoked by the local processor
3241 * have been completed (either by this todo run, or one on
3244 if (list_empty(&net_todo_list
))
3247 /* Snapshot list, allow later requests */
3248 spin_lock(&net_todo_list_lock
);
3249 list_replace_init(&net_todo_list
, &list
);
3250 spin_unlock(&net_todo_list_lock
);
3252 while (!list_empty(&list
)) {
3253 struct net_device
*dev
3254 = list_entry(list
.next
, struct net_device
, todo_list
);
3255 list_del(&dev
->todo_list
);
3257 if (unlikely(dev
->reg_state
!= NETREG_UNREGISTERING
)) {
3258 printk(KERN_ERR
"network todo '%s' but state %d\n",
3259 dev
->name
, dev
->reg_state
);
3264 netdev_unregister_sysfs(dev
);
3265 dev
->reg_state
= NETREG_UNREGISTERED
;
3267 netdev_wait_allrefs(dev
);
3270 BUG_ON(atomic_read(&dev
->refcnt
));
3271 BUG_TRAP(!dev
->ip_ptr
);
3272 BUG_TRAP(!dev
->ip6_ptr
);
3273 BUG_TRAP(!dev
->dn_ptr
);
3275 /* It must be the very last action,
3276 * after this 'dev' may point to freed up memory.
3278 if (dev
->destructor
)
3279 dev
->destructor(dev
);
3283 mutex_unlock(&net_todo_run_mutex
);
3286 static struct net_device_stats
*maybe_internal_stats(struct net_device
*dev
)
3288 if (dev
->features
& NETIF_F_INTERNAL_STATS
)
3294 * alloc_netdev - allocate network device
3295 * @sizeof_priv: size of private data to allocate space for
3296 * @name: device name format string
3297 * @setup: callback to initialize device
3299 * Allocates a struct net_device with private data area for driver use
3300 * and performs basic initialization.
3302 struct net_device
*alloc_netdev(int sizeof_priv
, const char *name
,
3303 void (*setup
)(struct net_device
*))
3306 struct net_device
*dev
;
3309 BUG_ON(strlen(name
) >= sizeof(dev
->name
));
3311 /* ensure 32-byte alignment of both the device and private area */
3312 alloc_size
= (sizeof(*dev
) + NETDEV_ALIGN_CONST
) & ~NETDEV_ALIGN_CONST
;
3313 alloc_size
+= sizeof_priv
+ NETDEV_ALIGN_CONST
;
3315 p
= kzalloc(alloc_size
, GFP_KERNEL
);
3317 printk(KERN_ERR
"alloc_netdev: Unable to allocate device.\n");
3321 dev
= (struct net_device
*)
3322 (((long)p
+ NETDEV_ALIGN_CONST
) & ~NETDEV_ALIGN_CONST
);
3323 dev
->padded
= (char *)dev
- (char *)p
;
3326 dev
->priv
= netdev_priv(dev
);
3328 dev
->get_stats
= maybe_internal_stats
;
3330 strcpy(dev
->name
, name
);
3333 EXPORT_SYMBOL(alloc_netdev
);
3336 * free_netdev - free network device
3339 * This function does the last stage of destroying an allocated device
3340 * interface. The reference to the device object is released.
3341 * If this is the last reference then it will be freed.
3343 void free_netdev(struct net_device
*dev
)
3346 /* Compatibility with error handling in drivers */
3347 if (dev
->reg_state
== NETREG_UNINITIALIZED
) {
3348 kfree((char *)dev
- dev
->padded
);
3352 BUG_ON(dev
->reg_state
!= NETREG_UNREGISTERED
);
3353 dev
->reg_state
= NETREG_RELEASED
;
3355 /* will free via device release */
3356 put_device(&dev
->dev
);
3358 kfree((char *)dev
- dev
->padded
);
3362 /* Synchronize with packet receive processing. */
3363 void synchronize_net(void)
3370 * unregister_netdevice - remove device from the kernel
3373 * This function shuts down a device interface and removes it
3374 * from the kernel tables. On success 0 is returned, on a failure
3375 * a negative errno code is returned.
3377 * Callers must hold the rtnl semaphore. You may want
3378 * unregister_netdev() instead of this.
3381 void unregister_netdevice(struct net_device
*dev
)
3383 struct net_device
*d
, **dp
;
3385 BUG_ON(dev_boot_phase
);
3388 /* Some devices call without registering for initialization unwind. */
3389 if (dev
->reg_state
== NETREG_UNINITIALIZED
) {
3390 printk(KERN_DEBUG
"unregister_netdevice: device %s/%p never "
3391 "was registered\n", dev
->name
, dev
);
3397 BUG_ON(dev
->reg_state
!= NETREG_REGISTERED
);
3399 /* If device is running, close it first. */
3400 if (dev
->flags
& IFF_UP
)
3403 /* And unlink it from device chain. */
3404 for (dp
= &dev_base
; (d
= *dp
) != NULL
; dp
= &d
->next
) {
3406 write_lock_bh(&dev_base_lock
);
3407 hlist_del(&dev
->name_hlist
);
3408 hlist_del(&dev
->index_hlist
);
3409 if (dev_tail
== &dev
->next
)
3412 write_unlock_bh(&dev_base_lock
);
3418 dev
->reg_state
= NETREG_UNREGISTERING
;
3422 /* Shutdown queueing discipline. */
3426 /* Notify protocols, that we are about to destroy
3427 this device. They should clean all the things.
3429 raw_notifier_call_chain(&netdev_chain
, NETDEV_UNREGISTER
, dev
);
3432 * Flush the multicast chain
3434 dev_mc_discard(dev
);
3439 /* Notifier chain MUST detach us from master device. */
3440 BUG_TRAP(!dev
->master
);
3442 /* Finish processing unregister after unlock */
3451 * unregister_netdev - remove device from the kernel
3454 * This function shuts down a device interface and removes it
3455 * from the kernel tables. On success 0 is returned, on a failure
3456 * a negative errno code is returned.
3458 * This is just a wrapper for unregister_netdevice that takes
3459 * the rtnl semaphore. In general you want to use this and not
3460 * unregister_netdevice.
3462 void unregister_netdev(struct net_device
*dev
)
3465 unregister_netdevice(dev
);
3469 EXPORT_SYMBOL(unregister_netdev
);
3471 static int dev_cpu_callback(struct notifier_block
*nfb
,
3472 unsigned long action
,
3475 struct sk_buff
**list_skb
;
3476 struct net_device
**list_net
;
3477 struct sk_buff
*skb
;
3478 unsigned int cpu
, oldcpu
= (unsigned long)ocpu
;
3479 struct softnet_data
*sd
, *oldsd
;
3481 if (action
!= CPU_DEAD
)
3484 local_irq_disable();
3485 cpu
= smp_processor_id();
3486 sd
= &per_cpu(softnet_data
, cpu
);
3487 oldsd
= &per_cpu(softnet_data
, oldcpu
);
3489 /* Find end of our completion_queue. */
3490 list_skb
= &sd
->completion_queue
;
3492 list_skb
= &(*list_skb
)->next
;
3493 /* Append completion queue from offline CPU. */
3494 *list_skb
= oldsd
->completion_queue
;
3495 oldsd
->completion_queue
= NULL
;
3497 /* Find end of our output_queue. */
3498 list_net
= &sd
->output_queue
;
3500 list_net
= &(*list_net
)->next_sched
;
3501 /* Append output queue from offline CPU. */
3502 *list_net
= oldsd
->output_queue
;
3503 oldsd
->output_queue
= NULL
;
3505 raise_softirq_irqoff(NET_TX_SOFTIRQ
);
3508 /* Process offline CPU's input_pkt_queue */
3509 while ((skb
= __skb_dequeue(&oldsd
->input_pkt_queue
)))
3515 #ifdef CONFIG_NET_DMA
3517 * net_dma_rebalance -
3518 * This is called when the number of channels allocated to the net_dma_client
3519 * changes. The net_dma_client tries to have one DMA channel per CPU.
3521 static void net_dma_rebalance(void)
3523 unsigned int cpu
, i
, n
;
3524 struct dma_chan
*chan
;
3526 if (net_dma_count
== 0) {
3527 for_each_online_cpu(cpu
)
3528 rcu_assign_pointer(per_cpu(softnet_data
, cpu
).net_dma
, NULL
);
3533 cpu
= first_cpu(cpu_online_map
);
3536 list_for_each_entry(chan
, &net_dma_client
->channels
, client_node
) {
3537 n
= ((num_online_cpus() / net_dma_count
)
3538 + (i
< (num_online_cpus() % net_dma_count
) ? 1 : 0));
3541 per_cpu(softnet_data
, cpu
).net_dma
= chan
;
3542 cpu
= next_cpu(cpu
, cpu_online_map
);
3551 * netdev_dma_event - event callback for the net_dma_client
3552 * @client: should always be net_dma_client
3553 * @chan: DMA channel for the event
3554 * @event: event type
3556 static void netdev_dma_event(struct dma_client
*client
, struct dma_chan
*chan
,
3557 enum dma_event event
)
3559 spin_lock(&net_dma_event_lock
);
3561 case DMA_RESOURCE_ADDED
:
3563 net_dma_rebalance();
3565 case DMA_RESOURCE_REMOVED
:
3567 net_dma_rebalance();
3572 spin_unlock(&net_dma_event_lock
);
3576 * netdev_dma_regiser - register the networking subsystem as a DMA client
3578 static int __init
netdev_dma_register(void)
3580 spin_lock_init(&net_dma_event_lock
);
3581 net_dma_client
= dma_async_client_register(netdev_dma_event
);
3582 if (net_dma_client
== NULL
)
3585 dma_async_client_chan_request(net_dma_client
, num_online_cpus());
3590 static int __init
netdev_dma_register(void) { return -ENODEV
; }
3591 #endif /* CONFIG_NET_DMA */
3594 * Initialize the DEV module. At boot time this walks the device list and
3595 * unhooks any devices that fail to initialise (normally hardware not
3596 * present) and leaves us with a valid list of present and active devices.
3601 * This is called single threaded during boot, so no need
3602 * to take the rtnl semaphore.
3604 static int __init
net_dev_init(void)
3606 int i
, rc
= -ENOMEM
;
3608 BUG_ON(!dev_boot_phase
);
3610 if (dev_proc_init())
3613 if (netdev_sysfs_init())
3616 INIT_LIST_HEAD(&ptype_all
);
3617 for (i
= 0; i
< 16; i
++)
3618 INIT_LIST_HEAD(&ptype_base
[i
]);
3620 for (i
= 0; i
< ARRAY_SIZE(dev_name_head
); i
++)
3621 INIT_HLIST_HEAD(&dev_name_head
[i
]);
3623 for (i
= 0; i
< ARRAY_SIZE(dev_index_head
); i
++)
3624 INIT_HLIST_HEAD(&dev_index_head
[i
]);
3627 * Initialise the packet receive queues.
3630 for_each_possible_cpu(i
) {
3631 struct softnet_data
*queue
;
3633 queue
= &per_cpu(softnet_data
, i
);
3634 skb_queue_head_init(&queue
->input_pkt_queue
);
3635 queue
->completion_queue
= NULL
;
3636 INIT_LIST_HEAD(&queue
->poll_list
);
3637 set_bit(__LINK_STATE_START
, &queue
->backlog_dev
.state
);
3638 queue
->backlog_dev
.weight
= weight_p
;
3639 queue
->backlog_dev
.poll
= process_backlog
;
3640 atomic_set(&queue
->backlog_dev
.refcnt
, 1);
3643 netdev_dma_register();
3647 open_softirq(NET_TX_SOFTIRQ
, net_tx_action
, NULL
);
3648 open_softirq(NET_RX_SOFTIRQ
, net_rx_action
, NULL
);
3650 hotcpu_notifier(dev_cpu_callback
, 0);
3658 subsys_initcall(net_dev_init
);
3660 EXPORT_SYMBOL(__dev_get_by_index
);
3661 EXPORT_SYMBOL(__dev_get_by_name
);
3662 EXPORT_SYMBOL(__dev_remove_pack
);
3663 EXPORT_SYMBOL(dev_valid_name
);
3664 EXPORT_SYMBOL(dev_add_pack
);
3665 EXPORT_SYMBOL(dev_alloc_name
);
3666 EXPORT_SYMBOL(dev_close
);
3667 EXPORT_SYMBOL(dev_get_by_flags
);
3668 EXPORT_SYMBOL(dev_get_by_index
);
3669 EXPORT_SYMBOL(dev_get_by_name
);
3670 EXPORT_SYMBOL(dev_open
);
3671 EXPORT_SYMBOL(dev_queue_xmit
);
3672 EXPORT_SYMBOL(dev_remove_pack
);
3673 EXPORT_SYMBOL(dev_set_allmulti
);
3674 EXPORT_SYMBOL(dev_set_promiscuity
);
3675 EXPORT_SYMBOL(dev_change_flags
);
3676 EXPORT_SYMBOL(dev_set_mtu
);
3677 EXPORT_SYMBOL(dev_set_mac_address
);
3678 EXPORT_SYMBOL(free_netdev
);
3679 EXPORT_SYMBOL(netdev_boot_setup_check
);
3680 EXPORT_SYMBOL(netdev_set_master
);
3681 EXPORT_SYMBOL(netdev_state_change
);
3682 EXPORT_SYMBOL(netif_receive_skb
);
3683 EXPORT_SYMBOL(netif_rx
);
3684 EXPORT_SYMBOL(register_gifconf
);
3685 EXPORT_SYMBOL(register_netdevice
);
3686 EXPORT_SYMBOL(register_netdevice_notifier
);
3687 EXPORT_SYMBOL(skb_checksum_help
);
3688 EXPORT_SYMBOL(synchronize_net
);
3689 EXPORT_SYMBOL(unregister_netdevice
);
3690 EXPORT_SYMBOL(unregister_netdevice_notifier
);
3691 EXPORT_SYMBOL(net_enable_timestamp
);
3692 EXPORT_SYMBOL(net_disable_timestamp
);
3693 EXPORT_SYMBOL(dev_get_flags
);
3695 #if defined(CONFIG_BRIDGE) || defined(CONFIG_BRIDGE_MODULE)
3696 EXPORT_SYMBOL(br_handle_frame_hook
);
3697 EXPORT_SYMBOL(br_fdb_get_hook
);
3698 EXPORT_SYMBOL(br_fdb_put_hook
);
3702 EXPORT_SYMBOL(dev_load
);
3705 EXPORT_PER_CPU_SYMBOL(softnet_data
);