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>
95 #include <net/net_namespace.h>
97 #include <linux/rtnetlink.h>
98 #include <linux/proc_fs.h>
99 #include <linux/seq_file.h>
100 #include <linux/stat.h>
101 #include <linux/if_bridge.h>
102 #include <linux/if_macvlan.h>
104 #include <net/pkt_sched.h>
105 #include <net/checksum.h>
106 #include <linux/highmem.h>
107 #include <linux/init.h>
108 #include <linux/kmod.h>
109 #include <linux/module.h>
110 #include <linux/kallsyms.h>
111 #include <linux/netpoll.h>
112 #include <linux/rcupdate.h>
113 #include <linux/delay.h>
114 #include <net/wext.h>
115 #include <net/iw_handler.h>
116 #include <asm/current.h>
117 #include <linux/audit.h>
118 #include <linux/dmaengine.h>
119 #include <linux/err.h>
120 #include <linux/ctype.h>
121 #include <linux/if_arp.h>
124 * The list of packet types we will receive (as opposed to discard)
125 * and the routines to invoke.
127 * Why 16. Because with 16 the only overlap we get on a hash of the
128 * low nibble of the protocol value is RARP/SNAP/X.25.
130 * NOTE: That is no longer true with the addition of VLAN tags. Not
131 * sure which should go first, but I bet it won't make much
132 * difference if we are running VLANs. The good news is that
133 * this protocol won't be in the list unless compiled in, so
134 * the average user (w/out VLANs) will not be adversely affected.
151 static DEFINE_SPINLOCK(ptype_lock);
152 static struct list_head ptype_base[16] __read_mostly; /* 16 way hashed list */
153 static struct list_head ptype_all __read_mostly; /* Taps */
155 #ifdef CONFIG_NET_DMA
157 struct dma_client client;
159 cpumask_t channel_mask;
160 struct dma_chan *channels[NR_CPUS];
163 static enum dma_state_client
164 netdev_dma_event(struct dma_client *client, struct dma_chan *chan,
165 enum dma_state state);
167 static struct net_dma net_dma = {
169 .event_callback = netdev_dma_event,
175 * The @dev_base_head list is protected by @dev_base_lock and the rtnl
178 * Pure readers hold dev_base_lock for reading.
180 * Writers must hold the rtnl semaphore while they loop through the
181 * dev_base_head list, and hold dev_base_lock for writing when they do the
182 * actual updates. This allows pure readers to access the list even
183 * while a writer is preparing to update it.
185 * To put it another way, dev_base_lock is held for writing only to
186 * protect against pure readers; the rtnl semaphore provides the
187 * protection against other writers.
189 * See, for example usages, register_netdevice() and
190 * unregister_netdevice(), which must be called with the rtnl
193 DEFINE_RWLOCK(dev_base_lock);
195 EXPORT_SYMBOL(dev_base_lock);
197 #define NETDEV_HASHBITS 8
198 #define NETDEV_HASHENTRIES (1 << NETDEV_HASHBITS)
200 static inline struct hlist_head *dev_name_hash(struct net *net, const char *name)
202 unsigned hash = full_name_hash(name, strnlen(name, IFNAMSIZ));
203 return &net->dev_name_head[hash & ((1 << NETDEV_HASHBITS) - 1)];
206 static inline struct hlist_head *dev_index_hash(struct net *net, int ifindex)
208 return &net->dev_index_head[ifindex & ((1 << NETDEV_HASHBITS) - 1)];
211 /* Device list insertion */
212 static int list_netdevice(struct net_device *dev)
214 struct net *net = dev->nd_net;
218 write_lock_bh(&dev_base_lock);
219 list_add_tail(&dev->dev_list, &net->dev_base_head);
220 hlist_add_head(&dev->name_hlist, dev_name_hash(net, dev->name));
221 hlist_add_head(&dev->index_hlist, dev_index_hash(net, dev->ifindex));
222 write_unlock_bh(&dev_base_lock);
226 /* Device list removal */
227 static void unlist_netdevice(struct net_device *dev)
231 /* Unlink dev from the device chain */
232 write_lock_bh(&dev_base_lock);
233 list_del(&dev->dev_list);
234 hlist_del(&dev->name_hlist);
235 hlist_del(&dev->index_hlist);
236 write_unlock_bh(&dev_base_lock);
243 static RAW_NOTIFIER_HEAD(netdev_chain);
246 * Device drivers call our routines to queue packets here. We empty the
247 * queue in the local softnet handler.
250 DEFINE_PER_CPU(struct softnet_data, softnet_data);
252 extern int netdev_kobject_init(void);
253 extern int netdev_register_kobject(struct net_device *);
254 extern void netdev_unregister_kobject(struct net_device *);
256 #ifdef CONFIG_DEBUG_LOCK_ALLOC
258 * register_netdevice() inits dev->_xmit_lock and sets lockdep class
259 * according to dev->type
261 static const unsigned short netdev_lock_type[] =
262 {ARPHRD_NETROM, ARPHRD_ETHER, ARPHRD_EETHER, ARPHRD_AX25,
263 ARPHRD_PRONET, ARPHRD_CHAOS, ARPHRD_IEEE802, ARPHRD_ARCNET,
264 ARPHRD_APPLETLK, ARPHRD_DLCI, ARPHRD_ATM, ARPHRD_METRICOM,
265 ARPHRD_IEEE1394, ARPHRD_EUI64, ARPHRD_INFINIBAND, ARPHRD_SLIP,
266 ARPHRD_CSLIP, ARPHRD_SLIP6, ARPHRD_CSLIP6, ARPHRD_RSRVD,
267 ARPHRD_ADAPT, ARPHRD_ROSE, ARPHRD_X25, ARPHRD_HWX25,
268 ARPHRD_PPP, ARPHRD_CISCO, ARPHRD_LAPB, ARPHRD_DDCMP,
269 ARPHRD_RAWHDLC, ARPHRD_TUNNEL, ARPHRD_TUNNEL6, ARPHRD_FRAD,
270 ARPHRD_SKIP, ARPHRD_LOOPBACK, ARPHRD_LOCALTLK, ARPHRD_FDDI,
271 ARPHRD_BIF, ARPHRD_SIT, ARPHRD_IPDDP, ARPHRD_IPGRE,
272 ARPHRD_PIMREG, ARPHRD_HIPPI, ARPHRD_ASH, ARPHRD_ECONET,
273 ARPHRD_IRDA, ARPHRD_FCPP, ARPHRD_FCAL, ARPHRD_FCPL,
274 ARPHRD_FCFABRIC, ARPHRD_IEEE802_TR, ARPHRD_IEEE80211,
275 ARPHRD_IEEE80211_PRISM, ARPHRD_IEEE80211_RADIOTAP, ARPHRD_VOID,
278 static const char *netdev_lock_name[] =
279 {"_xmit_NETROM", "_xmit_ETHER", "_xmit_EETHER", "_xmit_AX25",
280 "_xmit_PRONET", "_xmit_CHAOS", "_xmit_IEEE802", "_xmit_ARCNET",
281 "_xmit_APPLETLK", "_xmit_DLCI", "_xmit_ATM", "_xmit_METRICOM",
282 "_xmit_IEEE1394", "_xmit_EUI64", "_xmit_INFINIBAND", "_xmit_SLIP",
283 "_xmit_CSLIP", "_xmit_SLIP6", "_xmit_CSLIP6", "_xmit_RSRVD",
284 "_xmit_ADAPT", "_xmit_ROSE", "_xmit_X25", "_xmit_HWX25",
285 "_xmit_PPP", "_xmit_CISCO", "_xmit_LAPB", "_xmit_DDCMP",
286 "_xmit_RAWHDLC", "_xmit_TUNNEL", "_xmit_TUNNEL6", "_xmit_FRAD",
287 "_xmit_SKIP", "_xmit_LOOPBACK", "_xmit_LOCALTLK", "_xmit_FDDI",
288 "_xmit_BIF", "_xmit_SIT", "_xmit_IPDDP", "_xmit_IPGRE",
289 "_xmit_PIMREG", "_xmit_HIPPI", "_xmit_ASH", "_xmit_ECONET",
290 "_xmit_IRDA", "_xmit_FCPP", "_xmit_FCAL", "_xmit_FCPL",
291 "_xmit_FCFABRIC", "_xmit_IEEE802_TR", "_xmit_IEEE80211",
292 "_xmit_IEEE80211_PRISM", "_xmit_IEEE80211_RADIOTAP", "_xmit_VOID",
295 static struct lock_class_key netdev_xmit_lock_key[ARRAY_SIZE(netdev_lock_type)];
297 static inline unsigned short netdev_lock_pos(unsigned short dev_type)
301 for (i = 0; i < ARRAY_SIZE(netdev_lock_type); i++)
302 if (netdev_lock_type[i] == dev_type)
304 /* the last key is used by default */
305 return ARRAY_SIZE(netdev_lock_type) - 1;
308 static inline void netdev_set_lockdep_class(spinlock_t *lock,
309 unsigned short dev_type)
313 i = netdev_lock_pos(dev_type);
314 lockdep_set_class_and_name(lock, &netdev_xmit_lock_key[i],
315 netdev_lock_name[i]);
318 static inline void netdev_set_lockdep_class(spinlock_t *lock,
319 unsigned short dev_type)
324 /*******************************************************************************
326 Protocol management and registration routines
328 *******************************************************************************/
331 * Add a protocol ID to the list. Now that the input handler is
332 * smarter we can dispense with all the messy stuff that used to be
335 * BEWARE!!! Protocol handlers, mangling input packets,
336 * MUST BE last in hash buckets and checking protocol handlers
337 * MUST start from promiscuous ptype_all chain in net_bh.
338 * It is true now, do not change it.
339 * Explanation follows: if protocol handler, mangling packet, will
340 * be the first on list, it is not able to sense, that packet
341 * is cloned and should be copied-on-write, so that it will
342 * change it and subsequent readers will get broken packet.
347 * dev_add_pack - add packet handler
348 * @pt: packet type declaration
350 * Add a protocol handler to the networking stack. The passed &packet_type
351 * is linked into kernel lists and may not be freed until it has been
352 * removed from the kernel lists.
354 * This call does not sleep therefore it can not
355 * guarantee all CPU's that are in middle of receiving packets
356 * will see the new packet type (until the next received packet).
359 void dev_add_pack(struct packet_type *pt)
363 spin_lock_bh(&ptype_lock);
364 if (pt->type == htons(ETH_P_ALL))
365 list_add_rcu(&pt->list, &ptype_all);
367 hash = ntohs(pt->type) & 15;
368 list_add_rcu(&pt->list, &ptype_base[hash]);
370 spin_unlock_bh(&ptype_lock);
374 * __dev_remove_pack - remove packet handler
375 * @pt: packet type declaration
377 * Remove a protocol handler that was previously added to the kernel
378 * protocol handlers by dev_add_pack(). The passed &packet_type is removed
379 * from the kernel lists and can be freed or reused once this function
382 * The packet type might still be in use by receivers
383 * and must not be freed until after all the CPU's have gone
384 * through a quiescent state.
386 void __dev_remove_pack(struct packet_type *pt)
388 struct list_head *head;
389 struct packet_type *pt1;
391 spin_lock_bh(&ptype_lock);
393 if (pt->type == htons(ETH_P_ALL))
396 head = &ptype_base[ntohs(pt->type) & 15];
398 list_for_each_entry(pt1, head, list) {
400 list_del_rcu(&pt->list);
405 printk(KERN_WARNING "dev_remove_pack: %p not found.\n", pt);
407 spin_unlock_bh(&ptype_lock);
410 * dev_remove_pack - remove packet handler
411 * @pt: packet type declaration
413 * Remove a protocol handler that was previously added to the kernel
414 * protocol handlers by dev_add_pack(). The passed &packet_type is removed
415 * from the kernel lists and can be freed or reused once this function
418 * This call sleeps to guarantee that no CPU is looking at the packet
421 void dev_remove_pack(struct packet_type *pt)
423 __dev_remove_pack(pt);
428 /******************************************************************************
430 Device Boot-time Settings Routines
432 *******************************************************************************/
434 /* Boot time configuration table */
435 static struct netdev_boot_setup dev_boot_setup[NETDEV_BOOT_SETUP_MAX];
438 * netdev_boot_setup_add - add new setup entry
439 * @name: name of the device
440 * @map: configured settings for the device
442 * Adds new setup entry to the dev_boot_setup list. The function
443 * returns 0 on error and 1 on success. This is a generic routine to
446 static int netdev_boot_setup_add(char *name, struct ifmap *map)
448 struct netdev_boot_setup *s;
452 for (i = 0; i < NETDEV_BOOT_SETUP_MAX; i++) {
453 if (s[i].name[0] == '\0' || s[i].name[0] == ' ') {
454 memset(s[i].name, 0, sizeof(s[i].name));
455 strcpy(s[i].name, name);
456 memcpy(&s[i].map, map, sizeof(s[i].map));
461 return i >= NETDEV_BOOT_SETUP_MAX ? 0 : 1;
465 * netdev_boot_setup_check - check boot time settings
466 * @dev: the netdevice
468 * Check boot time settings for the device.
469 * The found settings are set for the device to be used
470 * later in the device probing.
471 * Returns 0 if no settings found, 1 if they are.
473 int netdev_boot_setup_check(struct net_device *dev)
475 struct netdev_boot_setup *s = dev_boot_setup;
478 for (i = 0; i < NETDEV_BOOT_SETUP_MAX; i++) {
479 if (s[i].name[0] != '\0' && s[i].name[0] != ' ' &&
480 !strncmp(dev->name, s[i].name, strlen(s[i].name))) {
481 dev->irq = s[i].map.irq;
482 dev->base_addr = s[i].map.base_addr;
483 dev->mem_start = s[i].map.mem_start;
484 dev->mem_end = s[i].map.mem_end;
493 * netdev_boot_base - get address from boot time settings
494 * @prefix: prefix for network device
495 * @unit: id for network device
497 * Check boot time settings for the base address of device.
498 * The found settings are set for the device to be used
499 * later in the device probing.
500 * Returns 0 if no settings found.
502 unsigned long netdev_boot_base(const char *prefix, int unit)
504 const struct netdev_boot_setup *s = dev_boot_setup;
508 sprintf(name, "%s%d", prefix, unit);
511 * If device already registered then return base of 1
512 * to indicate not to probe for this interface
514 if (__dev_get_by_name(&init_net, name))
517 for (i = 0; i < NETDEV_BOOT_SETUP_MAX; i++)
518 if (!strcmp(name, s[i].name))
519 return s[i].map.base_addr;
524 * Saves at boot time configured settings for any netdevice.
526 int __init netdev_boot_setup(char *str)
531 str = get_options(str, ARRAY_SIZE(ints), ints);
536 memset(&map, 0, sizeof(map));
540 map.base_addr = ints[2];
542 map.mem_start = ints[3];
544 map.mem_end = ints[4];
546 /* Add new entry to the list */
547 return netdev_boot_setup_add(str, &map);
550 __setup("netdev=", netdev_boot_setup);
552 /*******************************************************************************
554 Device Interface Subroutines
556 *******************************************************************************/
559 * __dev_get_by_name - find a device by its name
560 * @net: the applicable net namespace
561 * @name: name to find
563 * Find an interface by name. Must be called under RTNL semaphore
564 * or @dev_base_lock. If the name is found a pointer to the device
565 * is returned. If the name is not found then %NULL is returned. The
566 * reference counters are not incremented so the caller must be
567 * careful with locks.
570 struct net_device *__dev_get_by_name(struct net *net, const char *name)
572 struct hlist_node *p;
574 hlist_for_each(p, dev_name_hash(net, name)) {
575 struct net_device *dev
576 = hlist_entry(p, struct net_device, name_hlist);
577 if (!strncmp(dev->name, name, IFNAMSIZ))
584 * dev_get_by_name - find a device by its name
585 * @net: the applicable net namespace
586 * @name: name to find
588 * Find an interface by name. This can be called from any
589 * context and does its own locking. The returned handle has
590 * the usage count incremented and the caller must use dev_put() to
591 * release it when it is no longer needed. %NULL is returned if no
592 * matching device is found.
595 struct net_device *dev_get_by_name(struct net *net, const char *name)
597 struct net_device *dev;
599 read_lock(&dev_base_lock);
600 dev = __dev_get_by_name(net, name);
603 read_unlock(&dev_base_lock);
608 * __dev_get_by_index - find a device by its ifindex
609 * @net: the applicable net namespace
610 * @ifindex: index of device
612 * Search for an interface by index. Returns %NULL if the device
613 * is not found or a pointer to the device. The device has not
614 * had its reference counter increased so the caller must be careful
615 * about locking. The caller must hold either the RTNL semaphore
619 struct net_device *__dev_get_by_index(struct net *net, int ifindex)
621 struct hlist_node *p;
623 hlist_for_each(p, dev_index_hash(net, ifindex)) {
624 struct net_device *dev
625 = hlist_entry(p, struct net_device, index_hlist);
626 if (dev->ifindex == ifindex)
634 * dev_get_by_index - find a device by its ifindex
635 * @net: the applicable net namespace
636 * @ifindex: index of device
638 * Search for an interface by index. Returns NULL if the device
639 * is not found or a pointer to the device. The device returned has
640 * had a reference added and the pointer is safe until the user calls
641 * dev_put to indicate they have finished with it.
644 struct net_device *dev_get_by_index(struct net *net, int ifindex)
646 struct net_device *dev;
648 read_lock(&dev_base_lock);
649 dev = __dev_get_by_index(net, ifindex);
652 read_unlock(&dev_base_lock);
657 * dev_getbyhwaddr - find a device by its hardware address
658 * @net: the applicable net namespace
659 * @type: media type of device
660 * @ha: hardware address
662 * Search for an interface by MAC address. Returns NULL if the device
663 * is not found or a pointer to the device. The caller must hold the
664 * rtnl semaphore. The returned device has not had its ref count increased
665 * and the caller must therefore be careful about locking
668 * If the API was consistent this would be __dev_get_by_hwaddr
671 struct net_device *dev_getbyhwaddr(struct net *net, unsigned short type, char *ha)
673 struct net_device *dev;
677 for_each_netdev(&init_net, dev)
678 if (dev->type == type &&
679 !memcmp(dev->dev_addr, ha, dev->addr_len))
685 EXPORT_SYMBOL(dev_getbyhwaddr);
687 struct net_device *__dev_getfirstbyhwtype(struct net *net, unsigned short type)
689 struct net_device *dev;
692 for_each_netdev(net, dev)
693 if (dev->type == type)
699 EXPORT_SYMBOL(__dev_getfirstbyhwtype);
701 struct net_device *dev_getfirstbyhwtype(struct net *net, unsigned short type)
703 struct net_device *dev;
706 dev = __dev_getfirstbyhwtype(net, type);
713 EXPORT_SYMBOL(dev_getfirstbyhwtype);
716 * dev_get_by_flags - find any device with given flags
717 * @net: the applicable net namespace
718 * @if_flags: IFF_* values
719 * @mask: bitmask of bits in if_flags to check
721 * Search for any interface with the given flags. Returns NULL if a device
722 * is not found or a pointer to the device. The device returned has
723 * had a reference added and the pointer is safe until the user calls
724 * dev_put to indicate they have finished with it.
727 struct net_device * dev_get_by_flags(struct net *net, unsigned short if_flags, unsigned short mask)
729 struct net_device *dev, *ret;
732 read_lock(&dev_base_lock);
733 for_each_netdev(net, dev) {
734 if (((dev->flags ^ if_flags) & mask) == 0) {
740 read_unlock(&dev_base_lock);
745 * dev_valid_name - check if name is okay for network device
748 * Network device names need to be valid file names to
749 * to allow sysfs to work. We also disallow any kind of
752 int dev_valid_name(const char *name)
756 if (strlen(name) >= IFNAMSIZ)
758 if (!strcmp(name, ".") || !strcmp(name, ".."))
762 if (*name == '/' || isspace(*name))
770 * __dev_alloc_name - allocate a name for a device
771 * @net: network namespace to allocate the device name in
772 * @name: name format string
773 * @buf: scratch buffer and result name string
775 * Passed a format string - eg "lt%d" it will try and find a suitable
776 * id. It scans list of devices to build up a free map, then chooses
777 * the first empty slot. The caller must hold the dev_base or rtnl lock
778 * while allocating the name and adding the device in order to avoid
780 * Limited to bits_per_byte * page size devices (ie 32K on most platforms).
781 * Returns the number of the unit assigned or a negative errno code.
784 static int __dev_alloc_name(struct net *net, const char *name, char *buf)
788 const int max_netdevices = 8*PAGE_SIZE;
789 unsigned long *inuse;
790 struct net_device *d;
792 p = strnchr(name, IFNAMSIZ-1, '%');
795 * Verify the string as this thing may have come from
796 * the user. There must be either one "%d" and no other "%"
799 if (p[1] != 'd' || strchr(p + 2, '%'))
802 /* Use one page as a bit array of possible slots */
803 inuse = (unsigned long *) get_zeroed_page(GFP_ATOMIC);
807 for_each_netdev(net, d) {
808 if (!sscanf(d->name, name, &i))
810 if (i < 0 || i >= max_netdevices)
813 /* avoid cases where sscanf is not exact inverse of printf */
814 snprintf(buf, IFNAMSIZ, name, i);
815 if (!strncmp(buf, d->name, IFNAMSIZ))
819 i = find_first_zero_bit(inuse, max_netdevices);
820 free_page((unsigned long) inuse);
823 snprintf(buf, IFNAMSIZ, name, i);
824 if (!__dev_get_by_name(net, buf))
827 /* It is possible to run out of possible slots
828 * when the name is long and there isn't enough space left
829 * for the digits, or if all bits are used.
835 * dev_alloc_name - allocate a name for a device
837 * @name: name format string
839 * Passed a format string - eg "lt%d" it will try and find a suitable
840 * id. It scans list of devices to build up a free map, then chooses
841 * the first empty slot. The caller must hold the dev_base or rtnl lock
842 * while allocating the name and adding the device in order to avoid
844 * Limited to bits_per_byte * page size devices (ie 32K on most platforms).
845 * Returns the number of the unit assigned or a negative errno code.
848 int dev_alloc_name(struct net_device *dev, const char *name)
854 BUG_ON(!dev->nd_net);
856 ret = __dev_alloc_name(net, name, buf);
858 strlcpy(dev->name, buf, IFNAMSIZ);
864 * dev_change_name - change name of a device
866 * @newname: name (or format string) must be at least IFNAMSIZ
868 * Change name of a device, can pass format strings "eth%d".
871 int dev_change_name(struct net_device *dev, char *newname)
873 char oldname[IFNAMSIZ];
879 BUG_ON(!dev->nd_net);
882 if (dev->flags & IFF_UP)
885 if (!dev_valid_name(newname))
888 memcpy(oldname, dev->name, IFNAMSIZ);
890 if (strchr(newname, '%')) {
891 err = dev_alloc_name(dev, newname);
894 strcpy(newname, dev->name);
896 else if (__dev_get_by_name(net, newname))
899 strlcpy(dev->name, newname, IFNAMSIZ);
902 device_rename(&dev->dev, dev->name);
904 write_lock_bh(&dev_base_lock);
905 hlist_del(&dev->name_hlist);
906 hlist_add_head(&dev->name_hlist, dev_name_hash(net, dev->name));
907 write_unlock_bh(&dev_base_lock);
909 ret = call_netdevice_notifiers(NETDEV_CHANGENAME, dev);
910 ret = notifier_to_errno(ret);
915 "%s: name change rollback failed: %d.\n",
919 memcpy(dev->name, oldname, IFNAMSIZ);
928 * netdev_features_change - device changes features
929 * @dev: device to cause notification
931 * Called to indicate a device has changed features.
933 void netdev_features_change(struct net_device *dev)
935 call_netdevice_notifiers(NETDEV_FEAT_CHANGE, dev);
937 EXPORT_SYMBOL(netdev_features_change);
940 * netdev_state_change - device changes state
941 * @dev: device to cause notification
943 * Called to indicate a device has changed state. This function calls
944 * the notifier chains for netdev_chain and sends a NEWLINK message
945 * to the routing socket.
947 void netdev_state_change(struct net_device *dev)
949 if (dev->flags & IFF_UP) {
950 call_netdevice_notifiers(NETDEV_CHANGE, dev);
951 rtmsg_ifinfo(RTM_NEWLINK, dev, 0);
956 * dev_load - load a network module
957 * @net: the applicable net namespace
958 * @name: name of interface
960 * If a network interface is not present and the process has suitable
961 * privileges this function loads the module. If module loading is not
962 * available in this kernel then it becomes a nop.
965 void dev_load(struct net *net, const char *name)
967 struct net_device *dev;
969 read_lock(&dev_base_lock);
970 dev = __dev_get_by_name(net, name);
971 read_unlock(&dev_base_lock);
973 if (!dev && capable(CAP_SYS_MODULE))
974 request_module("%s", name);
978 * dev_open - prepare an interface for use.
979 * @dev: device to open
981 * Takes a device from down to up state. The device's private open
982 * function is invoked and then the multicast lists are loaded. Finally
983 * the device is moved into the up state and a %NETDEV_UP message is
984 * sent to the netdev notifier chain.
986 * Calling this function on an active interface is a nop. On a failure
987 * a negative errno code is returned.
989 int dev_open(struct net_device *dev)
997 if (dev->flags & IFF_UP)
1001 * Is it even present?
1003 if (!netif_device_present(dev))
1007 * Call device private open method
1009 set_bit(__LINK_STATE_START, &dev->state);
1011 if (dev->validate_addr)
1012 ret = dev->validate_addr(dev);
1014 if (!ret && dev->open)
1015 ret = dev->open(dev);
1018 * If it went open OK then:
1022 clear_bit(__LINK_STATE_START, &dev->state);
1027 dev->flags |= IFF_UP;
1030 * Initialize multicasting status
1032 dev_set_rx_mode(dev);
1035 * Wakeup transmit queue engine
1040 * ... and announce new interface.
1042 call_netdevice_notifiers(NETDEV_UP, dev);
1049 * dev_close - shutdown an interface.
1050 * @dev: device to shutdown
1052 * This function moves an active device into down state. A
1053 * %NETDEV_GOING_DOWN is sent to the netdev notifier chain. The device
1054 * is then deactivated and finally a %NETDEV_DOWN is sent to the notifier
1057 int dev_close(struct net_device *dev)
1061 if (!(dev->flags & IFF_UP))
1065 * Tell people we are going down, so that they can
1066 * prepare to death, when device is still operating.
1068 call_netdevice_notifiers(NETDEV_GOING_DOWN, dev);
1070 dev_deactivate(dev);
1072 clear_bit(__LINK_STATE_START, &dev->state);
1074 /* Synchronize to scheduled poll. We cannot touch poll list,
1075 * it can be even on different cpu. So just clear netif_running().
1077 * dev->stop() will invoke napi_disable() on all of it's
1078 * napi_struct instances on this device.
1080 smp_mb__after_clear_bit(); /* Commit netif_running(). */
1083 * Call the device specific close. This cannot fail.
1084 * Only if device is UP
1086 * We allow it to be called even after a DETACH hot-plug
1093 * Device is now down.
1096 dev->flags &= ~IFF_UP;
1099 * Tell people we are down
1101 call_netdevice_notifiers(NETDEV_DOWN, dev);
1107 static int dev_boot_phase = 1;
1110 * Device change register/unregister. These are not inline or static
1111 * as we export them to the world.
1115 * register_netdevice_notifier - register a network notifier block
1118 * Register a notifier to be called when network device events occur.
1119 * The notifier passed is linked into the kernel structures and must
1120 * not be reused until it has been unregistered. A negative errno code
1121 * is returned on a failure.
1123 * When registered all registration and up events are replayed
1124 * to the new notifier to allow device to have a race free
1125 * view of the network device list.
1128 int register_netdevice_notifier(struct notifier_block *nb)
1130 struct net_device *dev;
1131 struct net_device *last;
1136 err = raw_notifier_chain_register(&netdev_chain, nb);
1142 for_each_netdev(net, dev) {
1143 err = nb->notifier_call(nb, NETDEV_REGISTER, dev);
1144 err = notifier_to_errno(err);
1148 if (!(dev->flags & IFF_UP))
1151 nb->notifier_call(nb, NETDEV_UP, dev);
1162 for_each_netdev(net, dev) {
1166 if (dev->flags & IFF_UP) {
1167 nb->notifier_call(nb, NETDEV_GOING_DOWN, dev);
1168 nb->notifier_call(nb, NETDEV_DOWN, dev);
1170 nb->notifier_call(nb, NETDEV_UNREGISTER, dev);
1177 * unregister_netdevice_notifier - unregister a network notifier block
1180 * Unregister a notifier previously registered by
1181 * register_netdevice_notifier(). The notifier is unlinked into the
1182 * kernel structures and may then be reused. A negative errno code
1183 * is returned on a failure.
1186 int unregister_netdevice_notifier(struct notifier_block *nb)
1191 err = raw_notifier_chain_unregister(&netdev_chain, nb);
1197 * call_netdevice_notifiers - call all network notifier blocks
1198 * @val: value passed unmodified to notifier function
1199 * @dev: net_device pointer passed unmodified to notifier function
1201 * Call all network notifier blocks. Parameters and return value
1202 * are as for raw_notifier_call_chain().
1205 int call_netdevice_notifiers(unsigned long val, struct net_device *dev)
1207 return raw_notifier_call_chain(&netdev_chain, val, dev);
1210 /* When > 0 there are consumers of rx skb time stamps */
1211 static atomic_t netstamp_needed = ATOMIC_INIT(0);
1213 void net_enable_timestamp(void)
1215 atomic_inc(&netstamp_needed);
1218 void net_disable_timestamp(void)
1220 atomic_dec(&netstamp_needed);
1223 static inline void net_timestamp(struct sk_buff *skb)
1225 if (atomic_read(&netstamp_needed))
1226 __net_timestamp(skb);
1228 skb->tstamp.tv64 = 0;
1232 * Support routine. Sends outgoing frames to any network
1233 * taps currently in use.
1236 static void dev_queue_xmit_nit(struct sk_buff *skb, struct net_device *dev)
1238 struct packet_type *ptype;
1243 list_for_each_entry_rcu(ptype, &ptype_all, list) {
1244 /* Never send packets back to the socket
1245 * they originated from - MvS (miquels@drinkel.ow.org)
1247 if ((ptype->dev == dev || !ptype->dev) &&
1248 (ptype->af_packet_priv == NULL ||
1249 (struct sock *)ptype->af_packet_priv != skb->sk)) {
1250 struct sk_buff *skb2= skb_clone(skb, GFP_ATOMIC);
1254 /* skb->nh should be correctly
1255 set by sender, so that the second statement is
1256 just protection against buggy protocols.
1258 skb_reset_mac_header(skb2);
1260 if (skb_network_header(skb2) < skb2->data ||
1261 skb2->network_header > skb2->tail) {
1262 if (net_ratelimit())
1263 printk(KERN_CRIT "protocol %04x is "
1265 skb2->protocol, dev->name);
1266 skb_reset_network_header(skb2);
1269 skb2->transport_header = skb2->network_header;
1270 skb2->pkt_type = PACKET_OUTGOING;
1271 ptype->func(skb2, skb->dev, ptype, skb->dev);
1278 void __netif_schedule(struct net_device *dev)
1280 if (!test_and_set_bit(__LINK_STATE_SCHED, &dev->state)) {
1281 unsigned long flags;
1282 struct softnet_data *sd;
1284 local_irq_save(flags);
1285 sd = &__get_cpu_var(softnet_data);
1286 dev->next_sched = sd->output_queue;
1287 sd->output_queue = dev;
1288 raise_softirq_irqoff(NET_TX_SOFTIRQ);
1289 local_irq_restore(flags);
1292 EXPORT_SYMBOL(__netif_schedule);
1294 void dev_kfree_skb_irq(struct sk_buff *skb)
1296 if (atomic_dec_and_test(&skb->users)) {
1297 struct softnet_data *sd;
1298 unsigned long flags;
1300 local_irq_save(flags);
1301 sd = &__get_cpu_var(softnet_data);
1302 skb->next = sd->completion_queue;
1303 sd->completion_queue = skb;
1304 raise_softirq_irqoff(NET_TX_SOFTIRQ);
1305 local_irq_restore(flags);
1308 EXPORT_SYMBOL(dev_kfree_skb_irq);
1310 void dev_kfree_skb_any(struct sk_buff *skb)
1312 if (in_irq() || irqs_disabled())
1313 dev_kfree_skb_irq(skb);
1317 EXPORT_SYMBOL(dev_kfree_skb_any);
1321 * netif_device_detach - mark device as removed
1322 * @dev: network device
1324 * Mark device as removed from system and therefore no longer available.
1326 void netif_device_detach(struct net_device *dev)
1328 if (test_and_clear_bit(__LINK_STATE_PRESENT, &dev->state) &&
1329 netif_running(dev)) {
1330 netif_stop_queue(dev);
1333 EXPORT_SYMBOL(netif_device_detach);
1336 * netif_device_attach - mark device as attached
1337 * @dev: network device
1339 * Mark device as attached from system and restart if needed.
1341 void netif_device_attach(struct net_device *dev)
1343 if (!test_and_set_bit(__LINK_STATE_PRESENT, &dev->state) &&
1344 netif_running(dev)) {
1345 netif_wake_queue(dev);
1346 __netdev_watchdog_up(dev);
1349 EXPORT_SYMBOL(netif_device_attach);
1353 * Invalidate hardware checksum when packet is to be mangled, and
1354 * complete checksum manually on outgoing path.
1356 int skb_checksum_help(struct sk_buff *skb)
1359 int ret = 0, offset;
1361 if (skb->ip_summed == CHECKSUM_COMPLETE)
1362 goto out_set_summed;
1364 if (unlikely(skb_shinfo(skb)->gso_size)) {
1365 /* Let GSO fix up the checksum. */
1366 goto out_set_summed;
1369 offset = skb->csum_start - skb_headroom(skb);
1370 BUG_ON(offset >= skb_headlen(skb));
1371 csum = skb_checksum(skb, offset, skb->len - offset, 0);
1373 offset += skb->csum_offset;
1374 BUG_ON(offset + sizeof(__sum16) > skb_headlen(skb));
1376 if (skb_cloned(skb) &&
1377 !skb_clone_writable(skb, offset + sizeof(__sum16))) {
1378 ret = pskb_expand_head(skb, 0, 0, GFP_ATOMIC);
1383 *(__sum16 *)(skb->data + offset) = csum_fold(csum);
1385 skb->ip_summed = CHECKSUM_NONE;
1391 * skb_gso_segment - Perform segmentation on skb.
1392 * @skb: buffer to segment
1393 * @features: features for the output path (see dev->features)
1395 * This function segments the given skb and returns a list of segments.
1397 * It may return NULL if the skb requires no segmentation. This is
1398 * only possible when GSO is used for verifying header integrity.
1400 struct sk_buff *skb_gso_segment(struct sk_buff *skb, int features)
1402 struct sk_buff *segs = ERR_PTR(-EPROTONOSUPPORT);
1403 struct packet_type *ptype;
1404 __be16 type = skb->protocol;
1407 BUG_ON(skb_shinfo(skb)->frag_list);
1409 skb_reset_mac_header(skb);
1410 skb->mac_len = skb->network_header - skb->mac_header;
1411 __skb_pull(skb, skb->mac_len);
1413 if (WARN_ON(skb->ip_summed != CHECKSUM_PARTIAL)) {
1414 if (skb_header_cloned(skb) &&
1415 (err = pskb_expand_head(skb, 0, 0, GFP_ATOMIC)))
1416 return ERR_PTR(err);
1420 list_for_each_entry_rcu(ptype, &ptype_base[ntohs(type) & 15], list) {
1421 if (ptype->type == type && !ptype->dev && ptype->gso_segment) {
1422 if (unlikely(skb->ip_summed != CHECKSUM_PARTIAL)) {
1423 err = ptype->gso_send_check(skb);
1424 segs = ERR_PTR(err);
1425 if (err || skb_gso_ok(skb, features))
1427 __skb_push(skb, (skb->data -
1428 skb_network_header(skb)));
1430 segs = ptype->gso_segment(skb, features);
1436 __skb_push(skb, skb->data - skb_mac_header(skb));
1441 EXPORT_SYMBOL(skb_gso_segment);
1443 /* Take action when hardware reception checksum errors are detected. */
1445 void netdev_rx_csum_fault(struct net_device *dev)
1447 if (net_ratelimit()) {
1448 printk(KERN_ERR "%s: hw csum failure.\n",
1449 dev ? dev->name : "<unknown>");
1453 EXPORT_SYMBOL(netdev_rx_csum_fault);
1456 /* Actually, we should eliminate this check as soon as we know, that:
1457 * 1. IOMMU is present and allows to map all the memory.
1458 * 2. No high memory really exists on this machine.
1461 static inline int illegal_highdma(struct net_device *dev, struct sk_buff *skb)
1463 #ifdef CONFIG_HIGHMEM
1466 if (dev->features & NETIF_F_HIGHDMA)
1469 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++)
1470 if (PageHighMem(skb_shinfo(skb)->frags[i].page))
1478 void (*destructor)(struct sk_buff *skb);
1481 #define DEV_GSO_CB(skb) ((struct dev_gso_cb *)(skb)->cb)
1483 static void dev_gso_skb_destructor(struct sk_buff *skb)
1485 struct dev_gso_cb *cb;
1488 struct sk_buff *nskb = skb->next;
1490 skb->next = nskb->next;
1493 } while (skb->next);
1495 cb = DEV_GSO_CB(skb);
1497 cb->destructor(skb);
1501 * dev_gso_segment - Perform emulated hardware segmentation on skb.
1502 * @skb: buffer to segment
1504 * This function segments the given skb and stores the list of segments
1507 static int dev_gso_segment(struct sk_buff *skb)
1509 struct net_device *dev = skb->dev;
1510 struct sk_buff *segs;
1511 int features = dev->features & ~(illegal_highdma(dev, skb) ?
1514 segs = skb_gso_segment(skb, features);
1516 /* Verifying header integrity only. */
1520 if (unlikely(IS_ERR(segs)))
1521 return PTR_ERR(segs);
1524 DEV_GSO_CB(skb)->destructor = skb->destructor;
1525 skb->destructor = dev_gso_skb_destructor;
1530 int dev_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
1532 if (likely(!skb->next)) {
1533 if (!list_empty(&ptype_all))
1534 dev_queue_xmit_nit(skb, dev);
1536 if (netif_needs_gso(dev, skb)) {
1537 if (unlikely(dev_gso_segment(skb)))
1543 return dev->hard_start_xmit(skb, dev);
1548 struct sk_buff *nskb = skb->next;
1551 skb->next = nskb->next;
1553 rc = dev->hard_start_xmit(nskb, dev);
1555 nskb->next = skb->next;
1559 if (unlikely((netif_queue_stopped(dev) ||
1560 netif_subqueue_stopped(dev, skb)) &&
1562 return NETDEV_TX_BUSY;
1563 } while (skb->next);
1565 skb->destructor = DEV_GSO_CB(skb)->destructor;
1573 * dev_queue_xmit - transmit a buffer
1574 * @skb: buffer to transmit
1576 * Queue a buffer for transmission to a network device. The caller must
1577 * have set the device and priority and built the buffer before calling
1578 * this function. The function can be called from an interrupt.
1580 * A negative errno code is returned on a failure. A success does not
1581 * guarantee the frame will be transmitted as it may be dropped due
1582 * to congestion or traffic shaping.
1584 * -----------------------------------------------------------------------------------
1585 * I notice this method can also return errors from the queue disciplines,
1586 * including NET_XMIT_DROP, which is a positive value. So, errors can also
1589 * Regardless of the return value, the skb is consumed, so it is currently
1590 * difficult to retry a send to this method. (You can bump the ref count
1591 * before sending to hold a reference for retry if you are careful.)
1593 * When calling this method, interrupts MUST be enabled. This is because
1594 * the BH enable code must have IRQs enabled so that it will not deadlock.
1598 int dev_queue_xmit(struct sk_buff *skb)
1600 struct net_device *dev = skb->dev;
1604 /* GSO will handle the following emulations directly. */
1605 if (netif_needs_gso(dev, skb))
1608 if (skb_shinfo(skb)->frag_list &&
1609 !(dev->features & NETIF_F_FRAGLIST) &&
1610 __skb_linearize(skb))
1613 /* Fragmented skb is linearized if device does not support SG,
1614 * or if at least one of fragments is in highmem and device
1615 * does not support DMA from it.
1617 if (skb_shinfo(skb)->nr_frags &&
1618 (!(dev->features & NETIF_F_SG) || illegal_highdma(dev, skb)) &&
1619 __skb_linearize(skb))
1622 /* If packet is not checksummed and device does not support
1623 * checksumming for this protocol, complete checksumming here.
1625 if (skb->ip_summed == CHECKSUM_PARTIAL) {
1626 skb_set_transport_header(skb, skb->csum_start -
1629 if (!(dev->features & NETIF_F_GEN_CSUM) &&
1630 !((dev->features & NETIF_F_IP_CSUM) &&
1631 skb->protocol == htons(ETH_P_IP)) &&
1632 !((dev->features & NETIF_F_IPV6_CSUM) &&
1633 skb->protocol == htons(ETH_P_IPV6)))
1634 if (skb_checksum_help(skb))
1639 spin_lock_prefetch(&dev->queue_lock);
1641 /* Disable soft irqs for various locks below. Also
1642 * stops preemption for RCU.
1646 /* Updates of qdisc are serialized by queue_lock.
1647 * The struct Qdisc which is pointed to by qdisc is now a
1648 * rcu structure - it may be accessed without acquiring
1649 * a lock (but the structure may be stale.) The freeing of the
1650 * qdisc will be deferred until it's known that there are no
1651 * more references to it.
1653 * If the qdisc has an enqueue function, we still need to
1654 * hold the queue_lock before calling it, since queue_lock
1655 * also serializes access to the device queue.
1658 q = rcu_dereference(dev->qdisc);
1659 #ifdef CONFIG_NET_CLS_ACT
1660 skb->tc_verd = SET_TC_AT(skb->tc_verd,AT_EGRESS);
1663 /* Grab device queue */
1664 spin_lock(&dev->queue_lock);
1667 /* reset queue_mapping to zero */
1668 skb_set_queue_mapping(skb, 0);
1669 rc = q->enqueue(skb, q);
1671 spin_unlock(&dev->queue_lock);
1673 rc = rc == NET_XMIT_BYPASS ? NET_XMIT_SUCCESS : rc;
1676 spin_unlock(&dev->queue_lock);
1679 /* The device has no queue. Common case for software devices:
1680 loopback, all the sorts of tunnels...
1682 Really, it is unlikely that netif_tx_lock protection is necessary
1683 here. (f.e. loopback and IP tunnels are clean ignoring statistics
1685 However, it is possible, that they rely on protection
1688 Check this and shot the lock. It is not prone from deadlocks.
1689 Either shot noqueue qdisc, it is even simpler 8)
1691 if (dev->flags & IFF_UP) {
1692 int cpu = smp_processor_id(); /* ok because BHs are off */
1694 if (dev->xmit_lock_owner != cpu) {
1696 HARD_TX_LOCK(dev, cpu);
1698 if (!netif_queue_stopped(dev) &&
1699 !netif_subqueue_stopped(dev, skb)) {
1701 if (!dev_hard_start_xmit(skb, dev)) {
1702 HARD_TX_UNLOCK(dev);
1706 HARD_TX_UNLOCK(dev);
1707 if (net_ratelimit())
1708 printk(KERN_CRIT "Virtual device %s asks to "
1709 "queue packet!\n", dev->name);
1711 /* Recursion is detected! It is possible,
1713 if (net_ratelimit())
1714 printk(KERN_CRIT "Dead loop on virtual device "
1715 "%s, fix it urgently!\n", dev->name);
1720 rcu_read_unlock_bh();
1726 rcu_read_unlock_bh();
1731 /*=======================================================================
1733 =======================================================================*/
1735 int netdev_max_backlog __read_mostly = 1000;
1736 int netdev_budget __read_mostly = 300;
1737 int weight_p __read_mostly = 64; /* old backlog weight */
1739 DEFINE_PER_CPU(struct netif_rx_stats, netdev_rx_stat) = { 0, };
1743 * netif_rx - post buffer to the network code
1744 * @skb: buffer to post
1746 * This function receives a packet from a device driver and queues it for
1747 * the upper (protocol) levels to process. It always succeeds. The buffer
1748 * may be dropped during processing for congestion control or by the
1752 * NET_RX_SUCCESS (no congestion)
1753 * NET_RX_CN_LOW (low congestion)
1754 * NET_RX_CN_MOD (moderate congestion)
1755 * NET_RX_CN_HIGH (high congestion)
1756 * NET_RX_DROP (packet was dropped)
1760 int netif_rx(struct sk_buff *skb)
1762 struct softnet_data *queue;
1763 unsigned long flags;
1765 /* if netpoll wants it, pretend we never saw it */
1766 if (netpoll_rx(skb))
1769 if (!skb->tstamp.tv64)
1773 * The code is rearranged so that the path is the most
1774 * short when CPU is congested, but is still operating.
1776 local_irq_save(flags);
1777 queue = &__get_cpu_var(softnet_data);
1779 __get_cpu_var(netdev_rx_stat).total++;
1780 if (queue->input_pkt_queue.qlen <= netdev_max_backlog) {
1781 if (queue->input_pkt_queue.qlen) {
1784 __skb_queue_tail(&queue->input_pkt_queue, skb);
1785 local_irq_restore(flags);
1786 return NET_RX_SUCCESS;
1789 napi_schedule(&queue->backlog);
1793 __get_cpu_var(netdev_rx_stat).dropped++;
1794 local_irq_restore(flags);
1800 int netif_rx_ni(struct sk_buff *skb)
1805 err = netif_rx(skb);
1806 if (local_softirq_pending())
1813 EXPORT_SYMBOL(netif_rx_ni);
1815 static inline struct net_device *skb_bond(struct sk_buff *skb)
1817 struct net_device *dev = skb->dev;
1820 if (skb_bond_should_drop(skb)) {
1824 skb->dev = dev->master;
1831 static void net_tx_action(struct softirq_action *h)
1833 struct softnet_data *sd = &__get_cpu_var(softnet_data);
1835 if (sd->completion_queue) {
1836 struct sk_buff *clist;
1838 local_irq_disable();
1839 clist = sd->completion_queue;
1840 sd->completion_queue = NULL;
1844 struct sk_buff *skb = clist;
1845 clist = clist->next;
1847 BUG_TRAP(!atomic_read(&skb->users));
1852 if (sd->output_queue) {
1853 struct net_device *head;
1855 local_irq_disable();
1856 head = sd->output_queue;
1857 sd->output_queue = NULL;
1861 struct net_device *dev = head;
1862 head = head->next_sched;
1864 smp_mb__before_clear_bit();
1865 clear_bit(__LINK_STATE_SCHED, &dev->state);
1867 if (spin_trylock(&dev->queue_lock)) {
1869 spin_unlock(&dev->queue_lock);
1871 netif_schedule(dev);
1877 static inline int deliver_skb(struct sk_buff *skb,
1878 struct packet_type *pt_prev,
1879 struct net_device *orig_dev)
1881 atomic_inc(&skb->users);
1882 return pt_prev->func(skb, skb->dev, pt_prev, orig_dev);
1885 #if defined(CONFIG_BRIDGE) || defined (CONFIG_BRIDGE_MODULE)
1886 /* These hooks defined here for ATM */
1888 struct net_bridge_fdb_entry *(*br_fdb_get_hook)(struct net_bridge *br,
1889 unsigned char *addr);
1890 void (*br_fdb_put_hook)(struct net_bridge_fdb_entry *ent) __read_mostly;
1893 * If bridge module is loaded call bridging hook.
1894 * returns NULL if packet was consumed.
1896 struct sk_buff *(*br_handle_frame_hook)(struct net_bridge_port *p,
1897 struct sk_buff *skb) __read_mostly;
1898 static inline struct sk_buff *handle_bridge(struct sk_buff *skb,
1899 struct packet_type **pt_prev, int *ret,
1900 struct net_device *orig_dev)
1902 struct net_bridge_port *port;
1904 if (skb->pkt_type == PACKET_LOOPBACK ||
1905 (port = rcu_dereference(skb->dev->br_port)) == NULL)
1909 *ret = deliver_skb(skb, *pt_prev, orig_dev);
1913 return br_handle_frame_hook(port, skb);
1916 #define handle_bridge(skb, pt_prev, ret, orig_dev) (skb)
1919 #if defined(CONFIG_MACVLAN) || defined(CONFIG_MACVLAN_MODULE)
1920 struct sk_buff *(*macvlan_handle_frame_hook)(struct sk_buff *skb) __read_mostly;
1921 EXPORT_SYMBOL_GPL(macvlan_handle_frame_hook);
1923 static inline struct sk_buff *handle_macvlan(struct sk_buff *skb,
1924 struct packet_type **pt_prev,
1926 struct net_device *orig_dev)
1928 if (skb->dev->macvlan_port == NULL)
1932 *ret = deliver_skb(skb, *pt_prev, orig_dev);
1935 return macvlan_handle_frame_hook(skb);
1938 #define handle_macvlan(skb, pt_prev, ret, orig_dev) (skb)
1941 #ifdef CONFIG_NET_CLS_ACT
1942 /* TODO: Maybe we should just force sch_ingress to be compiled in
1943 * when CONFIG_NET_CLS_ACT is? otherwise some useless instructions
1944 * a compare and 2 stores extra right now if we dont have it on
1945 * but have CONFIG_NET_CLS_ACT
1946 * NOTE: This doesnt stop any functionality; if you dont have
1947 * the ingress scheduler, you just cant add policies on ingress.
1950 static int ing_filter(struct sk_buff *skb)
1953 struct net_device *dev = skb->dev;
1954 int result = TC_ACT_OK;
1955 u32 ttl = G_TC_RTTL(skb->tc_verd);
1957 if (MAX_RED_LOOP < ttl++) {
1959 "Redir loop detected Dropping packet (%d->%d)\n",
1960 skb->iif, dev->ifindex);
1964 skb->tc_verd = SET_TC_RTTL(skb->tc_verd, ttl);
1965 skb->tc_verd = SET_TC_AT(skb->tc_verd, AT_INGRESS);
1967 spin_lock(&dev->ingress_lock);
1968 if ((q = dev->qdisc_ingress) != NULL)
1969 result = q->enqueue(skb, q);
1970 spin_unlock(&dev->ingress_lock);
1975 static inline struct sk_buff *handle_ing(struct sk_buff *skb,
1976 struct packet_type **pt_prev,
1977 int *ret, struct net_device *orig_dev)
1979 if (!skb->dev->qdisc_ingress)
1983 *ret = deliver_skb(skb, *pt_prev, orig_dev);
1986 /* Huh? Why does turning on AF_PACKET affect this? */
1987 skb->tc_verd = SET_TC_OK2MUNGE(skb->tc_verd);
1990 switch (ing_filter(skb)) {
2003 int netif_receive_skb(struct sk_buff *skb)
2005 struct packet_type *ptype, *pt_prev;
2006 struct net_device *orig_dev;
2007 int ret = NET_RX_DROP;
2010 /* if we've gotten here through NAPI, check netpoll */
2011 if (netpoll_receive_skb(skb))
2014 if (!skb->tstamp.tv64)
2018 skb->iif = skb->dev->ifindex;
2020 orig_dev = skb_bond(skb);
2025 __get_cpu_var(netdev_rx_stat).total++;
2027 skb_reset_network_header(skb);
2028 skb_reset_transport_header(skb);
2029 skb->mac_len = skb->network_header - skb->mac_header;
2035 #ifdef CONFIG_NET_CLS_ACT
2036 if (skb->tc_verd & TC_NCLS) {
2037 skb->tc_verd = CLR_TC_NCLS(skb->tc_verd);
2042 list_for_each_entry_rcu(ptype, &ptype_all, list) {
2043 if (!ptype->dev || ptype->dev == skb->dev) {
2045 ret = deliver_skb(skb, pt_prev, orig_dev);
2050 #ifdef CONFIG_NET_CLS_ACT
2051 skb = handle_ing(skb, &pt_prev, &ret, orig_dev);
2057 skb = handle_bridge(skb, &pt_prev, &ret, orig_dev);
2060 skb = handle_macvlan(skb, &pt_prev, &ret, orig_dev);
2064 type = skb->protocol;
2065 list_for_each_entry_rcu(ptype, &ptype_base[ntohs(type)&15], list) {
2066 if (ptype->type == type &&
2067 (!ptype->dev || ptype->dev == skb->dev)) {
2069 ret = deliver_skb(skb, pt_prev, orig_dev);
2075 ret = pt_prev->func(skb, skb->dev, pt_prev, orig_dev);
2078 /* Jamal, now you will not able to escape explaining
2079 * me how you were going to use this. :-)
2089 static int process_backlog(struct napi_struct *napi, int quota)
2092 struct softnet_data *queue = &__get_cpu_var(softnet_data);
2093 unsigned long start_time = jiffies;
2095 napi->weight = weight_p;
2097 struct sk_buff *skb;
2098 struct net_device *dev;
2100 local_irq_disable();
2101 skb = __skb_dequeue(&queue->input_pkt_queue);
2103 __napi_complete(napi);
2112 netif_receive_skb(skb);
2115 } while (++work < quota && jiffies == start_time);
2121 * __napi_schedule - schedule for receive
2122 * @n: entry to schedule
2124 * The entry's receive function will be scheduled to run
2126 void fastcall __napi_schedule(struct napi_struct *n)
2128 unsigned long flags;
2130 local_irq_save(flags);
2131 list_add_tail(&n->poll_list, &__get_cpu_var(softnet_data).poll_list);
2132 __raise_softirq_irqoff(NET_RX_SOFTIRQ);
2133 local_irq_restore(flags);
2135 EXPORT_SYMBOL(__napi_schedule);
2138 static void net_rx_action(struct softirq_action *h)
2140 struct list_head *list = &__get_cpu_var(softnet_data).poll_list;
2141 unsigned long start_time = jiffies;
2142 int budget = netdev_budget;
2145 local_irq_disable();
2147 while (!list_empty(list)) {
2148 struct napi_struct *n;
2151 /* If softirq window is exhuasted then punt.
2153 * Note that this is a slight policy change from the
2154 * previous NAPI code, which would allow up to 2
2155 * jiffies to pass before breaking out. The test
2156 * used to be "jiffies - start_time > 1".
2158 if (unlikely(budget <= 0 || jiffies != start_time))
2163 /* Even though interrupts have been re-enabled, this
2164 * access is safe because interrupts can only add new
2165 * entries to the tail of this list, and only ->poll()
2166 * calls can remove this head entry from the list.
2168 n = list_entry(list->next, struct napi_struct, poll_list);
2170 have = netpoll_poll_lock(n);
2174 work = n->poll(n, weight);
2176 WARN_ON_ONCE(work > weight);
2180 local_irq_disable();
2182 /* Drivers must not modify the NAPI state if they
2183 * consume the entire weight. In such cases this code
2184 * still "owns" the NAPI instance and therefore can
2185 * move the instance around on the list at-will.
2187 if (unlikely(work == weight))
2188 list_move_tail(&n->poll_list, list);
2190 netpoll_poll_unlock(have);
2195 #ifdef CONFIG_NET_DMA
2197 * There may not be any more sk_buffs coming right now, so push
2198 * any pending DMA copies to hardware
2200 if (!cpus_empty(net_dma.channel_mask)) {
2202 for_each_cpu_mask(chan_idx, net_dma.channel_mask) {
2203 struct dma_chan *chan = net_dma.channels[chan_idx];
2205 dma_async_memcpy_issue_pending(chan);
2213 __get_cpu_var(netdev_rx_stat).time_squeeze++;
2214 __raise_softirq_irqoff(NET_RX_SOFTIRQ);
2218 static gifconf_func_t * gifconf_list [NPROTO];
2221 * register_gifconf - register a SIOCGIF handler
2222 * @family: Address family
2223 * @gifconf: Function handler
2225 * Register protocol dependent address dumping routines. The handler
2226 * that is passed must not be freed or reused until it has been replaced
2227 * by another handler.
2229 int register_gifconf(unsigned int family, gifconf_func_t * gifconf)
2231 if (family >= NPROTO)
2233 gifconf_list[family] = gifconf;
2239 * Map an interface index to its name (SIOCGIFNAME)
2243 * We need this ioctl for efficient implementation of the
2244 * if_indextoname() function required by the IPv6 API. Without
2245 * it, we would have to search all the interfaces to find a
2249 static int dev_ifname(struct net *net, struct ifreq __user *arg)
2251 struct net_device *dev;
2255 * Fetch the caller's info block.
2258 if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
2261 read_lock(&dev_base_lock);
2262 dev = __dev_get_by_index(net, ifr.ifr_ifindex);
2264 read_unlock(&dev_base_lock);
2268 strcpy(ifr.ifr_name, dev->name);
2269 read_unlock(&dev_base_lock);
2271 if (copy_to_user(arg, &ifr, sizeof(struct ifreq)))
2277 * Perform a SIOCGIFCONF call. This structure will change
2278 * size eventually, and there is nothing I can do about it.
2279 * Thus we will need a 'compatibility mode'.
2282 static int dev_ifconf(struct net *net, char __user *arg)
2285 struct net_device *dev;
2292 * Fetch the caller's info block.
2295 if (copy_from_user(&ifc, arg, sizeof(struct ifconf)))
2302 * Loop over the interfaces, and write an info block for each.
2306 for_each_netdev(net, dev) {
2307 for (i = 0; i < NPROTO; i++) {
2308 if (gifconf_list[i]) {
2311 done = gifconf_list[i](dev, NULL, 0);
2313 done = gifconf_list[i](dev, pos + total,
2323 * All done. Write the updated control block back to the caller.
2325 ifc.ifc_len = total;
2328 * Both BSD and Solaris return 0 here, so we do too.
2330 return copy_to_user(arg, &ifc, sizeof(struct ifconf)) ? -EFAULT : 0;
2333 #ifdef CONFIG_PROC_FS
2335 * This is invoked by the /proc filesystem handler to display a device
2338 void *dev_seq_start(struct seq_file *seq, loff_t *pos)
2340 struct net *net = seq->private;
2342 struct net_device *dev;
2344 read_lock(&dev_base_lock);
2346 return SEQ_START_TOKEN;
2349 for_each_netdev(net, dev)
2356 void *dev_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2358 struct net *net = seq->private;
2360 return v == SEQ_START_TOKEN ?
2361 first_net_device(net) : next_net_device((struct net_device *)v);
2364 void dev_seq_stop(struct seq_file *seq, void *v)
2366 read_unlock(&dev_base_lock);
2369 static void dev_seq_printf_stats(struct seq_file *seq, struct net_device *dev)
2371 struct net_device_stats *stats = dev->get_stats(dev);
2373 seq_printf(seq, "%6s:%8lu %7lu %4lu %4lu %4lu %5lu %10lu %9lu "
2374 "%8lu %7lu %4lu %4lu %4lu %5lu %7lu %10lu\n",
2375 dev->name, stats->rx_bytes, stats->rx_packets,
2377 stats->rx_dropped + stats->rx_missed_errors,
2378 stats->rx_fifo_errors,
2379 stats->rx_length_errors + stats->rx_over_errors +
2380 stats->rx_crc_errors + stats->rx_frame_errors,
2381 stats->rx_compressed, stats->multicast,
2382 stats->tx_bytes, stats->tx_packets,
2383 stats->tx_errors, stats->tx_dropped,
2384 stats->tx_fifo_errors, stats->collisions,
2385 stats->tx_carrier_errors +
2386 stats->tx_aborted_errors +
2387 stats->tx_window_errors +
2388 stats->tx_heartbeat_errors,
2389 stats->tx_compressed);
2393 * Called from the PROCfs module. This now uses the new arbitrary sized
2394 * /proc/net interface to create /proc/net/dev
2396 static int dev_seq_show(struct seq_file *seq, void *v)
2398 if (v == SEQ_START_TOKEN)
2399 seq_puts(seq, "Inter-| Receive "
2401 " face |bytes packets errs drop fifo frame "
2402 "compressed multicast|bytes packets errs "
2403 "drop fifo colls carrier compressed\n");
2405 dev_seq_printf_stats(seq, v);
2409 static struct netif_rx_stats *softnet_get_online(loff_t *pos)
2411 struct netif_rx_stats *rc = NULL;
2413 while (*pos < NR_CPUS)
2414 if (cpu_online(*pos)) {
2415 rc = &per_cpu(netdev_rx_stat, *pos);
2422 static void *softnet_seq_start(struct seq_file *seq, loff_t *pos)
2424 return softnet_get_online(pos);
2427 static void *softnet_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2430 return softnet_get_online(pos);
2433 static void softnet_seq_stop(struct seq_file *seq, void *v)
2437 static int softnet_seq_show(struct seq_file *seq, void *v)
2439 struct netif_rx_stats *s = v;
2441 seq_printf(seq, "%08x %08x %08x %08x %08x %08x %08x %08x %08x\n",
2442 s->total, s->dropped, s->time_squeeze, 0,
2443 0, 0, 0, 0, /* was fastroute */
2448 static const struct seq_operations dev_seq_ops = {
2449 .start = dev_seq_start,
2450 .next = dev_seq_next,
2451 .stop = dev_seq_stop,
2452 .show = dev_seq_show,
2455 static int dev_seq_open(struct inode *inode, struct file *file)
2457 struct seq_file *seq;
2459 res = seq_open(file, &dev_seq_ops);
2461 seq = file->private_data;
2462 seq->private = get_proc_net(inode);
2463 if (!seq->private) {
2464 seq_release(inode, file);
2471 static int dev_seq_release(struct inode *inode, struct file *file)
2473 struct seq_file *seq = file->private_data;
2474 struct net *net = seq->private;
2476 return seq_release(inode, file);
2479 static const struct file_operations dev_seq_fops = {
2480 .owner = THIS_MODULE,
2481 .open = dev_seq_open,
2483 .llseek = seq_lseek,
2484 .release = dev_seq_release,
2487 static const struct seq_operations softnet_seq_ops = {
2488 .start = softnet_seq_start,
2489 .next = softnet_seq_next,
2490 .stop = softnet_seq_stop,
2491 .show = softnet_seq_show,
2494 static int softnet_seq_open(struct inode *inode, struct file *file)
2496 return seq_open(file, &softnet_seq_ops);
2499 static const struct file_operations softnet_seq_fops = {
2500 .owner = THIS_MODULE,
2501 .open = softnet_seq_open,
2503 .llseek = seq_lseek,
2504 .release = seq_release,
2507 static void *ptype_get_idx(loff_t pos)
2509 struct packet_type *pt = NULL;
2513 list_for_each_entry_rcu(pt, &ptype_all, list) {
2519 for (t = 0; t < 16; t++) {
2520 list_for_each_entry_rcu(pt, &ptype_base[t], list) {
2529 static void *ptype_seq_start(struct seq_file *seq, loff_t *pos)
2532 return *pos ? ptype_get_idx(*pos - 1) : SEQ_START_TOKEN;
2535 static void *ptype_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2537 struct packet_type *pt;
2538 struct list_head *nxt;
2542 if (v == SEQ_START_TOKEN)
2543 return ptype_get_idx(0);
2546 nxt = pt->list.next;
2547 if (pt->type == htons(ETH_P_ALL)) {
2548 if (nxt != &ptype_all)
2551 nxt = ptype_base[0].next;
2553 hash = ntohs(pt->type) & 15;
2555 while (nxt == &ptype_base[hash]) {
2558 nxt = ptype_base[hash].next;
2561 return list_entry(nxt, struct packet_type, list);
2564 static void ptype_seq_stop(struct seq_file *seq, void *v)
2569 static void ptype_seq_decode(struct seq_file *seq, void *sym)
2571 #ifdef CONFIG_KALLSYMS
2572 unsigned long offset = 0, symsize;
2573 const char *symname;
2577 symname = kallsyms_lookup((unsigned long)sym, &symsize, &offset,
2584 modname = delim = "";
2585 seq_printf(seq, "%s%s%s%s+0x%lx", delim, modname, delim,
2591 seq_printf(seq, "[%p]", sym);
2594 static int ptype_seq_show(struct seq_file *seq, void *v)
2596 struct packet_type *pt = v;
2598 if (v == SEQ_START_TOKEN)
2599 seq_puts(seq, "Type Device Function\n");
2601 if (pt->type == htons(ETH_P_ALL))
2602 seq_puts(seq, "ALL ");
2604 seq_printf(seq, "%04x", ntohs(pt->type));
2606 seq_printf(seq, " %-8s ",
2607 pt->dev ? pt->dev->name : "");
2608 ptype_seq_decode(seq, pt->func);
2609 seq_putc(seq, '\n');
2615 static const struct seq_operations ptype_seq_ops = {
2616 .start = ptype_seq_start,
2617 .next = ptype_seq_next,
2618 .stop = ptype_seq_stop,
2619 .show = ptype_seq_show,
2622 static int ptype_seq_open(struct inode *inode, struct file *file)
2624 return seq_open(file, &ptype_seq_ops);
2627 static const struct file_operations ptype_seq_fops = {
2628 .owner = THIS_MODULE,
2629 .open = ptype_seq_open,
2631 .llseek = seq_lseek,
2632 .release = seq_release,
2636 static int __net_init dev_proc_net_init(struct net *net)
2640 if (!proc_net_fops_create(net, "dev", S_IRUGO, &dev_seq_fops))
2642 if (!proc_net_fops_create(net, "softnet_stat", S_IRUGO, &softnet_seq_fops))
2644 if (!proc_net_fops_create(net, "ptype", S_IRUGO, &ptype_seq_fops))
2647 if (wext_proc_init(net))
2653 proc_net_remove(net, "ptype");
2655 proc_net_remove(net, "softnet_stat");
2657 proc_net_remove(net, "dev");
2661 static void __net_exit dev_proc_net_exit(struct net *net)
2663 wext_proc_exit(net);
2665 proc_net_remove(net, "ptype");
2666 proc_net_remove(net, "softnet_stat");
2667 proc_net_remove(net, "dev");
2670 static struct pernet_operations __net_initdata dev_proc_ops = {
2671 .init = dev_proc_net_init,
2672 .exit = dev_proc_net_exit,
2675 static int __init dev_proc_init(void)
2677 return register_pernet_subsys(&dev_proc_ops);
2680 #define dev_proc_init() 0
2681 #endif /* CONFIG_PROC_FS */
2685 * netdev_set_master - set up master/slave pair
2686 * @slave: slave device
2687 * @master: new master device
2689 * Changes the master device of the slave. Pass %NULL to break the
2690 * bonding. The caller must hold the RTNL semaphore. On a failure
2691 * a negative errno code is returned. On success the reference counts
2692 * are adjusted, %RTM_NEWLINK is sent to the routing socket and the
2693 * function returns zero.
2695 int netdev_set_master(struct net_device *slave, struct net_device *master)
2697 struct net_device *old = slave->master;
2707 slave->master = master;
2715 slave->flags |= IFF_SLAVE;
2717 slave->flags &= ~IFF_SLAVE;
2719 rtmsg_ifinfo(RTM_NEWLINK, slave, IFF_SLAVE);
2723 static void __dev_set_promiscuity(struct net_device *dev, int inc)
2725 unsigned short old_flags = dev->flags;
2729 if ((dev->promiscuity += inc) == 0)
2730 dev->flags &= ~IFF_PROMISC;
2732 dev->flags |= IFF_PROMISC;
2733 if (dev->flags != old_flags) {
2734 printk(KERN_INFO "device %s %s promiscuous mode\n",
2735 dev->name, (dev->flags & IFF_PROMISC) ? "entered" :
2737 audit_log(current->audit_context, GFP_ATOMIC,
2738 AUDIT_ANOM_PROMISCUOUS,
2739 "dev=%s prom=%d old_prom=%d auid=%u",
2740 dev->name, (dev->flags & IFF_PROMISC),
2741 (old_flags & IFF_PROMISC),
2742 audit_get_loginuid(current->audit_context));
2744 if (dev->change_rx_flags)
2745 dev->change_rx_flags(dev, IFF_PROMISC);
2750 * dev_set_promiscuity - update promiscuity count on a device
2754 * Add or remove promiscuity from a device. While the count in the device
2755 * remains above zero the interface remains promiscuous. Once it hits zero
2756 * the device reverts back to normal filtering operation. A negative inc
2757 * value is used to drop promiscuity on the device.
2759 void dev_set_promiscuity(struct net_device *dev, int inc)
2761 unsigned short old_flags = dev->flags;
2763 __dev_set_promiscuity(dev, inc);
2764 if (dev->flags != old_flags)
2765 dev_set_rx_mode(dev);
2769 * dev_set_allmulti - update allmulti count on a device
2773 * Add or remove reception of all multicast frames to a device. While the
2774 * count in the device remains above zero the interface remains listening
2775 * to all interfaces. Once it hits zero the device reverts back to normal
2776 * filtering operation. A negative @inc value is used to drop the counter
2777 * when releasing a resource needing all multicasts.
2780 void dev_set_allmulti(struct net_device *dev, int inc)
2782 unsigned short old_flags = dev->flags;
2786 dev->flags |= IFF_ALLMULTI;
2787 if ((dev->allmulti += inc) == 0)
2788 dev->flags &= ~IFF_ALLMULTI;
2789 if (dev->flags ^ old_flags) {
2790 if (dev->change_rx_flags)
2791 dev->change_rx_flags(dev, IFF_ALLMULTI);
2792 dev_set_rx_mode(dev);
2797 * Upload unicast and multicast address lists to device and
2798 * configure RX filtering. When the device doesn't support unicast
2799 * filtering it is put in promiscous mode while unicast addresses
2802 void __dev_set_rx_mode(struct net_device *dev)
2804 /* dev_open will call this function so the list will stay sane. */
2805 if (!(dev->flags&IFF_UP))
2808 if (!netif_device_present(dev))
2811 if (dev->set_rx_mode)
2812 dev->set_rx_mode(dev);
2814 /* Unicast addresses changes may only happen under the rtnl,
2815 * therefore calling __dev_set_promiscuity here is safe.
2817 if (dev->uc_count > 0 && !dev->uc_promisc) {
2818 __dev_set_promiscuity(dev, 1);
2819 dev->uc_promisc = 1;
2820 } else if (dev->uc_count == 0 && dev->uc_promisc) {
2821 __dev_set_promiscuity(dev, -1);
2822 dev->uc_promisc = 0;
2825 if (dev->set_multicast_list)
2826 dev->set_multicast_list(dev);
2830 void dev_set_rx_mode(struct net_device *dev)
2832 netif_tx_lock_bh(dev);
2833 __dev_set_rx_mode(dev);
2834 netif_tx_unlock_bh(dev);
2837 int __dev_addr_delete(struct dev_addr_list **list, int *count,
2838 void *addr, int alen, int glbl)
2840 struct dev_addr_list *da;
2842 for (; (da = *list) != NULL; list = &da->next) {
2843 if (memcmp(da->da_addr, addr, da->da_addrlen) == 0 &&
2844 alen == da->da_addrlen) {
2846 int old_glbl = da->da_gusers;
2863 int __dev_addr_add(struct dev_addr_list **list, int *count,
2864 void *addr, int alen, int glbl)
2866 struct dev_addr_list *da;
2868 for (da = *list; da != NULL; da = da->next) {
2869 if (memcmp(da->da_addr, addr, da->da_addrlen) == 0 &&
2870 da->da_addrlen == alen) {
2872 int old_glbl = da->da_gusers;
2882 da = kmalloc(sizeof(*da), GFP_ATOMIC);
2885 memcpy(da->da_addr, addr, alen);
2886 da->da_addrlen = alen;
2888 da->da_gusers = glbl ? 1 : 0;
2896 * dev_unicast_delete - Release secondary unicast address.
2898 * @addr: address to delete
2899 * @alen: length of @addr
2901 * Release reference to a secondary unicast address and remove it
2902 * from the device if the reference count drops to zero.
2904 * The caller must hold the rtnl_mutex.
2906 int dev_unicast_delete(struct net_device *dev, void *addr, int alen)
2912 netif_tx_lock_bh(dev);
2913 err = __dev_addr_delete(&dev->uc_list, &dev->uc_count, addr, alen, 0);
2915 __dev_set_rx_mode(dev);
2916 netif_tx_unlock_bh(dev);
2919 EXPORT_SYMBOL(dev_unicast_delete);
2922 * dev_unicast_add - add a secondary unicast address
2924 * @addr: address to delete
2925 * @alen: length of @addr
2927 * Add a secondary unicast address to the device or increase
2928 * the reference count if it already exists.
2930 * The caller must hold the rtnl_mutex.
2932 int dev_unicast_add(struct net_device *dev, void *addr, int alen)
2938 netif_tx_lock_bh(dev);
2939 err = __dev_addr_add(&dev->uc_list, &dev->uc_count, addr, alen, 0);
2941 __dev_set_rx_mode(dev);
2942 netif_tx_unlock_bh(dev);
2945 EXPORT_SYMBOL(dev_unicast_add);
2947 static void __dev_addr_discard(struct dev_addr_list **list)
2949 struct dev_addr_list *tmp;
2951 while (*list != NULL) {
2954 if (tmp->da_users > tmp->da_gusers)
2955 printk("__dev_addr_discard: address leakage! "
2956 "da_users=%d\n", tmp->da_users);
2961 static void dev_addr_discard(struct net_device *dev)
2963 netif_tx_lock_bh(dev);
2965 __dev_addr_discard(&dev->uc_list);
2968 __dev_addr_discard(&dev->mc_list);
2971 netif_tx_unlock_bh(dev);
2974 unsigned dev_get_flags(const struct net_device *dev)
2978 flags = (dev->flags & ~(IFF_PROMISC |
2983 (dev->gflags & (IFF_PROMISC |
2986 if (netif_running(dev)) {
2987 if (netif_oper_up(dev))
2988 flags |= IFF_RUNNING;
2989 if (netif_carrier_ok(dev))
2990 flags |= IFF_LOWER_UP;
2991 if (netif_dormant(dev))
2992 flags |= IFF_DORMANT;
2998 int dev_change_flags(struct net_device *dev, unsigned flags)
3001 int old_flags = dev->flags;
3006 * Set the flags on our device.
3009 dev->flags = (flags & (IFF_DEBUG | IFF_NOTRAILERS | IFF_NOARP |
3010 IFF_DYNAMIC | IFF_MULTICAST | IFF_PORTSEL |
3012 (dev->flags & (IFF_UP | IFF_VOLATILE | IFF_PROMISC |
3016 * Load in the correct multicast list now the flags have changed.
3019 if (dev->change_rx_flags && (dev->flags ^ flags) & IFF_MULTICAST)
3020 dev->change_rx_flags(dev, IFF_MULTICAST);
3022 dev_set_rx_mode(dev);
3025 * Have we downed the interface. We handle IFF_UP ourselves
3026 * according to user attempts to set it, rather than blindly
3031 if ((old_flags ^ flags) & IFF_UP) { /* Bit is different ? */
3032 ret = ((old_flags & IFF_UP) ? dev_close : dev_open)(dev);
3035 dev_set_rx_mode(dev);
3038 if (dev->flags & IFF_UP &&
3039 ((old_flags ^ dev->flags) &~ (IFF_UP | IFF_PROMISC | IFF_ALLMULTI |
3041 call_netdevice_notifiers(NETDEV_CHANGE, dev);
3043 if ((flags ^ dev->gflags) & IFF_PROMISC) {
3044 int inc = (flags & IFF_PROMISC) ? +1 : -1;
3045 dev->gflags ^= IFF_PROMISC;
3046 dev_set_promiscuity(dev, inc);
3049 /* NOTE: order of synchronization of IFF_PROMISC and IFF_ALLMULTI
3050 is important. Some (broken) drivers set IFF_PROMISC, when
3051 IFF_ALLMULTI is requested not asking us and not reporting.
3053 if ((flags ^ dev->gflags) & IFF_ALLMULTI) {
3054 int inc = (flags & IFF_ALLMULTI) ? +1 : -1;
3055 dev->gflags ^= IFF_ALLMULTI;
3056 dev_set_allmulti(dev, inc);
3059 /* Exclude state transition flags, already notified */
3060 changes = (old_flags ^ dev->flags) & ~(IFF_UP | IFF_RUNNING);
3062 rtmsg_ifinfo(RTM_NEWLINK, dev, changes);
3067 int dev_set_mtu(struct net_device *dev, int new_mtu)
3071 if (new_mtu == dev->mtu)
3074 /* MTU must be positive. */
3078 if (!netif_device_present(dev))
3082 if (dev->change_mtu)
3083 err = dev->change_mtu(dev, new_mtu);
3086 if (!err && dev->flags & IFF_UP)
3087 call_netdevice_notifiers(NETDEV_CHANGEMTU, dev);
3091 int dev_set_mac_address(struct net_device *dev, struct sockaddr *sa)
3095 if (!dev->set_mac_address)
3097 if (sa->sa_family != dev->type)
3099 if (!netif_device_present(dev))
3101 err = dev->set_mac_address(dev, sa);
3103 call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
3108 * Perform the SIOCxIFxxx calls, inside read_lock(dev_base_lock)
3110 static int dev_ifsioc_locked(struct net *net, struct ifreq *ifr, unsigned int cmd)
3113 struct net_device *dev = __dev_get_by_name(net, ifr->ifr_name);
3119 case SIOCGIFFLAGS: /* Get interface flags */
3120 ifr->ifr_flags = dev_get_flags(dev);
3123 case SIOCGIFMETRIC: /* Get the metric on the interface
3124 (currently unused) */
3125 ifr->ifr_metric = 0;
3128 case SIOCGIFMTU: /* Get the MTU of a device */
3129 ifr->ifr_mtu = dev->mtu;
3134 memset(ifr->ifr_hwaddr.sa_data, 0, sizeof ifr->ifr_hwaddr.sa_data);
3136 memcpy(ifr->ifr_hwaddr.sa_data, dev->dev_addr,
3137 min(sizeof ifr->ifr_hwaddr.sa_data, (size_t) dev->addr_len));
3138 ifr->ifr_hwaddr.sa_family = dev->type;
3146 ifr->ifr_map.mem_start = dev->mem_start;
3147 ifr->ifr_map.mem_end = dev->mem_end;
3148 ifr->ifr_map.base_addr = dev->base_addr;
3149 ifr->ifr_map.irq = dev->irq;
3150 ifr->ifr_map.dma = dev->dma;
3151 ifr->ifr_map.port = dev->if_port;
3155 ifr->ifr_ifindex = dev->ifindex;
3159 ifr->ifr_qlen = dev->tx_queue_len;
3163 /* dev_ioctl() should ensure this case
3175 * Perform the SIOCxIFxxx calls, inside rtnl_lock()
3177 static int dev_ifsioc(struct net *net, struct ifreq *ifr, unsigned int cmd)
3180 struct net_device *dev = __dev_get_by_name(net, ifr->ifr_name);
3186 case SIOCSIFFLAGS: /* Set interface flags */
3187 return dev_change_flags(dev, ifr->ifr_flags);
3189 case SIOCSIFMETRIC: /* Set the metric on the interface
3190 (currently unused) */
3193 case SIOCSIFMTU: /* Set the MTU of a device */
3194 return dev_set_mtu(dev, ifr->ifr_mtu);
3197 return dev_set_mac_address(dev, &ifr->ifr_hwaddr);
3199 case SIOCSIFHWBROADCAST:
3200 if (ifr->ifr_hwaddr.sa_family != dev->type)
3202 memcpy(dev->broadcast, ifr->ifr_hwaddr.sa_data,
3203 min(sizeof ifr->ifr_hwaddr.sa_data, (size_t) dev->addr_len));
3204 call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
3208 if (dev->set_config) {
3209 if (!netif_device_present(dev))
3211 return dev->set_config(dev, &ifr->ifr_map);
3216 if (!dev->set_multicast_list ||
3217 ifr->ifr_hwaddr.sa_family != AF_UNSPEC)
3219 if (!netif_device_present(dev))
3221 return dev_mc_add(dev, ifr->ifr_hwaddr.sa_data,
3225 if (!dev->set_multicast_list ||
3226 ifr->ifr_hwaddr.sa_family != AF_UNSPEC)
3228 if (!netif_device_present(dev))
3230 return dev_mc_delete(dev, ifr->ifr_hwaddr.sa_data,
3234 if (ifr->ifr_qlen < 0)
3236 dev->tx_queue_len = ifr->ifr_qlen;
3240 ifr->ifr_newname[IFNAMSIZ-1] = '\0';
3241 return dev_change_name(dev, ifr->ifr_newname);
3244 * Unknown or private ioctl
3248 if ((cmd >= SIOCDEVPRIVATE &&
3249 cmd <= SIOCDEVPRIVATE + 15) ||
3250 cmd == SIOCBONDENSLAVE ||
3251 cmd == SIOCBONDRELEASE ||
3252 cmd == SIOCBONDSETHWADDR ||
3253 cmd == SIOCBONDSLAVEINFOQUERY ||
3254 cmd == SIOCBONDINFOQUERY ||
3255 cmd == SIOCBONDCHANGEACTIVE ||
3256 cmd == SIOCGMIIPHY ||
3257 cmd == SIOCGMIIREG ||
3258 cmd == SIOCSMIIREG ||
3259 cmd == SIOCBRADDIF ||
3260 cmd == SIOCBRDELIF ||
3261 cmd == SIOCWANDEV) {
3263 if (dev->do_ioctl) {
3264 if (netif_device_present(dev))
3265 err = dev->do_ioctl(dev, ifr,
3278 * This function handles all "interface"-type I/O control requests. The actual
3279 * 'doing' part of this is dev_ifsioc above.
3283 * dev_ioctl - network device ioctl
3284 * @net: the applicable net namespace
3285 * @cmd: command to issue
3286 * @arg: pointer to a struct ifreq in user space
3288 * Issue ioctl functions to devices. This is normally called by the
3289 * user space syscall interfaces but can sometimes be useful for
3290 * other purposes. The return value is the return from the syscall if
3291 * positive or a negative errno code on error.
3294 int dev_ioctl(struct net *net, unsigned int cmd, void __user *arg)
3300 /* One special case: SIOCGIFCONF takes ifconf argument
3301 and requires shared lock, because it sleeps writing
3305 if (cmd == SIOCGIFCONF) {
3307 ret = dev_ifconf(net, (char __user *) arg);
3311 if (cmd == SIOCGIFNAME)
3312 return dev_ifname(net, (struct ifreq __user *)arg);
3314 if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
3317 ifr.ifr_name[IFNAMSIZ-1] = 0;
3319 colon = strchr(ifr.ifr_name, ':');
3324 * See which interface the caller is talking about.
3329 * These ioctl calls:
3330 * - can be done by all.
3331 * - atomic and do not require locking.
3342 dev_load(net, ifr.ifr_name);
3343 read_lock(&dev_base_lock);
3344 ret = dev_ifsioc_locked(net, &ifr, cmd);
3345 read_unlock(&dev_base_lock);
3349 if (copy_to_user(arg, &ifr,
3350 sizeof(struct ifreq)))
3356 dev_load(net, ifr.ifr_name);
3358 ret = dev_ethtool(net, &ifr);
3363 if (copy_to_user(arg, &ifr,
3364 sizeof(struct ifreq)))
3370 * These ioctl calls:
3371 * - require superuser power.
3372 * - require strict serialization.
3378 if (!capable(CAP_NET_ADMIN))
3380 dev_load(net, ifr.ifr_name);
3382 ret = dev_ifsioc(net, &ifr, cmd);
3387 if (copy_to_user(arg, &ifr,
3388 sizeof(struct ifreq)))
3394 * These ioctl calls:
3395 * - require superuser power.
3396 * - require strict serialization.
3397 * - do not return a value
3407 case SIOCSIFHWBROADCAST:
3410 case SIOCBONDENSLAVE:
3411 case SIOCBONDRELEASE:
3412 case SIOCBONDSETHWADDR:
3413 case SIOCBONDCHANGEACTIVE:
3416 if (!capable(CAP_NET_ADMIN))
3419 case SIOCBONDSLAVEINFOQUERY:
3420 case SIOCBONDINFOQUERY:
3421 dev_load(net, ifr.ifr_name);
3423 ret = dev_ifsioc(net, &ifr, cmd);
3428 /* Get the per device memory space. We can add this but
3429 * currently do not support it */
3431 /* Set the per device memory buffer space.
3432 * Not applicable in our case */
3437 * Unknown or private ioctl.
3440 if (cmd == SIOCWANDEV ||
3441 (cmd >= SIOCDEVPRIVATE &&
3442 cmd <= SIOCDEVPRIVATE + 15)) {
3443 dev_load(net, ifr.ifr_name);
3445 ret = dev_ifsioc(net, &ifr, cmd);
3447 if (!ret && copy_to_user(arg, &ifr,
3448 sizeof(struct ifreq)))
3452 /* Take care of Wireless Extensions */
3453 if (cmd >= SIOCIWFIRST && cmd <= SIOCIWLAST)
3454 return wext_handle_ioctl(net, &ifr, cmd, arg);
3461 * dev_new_index - allocate an ifindex
3462 * @net: the applicable net namespace
3464 * Returns a suitable unique value for a new device interface
3465 * number. The caller must hold the rtnl semaphore or the
3466 * dev_base_lock to be sure it remains unique.
3468 static int dev_new_index(struct net *net)
3474 if (!__dev_get_by_index(net, ifindex))
3479 /* Delayed registration/unregisteration */
3480 static DEFINE_SPINLOCK(net_todo_list_lock);
3481 static struct list_head net_todo_list = LIST_HEAD_INIT(net_todo_list);
3483 static void net_set_todo(struct net_device *dev)
3485 spin_lock(&net_todo_list_lock);
3486 list_add_tail(&dev->todo_list, &net_todo_list);
3487 spin_unlock(&net_todo_list_lock);
3491 * register_netdevice - register a network device
3492 * @dev: device to register
3494 * Take a completed network device structure and add it to the kernel
3495 * interfaces. A %NETDEV_REGISTER message is sent to the netdev notifier
3496 * chain. 0 is returned on success. A negative errno code is returned
3497 * on a failure to set up the device, or if the name is a duplicate.
3499 * Callers must hold the rtnl semaphore. You may want
3500 * register_netdev() instead of this.
3503 * The locking appears insufficient to guarantee two parallel registers
3504 * will not get the same name.
3507 int register_netdevice(struct net_device *dev)
3509 struct hlist_head *head;
3510 struct hlist_node *p;
3514 BUG_ON(dev_boot_phase);
3519 /* When net_device's are persistent, this will be fatal. */
3520 BUG_ON(dev->reg_state != NETREG_UNINITIALIZED);
3521 BUG_ON(!dev->nd_net);
3524 spin_lock_init(&dev->queue_lock);
3525 spin_lock_init(&dev->_xmit_lock);
3526 netdev_set_lockdep_class(&dev->_xmit_lock, dev->type);
3527 dev->xmit_lock_owner = -1;
3528 spin_lock_init(&dev->ingress_lock);
3532 /* Init, if this function is available */
3534 ret = dev->init(dev);
3542 if (!dev_valid_name(dev->name)) {
3547 dev->ifindex = dev_new_index(net);
3548 if (dev->iflink == -1)
3549 dev->iflink = dev->ifindex;
3551 /* Check for existence of name */
3552 head = dev_name_hash(net, dev->name);
3553 hlist_for_each(p, head) {
3554 struct net_device *d
3555 = hlist_entry(p, struct net_device, name_hlist);
3556 if (!strncmp(d->name, dev->name, IFNAMSIZ)) {
3562 /* Fix illegal checksum combinations */
3563 if ((dev->features & NETIF_F_HW_CSUM) &&
3564 (dev->features & (NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM))) {
3565 printk(KERN_NOTICE "%s: mixed HW and IP checksum settings.\n",
3567 dev->features &= ~(NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM);
3570 if ((dev->features & NETIF_F_NO_CSUM) &&
3571 (dev->features & (NETIF_F_HW_CSUM|NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM))) {
3572 printk(KERN_NOTICE "%s: mixed no checksumming and other settings.\n",
3574 dev->features &= ~(NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM|NETIF_F_HW_CSUM);
3578 /* Fix illegal SG+CSUM combinations. */
3579 if ((dev->features & NETIF_F_SG) &&
3580 !(dev->features & NETIF_F_ALL_CSUM)) {
3581 printk(KERN_NOTICE "%s: Dropping NETIF_F_SG since no checksum feature.\n",
3583 dev->features &= ~NETIF_F_SG;
3586 /* TSO requires that SG is present as well. */
3587 if ((dev->features & NETIF_F_TSO) &&
3588 !(dev->features & NETIF_F_SG)) {
3589 printk(KERN_NOTICE "%s: Dropping NETIF_F_TSO since no SG feature.\n",
3591 dev->features &= ~NETIF_F_TSO;
3593 if (dev->features & NETIF_F_UFO) {
3594 if (!(dev->features & NETIF_F_HW_CSUM)) {
3595 printk(KERN_ERR "%s: Dropping NETIF_F_UFO since no "
3596 "NETIF_F_HW_CSUM feature.\n",
3598 dev->features &= ~NETIF_F_UFO;
3600 if (!(dev->features & NETIF_F_SG)) {
3601 printk(KERN_ERR "%s: Dropping NETIF_F_UFO since no "
3602 "NETIF_F_SG feature.\n",
3604 dev->features &= ~NETIF_F_UFO;
3608 ret = netdev_register_kobject(dev);
3611 dev->reg_state = NETREG_REGISTERED;
3614 * Default initial state at registry is that the
3615 * device is present.
3618 set_bit(__LINK_STATE_PRESENT, &dev->state);
3620 dev_init_scheduler(dev);
3622 list_netdevice(dev);
3624 /* Notify protocols, that a new device appeared. */
3625 ret = call_netdevice_notifiers(NETDEV_REGISTER, dev);
3626 ret = notifier_to_errno(ret);
3628 unregister_netdevice(dev);
3640 * register_netdev - register a network device
3641 * @dev: device to register
3643 * Take a completed network device structure and add it to the kernel
3644 * interfaces. A %NETDEV_REGISTER message is sent to the netdev notifier
3645 * chain. 0 is returned on success. A negative errno code is returned
3646 * on a failure to set up the device, or if the name is a duplicate.
3648 * This is a wrapper around register_netdevice that takes the rtnl semaphore
3649 * and expands the device name if you passed a format string to
3652 int register_netdev(struct net_device *dev)
3659 * If the name is a format string the caller wants us to do a
3662 if (strchr(dev->name, '%')) {
3663 err = dev_alloc_name(dev, dev->name);
3668 err = register_netdevice(dev);
3673 EXPORT_SYMBOL(register_netdev);
3676 * netdev_wait_allrefs - wait until all references are gone.
3678 * This is called when unregistering network devices.
3680 * Any protocol or device that holds a reference should register
3681 * for netdevice notification, and cleanup and put back the
3682 * reference if they receive an UNREGISTER event.
3683 * We can get stuck here if buggy protocols don't correctly
3686 static void netdev_wait_allrefs(struct net_device *dev)
3688 unsigned long rebroadcast_time, warning_time;
3690 rebroadcast_time = warning_time = jiffies;
3691 while (atomic_read(&dev->refcnt) != 0) {
3692 if (time_after(jiffies, rebroadcast_time + 1 * HZ)) {
3695 /* Rebroadcast unregister notification */
3696 call_netdevice_notifiers(NETDEV_UNREGISTER, dev);
3698 if (test_bit(__LINK_STATE_LINKWATCH_PENDING,
3700 /* We must not have linkwatch events
3701 * pending on unregister. If this
3702 * happens, we simply run the queue
3703 * unscheduled, resulting in a noop
3706 linkwatch_run_queue();
3711 rebroadcast_time = jiffies;
3716 if (time_after(jiffies, warning_time + 10 * HZ)) {
3717 printk(KERN_EMERG "unregister_netdevice: "
3718 "waiting for %s to become free. Usage "
3720 dev->name, atomic_read(&dev->refcnt));
3721 warning_time = jiffies;
3730 * register_netdevice(x1);
3731 * register_netdevice(x2);
3733 * unregister_netdevice(y1);
3734 * unregister_netdevice(y2);
3740 * We are invoked by rtnl_unlock() after it drops the semaphore.
3741 * This allows us to deal with problems:
3742 * 1) We can delete sysfs objects which invoke hotplug
3743 * without deadlocking with linkwatch via keventd.
3744 * 2) Since we run with the RTNL semaphore not held, we can sleep
3745 * safely in order to wait for the netdev refcnt to drop to zero.
3747 static DEFINE_MUTEX(net_todo_run_mutex);
3748 void netdev_run_todo(void)
3750 struct list_head list;
3752 /* Need to guard against multiple cpu's getting out of order. */
3753 mutex_lock(&net_todo_run_mutex);
3755 /* Not safe to do outside the semaphore. We must not return
3756 * until all unregister events invoked by the local processor
3757 * have been completed (either by this todo run, or one on
3760 if (list_empty(&net_todo_list))
3763 /* Snapshot list, allow later requests */
3764 spin_lock(&net_todo_list_lock);
3765 list_replace_init(&net_todo_list, &list);
3766 spin_unlock(&net_todo_list_lock);
3768 while (!list_empty(&list)) {
3769 struct net_device *dev
3770 = list_entry(list.next, struct net_device, todo_list);
3771 list_del(&dev->todo_list);
3773 if (unlikely(dev->reg_state != NETREG_UNREGISTERING)) {
3774 printk(KERN_ERR "network todo '%s' but state %d\n",
3775 dev->name, dev->reg_state);
3780 dev->reg_state = NETREG_UNREGISTERED;
3782 netdev_wait_allrefs(dev);
3785 BUG_ON(atomic_read(&dev->refcnt));
3786 BUG_TRAP(!dev->ip_ptr);
3787 BUG_TRAP(!dev->ip6_ptr);
3788 BUG_TRAP(!dev->dn_ptr);
3790 if (dev->destructor)
3791 dev->destructor(dev);
3793 /* Free network device */
3794 kobject_put(&dev->dev.kobj);
3798 mutex_unlock(&net_todo_run_mutex);
3801 static struct net_device_stats *internal_stats(struct net_device *dev)
3807 * alloc_netdev_mq - allocate network device
3808 * @sizeof_priv: size of private data to allocate space for
3809 * @name: device name format string
3810 * @setup: callback to initialize device
3811 * @queue_count: the number of subqueues to allocate
3813 * Allocates a struct net_device with private data area for driver use
3814 * and performs basic initialization. Also allocates subquue structs
3815 * for each queue on the device at the end of the netdevice.
3817 struct net_device *alloc_netdev_mq(int sizeof_priv, const char *name,
3818 void (*setup)(struct net_device *), unsigned int queue_count)
3821 struct net_device *dev;
3824 BUG_ON(strlen(name) >= sizeof(dev->name));
3826 /* ensure 32-byte alignment of both the device and private area */
3827 alloc_size = (sizeof(*dev) + NETDEV_ALIGN_CONST +
3828 (sizeof(struct net_device_subqueue) * (queue_count - 1))) &
3829 ~NETDEV_ALIGN_CONST;
3830 alloc_size += sizeof_priv + NETDEV_ALIGN_CONST;
3832 p = kzalloc(alloc_size, GFP_KERNEL);
3834 printk(KERN_ERR "alloc_netdev: Unable to allocate device.\n");
3838 dev = (struct net_device *)
3839 (((long)p + NETDEV_ALIGN_CONST) & ~NETDEV_ALIGN_CONST);
3840 dev->padded = (char *)dev - (char *)p;
3841 dev->nd_net = &init_net;
3844 dev->priv = ((char *)dev +
3845 ((sizeof(struct net_device) +
3846 (sizeof(struct net_device_subqueue) *
3847 (queue_count - 1)) + NETDEV_ALIGN_CONST)
3848 & ~NETDEV_ALIGN_CONST));
3851 dev->egress_subqueue_count = queue_count;
3853 dev->get_stats = internal_stats;
3854 netpoll_netdev_init(dev);
3856 strcpy(dev->name, name);
3859 EXPORT_SYMBOL(alloc_netdev_mq);
3862 * free_netdev - free network device
3865 * This function does the last stage of destroying an allocated device
3866 * interface. The reference to the device object is released.
3867 * If this is the last reference then it will be freed.
3869 void free_netdev(struct net_device *dev)
3871 /* Compatibility with error handling in drivers */
3872 if (dev->reg_state == NETREG_UNINITIALIZED) {
3873 kfree((char *)dev - dev->padded);
3877 BUG_ON(dev->reg_state != NETREG_UNREGISTERED);
3878 dev->reg_state = NETREG_RELEASED;
3880 /* will free via device release */
3881 put_device(&dev->dev);
3884 /* Synchronize with packet receive processing. */
3885 void synchronize_net(void)
3892 * unregister_netdevice - remove device from the kernel
3895 * This function shuts down a device interface and removes it
3896 * from the kernel tables. On success 0 is returned, on a failure
3897 * a negative errno code is returned.
3899 * Callers must hold the rtnl semaphore. You may want
3900 * unregister_netdev() instead of this.
3903 void unregister_netdevice(struct net_device *dev)
3905 BUG_ON(dev_boot_phase);
3908 /* Some devices call without registering for initialization unwind. */
3909 if (dev->reg_state == NETREG_UNINITIALIZED) {
3910 printk(KERN_DEBUG "unregister_netdevice: device %s/%p never "
3911 "was registered\n", dev->name, dev);
3917 BUG_ON(dev->reg_state != NETREG_REGISTERED);
3919 /* If device is running, close it first. */
3922 /* And unlink it from device chain. */
3923 unlist_netdevice(dev);
3925 dev->reg_state = NETREG_UNREGISTERING;
3929 /* Shutdown queueing discipline. */
3933 /* Notify protocols, that we are about to destroy
3934 this device. They should clean all the things.
3936 call_netdevice_notifiers(NETDEV_UNREGISTER, dev);
3939 * Flush the unicast and multicast chains
3941 dev_addr_discard(dev);
3946 /* Notifier chain MUST detach us from master device. */
3947 BUG_TRAP(!dev->master);
3949 /* Remove entries from kobject tree */
3950 netdev_unregister_kobject(dev);
3952 /* Finish processing unregister after unlock */
3961 * unregister_netdev - remove device from the kernel
3964 * This function shuts down a device interface and removes it
3965 * from the kernel tables. On success 0 is returned, on a failure
3966 * a negative errno code is returned.
3968 * This is just a wrapper for unregister_netdevice that takes
3969 * the rtnl semaphore. In general you want to use this and not
3970 * unregister_netdevice.
3972 void unregister_netdev(struct net_device *dev)
3975 unregister_netdevice(dev);
3979 EXPORT_SYMBOL(unregister_netdev);
3982 * dev_change_net_namespace - move device to different nethost namespace
3984 * @net: network namespace
3985 * @pat: If not NULL name pattern to try if the current device name
3986 * is already taken in the destination network namespace.
3988 * This function shuts down a device interface and moves it
3989 * to a new network namespace. On success 0 is returned, on
3990 * a failure a netagive errno code is returned.
3992 * Callers must hold the rtnl semaphore.
3995 int dev_change_net_namespace(struct net_device *dev, struct net *net, const char *pat)
3998 const char *destname;
4003 /* Don't allow namespace local devices to be moved. */
4005 if (dev->features & NETIF_F_NETNS_LOCAL)
4008 /* Ensure the device has been registrered */
4010 if (dev->reg_state != NETREG_REGISTERED)
4013 /* Get out if there is nothing todo */
4015 if (dev->nd_net == net)
4018 /* Pick the destination device name, and ensure
4019 * we can use it in the destination network namespace.
4022 destname = dev->name;
4023 if (__dev_get_by_name(net, destname)) {
4024 /* We get here if we can't use the current device name */
4027 if (!dev_valid_name(pat))
4029 if (strchr(pat, '%')) {
4030 if (__dev_alloc_name(net, pat, buf) < 0)
4035 if (__dev_get_by_name(net, destname))
4040 * And now a mini version of register_netdevice unregister_netdevice.
4043 /* If device is running close it first. */
4046 /* And unlink it from device chain */
4048 unlist_netdevice(dev);
4052 /* Shutdown queueing discipline. */
4055 /* Notify protocols, that we are about to destroy
4056 this device. They should clean all the things.
4058 call_netdevice_notifiers(NETDEV_UNREGISTER, dev);
4061 * Flush the unicast and multicast chains
4063 dev_addr_discard(dev);
4065 /* Actually switch the network namespace */
4068 /* Assign the new device name */
4069 if (destname != dev->name)
4070 strcpy(dev->name, destname);
4072 /* If there is an ifindex conflict assign a new one */
4073 if (__dev_get_by_index(net, dev->ifindex)) {
4074 int iflink = (dev->iflink == dev->ifindex);
4075 dev->ifindex = dev_new_index(net);
4077 dev->iflink = dev->ifindex;
4080 /* Fixup kobjects */
4081 err = device_rename(&dev->dev, dev->name);
4084 /* Add the device back in the hashes */
4085 list_netdevice(dev);
4087 /* Notify protocols, that a new device appeared. */
4088 call_netdevice_notifiers(NETDEV_REGISTER, dev);
4096 static int dev_cpu_callback(struct notifier_block *nfb,
4097 unsigned long action,
4100 struct sk_buff **list_skb;
4101 struct net_device **list_net;
4102 struct sk_buff *skb;
4103 unsigned int cpu, oldcpu = (unsigned long)ocpu;
4104 struct softnet_data *sd, *oldsd;
4106 if (action != CPU_DEAD && action != CPU_DEAD_FROZEN)
4109 local_irq_disable();
4110 cpu = smp_processor_id();
4111 sd = &per_cpu(softnet_data, cpu);
4112 oldsd = &per_cpu(softnet_data, oldcpu);
4114 /* Find end of our completion_queue. */
4115 list_skb = &sd->completion_queue;
4117 list_skb = &(*list_skb)->next;
4118 /* Append completion queue from offline CPU. */
4119 *list_skb = oldsd->completion_queue;
4120 oldsd->completion_queue = NULL;
4122 /* Find end of our output_queue. */
4123 list_net = &sd->output_queue;
4125 list_net = &(*list_net)->next_sched;
4126 /* Append output queue from offline CPU. */
4127 *list_net = oldsd->output_queue;
4128 oldsd->output_queue = NULL;
4130 raise_softirq_irqoff(NET_TX_SOFTIRQ);
4133 /* Process offline CPU's input_pkt_queue */
4134 while ((skb = __skb_dequeue(&oldsd->input_pkt_queue)))
4140 #ifdef CONFIG_NET_DMA
4142 * net_dma_rebalance - try to maintain one DMA channel per CPU
4143 * @net_dma: DMA client and associated data (lock, channels, channel_mask)
4145 * This is called when the number of channels allocated to the net_dma client
4146 * changes. The net_dma client tries to have one DMA channel per CPU.
4149 static void net_dma_rebalance(struct net_dma *net_dma)
4151 unsigned int cpu, i, n, chan_idx;
4152 struct dma_chan *chan;
4154 if (cpus_empty(net_dma->channel_mask)) {
4155 for_each_online_cpu(cpu)
4156 rcu_assign_pointer(per_cpu(softnet_data, cpu).net_dma, NULL);
4161 cpu = first_cpu(cpu_online_map);
4163 for_each_cpu_mask(chan_idx, net_dma->channel_mask) {
4164 chan = net_dma->channels[chan_idx];
4166 n = ((num_online_cpus() / cpus_weight(net_dma->channel_mask))
4167 + (i < (num_online_cpus() %
4168 cpus_weight(net_dma->channel_mask)) ? 1 : 0));
4171 per_cpu(softnet_data, cpu).net_dma = chan;
4172 cpu = next_cpu(cpu, cpu_online_map);
4180 * netdev_dma_event - event callback for the net_dma_client
4181 * @client: should always be net_dma_client
4182 * @chan: DMA channel for the event
4183 * @state: DMA state to be handled
4185 static enum dma_state_client
4186 netdev_dma_event(struct dma_client *client, struct dma_chan *chan,
4187 enum dma_state state)
4189 int i, found = 0, pos = -1;
4190 struct net_dma *net_dma =
4191 container_of(client, struct net_dma, client);
4192 enum dma_state_client ack = DMA_DUP; /* default: take no action */
4194 spin_lock(&net_dma->lock);
4196 case DMA_RESOURCE_AVAILABLE:
4197 for (i = 0; i < NR_CPUS; i++)
4198 if (net_dma->channels[i] == chan) {
4201 } else if (net_dma->channels[i] == NULL && pos < 0)
4204 if (!found && pos >= 0) {
4206 net_dma->channels[pos] = chan;
4207 cpu_set(pos, net_dma->channel_mask);
4208 net_dma_rebalance(net_dma);
4211 case DMA_RESOURCE_REMOVED:
4212 for (i = 0; i < NR_CPUS; i++)
4213 if (net_dma->channels[i] == chan) {
4221 cpu_clear(pos, net_dma->channel_mask);
4222 net_dma->channels[i] = NULL;
4223 net_dma_rebalance(net_dma);
4229 spin_unlock(&net_dma->lock);
4235 * netdev_dma_regiser - register the networking subsystem as a DMA client
4237 static int __init netdev_dma_register(void)
4239 spin_lock_init(&net_dma.lock);
4240 dma_cap_set(DMA_MEMCPY, net_dma.client.cap_mask);
4241 dma_async_client_register(&net_dma.client);
4242 dma_async_client_chan_request(&net_dma.client);
4247 static int __init netdev_dma_register(void) { return -ENODEV; }
4248 #endif /* CONFIG_NET_DMA */
4251 * netdev_compute_feature - compute conjunction of two feature sets
4252 * @all: first feature set
4253 * @one: second feature set
4255 * Computes a new feature set after adding a device with feature set
4256 * @one to the master device with current feature set @all. Returns
4257 * the new feature set.
4259 int netdev_compute_features(unsigned long all, unsigned long one)
4261 /* if device needs checksumming, downgrade to hw checksumming */
4262 if (all & NETIF_F_NO_CSUM && !(one & NETIF_F_NO_CSUM))
4263 all ^= NETIF_F_NO_CSUM | NETIF_F_HW_CSUM;
4265 /* if device can't do all checksum, downgrade to ipv4/ipv6 */
4266 if (all & NETIF_F_HW_CSUM && !(one & NETIF_F_HW_CSUM))
4267 all ^= NETIF_F_HW_CSUM
4268 | NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM;
4270 if (one & NETIF_F_GSO)
4271 one |= NETIF_F_GSO_SOFTWARE;
4274 /* If even one device supports robust GSO, enable it for all. */
4275 if (one & NETIF_F_GSO_ROBUST)
4276 all |= NETIF_F_GSO_ROBUST;
4278 all &= one | NETIF_F_LLTX;
4280 if (!(all & NETIF_F_ALL_CSUM))
4282 if (!(all & NETIF_F_SG))
4283 all &= ~NETIF_F_GSO_MASK;
4287 EXPORT_SYMBOL(netdev_compute_features);
4289 static struct hlist_head *netdev_create_hash(void)
4292 struct hlist_head *hash;
4294 hash = kmalloc(sizeof(*hash) * NETDEV_HASHENTRIES, GFP_KERNEL);
4296 for (i = 0; i < NETDEV_HASHENTRIES; i++)
4297 INIT_HLIST_HEAD(&hash[i]);
4302 /* Initialize per network namespace state */
4303 static int __net_init netdev_init(struct net *net)
4305 INIT_LIST_HEAD(&net->dev_base_head);
4306 rwlock_init(&dev_base_lock);
4308 net->dev_name_head = netdev_create_hash();
4309 if (net->dev_name_head == NULL)
4312 net->dev_index_head = netdev_create_hash();
4313 if (net->dev_index_head == NULL)
4319 kfree(net->dev_name_head);
4324 static void __net_exit netdev_exit(struct net *net)
4326 kfree(net->dev_name_head);
4327 kfree(net->dev_index_head);
4330 static struct pernet_operations __net_initdata netdev_net_ops = {
4331 .init = netdev_init,
4332 .exit = netdev_exit,
4335 static void __net_exit default_device_exit(struct net *net)
4337 struct net_device *dev, *next;
4339 * Push all migratable of the network devices back to the
4340 * initial network namespace
4343 for_each_netdev_safe(net, dev, next) {
4346 /* Ignore unmoveable devices (i.e. loopback) */
4347 if (dev->features & NETIF_F_NETNS_LOCAL)
4350 /* Push remaing network devices to init_net */
4351 err = dev_change_net_namespace(dev, &init_net, "dev%d");
4353 printk(KERN_WARNING "%s: failed to move %s to init_net: %d\n",
4354 __func__, dev->name, err);
4355 unregister_netdevice(dev);
4361 static struct pernet_operations __net_initdata default_device_ops = {
4362 .exit = default_device_exit,
4366 * Initialize the DEV module. At boot time this walks the device list and
4367 * unhooks any devices that fail to initialise (normally hardware not
4368 * present) and leaves us with a valid list of present and active devices.
4373 * This is called single threaded during boot, so no need
4374 * to take the rtnl semaphore.
4376 static int __init net_dev_init(void)
4378 int i, rc = -ENOMEM;
4380 BUG_ON(!dev_boot_phase);
4382 if (dev_proc_init())
4385 if (netdev_kobject_init())
4388 INIT_LIST_HEAD(&ptype_all);
4389 for (i = 0; i < 16; i++)
4390 INIT_LIST_HEAD(&ptype_base[i]);
4392 if (register_pernet_subsys(&netdev_net_ops))
4395 if (register_pernet_device(&default_device_ops))
4399 * Initialise the packet receive queues.
4402 for_each_possible_cpu(i) {
4403 struct softnet_data *queue;
4405 queue = &per_cpu(softnet_data, i);
4406 skb_queue_head_init(&queue->input_pkt_queue);
4407 queue->completion_queue = NULL;
4408 INIT_LIST_HEAD(&queue->poll_list);
4410 queue->backlog.poll = process_backlog;
4411 queue->backlog.weight = weight_p;
4414 netdev_dma_register();
4418 open_softirq(NET_TX_SOFTIRQ, net_tx_action, NULL);
4419 open_softirq(NET_RX_SOFTIRQ, net_rx_action, NULL);
4421 hotcpu_notifier(dev_cpu_callback, 0);
4429 subsys_initcall(net_dev_init);
4431 EXPORT_SYMBOL(__dev_get_by_index);
4432 EXPORT_SYMBOL(__dev_get_by_name);
4433 EXPORT_SYMBOL(__dev_remove_pack);
4434 EXPORT_SYMBOL(dev_valid_name);
4435 EXPORT_SYMBOL(dev_add_pack);
4436 EXPORT_SYMBOL(dev_alloc_name);
4437 EXPORT_SYMBOL(dev_close);
4438 EXPORT_SYMBOL(dev_get_by_flags);
4439 EXPORT_SYMBOL(dev_get_by_index);
4440 EXPORT_SYMBOL(dev_get_by_name);
4441 EXPORT_SYMBOL(dev_open);
4442 EXPORT_SYMBOL(dev_queue_xmit);
4443 EXPORT_SYMBOL(dev_remove_pack);
4444 EXPORT_SYMBOL(dev_set_allmulti);
4445 EXPORT_SYMBOL(dev_set_promiscuity);
4446 EXPORT_SYMBOL(dev_change_flags);
4447 EXPORT_SYMBOL(dev_set_mtu);
4448 EXPORT_SYMBOL(dev_set_mac_address);
4449 EXPORT_SYMBOL(free_netdev);
4450 EXPORT_SYMBOL(netdev_boot_setup_check);
4451 EXPORT_SYMBOL(netdev_set_master);
4452 EXPORT_SYMBOL(netdev_state_change);
4453 EXPORT_SYMBOL(netif_receive_skb);
4454 EXPORT_SYMBOL(netif_rx);
4455 EXPORT_SYMBOL(register_gifconf);
4456 EXPORT_SYMBOL(register_netdevice);
4457 EXPORT_SYMBOL(register_netdevice_notifier);
4458 EXPORT_SYMBOL(skb_checksum_help);
4459 EXPORT_SYMBOL(synchronize_net);
4460 EXPORT_SYMBOL(unregister_netdevice);
4461 EXPORT_SYMBOL(unregister_netdevice_notifier);
4462 EXPORT_SYMBOL(net_enable_timestamp);
4463 EXPORT_SYMBOL(net_disable_timestamp);
4464 EXPORT_SYMBOL(dev_get_flags);
4466 #if defined(CONFIG_BRIDGE) || defined(CONFIG_BRIDGE_MODULE)
4467 EXPORT_SYMBOL(br_handle_frame_hook);
4468 EXPORT_SYMBOL(br_fdb_get_hook);
4469 EXPORT_SYMBOL(br_fdb_put_hook);
4473 EXPORT_SYMBOL(dev_load);
4476 EXPORT_PER_CPU_SYMBOL(softnet_data);