2 * NET3 Protocol independent device support routines.
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License
6 * as published by the Free Software Foundation; either version
7 * 2 of the License, or (at your option) any later version.
9 * Derived from the non IP parts of dev.c 1.0.19
11 * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
12 * Mark Evans, <evansmp@uhura.aston.ac.uk>
15 * Florian la Roche <rzsfl@rz.uni-sb.de>
16 * Alan Cox <gw4pts@gw4pts.ampr.org>
17 * David Hinds <dahinds@users.sourceforge.net>
18 * Alexey Kuznetsov <kuznet@ms2.inr.ac.ru>
19 * Adam Sulmicki <adam@cfar.umd.edu>
20 * Pekka Riikonen <priikone@poesidon.pspt.fi>
23 * D.J. Barrow : Fixed bug where dev->refcnt gets set
24 * to 2 if register_netdev gets called
25 * before net_dev_init & also removed a
26 * few lines of code in the process.
27 * Alan Cox : device private ioctl copies fields back.
28 * Alan Cox : Transmit queue code does relevant
29 * stunts to keep the queue safe.
30 * Alan Cox : Fixed double lock.
31 * Alan Cox : Fixed promisc NULL pointer trap
32 * ???????? : Support the full private ioctl range
33 * Alan Cox : Moved ioctl permission check into
35 * Tim Kordas : SIOCADDMULTI/SIOCDELMULTI
36 * Alan Cox : 100 backlog just doesn't cut it when
37 * you start doing multicast video 8)
38 * Alan Cox : Rewrote net_bh and list manager.
39 * Alan Cox : Fix ETH_P_ALL echoback lengths.
40 * Alan Cox : Took out transmit every packet pass
41 * Saved a few bytes in the ioctl handler
42 * Alan Cox : Network driver sets packet type before
43 * calling netif_rx. Saves a function
45 * Alan Cox : Hashed net_bh()
46 * Richard Kooijman: Timestamp fixes.
47 * Alan Cox : Wrong field in SIOCGIFDSTADDR
48 * Alan Cox : Device lock protection.
49 * Alan Cox : Fixed nasty side effect of device close
51 * Rudi Cilibrasi : Pass the right thing to
53 * Dave Miller : 32bit quantity for the device lock to
54 * make it work out on a Sparc.
55 * Bjorn Ekwall : Added KERNELD hack.
56 * Alan Cox : Cleaned up the backlog initialise.
57 * Craig Metz : SIOCGIFCONF fix if space for under
59 * Thomas Bogendoerfer : Return ENODEV for dev_open, if there
60 * is no device open function.
61 * Andi Kleen : Fix error reporting for SIOCGIFCONF
62 * Michael Chastain : Fix signed/unsigned for SIOCGIFCONF
63 * Cyrus Durgin : Cleaned for KMOD
64 * Adam Sulmicki : Bug Fix : Network Device Unload
65 * A network device unload needs to purge
67 * Paul Rusty Russell : SIOCSIFNAME
68 * Pekka Riikonen : Netdev boot-time settings code
69 * Andrew Morton : Make unregister_netdevice wait
70 * indefinitely on dev->refcnt
71 * J Hadi Salim : - Backlog queue sampling
72 * - netif_rx() feedback
75 #include <asm/uaccess.h>
76 #include <asm/system.h>
77 #include <linux/bitops.h>
78 #include <linux/capability.h>
79 #include <linux/cpu.h>
80 #include <linux/types.h>
81 #include <linux/kernel.h>
82 #include <linux/sched.h>
83 #include <linux/mutex.h>
84 #include <linux/string.h>
86 #include <linux/socket.h>
87 #include <linux/sockios.h>
88 #include <linux/errno.h>
89 #include <linux/interrupt.h>
90 #include <linux/if_ether.h>
91 #include <linux/netdevice.h>
92 #include <linux/etherdevice.h>
93 #include <linux/notifier.h>
94 #include <linux/skbuff.h>
95 #include <net/net_namespace.h>
97 #include <linux/rtnetlink.h>
98 #include <linux/proc_fs.h>
99 #include <linux/seq_file.h>
100 #include <linux/stat.h>
101 #include <linux/if_bridge.h>
102 #include <linux/if_macvlan.h>
104 #include <net/pkt_sched.h>
105 #include <net/checksum.h>
106 #include <linux/highmem.h>
107 #include <linux/init.h>
108 #include <linux/kmod.h>
109 #include <linux/module.h>
110 #include <linux/kallsyms.h>
111 #include <linux/netpoll.h>
112 #include <linux/rcupdate.h>
113 #include <linux/delay.h>
114 #include <net/wext.h>
115 #include <net/iw_handler.h>
116 #include <asm/current.h>
117 #include <linux/audit.h>
118 #include <linux/dmaengine.h>
119 #include <linux/err.h>
120 #include <linux/ctype.h>
121 #include <linux/if_arp.h>
124 * The list of packet types we will receive (as opposed to discard)
125 * and the routines to invoke.
127 * Why 16. Because with 16 the only overlap we get on a hash of the
128 * low nibble of the protocol value is RARP/SNAP/X.25.
130 * NOTE: That is no longer true with the addition of VLAN tags. Not
131 * sure which should go first, but I bet it won't make much
132 * difference if we are running VLANs. The good news is that
133 * this protocol won't be in the list unless compiled in, so
134 * the average user (w/out VLANs) will not be adversely affected.
151 static DEFINE_SPINLOCK(ptype_lock);
152 static struct list_head ptype_base[16] __read_mostly; /* 16 way hashed list */
153 static struct list_head ptype_all __read_mostly; /* Taps */
155 #ifdef CONFIG_NET_DMA
157 struct dma_client client;
159 cpumask_t channel_mask;
160 struct dma_chan *channels[NR_CPUS];
163 static enum dma_state_client
164 netdev_dma_event(struct dma_client *client, struct dma_chan *chan,
165 enum dma_state state);
167 static struct net_dma net_dma = {
169 .event_callback = netdev_dma_event,
175 * The @dev_base_head list is protected by @dev_base_lock and the rtnl
178 * Pure readers hold dev_base_lock for reading.
180 * Writers must hold the rtnl semaphore while they loop through the
181 * dev_base_head list, and hold dev_base_lock for writing when they do the
182 * actual updates. This allows pure readers to access the list even
183 * while a writer is preparing to update it.
185 * To put it another way, dev_base_lock is held for writing only to
186 * protect against pure readers; the rtnl semaphore provides the
187 * protection against other writers.
189 * See, for example usages, register_netdevice() and
190 * unregister_netdevice(), which must be called with the rtnl
193 DEFINE_RWLOCK(dev_base_lock);
195 EXPORT_SYMBOL(dev_base_lock);
197 #define NETDEV_HASHBITS 8
198 #define NETDEV_HASHENTRIES (1 << NETDEV_HASHBITS)
200 static inline struct hlist_head *dev_name_hash(struct net *net, const char *name)
202 unsigned hash = full_name_hash(name, strnlen(name, IFNAMSIZ));
203 return &net->dev_name_head[hash & ((1 << NETDEV_HASHBITS) - 1)];
206 static inline struct hlist_head *dev_index_hash(struct net *net, int ifindex)
208 return &net->dev_index_head[ifindex & ((1 << NETDEV_HASHBITS) - 1)];
211 /* Device list insertion */
212 static int list_netdevice(struct net_device *dev)
214 struct net *net = dev->nd_net;
218 write_lock_bh(&dev_base_lock);
219 list_add_tail(&dev->dev_list, &net->dev_base_head);
220 hlist_add_head(&dev->name_hlist, dev_name_hash(net, dev->name));
221 hlist_add_head(&dev->index_hlist, dev_index_hash(net, dev->ifindex));
222 write_unlock_bh(&dev_base_lock);
226 /* Device list removal */
227 static void unlist_netdevice(struct net_device *dev)
231 /* Unlink dev from the device chain */
232 write_lock_bh(&dev_base_lock);
233 list_del(&dev->dev_list);
234 hlist_del(&dev->name_hlist);
235 hlist_del(&dev->index_hlist);
236 write_unlock_bh(&dev_base_lock);
243 static RAW_NOTIFIER_HEAD(netdev_chain);
246 * Device drivers call our routines to queue packets here. We empty the
247 * queue in the local softnet handler.
250 DEFINE_PER_CPU(struct softnet_data, softnet_data);
252 extern int netdev_kobject_init(void);
253 extern int netdev_register_kobject(struct net_device *);
254 extern void netdev_unregister_kobject(struct net_device *);
256 #ifdef CONFIG_DEBUG_LOCK_ALLOC
258 * register_netdevice() inits dev->_xmit_lock and sets lockdep class
259 * according to dev->type
261 static const unsigned short netdev_lock_type[] =
262 {ARPHRD_NETROM, ARPHRD_ETHER, ARPHRD_EETHER, ARPHRD_AX25,
263 ARPHRD_PRONET, ARPHRD_CHAOS, ARPHRD_IEEE802, ARPHRD_ARCNET,
264 ARPHRD_APPLETLK, ARPHRD_DLCI, ARPHRD_ATM, ARPHRD_METRICOM,
265 ARPHRD_IEEE1394, ARPHRD_EUI64, ARPHRD_INFINIBAND, ARPHRD_SLIP,
266 ARPHRD_CSLIP, ARPHRD_SLIP6, ARPHRD_CSLIP6, ARPHRD_RSRVD,
267 ARPHRD_ADAPT, ARPHRD_ROSE, ARPHRD_X25, ARPHRD_HWX25,
268 ARPHRD_PPP, ARPHRD_CISCO, ARPHRD_LAPB, ARPHRD_DDCMP,
269 ARPHRD_RAWHDLC, ARPHRD_TUNNEL, ARPHRD_TUNNEL6, ARPHRD_FRAD,
270 ARPHRD_SKIP, ARPHRD_LOOPBACK, ARPHRD_LOCALTLK, ARPHRD_FDDI,
271 ARPHRD_BIF, ARPHRD_SIT, ARPHRD_IPDDP, ARPHRD_IPGRE,
272 ARPHRD_PIMREG, ARPHRD_HIPPI, ARPHRD_ASH, ARPHRD_ECONET,
273 ARPHRD_IRDA, ARPHRD_FCPP, ARPHRD_FCAL, ARPHRD_FCPL,
274 ARPHRD_FCFABRIC, ARPHRD_IEEE802_TR, ARPHRD_IEEE80211,
275 ARPHRD_IEEE80211_PRISM, ARPHRD_IEEE80211_RADIOTAP, ARPHRD_VOID,
278 static const char *netdev_lock_name[] =
279 {"_xmit_NETROM", "_xmit_ETHER", "_xmit_EETHER", "_xmit_AX25",
280 "_xmit_PRONET", "_xmit_CHAOS", "_xmit_IEEE802", "_xmit_ARCNET",
281 "_xmit_APPLETLK", "_xmit_DLCI", "_xmit_ATM", "_xmit_METRICOM",
282 "_xmit_IEEE1394", "_xmit_EUI64", "_xmit_INFINIBAND", "_xmit_SLIP",
283 "_xmit_CSLIP", "_xmit_SLIP6", "_xmit_CSLIP6", "_xmit_RSRVD",
284 "_xmit_ADAPT", "_xmit_ROSE", "_xmit_X25", "_xmit_HWX25",
285 "_xmit_PPP", "_xmit_CISCO", "_xmit_LAPB", "_xmit_DDCMP",
286 "_xmit_RAWHDLC", "_xmit_TUNNEL", "_xmit_TUNNEL6", "_xmit_FRAD",
287 "_xmit_SKIP", "_xmit_LOOPBACK", "_xmit_LOCALTLK", "_xmit_FDDI",
288 "_xmit_BIF", "_xmit_SIT", "_xmit_IPDDP", "_xmit_IPGRE",
289 "_xmit_PIMREG", "_xmit_HIPPI", "_xmit_ASH", "_xmit_ECONET",
290 "_xmit_IRDA", "_xmit_FCPP", "_xmit_FCAL", "_xmit_FCPL",
291 "_xmit_FCFABRIC", "_xmit_IEEE802_TR", "_xmit_IEEE80211",
292 "_xmit_IEEE80211_PRISM", "_xmit_IEEE80211_RADIOTAP", "_xmit_VOID",
295 static struct lock_class_key netdev_xmit_lock_key[ARRAY_SIZE(netdev_lock_type)];
297 static inline unsigned short netdev_lock_pos(unsigned short dev_type)
301 for (i = 0; i < ARRAY_SIZE(netdev_lock_type); i++)
302 if (netdev_lock_type[i] == dev_type)
304 /* the last key is used by default */
305 return ARRAY_SIZE(netdev_lock_type) - 1;
308 static inline void netdev_set_lockdep_class(spinlock_t *lock,
309 unsigned short dev_type)
313 i = netdev_lock_pos(dev_type);
314 lockdep_set_class_and_name(lock, &netdev_xmit_lock_key[i],
315 netdev_lock_name[i]);
318 static inline void netdev_set_lockdep_class(spinlock_t *lock,
319 unsigned short dev_type)
324 /*******************************************************************************
326 Protocol management and registration routines
328 *******************************************************************************/
331 * Add a protocol ID to the list. Now that the input handler is
332 * smarter we can dispense with all the messy stuff that used to be
335 * BEWARE!!! Protocol handlers, mangling input packets,
336 * MUST BE last in hash buckets and checking protocol handlers
337 * MUST start from promiscuous ptype_all chain in net_bh.
338 * It is true now, do not change it.
339 * Explanation follows: if protocol handler, mangling packet, will
340 * be the first on list, it is not able to sense, that packet
341 * is cloned and should be copied-on-write, so that it will
342 * change it and subsequent readers will get broken packet.
347 * dev_add_pack - add packet handler
348 * @pt: packet type declaration
350 * Add a protocol handler to the networking stack. The passed &packet_type
351 * is linked into kernel lists and may not be freed until it has been
352 * removed from the kernel lists.
354 * This call does not sleep therefore it can not
355 * guarantee all CPU's that are in middle of receiving packets
356 * will see the new packet type (until the next received packet).
359 void dev_add_pack(struct packet_type *pt)
363 spin_lock_bh(&ptype_lock);
364 if (pt->type == htons(ETH_P_ALL))
365 list_add_rcu(&pt->list, &ptype_all);
367 hash = ntohs(pt->type) & 15;
368 list_add_rcu(&pt->list, &ptype_base[hash]);
370 spin_unlock_bh(&ptype_lock);
374 * __dev_remove_pack - remove packet handler
375 * @pt: packet type declaration
377 * Remove a protocol handler that was previously added to the kernel
378 * protocol handlers by dev_add_pack(). The passed &packet_type is removed
379 * from the kernel lists and can be freed or reused once this function
382 * The packet type might still be in use by receivers
383 * and must not be freed until after all the CPU's have gone
384 * through a quiescent state.
386 void __dev_remove_pack(struct packet_type *pt)
388 struct list_head *head;
389 struct packet_type *pt1;
391 spin_lock_bh(&ptype_lock);
393 if (pt->type == htons(ETH_P_ALL))
396 head = &ptype_base[ntohs(pt->type) & 15];
398 list_for_each_entry(pt1, head, list) {
400 list_del_rcu(&pt->list);
405 printk(KERN_WARNING "dev_remove_pack: %p not found.\n", pt);
407 spin_unlock_bh(&ptype_lock);
410 * dev_remove_pack - remove packet handler
411 * @pt: packet type declaration
413 * Remove a protocol handler that was previously added to the kernel
414 * protocol handlers by dev_add_pack(). The passed &packet_type is removed
415 * from the kernel lists and can be freed or reused once this function
418 * This call sleeps to guarantee that no CPU is looking at the packet
421 void dev_remove_pack(struct packet_type *pt)
423 __dev_remove_pack(pt);
428 /******************************************************************************
430 Device Boot-time Settings Routines
432 *******************************************************************************/
434 /* Boot time configuration table */
435 static struct netdev_boot_setup dev_boot_setup[NETDEV_BOOT_SETUP_MAX];
438 * netdev_boot_setup_add - add new setup entry
439 * @name: name of the device
440 * @map: configured settings for the device
442 * Adds new setup entry to the dev_boot_setup list. The function
443 * returns 0 on error and 1 on success. This is a generic routine to
446 static int netdev_boot_setup_add(char *name, struct ifmap *map)
448 struct netdev_boot_setup *s;
452 for (i = 0; i < NETDEV_BOOT_SETUP_MAX; i++) {
453 if (s[i].name[0] == '\0' || s[i].name[0] == ' ') {
454 memset(s[i].name, 0, sizeof(s[i].name));
455 strcpy(s[i].name, name);
456 memcpy(&s[i].map, map, sizeof(s[i].map));
461 return i >= NETDEV_BOOT_SETUP_MAX ? 0 : 1;
465 * netdev_boot_setup_check - check boot time settings
466 * @dev: the netdevice
468 * Check boot time settings for the device.
469 * The found settings are set for the device to be used
470 * later in the device probing.
471 * Returns 0 if no settings found, 1 if they are.
473 int netdev_boot_setup_check(struct net_device *dev)
475 struct netdev_boot_setup *s = dev_boot_setup;
478 for (i = 0; i < NETDEV_BOOT_SETUP_MAX; i++) {
479 if (s[i].name[0] != '\0' && s[i].name[0] != ' ' &&
480 !strncmp(dev->name, s[i].name, strlen(s[i].name))) {
481 dev->irq = s[i].map.irq;
482 dev->base_addr = s[i].map.base_addr;
483 dev->mem_start = s[i].map.mem_start;
484 dev->mem_end = s[i].map.mem_end;
493 * netdev_boot_base - get address from boot time settings
494 * @prefix: prefix for network device
495 * @unit: id for network device
497 * Check boot time settings for the base address of device.
498 * The found settings are set for the device to be used
499 * later in the device probing.
500 * Returns 0 if no settings found.
502 unsigned long netdev_boot_base(const char *prefix, int unit)
504 const struct netdev_boot_setup *s = dev_boot_setup;
508 sprintf(name, "%s%d", prefix, unit);
511 * If device already registered then return base of 1
512 * to indicate not to probe for this interface
514 if (__dev_get_by_name(&init_net, name))
517 for (i = 0; i < NETDEV_BOOT_SETUP_MAX; i++)
518 if (!strcmp(name, s[i].name))
519 return s[i].map.base_addr;
524 * Saves at boot time configured settings for any netdevice.
526 int __init netdev_boot_setup(char *str)
531 str = get_options(str, ARRAY_SIZE(ints), ints);
536 memset(&map, 0, sizeof(map));
540 map.base_addr = ints[2];
542 map.mem_start = ints[3];
544 map.mem_end = ints[4];
546 /* Add new entry to the list */
547 return netdev_boot_setup_add(str, &map);
550 __setup("netdev=", netdev_boot_setup);
552 /*******************************************************************************
554 Device Interface Subroutines
556 *******************************************************************************/
559 * __dev_get_by_name - find a device by its name
560 * @name: name to find
562 * Find an interface by name. Must be called under RTNL semaphore
563 * or @dev_base_lock. If the name is found a pointer to the device
564 * is returned. If the name is not found then %NULL is returned. The
565 * reference counters are not incremented so the caller must be
566 * careful with locks.
569 struct net_device *__dev_get_by_name(struct net *net, const char *name)
571 struct hlist_node *p;
573 hlist_for_each(p, dev_name_hash(net, name)) {
574 struct net_device *dev
575 = hlist_entry(p, struct net_device, name_hlist);
576 if (!strncmp(dev->name, name, IFNAMSIZ))
583 * dev_get_by_name - find a device by its name
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 * @ifindex: index of device
609 * Search for an interface by index. Returns %NULL if the device
610 * is not found or a pointer to the device. The device has not
611 * had its reference counter increased so the caller must be careful
612 * about locking. The caller must hold either the RTNL semaphore
616 struct net_device *__dev_get_by_index(struct net *net, int ifindex)
618 struct hlist_node *p;
620 hlist_for_each(p, dev_index_hash(net, ifindex)) {
621 struct net_device *dev
622 = hlist_entry(p, struct net_device, index_hlist);
623 if (dev->ifindex == ifindex)
631 * dev_get_by_index - find a device by its ifindex
632 * @ifindex: index of device
634 * Search for an interface by index. Returns NULL if the device
635 * is not found or a pointer to the device. The device returned has
636 * had a reference added and the pointer is safe until the user calls
637 * dev_put to indicate they have finished with it.
640 struct net_device *dev_get_by_index(struct net *net, int ifindex)
642 struct net_device *dev;
644 read_lock(&dev_base_lock);
645 dev = __dev_get_by_index(net, ifindex);
648 read_unlock(&dev_base_lock);
653 * dev_getbyhwaddr - find a device by its hardware address
654 * @type: media type of device
655 * @ha: hardware address
657 * Search for an interface by MAC address. Returns NULL if the device
658 * is not found or a pointer to the device. The caller must hold the
659 * rtnl semaphore. The returned device has not had its ref count increased
660 * and the caller must therefore be careful about locking
663 * If the API was consistent this would be __dev_get_by_hwaddr
666 struct net_device *dev_getbyhwaddr(struct net *net, unsigned short type, char *ha)
668 struct net_device *dev;
672 for_each_netdev(&init_net, dev)
673 if (dev->type == type &&
674 !memcmp(dev->dev_addr, ha, dev->addr_len))
680 EXPORT_SYMBOL(dev_getbyhwaddr);
682 struct net_device *__dev_getfirstbyhwtype(struct net *net, unsigned short type)
684 struct net_device *dev;
687 for_each_netdev(net, dev)
688 if (dev->type == type)
694 EXPORT_SYMBOL(__dev_getfirstbyhwtype);
696 struct net_device *dev_getfirstbyhwtype(struct net *net, unsigned short type)
698 struct net_device *dev;
701 dev = __dev_getfirstbyhwtype(net, type);
708 EXPORT_SYMBOL(dev_getfirstbyhwtype);
711 * dev_get_by_flags - find any device with given flags
712 * @if_flags: IFF_* values
713 * @mask: bitmask of bits in if_flags to check
715 * Search for any interface with the given flags. Returns NULL if a device
716 * is not found or a pointer to the device. The device returned has
717 * had a reference added and the pointer is safe until the user calls
718 * dev_put to indicate they have finished with it.
721 struct net_device * dev_get_by_flags(struct net *net, unsigned short if_flags, unsigned short mask)
723 struct net_device *dev, *ret;
726 read_lock(&dev_base_lock);
727 for_each_netdev(net, dev) {
728 if (((dev->flags ^ if_flags) & mask) == 0) {
734 read_unlock(&dev_base_lock);
739 * dev_valid_name - check if name is okay for network device
742 * Network device names need to be valid file names to
743 * to allow sysfs to work. We also disallow any kind of
746 int dev_valid_name(const char *name)
750 if (strlen(name) >= IFNAMSIZ)
752 if (!strcmp(name, ".") || !strcmp(name, ".."))
756 if (*name == '/' || isspace(*name))
764 * __dev_alloc_name - allocate a name for a device
765 * @net: network namespace to allocate the device name in
766 * @name: name format string
767 * @buf: scratch buffer and result name string
769 * Passed a format string - eg "lt%d" it will try and find a suitable
770 * id. It scans list of devices to build up a free map, then chooses
771 * the first empty slot. The caller must hold the dev_base or rtnl lock
772 * while allocating the name and adding the device in order to avoid
774 * Limited to bits_per_byte * page size devices (ie 32K on most platforms).
775 * Returns the number of the unit assigned or a negative errno code.
778 static int __dev_alloc_name(struct net *net, const char *name, char *buf)
782 const int max_netdevices = 8*PAGE_SIZE;
783 unsigned long *inuse;
784 struct net_device *d;
786 p = strnchr(name, IFNAMSIZ-1, '%');
789 * Verify the string as this thing may have come from
790 * the user. There must be either one "%d" and no other "%"
793 if (p[1] != 'd' || strchr(p + 2, '%'))
796 /* Use one page as a bit array of possible slots */
797 inuse = (unsigned long *) get_zeroed_page(GFP_ATOMIC);
801 for_each_netdev(net, d) {
802 if (!sscanf(d->name, name, &i))
804 if (i < 0 || i >= max_netdevices)
807 /* avoid cases where sscanf is not exact inverse of printf */
808 snprintf(buf, IFNAMSIZ, name, i);
809 if (!strncmp(buf, d->name, IFNAMSIZ))
813 i = find_first_zero_bit(inuse, max_netdevices);
814 free_page((unsigned long) inuse);
817 snprintf(buf, IFNAMSIZ, name, i);
818 if (!__dev_get_by_name(net, buf))
821 /* It is possible to run out of possible slots
822 * when the name is long and there isn't enough space left
823 * for the digits, or if all bits are used.
829 * dev_alloc_name - allocate a name for a device
831 * @name: name format string
833 * Passed a format string - eg "lt%d" it will try and find a suitable
834 * id. It scans list of devices to build up a free map, then chooses
835 * the first empty slot. The caller must hold the dev_base or rtnl lock
836 * while allocating the name and adding the device in order to avoid
838 * Limited to bits_per_byte * page size devices (ie 32K on most platforms).
839 * Returns the number of the unit assigned or a negative errno code.
842 int dev_alloc_name(struct net_device *dev, const char *name)
848 BUG_ON(!dev->nd_net);
850 ret = __dev_alloc_name(net, name, buf);
852 strlcpy(dev->name, buf, IFNAMSIZ);
858 * dev_change_name - change name of a device
860 * @newname: name (or format string) must be at least IFNAMSIZ
862 * Change name of a device, can pass format strings "eth%d".
865 int dev_change_name(struct net_device *dev, char *newname)
867 char oldname[IFNAMSIZ];
873 BUG_ON(!dev->nd_net);
876 if (dev->flags & IFF_UP)
879 if (!dev_valid_name(newname))
882 memcpy(oldname, dev->name, IFNAMSIZ);
884 if (strchr(newname, '%')) {
885 err = dev_alloc_name(dev, newname);
888 strcpy(newname, dev->name);
890 else if (__dev_get_by_name(net, newname))
893 strlcpy(dev->name, newname, IFNAMSIZ);
896 device_rename(&dev->dev, dev->name);
898 write_lock_bh(&dev_base_lock);
899 hlist_del(&dev->name_hlist);
900 hlist_add_head(&dev->name_hlist, dev_name_hash(net, dev->name));
901 write_unlock_bh(&dev_base_lock);
903 ret = call_netdevice_notifiers(NETDEV_CHANGENAME, dev);
904 ret = notifier_to_errno(ret);
909 "%s: name change rollback failed: %d.\n",
913 memcpy(dev->name, oldname, IFNAMSIZ);
922 * netdev_features_change - device changes features
923 * @dev: device to cause notification
925 * Called to indicate a device has changed features.
927 void netdev_features_change(struct net_device *dev)
929 call_netdevice_notifiers(NETDEV_FEAT_CHANGE, dev);
931 EXPORT_SYMBOL(netdev_features_change);
934 * netdev_state_change - device changes state
935 * @dev: device to cause notification
937 * Called to indicate a device has changed state. This function calls
938 * the notifier chains for netdev_chain and sends a NEWLINK message
939 * to the routing socket.
941 void netdev_state_change(struct net_device *dev)
943 if (dev->flags & IFF_UP) {
944 call_netdevice_notifiers(NETDEV_CHANGE, dev);
945 rtmsg_ifinfo(RTM_NEWLINK, dev, 0);
950 * dev_load - load a network module
951 * @name: name of interface
953 * If a network interface is not present and the process has suitable
954 * privileges this function loads the module. If module loading is not
955 * available in this kernel then it becomes a nop.
958 void dev_load(struct net *net, const char *name)
960 struct net_device *dev;
962 read_lock(&dev_base_lock);
963 dev = __dev_get_by_name(net, name);
964 read_unlock(&dev_base_lock);
966 if (!dev && capable(CAP_SYS_MODULE))
967 request_module("%s", name);
971 * dev_open - prepare an interface for use.
972 * @dev: device to open
974 * Takes a device from down to up state. The device's private open
975 * function is invoked and then the multicast lists are loaded. Finally
976 * the device is moved into the up state and a %NETDEV_UP message is
977 * sent to the netdev notifier chain.
979 * Calling this function on an active interface is a nop. On a failure
980 * a negative errno code is returned.
982 int dev_open(struct net_device *dev)
990 if (dev->flags & IFF_UP)
994 * Is it even present?
996 if (!netif_device_present(dev))
1000 * Call device private open method
1002 set_bit(__LINK_STATE_START, &dev->state);
1004 ret = dev->open(dev);
1006 clear_bit(__LINK_STATE_START, &dev->state);
1010 * If it went open OK then:
1017 dev->flags |= IFF_UP;
1020 * Initialize multicasting status
1022 dev_set_rx_mode(dev);
1025 * Wakeup transmit queue engine
1030 * ... and announce new interface.
1032 call_netdevice_notifiers(NETDEV_UP, dev);
1038 * dev_close - shutdown an interface.
1039 * @dev: device to shutdown
1041 * This function moves an active device into down state. A
1042 * %NETDEV_GOING_DOWN is sent to the netdev notifier chain. The device
1043 * is then deactivated and finally a %NETDEV_DOWN is sent to the notifier
1046 int dev_close(struct net_device *dev)
1050 if (!(dev->flags & IFF_UP))
1054 * Tell people we are going down, so that they can
1055 * prepare to death, when device is still operating.
1057 call_netdevice_notifiers(NETDEV_GOING_DOWN, dev);
1059 dev_deactivate(dev);
1061 clear_bit(__LINK_STATE_START, &dev->state);
1063 /* Synchronize to scheduled poll. We cannot touch poll list,
1064 * it can be even on different cpu. So just clear netif_running().
1066 * dev->stop() will invoke napi_disable() on all of it's
1067 * napi_struct instances on this device.
1069 smp_mb__after_clear_bit(); /* Commit netif_running(). */
1072 * Call the device specific close. This cannot fail.
1073 * Only if device is UP
1075 * We allow it to be called even after a DETACH hot-plug
1082 * Device is now down.
1085 dev->flags &= ~IFF_UP;
1088 * Tell people we are down
1090 call_netdevice_notifiers(NETDEV_DOWN, dev);
1096 static int dev_boot_phase = 1;
1099 * Device change register/unregister. These are not inline or static
1100 * as we export them to the world.
1104 * register_netdevice_notifier - register a network notifier block
1107 * Register a notifier to be called when network device events occur.
1108 * The notifier passed is linked into the kernel structures and must
1109 * not be reused until it has been unregistered. A negative errno code
1110 * is returned on a failure.
1112 * When registered all registration and up events are replayed
1113 * to the new notifier to allow device to have a race free
1114 * view of the network device list.
1117 int register_netdevice_notifier(struct notifier_block *nb)
1119 struct net_device *dev;
1120 struct net_device *last;
1125 err = raw_notifier_chain_register(&netdev_chain, nb);
1131 for_each_netdev(net, dev) {
1132 err = nb->notifier_call(nb, NETDEV_REGISTER, dev);
1133 err = notifier_to_errno(err);
1137 if (!(dev->flags & IFF_UP))
1140 nb->notifier_call(nb, NETDEV_UP, dev);
1151 for_each_netdev(net, dev) {
1155 if (dev->flags & IFF_UP) {
1156 nb->notifier_call(nb, NETDEV_GOING_DOWN, dev);
1157 nb->notifier_call(nb, NETDEV_DOWN, dev);
1159 nb->notifier_call(nb, NETDEV_UNREGISTER, dev);
1166 * unregister_netdevice_notifier - unregister a network notifier block
1169 * Unregister a notifier previously registered by
1170 * register_netdevice_notifier(). The notifier is unlinked into the
1171 * kernel structures and may then be reused. A negative errno code
1172 * is returned on a failure.
1175 int unregister_netdevice_notifier(struct notifier_block *nb)
1180 err = raw_notifier_chain_unregister(&netdev_chain, nb);
1186 * call_netdevice_notifiers - call all network notifier blocks
1187 * @val: value passed unmodified to notifier function
1188 * @v: pointer passed unmodified to notifier function
1190 * Call all network notifier blocks. Parameters and return value
1191 * are as for raw_notifier_call_chain().
1194 int call_netdevice_notifiers(unsigned long val, struct net_device *dev)
1196 return raw_notifier_call_chain(&netdev_chain, val, dev);
1199 /* When > 0 there are consumers of rx skb time stamps */
1200 static atomic_t netstamp_needed = ATOMIC_INIT(0);
1202 void net_enable_timestamp(void)
1204 atomic_inc(&netstamp_needed);
1207 void net_disable_timestamp(void)
1209 atomic_dec(&netstamp_needed);
1212 static inline void net_timestamp(struct sk_buff *skb)
1214 if (atomic_read(&netstamp_needed))
1215 __net_timestamp(skb);
1217 skb->tstamp.tv64 = 0;
1221 * Support routine. Sends outgoing frames to any network
1222 * taps currently in use.
1225 static void dev_queue_xmit_nit(struct sk_buff *skb, struct net_device *dev)
1227 struct packet_type *ptype;
1232 list_for_each_entry_rcu(ptype, &ptype_all, list) {
1233 /* Never send packets back to the socket
1234 * they originated from - MvS (miquels@drinkel.ow.org)
1236 if ((ptype->dev == dev || !ptype->dev) &&
1237 (ptype->af_packet_priv == NULL ||
1238 (struct sock *)ptype->af_packet_priv != skb->sk)) {
1239 struct sk_buff *skb2= skb_clone(skb, GFP_ATOMIC);
1243 /* skb->nh should be correctly
1244 set by sender, so that the second statement is
1245 just protection against buggy protocols.
1247 skb_reset_mac_header(skb2);
1249 if (skb_network_header(skb2) < skb2->data ||
1250 skb2->network_header > skb2->tail) {
1251 if (net_ratelimit())
1252 printk(KERN_CRIT "protocol %04x is "
1254 skb2->protocol, dev->name);
1255 skb_reset_network_header(skb2);
1258 skb2->transport_header = skb2->network_header;
1259 skb2->pkt_type = PACKET_OUTGOING;
1260 ptype->func(skb2, skb->dev, ptype, skb->dev);
1267 void __netif_schedule(struct net_device *dev)
1269 if (!test_and_set_bit(__LINK_STATE_SCHED, &dev->state)) {
1270 unsigned long flags;
1271 struct softnet_data *sd;
1273 local_irq_save(flags);
1274 sd = &__get_cpu_var(softnet_data);
1275 dev->next_sched = sd->output_queue;
1276 sd->output_queue = dev;
1277 raise_softirq_irqoff(NET_TX_SOFTIRQ);
1278 local_irq_restore(flags);
1281 EXPORT_SYMBOL(__netif_schedule);
1283 void dev_kfree_skb_irq(struct sk_buff *skb)
1285 if (atomic_dec_and_test(&skb->users)) {
1286 struct softnet_data *sd;
1287 unsigned long flags;
1289 local_irq_save(flags);
1290 sd = &__get_cpu_var(softnet_data);
1291 skb->next = sd->completion_queue;
1292 sd->completion_queue = skb;
1293 raise_softirq_irqoff(NET_TX_SOFTIRQ);
1294 local_irq_restore(flags);
1297 EXPORT_SYMBOL(dev_kfree_skb_irq);
1299 void dev_kfree_skb_any(struct sk_buff *skb)
1301 if (in_irq() || irqs_disabled())
1302 dev_kfree_skb_irq(skb);
1306 EXPORT_SYMBOL(dev_kfree_skb_any);
1310 * netif_device_detach - mark device as removed
1311 * @dev: network device
1313 * Mark device as removed from system and therefore no longer available.
1315 void netif_device_detach(struct net_device *dev)
1317 if (test_and_clear_bit(__LINK_STATE_PRESENT, &dev->state) &&
1318 netif_running(dev)) {
1319 netif_stop_queue(dev);
1322 EXPORT_SYMBOL(netif_device_detach);
1325 * netif_device_attach - mark device as attached
1326 * @dev: network device
1328 * Mark device as attached from system and restart if needed.
1330 void netif_device_attach(struct net_device *dev)
1332 if (!test_and_set_bit(__LINK_STATE_PRESENT, &dev->state) &&
1333 netif_running(dev)) {
1334 netif_wake_queue(dev);
1335 __netdev_watchdog_up(dev);
1338 EXPORT_SYMBOL(netif_device_attach);
1342 * Invalidate hardware checksum when packet is to be mangled, and
1343 * complete checksum manually on outgoing path.
1345 int skb_checksum_help(struct sk_buff *skb)
1348 int ret = 0, offset;
1350 if (skb->ip_summed == CHECKSUM_COMPLETE)
1351 goto out_set_summed;
1353 if (unlikely(skb_shinfo(skb)->gso_size)) {
1354 /* Let GSO fix up the checksum. */
1355 goto out_set_summed;
1358 if (skb_cloned(skb)) {
1359 ret = pskb_expand_head(skb, 0, 0, GFP_ATOMIC);
1364 offset = skb->csum_start - skb_headroom(skb);
1365 BUG_ON(offset > (int)skb->len);
1366 csum = skb_checksum(skb, offset, skb->len-offset, 0);
1368 offset = skb_headlen(skb) - offset;
1369 BUG_ON(offset <= 0);
1370 BUG_ON(skb->csum_offset + 2 > offset);
1372 *(__sum16 *)(skb->head + skb->csum_start + skb->csum_offset) =
1375 skb->ip_summed = CHECKSUM_NONE;
1381 * skb_gso_segment - Perform segmentation on skb.
1382 * @skb: buffer to segment
1383 * @features: features for the output path (see dev->features)
1385 * This function segments the given skb and returns a list of segments.
1387 * It may return NULL if the skb requires no segmentation. This is
1388 * only possible when GSO is used for verifying header integrity.
1390 struct sk_buff *skb_gso_segment(struct sk_buff *skb, int features)
1392 struct sk_buff *segs = ERR_PTR(-EPROTONOSUPPORT);
1393 struct packet_type *ptype;
1394 __be16 type = skb->protocol;
1397 BUG_ON(skb_shinfo(skb)->frag_list);
1399 skb_reset_mac_header(skb);
1400 skb->mac_len = skb->network_header - skb->mac_header;
1401 __skb_pull(skb, skb->mac_len);
1403 if (WARN_ON(skb->ip_summed != CHECKSUM_PARTIAL)) {
1404 if (skb_header_cloned(skb) &&
1405 (err = pskb_expand_head(skb, 0, 0, GFP_ATOMIC)))
1406 return ERR_PTR(err);
1410 list_for_each_entry_rcu(ptype, &ptype_base[ntohs(type) & 15], list) {
1411 if (ptype->type == type && !ptype->dev && ptype->gso_segment) {
1412 if (unlikely(skb->ip_summed != CHECKSUM_PARTIAL)) {
1413 err = ptype->gso_send_check(skb);
1414 segs = ERR_PTR(err);
1415 if (err || skb_gso_ok(skb, features))
1417 __skb_push(skb, (skb->data -
1418 skb_network_header(skb)));
1420 segs = ptype->gso_segment(skb, features);
1426 __skb_push(skb, skb->data - skb_mac_header(skb));
1431 EXPORT_SYMBOL(skb_gso_segment);
1433 /* Take action when hardware reception checksum errors are detected. */
1435 void netdev_rx_csum_fault(struct net_device *dev)
1437 if (net_ratelimit()) {
1438 printk(KERN_ERR "%s: hw csum failure.\n",
1439 dev ? dev->name : "<unknown>");
1443 EXPORT_SYMBOL(netdev_rx_csum_fault);
1446 /* Actually, we should eliminate this check as soon as we know, that:
1447 * 1. IOMMU is present and allows to map all the memory.
1448 * 2. No high memory really exists on this machine.
1451 static inline int illegal_highdma(struct net_device *dev, struct sk_buff *skb)
1453 #ifdef CONFIG_HIGHMEM
1456 if (dev->features & NETIF_F_HIGHDMA)
1459 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++)
1460 if (PageHighMem(skb_shinfo(skb)->frags[i].page))
1468 void (*destructor)(struct sk_buff *skb);
1471 #define DEV_GSO_CB(skb) ((struct dev_gso_cb *)(skb)->cb)
1473 static void dev_gso_skb_destructor(struct sk_buff *skb)
1475 struct dev_gso_cb *cb;
1478 struct sk_buff *nskb = skb->next;
1480 skb->next = nskb->next;
1483 } while (skb->next);
1485 cb = DEV_GSO_CB(skb);
1487 cb->destructor(skb);
1491 * dev_gso_segment - Perform emulated hardware segmentation on skb.
1492 * @skb: buffer to segment
1494 * This function segments the given skb and stores the list of segments
1497 static int dev_gso_segment(struct sk_buff *skb)
1499 struct net_device *dev = skb->dev;
1500 struct sk_buff *segs;
1501 int features = dev->features & ~(illegal_highdma(dev, skb) ?
1504 segs = skb_gso_segment(skb, features);
1506 /* Verifying header integrity only. */
1510 if (unlikely(IS_ERR(segs)))
1511 return PTR_ERR(segs);
1514 DEV_GSO_CB(skb)->destructor = skb->destructor;
1515 skb->destructor = dev_gso_skb_destructor;
1520 int dev_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
1522 if (likely(!skb->next)) {
1523 if (!list_empty(&ptype_all))
1524 dev_queue_xmit_nit(skb, dev);
1526 if (netif_needs_gso(dev, skb)) {
1527 if (unlikely(dev_gso_segment(skb)))
1533 return dev->hard_start_xmit(skb, dev);
1538 struct sk_buff *nskb = skb->next;
1541 skb->next = nskb->next;
1543 rc = dev->hard_start_xmit(nskb, dev);
1545 nskb->next = skb->next;
1549 if (unlikely((netif_queue_stopped(dev) ||
1550 netif_subqueue_stopped(dev, skb->queue_mapping)) &&
1552 return NETDEV_TX_BUSY;
1553 } while (skb->next);
1555 skb->destructor = DEV_GSO_CB(skb)->destructor;
1563 * dev_queue_xmit - transmit a buffer
1564 * @skb: buffer to transmit
1566 * Queue a buffer for transmission to a network device. The caller must
1567 * have set the device and priority and built the buffer before calling
1568 * this function. The function can be called from an interrupt.
1570 * A negative errno code is returned on a failure. A success does not
1571 * guarantee the frame will be transmitted as it may be dropped due
1572 * to congestion or traffic shaping.
1574 * -----------------------------------------------------------------------------------
1575 * I notice this method can also return errors from the queue disciplines,
1576 * including NET_XMIT_DROP, which is a positive value. So, errors can also
1579 * Regardless of the return value, the skb is consumed, so it is currently
1580 * difficult to retry a send to this method. (You can bump the ref count
1581 * before sending to hold a reference for retry if you are careful.)
1583 * When calling this method, interrupts MUST be enabled. This is because
1584 * the BH enable code must have IRQs enabled so that it will not deadlock.
1588 int dev_queue_xmit(struct sk_buff *skb)
1590 struct net_device *dev = skb->dev;
1594 /* GSO will handle the following emulations directly. */
1595 if (netif_needs_gso(dev, skb))
1598 if (skb_shinfo(skb)->frag_list &&
1599 !(dev->features & NETIF_F_FRAGLIST) &&
1600 __skb_linearize(skb))
1603 /* Fragmented skb is linearized if device does not support SG,
1604 * or if at least one of fragments is in highmem and device
1605 * does not support DMA from it.
1607 if (skb_shinfo(skb)->nr_frags &&
1608 (!(dev->features & NETIF_F_SG) || illegal_highdma(dev, skb)) &&
1609 __skb_linearize(skb))
1612 /* If packet is not checksummed and device does not support
1613 * checksumming for this protocol, complete checksumming here.
1615 if (skb->ip_summed == CHECKSUM_PARTIAL) {
1616 skb_set_transport_header(skb, skb->csum_start -
1619 if (!(dev->features & NETIF_F_GEN_CSUM) &&
1620 !((dev->features & NETIF_F_IP_CSUM) &&
1621 skb->protocol == htons(ETH_P_IP)) &&
1622 !((dev->features & NETIF_F_IPV6_CSUM) &&
1623 skb->protocol == htons(ETH_P_IPV6)))
1624 if (skb_checksum_help(skb))
1629 spin_lock_prefetch(&dev->queue_lock);
1631 /* Disable soft irqs for various locks below. Also
1632 * stops preemption for RCU.
1636 /* Updates of qdisc are serialized by queue_lock.
1637 * The struct Qdisc which is pointed to by qdisc is now a
1638 * rcu structure - it may be accessed without acquiring
1639 * a lock (but the structure may be stale.) The freeing of the
1640 * qdisc will be deferred until it's known that there are no
1641 * more references to it.
1643 * If the qdisc has an enqueue function, we still need to
1644 * hold the queue_lock before calling it, since queue_lock
1645 * also serializes access to the device queue.
1648 q = rcu_dereference(dev->qdisc);
1649 #ifdef CONFIG_NET_CLS_ACT
1650 skb->tc_verd = SET_TC_AT(skb->tc_verd,AT_EGRESS);
1653 /* Grab device queue */
1654 spin_lock(&dev->queue_lock);
1657 /* reset queue_mapping to zero */
1658 skb->queue_mapping = 0;
1659 rc = q->enqueue(skb, q);
1661 spin_unlock(&dev->queue_lock);
1663 rc = rc == NET_XMIT_BYPASS ? NET_XMIT_SUCCESS : rc;
1666 spin_unlock(&dev->queue_lock);
1669 /* The device has no queue. Common case for software devices:
1670 loopback, all the sorts of tunnels...
1672 Really, it is unlikely that netif_tx_lock protection is necessary
1673 here. (f.e. loopback and IP tunnels are clean ignoring statistics
1675 However, it is possible, that they rely on protection
1678 Check this and shot the lock. It is not prone from deadlocks.
1679 Either shot noqueue qdisc, it is even simpler 8)
1681 if (dev->flags & IFF_UP) {
1682 int cpu = smp_processor_id(); /* ok because BHs are off */
1684 if (dev->xmit_lock_owner != cpu) {
1686 HARD_TX_LOCK(dev, cpu);
1688 if (!netif_queue_stopped(dev) &&
1689 !netif_subqueue_stopped(dev, skb->queue_mapping)) {
1691 if (!dev_hard_start_xmit(skb, dev)) {
1692 HARD_TX_UNLOCK(dev);
1696 HARD_TX_UNLOCK(dev);
1697 if (net_ratelimit())
1698 printk(KERN_CRIT "Virtual device %s asks to "
1699 "queue packet!\n", dev->name);
1701 /* Recursion is detected! It is possible,
1703 if (net_ratelimit())
1704 printk(KERN_CRIT "Dead loop on virtual device "
1705 "%s, fix it urgently!\n", dev->name);
1710 rcu_read_unlock_bh();
1716 rcu_read_unlock_bh();
1721 /*=======================================================================
1723 =======================================================================*/
1725 int netdev_max_backlog __read_mostly = 1000;
1726 int netdev_budget __read_mostly = 300;
1727 int weight_p __read_mostly = 64; /* old backlog weight */
1729 DEFINE_PER_CPU(struct netif_rx_stats, netdev_rx_stat) = { 0, };
1733 * netif_rx - post buffer to the network code
1734 * @skb: buffer to post
1736 * This function receives a packet from a device driver and queues it for
1737 * the upper (protocol) levels to process. It always succeeds. The buffer
1738 * may be dropped during processing for congestion control or by the
1742 * NET_RX_SUCCESS (no congestion)
1743 * NET_RX_CN_LOW (low congestion)
1744 * NET_RX_CN_MOD (moderate congestion)
1745 * NET_RX_CN_HIGH (high congestion)
1746 * NET_RX_DROP (packet was dropped)
1750 int netif_rx(struct sk_buff *skb)
1752 struct softnet_data *queue;
1753 unsigned long flags;
1755 /* if netpoll wants it, pretend we never saw it */
1756 if (netpoll_rx(skb))
1759 if (!skb->tstamp.tv64)
1763 * The code is rearranged so that the path is the most
1764 * short when CPU is congested, but is still operating.
1766 local_irq_save(flags);
1767 queue = &__get_cpu_var(softnet_data);
1769 __get_cpu_var(netdev_rx_stat).total++;
1770 if (queue->input_pkt_queue.qlen <= netdev_max_backlog) {
1771 if (queue->input_pkt_queue.qlen) {
1774 __skb_queue_tail(&queue->input_pkt_queue, skb);
1775 local_irq_restore(flags);
1776 return NET_RX_SUCCESS;
1779 napi_schedule(&queue->backlog);
1783 __get_cpu_var(netdev_rx_stat).dropped++;
1784 local_irq_restore(flags);
1790 int netif_rx_ni(struct sk_buff *skb)
1795 err = netif_rx(skb);
1796 if (local_softirq_pending())
1803 EXPORT_SYMBOL(netif_rx_ni);
1805 static inline struct net_device *skb_bond(struct sk_buff *skb)
1807 struct net_device *dev = skb->dev;
1810 if (skb_bond_should_drop(skb)) {
1814 skb->dev = dev->master;
1821 static void net_tx_action(struct softirq_action *h)
1823 struct softnet_data *sd = &__get_cpu_var(softnet_data);
1825 if (sd->completion_queue) {
1826 struct sk_buff *clist;
1828 local_irq_disable();
1829 clist = sd->completion_queue;
1830 sd->completion_queue = NULL;
1834 struct sk_buff *skb = clist;
1835 clist = clist->next;
1837 BUG_TRAP(!atomic_read(&skb->users));
1842 if (sd->output_queue) {
1843 struct net_device *head;
1845 local_irq_disable();
1846 head = sd->output_queue;
1847 sd->output_queue = NULL;
1851 struct net_device *dev = head;
1852 head = head->next_sched;
1854 smp_mb__before_clear_bit();
1855 clear_bit(__LINK_STATE_SCHED, &dev->state);
1857 if (spin_trylock(&dev->queue_lock)) {
1859 spin_unlock(&dev->queue_lock);
1861 netif_schedule(dev);
1867 static inline int deliver_skb(struct sk_buff *skb,
1868 struct packet_type *pt_prev,
1869 struct net_device *orig_dev)
1871 atomic_inc(&skb->users);
1872 return pt_prev->func(skb, skb->dev, pt_prev, orig_dev);
1875 #if defined(CONFIG_BRIDGE) || defined (CONFIG_BRIDGE_MODULE)
1876 /* These hooks defined here for ATM */
1878 struct net_bridge_fdb_entry *(*br_fdb_get_hook)(struct net_bridge *br,
1879 unsigned char *addr);
1880 void (*br_fdb_put_hook)(struct net_bridge_fdb_entry *ent) __read_mostly;
1883 * If bridge module is loaded call bridging hook.
1884 * returns NULL if packet was consumed.
1886 struct sk_buff *(*br_handle_frame_hook)(struct net_bridge_port *p,
1887 struct sk_buff *skb) __read_mostly;
1888 static inline struct sk_buff *handle_bridge(struct sk_buff *skb,
1889 struct packet_type **pt_prev, int *ret,
1890 struct net_device *orig_dev)
1892 struct net_bridge_port *port;
1894 if (skb->pkt_type == PACKET_LOOPBACK ||
1895 (port = rcu_dereference(skb->dev->br_port)) == NULL)
1899 *ret = deliver_skb(skb, *pt_prev, orig_dev);
1903 return br_handle_frame_hook(port, skb);
1906 #define handle_bridge(skb, pt_prev, ret, orig_dev) (skb)
1909 #if defined(CONFIG_MACVLAN) || defined(CONFIG_MACVLAN_MODULE)
1910 struct sk_buff *(*macvlan_handle_frame_hook)(struct sk_buff *skb) __read_mostly;
1911 EXPORT_SYMBOL_GPL(macvlan_handle_frame_hook);
1913 static inline struct sk_buff *handle_macvlan(struct sk_buff *skb,
1914 struct packet_type **pt_prev,
1916 struct net_device *orig_dev)
1918 if (skb->dev->macvlan_port == NULL)
1922 *ret = deliver_skb(skb, *pt_prev, orig_dev);
1925 return macvlan_handle_frame_hook(skb);
1928 #define handle_macvlan(skb, pt_prev, ret, orig_dev) (skb)
1931 #ifdef CONFIG_NET_CLS_ACT
1932 /* TODO: Maybe we should just force sch_ingress to be compiled in
1933 * when CONFIG_NET_CLS_ACT is? otherwise some useless instructions
1934 * a compare and 2 stores extra right now if we dont have it on
1935 * but have CONFIG_NET_CLS_ACT
1936 * NOTE: This doesnt stop any functionality; if you dont have
1937 * the ingress scheduler, you just cant add policies on ingress.
1940 static int ing_filter(struct sk_buff *skb)
1943 struct net_device *dev = skb->dev;
1944 int result = TC_ACT_OK;
1946 if (dev->qdisc_ingress) {
1947 __u32 ttl = (__u32) G_TC_RTTL(skb->tc_verd);
1948 if (MAX_RED_LOOP < ttl++) {
1949 printk(KERN_WARNING "Redir loop detected Dropping packet (%d->%d)\n",
1950 skb->iif, skb->dev->ifindex);
1954 skb->tc_verd = SET_TC_RTTL(skb->tc_verd,ttl);
1956 skb->tc_verd = SET_TC_AT(skb->tc_verd,AT_INGRESS);
1958 spin_lock(&dev->ingress_lock);
1959 if ((q = dev->qdisc_ingress) != NULL)
1960 result = q->enqueue(skb, q);
1961 spin_unlock(&dev->ingress_lock);
1969 int netif_receive_skb(struct sk_buff *skb)
1971 struct packet_type *ptype, *pt_prev;
1972 struct net_device *orig_dev;
1973 int ret = NET_RX_DROP;
1976 /* if we've gotten here through NAPI, check netpoll */
1977 if (netpoll_receive_skb(skb))
1980 if (!skb->tstamp.tv64)
1984 skb->iif = skb->dev->ifindex;
1986 orig_dev = skb_bond(skb);
1991 __get_cpu_var(netdev_rx_stat).total++;
1993 skb_reset_network_header(skb);
1994 skb_reset_transport_header(skb);
1995 skb->mac_len = skb->network_header - skb->mac_header;
2001 #ifdef CONFIG_NET_CLS_ACT
2002 if (skb->tc_verd & TC_NCLS) {
2003 skb->tc_verd = CLR_TC_NCLS(skb->tc_verd);
2008 list_for_each_entry_rcu(ptype, &ptype_all, list) {
2009 if (!ptype->dev || ptype->dev == skb->dev) {
2011 ret = deliver_skb(skb, pt_prev, orig_dev);
2016 #ifdef CONFIG_NET_CLS_ACT
2018 ret = deliver_skb(skb, pt_prev, orig_dev);
2019 pt_prev = NULL; /* noone else should process this after*/
2021 skb->tc_verd = SET_TC_OK2MUNGE(skb->tc_verd);
2024 ret = ing_filter(skb);
2026 if (ret == TC_ACT_SHOT || (ret == TC_ACT_STOLEN)) {
2035 skb = handle_bridge(skb, &pt_prev, &ret, orig_dev);
2038 skb = handle_macvlan(skb, &pt_prev, &ret, orig_dev);
2042 type = skb->protocol;
2043 list_for_each_entry_rcu(ptype, &ptype_base[ntohs(type)&15], list) {
2044 if (ptype->type == type &&
2045 (!ptype->dev || ptype->dev == skb->dev)) {
2047 ret = deliver_skb(skb, pt_prev, orig_dev);
2053 ret = pt_prev->func(skb, skb->dev, pt_prev, orig_dev);
2056 /* Jamal, now you will not able to escape explaining
2057 * me how you were going to use this. :-)
2067 static int process_backlog(struct napi_struct *napi, int quota)
2070 struct softnet_data *queue = &__get_cpu_var(softnet_data);
2071 unsigned long start_time = jiffies;
2073 napi->weight = weight_p;
2075 struct sk_buff *skb;
2076 struct net_device *dev;
2078 local_irq_disable();
2079 skb = __skb_dequeue(&queue->input_pkt_queue);
2081 __napi_complete(napi);
2090 netif_receive_skb(skb);
2093 } while (++work < quota && jiffies == start_time);
2099 * __napi_schedule - schedule for receive
2100 * @napi: entry to schedule
2102 * The entry's receive function will be scheduled to run
2104 void fastcall __napi_schedule(struct napi_struct *n)
2106 unsigned long flags;
2108 local_irq_save(flags);
2109 list_add_tail(&n->poll_list, &__get_cpu_var(softnet_data).poll_list);
2110 __raise_softirq_irqoff(NET_RX_SOFTIRQ);
2111 local_irq_restore(flags);
2113 EXPORT_SYMBOL(__napi_schedule);
2116 static void net_rx_action(struct softirq_action *h)
2118 struct list_head *list = &__get_cpu_var(softnet_data).poll_list;
2119 unsigned long start_time = jiffies;
2120 int budget = netdev_budget;
2123 local_irq_disable();
2125 while (!list_empty(list)) {
2126 struct napi_struct *n;
2129 /* If softirq window is exhuasted then punt.
2131 * Note that this is a slight policy change from the
2132 * previous NAPI code, which would allow up to 2
2133 * jiffies to pass before breaking out. The test
2134 * used to be "jiffies - start_time > 1".
2136 if (unlikely(budget <= 0 || jiffies != start_time))
2141 /* Even though interrupts have been re-enabled, this
2142 * access is safe because interrupts can only add new
2143 * entries to the tail of this list, and only ->poll()
2144 * calls can remove this head entry from the list.
2146 n = list_entry(list->next, struct napi_struct, poll_list);
2148 have = netpoll_poll_lock(n);
2152 work = n->poll(n, weight);
2154 WARN_ON_ONCE(work > weight);
2158 local_irq_disable();
2160 /* Drivers must not modify the NAPI state if they
2161 * consume the entire weight. In such cases this code
2162 * still "owns" the NAPI instance and therefore can
2163 * move the instance around on the list at-will.
2165 if (unlikely(work == weight))
2166 list_move_tail(&n->poll_list, list);
2168 netpoll_poll_unlock(have);
2173 #ifdef CONFIG_NET_DMA
2175 * There may not be any more sk_buffs coming right now, so push
2176 * any pending DMA copies to hardware
2178 if (!cpus_empty(net_dma.channel_mask)) {
2180 for_each_cpu_mask(chan_idx, net_dma.channel_mask) {
2181 struct dma_chan *chan = net_dma.channels[chan_idx];
2183 dma_async_memcpy_issue_pending(chan);
2191 __get_cpu_var(netdev_rx_stat).time_squeeze++;
2192 __raise_softirq_irqoff(NET_RX_SOFTIRQ);
2196 static gifconf_func_t * gifconf_list [NPROTO];
2199 * register_gifconf - register a SIOCGIF handler
2200 * @family: Address family
2201 * @gifconf: Function handler
2203 * Register protocol dependent address dumping routines. The handler
2204 * that is passed must not be freed or reused until it has been replaced
2205 * by another handler.
2207 int register_gifconf(unsigned int family, gifconf_func_t * gifconf)
2209 if (family >= NPROTO)
2211 gifconf_list[family] = gifconf;
2217 * Map an interface index to its name (SIOCGIFNAME)
2221 * We need this ioctl for efficient implementation of the
2222 * if_indextoname() function required by the IPv6 API. Without
2223 * it, we would have to search all the interfaces to find a
2227 static int dev_ifname(struct net *net, struct ifreq __user *arg)
2229 struct net_device *dev;
2233 * Fetch the caller's info block.
2236 if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
2239 read_lock(&dev_base_lock);
2240 dev = __dev_get_by_index(net, ifr.ifr_ifindex);
2242 read_unlock(&dev_base_lock);
2246 strcpy(ifr.ifr_name, dev->name);
2247 read_unlock(&dev_base_lock);
2249 if (copy_to_user(arg, &ifr, sizeof(struct ifreq)))
2255 * Perform a SIOCGIFCONF call. This structure will change
2256 * size eventually, and there is nothing I can do about it.
2257 * Thus we will need a 'compatibility mode'.
2260 static int dev_ifconf(struct net *net, char __user *arg)
2263 struct net_device *dev;
2270 * Fetch the caller's info block.
2273 if (copy_from_user(&ifc, arg, sizeof(struct ifconf)))
2280 * Loop over the interfaces, and write an info block for each.
2284 for_each_netdev(net, dev) {
2285 for (i = 0; i < NPROTO; i++) {
2286 if (gifconf_list[i]) {
2289 done = gifconf_list[i](dev, NULL, 0);
2291 done = gifconf_list[i](dev, pos + total,
2301 * All done. Write the updated control block back to the caller.
2303 ifc.ifc_len = total;
2306 * Both BSD and Solaris return 0 here, so we do too.
2308 return copy_to_user(arg, &ifc, sizeof(struct ifconf)) ? -EFAULT : 0;
2311 #ifdef CONFIG_PROC_FS
2313 * This is invoked by the /proc filesystem handler to display a device
2316 void *dev_seq_start(struct seq_file *seq, loff_t *pos)
2318 struct net *net = seq->private;
2320 struct net_device *dev;
2322 read_lock(&dev_base_lock);
2324 return SEQ_START_TOKEN;
2327 for_each_netdev(net, dev)
2334 void *dev_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2336 struct net *net = seq->private;
2338 return v == SEQ_START_TOKEN ?
2339 first_net_device(net) : next_net_device((struct net_device *)v);
2342 void dev_seq_stop(struct seq_file *seq, void *v)
2344 read_unlock(&dev_base_lock);
2347 static void dev_seq_printf_stats(struct seq_file *seq, struct net_device *dev)
2349 struct net_device_stats *stats = dev->get_stats(dev);
2351 seq_printf(seq, "%6s:%8lu %7lu %4lu %4lu %4lu %5lu %10lu %9lu "
2352 "%8lu %7lu %4lu %4lu %4lu %5lu %7lu %10lu\n",
2353 dev->name, stats->rx_bytes, stats->rx_packets,
2355 stats->rx_dropped + stats->rx_missed_errors,
2356 stats->rx_fifo_errors,
2357 stats->rx_length_errors + stats->rx_over_errors +
2358 stats->rx_crc_errors + stats->rx_frame_errors,
2359 stats->rx_compressed, stats->multicast,
2360 stats->tx_bytes, stats->tx_packets,
2361 stats->tx_errors, stats->tx_dropped,
2362 stats->tx_fifo_errors, stats->collisions,
2363 stats->tx_carrier_errors +
2364 stats->tx_aborted_errors +
2365 stats->tx_window_errors +
2366 stats->tx_heartbeat_errors,
2367 stats->tx_compressed);
2371 * Called from the PROCfs module. This now uses the new arbitrary sized
2372 * /proc/net interface to create /proc/net/dev
2374 static int dev_seq_show(struct seq_file *seq, void *v)
2376 if (v == SEQ_START_TOKEN)
2377 seq_puts(seq, "Inter-| Receive "
2379 " face |bytes packets errs drop fifo frame "
2380 "compressed multicast|bytes packets errs "
2381 "drop fifo colls carrier compressed\n");
2383 dev_seq_printf_stats(seq, v);
2387 static struct netif_rx_stats *softnet_get_online(loff_t *pos)
2389 struct netif_rx_stats *rc = NULL;
2391 while (*pos < NR_CPUS)
2392 if (cpu_online(*pos)) {
2393 rc = &per_cpu(netdev_rx_stat, *pos);
2400 static void *softnet_seq_start(struct seq_file *seq, loff_t *pos)
2402 return softnet_get_online(pos);
2405 static void *softnet_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2408 return softnet_get_online(pos);
2411 static void softnet_seq_stop(struct seq_file *seq, void *v)
2415 static int softnet_seq_show(struct seq_file *seq, void *v)
2417 struct netif_rx_stats *s = v;
2419 seq_printf(seq, "%08x %08x %08x %08x %08x %08x %08x %08x %08x\n",
2420 s->total, s->dropped, s->time_squeeze, 0,
2421 0, 0, 0, 0, /* was fastroute */
2426 static const struct seq_operations dev_seq_ops = {
2427 .start = dev_seq_start,
2428 .next = dev_seq_next,
2429 .stop = dev_seq_stop,
2430 .show = dev_seq_show,
2433 static int dev_seq_open(struct inode *inode, struct file *file)
2435 struct seq_file *seq;
2437 res = seq_open(file, &dev_seq_ops);
2439 seq = file->private_data;
2440 seq->private = get_proc_net(inode);
2441 if (!seq->private) {
2442 seq_release(inode, file);
2449 static int dev_seq_release(struct inode *inode, struct file *file)
2451 struct seq_file *seq = file->private_data;
2452 struct net *net = seq->private;
2454 return seq_release(inode, file);
2457 static const struct file_operations dev_seq_fops = {
2458 .owner = THIS_MODULE,
2459 .open = dev_seq_open,
2461 .llseek = seq_lseek,
2462 .release = dev_seq_release,
2465 static const struct seq_operations softnet_seq_ops = {
2466 .start = softnet_seq_start,
2467 .next = softnet_seq_next,
2468 .stop = softnet_seq_stop,
2469 .show = softnet_seq_show,
2472 static int softnet_seq_open(struct inode *inode, struct file *file)
2474 return seq_open(file, &softnet_seq_ops);
2477 static const struct file_operations softnet_seq_fops = {
2478 .owner = THIS_MODULE,
2479 .open = softnet_seq_open,
2481 .llseek = seq_lseek,
2482 .release = seq_release,
2485 static void *ptype_get_idx(loff_t pos)
2487 struct packet_type *pt = NULL;
2491 list_for_each_entry_rcu(pt, &ptype_all, list) {
2497 for (t = 0; t < 16; t++) {
2498 list_for_each_entry_rcu(pt, &ptype_base[t], list) {
2507 static void *ptype_seq_start(struct seq_file *seq, loff_t *pos)
2510 return *pos ? ptype_get_idx(*pos - 1) : SEQ_START_TOKEN;
2513 static void *ptype_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2515 struct packet_type *pt;
2516 struct list_head *nxt;
2520 if (v == SEQ_START_TOKEN)
2521 return ptype_get_idx(0);
2524 nxt = pt->list.next;
2525 if (pt->type == htons(ETH_P_ALL)) {
2526 if (nxt != &ptype_all)
2529 nxt = ptype_base[0].next;
2531 hash = ntohs(pt->type) & 15;
2533 while (nxt == &ptype_base[hash]) {
2536 nxt = ptype_base[hash].next;
2539 return list_entry(nxt, struct packet_type, list);
2542 static void ptype_seq_stop(struct seq_file *seq, void *v)
2547 static void ptype_seq_decode(struct seq_file *seq, void *sym)
2549 #ifdef CONFIG_KALLSYMS
2550 unsigned long offset = 0, symsize;
2551 const char *symname;
2555 symname = kallsyms_lookup((unsigned long)sym, &symsize, &offset,
2562 modname = delim = "";
2563 seq_printf(seq, "%s%s%s%s+0x%lx", delim, modname, delim,
2569 seq_printf(seq, "[%p]", sym);
2572 static int ptype_seq_show(struct seq_file *seq, void *v)
2574 struct packet_type *pt = v;
2576 if (v == SEQ_START_TOKEN)
2577 seq_puts(seq, "Type Device Function\n");
2579 if (pt->type == htons(ETH_P_ALL))
2580 seq_puts(seq, "ALL ");
2582 seq_printf(seq, "%04x", ntohs(pt->type));
2584 seq_printf(seq, " %-8s ",
2585 pt->dev ? pt->dev->name : "");
2586 ptype_seq_decode(seq, pt->func);
2587 seq_putc(seq, '\n');
2593 static const struct seq_operations ptype_seq_ops = {
2594 .start = ptype_seq_start,
2595 .next = ptype_seq_next,
2596 .stop = ptype_seq_stop,
2597 .show = ptype_seq_show,
2600 static int ptype_seq_open(struct inode *inode, struct file *file)
2602 return seq_open(file, &ptype_seq_ops);
2605 static const struct file_operations ptype_seq_fops = {
2606 .owner = THIS_MODULE,
2607 .open = ptype_seq_open,
2609 .llseek = seq_lseek,
2610 .release = seq_release,
2614 static int dev_proc_net_init(struct net *net)
2618 if (!proc_net_fops_create(net, "dev", S_IRUGO, &dev_seq_fops))
2620 if (!proc_net_fops_create(net, "softnet_stat", S_IRUGO, &softnet_seq_fops))
2622 if (!proc_net_fops_create(net, "ptype", S_IRUGO, &ptype_seq_fops))
2625 if (wext_proc_init(net))
2631 proc_net_remove(net, "ptype");
2633 proc_net_remove(net, "softnet_stat");
2635 proc_net_remove(net, "dev");
2639 static void dev_proc_net_exit(struct net *net)
2641 wext_proc_exit(net);
2643 proc_net_remove(net, "ptype");
2644 proc_net_remove(net, "softnet_stat");
2645 proc_net_remove(net, "dev");
2648 static struct pernet_operations dev_proc_ops = {
2649 .init = dev_proc_net_init,
2650 .exit = dev_proc_net_exit,
2653 static int __init dev_proc_init(void)
2655 return register_pernet_subsys(&dev_proc_ops);
2658 #define dev_proc_init() 0
2659 #endif /* CONFIG_PROC_FS */
2663 * netdev_set_master - set up master/slave pair
2664 * @slave: slave device
2665 * @master: new master device
2667 * Changes the master device of the slave. Pass %NULL to break the
2668 * bonding. The caller must hold the RTNL semaphore. On a failure
2669 * a negative errno code is returned. On success the reference counts
2670 * are adjusted, %RTM_NEWLINK is sent to the routing socket and the
2671 * function returns zero.
2673 int netdev_set_master(struct net_device *slave, struct net_device *master)
2675 struct net_device *old = slave->master;
2685 slave->master = master;
2693 slave->flags |= IFF_SLAVE;
2695 slave->flags &= ~IFF_SLAVE;
2697 rtmsg_ifinfo(RTM_NEWLINK, slave, IFF_SLAVE);
2701 static void __dev_set_promiscuity(struct net_device *dev, int inc)
2703 unsigned short old_flags = dev->flags;
2707 if ((dev->promiscuity += inc) == 0)
2708 dev->flags &= ~IFF_PROMISC;
2710 dev->flags |= IFF_PROMISC;
2711 if (dev->flags != old_flags) {
2712 printk(KERN_INFO "device %s %s promiscuous mode\n",
2713 dev->name, (dev->flags & IFF_PROMISC) ? "entered" :
2715 audit_log(current->audit_context, GFP_ATOMIC,
2716 AUDIT_ANOM_PROMISCUOUS,
2717 "dev=%s prom=%d old_prom=%d auid=%u",
2718 dev->name, (dev->flags & IFF_PROMISC),
2719 (old_flags & IFF_PROMISC),
2720 audit_get_loginuid(current->audit_context));
2722 if (dev->change_rx_flags)
2723 dev->change_rx_flags(dev, IFF_PROMISC);
2728 * dev_set_promiscuity - update promiscuity count on a device
2732 * Add or remove promiscuity from a device. While the count in the device
2733 * remains above zero the interface remains promiscuous. Once it hits zero
2734 * the device reverts back to normal filtering operation. A negative inc
2735 * value is used to drop promiscuity on the device.
2737 void dev_set_promiscuity(struct net_device *dev, int inc)
2739 unsigned short old_flags = dev->flags;
2741 __dev_set_promiscuity(dev, inc);
2742 if (dev->flags != old_flags)
2743 dev_set_rx_mode(dev);
2747 * dev_set_allmulti - update allmulti count on a device
2751 * Add or remove reception of all multicast frames to a device. While the
2752 * count in the device remains above zero the interface remains listening
2753 * to all interfaces. Once it hits zero the device reverts back to normal
2754 * filtering operation. A negative @inc value is used to drop the counter
2755 * when releasing a resource needing all multicasts.
2758 void dev_set_allmulti(struct net_device *dev, int inc)
2760 unsigned short old_flags = dev->flags;
2764 dev->flags |= IFF_ALLMULTI;
2765 if ((dev->allmulti += inc) == 0)
2766 dev->flags &= ~IFF_ALLMULTI;
2767 if (dev->flags ^ old_flags) {
2768 if (dev->change_rx_flags)
2769 dev->change_rx_flags(dev, IFF_ALLMULTI);
2770 dev_set_rx_mode(dev);
2775 * Upload unicast and multicast address lists to device and
2776 * configure RX filtering. When the device doesn't support unicast
2777 * filtering it is put in promiscous mode while unicast addresses
2780 void __dev_set_rx_mode(struct net_device *dev)
2782 /* dev_open will call this function so the list will stay sane. */
2783 if (!(dev->flags&IFF_UP))
2786 if (!netif_device_present(dev))
2789 if (dev->set_rx_mode)
2790 dev->set_rx_mode(dev);
2792 /* Unicast addresses changes may only happen under the rtnl,
2793 * therefore calling __dev_set_promiscuity here is safe.
2795 if (dev->uc_count > 0 && !dev->uc_promisc) {
2796 __dev_set_promiscuity(dev, 1);
2797 dev->uc_promisc = 1;
2798 } else if (dev->uc_count == 0 && dev->uc_promisc) {
2799 __dev_set_promiscuity(dev, -1);
2800 dev->uc_promisc = 0;
2803 if (dev->set_multicast_list)
2804 dev->set_multicast_list(dev);
2808 void dev_set_rx_mode(struct net_device *dev)
2810 netif_tx_lock_bh(dev);
2811 __dev_set_rx_mode(dev);
2812 netif_tx_unlock_bh(dev);
2815 int __dev_addr_delete(struct dev_addr_list **list, int *count,
2816 void *addr, int alen, int glbl)
2818 struct dev_addr_list *da;
2820 for (; (da = *list) != NULL; list = &da->next) {
2821 if (memcmp(da->da_addr, addr, da->da_addrlen) == 0 &&
2822 alen == da->da_addrlen) {
2824 int old_glbl = da->da_gusers;
2841 int __dev_addr_add(struct dev_addr_list **list, int *count,
2842 void *addr, int alen, int glbl)
2844 struct dev_addr_list *da;
2846 for (da = *list; da != NULL; da = da->next) {
2847 if (memcmp(da->da_addr, addr, da->da_addrlen) == 0 &&
2848 da->da_addrlen == alen) {
2850 int old_glbl = da->da_gusers;
2860 da = kmalloc(sizeof(*da), GFP_ATOMIC);
2863 memcpy(da->da_addr, addr, alen);
2864 da->da_addrlen = alen;
2866 da->da_gusers = glbl ? 1 : 0;
2874 * dev_unicast_delete - Release secondary unicast address.
2876 * @addr: address to delete
2877 * @alen: length of @addr
2879 * Release reference to a secondary unicast address and remove it
2880 * from the device if the reference count drops to zero.
2882 * The caller must hold the rtnl_mutex.
2884 int dev_unicast_delete(struct net_device *dev, void *addr, int alen)
2890 netif_tx_lock_bh(dev);
2891 err = __dev_addr_delete(&dev->uc_list, &dev->uc_count, addr, alen, 0);
2893 __dev_set_rx_mode(dev);
2894 netif_tx_unlock_bh(dev);
2897 EXPORT_SYMBOL(dev_unicast_delete);
2900 * dev_unicast_add - add a secondary unicast address
2902 * @addr: address to delete
2903 * @alen: length of @addr
2905 * Add a secondary unicast address to the device or increase
2906 * the reference count if it already exists.
2908 * The caller must hold the rtnl_mutex.
2910 int dev_unicast_add(struct net_device *dev, void *addr, int alen)
2916 netif_tx_lock_bh(dev);
2917 err = __dev_addr_add(&dev->uc_list, &dev->uc_count, addr, alen, 0);
2919 __dev_set_rx_mode(dev);
2920 netif_tx_unlock_bh(dev);
2923 EXPORT_SYMBOL(dev_unicast_add);
2925 static void __dev_addr_discard(struct dev_addr_list **list)
2927 struct dev_addr_list *tmp;
2929 while (*list != NULL) {
2932 if (tmp->da_users > tmp->da_gusers)
2933 printk("__dev_addr_discard: address leakage! "
2934 "da_users=%d\n", tmp->da_users);
2939 static void dev_addr_discard(struct net_device *dev)
2941 netif_tx_lock_bh(dev);
2943 __dev_addr_discard(&dev->uc_list);
2946 __dev_addr_discard(&dev->mc_list);
2949 netif_tx_unlock_bh(dev);
2952 unsigned dev_get_flags(const struct net_device *dev)
2956 flags = (dev->flags & ~(IFF_PROMISC |
2961 (dev->gflags & (IFF_PROMISC |
2964 if (netif_running(dev)) {
2965 if (netif_oper_up(dev))
2966 flags |= IFF_RUNNING;
2967 if (netif_carrier_ok(dev))
2968 flags |= IFF_LOWER_UP;
2969 if (netif_dormant(dev))
2970 flags |= IFF_DORMANT;
2976 int dev_change_flags(struct net_device *dev, unsigned flags)
2979 int old_flags = dev->flags;
2984 * Set the flags on our device.
2987 dev->flags = (flags & (IFF_DEBUG | IFF_NOTRAILERS | IFF_NOARP |
2988 IFF_DYNAMIC | IFF_MULTICAST | IFF_PORTSEL |
2990 (dev->flags & (IFF_UP | IFF_VOLATILE | IFF_PROMISC |
2994 * Load in the correct multicast list now the flags have changed.
2997 if (dev->change_rx_flags && (dev->flags ^ flags) & IFF_MULTICAST)
2998 dev->change_rx_flags(dev, IFF_MULTICAST);
3000 dev_set_rx_mode(dev);
3003 * Have we downed the interface. We handle IFF_UP ourselves
3004 * according to user attempts to set it, rather than blindly
3009 if ((old_flags ^ flags) & IFF_UP) { /* Bit is different ? */
3010 ret = ((old_flags & IFF_UP) ? dev_close : dev_open)(dev);
3013 dev_set_rx_mode(dev);
3016 if (dev->flags & IFF_UP &&
3017 ((old_flags ^ dev->flags) &~ (IFF_UP | IFF_PROMISC | IFF_ALLMULTI |
3019 call_netdevice_notifiers(NETDEV_CHANGE, dev);
3021 if ((flags ^ dev->gflags) & IFF_PROMISC) {
3022 int inc = (flags & IFF_PROMISC) ? +1 : -1;
3023 dev->gflags ^= IFF_PROMISC;
3024 dev_set_promiscuity(dev, inc);
3027 /* NOTE: order of synchronization of IFF_PROMISC and IFF_ALLMULTI
3028 is important. Some (broken) drivers set IFF_PROMISC, when
3029 IFF_ALLMULTI is requested not asking us and not reporting.
3031 if ((flags ^ dev->gflags) & IFF_ALLMULTI) {
3032 int inc = (flags & IFF_ALLMULTI) ? +1 : -1;
3033 dev->gflags ^= IFF_ALLMULTI;
3034 dev_set_allmulti(dev, inc);
3037 /* Exclude state transition flags, already notified */
3038 changes = (old_flags ^ dev->flags) & ~(IFF_UP | IFF_RUNNING);
3040 rtmsg_ifinfo(RTM_NEWLINK, dev, changes);
3045 int dev_set_mtu(struct net_device *dev, int new_mtu)
3049 if (new_mtu == dev->mtu)
3052 /* MTU must be positive. */
3056 if (!netif_device_present(dev))
3060 if (dev->change_mtu)
3061 err = dev->change_mtu(dev, new_mtu);
3064 if (!err && dev->flags & IFF_UP)
3065 call_netdevice_notifiers(NETDEV_CHANGEMTU, dev);
3069 int dev_set_mac_address(struct net_device *dev, struct sockaddr *sa)
3073 if (!dev->set_mac_address)
3075 if (sa->sa_family != dev->type)
3077 if (!netif_device_present(dev))
3079 err = dev->set_mac_address(dev, sa);
3081 call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
3086 * Perform the SIOCxIFxxx calls, inside read_lock(dev_base_lock)
3088 static int dev_ifsioc_locked(struct net *net, struct ifreq *ifr, unsigned int cmd)
3091 struct net_device *dev = __dev_get_by_name(net, ifr->ifr_name);
3097 case SIOCGIFFLAGS: /* Get interface flags */
3098 ifr->ifr_flags = dev_get_flags(dev);
3101 case SIOCGIFMETRIC: /* Get the metric on the interface
3102 (currently unused) */
3103 ifr->ifr_metric = 0;
3106 case SIOCGIFMTU: /* Get the MTU of a device */
3107 ifr->ifr_mtu = dev->mtu;
3112 memset(ifr->ifr_hwaddr.sa_data, 0, sizeof ifr->ifr_hwaddr.sa_data);
3114 memcpy(ifr->ifr_hwaddr.sa_data, dev->dev_addr,
3115 min(sizeof ifr->ifr_hwaddr.sa_data, (size_t) dev->addr_len));
3116 ifr->ifr_hwaddr.sa_family = dev->type;
3124 ifr->ifr_map.mem_start = dev->mem_start;
3125 ifr->ifr_map.mem_end = dev->mem_end;
3126 ifr->ifr_map.base_addr = dev->base_addr;
3127 ifr->ifr_map.irq = dev->irq;
3128 ifr->ifr_map.dma = dev->dma;
3129 ifr->ifr_map.port = dev->if_port;
3133 ifr->ifr_ifindex = dev->ifindex;
3137 ifr->ifr_qlen = dev->tx_queue_len;
3141 /* dev_ioctl() should ensure this case
3153 * Perform the SIOCxIFxxx calls, inside rtnl_lock()
3155 static int dev_ifsioc(struct net *net, struct ifreq *ifr, unsigned int cmd)
3158 struct net_device *dev = __dev_get_by_name(net, ifr->ifr_name);
3164 case SIOCSIFFLAGS: /* Set interface flags */
3165 return dev_change_flags(dev, ifr->ifr_flags);
3167 case SIOCSIFMETRIC: /* Set the metric on the interface
3168 (currently unused) */
3171 case SIOCSIFMTU: /* Set the MTU of a device */
3172 return dev_set_mtu(dev, ifr->ifr_mtu);
3175 return dev_set_mac_address(dev, &ifr->ifr_hwaddr);
3177 case SIOCSIFHWBROADCAST:
3178 if (ifr->ifr_hwaddr.sa_family != dev->type)
3180 memcpy(dev->broadcast, ifr->ifr_hwaddr.sa_data,
3181 min(sizeof ifr->ifr_hwaddr.sa_data, (size_t) dev->addr_len));
3182 call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
3186 if (dev->set_config) {
3187 if (!netif_device_present(dev))
3189 return dev->set_config(dev, &ifr->ifr_map);
3194 if (!dev->set_multicast_list ||
3195 ifr->ifr_hwaddr.sa_family != AF_UNSPEC)
3197 if (!netif_device_present(dev))
3199 return dev_mc_add(dev, ifr->ifr_hwaddr.sa_data,
3203 if (!dev->set_multicast_list ||
3204 ifr->ifr_hwaddr.sa_family != AF_UNSPEC)
3206 if (!netif_device_present(dev))
3208 return dev_mc_delete(dev, ifr->ifr_hwaddr.sa_data,
3212 if (ifr->ifr_qlen < 0)
3214 dev->tx_queue_len = ifr->ifr_qlen;
3218 ifr->ifr_newname[IFNAMSIZ-1] = '\0';
3219 return dev_change_name(dev, ifr->ifr_newname);
3222 * Unknown or private ioctl
3226 if ((cmd >= SIOCDEVPRIVATE &&
3227 cmd <= SIOCDEVPRIVATE + 15) ||
3228 cmd == SIOCBONDENSLAVE ||
3229 cmd == SIOCBONDRELEASE ||
3230 cmd == SIOCBONDSETHWADDR ||
3231 cmd == SIOCBONDSLAVEINFOQUERY ||
3232 cmd == SIOCBONDINFOQUERY ||
3233 cmd == SIOCBONDCHANGEACTIVE ||
3234 cmd == SIOCGMIIPHY ||
3235 cmd == SIOCGMIIREG ||
3236 cmd == SIOCSMIIREG ||
3237 cmd == SIOCBRADDIF ||
3238 cmd == SIOCBRDELIF ||
3239 cmd == SIOCWANDEV) {
3241 if (dev->do_ioctl) {
3242 if (netif_device_present(dev))
3243 err = dev->do_ioctl(dev, ifr,
3256 * This function handles all "interface"-type I/O control requests. The actual
3257 * 'doing' part of this is dev_ifsioc above.
3261 * dev_ioctl - network device ioctl
3262 * @cmd: command to issue
3263 * @arg: pointer to a struct ifreq in user space
3265 * Issue ioctl functions to devices. This is normally called by the
3266 * user space syscall interfaces but can sometimes be useful for
3267 * other purposes. The return value is the return from the syscall if
3268 * positive or a negative errno code on error.
3271 int dev_ioctl(struct net *net, unsigned int cmd, void __user *arg)
3277 /* One special case: SIOCGIFCONF takes ifconf argument
3278 and requires shared lock, because it sleeps writing
3282 if (cmd == SIOCGIFCONF) {
3284 ret = dev_ifconf(net, (char __user *) arg);
3288 if (cmd == SIOCGIFNAME)
3289 return dev_ifname(net, (struct ifreq __user *)arg);
3291 if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
3294 ifr.ifr_name[IFNAMSIZ-1] = 0;
3296 colon = strchr(ifr.ifr_name, ':');
3301 * See which interface the caller is talking about.
3306 * These ioctl calls:
3307 * - can be done by all.
3308 * - atomic and do not require locking.
3319 dev_load(net, ifr.ifr_name);
3320 read_lock(&dev_base_lock);
3321 ret = dev_ifsioc_locked(net, &ifr, cmd);
3322 read_unlock(&dev_base_lock);
3326 if (copy_to_user(arg, &ifr,
3327 sizeof(struct ifreq)))
3333 dev_load(net, ifr.ifr_name);
3335 ret = dev_ethtool(net, &ifr);
3340 if (copy_to_user(arg, &ifr,
3341 sizeof(struct ifreq)))
3347 * These ioctl calls:
3348 * - require superuser power.
3349 * - require strict serialization.
3355 if (!capable(CAP_NET_ADMIN))
3357 dev_load(net, ifr.ifr_name);
3359 ret = dev_ifsioc(net, &ifr, cmd);
3364 if (copy_to_user(arg, &ifr,
3365 sizeof(struct ifreq)))
3371 * These ioctl calls:
3372 * - require superuser power.
3373 * - require strict serialization.
3374 * - do not return a value
3384 case SIOCSIFHWBROADCAST:
3387 case SIOCBONDENSLAVE:
3388 case SIOCBONDRELEASE:
3389 case SIOCBONDSETHWADDR:
3390 case SIOCBONDCHANGEACTIVE:
3393 if (!capable(CAP_NET_ADMIN))
3396 case SIOCBONDSLAVEINFOQUERY:
3397 case SIOCBONDINFOQUERY:
3398 dev_load(net, ifr.ifr_name);
3400 ret = dev_ifsioc(net, &ifr, cmd);
3405 /* Get the per device memory space. We can add this but
3406 * currently do not support it */
3408 /* Set the per device memory buffer space.
3409 * Not applicable in our case */
3414 * Unknown or private ioctl.
3417 if (cmd == SIOCWANDEV ||
3418 (cmd >= SIOCDEVPRIVATE &&
3419 cmd <= SIOCDEVPRIVATE + 15)) {
3420 dev_load(net, ifr.ifr_name);
3422 ret = dev_ifsioc(net, &ifr, cmd);
3424 if (!ret && copy_to_user(arg, &ifr,
3425 sizeof(struct ifreq)))
3429 /* Take care of Wireless Extensions */
3430 if (cmd >= SIOCIWFIRST && cmd <= SIOCIWLAST)
3431 return wext_handle_ioctl(net, &ifr, cmd, arg);
3438 * dev_new_index - allocate an ifindex
3440 * Returns a suitable unique value for a new device interface
3441 * number. The caller must hold the rtnl semaphore or the
3442 * dev_base_lock to be sure it remains unique.
3444 static int dev_new_index(struct net *net)
3450 if (!__dev_get_by_index(net, ifindex))
3455 /* Delayed registration/unregisteration */
3456 static DEFINE_SPINLOCK(net_todo_list_lock);
3457 static struct list_head net_todo_list = LIST_HEAD_INIT(net_todo_list);
3459 static void net_set_todo(struct net_device *dev)
3461 spin_lock(&net_todo_list_lock);
3462 list_add_tail(&dev->todo_list, &net_todo_list);
3463 spin_unlock(&net_todo_list_lock);
3467 * register_netdevice - register a network device
3468 * @dev: device to register
3470 * Take a completed network device structure and add it to the kernel
3471 * interfaces. A %NETDEV_REGISTER message is sent to the netdev notifier
3472 * chain. 0 is returned on success. A negative errno code is returned
3473 * on a failure to set up the device, or if the name is a duplicate.
3475 * Callers must hold the rtnl semaphore. You may want
3476 * register_netdev() instead of this.
3479 * The locking appears insufficient to guarantee two parallel registers
3480 * will not get the same name.
3483 int register_netdevice(struct net_device *dev)
3485 struct hlist_head *head;
3486 struct hlist_node *p;
3490 BUG_ON(dev_boot_phase);
3495 /* When net_device's are persistent, this will be fatal. */
3496 BUG_ON(dev->reg_state != NETREG_UNINITIALIZED);
3497 BUG_ON(!dev->nd_net);
3500 spin_lock_init(&dev->queue_lock);
3501 spin_lock_init(&dev->_xmit_lock);
3502 netdev_set_lockdep_class(&dev->_xmit_lock, dev->type);
3503 dev->xmit_lock_owner = -1;
3504 spin_lock_init(&dev->ingress_lock);
3508 /* Init, if this function is available */
3510 ret = dev->init(dev);
3518 if (!dev_valid_name(dev->name)) {
3523 dev->ifindex = dev_new_index(net);
3524 if (dev->iflink == -1)
3525 dev->iflink = dev->ifindex;
3527 /* Check for existence of name */
3528 head = dev_name_hash(net, dev->name);
3529 hlist_for_each(p, head) {
3530 struct net_device *d
3531 = hlist_entry(p, struct net_device, name_hlist);
3532 if (!strncmp(d->name, dev->name, IFNAMSIZ)) {
3538 /* Fix illegal checksum combinations */
3539 if ((dev->features & NETIF_F_HW_CSUM) &&
3540 (dev->features & (NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM))) {
3541 printk(KERN_NOTICE "%s: mixed HW and IP checksum settings.\n",
3543 dev->features &= ~(NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM);
3546 if ((dev->features & NETIF_F_NO_CSUM) &&
3547 (dev->features & (NETIF_F_HW_CSUM|NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM))) {
3548 printk(KERN_NOTICE "%s: mixed no checksumming and other settings.\n",
3550 dev->features &= ~(NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM|NETIF_F_HW_CSUM);
3554 /* Fix illegal SG+CSUM combinations. */
3555 if ((dev->features & NETIF_F_SG) &&
3556 !(dev->features & NETIF_F_ALL_CSUM)) {
3557 printk(KERN_NOTICE "%s: Dropping NETIF_F_SG since no checksum feature.\n",
3559 dev->features &= ~NETIF_F_SG;
3562 /* TSO requires that SG is present as well. */
3563 if ((dev->features & NETIF_F_TSO) &&
3564 !(dev->features & NETIF_F_SG)) {
3565 printk(KERN_NOTICE "%s: Dropping NETIF_F_TSO since no SG feature.\n",
3567 dev->features &= ~NETIF_F_TSO;
3569 if (dev->features & NETIF_F_UFO) {
3570 if (!(dev->features & NETIF_F_HW_CSUM)) {
3571 printk(KERN_ERR "%s: Dropping NETIF_F_UFO since no "
3572 "NETIF_F_HW_CSUM feature.\n",
3574 dev->features &= ~NETIF_F_UFO;
3576 if (!(dev->features & NETIF_F_SG)) {
3577 printk(KERN_ERR "%s: Dropping NETIF_F_UFO since no "
3578 "NETIF_F_SG feature.\n",
3580 dev->features &= ~NETIF_F_UFO;
3584 ret = netdev_register_kobject(dev);
3587 dev->reg_state = NETREG_REGISTERED;
3590 * Default initial state at registry is that the
3591 * device is present.
3594 set_bit(__LINK_STATE_PRESENT, &dev->state);
3596 dev_init_scheduler(dev);
3598 list_netdevice(dev);
3600 /* Notify protocols, that a new device appeared. */
3601 ret = call_netdevice_notifiers(NETDEV_REGISTER, dev);
3602 ret = notifier_to_errno(ret);
3604 unregister_netdevice(dev);
3616 * register_netdev - register a network device
3617 * @dev: device to register
3619 * Take a completed network device structure and add it to the kernel
3620 * interfaces. A %NETDEV_REGISTER message is sent to the netdev notifier
3621 * chain. 0 is returned on success. A negative errno code is returned
3622 * on a failure to set up the device, or if the name is a duplicate.
3624 * This is a wrapper around register_netdevice that takes the rtnl semaphore
3625 * and expands the device name if you passed a format string to
3628 int register_netdev(struct net_device *dev)
3635 * If the name is a format string the caller wants us to do a
3638 if (strchr(dev->name, '%')) {
3639 err = dev_alloc_name(dev, dev->name);
3644 err = register_netdevice(dev);
3649 EXPORT_SYMBOL(register_netdev);
3652 * netdev_wait_allrefs - wait until all references are gone.
3654 * This is called when unregistering network devices.
3656 * Any protocol or device that holds a reference should register
3657 * for netdevice notification, and cleanup and put back the
3658 * reference if they receive an UNREGISTER event.
3659 * We can get stuck here if buggy protocols don't correctly
3662 static void netdev_wait_allrefs(struct net_device *dev)
3664 unsigned long rebroadcast_time, warning_time;
3666 rebroadcast_time = warning_time = jiffies;
3667 while (atomic_read(&dev->refcnt) != 0) {
3668 if (time_after(jiffies, rebroadcast_time + 1 * HZ)) {
3671 /* Rebroadcast unregister notification */
3672 call_netdevice_notifiers(NETDEV_UNREGISTER, dev);
3674 if (test_bit(__LINK_STATE_LINKWATCH_PENDING,
3676 /* We must not have linkwatch events
3677 * pending on unregister. If this
3678 * happens, we simply run the queue
3679 * unscheduled, resulting in a noop
3682 linkwatch_run_queue();
3687 rebroadcast_time = jiffies;
3692 if (time_after(jiffies, warning_time + 10 * HZ)) {
3693 printk(KERN_EMERG "unregister_netdevice: "
3694 "waiting for %s to become free. Usage "
3696 dev->name, atomic_read(&dev->refcnt));
3697 warning_time = jiffies;
3706 * register_netdevice(x1);
3707 * register_netdevice(x2);
3709 * unregister_netdevice(y1);
3710 * unregister_netdevice(y2);
3716 * We are invoked by rtnl_unlock() after it drops the semaphore.
3717 * This allows us to deal with problems:
3718 * 1) We can delete sysfs objects which invoke hotplug
3719 * without deadlocking with linkwatch via keventd.
3720 * 2) Since we run with the RTNL semaphore not held, we can sleep
3721 * safely in order to wait for the netdev refcnt to drop to zero.
3723 static DEFINE_MUTEX(net_todo_run_mutex);
3724 void netdev_run_todo(void)
3726 struct list_head list;
3728 /* Need to guard against multiple cpu's getting out of order. */
3729 mutex_lock(&net_todo_run_mutex);
3731 /* Not safe to do outside the semaphore. We must not return
3732 * until all unregister events invoked by the local processor
3733 * have been completed (either by this todo run, or one on
3736 if (list_empty(&net_todo_list))
3739 /* Snapshot list, allow later requests */
3740 spin_lock(&net_todo_list_lock);
3741 list_replace_init(&net_todo_list, &list);
3742 spin_unlock(&net_todo_list_lock);
3744 while (!list_empty(&list)) {
3745 struct net_device *dev
3746 = list_entry(list.next, struct net_device, todo_list);
3747 list_del(&dev->todo_list);
3749 if (unlikely(dev->reg_state != NETREG_UNREGISTERING)) {
3750 printk(KERN_ERR "network todo '%s' but state %d\n",
3751 dev->name, dev->reg_state);
3756 dev->reg_state = NETREG_UNREGISTERED;
3758 netdev_wait_allrefs(dev);
3761 BUG_ON(atomic_read(&dev->refcnt));
3762 BUG_TRAP(!dev->ip_ptr);
3763 BUG_TRAP(!dev->ip6_ptr);
3764 BUG_TRAP(!dev->dn_ptr);
3766 if (dev->destructor)
3767 dev->destructor(dev);
3769 /* Free network device */
3770 kobject_put(&dev->dev.kobj);
3774 mutex_unlock(&net_todo_run_mutex);
3777 static struct net_device_stats *internal_stats(struct net_device *dev)
3783 * alloc_netdev_mq - allocate network device
3784 * @sizeof_priv: size of private data to allocate space for
3785 * @name: device name format string
3786 * @setup: callback to initialize device
3787 * @queue_count: the number of subqueues to allocate
3789 * Allocates a struct net_device with private data area for driver use
3790 * and performs basic initialization. Also allocates subquue structs
3791 * for each queue on the device at the end of the netdevice.
3793 struct net_device *alloc_netdev_mq(int sizeof_priv, const char *name,
3794 void (*setup)(struct net_device *), unsigned int queue_count)
3797 struct net_device *dev;
3800 BUG_ON(strlen(name) >= sizeof(dev->name));
3802 /* ensure 32-byte alignment of both the device and private area */
3803 alloc_size = (sizeof(*dev) + NETDEV_ALIGN_CONST +
3804 (sizeof(struct net_device_subqueue) * (queue_count - 1))) &
3805 ~NETDEV_ALIGN_CONST;
3806 alloc_size += sizeof_priv + NETDEV_ALIGN_CONST;
3808 p = kzalloc(alloc_size, GFP_KERNEL);
3810 printk(KERN_ERR "alloc_netdev: Unable to allocate device.\n");
3814 dev = (struct net_device *)
3815 (((long)p + NETDEV_ALIGN_CONST) & ~NETDEV_ALIGN_CONST);
3816 dev->padded = (char *)dev - (char *)p;
3817 dev->nd_net = &init_net;
3820 dev->priv = ((char *)dev +
3821 ((sizeof(struct net_device) +
3822 (sizeof(struct net_device_subqueue) *
3823 (queue_count - 1)) + NETDEV_ALIGN_CONST)
3824 & ~NETDEV_ALIGN_CONST));
3827 dev->egress_subqueue_count = queue_count;
3829 dev->get_stats = internal_stats;
3830 netpoll_netdev_init(dev);
3832 strcpy(dev->name, name);
3835 EXPORT_SYMBOL(alloc_netdev_mq);
3838 * free_netdev - free network device
3841 * This function does the last stage of destroying an allocated device
3842 * interface. The reference to the device object is released.
3843 * If this is the last reference then it will be freed.
3845 void free_netdev(struct net_device *dev)
3847 /* Compatibility with error handling in drivers */
3848 if (dev->reg_state == NETREG_UNINITIALIZED) {
3849 kfree((char *)dev - dev->padded);
3853 BUG_ON(dev->reg_state != NETREG_UNREGISTERED);
3854 dev->reg_state = NETREG_RELEASED;
3856 /* will free via device release */
3857 put_device(&dev->dev);
3860 /* Synchronize with packet receive processing. */
3861 void synchronize_net(void)
3868 * unregister_netdevice - remove device from the kernel
3871 * This function shuts down a device interface and removes it
3872 * from the kernel tables. On success 0 is returned, on a failure
3873 * a negative errno code is returned.
3875 * Callers must hold the rtnl semaphore. You may want
3876 * unregister_netdev() instead of this.
3879 void unregister_netdevice(struct net_device *dev)
3881 BUG_ON(dev_boot_phase);
3884 /* Some devices call without registering for initialization unwind. */
3885 if (dev->reg_state == NETREG_UNINITIALIZED) {
3886 printk(KERN_DEBUG "unregister_netdevice: device %s/%p never "
3887 "was registered\n", dev->name, dev);
3893 BUG_ON(dev->reg_state != NETREG_REGISTERED);
3895 /* If device is running, close it first. */
3896 if (dev->flags & IFF_UP)
3899 /* And unlink it from device chain. */
3900 unlist_netdevice(dev);
3902 dev->reg_state = NETREG_UNREGISTERING;
3906 /* Shutdown queueing discipline. */
3910 /* Notify protocols, that we are about to destroy
3911 this device. They should clean all the things.
3913 call_netdevice_notifiers(NETDEV_UNREGISTER, dev);
3916 * Flush the unicast and multicast chains
3918 dev_addr_discard(dev);
3923 /* Notifier chain MUST detach us from master device. */
3924 BUG_TRAP(!dev->master);
3926 /* Remove entries from kobject tree */
3927 netdev_unregister_kobject(dev);
3929 /* Finish processing unregister after unlock */
3938 * unregister_netdev - remove device from the kernel
3941 * This function shuts down a device interface and removes it
3942 * from the kernel tables. On success 0 is returned, on a failure
3943 * a negative errno code is returned.
3945 * This is just a wrapper for unregister_netdevice that takes
3946 * the rtnl semaphore. In general you want to use this and not
3947 * unregister_netdevice.
3949 void unregister_netdev(struct net_device *dev)
3952 unregister_netdevice(dev);
3956 EXPORT_SYMBOL(unregister_netdev);
3959 * dev_change_net_namespace - move device to different nethost namespace
3961 * @net: network namespace
3962 * @pat: If not NULL name pattern to try if the current device name
3963 * is already taken in the destination network namespace.
3965 * This function shuts down a device interface and moves it
3966 * to a new network namespace. On success 0 is returned, on
3967 * a failure a netagive errno code is returned.
3969 * Callers must hold the rtnl semaphore.
3972 int dev_change_net_namespace(struct net_device *dev, struct net *net, const char *pat)
3975 const char *destname;
3980 /* Don't allow namespace local devices to be moved. */
3982 if (dev->features & NETIF_F_NETNS_LOCAL)
3985 /* Ensure the device has been registrered */
3987 if (dev->reg_state != NETREG_REGISTERED)
3990 /* Get out if there is nothing todo */
3992 if (dev->nd_net == net)
3995 /* Pick the destination device name, and ensure
3996 * we can use it in the destination network namespace.
3999 destname = dev->name;
4000 if (__dev_get_by_name(net, destname)) {
4001 /* We get here if we can't use the current device name */
4004 if (!dev_valid_name(pat))
4006 if (strchr(pat, '%')) {
4007 if (__dev_alloc_name(net, pat, buf) < 0)
4012 if (__dev_get_by_name(net, destname))
4017 * And now a mini version of register_netdevice unregister_netdevice.
4020 /* If device is running close it first. */
4021 if (dev->flags & IFF_UP)
4024 /* And unlink it from device chain */
4026 unlist_netdevice(dev);
4030 /* Shutdown queueing discipline. */
4033 /* Notify protocols, that we are about to destroy
4034 this device. They should clean all the things.
4036 call_netdevice_notifiers(NETDEV_UNREGISTER, dev);
4039 * Flush the unicast and multicast chains
4041 dev_addr_discard(dev);
4043 /* Actually switch the network namespace */
4046 /* Assign the new device name */
4047 if (destname != dev->name)
4048 strcpy(dev->name, destname);
4050 /* If there is an ifindex conflict assign a new one */
4051 if (__dev_get_by_index(net, dev->ifindex)) {
4052 int iflink = (dev->iflink == dev->ifindex);
4053 dev->ifindex = dev_new_index(net);
4055 dev->iflink = dev->ifindex;
4058 /* Fixup kobjects */
4059 err = device_rename(&dev->dev, dev->name);
4062 /* Add the device back in the hashes */
4063 list_netdevice(dev);
4065 /* Notify protocols, that a new device appeared. */
4066 call_netdevice_notifiers(NETDEV_REGISTER, dev);
4074 static int dev_cpu_callback(struct notifier_block *nfb,
4075 unsigned long action,
4078 struct sk_buff **list_skb;
4079 struct net_device **list_net;
4080 struct sk_buff *skb;
4081 unsigned int cpu, oldcpu = (unsigned long)ocpu;
4082 struct softnet_data *sd, *oldsd;
4084 if (action != CPU_DEAD && action != CPU_DEAD_FROZEN)
4087 local_irq_disable();
4088 cpu = smp_processor_id();
4089 sd = &per_cpu(softnet_data, cpu);
4090 oldsd = &per_cpu(softnet_data, oldcpu);
4092 /* Find end of our completion_queue. */
4093 list_skb = &sd->completion_queue;
4095 list_skb = &(*list_skb)->next;
4096 /* Append completion queue from offline CPU. */
4097 *list_skb = oldsd->completion_queue;
4098 oldsd->completion_queue = NULL;
4100 /* Find end of our output_queue. */
4101 list_net = &sd->output_queue;
4103 list_net = &(*list_net)->next_sched;
4104 /* Append output queue from offline CPU. */
4105 *list_net = oldsd->output_queue;
4106 oldsd->output_queue = NULL;
4108 raise_softirq_irqoff(NET_TX_SOFTIRQ);
4111 /* Process offline CPU's input_pkt_queue */
4112 while ((skb = __skb_dequeue(&oldsd->input_pkt_queue)))
4118 #ifdef CONFIG_NET_DMA
4120 * net_dma_rebalance - try to maintain one DMA channel per CPU
4121 * @net_dma: DMA client and associated data (lock, channels, channel_mask)
4123 * This is called when the number of channels allocated to the net_dma client
4124 * changes. The net_dma client tries to have one DMA channel per CPU.
4127 static void net_dma_rebalance(struct net_dma *net_dma)
4129 unsigned int cpu, i, n, chan_idx;
4130 struct dma_chan *chan;
4132 if (cpus_empty(net_dma->channel_mask)) {
4133 for_each_online_cpu(cpu)
4134 rcu_assign_pointer(per_cpu(softnet_data, cpu).net_dma, NULL);
4139 cpu = first_cpu(cpu_online_map);
4141 for_each_cpu_mask(chan_idx, net_dma->channel_mask) {
4142 chan = net_dma->channels[chan_idx];
4144 n = ((num_online_cpus() / cpus_weight(net_dma->channel_mask))
4145 + (i < (num_online_cpus() %
4146 cpus_weight(net_dma->channel_mask)) ? 1 : 0));
4149 per_cpu(softnet_data, cpu).net_dma = chan;
4150 cpu = next_cpu(cpu, cpu_online_map);
4158 * netdev_dma_event - event callback for the net_dma_client
4159 * @client: should always be net_dma_client
4160 * @chan: DMA channel for the event
4161 * @state: DMA state to be handled
4163 static enum dma_state_client
4164 netdev_dma_event(struct dma_client *client, struct dma_chan *chan,
4165 enum dma_state state)
4167 int i, found = 0, pos = -1;
4168 struct net_dma *net_dma =
4169 container_of(client, struct net_dma, client);
4170 enum dma_state_client ack = DMA_DUP; /* default: take no action */
4172 spin_lock(&net_dma->lock);
4174 case DMA_RESOURCE_AVAILABLE:
4175 for (i = 0; i < NR_CPUS; i++)
4176 if (net_dma->channels[i] == chan) {
4179 } else if (net_dma->channels[i] == NULL && pos < 0)
4182 if (!found && pos >= 0) {
4184 net_dma->channels[pos] = chan;
4185 cpu_set(pos, net_dma->channel_mask);
4186 net_dma_rebalance(net_dma);
4189 case DMA_RESOURCE_REMOVED:
4190 for (i = 0; i < NR_CPUS; i++)
4191 if (net_dma->channels[i] == chan) {
4199 cpu_clear(pos, net_dma->channel_mask);
4200 net_dma->channels[i] = NULL;
4201 net_dma_rebalance(net_dma);
4207 spin_unlock(&net_dma->lock);
4213 * netdev_dma_regiser - register the networking subsystem as a DMA client
4215 static int __init netdev_dma_register(void)
4217 spin_lock_init(&net_dma.lock);
4218 dma_cap_set(DMA_MEMCPY, net_dma.client.cap_mask);
4219 dma_async_client_register(&net_dma.client);
4220 dma_async_client_chan_request(&net_dma.client);
4225 static int __init netdev_dma_register(void) { return -ENODEV; }
4226 #endif /* CONFIG_NET_DMA */
4229 * netdev_compute_feature - compute conjunction of two feature sets
4230 * @all: first feature set
4231 * @one: second feature set
4233 * Computes a new feature set after adding a device with feature set
4234 * @one to the master device with current feature set @all. Returns
4235 * the new feature set.
4237 int netdev_compute_features(unsigned long all, unsigned long one)
4239 /* if device needs checksumming, downgrade to hw checksumming */
4240 if (all & NETIF_F_NO_CSUM && !(one & NETIF_F_NO_CSUM))
4241 all ^= NETIF_F_NO_CSUM | NETIF_F_HW_CSUM;
4243 /* if device can't do all checksum, downgrade to ipv4/ipv6 */
4244 if (all & NETIF_F_HW_CSUM && !(one & NETIF_F_HW_CSUM))
4245 all ^= NETIF_F_HW_CSUM
4246 | NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM;
4248 if (one & NETIF_F_GSO)
4249 one |= NETIF_F_GSO_SOFTWARE;
4252 /* If even one device supports robust GSO, enable it for all. */
4253 if (one & NETIF_F_GSO_ROBUST)
4254 all |= NETIF_F_GSO_ROBUST;
4256 all &= one | NETIF_F_LLTX;
4258 if (!(all & NETIF_F_ALL_CSUM))
4260 if (!(all & NETIF_F_SG))
4261 all &= ~NETIF_F_GSO_MASK;
4265 EXPORT_SYMBOL(netdev_compute_features);
4267 static struct hlist_head *netdev_create_hash(void)
4270 struct hlist_head *hash;
4272 hash = kmalloc(sizeof(*hash) * NETDEV_HASHENTRIES, GFP_KERNEL);
4274 for (i = 0; i < NETDEV_HASHENTRIES; i++)
4275 INIT_HLIST_HEAD(&hash[i]);
4280 /* Initialize per network namespace state */
4281 static int netdev_init(struct net *net)
4283 INIT_LIST_HEAD(&net->dev_base_head);
4284 rwlock_init(&dev_base_lock);
4286 net->dev_name_head = netdev_create_hash();
4287 if (net->dev_name_head == NULL)
4290 net->dev_index_head = netdev_create_hash();
4291 if (net->dev_index_head == NULL)
4297 kfree(net->dev_name_head);
4302 static void netdev_exit(struct net *net)
4304 kfree(net->dev_name_head);
4305 kfree(net->dev_index_head);
4308 static struct pernet_operations netdev_net_ops = {
4309 .init = netdev_init,
4310 .exit = netdev_exit,
4313 static void default_device_exit(struct net *net)
4315 struct net_device *dev, *next;
4317 * Push all migratable of the network devices back to the
4318 * initial network namespace
4321 for_each_netdev_safe(net, dev, next) {
4324 /* Ignore unmoveable devices (i.e. loopback) */
4325 if (dev->features & NETIF_F_NETNS_LOCAL)
4328 /* Push remaing network devices to init_net */
4329 err = dev_change_net_namespace(dev, &init_net, "dev%d");
4331 printk(KERN_WARNING "%s: failed to move %s to init_net: %d\n",
4332 __func__, dev->name, err);
4333 unregister_netdevice(dev);
4339 static struct pernet_operations default_device_ops = {
4340 .exit = default_device_exit,
4344 * Initialize the DEV module. At boot time this walks the device list and
4345 * unhooks any devices that fail to initialise (normally hardware not
4346 * present) and leaves us with a valid list of present and active devices.
4351 * This is called single threaded during boot, so no need
4352 * to take the rtnl semaphore.
4354 static int __init net_dev_init(void)
4356 int i, rc = -ENOMEM;
4358 BUG_ON(!dev_boot_phase);
4360 if (dev_proc_init())
4363 if (netdev_kobject_init())
4366 INIT_LIST_HEAD(&ptype_all);
4367 for (i = 0; i < 16; i++)
4368 INIT_LIST_HEAD(&ptype_base[i]);
4370 if (register_pernet_subsys(&netdev_net_ops))
4373 if (register_pernet_device(&default_device_ops))
4377 * Initialise the packet receive queues.
4380 for_each_possible_cpu(i) {
4381 struct softnet_data *queue;
4383 queue = &per_cpu(softnet_data, i);
4384 skb_queue_head_init(&queue->input_pkt_queue);
4385 queue->completion_queue = NULL;
4386 INIT_LIST_HEAD(&queue->poll_list);
4388 queue->backlog.poll = process_backlog;
4389 queue->backlog.weight = weight_p;
4392 netdev_dma_register();
4396 open_softirq(NET_TX_SOFTIRQ, net_tx_action, NULL);
4397 open_softirq(NET_RX_SOFTIRQ, net_rx_action, NULL);
4399 hotcpu_notifier(dev_cpu_callback, 0);
4407 subsys_initcall(net_dev_init);
4409 EXPORT_SYMBOL(__dev_get_by_index);
4410 EXPORT_SYMBOL(__dev_get_by_name);
4411 EXPORT_SYMBOL(__dev_remove_pack);
4412 EXPORT_SYMBOL(dev_valid_name);
4413 EXPORT_SYMBOL(dev_add_pack);
4414 EXPORT_SYMBOL(dev_alloc_name);
4415 EXPORT_SYMBOL(dev_close);
4416 EXPORT_SYMBOL(dev_get_by_flags);
4417 EXPORT_SYMBOL(dev_get_by_index);
4418 EXPORT_SYMBOL(dev_get_by_name);
4419 EXPORT_SYMBOL(dev_open);
4420 EXPORT_SYMBOL(dev_queue_xmit);
4421 EXPORT_SYMBOL(dev_remove_pack);
4422 EXPORT_SYMBOL(dev_set_allmulti);
4423 EXPORT_SYMBOL(dev_set_promiscuity);
4424 EXPORT_SYMBOL(dev_change_flags);
4425 EXPORT_SYMBOL(dev_set_mtu);
4426 EXPORT_SYMBOL(dev_set_mac_address);
4427 EXPORT_SYMBOL(free_netdev);
4428 EXPORT_SYMBOL(netdev_boot_setup_check);
4429 EXPORT_SYMBOL(netdev_set_master);
4430 EXPORT_SYMBOL(netdev_state_change);
4431 EXPORT_SYMBOL(netif_receive_skb);
4432 EXPORT_SYMBOL(netif_rx);
4433 EXPORT_SYMBOL(register_gifconf);
4434 EXPORT_SYMBOL(register_netdevice);
4435 EXPORT_SYMBOL(register_netdevice_notifier);
4436 EXPORT_SYMBOL(skb_checksum_help);
4437 EXPORT_SYMBOL(synchronize_net);
4438 EXPORT_SYMBOL(unregister_netdevice);
4439 EXPORT_SYMBOL(unregister_netdevice_notifier);
4440 EXPORT_SYMBOL(net_enable_timestamp);
4441 EXPORT_SYMBOL(net_disable_timestamp);
4442 EXPORT_SYMBOL(dev_get_flags);
4444 #if defined(CONFIG_BRIDGE) || defined(CONFIG_BRIDGE_MODULE)
4445 EXPORT_SYMBOL(br_handle_frame_hook);
4446 EXPORT_SYMBOL(br_fdb_get_hook);
4447 EXPORT_SYMBOL(br_fdb_put_hook);
4451 EXPORT_SYMBOL(dev_load);
4454 EXPORT_PER_CPU_SYMBOL(softnet_data);