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>
123 #include "net-sysfs.h"
126 * The list of packet types we will receive (as opposed to discard)
127 * and the routines to invoke.
129 * Why 16. Because with 16 the only overlap we get on a hash of the
130 * low nibble of the protocol value is RARP/SNAP/X.25.
132 * NOTE: That is no longer true with the addition of VLAN tags. Not
133 * sure which should go first, but I bet it won't make much
134 * difference if we are running VLANs. The good news is that
135 * this protocol won't be in the list unless compiled in, so
136 * the average user (w/out VLANs) will not be adversely affected.
153 static DEFINE_SPINLOCK(ptype_lock);
154 static struct list_head ptype_base[16] __read_mostly; /* 16 way hashed list */
155 static struct list_head ptype_all __read_mostly; /* Taps */
157 #ifdef CONFIG_NET_DMA
159 struct dma_client client;
161 cpumask_t channel_mask;
162 struct dma_chan *channels[NR_CPUS];
165 static enum dma_state_client
166 netdev_dma_event(struct dma_client *client, struct dma_chan *chan,
167 enum dma_state state);
169 static struct net_dma net_dma = {
171 .event_callback = netdev_dma_event,
177 * The @dev_base_head list is protected by @dev_base_lock and the rtnl
180 * Pure readers hold dev_base_lock for reading.
182 * Writers must hold the rtnl semaphore while they loop through the
183 * dev_base_head list, and hold dev_base_lock for writing when they do the
184 * actual updates. This allows pure readers to access the list even
185 * while a writer is preparing to update it.
187 * To put it another way, dev_base_lock is held for writing only to
188 * protect against pure readers; the rtnl semaphore provides the
189 * protection against other writers.
191 * See, for example usages, register_netdevice() and
192 * unregister_netdevice(), which must be called with the rtnl
195 DEFINE_RWLOCK(dev_base_lock);
197 EXPORT_SYMBOL(dev_base_lock);
199 #define NETDEV_HASHBITS 8
200 #define NETDEV_HASHENTRIES (1 << NETDEV_HASHBITS)
202 static inline struct hlist_head *dev_name_hash(struct net *net, const char *name)
204 unsigned hash = full_name_hash(name, strnlen(name, IFNAMSIZ));
205 return &net->dev_name_head[hash & ((1 << NETDEV_HASHBITS) - 1)];
208 static inline struct hlist_head *dev_index_hash(struct net *net, int ifindex)
210 return &net->dev_index_head[ifindex & ((1 << NETDEV_HASHBITS) - 1)];
213 /* Device list insertion */
214 static int list_netdevice(struct net_device *dev)
216 struct net *net = dev->nd_net;
220 write_lock_bh(&dev_base_lock);
221 list_add_tail(&dev->dev_list, &net->dev_base_head);
222 hlist_add_head(&dev->name_hlist, dev_name_hash(net, dev->name));
223 hlist_add_head(&dev->index_hlist, dev_index_hash(net, dev->ifindex));
224 write_unlock_bh(&dev_base_lock);
228 /* Device list removal */
229 static void unlist_netdevice(struct net_device *dev)
233 /* Unlink dev from the device chain */
234 write_lock_bh(&dev_base_lock);
235 list_del(&dev->dev_list);
236 hlist_del(&dev->name_hlist);
237 hlist_del(&dev->index_hlist);
238 write_unlock_bh(&dev_base_lock);
245 static RAW_NOTIFIER_HEAD(netdev_chain);
248 * Device drivers call our routines to queue packets here. We empty the
249 * queue in the local softnet handler.
252 DEFINE_PER_CPU(struct softnet_data, softnet_data);
254 #ifdef CONFIG_DEBUG_LOCK_ALLOC
256 * register_netdevice() inits dev->_xmit_lock and sets lockdep class
257 * according to dev->type
259 static const unsigned short netdev_lock_type[] =
260 {ARPHRD_NETROM, ARPHRD_ETHER, ARPHRD_EETHER, ARPHRD_AX25,
261 ARPHRD_PRONET, ARPHRD_CHAOS, ARPHRD_IEEE802, ARPHRD_ARCNET,
262 ARPHRD_APPLETLK, ARPHRD_DLCI, ARPHRD_ATM, ARPHRD_METRICOM,
263 ARPHRD_IEEE1394, ARPHRD_EUI64, ARPHRD_INFINIBAND, ARPHRD_SLIP,
264 ARPHRD_CSLIP, ARPHRD_SLIP6, ARPHRD_CSLIP6, ARPHRD_RSRVD,
265 ARPHRD_ADAPT, ARPHRD_ROSE, ARPHRD_X25, ARPHRD_HWX25,
266 ARPHRD_PPP, ARPHRD_CISCO, ARPHRD_LAPB, ARPHRD_DDCMP,
267 ARPHRD_RAWHDLC, ARPHRD_TUNNEL, ARPHRD_TUNNEL6, ARPHRD_FRAD,
268 ARPHRD_SKIP, ARPHRD_LOOPBACK, ARPHRD_LOCALTLK, ARPHRD_FDDI,
269 ARPHRD_BIF, ARPHRD_SIT, ARPHRD_IPDDP, ARPHRD_IPGRE,
270 ARPHRD_PIMREG, ARPHRD_HIPPI, ARPHRD_ASH, ARPHRD_ECONET,
271 ARPHRD_IRDA, ARPHRD_FCPP, ARPHRD_FCAL, ARPHRD_FCPL,
272 ARPHRD_FCFABRIC, ARPHRD_IEEE802_TR, ARPHRD_IEEE80211,
273 ARPHRD_IEEE80211_PRISM, ARPHRD_IEEE80211_RADIOTAP, ARPHRD_VOID,
276 static const char *netdev_lock_name[] =
277 {"_xmit_NETROM", "_xmit_ETHER", "_xmit_EETHER", "_xmit_AX25",
278 "_xmit_PRONET", "_xmit_CHAOS", "_xmit_IEEE802", "_xmit_ARCNET",
279 "_xmit_APPLETLK", "_xmit_DLCI", "_xmit_ATM", "_xmit_METRICOM",
280 "_xmit_IEEE1394", "_xmit_EUI64", "_xmit_INFINIBAND", "_xmit_SLIP",
281 "_xmit_CSLIP", "_xmit_SLIP6", "_xmit_CSLIP6", "_xmit_RSRVD",
282 "_xmit_ADAPT", "_xmit_ROSE", "_xmit_X25", "_xmit_HWX25",
283 "_xmit_PPP", "_xmit_CISCO", "_xmit_LAPB", "_xmit_DDCMP",
284 "_xmit_RAWHDLC", "_xmit_TUNNEL", "_xmit_TUNNEL6", "_xmit_FRAD",
285 "_xmit_SKIP", "_xmit_LOOPBACK", "_xmit_LOCALTLK", "_xmit_FDDI",
286 "_xmit_BIF", "_xmit_SIT", "_xmit_IPDDP", "_xmit_IPGRE",
287 "_xmit_PIMREG", "_xmit_HIPPI", "_xmit_ASH", "_xmit_ECONET",
288 "_xmit_IRDA", "_xmit_FCPP", "_xmit_FCAL", "_xmit_FCPL",
289 "_xmit_FCFABRIC", "_xmit_IEEE802_TR", "_xmit_IEEE80211",
290 "_xmit_IEEE80211_PRISM", "_xmit_IEEE80211_RADIOTAP", "_xmit_VOID",
293 static struct lock_class_key netdev_xmit_lock_key[ARRAY_SIZE(netdev_lock_type)];
295 static inline unsigned short netdev_lock_pos(unsigned short dev_type)
299 for (i = 0; i < ARRAY_SIZE(netdev_lock_type); i++)
300 if (netdev_lock_type[i] == dev_type)
302 /* the last key is used by default */
303 return ARRAY_SIZE(netdev_lock_type) - 1;
306 static inline void netdev_set_lockdep_class(spinlock_t *lock,
307 unsigned short dev_type)
311 i = netdev_lock_pos(dev_type);
312 lockdep_set_class_and_name(lock, &netdev_xmit_lock_key[i],
313 netdev_lock_name[i]);
316 static inline void netdev_set_lockdep_class(spinlock_t *lock,
317 unsigned short dev_type)
322 /*******************************************************************************
324 Protocol management and registration routines
326 *******************************************************************************/
329 * Add a protocol ID to the list. Now that the input handler is
330 * smarter we can dispense with all the messy stuff that used to be
333 * BEWARE!!! Protocol handlers, mangling input packets,
334 * MUST BE last in hash buckets and checking protocol handlers
335 * MUST start from promiscuous ptype_all chain in net_bh.
336 * It is true now, do not change it.
337 * Explanation follows: if protocol handler, mangling packet, will
338 * be the first on list, it is not able to sense, that packet
339 * is cloned and should be copied-on-write, so that it will
340 * change it and subsequent readers will get broken packet.
345 * dev_add_pack - add packet handler
346 * @pt: packet type declaration
348 * Add a protocol handler to the networking stack. The passed &packet_type
349 * is linked into kernel lists and may not be freed until it has been
350 * removed from the kernel lists.
352 * This call does not sleep therefore it can not
353 * guarantee all CPU's that are in middle of receiving packets
354 * will see the new packet type (until the next received packet).
357 void dev_add_pack(struct packet_type *pt)
361 spin_lock_bh(&ptype_lock);
362 if (pt->type == htons(ETH_P_ALL))
363 list_add_rcu(&pt->list, &ptype_all);
365 hash = ntohs(pt->type) & 15;
366 list_add_rcu(&pt->list, &ptype_base[hash]);
368 spin_unlock_bh(&ptype_lock);
372 * __dev_remove_pack - remove packet handler
373 * @pt: packet type declaration
375 * Remove a protocol handler that was previously added to the kernel
376 * protocol handlers by dev_add_pack(). The passed &packet_type is removed
377 * from the kernel lists and can be freed or reused once this function
380 * The packet type might still be in use by receivers
381 * and must not be freed until after all the CPU's have gone
382 * through a quiescent state.
384 void __dev_remove_pack(struct packet_type *pt)
386 struct list_head *head;
387 struct packet_type *pt1;
389 spin_lock_bh(&ptype_lock);
391 if (pt->type == htons(ETH_P_ALL))
394 head = &ptype_base[ntohs(pt->type) & 15];
396 list_for_each_entry(pt1, head, list) {
398 list_del_rcu(&pt->list);
403 printk(KERN_WARNING "dev_remove_pack: %p not found.\n", pt);
405 spin_unlock_bh(&ptype_lock);
408 * dev_remove_pack - remove packet handler
409 * @pt: packet type declaration
411 * Remove a protocol handler that was previously added to the kernel
412 * protocol handlers by dev_add_pack(). The passed &packet_type is removed
413 * from the kernel lists and can be freed or reused once this function
416 * This call sleeps to guarantee that no CPU is looking at the packet
419 void dev_remove_pack(struct packet_type *pt)
421 __dev_remove_pack(pt);
426 /******************************************************************************
428 Device Boot-time Settings Routines
430 *******************************************************************************/
432 /* Boot time configuration table */
433 static struct netdev_boot_setup dev_boot_setup[NETDEV_BOOT_SETUP_MAX];
436 * netdev_boot_setup_add - add new setup entry
437 * @name: name of the device
438 * @map: configured settings for the device
440 * Adds new setup entry to the dev_boot_setup list. The function
441 * returns 0 on error and 1 on success. This is a generic routine to
444 static int netdev_boot_setup_add(char *name, struct ifmap *map)
446 struct netdev_boot_setup *s;
450 for (i = 0; i < NETDEV_BOOT_SETUP_MAX; i++) {
451 if (s[i].name[0] == '\0' || s[i].name[0] == ' ') {
452 memset(s[i].name, 0, sizeof(s[i].name));
453 strcpy(s[i].name, name);
454 memcpy(&s[i].map, map, sizeof(s[i].map));
459 return i >= NETDEV_BOOT_SETUP_MAX ? 0 : 1;
463 * netdev_boot_setup_check - check boot time settings
464 * @dev: the netdevice
466 * Check boot time settings for the device.
467 * The found settings are set for the device to be used
468 * later in the device probing.
469 * Returns 0 if no settings found, 1 if they are.
471 int netdev_boot_setup_check(struct net_device *dev)
473 struct netdev_boot_setup *s = dev_boot_setup;
476 for (i = 0; i < NETDEV_BOOT_SETUP_MAX; i++) {
477 if (s[i].name[0] != '\0' && s[i].name[0] != ' ' &&
478 !strncmp(dev->name, s[i].name, strlen(s[i].name))) {
479 dev->irq = s[i].map.irq;
480 dev->base_addr = s[i].map.base_addr;
481 dev->mem_start = s[i].map.mem_start;
482 dev->mem_end = s[i].map.mem_end;
491 * netdev_boot_base - get address from boot time settings
492 * @prefix: prefix for network device
493 * @unit: id for network device
495 * Check boot time settings for the base address of device.
496 * The found settings are set for the device to be used
497 * later in the device probing.
498 * Returns 0 if no settings found.
500 unsigned long netdev_boot_base(const char *prefix, int unit)
502 const struct netdev_boot_setup *s = dev_boot_setup;
506 sprintf(name, "%s%d", prefix, unit);
509 * If device already registered then return base of 1
510 * to indicate not to probe for this interface
512 if (__dev_get_by_name(&init_net, name))
515 for (i = 0; i < NETDEV_BOOT_SETUP_MAX; i++)
516 if (!strcmp(name, s[i].name))
517 return s[i].map.base_addr;
522 * Saves at boot time configured settings for any netdevice.
524 int __init netdev_boot_setup(char *str)
529 str = get_options(str, ARRAY_SIZE(ints), ints);
534 memset(&map, 0, sizeof(map));
538 map.base_addr = ints[2];
540 map.mem_start = ints[3];
542 map.mem_end = ints[4];
544 /* Add new entry to the list */
545 return netdev_boot_setup_add(str, &map);
548 __setup("netdev=", netdev_boot_setup);
550 /*******************************************************************************
552 Device Interface Subroutines
554 *******************************************************************************/
557 * __dev_get_by_name - find a device by its name
558 * @net: the applicable net namespace
559 * @name: name to find
561 * Find an interface by name. Must be called under RTNL semaphore
562 * or @dev_base_lock. If the name is found a pointer to the device
563 * is returned. If the name is not found then %NULL is returned. The
564 * reference counters are not incremented so the caller must be
565 * careful with locks.
568 struct net_device *__dev_get_by_name(struct net *net, const char *name)
570 struct hlist_node *p;
572 hlist_for_each(p, dev_name_hash(net, name)) {
573 struct net_device *dev
574 = hlist_entry(p, struct net_device, name_hlist);
575 if (!strncmp(dev->name, name, IFNAMSIZ))
582 * dev_get_by_name - find a device by its name
583 * @net: the applicable net namespace
584 * @name: name to find
586 * Find an interface by name. This can be called from any
587 * context and does its own locking. The returned handle has
588 * the usage count incremented and the caller must use dev_put() to
589 * release it when it is no longer needed. %NULL is returned if no
590 * matching device is found.
593 struct net_device *dev_get_by_name(struct net *net, const char *name)
595 struct net_device *dev;
597 read_lock(&dev_base_lock);
598 dev = __dev_get_by_name(net, name);
601 read_unlock(&dev_base_lock);
606 * __dev_get_by_index - find a device by its ifindex
607 * @net: the applicable net namespace
608 * @ifindex: index of device
610 * Search for an interface by index. Returns %NULL if the device
611 * is not found or a pointer to the device. The device has not
612 * had its reference counter increased so the caller must be careful
613 * about locking. The caller must hold either the RTNL semaphore
617 struct net_device *__dev_get_by_index(struct net *net, int ifindex)
619 struct hlist_node *p;
621 hlist_for_each(p, dev_index_hash(net, ifindex)) {
622 struct net_device *dev
623 = hlist_entry(p, struct net_device, index_hlist);
624 if (dev->ifindex == ifindex)
632 * dev_get_by_index - find a device by its ifindex
633 * @net: the applicable net namespace
634 * @ifindex: index of device
636 * Search for an interface by index. Returns NULL if the device
637 * is not found or a pointer to the device. The device returned has
638 * had a reference added and the pointer is safe until the user calls
639 * dev_put to indicate they have finished with it.
642 struct net_device *dev_get_by_index(struct net *net, int ifindex)
644 struct net_device *dev;
646 read_lock(&dev_base_lock);
647 dev = __dev_get_by_index(net, ifindex);
650 read_unlock(&dev_base_lock);
655 * dev_getbyhwaddr - find a device by its hardware address
656 * @net: the applicable net namespace
657 * @type: media type of device
658 * @ha: hardware address
660 * Search for an interface by MAC address. Returns NULL if the device
661 * is not found or a pointer to the device. The caller must hold the
662 * rtnl semaphore. The returned device has not had its ref count increased
663 * and the caller must therefore be careful about locking
666 * If the API was consistent this would be __dev_get_by_hwaddr
669 struct net_device *dev_getbyhwaddr(struct net *net, unsigned short type, char *ha)
671 struct net_device *dev;
675 for_each_netdev(&init_net, dev)
676 if (dev->type == type &&
677 !memcmp(dev->dev_addr, ha, dev->addr_len))
683 EXPORT_SYMBOL(dev_getbyhwaddr);
685 struct net_device *__dev_getfirstbyhwtype(struct net *net, unsigned short type)
687 struct net_device *dev;
690 for_each_netdev(net, dev)
691 if (dev->type == type)
697 EXPORT_SYMBOL(__dev_getfirstbyhwtype);
699 struct net_device *dev_getfirstbyhwtype(struct net *net, unsigned short type)
701 struct net_device *dev;
704 dev = __dev_getfirstbyhwtype(net, type);
711 EXPORT_SYMBOL(dev_getfirstbyhwtype);
714 * dev_get_by_flags - find any device with given flags
715 * @net: the applicable net namespace
716 * @if_flags: IFF_* values
717 * @mask: bitmask of bits in if_flags to check
719 * Search for any interface with the given flags. Returns NULL if a device
720 * is not found or a pointer to the device. The device returned has
721 * had a reference added and the pointer is safe until the user calls
722 * dev_put to indicate they have finished with it.
725 struct net_device * dev_get_by_flags(struct net *net, unsigned short if_flags, unsigned short mask)
727 struct net_device *dev, *ret;
730 read_lock(&dev_base_lock);
731 for_each_netdev(net, dev) {
732 if (((dev->flags ^ if_flags) & mask) == 0) {
738 read_unlock(&dev_base_lock);
743 * dev_valid_name - check if name is okay for network device
746 * Network device names need to be valid file names to
747 * to allow sysfs to work. We also disallow any kind of
750 int dev_valid_name(const char *name)
754 if (strlen(name) >= IFNAMSIZ)
756 if (!strcmp(name, ".") || !strcmp(name, ".."))
760 if (*name == '/' || isspace(*name))
768 * __dev_alloc_name - allocate a name for a device
769 * @net: network namespace to allocate the device name in
770 * @name: name format string
771 * @buf: scratch buffer and result name string
773 * Passed a format string - eg "lt%d" it will try and find a suitable
774 * id. It scans list of devices to build up a free map, then chooses
775 * the first empty slot. The caller must hold the dev_base or rtnl lock
776 * while allocating the name and adding the device in order to avoid
778 * Limited to bits_per_byte * page size devices (ie 32K on most platforms).
779 * Returns the number of the unit assigned or a negative errno code.
782 static int __dev_alloc_name(struct net *net, const char *name, char *buf)
786 const int max_netdevices = 8*PAGE_SIZE;
787 unsigned long *inuse;
788 struct net_device *d;
790 p = strnchr(name, IFNAMSIZ-1, '%');
793 * Verify the string as this thing may have come from
794 * the user. There must be either one "%d" and no other "%"
797 if (p[1] != 'd' || strchr(p + 2, '%'))
800 /* Use one page as a bit array of possible slots */
801 inuse = (unsigned long *) get_zeroed_page(GFP_ATOMIC);
805 for_each_netdev(net, d) {
806 if (!sscanf(d->name, name, &i))
808 if (i < 0 || i >= max_netdevices)
811 /* avoid cases where sscanf is not exact inverse of printf */
812 snprintf(buf, IFNAMSIZ, name, i);
813 if (!strncmp(buf, d->name, IFNAMSIZ))
817 i = find_first_zero_bit(inuse, max_netdevices);
818 free_page((unsigned long) inuse);
821 snprintf(buf, IFNAMSIZ, name, i);
822 if (!__dev_get_by_name(net, buf))
825 /* It is possible to run out of possible slots
826 * when the name is long and there isn't enough space left
827 * for the digits, or if all bits are used.
833 * dev_alloc_name - allocate a name for a device
835 * @name: name format string
837 * Passed a format string - eg "lt%d" it will try and find a suitable
838 * id. It scans list of devices to build up a free map, then chooses
839 * the first empty slot. The caller must hold the dev_base or rtnl lock
840 * while allocating the name and adding the device in order to avoid
842 * Limited to bits_per_byte * page size devices (ie 32K on most platforms).
843 * Returns the number of the unit assigned or a negative errno code.
846 int dev_alloc_name(struct net_device *dev, const char *name)
852 BUG_ON(!dev->nd_net);
854 ret = __dev_alloc_name(net, name, buf);
856 strlcpy(dev->name, buf, IFNAMSIZ);
862 * dev_change_name - change name of a device
864 * @newname: name (or format string) must be at least IFNAMSIZ
866 * Change name of a device, can pass format strings "eth%d".
869 int dev_change_name(struct net_device *dev, char *newname)
871 char oldname[IFNAMSIZ];
877 BUG_ON(!dev->nd_net);
880 if (dev->flags & IFF_UP)
883 if (!dev_valid_name(newname))
886 if (strncmp(newname, dev->name, IFNAMSIZ) == 0)
889 memcpy(oldname, dev->name, IFNAMSIZ);
891 if (strchr(newname, '%')) {
892 err = dev_alloc_name(dev, newname);
895 strcpy(newname, dev->name);
897 else if (__dev_get_by_name(net, newname))
900 strlcpy(dev->name, newname, IFNAMSIZ);
903 device_rename(&dev->dev, dev->name);
905 write_lock_bh(&dev_base_lock);
906 hlist_del(&dev->name_hlist);
907 hlist_add_head(&dev->name_hlist, dev_name_hash(net, dev->name));
908 write_unlock_bh(&dev_base_lock);
910 ret = call_netdevice_notifiers(NETDEV_CHANGENAME, dev);
911 ret = notifier_to_errno(ret);
916 "%s: name change rollback failed: %d.\n",
920 memcpy(dev->name, oldname, IFNAMSIZ);
929 * netdev_features_change - device changes features
930 * @dev: device to cause notification
932 * Called to indicate a device has changed features.
934 void netdev_features_change(struct net_device *dev)
936 call_netdevice_notifiers(NETDEV_FEAT_CHANGE, dev);
938 EXPORT_SYMBOL(netdev_features_change);
941 * netdev_state_change - device changes state
942 * @dev: device to cause notification
944 * Called to indicate a device has changed state. This function calls
945 * the notifier chains for netdev_chain and sends a NEWLINK message
946 * to the routing socket.
948 void netdev_state_change(struct net_device *dev)
950 if (dev->flags & IFF_UP) {
951 call_netdevice_notifiers(NETDEV_CHANGE, dev);
952 rtmsg_ifinfo(RTM_NEWLINK, dev, 0);
957 * dev_load - load a network module
958 * @net: the applicable net namespace
959 * @name: name of interface
961 * If a network interface is not present and the process has suitable
962 * privileges this function loads the module. If module loading is not
963 * available in this kernel then it becomes a nop.
966 void dev_load(struct net *net, const char *name)
968 struct net_device *dev;
970 read_lock(&dev_base_lock);
971 dev = __dev_get_by_name(net, name);
972 read_unlock(&dev_base_lock);
974 if (!dev && capable(CAP_SYS_MODULE))
975 request_module("%s", name);
979 * dev_open - prepare an interface for use.
980 * @dev: device to open
982 * Takes a device from down to up state. The device's private open
983 * function is invoked and then the multicast lists are loaded. Finally
984 * the device is moved into the up state and a %NETDEV_UP message is
985 * sent to the netdev notifier chain.
987 * Calling this function on an active interface is a nop. On a failure
988 * a negative errno code is returned.
990 int dev_open(struct net_device *dev)
998 if (dev->flags & IFF_UP)
1002 * Is it even present?
1004 if (!netif_device_present(dev))
1008 * Call device private open method
1010 set_bit(__LINK_STATE_START, &dev->state);
1012 if (dev->validate_addr)
1013 ret = dev->validate_addr(dev);
1015 if (!ret && dev->open)
1016 ret = dev->open(dev);
1019 * If it went open OK then:
1023 clear_bit(__LINK_STATE_START, &dev->state);
1028 dev->flags |= IFF_UP;
1031 * Initialize multicasting status
1033 dev_set_rx_mode(dev);
1036 * Wakeup transmit queue engine
1041 * ... and announce new interface.
1043 call_netdevice_notifiers(NETDEV_UP, dev);
1050 * dev_close - shutdown an interface.
1051 * @dev: device to shutdown
1053 * This function moves an active device into down state. A
1054 * %NETDEV_GOING_DOWN is sent to the netdev notifier chain. The device
1055 * is then deactivated and finally a %NETDEV_DOWN is sent to the notifier
1058 int dev_close(struct net_device *dev)
1062 if (!(dev->flags & IFF_UP))
1066 * Tell people we are going down, so that they can
1067 * prepare to death, when device is still operating.
1069 call_netdevice_notifiers(NETDEV_GOING_DOWN, dev);
1071 dev_deactivate(dev);
1073 clear_bit(__LINK_STATE_START, &dev->state);
1075 /* Synchronize to scheduled poll. We cannot touch poll list,
1076 * it can be even on different cpu. So just clear netif_running().
1078 * dev->stop() will invoke napi_disable() on all of it's
1079 * napi_struct instances on this device.
1081 smp_mb__after_clear_bit(); /* Commit netif_running(). */
1084 * Call the device specific close. This cannot fail.
1085 * Only if device is UP
1087 * We allow it to be called even after a DETACH hot-plug
1094 * Device is now down.
1097 dev->flags &= ~IFF_UP;
1100 * Tell people we are down
1102 call_netdevice_notifiers(NETDEV_DOWN, dev);
1108 static int dev_boot_phase = 1;
1111 * Device change register/unregister. These are not inline or static
1112 * as we export them to the world.
1116 * register_netdevice_notifier - register a network notifier block
1119 * Register a notifier to be called when network device events occur.
1120 * The notifier passed is linked into the kernel structures and must
1121 * not be reused until it has been unregistered. A negative errno code
1122 * is returned on a failure.
1124 * When registered all registration and up events are replayed
1125 * to the new notifier to allow device to have a race free
1126 * view of the network device list.
1129 int register_netdevice_notifier(struct notifier_block *nb)
1131 struct net_device *dev;
1132 struct net_device *last;
1137 err = raw_notifier_chain_register(&netdev_chain, nb);
1143 for_each_netdev(net, dev) {
1144 err = nb->notifier_call(nb, NETDEV_REGISTER, dev);
1145 err = notifier_to_errno(err);
1149 if (!(dev->flags & IFF_UP))
1152 nb->notifier_call(nb, NETDEV_UP, dev);
1163 for_each_netdev(net, dev) {
1167 if (dev->flags & IFF_UP) {
1168 nb->notifier_call(nb, NETDEV_GOING_DOWN, dev);
1169 nb->notifier_call(nb, NETDEV_DOWN, dev);
1171 nb->notifier_call(nb, NETDEV_UNREGISTER, dev);
1175 raw_notifier_chain_unregister(&netdev_chain, nb);
1180 * unregister_netdevice_notifier - unregister a network notifier block
1183 * Unregister a notifier previously registered by
1184 * register_netdevice_notifier(). The notifier is unlinked into the
1185 * kernel structures and may then be reused. A negative errno code
1186 * is returned on a failure.
1189 int unregister_netdevice_notifier(struct notifier_block *nb)
1194 err = raw_notifier_chain_unregister(&netdev_chain, nb);
1200 * call_netdevice_notifiers - call all network notifier blocks
1201 * @val: value passed unmodified to notifier function
1202 * @dev: net_device pointer passed unmodified to notifier function
1204 * Call all network notifier blocks. Parameters and return value
1205 * are as for raw_notifier_call_chain().
1208 int call_netdevice_notifiers(unsigned long val, struct net_device *dev)
1210 return raw_notifier_call_chain(&netdev_chain, val, dev);
1213 /* When > 0 there are consumers of rx skb time stamps */
1214 static atomic_t netstamp_needed = ATOMIC_INIT(0);
1216 void net_enable_timestamp(void)
1218 atomic_inc(&netstamp_needed);
1221 void net_disable_timestamp(void)
1223 atomic_dec(&netstamp_needed);
1226 static inline void net_timestamp(struct sk_buff *skb)
1228 if (atomic_read(&netstamp_needed))
1229 __net_timestamp(skb);
1231 skb->tstamp.tv64 = 0;
1235 * Support routine. Sends outgoing frames to any network
1236 * taps currently in use.
1239 static void dev_queue_xmit_nit(struct sk_buff *skb, struct net_device *dev)
1241 struct packet_type *ptype;
1246 list_for_each_entry_rcu(ptype, &ptype_all, list) {
1247 /* Never send packets back to the socket
1248 * they originated from - MvS (miquels@drinkel.ow.org)
1250 if ((ptype->dev == dev || !ptype->dev) &&
1251 (ptype->af_packet_priv == NULL ||
1252 (struct sock *)ptype->af_packet_priv != skb->sk)) {
1253 struct sk_buff *skb2= skb_clone(skb, GFP_ATOMIC);
1257 /* skb->nh should be correctly
1258 set by sender, so that the second statement is
1259 just protection against buggy protocols.
1261 skb_reset_mac_header(skb2);
1263 if (skb_network_header(skb2) < skb2->data ||
1264 skb2->network_header > skb2->tail) {
1265 if (net_ratelimit())
1266 printk(KERN_CRIT "protocol %04x is "
1268 skb2->protocol, dev->name);
1269 skb_reset_network_header(skb2);
1272 skb2->transport_header = skb2->network_header;
1273 skb2->pkt_type = PACKET_OUTGOING;
1274 ptype->func(skb2, skb->dev, ptype, skb->dev);
1281 void __netif_schedule(struct net_device *dev)
1283 if (!test_and_set_bit(__LINK_STATE_SCHED, &dev->state)) {
1284 unsigned long flags;
1285 struct softnet_data *sd;
1287 local_irq_save(flags);
1288 sd = &__get_cpu_var(softnet_data);
1289 dev->next_sched = sd->output_queue;
1290 sd->output_queue = dev;
1291 raise_softirq_irqoff(NET_TX_SOFTIRQ);
1292 local_irq_restore(flags);
1295 EXPORT_SYMBOL(__netif_schedule);
1297 void dev_kfree_skb_irq(struct sk_buff *skb)
1299 if (atomic_dec_and_test(&skb->users)) {
1300 struct softnet_data *sd;
1301 unsigned long flags;
1303 local_irq_save(flags);
1304 sd = &__get_cpu_var(softnet_data);
1305 skb->next = sd->completion_queue;
1306 sd->completion_queue = skb;
1307 raise_softirq_irqoff(NET_TX_SOFTIRQ);
1308 local_irq_restore(flags);
1311 EXPORT_SYMBOL(dev_kfree_skb_irq);
1313 void dev_kfree_skb_any(struct sk_buff *skb)
1315 if (in_irq() || irqs_disabled())
1316 dev_kfree_skb_irq(skb);
1320 EXPORT_SYMBOL(dev_kfree_skb_any);
1324 * netif_device_detach - mark device as removed
1325 * @dev: network device
1327 * Mark device as removed from system and therefore no longer available.
1329 void netif_device_detach(struct net_device *dev)
1331 if (test_and_clear_bit(__LINK_STATE_PRESENT, &dev->state) &&
1332 netif_running(dev)) {
1333 netif_stop_queue(dev);
1336 EXPORT_SYMBOL(netif_device_detach);
1339 * netif_device_attach - mark device as attached
1340 * @dev: network device
1342 * Mark device as attached from system and restart if needed.
1344 void netif_device_attach(struct net_device *dev)
1346 if (!test_and_set_bit(__LINK_STATE_PRESENT, &dev->state) &&
1347 netif_running(dev)) {
1348 netif_wake_queue(dev);
1349 __netdev_watchdog_up(dev);
1352 EXPORT_SYMBOL(netif_device_attach);
1356 * Invalidate hardware checksum when packet is to be mangled, and
1357 * complete checksum manually on outgoing path.
1359 int skb_checksum_help(struct sk_buff *skb)
1362 int ret = 0, offset;
1364 if (skb->ip_summed == CHECKSUM_COMPLETE)
1365 goto out_set_summed;
1367 if (unlikely(skb_shinfo(skb)->gso_size)) {
1368 /* Let GSO fix up the checksum. */
1369 goto out_set_summed;
1372 offset = skb->csum_start - skb_headroom(skb);
1373 BUG_ON(offset >= skb_headlen(skb));
1374 csum = skb_checksum(skb, offset, skb->len - offset, 0);
1376 offset += skb->csum_offset;
1377 BUG_ON(offset + sizeof(__sum16) > skb_headlen(skb));
1379 if (skb_cloned(skb) &&
1380 !skb_clone_writable(skb, offset + sizeof(__sum16))) {
1381 ret = pskb_expand_head(skb, 0, 0, GFP_ATOMIC);
1386 *(__sum16 *)(skb->data + offset) = csum_fold(csum);
1388 skb->ip_summed = CHECKSUM_NONE;
1394 * skb_gso_segment - Perform segmentation on skb.
1395 * @skb: buffer to segment
1396 * @features: features for the output path (see dev->features)
1398 * This function segments the given skb and returns a list of segments.
1400 * It may return NULL if the skb requires no segmentation. This is
1401 * only possible when GSO is used for verifying header integrity.
1403 struct sk_buff *skb_gso_segment(struct sk_buff *skb, int features)
1405 struct sk_buff *segs = ERR_PTR(-EPROTONOSUPPORT);
1406 struct packet_type *ptype;
1407 __be16 type = skb->protocol;
1410 BUG_ON(skb_shinfo(skb)->frag_list);
1412 skb_reset_mac_header(skb);
1413 skb->mac_len = skb->network_header - skb->mac_header;
1414 __skb_pull(skb, skb->mac_len);
1416 if (WARN_ON(skb->ip_summed != CHECKSUM_PARTIAL)) {
1417 if (skb_header_cloned(skb) &&
1418 (err = pskb_expand_head(skb, 0, 0, GFP_ATOMIC)))
1419 return ERR_PTR(err);
1423 list_for_each_entry_rcu(ptype, &ptype_base[ntohs(type) & 15], list) {
1424 if (ptype->type == type && !ptype->dev && ptype->gso_segment) {
1425 if (unlikely(skb->ip_summed != CHECKSUM_PARTIAL)) {
1426 err = ptype->gso_send_check(skb);
1427 segs = ERR_PTR(err);
1428 if (err || skb_gso_ok(skb, features))
1430 __skb_push(skb, (skb->data -
1431 skb_network_header(skb)));
1433 segs = ptype->gso_segment(skb, features);
1439 __skb_push(skb, skb->data - skb_mac_header(skb));
1444 EXPORT_SYMBOL(skb_gso_segment);
1446 /* Take action when hardware reception checksum errors are detected. */
1448 void netdev_rx_csum_fault(struct net_device *dev)
1450 if (net_ratelimit()) {
1451 printk(KERN_ERR "%s: hw csum failure.\n",
1452 dev ? dev->name : "<unknown>");
1456 EXPORT_SYMBOL(netdev_rx_csum_fault);
1459 /* Actually, we should eliminate this check as soon as we know, that:
1460 * 1. IOMMU is present and allows to map all the memory.
1461 * 2. No high memory really exists on this machine.
1464 static inline int illegal_highdma(struct net_device *dev, struct sk_buff *skb)
1466 #ifdef CONFIG_HIGHMEM
1469 if (dev->features & NETIF_F_HIGHDMA)
1472 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++)
1473 if (PageHighMem(skb_shinfo(skb)->frags[i].page))
1481 void (*destructor)(struct sk_buff *skb);
1484 #define DEV_GSO_CB(skb) ((struct dev_gso_cb *)(skb)->cb)
1486 static void dev_gso_skb_destructor(struct sk_buff *skb)
1488 struct dev_gso_cb *cb;
1491 struct sk_buff *nskb = skb->next;
1493 skb->next = nskb->next;
1496 } while (skb->next);
1498 cb = DEV_GSO_CB(skb);
1500 cb->destructor(skb);
1504 * dev_gso_segment - Perform emulated hardware segmentation on skb.
1505 * @skb: buffer to segment
1507 * This function segments the given skb and stores the list of segments
1510 static int dev_gso_segment(struct sk_buff *skb)
1512 struct net_device *dev = skb->dev;
1513 struct sk_buff *segs;
1514 int features = dev->features & ~(illegal_highdma(dev, skb) ?
1517 segs = skb_gso_segment(skb, features);
1519 /* Verifying header integrity only. */
1523 if (unlikely(IS_ERR(segs)))
1524 return PTR_ERR(segs);
1527 DEV_GSO_CB(skb)->destructor = skb->destructor;
1528 skb->destructor = dev_gso_skb_destructor;
1533 int dev_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
1535 if (likely(!skb->next)) {
1536 if (!list_empty(&ptype_all))
1537 dev_queue_xmit_nit(skb, dev);
1539 if (netif_needs_gso(dev, skb)) {
1540 if (unlikely(dev_gso_segment(skb)))
1546 return dev->hard_start_xmit(skb, dev);
1551 struct sk_buff *nskb = skb->next;
1554 skb->next = nskb->next;
1556 rc = dev->hard_start_xmit(nskb, dev);
1558 nskb->next = skb->next;
1562 if (unlikely((netif_queue_stopped(dev) ||
1563 netif_subqueue_stopped(dev, skb)) &&
1565 return NETDEV_TX_BUSY;
1566 } while (skb->next);
1568 skb->destructor = DEV_GSO_CB(skb)->destructor;
1576 * dev_queue_xmit - transmit a buffer
1577 * @skb: buffer to transmit
1579 * Queue a buffer for transmission to a network device. The caller must
1580 * have set the device and priority and built the buffer before calling
1581 * this function. The function can be called from an interrupt.
1583 * A negative errno code is returned on a failure. A success does not
1584 * guarantee the frame will be transmitted as it may be dropped due
1585 * to congestion or traffic shaping.
1587 * -----------------------------------------------------------------------------------
1588 * I notice this method can also return errors from the queue disciplines,
1589 * including NET_XMIT_DROP, which is a positive value. So, errors can also
1592 * Regardless of the return value, the skb is consumed, so it is currently
1593 * difficult to retry a send to this method. (You can bump the ref count
1594 * before sending to hold a reference for retry if you are careful.)
1596 * When calling this method, interrupts MUST be enabled. This is because
1597 * the BH enable code must have IRQs enabled so that it will not deadlock.
1601 int dev_queue_xmit(struct sk_buff *skb)
1603 struct net_device *dev = skb->dev;
1607 /* GSO will handle the following emulations directly. */
1608 if (netif_needs_gso(dev, skb))
1611 if (skb_shinfo(skb)->frag_list &&
1612 !(dev->features & NETIF_F_FRAGLIST) &&
1613 __skb_linearize(skb))
1616 /* Fragmented skb is linearized if device does not support SG,
1617 * or if at least one of fragments is in highmem and device
1618 * does not support DMA from it.
1620 if (skb_shinfo(skb)->nr_frags &&
1621 (!(dev->features & NETIF_F_SG) || illegal_highdma(dev, skb)) &&
1622 __skb_linearize(skb))
1625 /* If packet is not checksummed and device does not support
1626 * checksumming for this protocol, complete checksumming here.
1628 if (skb->ip_summed == CHECKSUM_PARTIAL) {
1629 skb_set_transport_header(skb, skb->csum_start -
1632 if (!(dev->features & NETIF_F_GEN_CSUM) &&
1633 !((dev->features & NETIF_F_IP_CSUM) &&
1634 skb->protocol == htons(ETH_P_IP)) &&
1635 !((dev->features & NETIF_F_IPV6_CSUM) &&
1636 skb->protocol == htons(ETH_P_IPV6)))
1637 if (skb_checksum_help(skb))
1642 spin_lock_prefetch(&dev->queue_lock);
1644 /* Disable soft irqs for various locks below. Also
1645 * stops preemption for RCU.
1649 /* Updates of qdisc are serialized by queue_lock.
1650 * The struct Qdisc which is pointed to by qdisc is now a
1651 * rcu structure - it may be accessed without acquiring
1652 * a lock (but the structure may be stale.) The freeing of the
1653 * qdisc will be deferred until it's known that there are no
1654 * more references to it.
1656 * If the qdisc has an enqueue function, we still need to
1657 * hold the queue_lock before calling it, since queue_lock
1658 * also serializes access to the device queue.
1661 q = rcu_dereference(dev->qdisc);
1662 #ifdef CONFIG_NET_CLS_ACT
1663 skb->tc_verd = SET_TC_AT(skb->tc_verd,AT_EGRESS);
1666 /* Grab device queue */
1667 spin_lock(&dev->queue_lock);
1670 /* reset queue_mapping to zero */
1671 skb_set_queue_mapping(skb, 0);
1672 rc = q->enqueue(skb, q);
1674 spin_unlock(&dev->queue_lock);
1676 rc = rc == NET_XMIT_BYPASS ? NET_XMIT_SUCCESS : rc;
1679 spin_unlock(&dev->queue_lock);
1682 /* The device has no queue. Common case for software devices:
1683 loopback, all the sorts of tunnels...
1685 Really, it is unlikely that netif_tx_lock protection is necessary
1686 here. (f.e. loopback and IP tunnels are clean ignoring statistics
1688 However, it is possible, that they rely on protection
1691 Check this and shot the lock. It is not prone from deadlocks.
1692 Either shot noqueue qdisc, it is even simpler 8)
1694 if (dev->flags & IFF_UP) {
1695 int cpu = smp_processor_id(); /* ok because BHs are off */
1697 if (dev->xmit_lock_owner != cpu) {
1699 HARD_TX_LOCK(dev, cpu);
1701 if (!netif_queue_stopped(dev) &&
1702 !netif_subqueue_stopped(dev, skb)) {
1704 if (!dev_hard_start_xmit(skb, dev)) {
1705 HARD_TX_UNLOCK(dev);
1709 HARD_TX_UNLOCK(dev);
1710 if (net_ratelimit())
1711 printk(KERN_CRIT "Virtual device %s asks to "
1712 "queue packet!\n", dev->name);
1714 /* Recursion is detected! It is possible,
1716 if (net_ratelimit())
1717 printk(KERN_CRIT "Dead loop on virtual device "
1718 "%s, fix it urgently!\n", dev->name);
1723 rcu_read_unlock_bh();
1729 rcu_read_unlock_bh();
1734 /*=======================================================================
1736 =======================================================================*/
1738 int netdev_max_backlog __read_mostly = 1000;
1739 int netdev_budget __read_mostly = 300;
1740 int weight_p __read_mostly = 64; /* old backlog weight */
1742 DEFINE_PER_CPU(struct netif_rx_stats, netdev_rx_stat) = { 0, };
1746 * netif_rx - post buffer to the network code
1747 * @skb: buffer to post
1749 * This function receives a packet from a device driver and queues it for
1750 * the upper (protocol) levels to process. It always succeeds. The buffer
1751 * may be dropped during processing for congestion control or by the
1755 * NET_RX_SUCCESS (no 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)) {
2004 * netif_receive_skb - process receive buffer from network
2005 * @skb: buffer to process
2007 * netif_receive_skb() is the main receive data processing function.
2008 * It always succeeds. The buffer may be dropped during processing
2009 * for congestion control or by the protocol layers.
2011 * This function may only be called from softirq context and interrupts
2012 * should be enabled.
2014 * Return values (usually ignored):
2015 * NET_RX_SUCCESS: no congestion
2016 * NET_RX_DROP: packet was dropped
2018 int netif_receive_skb(struct sk_buff *skb)
2020 struct packet_type *ptype, *pt_prev;
2021 struct net_device *orig_dev;
2022 int ret = NET_RX_DROP;
2025 /* if we've gotten here through NAPI, check netpoll */
2026 if (netpoll_receive_skb(skb))
2029 if (!skb->tstamp.tv64)
2033 skb->iif = skb->dev->ifindex;
2035 orig_dev = skb_bond(skb);
2040 __get_cpu_var(netdev_rx_stat).total++;
2042 skb_reset_network_header(skb);
2043 skb_reset_transport_header(skb);
2044 skb->mac_len = skb->network_header - skb->mac_header;
2050 #ifdef CONFIG_NET_CLS_ACT
2051 if (skb->tc_verd & TC_NCLS) {
2052 skb->tc_verd = CLR_TC_NCLS(skb->tc_verd);
2057 list_for_each_entry_rcu(ptype, &ptype_all, list) {
2058 if (!ptype->dev || ptype->dev == skb->dev) {
2060 ret = deliver_skb(skb, pt_prev, orig_dev);
2065 #ifdef CONFIG_NET_CLS_ACT
2066 skb = handle_ing(skb, &pt_prev, &ret, orig_dev);
2072 skb = handle_bridge(skb, &pt_prev, &ret, orig_dev);
2075 skb = handle_macvlan(skb, &pt_prev, &ret, orig_dev);
2079 type = skb->protocol;
2080 list_for_each_entry_rcu(ptype, &ptype_base[ntohs(type)&15], list) {
2081 if (ptype->type == type &&
2082 (!ptype->dev || ptype->dev == skb->dev)) {
2084 ret = deliver_skb(skb, pt_prev, orig_dev);
2090 ret = pt_prev->func(skb, skb->dev, pt_prev, orig_dev);
2093 /* Jamal, now you will not able to escape explaining
2094 * me how you were going to use this. :-)
2104 static int process_backlog(struct napi_struct *napi, int quota)
2107 struct softnet_data *queue = &__get_cpu_var(softnet_data);
2108 unsigned long start_time = jiffies;
2110 napi->weight = weight_p;
2112 struct sk_buff *skb;
2113 struct net_device *dev;
2115 local_irq_disable();
2116 skb = __skb_dequeue(&queue->input_pkt_queue);
2118 __napi_complete(napi);
2127 netif_receive_skb(skb);
2130 } while (++work < quota && jiffies == start_time);
2136 * __napi_schedule - schedule for receive
2137 * @n: entry to schedule
2139 * The entry's receive function will be scheduled to run
2141 void fastcall __napi_schedule(struct napi_struct *n)
2143 unsigned long flags;
2145 local_irq_save(flags);
2146 list_add_tail(&n->poll_list, &__get_cpu_var(softnet_data).poll_list);
2147 __raise_softirq_irqoff(NET_RX_SOFTIRQ);
2148 local_irq_restore(flags);
2150 EXPORT_SYMBOL(__napi_schedule);
2153 static void net_rx_action(struct softirq_action *h)
2155 struct list_head *list = &__get_cpu_var(softnet_data).poll_list;
2156 unsigned long start_time = jiffies;
2157 int budget = netdev_budget;
2160 local_irq_disable();
2162 while (!list_empty(list)) {
2163 struct napi_struct *n;
2166 /* If softirq window is exhuasted then punt.
2168 * Note that this is a slight policy change from the
2169 * previous NAPI code, which would allow up to 2
2170 * jiffies to pass before breaking out. The test
2171 * used to be "jiffies - start_time > 1".
2173 if (unlikely(budget <= 0 || jiffies != start_time))
2178 /* Even though interrupts have been re-enabled, this
2179 * access is safe because interrupts can only add new
2180 * entries to the tail of this list, and only ->poll()
2181 * calls can remove this head entry from the list.
2183 n = list_entry(list->next, struct napi_struct, poll_list);
2185 have = netpoll_poll_lock(n);
2189 /* This NAPI_STATE_SCHED test is for avoiding a race
2190 * with netpoll's poll_napi(). Only the entity which
2191 * obtains the lock and sees NAPI_STATE_SCHED set will
2192 * actually make the ->poll() call. Therefore we avoid
2193 * accidently calling ->poll() when NAPI is not scheduled.
2196 if (test_bit(NAPI_STATE_SCHED, &n->state))
2197 work = n->poll(n, weight);
2199 WARN_ON_ONCE(work > weight);
2203 local_irq_disable();
2205 /* Drivers must not modify the NAPI state if they
2206 * consume the entire weight. In such cases this code
2207 * still "owns" the NAPI instance and therefore can
2208 * move the instance around on the list at-will.
2210 if (unlikely(work == weight)) {
2211 if (unlikely(napi_disable_pending(n)))
2214 list_move_tail(&n->poll_list, list);
2217 netpoll_poll_unlock(have);
2222 #ifdef CONFIG_NET_DMA
2224 * There may not be any more sk_buffs coming right now, so push
2225 * any pending DMA copies to hardware
2227 if (!cpus_empty(net_dma.channel_mask)) {
2229 for_each_cpu_mask(chan_idx, net_dma.channel_mask) {
2230 struct dma_chan *chan = net_dma.channels[chan_idx];
2232 dma_async_memcpy_issue_pending(chan);
2240 __get_cpu_var(netdev_rx_stat).time_squeeze++;
2241 __raise_softirq_irqoff(NET_RX_SOFTIRQ);
2245 static gifconf_func_t * gifconf_list [NPROTO];
2248 * register_gifconf - register a SIOCGIF handler
2249 * @family: Address family
2250 * @gifconf: Function handler
2252 * Register protocol dependent address dumping routines. The handler
2253 * that is passed must not be freed or reused until it has been replaced
2254 * by another handler.
2256 int register_gifconf(unsigned int family, gifconf_func_t * gifconf)
2258 if (family >= NPROTO)
2260 gifconf_list[family] = gifconf;
2266 * Map an interface index to its name (SIOCGIFNAME)
2270 * We need this ioctl for efficient implementation of the
2271 * if_indextoname() function required by the IPv6 API. Without
2272 * it, we would have to search all the interfaces to find a
2276 static int dev_ifname(struct net *net, struct ifreq __user *arg)
2278 struct net_device *dev;
2282 * Fetch the caller's info block.
2285 if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
2288 read_lock(&dev_base_lock);
2289 dev = __dev_get_by_index(net, ifr.ifr_ifindex);
2291 read_unlock(&dev_base_lock);
2295 strcpy(ifr.ifr_name, dev->name);
2296 read_unlock(&dev_base_lock);
2298 if (copy_to_user(arg, &ifr, sizeof(struct ifreq)))
2304 * Perform a SIOCGIFCONF call. This structure will change
2305 * size eventually, and there is nothing I can do about it.
2306 * Thus we will need a 'compatibility mode'.
2309 static int dev_ifconf(struct net *net, char __user *arg)
2312 struct net_device *dev;
2319 * Fetch the caller's info block.
2322 if (copy_from_user(&ifc, arg, sizeof(struct ifconf)))
2329 * Loop over the interfaces, and write an info block for each.
2333 for_each_netdev(net, dev) {
2334 for (i = 0; i < NPROTO; i++) {
2335 if (gifconf_list[i]) {
2338 done = gifconf_list[i](dev, NULL, 0);
2340 done = gifconf_list[i](dev, pos + total,
2350 * All done. Write the updated control block back to the caller.
2352 ifc.ifc_len = total;
2355 * Both BSD and Solaris return 0 here, so we do too.
2357 return copy_to_user(arg, &ifc, sizeof(struct ifconf)) ? -EFAULT : 0;
2360 #ifdef CONFIG_PROC_FS
2362 * This is invoked by the /proc filesystem handler to display a device
2365 void *dev_seq_start(struct seq_file *seq, loff_t *pos)
2367 struct net *net = seq_file_net(seq);
2369 struct net_device *dev;
2371 read_lock(&dev_base_lock);
2373 return SEQ_START_TOKEN;
2376 for_each_netdev(net, dev)
2383 void *dev_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2385 struct net *net = seq_file_net(seq);
2387 return v == SEQ_START_TOKEN ?
2388 first_net_device(net) : next_net_device((struct net_device *)v);
2391 void dev_seq_stop(struct seq_file *seq, void *v)
2393 read_unlock(&dev_base_lock);
2396 static void dev_seq_printf_stats(struct seq_file *seq, struct net_device *dev)
2398 struct net_device_stats *stats = dev->get_stats(dev);
2400 seq_printf(seq, "%6s:%8lu %7lu %4lu %4lu %4lu %5lu %10lu %9lu "
2401 "%8lu %7lu %4lu %4lu %4lu %5lu %7lu %10lu\n",
2402 dev->name, stats->rx_bytes, stats->rx_packets,
2404 stats->rx_dropped + stats->rx_missed_errors,
2405 stats->rx_fifo_errors,
2406 stats->rx_length_errors + stats->rx_over_errors +
2407 stats->rx_crc_errors + stats->rx_frame_errors,
2408 stats->rx_compressed, stats->multicast,
2409 stats->tx_bytes, stats->tx_packets,
2410 stats->tx_errors, stats->tx_dropped,
2411 stats->tx_fifo_errors, stats->collisions,
2412 stats->tx_carrier_errors +
2413 stats->tx_aborted_errors +
2414 stats->tx_window_errors +
2415 stats->tx_heartbeat_errors,
2416 stats->tx_compressed);
2420 * Called from the PROCfs module. This now uses the new arbitrary sized
2421 * /proc/net interface to create /proc/net/dev
2423 static int dev_seq_show(struct seq_file *seq, void *v)
2425 if (v == SEQ_START_TOKEN)
2426 seq_puts(seq, "Inter-| Receive "
2428 " face |bytes packets errs drop fifo frame "
2429 "compressed multicast|bytes packets errs "
2430 "drop fifo colls carrier compressed\n");
2432 dev_seq_printf_stats(seq, v);
2436 static struct netif_rx_stats *softnet_get_online(loff_t *pos)
2438 struct netif_rx_stats *rc = NULL;
2440 while (*pos < NR_CPUS)
2441 if (cpu_online(*pos)) {
2442 rc = &per_cpu(netdev_rx_stat, *pos);
2449 static void *softnet_seq_start(struct seq_file *seq, loff_t *pos)
2451 return softnet_get_online(pos);
2454 static void *softnet_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2457 return softnet_get_online(pos);
2460 static void softnet_seq_stop(struct seq_file *seq, void *v)
2464 static int softnet_seq_show(struct seq_file *seq, void *v)
2466 struct netif_rx_stats *s = v;
2468 seq_printf(seq, "%08x %08x %08x %08x %08x %08x %08x %08x %08x\n",
2469 s->total, s->dropped, s->time_squeeze, 0,
2470 0, 0, 0, 0, /* was fastroute */
2475 static const struct seq_operations dev_seq_ops = {
2476 .start = dev_seq_start,
2477 .next = dev_seq_next,
2478 .stop = dev_seq_stop,
2479 .show = dev_seq_show,
2482 static int dev_seq_open(struct inode *inode, struct file *file)
2484 return seq_open_net(inode, file, &dev_seq_ops,
2485 sizeof(struct seq_net_private));
2488 static const struct file_operations dev_seq_fops = {
2489 .owner = THIS_MODULE,
2490 .open = dev_seq_open,
2492 .llseek = seq_lseek,
2493 .release = seq_release_net,
2496 static const struct seq_operations softnet_seq_ops = {
2497 .start = softnet_seq_start,
2498 .next = softnet_seq_next,
2499 .stop = softnet_seq_stop,
2500 .show = softnet_seq_show,
2503 static int softnet_seq_open(struct inode *inode, struct file *file)
2505 return seq_open(file, &softnet_seq_ops);
2508 static const struct file_operations softnet_seq_fops = {
2509 .owner = THIS_MODULE,
2510 .open = softnet_seq_open,
2512 .llseek = seq_lseek,
2513 .release = seq_release,
2516 static void *ptype_get_idx(loff_t pos)
2518 struct packet_type *pt = NULL;
2522 list_for_each_entry_rcu(pt, &ptype_all, list) {
2528 for (t = 0; t < 16; t++) {
2529 list_for_each_entry_rcu(pt, &ptype_base[t], list) {
2538 static void *ptype_seq_start(struct seq_file *seq, loff_t *pos)
2541 return *pos ? ptype_get_idx(*pos - 1) : SEQ_START_TOKEN;
2544 static void *ptype_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2546 struct packet_type *pt;
2547 struct list_head *nxt;
2551 if (v == SEQ_START_TOKEN)
2552 return ptype_get_idx(0);
2555 nxt = pt->list.next;
2556 if (pt->type == htons(ETH_P_ALL)) {
2557 if (nxt != &ptype_all)
2560 nxt = ptype_base[0].next;
2562 hash = ntohs(pt->type) & 15;
2564 while (nxt == &ptype_base[hash]) {
2567 nxt = ptype_base[hash].next;
2570 return list_entry(nxt, struct packet_type, list);
2573 static void ptype_seq_stop(struct seq_file *seq, void *v)
2578 static void ptype_seq_decode(struct seq_file *seq, void *sym)
2580 #ifdef CONFIG_KALLSYMS
2581 unsigned long offset = 0, symsize;
2582 const char *symname;
2586 symname = kallsyms_lookup((unsigned long)sym, &symsize, &offset,
2593 modname = delim = "";
2594 seq_printf(seq, "%s%s%s%s+0x%lx", delim, modname, delim,
2600 seq_printf(seq, "[%p]", sym);
2603 static int ptype_seq_show(struct seq_file *seq, void *v)
2605 struct packet_type *pt = v;
2607 if (v == SEQ_START_TOKEN)
2608 seq_puts(seq, "Type Device Function\n");
2610 if (pt->type == htons(ETH_P_ALL))
2611 seq_puts(seq, "ALL ");
2613 seq_printf(seq, "%04x", ntohs(pt->type));
2615 seq_printf(seq, " %-8s ",
2616 pt->dev ? pt->dev->name : "");
2617 ptype_seq_decode(seq, pt->func);
2618 seq_putc(seq, '\n');
2624 static const struct seq_operations ptype_seq_ops = {
2625 .start = ptype_seq_start,
2626 .next = ptype_seq_next,
2627 .stop = ptype_seq_stop,
2628 .show = ptype_seq_show,
2631 static int ptype_seq_open(struct inode *inode, struct file *file)
2633 return seq_open(file, &ptype_seq_ops);
2636 static const struct file_operations ptype_seq_fops = {
2637 .owner = THIS_MODULE,
2638 .open = ptype_seq_open,
2640 .llseek = seq_lseek,
2641 .release = seq_release,
2645 static int __net_init dev_proc_net_init(struct net *net)
2649 if (!proc_net_fops_create(net, "dev", S_IRUGO, &dev_seq_fops))
2651 if (!proc_net_fops_create(net, "softnet_stat", S_IRUGO, &softnet_seq_fops))
2653 if (!proc_net_fops_create(net, "ptype", S_IRUGO, &ptype_seq_fops))
2656 if (wext_proc_init(net))
2662 proc_net_remove(net, "ptype");
2664 proc_net_remove(net, "softnet_stat");
2666 proc_net_remove(net, "dev");
2670 static void __net_exit dev_proc_net_exit(struct net *net)
2672 wext_proc_exit(net);
2674 proc_net_remove(net, "ptype");
2675 proc_net_remove(net, "softnet_stat");
2676 proc_net_remove(net, "dev");
2679 static struct pernet_operations __net_initdata dev_proc_ops = {
2680 .init = dev_proc_net_init,
2681 .exit = dev_proc_net_exit,
2684 static int __init dev_proc_init(void)
2686 return register_pernet_subsys(&dev_proc_ops);
2689 #define dev_proc_init() 0
2690 #endif /* CONFIG_PROC_FS */
2694 * netdev_set_master - set up master/slave pair
2695 * @slave: slave device
2696 * @master: new master device
2698 * Changes the master device of the slave. Pass %NULL to break the
2699 * bonding. The caller must hold the RTNL semaphore. On a failure
2700 * a negative errno code is returned. On success the reference counts
2701 * are adjusted, %RTM_NEWLINK is sent to the routing socket and the
2702 * function returns zero.
2704 int netdev_set_master(struct net_device *slave, struct net_device *master)
2706 struct net_device *old = slave->master;
2716 slave->master = master;
2724 slave->flags |= IFF_SLAVE;
2726 slave->flags &= ~IFF_SLAVE;
2728 rtmsg_ifinfo(RTM_NEWLINK, slave, IFF_SLAVE);
2732 static void __dev_set_promiscuity(struct net_device *dev, int inc)
2734 unsigned short old_flags = dev->flags;
2738 if ((dev->promiscuity += inc) == 0)
2739 dev->flags &= ~IFF_PROMISC;
2741 dev->flags |= IFF_PROMISC;
2742 if (dev->flags != old_flags) {
2743 printk(KERN_INFO "device %s %s promiscuous mode\n",
2744 dev->name, (dev->flags & IFF_PROMISC) ? "entered" :
2746 audit_log(current->audit_context, GFP_ATOMIC,
2747 AUDIT_ANOM_PROMISCUOUS,
2748 "dev=%s prom=%d old_prom=%d auid=%u",
2749 dev->name, (dev->flags & IFF_PROMISC),
2750 (old_flags & IFF_PROMISC),
2751 audit_get_loginuid(current->audit_context));
2753 if (dev->change_rx_flags)
2754 dev->change_rx_flags(dev, IFF_PROMISC);
2759 * dev_set_promiscuity - update promiscuity count on a device
2763 * Add or remove promiscuity from a device. While the count in the device
2764 * remains above zero the interface remains promiscuous. Once it hits zero
2765 * the device reverts back to normal filtering operation. A negative inc
2766 * value is used to drop promiscuity on the device.
2768 void dev_set_promiscuity(struct net_device *dev, int inc)
2770 unsigned short old_flags = dev->flags;
2772 __dev_set_promiscuity(dev, inc);
2773 if (dev->flags != old_flags)
2774 dev_set_rx_mode(dev);
2778 * dev_set_allmulti - update allmulti count on a device
2782 * Add or remove reception of all multicast frames to a device. While the
2783 * count in the device remains above zero the interface remains listening
2784 * to all interfaces. Once it hits zero the device reverts back to normal
2785 * filtering operation. A negative @inc value is used to drop the counter
2786 * when releasing a resource needing all multicasts.
2789 void dev_set_allmulti(struct net_device *dev, int inc)
2791 unsigned short old_flags = dev->flags;
2795 dev->flags |= IFF_ALLMULTI;
2796 if ((dev->allmulti += inc) == 0)
2797 dev->flags &= ~IFF_ALLMULTI;
2798 if (dev->flags ^ old_flags) {
2799 if (dev->change_rx_flags)
2800 dev->change_rx_flags(dev, IFF_ALLMULTI);
2801 dev_set_rx_mode(dev);
2806 * Upload unicast and multicast address lists to device and
2807 * configure RX filtering. When the device doesn't support unicast
2808 * filtering it is put in promiscuous mode while unicast addresses
2811 void __dev_set_rx_mode(struct net_device *dev)
2813 /* dev_open will call this function so the list will stay sane. */
2814 if (!(dev->flags&IFF_UP))
2817 if (!netif_device_present(dev))
2820 if (dev->set_rx_mode)
2821 dev->set_rx_mode(dev);
2823 /* Unicast addresses changes may only happen under the rtnl,
2824 * therefore calling __dev_set_promiscuity here is safe.
2826 if (dev->uc_count > 0 && !dev->uc_promisc) {
2827 __dev_set_promiscuity(dev, 1);
2828 dev->uc_promisc = 1;
2829 } else if (dev->uc_count == 0 && dev->uc_promisc) {
2830 __dev_set_promiscuity(dev, -1);
2831 dev->uc_promisc = 0;
2834 if (dev->set_multicast_list)
2835 dev->set_multicast_list(dev);
2839 void dev_set_rx_mode(struct net_device *dev)
2841 netif_tx_lock_bh(dev);
2842 __dev_set_rx_mode(dev);
2843 netif_tx_unlock_bh(dev);
2846 int __dev_addr_delete(struct dev_addr_list **list, int *count,
2847 void *addr, int alen, int glbl)
2849 struct dev_addr_list *da;
2851 for (; (da = *list) != NULL; list = &da->next) {
2852 if (memcmp(da->da_addr, addr, da->da_addrlen) == 0 &&
2853 alen == da->da_addrlen) {
2855 int old_glbl = da->da_gusers;
2872 int __dev_addr_add(struct dev_addr_list **list, int *count,
2873 void *addr, int alen, int glbl)
2875 struct dev_addr_list *da;
2877 for (da = *list; da != NULL; da = da->next) {
2878 if (memcmp(da->da_addr, addr, da->da_addrlen) == 0 &&
2879 da->da_addrlen == alen) {
2881 int old_glbl = da->da_gusers;
2891 da = kmalloc(sizeof(*da), GFP_ATOMIC);
2894 memcpy(da->da_addr, addr, alen);
2895 da->da_addrlen = alen;
2897 da->da_gusers = glbl ? 1 : 0;
2905 * dev_unicast_delete - Release secondary unicast address.
2907 * @addr: address to delete
2908 * @alen: length of @addr
2910 * Release reference to a secondary unicast address and remove it
2911 * from the device if the reference count drops to zero.
2913 * The caller must hold the rtnl_mutex.
2915 int dev_unicast_delete(struct net_device *dev, void *addr, int alen)
2921 netif_tx_lock_bh(dev);
2922 err = __dev_addr_delete(&dev->uc_list, &dev->uc_count, addr, alen, 0);
2924 __dev_set_rx_mode(dev);
2925 netif_tx_unlock_bh(dev);
2928 EXPORT_SYMBOL(dev_unicast_delete);
2931 * dev_unicast_add - add a secondary unicast address
2933 * @addr: address to delete
2934 * @alen: length of @addr
2936 * Add a secondary unicast address to the device or increase
2937 * the reference count if it already exists.
2939 * The caller must hold the rtnl_mutex.
2941 int dev_unicast_add(struct net_device *dev, void *addr, int alen)
2947 netif_tx_lock_bh(dev);
2948 err = __dev_addr_add(&dev->uc_list, &dev->uc_count, addr, alen, 0);
2950 __dev_set_rx_mode(dev);
2951 netif_tx_unlock_bh(dev);
2954 EXPORT_SYMBOL(dev_unicast_add);
2956 static void __dev_addr_discard(struct dev_addr_list **list)
2958 struct dev_addr_list *tmp;
2960 while (*list != NULL) {
2963 if (tmp->da_users > tmp->da_gusers)
2964 printk("__dev_addr_discard: address leakage! "
2965 "da_users=%d\n", tmp->da_users);
2970 static void dev_addr_discard(struct net_device *dev)
2972 netif_tx_lock_bh(dev);
2974 __dev_addr_discard(&dev->uc_list);
2977 __dev_addr_discard(&dev->mc_list);
2980 netif_tx_unlock_bh(dev);
2983 unsigned dev_get_flags(const struct net_device *dev)
2987 flags = (dev->flags & ~(IFF_PROMISC |
2992 (dev->gflags & (IFF_PROMISC |
2995 if (netif_running(dev)) {
2996 if (netif_oper_up(dev))
2997 flags |= IFF_RUNNING;
2998 if (netif_carrier_ok(dev))
2999 flags |= IFF_LOWER_UP;
3000 if (netif_dormant(dev))
3001 flags |= IFF_DORMANT;
3007 int dev_change_flags(struct net_device *dev, unsigned flags)
3010 int old_flags = dev->flags;
3015 * Set the flags on our device.
3018 dev->flags = (flags & (IFF_DEBUG | IFF_NOTRAILERS | IFF_NOARP |
3019 IFF_DYNAMIC | IFF_MULTICAST | IFF_PORTSEL |
3021 (dev->flags & (IFF_UP | IFF_VOLATILE | IFF_PROMISC |
3025 * Load in the correct multicast list now the flags have changed.
3028 if (dev->change_rx_flags && (dev->flags ^ flags) & IFF_MULTICAST)
3029 dev->change_rx_flags(dev, IFF_MULTICAST);
3031 dev_set_rx_mode(dev);
3034 * Have we downed the interface. We handle IFF_UP ourselves
3035 * according to user attempts to set it, rather than blindly
3040 if ((old_flags ^ flags) & IFF_UP) { /* Bit is different ? */
3041 ret = ((old_flags & IFF_UP) ? dev_close : dev_open)(dev);
3044 dev_set_rx_mode(dev);
3047 if (dev->flags & IFF_UP &&
3048 ((old_flags ^ dev->flags) &~ (IFF_UP | IFF_PROMISC | IFF_ALLMULTI |
3050 call_netdevice_notifiers(NETDEV_CHANGE, dev);
3052 if ((flags ^ dev->gflags) & IFF_PROMISC) {
3053 int inc = (flags & IFF_PROMISC) ? +1 : -1;
3054 dev->gflags ^= IFF_PROMISC;
3055 dev_set_promiscuity(dev, inc);
3058 /* NOTE: order of synchronization of IFF_PROMISC and IFF_ALLMULTI
3059 is important. Some (broken) drivers set IFF_PROMISC, when
3060 IFF_ALLMULTI is requested not asking us and not reporting.
3062 if ((flags ^ dev->gflags) & IFF_ALLMULTI) {
3063 int inc = (flags & IFF_ALLMULTI) ? +1 : -1;
3064 dev->gflags ^= IFF_ALLMULTI;
3065 dev_set_allmulti(dev, inc);
3068 /* Exclude state transition flags, already notified */
3069 changes = (old_flags ^ dev->flags) & ~(IFF_UP | IFF_RUNNING);
3071 rtmsg_ifinfo(RTM_NEWLINK, dev, changes);
3076 int dev_set_mtu(struct net_device *dev, int new_mtu)
3080 if (new_mtu == dev->mtu)
3083 /* MTU must be positive. */
3087 if (!netif_device_present(dev))
3091 if (dev->change_mtu)
3092 err = dev->change_mtu(dev, new_mtu);
3095 if (!err && dev->flags & IFF_UP)
3096 call_netdevice_notifiers(NETDEV_CHANGEMTU, dev);
3100 int dev_set_mac_address(struct net_device *dev, struct sockaddr *sa)
3104 if (!dev->set_mac_address)
3106 if (sa->sa_family != dev->type)
3108 if (!netif_device_present(dev))
3110 err = dev->set_mac_address(dev, sa);
3112 call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
3117 * Perform the SIOCxIFxxx calls, inside read_lock(dev_base_lock)
3119 static int dev_ifsioc_locked(struct net *net, struct ifreq *ifr, unsigned int cmd)
3122 struct net_device *dev = __dev_get_by_name(net, ifr->ifr_name);
3128 case SIOCGIFFLAGS: /* Get interface flags */
3129 ifr->ifr_flags = dev_get_flags(dev);
3132 case SIOCGIFMETRIC: /* Get the metric on the interface
3133 (currently unused) */
3134 ifr->ifr_metric = 0;
3137 case SIOCGIFMTU: /* Get the MTU of a device */
3138 ifr->ifr_mtu = dev->mtu;
3143 memset(ifr->ifr_hwaddr.sa_data, 0, sizeof ifr->ifr_hwaddr.sa_data);
3145 memcpy(ifr->ifr_hwaddr.sa_data, dev->dev_addr,
3146 min(sizeof ifr->ifr_hwaddr.sa_data, (size_t) dev->addr_len));
3147 ifr->ifr_hwaddr.sa_family = dev->type;
3155 ifr->ifr_map.mem_start = dev->mem_start;
3156 ifr->ifr_map.mem_end = dev->mem_end;
3157 ifr->ifr_map.base_addr = dev->base_addr;
3158 ifr->ifr_map.irq = dev->irq;
3159 ifr->ifr_map.dma = dev->dma;
3160 ifr->ifr_map.port = dev->if_port;
3164 ifr->ifr_ifindex = dev->ifindex;
3168 ifr->ifr_qlen = dev->tx_queue_len;
3172 /* dev_ioctl() should ensure this case
3184 * Perform the SIOCxIFxxx calls, inside rtnl_lock()
3186 static int dev_ifsioc(struct net *net, struct ifreq *ifr, unsigned int cmd)
3189 struct net_device *dev = __dev_get_by_name(net, ifr->ifr_name);
3195 case SIOCSIFFLAGS: /* Set interface flags */
3196 return dev_change_flags(dev, ifr->ifr_flags);
3198 case SIOCSIFMETRIC: /* Set the metric on the interface
3199 (currently unused) */
3202 case SIOCSIFMTU: /* Set the MTU of a device */
3203 return dev_set_mtu(dev, ifr->ifr_mtu);
3206 return dev_set_mac_address(dev, &ifr->ifr_hwaddr);
3208 case SIOCSIFHWBROADCAST:
3209 if (ifr->ifr_hwaddr.sa_family != dev->type)
3211 memcpy(dev->broadcast, ifr->ifr_hwaddr.sa_data,
3212 min(sizeof ifr->ifr_hwaddr.sa_data, (size_t) dev->addr_len));
3213 call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
3217 if (dev->set_config) {
3218 if (!netif_device_present(dev))
3220 return dev->set_config(dev, &ifr->ifr_map);
3225 if (!dev->set_multicast_list ||
3226 ifr->ifr_hwaddr.sa_family != AF_UNSPEC)
3228 if (!netif_device_present(dev))
3230 return dev_mc_add(dev, ifr->ifr_hwaddr.sa_data,
3234 if (!dev->set_multicast_list ||
3235 ifr->ifr_hwaddr.sa_family != AF_UNSPEC)
3237 if (!netif_device_present(dev))
3239 return dev_mc_delete(dev, ifr->ifr_hwaddr.sa_data,
3243 if (ifr->ifr_qlen < 0)
3245 dev->tx_queue_len = ifr->ifr_qlen;
3249 ifr->ifr_newname[IFNAMSIZ-1] = '\0';
3250 return dev_change_name(dev, ifr->ifr_newname);
3253 * Unknown or private ioctl
3257 if ((cmd >= SIOCDEVPRIVATE &&
3258 cmd <= SIOCDEVPRIVATE + 15) ||
3259 cmd == SIOCBONDENSLAVE ||
3260 cmd == SIOCBONDRELEASE ||
3261 cmd == SIOCBONDSETHWADDR ||
3262 cmd == SIOCBONDSLAVEINFOQUERY ||
3263 cmd == SIOCBONDINFOQUERY ||
3264 cmd == SIOCBONDCHANGEACTIVE ||
3265 cmd == SIOCGMIIPHY ||
3266 cmd == SIOCGMIIREG ||
3267 cmd == SIOCSMIIREG ||
3268 cmd == SIOCBRADDIF ||
3269 cmd == SIOCBRDELIF ||
3270 cmd == SIOCWANDEV) {
3272 if (dev->do_ioctl) {
3273 if (netif_device_present(dev))
3274 err = dev->do_ioctl(dev, ifr,
3287 * This function handles all "interface"-type I/O control requests. The actual
3288 * 'doing' part of this is dev_ifsioc above.
3292 * dev_ioctl - network device ioctl
3293 * @net: the applicable net namespace
3294 * @cmd: command to issue
3295 * @arg: pointer to a struct ifreq in user space
3297 * Issue ioctl functions to devices. This is normally called by the
3298 * user space syscall interfaces but can sometimes be useful for
3299 * other purposes. The return value is the return from the syscall if
3300 * positive or a negative errno code on error.
3303 int dev_ioctl(struct net *net, unsigned int cmd, void __user *arg)
3309 /* One special case: SIOCGIFCONF takes ifconf argument
3310 and requires shared lock, because it sleeps writing
3314 if (cmd == SIOCGIFCONF) {
3316 ret = dev_ifconf(net, (char __user *) arg);
3320 if (cmd == SIOCGIFNAME)
3321 return dev_ifname(net, (struct ifreq __user *)arg);
3323 if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
3326 ifr.ifr_name[IFNAMSIZ-1] = 0;
3328 colon = strchr(ifr.ifr_name, ':');
3333 * See which interface the caller is talking about.
3338 * These ioctl calls:
3339 * - can be done by all.
3340 * - atomic and do not require locking.
3351 dev_load(net, ifr.ifr_name);
3352 read_lock(&dev_base_lock);
3353 ret = dev_ifsioc_locked(net, &ifr, cmd);
3354 read_unlock(&dev_base_lock);
3358 if (copy_to_user(arg, &ifr,
3359 sizeof(struct ifreq)))
3365 dev_load(net, ifr.ifr_name);
3367 ret = dev_ethtool(net, &ifr);
3372 if (copy_to_user(arg, &ifr,
3373 sizeof(struct ifreq)))
3379 * These ioctl calls:
3380 * - require superuser power.
3381 * - require strict serialization.
3387 if (!capable(CAP_NET_ADMIN))
3389 dev_load(net, ifr.ifr_name);
3391 ret = dev_ifsioc(net, &ifr, cmd);
3396 if (copy_to_user(arg, &ifr,
3397 sizeof(struct ifreq)))
3403 * These ioctl calls:
3404 * - require superuser power.
3405 * - require strict serialization.
3406 * - do not return a value
3416 case SIOCSIFHWBROADCAST:
3419 case SIOCBONDENSLAVE:
3420 case SIOCBONDRELEASE:
3421 case SIOCBONDSETHWADDR:
3422 case SIOCBONDCHANGEACTIVE:
3425 if (!capable(CAP_NET_ADMIN))
3428 case SIOCBONDSLAVEINFOQUERY:
3429 case SIOCBONDINFOQUERY:
3430 dev_load(net, ifr.ifr_name);
3432 ret = dev_ifsioc(net, &ifr, cmd);
3437 /* Get the per device memory space. We can add this but
3438 * currently do not support it */
3440 /* Set the per device memory buffer space.
3441 * Not applicable in our case */
3446 * Unknown or private ioctl.
3449 if (cmd == SIOCWANDEV ||
3450 (cmd >= SIOCDEVPRIVATE &&
3451 cmd <= SIOCDEVPRIVATE + 15)) {
3452 dev_load(net, ifr.ifr_name);
3454 ret = dev_ifsioc(net, &ifr, cmd);
3456 if (!ret && copy_to_user(arg, &ifr,
3457 sizeof(struct ifreq)))
3461 /* Take care of Wireless Extensions */
3462 if (cmd >= SIOCIWFIRST && cmd <= SIOCIWLAST)
3463 return wext_handle_ioctl(net, &ifr, cmd, arg);
3470 * dev_new_index - allocate an ifindex
3471 * @net: the applicable net namespace
3473 * Returns a suitable unique value for a new device interface
3474 * number. The caller must hold the rtnl semaphore or the
3475 * dev_base_lock to be sure it remains unique.
3477 static int dev_new_index(struct net *net)
3483 if (!__dev_get_by_index(net, ifindex))
3488 /* Delayed registration/unregisteration */
3489 static DEFINE_SPINLOCK(net_todo_list_lock);
3490 static struct list_head net_todo_list = LIST_HEAD_INIT(net_todo_list);
3492 static void net_set_todo(struct net_device *dev)
3494 spin_lock(&net_todo_list_lock);
3495 list_add_tail(&dev->todo_list, &net_todo_list);
3496 spin_unlock(&net_todo_list_lock);
3499 static void rollback_registered(struct net_device *dev)
3501 BUG_ON(dev_boot_phase);
3504 /* Some devices call without registering for initialization unwind. */
3505 if (dev->reg_state == NETREG_UNINITIALIZED) {
3506 printk(KERN_DEBUG "unregister_netdevice: device %s/%p never "
3507 "was registered\n", dev->name, dev);
3513 BUG_ON(dev->reg_state != NETREG_REGISTERED);
3515 /* If device is running, close it first. */
3518 /* And unlink it from device chain. */
3519 unlist_netdevice(dev);
3521 dev->reg_state = NETREG_UNREGISTERING;
3525 /* Shutdown queueing discipline. */
3529 /* Notify protocols, that we are about to destroy
3530 this device. They should clean all the things.
3532 call_netdevice_notifiers(NETDEV_UNREGISTER, dev);
3535 * Flush the unicast and multicast chains
3537 dev_addr_discard(dev);
3542 /* Notifier chain MUST detach us from master device. */
3543 BUG_TRAP(!dev->master);
3545 /* Remove entries from kobject tree */
3546 netdev_unregister_kobject(dev);
3554 * register_netdevice - register a network device
3555 * @dev: device to register
3557 * Take a completed network device structure and add it to the kernel
3558 * interfaces. A %NETDEV_REGISTER message is sent to the netdev notifier
3559 * chain. 0 is returned on success. A negative errno code is returned
3560 * on a failure to set up the device, or if the name is a duplicate.
3562 * Callers must hold the rtnl semaphore. You may want
3563 * register_netdev() instead of this.
3566 * The locking appears insufficient to guarantee two parallel registers
3567 * will not get the same name.
3570 int register_netdevice(struct net_device *dev)
3572 struct hlist_head *head;
3573 struct hlist_node *p;
3577 BUG_ON(dev_boot_phase);
3582 /* When net_device's are persistent, this will be fatal. */
3583 BUG_ON(dev->reg_state != NETREG_UNINITIALIZED);
3584 BUG_ON(!dev->nd_net);
3587 spin_lock_init(&dev->queue_lock);
3588 spin_lock_init(&dev->_xmit_lock);
3589 netdev_set_lockdep_class(&dev->_xmit_lock, dev->type);
3590 dev->xmit_lock_owner = -1;
3591 spin_lock_init(&dev->ingress_lock);
3595 /* Init, if this function is available */
3597 ret = dev->init(dev);
3605 if (!dev_valid_name(dev->name)) {
3610 dev->ifindex = dev_new_index(net);
3611 if (dev->iflink == -1)
3612 dev->iflink = dev->ifindex;
3614 /* Check for existence of name */
3615 head = dev_name_hash(net, dev->name);
3616 hlist_for_each(p, head) {
3617 struct net_device *d
3618 = hlist_entry(p, struct net_device, name_hlist);
3619 if (!strncmp(d->name, dev->name, IFNAMSIZ)) {
3625 /* Fix illegal checksum combinations */
3626 if ((dev->features & NETIF_F_HW_CSUM) &&
3627 (dev->features & (NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM))) {
3628 printk(KERN_NOTICE "%s: mixed HW and IP checksum settings.\n",
3630 dev->features &= ~(NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM);
3633 if ((dev->features & NETIF_F_NO_CSUM) &&
3634 (dev->features & (NETIF_F_HW_CSUM|NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM))) {
3635 printk(KERN_NOTICE "%s: mixed no checksumming and other settings.\n",
3637 dev->features &= ~(NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM|NETIF_F_HW_CSUM);
3641 /* Fix illegal SG+CSUM combinations. */
3642 if ((dev->features & NETIF_F_SG) &&
3643 !(dev->features & NETIF_F_ALL_CSUM)) {
3644 printk(KERN_NOTICE "%s: Dropping NETIF_F_SG since no checksum feature.\n",
3646 dev->features &= ~NETIF_F_SG;
3649 /* TSO requires that SG is present as well. */
3650 if ((dev->features & NETIF_F_TSO) &&
3651 !(dev->features & NETIF_F_SG)) {
3652 printk(KERN_NOTICE "%s: Dropping NETIF_F_TSO since no SG feature.\n",
3654 dev->features &= ~NETIF_F_TSO;
3656 if (dev->features & NETIF_F_UFO) {
3657 if (!(dev->features & NETIF_F_HW_CSUM)) {
3658 printk(KERN_ERR "%s: Dropping NETIF_F_UFO since no "
3659 "NETIF_F_HW_CSUM feature.\n",
3661 dev->features &= ~NETIF_F_UFO;
3663 if (!(dev->features & NETIF_F_SG)) {
3664 printk(KERN_ERR "%s: Dropping NETIF_F_UFO since no "
3665 "NETIF_F_SG feature.\n",
3667 dev->features &= ~NETIF_F_UFO;
3671 ret = netdev_register_kobject(dev);
3674 dev->reg_state = NETREG_REGISTERED;
3677 * Default initial state at registry is that the
3678 * device is present.
3681 set_bit(__LINK_STATE_PRESENT, &dev->state);
3683 dev_init_scheduler(dev);
3685 list_netdevice(dev);
3687 /* Notify protocols, that a new device appeared. */
3688 ret = call_netdevice_notifiers(NETDEV_REGISTER, dev);
3689 ret = notifier_to_errno(ret);
3691 rollback_registered(dev);
3692 dev->reg_state = NETREG_UNREGISTERED;
3705 * register_netdev - register a network device
3706 * @dev: device to register
3708 * Take a completed network device structure and add it to the kernel
3709 * interfaces. A %NETDEV_REGISTER message is sent to the netdev notifier
3710 * chain. 0 is returned on success. A negative errno code is returned
3711 * on a failure to set up the device, or if the name is a duplicate.
3713 * This is a wrapper around register_netdevice that takes the rtnl semaphore
3714 * and expands the device name if you passed a format string to
3717 int register_netdev(struct net_device *dev)
3724 * If the name is a format string the caller wants us to do a
3727 if (strchr(dev->name, '%')) {
3728 err = dev_alloc_name(dev, dev->name);
3733 err = register_netdevice(dev);
3738 EXPORT_SYMBOL(register_netdev);
3741 * netdev_wait_allrefs - wait until all references are gone.
3743 * This is called when unregistering network devices.
3745 * Any protocol or device that holds a reference should register
3746 * for netdevice notification, and cleanup and put back the
3747 * reference if they receive an UNREGISTER event.
3748 * We can get stuck here if buggy protocols don't correctly
3751 static void netdev_wait_allrefs(struct net_device *dev)
3753 unsigned long rebroadcast_time, warning_time;
3755 rebroadcast_time = warning_time = jiffies;
3756 while (atomic_read(&dev->refcnt) != 0) {
3757 if (time_after(jiffies, rebroadcast_time + 1 * HZ)) {
3760 /* Rebroadcast unregister notification */
3761 call_netdevice_notifiers(NETDEV_UNREGISTER, dev);
3763 if (test_bit(__LINK_STATE_LINKWATCH_PENDING,
3765 /* We must not have linkwatch events
3766 * pending on unregister. If this
3767 * happens, we simply run the queue
3768 * unscheduled, resulting in a noop
3771 linkwatch_run_queue();
3776 rebroadcast_time = jiffies;
3781 if (time_after(jiffies, warning_time + 10 * HZ)) {
3782 printk(KERN_EMERG "unregister_netdevice: "
3783 "waiting for %s to become free. Usage "
3785 dev->name, atomic_read(&dev->refcnt));
3786 warning_time = jiffies;
3795 * register_netdevice(x1);
3796 * register_netdevice(x2);
3798 * unregister_netdevice(y1);
3799 * unregister_netdevice(y2);
3805 * We are invoked by rtnl_unlock() after it drops the semaphore.
3806 * This allows us to deal with problems:
3807 * 1) We can delete sysfs objects which invoke hotplug
3808 * without deadlocking with linkwatch via keventd.
3809 * 2) Since we run with the RTNL semaphore not held, we can sleep
3810 * safely in order to wait for the netdev refcnt to drop to zero.
3812 static DEFINE_MUTEX(net_todo_run_mutex);
3813 void netdev_run_todo(void)
3815 struct list_head list;
3817 /* Need to guard against multiple cpu's getting out of order. */
3818 mutex_lock(&net_todo_run_mutex);
3820 /* Not safe to do outside the semaphore. We must not return
3821 * until all unregister events invoked by the local processor
3822 * have been completed (either by this todo run, or one on
3825 if (list_empty(&net_todo_list))
3828 /* Snapshot list, allow later requests */
3829 spin_lock(&net_todo_list_lock);
3830 list_replace_init(&net_todo_list, &list);
3831 spin_unlock(&net_todo_list_lock);
3833 while (!list_empty(&list)) {
3834 struct net_device *dev
3835 = list_entry(list.next, struct net_device, todo_list);
3836 list_del(&dev->todo_list);
3838 if (unlikely(dev->reg_state != NETREG_UNREGISTERING)) {
3839 printk(KERN_ERR "network todo '%s' but state %d\n",
3840 dev->name, dev->reg_state);
3845 dev->reg_state = NETREG_UNREGISTERED;
3847 netdev_wait_allrefs(dev);
3850 BUG_ON(atomic_read(&dev->refcnt));
3851 BUG_TRAP(!dev->ip_ptr);
3852 BUG_TRAP(!dev->ip6_ptr);
3853 BUG_TRAP(!dev->dn_ptr);
3855 if (dev->destructor)
3856 dev->destructor(dev);
3858 /* Free network device */
3859 kobject_put(&dev->dev.kobj);
3863 mutex_unlock(&net_todo_run_mutex);
3866 static struct net_device_stats *internal_stats(struct net_device *dev)
3872 * alloc_netdev_mq - allocate network device
3873 * @sizeof_priv: size of private data to allocate space for
3874 * @name: device name format string
3875 * @setup: callback to initialize device
3876 * @queue_count: the number of subqueues to allocate
3878 * Allocates a struct net_device with private data area for driver use
3879 * and performs basic initialization. Also allocates subquue structs
3880 * for each queue on the device at the end of the netdevice.
3882 struct net_device *alloc_netdev_mq(int sizeof_priv, const char *name,
3883 void (*setup)(struct net_device *), unsigned int queue_count)
3886 struct net_device *dev;
3889 BUG_ON(strlen(name) >= sizeof(dev->name));
3891 /* ensure 32-byte alignment of both the device and private area */
3892 alloc_size = (sizeof(*dev) + NETDEV_ALIGN_CONST +
3893 (sizeof(struct net_device_subqueue) * (queue_count - 1))) &
3894 ~NETDEV_ALIGN_CONST;
3895 alloc_size += sizeof_priv + NETDEV_ALIGN_CONST;
3897 p = kzalloc(alloc_size, GFP_KERNEL);
3899 printk(KERN_ERR "alloc_netdev: Unable to allocate device.\n");
3903 dev = (struct net_device *)
3904 (((long)p + NETDEV_ALIGN_CONST) & ~NETDEV_ALIGN_CONST);
3905 dev->padded = (char *)dev - (char *)p;
3906 dev->nd_net = &init_net;
3909 dev->priv = ((char *)dev +
3910 ((sizeof(struct net_device) +
3911 (sizeof(struct net_device_subqueue) *
3912 (queue_count - 1)) + NETDEV_ALIGN_CONST)
3913 & ~NETDEV_ALIGN_CONST));
3916 dev->egress_subqueue_count = queue_count;
3918 dev->get_stats = internal_stats;
3919 netpoll_netdev_init(dev);
3921 strcpy(dev->name, name);
3924 EXPORT_SYMBOL(alloc_netdev_mq);
3927 * free_netdev - free network device
3930 * This function does the last stage of destroying an allocated device
3931 * interface. The reference to the device object is released.
3932 * If this is the last reference then it will be freed.
3934 void free_netdev(struct net_device *dev)
3936 /* Compatibility with error handling in drivers */
3937 if (dev->reg_state == NETREG_UNINITIALIZED) {
3938 kfree((char *)dev - dev->padded);
3942 BUG_ON(dev->reg_state != NETREG_UNREGISTERED);
3943 dev->reg_state = NETREG_RELEASED;
3945 /* will free via device release */
3946 put_device(&dev->dev);
3949 /* Synchronize with packet receive processing. */
3950 void synchronize_net(void)
3957 * unregister_netdevice - remove device from the kernel
3960 * This function shuts down a device interface and removes it
3961 * from the kernel tables.
3963 * Callers must hold the rtnl semaphore. You may want
3964 * unregister_netdev() instead of this.
3967 void unregister_netdevice(struct net_device *dev)
3969 rollback_registered(dev);
3970 /* Finish processing unregister after unlock */
3975 * unregister_netdev - remove device from the kernel
3978 * This function shuts down a device interface and removes it
3979 * from the kernel tables.
3981 * This is just a wrapper for unregister_netdevice that takes
3982 * the rtnl semaphore. In general you want to use this and not
3983 * unregister_netdevice.
3985 void unregister_netdev(struct net_device *dev)
3988 unregister_netdevice(dev);
3992 EXPORT_SYMBOL(unregister_netdev);
3995 * dev_change_net_namespace - move device to different nethost namespace
3997 * @net: network namespace
3998 * @pat: If not NULL name pattern to try if the current device name
3999 * is already taken in the destination network namespace.
4001 * This function shuts down a device interface and moves it
4002 * to a new network namespace. On success 0 is returned, on
4003 * a failure a netagive errno code is returned.
4005 * Callers must hold the rtnl semaphore.
4008 int dev_change_net_namespace(struct net_device *dev, struct net *net, const char *pat)
4011 const char *destname;
4016 /* Don't allow namespace local devices to be moved. */
4018 if (dev->features & NETIF_F_NETNS_LOCAL)
4021 /* Ensure the device has been registrered */
4023 if (dev->reg_state != NETREG_REGISTERED)
4026 /* Get out if there is nothing todo */
4028 if (dev->nd_net == net)
4031 /* Pick the destination device name, and ensure
4032 * we can use it in the destination network namespace.
4035 destname = dev->name;
4036 if (__dev_get_by_name(net, destname)) {
4037 /* We get here if we can't use the current device name */
4040 if (!dev_valid_name(pat))
4042 if (strchr(pat, '%')) {
4043 if (__dev_alloc_name(net, pat, buf) < 0)
4048 if (__dev_get_by_name(net, destname))
4053 * And now a mini version of register_netdevice unregister_netdevice.
4056 /* If device is running close it first. */
4059 /* And unlink it from device chain */
4061 unlist_netdevice(dev);
4065 /* Shutdown queueing discipline. */
4068 /* Notify protocols, that we are about to destroy
4069 this device. They should clean all the things.
4071 call_netdevice_notifiers(NETDEV_UNREGISTER, dev);
4074 * Flush the unicast and multicast chains
4076 dev_addr_discard(dev);
4078 /* Actually switch the network namespace */
4081 /* Assign the new device name */
4082 if (destname != dev->name)
4083 strcpy(dev->name, destname);
4085 /* If there is an ifindex conflict assign a new one */
4086 if (__dev_get_by_index(net, dev->ifindex)) {
4087 int iflink = (dev->iflink == dev->ifindex);
4088 dev->ifindex = dev_new_index(net);
4090 dev->iflink = dev->ifindex;
4093 /* Fixup kobjects */
4094 err = device_rename(&dev->dev, dev->name);
4097 /* Add the device back in the hashes */
4098 list_netdevice(dev);
4100 /* Notify protocols, that a new device appeared. */
4101 call_netdevice_notifiers(NETDEV_REGISTER, dev);
4109 static int dev_cpu_callback(struct notifier_block *nfb,
4110 unsigned long action,
4113 struct sk_buff **list_skb;
4114 struct net_device **list_net;
4115 struct sk_buff *skb;
4116 unsigned int cpu, oldcpu = (unsigned long)ocpu;
4117 struct softnet_data *sd, *oldsd;
4119 if (action != CPU_DEAD && action != CPU_DEAD_FROZEN)
4122 local_irq_disable();
4123 cpu = smp_processor_id();
4124 sd = &per_cpu(softnet_data, cpu);
4125 oldsd = &per_cpu(softnet_data, oldcpu);
4127 /* Find end of our completion_queue. */
4128 list_skb = &sd->completion_queue;
4130 list_skb = &(*list_skb)->next;
4131 /* Append completion queue from offline CPU. */
4132 *list_skb = oldsd->completion_queue;
4133 oldsd->completion_queue = NULL;
4135 /* Find end of our output_queue. */
4136 list_net = &sd->output_queue;
4138 list_net = &(*list_net)->next_sched;
4139 /* Append output queue from offline CPU. */
4140 *list_net = oldsd->output_queue;
4141 oldsd->output_queue = NULL;
4143 raise_softirq_irqoff(NET_TX_SOFTIRQ);
4146 /* Process offline CPU's input_pkt_queue */
4147 while ((skb = __skb_dequeue(&oldsd->input_pkt_queue)))
4153 #ifdef CONFIG_NET_DMA
4155 * net_dma_rebalance - try to maintain one DMA channel per CPU
4156 * @net_dma: DMA client and associated data (lock, channels, channel_mask)
4158 * This is called when the number of channels allocated to the net_dma client
4159 * changes. The net_dma client tries to have one DMA channel per CPU.
4162 static void net_dma_rebalance(struct net_dma *net_dma)
4164 unsigned int cpu, i, n, chan_idx;
4165 struct dma_chan *chan;
4167 if (cpus_empty(net_dma->channel_mask)) {
4168 for_each_online_cpu(cpu)
4169 rcu_assign_pointer(per_cpu(softnet_data, cpu).net_dma, NULL);
4174 cpu = first_cpu(cpu_online_map);
4176 for_each_cpu_mask(chan_idx, net_dma->channel_mask) {
4177 chan = net_dma->channels[chan_idx];
4179 n = ((num_online_cpus() / cpus_weight(net_dma->channel_mask))
4180 + (i < (num_online_cpus() %
4181 cpus_weight(net_dma->channel_mask)) ? 1 : 0));
4184 per_cpu(softnet_data, cpu).net_dma = chan;
4185 cpu = next_cpu(cpu, cpu_online_map);
4193 * netdev_dma_event - event callback for the net_dma_client
4194 * @client: should always be net_dma_client
4195 * @chan: DMA channel for the event
4196 * @state: DMA state to be handled
4198 static enum dma_state_client
4199 netdev_dma_event(struct dma_client *client, struct dma_chan *chan,
4200 enum dma_state state)
4202 int i, found = 0, pos = -1;
4203 struct net_dma *net_dma =
4204 container_of(client, struct net_dma, client);
4205 enum dma_state_client ack = DMA_DUP; /* default: take no action */
4207 spin_lock(&net_dma->lock);
4209 case DMA_RESOURCE_AVAILABLE:
4210 for (i = 0; i < NR_CPUS; i++)
4211 if (net_dma->channels[i] == chan) {
4214 } else if (net_dma->channels[i] == NULL && pos < 0)
4217 if (!found && pos >= 0) {
4219 net_dma->channels[pos] = chan;
4220 cpu_set(pos, net_dma->channel_mask);
4221 net_dma_rebalance(net_dma);
4224 case DMA_RESOURCE_REMOVED:
4225 for (i = 0; i < NR_CPUS; i++)
4226 if (net_dma->channels[i] == chan) {
4234 cpu_clear(pos, net_dma->channel_mask);
4235 net_dma->channels[i] = NULL;
4236 net_dma_rebalance(net_dma);
4242 spin_unlock(&net_dma->lock);
4248 * netdev_dma_regiser - register the networking subsystem as a DMA client
4250 static int __init netdev_dma_register(void)
4252 spin_lock_init(&net_dma.lock);
4253 dma_cap_set(DMA_MEMCPY, net_dma.client.cap_mask);
4254 dma_async_client_register(&net_dma.client);
4255 dma_async_client_chan_request(&net_dma.client);
4260 static int __init netdev_dma_register(void) { return -ENODEV; }
4261 #endif /* CONFIG_NET_DMA */
4264 * netdev_compute_feature - compute conjunction of two feature sets
4265 * @all: first feature set
4266 * @one: second feature set
4268 * Computes a new feature set after adding a device with feature set
4269 * @one to the master device with current feature set @all. Returns
4270 * the new feature set.
4272 int netdev_compute_features(unsigned long all, unsigned long one)
4274 /* if device needs checksumming, downgrade to hw checksumming */
4275 if (all & NETIF_F_NO_CSUM && !(one & NETIF_F_NO_CSUM))
4276 all ^= NETIF_F_NO_CSUM | NETIF_F_HW_CSUM;
4278 /* if device can't do all checksum, downgrade to ipv4/ipv6 */
4279 if (all & NETIF_F_HW_CSUM && !(one & NETIF_F_HW_CSUM))
4280 all ^= NETIF_F_HW_CSUM
4281 | NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM;
4283 if (one & NETIF_F_GSO)
4284 one |= NETIF_F_GSO_SOFTWARE;
4287 /* If even one device supports robust GSO, enable it for all. */
4288 if (one & NETIF_F_GSO_ROBUST)
4289 all |= NETIF_F_GSO_ROBUST;
4291 all &= one | NETIF_F_LLTX;
4293 if (!(all & NETIF_F_ALL_CSUM))
4295 if (!(all & NETIF_F_SG))
4296 all &= ~NETIF_F_GSO_MASK;
4300 EXPORT_SYMBOL(netdev_compute_features);
4302 static struct hlist_head *netdev_create_hash(void)
4305 struct hlist_head *hash;
4307 hash = kmalloc(sizeof(*hash) * NETDEV_HASHENTRIES, GFP_KERNEL);
4309 for (i = 0; i < NETDEV_HASHENTRIES; i++)
4310 INIT_HLIST_HEAD(&hash[i]);
4315 /* Initialize per network namespace state */
4316 static int __net_init netdev_init(struct net *net)
4318 INIT_LIST_HEAD(&net->dev_base_head);
4320 net->dev_name_head = netdev_create_hash();
4321 if (net->dev_name_head == NULL)
4324 net->dev_index_head = netdev_create_hash();
4325 if (net->dev_index_head == NULL)
4331 kfree(net->dev_name_head);
4336 static void __net_exit netdev_exit(struct net *net)
4338 kfree(net->dev_name_head);
4339 kfree(net->dev_index_head);
4342 static struct pernet_operations __net_initdata netdev_net_ops = {
4343 .init = netdev_init,
4344 .exit = netdev_exit,
4347 static void __net_exit default_device_exit(struct net *net)
4349 struct net_device *dev, *next;
4351 * Push all migratable of the network devices back to the
4352 * initial network namespace
4355 for_each_netdev_safe(net, dev, next) {
4358 /* Ignore unmoveable devices (i.e. loopback) */
4359 if (dev->features & NETIF_F_NETNS_LOCAL)
4362 /* Push remaing network devices to init_net */
4363 err = dev_change_net_namespace(dev, &init_net, "dev%d");
4365 printk(KERN_WARNING "%s: failed to move %s to init_net: %d\n",
4366 __func__, dev->name, err);
4367 unregister_netdevice(dev);
4373 static struct pernet_operations __net_initdata default_device_ops = {
4374 .exit = default_device_exit,
4378 * Initialize the DEV module. At boot time this walks the device list and
4379 * unhooks any devices that fail to initialise (normally hardware not
4380 * present) and leaves us with a valid list of present and active devices.
4385 * This is called single threaded during boot, so no need
4386 * to take the rtnl semaphore.
4388 static int __init net_dev_init(void)
4390 int i, rc = -ENOMEM;
4392 BUG_ON(!dev_boot_phase);
4394 if (dev_proc_init())
4397 if (netdev_kobject_init())
4400 INIT_LIST_HEAD(&ptype_all);
4401 for (i = 0; i < 16; i++)
4402 INIT_LIST_HEAD(&ptype_base[i]);
4404 if (register_pernet_subsys(&netdev_net_ops))
4407 if (register_pernet_device(&default_device_ops))
4411 * Initialise the packet receive queues.
4414 for_each_possible_cpu(i) {
4415 struct softnet_data *queue;
4417 queue = &per_cpu(softnet_data, i);
4418 skb_queue_head_init(&queue->input_pkt_queue);
4419 queue->completion_queue = NULL;
4420 INIT_LIST_HEAD(&queue->poll_list);
4422 queue->backlog.poll = process_backlog;
4423 queue->backlog.weight = weight_p;
4426 netdev_dma_register();
4430 open_softirq(NET_TX_SOFTIRQ, net_tx_action, NULL);
4431 open_softirq(NET_RX_SOFTIRQ, net_rx_action, NULL);
4433 hotcpu_notifier(dev_cpu_callback, 0);
4441 subsys_initcall(net_dev_init);
4443 EXPORT_SYMBOL(__dev_get_by_index);
4444 EXPORT_SYMBOL(__dev_get_by_name);
4445 EXPORT_SYMBOL(__dev_remove_pack);
4446 EXPORT_SYMBOL(dev_valid_name);
4447 EXPORT_SYMBOL(dev_add_pack);
4448 EXPORT_SYMBOL(dev_alloc_name);
4449 EXPORT_SYMBOL(dev_close);
4450 EXPORT_SYMBOL(dev_get_by_flags);
4451 EXPORT_SYMBOL(dev_get_by_index);
4452 EXPORT_SYMBOL(dev_get_by_name);
4453 EXPORT_SYMBOL(dev_open);
4454 EXPORT_SYMBOL(dev_queue_xmit);
4455 EXPORT_SYMBOL(dev_remove_pack);
4456 EXPORT_SYMBOL(dev_set_allmulti);
4457 EXPORT_SYMBOL(dev_set_promiscuity);
4458 EXPORT_SYMBOL(dev_change_flags);
4459 EXPORT_SYMBOL(dev_set_mtu);
4460 EXPORT_SYMBOL(dev_set_mac_address);
4461 EXPORT_SYMBOL(free_netdev);
4462 EXPORT_SYMBOL(netdev_boot_setup_check);
4463 EXPORT_SYMBOL(netdev_set_master);
4464 EXPORT_SYMBOL(netdev_state_change);
4465 EXPORT_SYMBOL(netif_receive_skb);
4466 EXPORT_SYMBOL(netif_rx);
4467 EXPORT_SYMBOL(register_gifconf);
4468 EXPORT_SYMBOL(register_netdevice);
4469 EXPORT_SYMBOL(register_netdevice_notifier);
4470 EXPORT_SYMBOL(skb_checksum_help);
4471 EXPORT_SYMBOL(synchronize_net);
4472 EXPORT_SYMBOL(unregister_netdevice);
4473 EXPORT_SYMBOL(unregister_netdevice_notifier);
4474 EXPORT_SYMBOL(net_enable_timestamp);
4475 EXPORT_SYMBOL(net_disable_timestamp);
4476 EXPORT_SYMBOL(dev_get_flags);
4478 #if defined(CONFIG_BRIDGE) || defined(CONFIG_BRIDGE_MODULE)
4479 EXPORT_SYMBOL(br_handle_frame_hook);
4480 EXPORT_SYMBOL(br_fdb_get_hook);
4481 EXPORT_SYMBOL(br_fdb_put_hook);
4485 EXPORT_SYMBOL(dev_load);
4488 EXPORT_PER_CPU_SYMBOL(softnet_data);