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/ethtool.h>
94 #include <linux/notifier.h>
95 #include <linux/skbuff.h>
96 #include <net/net_namespace.h>
98 #include <linux/rtnetlink.h>
99 #include <linux/proc_fs.h>
100 #include <linux/seq_file.h>
101 #include <linux/stat.h>
102 #include <linux/if_bridge.h>
103 #include <linux/if_macvlan.h>
105 #include <net/pkt_sched.h>
106 #include <net/checksum.h>
107 #include <linux/highmem.h>
108 #include <linux/init.h>
109 #include <linux/kmod.h>
110 #include <linux/module.h>
111 #include <linux/kallsyms.h>
112 #include <linux/netpoll.h>
113 #include <linux/rcupdate.h>
114 #include <linux/delay.h>
115 #include <net/wext.h>
116 #include <net/iw_handler.h>
117 #include <asm/current.h>
118 #include <linux/audit.h>
119 #include <linux/dmaengine.h>
120 #include <linux/err.h>
121 #include <linux/ctype.h>
122 #include <linux/if_arp.h>
123 #include <linux/if_vlan.h>
124 #include <linux/ip.h>
125 #include <linux/ipv6.h>
126 #include <linux/in.h>
127 #include <linux/jhash.h>
128 #include <linux/random.h>
130 #include "net-sysfs.h"
133 * The list of packet types we will receive (as opposed to discard)
134 * and the routines to invoke.
136 * Why 16. Because with 16 the only overlap we get on a hash of the
137 * low nibble of the protocol value is RARP/SNAP/X.25.
139 * NOTE: That is no longer true with the addition of VLAN tags. Not
140 * sure which should go first, but I bet it won't make much
141 * difference if we are running VLANs. The good news is that
142 * this protocol won't be in the list unless compiled in, so
143 * the average user (w/out VLANs) will not be adversely affected.
160 #define PTYPE_HASH_SIZE (16)
161 #define PTYPE_HASH_MASK (PTYPE_HASH_SIZE - 1)
163 static DEFINE_SPINLOCK(ptype_lock);
164 static struct list_head ptype_base[PTYPE_HASH_SIZE] __read_mostly;
165 static struct list_head ptype_all __read_mostly; /* Taps */
167 #ifdef CONFIG_NET_DMA
169 struct dma_client client;
171 cpumask_t channel_mask;
172 struct dma_chan **channels;
175 static enum dma_state_client
176 netdev_dma_event(struct dma_client *client, struct dma_chan *chan,
177 enum dma_state state);
179 static struct net_dma net_dma = {
181 .event_callback = netdev_dma_event,
187 * The @dev_base_head list is protected by @dev_base_lock and the rtnl
190 * Pure readers hold dev_base_lock for reading.
192 * Writers must hold the rtnl semaphore while they loop through the
193 * dev_base_head list, and hold dev_base_lock for writing when they do the
194 * actual updates. This allows pure readers to access the list even
195 * while a writer is preparing to update it.
197 * To put it another way, dev_base_lock is held for writing only to
198 * protect against pure readers; the rtnl semaphore provides the
199 * protection against other writers.
201 * See, for example usages, register_netdevice() and
202 * unregister_netdevice(), which must be called with the rtnl
205 DEFINE_RWLOCK(dev_base_lock);
207 EXPORT_SYMBOL(dev_base_lock);
209 #define NETDEV_HASHBITS 8
210 #define NETDEV_HASHENTRIES (1 << NETDEV_HASHBITS)
212 static inline struct hlist_head *dev_name_hash(struct net *net, const char *name)
214 unsigned hash = full_name_hash(name, strnlen(name, IFNAMSIZ));
215 return &net->dev_name_head[hash & ((1 << NETDEV_HASHBITS) - 1)];
218 static inline struct hlist_head *dev_index_hash(struct net *net, int ifindex)
220 return &net->dev_index_head[ifindex & ((1 << NETDEV_HASHBITS) - 1)];
223 /* Device list insertion */
224 static int list_netdevice(struct net_device *dev)
226 struct net *net = dev_net(dev);
230 write_lock_bh(&dev_base_lock);
231 list_add_tail(&dev->dev_list, &net->dev_base_head);
232 hlist_add_head(&dev->name_hlist, dev_name_hash(net, dev->name));
233 hlist_add_head(&dev->index_hlist, dev_index_hash(net, dev->ifindex));
234 write_unlock_bh(&dev_base_lock);
238 /* Device list removal */
239 static void unlist_netdevice(struct net_device *dev)
243 /* Unlink dev from the device chain */
244 write_lock_bh(&dev_base_lock);
245 list_del(&dev->dev_list);
246 hlist_del(&dev->name_hlist);
247 hlist_del(&dev->index_hlist);
248 write_unlock_bh(&dev_base_lock);
255 static RAW_NOTIFIER_HEAD(netdev_chain);
258 * Device drivers call our routines to queue packets here. We empty the
259 * queue in the local softnet handler.
262 DEFINE_PER_CPU(struct softnet_data, softnet_data);
264 #ifdef CONFIG_LOCKDEP
266 * register_netdevice() inits txq->_xmit_lock and sets lockdep class
267 * according to dev->type
269 static const unsigned short netdev_lock_type[] =
270 {ARPHRD_NETROM, ARPHRD_ETHER, ARPHRD_EETHER, ARPHRD_AX25,
271 ARPHRD_PRONET, ARPHRD_CHAOS, ARPHRD_IEEE802, ARPHRD_ARCNET,
272 ARPHRD_APPLETLK, ARPHRD_DLCI, ARPHRD_ATM, ARPHRD_METRICOM,
273 ARPHRD_IEEE1394, ARPHRD_EUI64, ARPHRD_INFINIBAND, ARPHRD_SLIP,
274 ARPHRD_CSLIP, ARPHRD_SLIP6, ARPHRD_CSLIP6, ARPHRD_RSRVD,
275 ARPHRD_ADAPT, ARPHRD_ROSE, ARPHRD_X25, ARPHRD_HWX25,
276 ARPHRD_PPP, ARPHRD_CISCO, ARPHRD_LAPB, ARPHRD_DDCMP,
277 ARPHRD_RAWHDLC, ARPHRD_TUNNEL, ARPHRD_TUNNEL6, ARPHRD_FRAD,
278 ARPHRD_SKIP, ARPHRD_LOOPBACK, ARPHRD_LOCALTLK, ARPHRD_FDDI,
279 ARPHRD_BIF, ARPHRD_SIT, ARPHRD_IPDDP, ARPHRD_IPGRE,
280 ARPHRD_PIMREG, ARPHRD_HIPPI, ARPHRD_ASH, ARPHRD_ECONET,
281 ARPHRD_IRDA, ARPHRD_FCPP, ARPHRD_FCAL, ARPHRD_FCPL,
282 ARPHRD_FCFABRIC, ARPHRD_IEEE802_TR, ARPHRD_IEEE80211,
283 ARPHRD_IEEE80211_PRISM, ARPHRD_IEEE80211_RADIOTAP, ARPHRD_VOID,
286 static const char *netdev_lock_name[] =
287 {"_xmit_NETROM", "_xmit_ETHER", "_xmit_EETHER", "_xmit_AX25",
288 "_xmit_PRONET", "_xmit_CHAOS", "_xmit_IEEE802", "_xmit_ARCNET",
289 "_xmit_APPLETLK", "_xmit_DLCI", "_xmit_ATM", "_xmit_METRICOM",
290 "_xmit_IEEE1394", "_xmit_EUI64", "_xmit_INFINIBAND", "_xmit_SLIP",
291 "_xmit_CSLIP", "_xmit_SLIP6", "_xmit_CSLIP6", "_xmit_RSRVD",
292 "_xmit_ADAPT", "_xmit_ROSE", "_xmit_X25", "_xmit_HWX25",
293 "_xmit_PPP", "_xmit_CISCO", "_xmit_LAPB", "_xmit_DDCMP",
294 "_xmit_RAWHDLC", "_xmit_TUNNEL", "_xmit_TUNNEL6", "_xmit_FRAD",
295 "_xmit_SKIP", "_xmit_LOOPBACK", "_xmit_LOCALTLK", "_xmit_FDDI",
296 "_xmit_BIF", "_xmit_SIT", "_xmit_IPDDP", "_xmit_IPGRE",
297 "_xmit_PIMREG", "_xmit_HIPPI", "_xmit_ASH", "_xmit_ECONET",
298 "_xmit_IRDA", "_xmit_FCPP", "_xmit_FCAL", "_xmit_FCPL",
299 "_xmit_FCFABRIC", "_xmit_IEEE802_TR", "_xmit_IEEE80211",
300 "_xmit_IEEE80211_PRISM", "_xmit_IEEE80211_RADIOTAP", "_xmit_VOID",
303 static struct lock_class_key netdev_xmit_lock_key[ARRAY_SIZE(netdev_lock_type)];
304 static struct lock_class_key netdev_addr_lock_key[ARRAY_SIZE(netdev_lock_type)];
306 static inline unsigned short netdev_lock_pos(unsigned short dev_type)
310 for (i = 0; i < ARRAY_SIZE(netdev_lock_type); i++)
311 if (netdev_lock_type[i] == dev_type)
313 /* the last key is used by default */
314 return ARRAY_SIZE(netdev_lock_type) - 1;
317 static inline void netdev_set_xmit_lockdep_class(spinlock_t *lock,
318 unsigned short dev_type)
322 i = netdev_lock_pos(dev_type);
323 lockdep_set_class_and_name(lock, &netdev_xmit_lock_key[i],
324 netdev_lock_name[i]);
327 static inline void netdev_set_addr_lockdep_class(struct net_device *dev)
331 i = netdev_lock_pos(dev->type);
332 lockdep_set_class_and_name(&dev->addr_list_lock,
333 &netdev_addr_lock_key[i],
334 netdev_lock_name[i]);
337 static inline void netdev_set_xmit_lockdep_class(spinlock_t *lock,
338 unsigned short dev_type)
341 static inline void netdev_set_addr_lockdep_class(struct net_device *dev)
346 /*******************************************************************************
348 Protocol management and registration routines
350 *******************************************************************************/
353 * Add a protocol ID to the list. Now that the input handler is
354 * smarter we can dispense with all the messy stuff that used to be
357 * BEWARE!!! Protocol handlers, mangling input packets,
358 * MUST BE last in hash buckets and checking protocol handlers
359 * MUST start from promiscuous ptype_all chain in net_bh.
360 * It is true now, do not change it.
361 * Explanation follows: if protocol handler, mangling packet, will
362 * be the first on list, it is not able to sense, that packet
363 * is cloned and should be copied-on-write, so that it will
364 * change it and subsequent readers will get broken packet.
369 * dev_add_pack - add packet handler
370 * @pt: packet type declaration
372 * Add a protocol handler to the networking stack. The passed &packet_type
373 * is linked into kernel lists and may not be freed until it has been
374 * removed from the kernel lists.
376 * This call does not sleep therefore it can not
377 * guarantee all CPU's that are in middle of receiving packets
378 * will see the new packet type (until the next received packet).
381 void dev_add_pack(struct packet_type *pt)
385 spin_lock_bh(&ptype_lock);
386 if (pt->type == htons(ETH_P_ALL))
387 list_add_rcu(&pt->list, &ptype_all);
389 hash = ntohs(pt->type) & PTYPE_HASH_MASK;
390 list_add_rcu(&pt->list, &ptype_base[hash]);
392 spin_unlock_bh(&ptype_lock);
396 * __dev_remove_pack - remove packet handler
397 * @pt: packet type declaration
399 * Remove a protocol handler that was previously added to the kernel
400 * protocol handlers by dev_add_pack(). The passed &packet_type is removed
401 * from the kernel lists and can be freed or reused once this function
404 * The packet type might still be in use by receivers
405 * and must not be freed until after all the CPU's have gone
406 * through a quiescent state.
408 void __dev_remove_pack(struct packet_type *pt)
410 struct list_head *head;
411 struct packet_type *pt1;
413 spin_lock_bh(&ptype_lock);
415 if (pt->type == htons(ETH_P_ALL))
418 head = &ptype_base[ntohs(pt->type) & PTYPE_HASH_MASK];
420 list_for_each_entry(pt1, head, list) {
422 list_del_rcu(&pt->list);
427 printk(KERN_WARNING "dev_remove_pack: %p not found.\n", pt);
429 spin_unlock_bh(&ptype_lock);
432 * dev_remove_pack - remove packet handler
433 * @pt: packet type declaration
435 * Remove a protocol handler that was previously added to the kernel
436 * protocol handlers by dev_add_pack(). The passed &packet_type is removed
437 * from the kernel lists and can be freed or reused once this function
440 * This call sleeps to guarantee that no CPU is looking at the packet
443 void dev_remove_pack(struct packet_type *pt)
445 __dev_remove_pack(pt);
450 /******************************************************************************
452 Device Boot-time Settings Routines
454 *******************************************************************************/
456 /* Boot time configuration table */
457 static struct netdev_boot_setup dev_boot_setup[NETDEV_BOOT_SETUP_MAX];
460 * netdev_boot_setup_add - add new setup entry
461 * @name: name of the device
462 * @map: configured settings for the device
464 * Adds new setup entry to the dev_boot_setup list. The function
465 * returns 0 on error and 1 on success. This is a generic routine to
468 static int netdev_boot_setup_add(char *name, struct ifmap *map)
470 struct netdev_boot_setup *s;
474 for (i = 0; i < NETDEV_BOOT_SETUP_MAX; i++) {
475 if (s[i].name[0] == '\0' || s[i].name[0] == ' ') {
476 memset(s[i].name, 0, sizeof(s[i].name));
477 strlcpy(s[i].name, name, IFNAMSIZ);
478 memcpy(&s[i].map, map, sizeof(s[i].map));
483 return i >= NETDEV_BOOT_SETUP_MAX ? 0 : 1;
487 * netdev_boot_setup_check - check boot time settings
488 * @dev: the netdevice
490 * Check boot time settings for the device.
491 * The found settings are set for the device to be used
492 * later in the device probing.
493 * Returns 0 if no settings found, 1 if they are.
495 int netdev_boot_setup_check(struct net_device *dev)
497 struct netdev_boot_setup *s = dev_boot_setup;
500 for (i = 0; i < NETDEV_BOOT_SETUP_MAX; i++) {
501 if (s[i].name[0] != '\0' && s[i].name[0] != ' ' &&
502 !strcmp(dev->name, s[i].name)) {
503 dev->irq = s[i].map.irq;
504 dev->base_addr = s[i].map.base_addr;
505 dev->mem_start = s[i].map.mem_start;
506 dev->mem_end = s[i].map.mem_end;
515 * netdev_boot_base - get address from boot time settings
516 * @prefix: prefix for network device
517 * @unit: id for network device
519 * Check boot time settings for the base address of device.
520 * The found settings are set for the device to be used
521 * later in the device probing.
522 * Returns 0 if no settings found.
524 unsigned long netdev_boot_base(const char *prefix, int unit)
526 const struct netdev_boot_setup *s = dev_boot_setup;
530 sprintf(name, "%s%d", prefix, unit);
533 * If device already registered then return base of 1
534 * to indicate not to probe for this interface
536 if (__dev_get_by_name(&init_net, name))
539 for (i = 0; i < NETDEV_BOOT_SETUP_MAX; i++)
540 if (!strcmp(name, s[i].name))
541 return s[i].map.base_addr;
546 * Saves at boot time configured settings for any netdevice.
548 int __init netdev_boot_setup(char *str)
553 str = get_options(str, ARRAY_SIZE(ints), ints);
558 memset(&map, 0, sizeof(map));
562 map.base_addr = ints[2];
564 map.mem_start = ints[3];
566 map.mem_end = ints[4];
568 /* Add new entry to the list */
569 return netdev_boot_setup_add(str, &map);
572 __setup("netdev=", netdev_boot_setup);
574 /*******************************************************************************
576 Device Interface Subroutines
578 *******************************************************************************/
581 * __dev_get_by_name - find a device by its name
582 * @net: the applicable net namespace
583 * @name: name to find
585 * Find an interface by name. Must be called under RTNL semaphore
586 * or @dev_base_lock. If the name is found a pointer to the device
587 * is returned. If the name is not found then %NULL is returned. The
588 * reference counters are not incremented so the caller must be
589 * careful with locks.
592 struct net_device *__dev_get_by_name(struct net *net, const char *name)
594 struct hlist_node *p;
596 hlist_for_each(p, dev_name_hash(net, name)) {
597 struct net_device *dev
598 = hlist_entry(p, struct net_device, name_hlist);
599 if (!strncmp(dev->name, name, IFNAMSIZ))
606 * dev_get_by_name - find a device by its name
607 * @net: the applicable net namespace
608 * @name: name to find
610 * Find an interface by name. This can be called from any
611 * context and does its own locking. The returned handle has
612 * the usage count incremented and the caller must use dev_put() to
613 * release it when it is no longer needed. %NULL is returned if no
614 * matching device is found.
617 struct net_device *dev_get_by_name(struct net *net, const char *name)
619 struct net_device *dev;
621 read_lock(&dev_base_lock);
622 dev = __dev_get_by_name(net, name);
625 read_unlock(&dev_base_lock);
630 * __dev_get_by_index - find a device by its ifindex
631 * @net: the applicable net namespace
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 has not
636 * had its reference counter increased so the caller must be careful
637 * about locking. The caller must hold either the RTNL semaphore
641 struct net_device *__dev_get_by_index(struct net *net, int ifindex)
643 struct hlist_node *p;
645 hlist_for_each(p, dev_index_hash(net, ifindex)) {
646 struct net_device *dev
647 = hlist_entry(p, struct net_device, index_hlist);
648 if (dev->ifindex == ifindex)
656 * dev_get_by_index - find a device by its ifindex
657 * @net: the applicable net namespace
658 * @ifindex: index of device
660 * Search for an interface by index. Returns NULL if the device
661 * is not found or a pointer to the device. The device returned has
662 * had a reference added and the pointer is safe until the user calls
663 * dev_put to indicate they have finished with it.
666 struct net_device *dev_get_by_index(struct net *net, int ifindex)
668 struct net_device *dev;
670 read_lock(&dev_base_lock);
671 dev = __dev_get_by_index(net, ifindex);
674 read_unlock(&dev_base_lock);
679 * dev_getbyhwaddr - find a device by its hardware address
680 * @net: the applicable net namespace
681 * @type: media type of device
682 * @ha: hardware address
684 * Search for an interface by MAC address. Returns NULL if the device
685 * is not found or a pointer to the device. The caller must hold the
686 * rtnl semaphore. The returned device has not had its ref count increased
687 * and the caller must therefore be careful about locking
690 * If the API was consistent this would be __dev_get_by_hwaddr
693 struct net_device *dev_getbyhwaddr(struct net *net, unsigned short type, char *ha)
695 struct net_device *dev;
699 for_each_netdev(net, dev)
700 if (dev->type == type &&
701 !memcmp(dev->dev_addr, ha, dev->addr_len))
707 EXPORT_SYMBOL(dev_getbyhwaddr);
709 struct net_device *__dev_getfirstbyhwtype(struct net *net, unsigned short type)
711 struct net_device *dev;
714 for_each_netdev(net, dev)
715 if (dev->type == type)
721 EXPORT_SYMBOL(__dev_getfirstbyhwtype);
723 struct net_device *dev_getfirstbyhwtype(struct net *net, unsigned short type)
725 struct net_device *dev;
728 dev = __dev_getfirstbyhwtype(net, type);
735 EXPORT_SYMBOL(dev_getfirstbyhwtype);
738 * dev_get_by_flags - find any device with given flags
739 * @net: the applicable net namespace
740 * @if_flags: IFF_* values
741 * @mask: bitmask of bits in if_flags to check
743 * Search for any interface with the given flags. Returns NULL if a device
744 * is not found or a pointer to the device. The device returned has
745 * had a reference added and the pointer is safe until the user calls
746 * dev_put to indicate they have finished with it.
749 struct net_device * dev_get_by_flags(struct net *net, unsigned short if_flags, unsigned short mask)
751 struct net_device *dev, *ret;
754 read_lock(&dev_base_lock);
755 for_each_netdev(net, dev) {
756 if (((dev->flags ^ if_flags) & mask) == 0) {
762 read_unlock(&dev_base_lock);
767 * dev_valid_name - check if name is okay for network device
770 * Network device names need to be valid file names to
771 * to allow sysfs to work. We also disallow any kind of
774 int dev_valid_name(const char *name)
778 if (strlen(name) >= IFNAMSIZ)
780 if (!strcmp(name, ".") || !strcmp(name, ".."))
784 if (*name == '/' || isspace(*name))
792 * __dev_alloc_name - allocate a name for a device
793 * @net: network namespace to allocate the device name in
794 * @name: name format string
795 * @buf: scratch buffer and result name string
797 * Passed a format string - eg "lt%d" it will try and find a suitable
798 * id. It scans list of devices to build up a free map, then chooses
799 * the first empty slot. The caller must hold the dev_base or rtnl lock
800 * while allocating the name and adding the device in order to avoid
802 * Limited to bits_per_byte * page size devices (ie 32K on most platforms).
803 * Returns the number of the unit assigned or a negative errno code.
806 static int __dev_alloc_name(struct net *net, const char *name, char *buf)
810 const int max_netdevices = 8*PAGE_SIZE;
811 unsigned long *inuse;
812 struct net_device *d;
814 p = strnchr(name, IFNAMSIZ-1, '%');
817 * Verify the string as this thing may have come from
818 * the user. There must be either one "%d" and no other "%"
821 if (p[1] != 'd' || strchr(p + 2, '%'))
824 /* Use one page as a bit array of possible slots */
825 inuse = (unsigned long *) get_zeroed_page(GFP_ATOMIC);
829 for_each_netdev(net, d) {
830 if (!sscanf(d->name, name, &i))
832 if (i < 0 || i >= max_netdevices)
835 /* avoid cases where sscanf is not exact inverse of printf */
836 snprintf(buf, IFNAMSIZ, name, i);
837 if (!strncmp(buf, d->name, IFNAMSIZ))
841 i = find_first_zero_bit(inuse, max_netdevices);
842 free_page((unsigned long) inuse);
845 snprintf(buf, IFNAMSIZ, name, i);
846 if (!__dev_get_by_name(net, buf))
849 /* It is possible to run out of possible slots
850 * when the name is long and there isn't enough space left
851 * for the digits, or if all bits are used.
857 * dev_alloc_name - allocate a name for a device
859 * @name: name format string
861 * Passed a format string - eg "lt%d" it will try and find a suitable
862 * id. It scans list of devices to build up a free map, then chooses
863 * the first empty slot. The caller must hold the dev_base or rtnl lock
864 * while allocating the name and adding the device in order to avoid
866 * Limited to bits_per_byte * page size devices (ie 32K on most platforms).
867 * Returns the number of the unit assigned or a negative errno code.
870 int dev_alloc_name(struct net_device *dev, const char *name)
876 BUG_ON(!dev_net(dev));
878 ret = __dev_alloc_name(net, name, buf);
880 strlcpy(dev->name, buf, IFNAMSIZ);
886 * dev_change_name - change name of a device
888 * @newname: name (or format string) must be at least IFNAMSIZ
890 * Change name of a device, can pass format strings "eth%d".
893 int dev_change_name(struct net_device *dev, char *newname)
895 char oldname[IFNAMSIZ];
901 BUG_ON(!dev_net(dev));
904 if (dev->flags & IFF_UP)
907 if (!dev_valid_name(newname))
910 if (strncmp(newname, dev->name, IFNAMSIZ) == 0)
913 memcpy(oldname, dev->name, IFNAMSIZ);
915 if (strchr(newname, '%')) {
916 err = dev_alloc_name(dev, newname);
919 strcpy(newname, dev->name);
921 else if (__dev_get_by_name(net, newname))
924 strlcpy(dev->name, newname, IFNAMSIZ);
927 err = device_rename(&dev->dev, dev->name);
929 memcpy(dev->name, oldname, IFNAMSIZ);
933 write_lock_bh(&dev_base_lock);
934 hlist_del(&dev->name_hlist);
935 hlist_add_head(&dev->name_hlist, dev_name_hash(net, dev->name));
936 write_unlock_bh(&dev_base_lock);
938 ret = call_netdevice_notifiers(NETDEV_CHANGENAME, dev);
939 ret = notifier_to_errno(ret);
944 "%s: name change rollback failed: %d.\n",
948 memcpy(dev->name, oldname, IFNAMSIZ);
957 * netdev_features_change - device changes features
958 * @dev: device to cause notification
960 * Called to indicate a device has changed features.
962 void netdev_features_change(struct net_device *dev)
964 call_netdevice_notifiers(NETDEV_FEAT_CHANGE, dev);
966 EXPORT_SYMBOL(netdev_features_change);
969 * netdev_state_change - device changes state
970 * @dev: device to cause notification
972 * Called to indicate a device has changed state. This function calls
973 * the notifier chains for netdev_chain and sends a NEWLINK message
974 * to the routing socket.
976 void netdev_state_change(struct net_device *dev)
978 if (dev->flags & IFF_UP) {
979 call_netdevice_notifiers(NETDEV_CHANGE, dev);
980 rtmsg_ifinfo(RTM_NEWLINK, dev, 0);
984 void netdev_bonding_change(struct net_device *dev)
986 call_netdevice_notifiers(NETDEV_BONDING_FAILOVER, dev);
988 EXPORT_SYMBOL(netdev_bonding_change);
991 * dev_load - load a network module
992 * @net: the applicable net namespace
993 * @name: name of interface
995 * If a network interface is not present and the process has suitable
996 * privileges this function loads the module. If module loading is not
997 * available in this kernel then it becomes a nop.
1000 void dev_load(struct net *net, const char *name)
1002 struct net_device *dev;
1004 read_lock(&dev_base_lock);
1005 dev = __dev_get_by_name(net, name);
1006 read_unlock(&dev_base_lock);
1008 if (!dev && capable(CAP_SYS_MODULE))
1009 request_module("%s", name);
1013 * dev_open - prepare an interface for use.
1014 * @dev: device to open
1016 * Takes a device from down to up state. The device's private open
1017 * function is invoked and then the multicast lists are loaded. Finally
1018 * the device is moved into the up state and a %NETDEV_UP message is
1019 * sent to the netdev notifier chain.
1021 * Calling this function on an active interface is a nop. On a failure
1022 * a negative errno code is returned.
1024 int dev_open(struct net_device *dev)
1034 if (dev->flags & IFF_UP)
1038 * Is it even present?
1040 if (!netif_device_present(dev))
1044 * Call device private open method
1046 set_bit(__LINK_STATE_START, &dev->state);
1048 if (dev->validate_addr)
1049 ret = dev->validate_addr(dev);
1051 if (!ret && dev->open)
1052 ret = dev->open(dev);
1055 * If it went open OK then:
1059 clear_bit(__LINK_STATE_START, &dev->state);
1064 dev->flags |= IFF_UP;
1067 * Initialize multicasting status
1069 dev_set_rx_mode(dev);
1072 * Wakeup transmit queue engine
1077 * ... and announce new interface.
1079 call_netdevice_notifiers(NETDEV_UP, dev);
1086 * dev_close - shutdown an interface.
1087 * @dev: device to shutdown
1089 * This function moves an active device into down state. A
1090 * %NETDEV_GOING_DOWN is sent to the netdev notifier chain. The device
1091 * is then deactivated and finally a %NETDEV_DOWN is sent to the notifier
1094 int dev_close(struct net_device *dev)
1100 if (!(dev->flags & IFF_UP))
1104 * Tell people we are going down, so that they can
1105 * prepare to death, when device is still operating.
1107 call_netdevice_notifiers(NETDEV_GOING_DOWN, dev);
1109 clear_bit(__LINK_STATE_START, &dev->state);
1111 /* Synchronize to scheduled poll. We cannot touch poll list,
1112 * it can be even on different cpu. So just clear netif_running().
1114 * dev->stop() will invoke napi_disable() on all of it's
1115 * napi_struct instances on this device.
1117 smp_mb__after_clear_bit(); /* Commit netif_running(). */
1119 dev_deactivate(dev);
1122 * Call the device specific close. This cannot fail.
1123 * Only if device is UP
1125 * We allow it to be called even after a DETACH hot-plug
1132 * Device is now down.
1135 dev->flags &= ~IFF_UP;
1138 * Tell people we are down
1140 call_netdevice_notifiers(NETDEV_DOWN, dev);
1147 * dev_disable_lro - disable Large Receive Offload on a device
1150 * Disable Large Receive Offload (LRO) on a net device. Must be
1151 * called under RTNL. This is needed if received packets may be
1152 * forwarded to another interface.
1154 void dev_disable_lro(struct net_device *dev)
1156 if (dev->ethtool_ops && dev->ethtool_ops->get_flags &&
1157 dev->ethtool_ops->set_flags) {
1158 u32 flags = dev->ethtool_ops->get_flags(dev);
1159 if (flags & ETH_FLAG_LRO) {
1160 flags &= ~ETH_FLAG_LRO;
1161 dev->ethtool_ops->set_flags(dev, flags);
1164 WARN_ON(dev->features & NETIF_F_LRO);
1166 EXPORT_SYMBOL(dev_disable_lro);
1169 static int dev_boot_phase = 1;
1172 * Device change register/unregister. These are not inline or static
1173 * as we export them to the world.
1177 * register_netdevice_notifier - register a network notifier block
1180 * Register a notifier to be called when network device events occur.
1181 * The notifier passed is linked into the kernel structures and must
1182 * not be reused until it has been unregistered. A negative errno code
1183 * is returned on a failure.
1185 * When registered all registration and up events are replayed
1186 * to the new notifier to allow device to have a race free
1187 * view of the network device list.
1190 int register_netdevice_notifier(struct notifier_block *nb)
1192 struct net_device *dev;
1193 struct net_device *last;
1198 err = raw_notifier_chain_register(&netdev_chain, nb);
1204 for_each_netdev(net, dev) {
1205 err = nb->notifier_call(nb, NETDEV_REGISTER, dev);
1206 err = notifier_to_errno(err);
1210 if (!(dev->flags & IFF_UP))
1213 nb->notifier_call(nb, NETDEV_UP, dev);
1224 for_each_netdev(net, dev) {
1228 if (dev->flags & IFF_UP) {
1229 nb->notifier_call(nb, NETDEV_GOING_DOWN, dev);
1230 nb->notifier_call(nb, NETDEV_DOWN, dev);
1232 nb->notifier_call(nb, NETDEV_UNREGISTER, dev);
1236 raw_notifier_chain_unregister(&netdev_chain, nb);
1241 * unregister_netdevice_notifier - unregister a network notifier block
1244 * Unregister a notifier previously registered by
1245 * register_netdevice_notifier(). The notifier is unlinked into the
1246 * kernel structures and may then be reused. A negative errno code
1247 * is returned on a failure.
1250 int unregister_netdevice_notifier(struct notifier_block *nb)
1255 err = raw_notifier_chain_unregister(&netdev_chain, nb);
1261 * call_netdevice_notifiers - call all network notifier blocks
1262 * @val: value passed unmodified to notifier function
1263 * @dev: net_device pointer passed unmodified to notifier function
1265 * Call all network notifier blocks. Parameters and return value
1266 * are as for raw_notifier_call_chain().
1269 int call_netdevice_notifiers(unsigned long val, struct net_device *dev)
1271 return raw_notifier_call_chain(&netdev_chain, val, dev);
1274 /* When > 0 there are consumers of rx skb time stamps */
1275 static atomic_t netstamp_needed = ATOMIC_INIT(0);
1277 void net_enable_timestamp(void)
1279 atomic_inc(&netstamp_needed);
1282 void net_disable_timestamp(void)
1284 atomic_dec(&netstamp_needed);
1287 static inline void net_timestamp(struct sk_buff *skb)
1289 if (atomic_read(&netstamp_needed))
1290 __net_timestamp(skb);
1292 skb->tstamp.tv64 = 0;
1296 * Support routine. Sends outgoing frames to any network
1297 * taps currently in use.
1300 static void dev_queue_xmit_nit(struct sk_buff *skb, struct net_device *dev)
1302 struct packet_type *ptype;
1307 list_for_each_entry_rcu(ptype, &ptype_all, list) {
1308 /* Never send packets back to the socket
1309 * they originated from - MvS (miquels@drinkel.ow.org)
1311 if ((ptype->dev == dev || !ptype->dev) &&
1312 (ptype->af_packet_priv == NULL ||
1313 (struct sock *)ptype->af_packet_priv != skb->sk)) {
1314 struct sk_buff *skb2= skb_clone(skb, GFP_ATOMIC);
1318 /* skb->nh should be correctly
1319 set by sender, so that the second statement is
1320 just protection against buggy protocols.
1322 skb_reset_mac_header(skb2);
1324 if (skb_network_header(skb2) < skb2->data ||
1325 skb2->network_header > skb2->tail) {
1326 if (net_ratelimit())
1327 printk(KERN_CRIT "protocol %04x is "
1329 skb2->protocol, dev->name);
1330 skb_reset_network_header(skb2);
1333 skb2->transport_header = skb2->network_header;
1334 skb2->pkt_type = PACKET_OUTGOING;
1335 ptype->func(skb2, skb->dev, ptype, skb->dev);
1342 void __netif_schedule(struct Qdisc *q)
1344 if (!test_and_set_bit(__QDISC_STATE_SCHED, &q->state)) {
1345 struct softnet_data *sd;
1346 unsigned long flags;
1348 local_irq_save(flags);
1349 sd = &__get_cpu_var(softnet_data);
1350 q->next_sched = sd->output_queue;
1351 sd->output_queue = q;
1352 raise_softirq_irqoff(NET_TX_SOFTIRQ);
1353 local_irq_restore(flags);
1356 EXPORT_SYMBOL(__netif_schedule);
1358 void dev_kfree_skb_irq(struct sk_buff *skb)
1360 if (atomic_dec_and_test(&skb->users)) {
1361 struct softnet_data *sd;
1362 unsigned long flags;
1364 local_irq_save(flags);
1365 sd = &__get_cpu_var(softnet_data);
1366 skb->next = sd->completion_queue;
1367 sd->completion_queue = skb;
1368 raise_softirq_irqoff(NET_TX_SOFTIRQ);
1369 local_irq_restore(flags);
1372 EXPORT_SYMBOL(dev_kfree_skb_irq);
1374 void dev_kfree_skb_any(struct sk_buff *skb)
1376 if (in_irq() || irqs_disabled())
1377 dev_kfree_skb_irq(skb);
1381 EXPORT_SYMBOL(dev_kfree_skb_any);
1385 * netif_device_detach - mark device as removed
1386 * @dev: network device
1388 * Mark device as removed from system and therefore no longer available.
1390 void netif_device_detach(struct net_device *dev)
1392 if (test_and_clear_bit(__LINK_STATE_PRESENT, &dev->state) &&
1393 netif_running(dev)) {
1394 netif_stop_queue(dev);
1397 EXPORT_SYMBOL(netif_device_detach);
1400 * netif_device_attach - mark device as attached
1401 * @dev: network device
1403 * Mark device as attached from system and restart if needed.
1405 void netif_device_attach(struct net_device *dev)
1407 if (!test_and_set_bit(__LINK_STATE_PRESENT, &dev->state) &&
1408 netif_running(dev)) {
1409 netif_wake_queue(dev);
1410 __netdev_watchdog_up(dev);
1413 EXPORT_SYMBOL(netif_device_attach);
1415 static bool can_checksum_protocol(unsigned long features, __be16 protocol)
1417 return ((features & NETIF_F_GEN_CSUM) ||
1418 ((features & NETIF_F_IP_CSUM) &&
1419 protocol == htons(ETH_P_IP)) ||
1420 ((features & NETIF_F_IPV6_CSUM) &&
1421 protocol == htons(ETH_P_IPV6)));
1424 static bool dev_can_checksum(struct net_device *dev, struct sk_buff *skb)
1426 if (can_checksum_protocol(dev->features, skb->protocol))
1429 if (skb->protocol == htons(ETH_P_8021Q)) {
1430 struct vlan_ethhdr *veh = (struct vlan_ethhdr *)skb->data;
1431 if (can_checksum_protocol(dev->features & dev->vlan_features,
1432 veh->h_vlan_encapsulated_proto))
1440 * Invalidate hardware checksum when packet is to be mangled, and
1441 * complete checksum manually on outgoing path.
1443 int skb_checksum_help(struct sk_buff *skb)
1446 int ret = 0, offset;
1448 if (skb->ip_summed == CHECKSUM_COMPLETE)
1449 goto out_set_summed;
1451 if (unlikely(skb_shinfo(skb)->gso_size)) {
1452 /* Let GSO fix up the checksum. */
1453 goto out_set_summed;
1456 offset = skb->csum_start - skb_headroom(skb);
1457 BUG_ON(offset >= skb_headlen(skb));
1458 csum = skb_checksum(skb, offset, skb->len - offset, 0);
1460 offset += skb->csum_offset;
1461 BUG_ON(offset + sizeof(__sum16) > skb_headlen(skb));
1463 if (skb_cloned(skb) &&
1464 !skb_clone_writable(skb, offset + sizeof(__sum16))) {
1465 ret = pskb_expand_head(skb, 0, 0, GFP_ATOMIC);
1470 *(__sum16 *)(skb->data + offset) = csum_fold(csum);
1472 skb->ip_summed = CHECKSUM_NONE;
1478 * skb_gso_segment - Perform segmentation on skb.
1479 * @skb: buffer to segment
1480 * @features: features for the output path (see dev->features)
1482 * This function segments the given skb and returns a list of segments.
1484 * It may return NULL if the skb requires no segmentation. This is
1485 * only possible when GSO is used for verifying header integrity.
1487 struct sk_buff *skb_gso_segment(struct sk_buff *skb, int features)
1489 struct sk_buff *segs = ERR_PTR(-EPROTONOSUPPORT);
1490 struct packet_type *ptype;
1491 __be16 type = skb->protocol;
1494 BUG_ON(skb_shinfo(skb)->frag_list);
1496 skb_reset_mac_header(skb);
1497 skb->mac_len = skb->network_header - skb->mac_header;
1498 __skb_pull(skb, skb->mac_len);
1500 if (WARN_ON(skb->ip_summed != CHECKSUM_PARTIAL)) {
1501 if (skb_header_cloned(skb) &&
1502 (err = pskb_expand_head(skb, 0, 0, GFP_ATOMIC)))
1503 return ERR_PTR(err);
1507 list_for_each_entry_rcu(ptype,
1508 &ptype_base[ntohs(type) & PTYPE_HASH_MASK], list) {
1509 if (ptype->type == type && !ptype->dev && ptype->gso_segment) {
1510 if (unlikely(skb->ip_summed != CHECKSUM_PARTIAL)) {
1511 err = ptype->gso_send_check(skb);
1512 segs = ERR_PTR(err);
1513 if (err || skb_gso_ok(skb, features))
1515 __skb_push(skb, (skb->data -
1516 skb_network_header(skb)));
1518 segs = ptype->gso_segment(skb, features);
1524 __skb_push(skb, skb->data - skb_mac_header(skb));
1529 EXPORT_SYMBOL(skb_gso_segment);
1531 /* Take action when hardware reception checksum errors are detected. */
1533 void netdev_rx_csum_fault(struct net_device *dev)
1535 if (net_ratelimit()) {
1536 printk(KERN_ERR "%s: hw csum failure.\n",
1537 dev ? dev->name : "<unknown>");
1541 EXPORT_SYMBOL(netdev_rx_csum_fault);
1544 /* Actually, we should eliminate this check as soon as we know, that:
1545 * 1. IOMMU is present and allows to map all the memory.
1546 * 2. No high memory really exists on this machine.
1549 static inline int illegal_highdma(struct net_device *dev, struct sk_buff *skb)
1551 #ifdef CONFIG_HIGHMEM
1554 if (dev->features & NETIF_F_HIGHDMA)
1557 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++)
1558 if (PageHighMem(skb_shinfo(skb)->frags[i].page))
1566 void (*destructor)(struct sk_buff *skb);
1569 #define DEV_GSO_CB(skb) ((struct dev_gso_cb *)(skb)->cb)
1571 static void dev_gso_skb_destructor(struct sk_buff *skb)
1573 struct dev_gso_cb *cb;
1576 struct sk_buff *nskb = skb->next;
1578 skb->next = nskb->next;
1581 } while (skb->next);
1583 cb = DEV_GSO_CB(skb);
1585 cb->destructor(skb);
1589 * dev_gso_segment - Perform emulated hardware segmentation on skb.
1590 * @skb: buffer to segment
1592 * This function segments the given skb and stores the list of segments
1595 static int dev_gso_segment(struct sk_buff *skb)
1597 struct net_device *dev = skb->dev;
1598 struct sk_buff *segs;
1599 int features = dev->features & ~(illegal_highdma(dev, skb) ?
1602 segs = skb_gso_segment(skb, features);
1604 /* Verifying header integrity only. */
1609 return PTR_ERR(segs);
1612 DEV_GSO_CB(skb)->destructor = skb->destructor;
1613 skb->destructor = dev_gso_skb_destructor;
1618 int dev_hard_start_xmit(struct sk_buff *skb, struct net_device *dev,
1619 struct netdev_queue *txq)
1621 if (likely(!skb->next)) {
1622 if (!list_empty(&ptype_all))
1623 dev_queue_xmit_nit(skb, dev);
1625 if (netif_needs_gso(dev, skb)) {
1626 if (unlikely(dev_gso_segment(skb)))
1632 return dev->hard_start_xmit(skb, dev);
1637 struct sk_buff *nskb = skb->next;
1640 skb->next = nskb->next;
1642 rc = dev->hard_start_xmit(nskb, dev);
1644 nskb->next = skb->next;
1648 if (unlikely(netif_tx_queue_stopped(txq) && skb->next))
1649 return NETDEV_TX_BUSY;
1650 } while (skb->next);
1652 skb->destructor = DEV_GSO_CB(skb)->destructor;
1659 static u32 simple_tx_hashrnd;
1660 static int simple_tx_hashrnd_initialized = 0;
1662 static u16 simple_tx_hash(struct net_device *dev, struct sk_buff *skb)
1664 u32 addr1, addr2, ports;
1668 if (unlikely(!simple_tx_hashrnd_initialized)) {
1669 get_random_bytes(&simple_tx_hashrnd, 4);
1670 simple_tx_hashrnd_initialized = 1;
1673 switch (skb->protocol) {
1674 case __constant_htons(ETH_P_IP):
1675 ip_proto = ip_hdr(skb)->protocol;
1676 addr1 = ip_hdr(skb)->saddr;
1677 addr2 = ip_hdr(skb)->daddr;
1678 ihl = ip_hdr(skb)->ihl;
1680 case __constant_htons(ETH_P_IPV6):
1681 ip_proto = ipv6_hdr(skb)->nexthdr;
1682 addr1 = ipv6_hdr(skb)->saddr.s6_addr32[3];
1683 addr2 = ipv6_hdr(skb)->daddr.s6_addr32[3];
1698 case IPPROTO_UDPLITE:
1699 ports = *((u32 *) (skb_network_header(skb) + (ihl * 4)));
1707 hash = jhash_3words(addr1, addr2, ports, simple_tx_hashrnd);
1709 return (u16) (((u64) hash * dev->real_num_tx_queues) >> 32);
1712 static struct netdev_queue *dev_pick_tx(struct net_device *dev,
1713 struct sk_buff *skb)
1715 u16 queue_index = 0;
1717 if (dev->select_queue)
1718 queue_index = dev->select_queue(dev, skb);
1719 else if (dev->real_num_tx_queues > 1)
1720 queue_index = simple_tx_hash(dev, skb);
1722 skb_set_queue_mapping(skb, queue_index);
1723 return netdev_get_tx_queue(dev, queue_index);
1727 * dev_queue_xmit - transmit a buffer
1728 * @skb: buffer to transmit
1730 * Queue a buffer for transmission to a network device. The caller must
1731 * have set the device and priority and built the buffer before calling
1732 * this function. The function can be called from an interrupt.
1734 * A negative errno code is returned on a failure. A success does not
1735 * guarantee the frame will be transmitted as it may be dropped due
1736 * to congestion or traffic shaping.
1738 * -----------------------------------------------------------------------------------
1739 * I notice this method can also return errors from the queue disciplines,
1740 * including NET_XMIT_DROP, which is a positive value. So, errors can also
1743 * Regardless of the return value, the skb is consumed, so it is currently
1744 * difficult to retry a send to this method. (You can bump the ref count
1745 * before sending to hold a reference for retry if you are careful.)
1747 * When calling this method, interrupts MUST be enabled. This is because
1748 * the BH enable code must have IRQs enabled so that it will not deadlock.
1751 int dev_queue_xmit(struct sk_buff *skb)
1753 struct net_device *dev = skb->dev;
1754 struct netdev_queue *txq;
1758 /* GSO will handle the following emulations directly. */
1759 if (netif_needs_gso(dev, skb))
1762 if (skb_shinfo(skb)->frag_list &&
1763 !(dev->features & NETIF_F_FRAGLIST) &&
1764 __skb_linearize(skb))
1767 /* Fragmented skb is linearized if device does not support SG,
1768 * or if at least one of fragments is in highmem and device
1769 * does not support DMA from it.
1771 if (skb_shinfo(skb)->nr_frags &&
1772 (!(dev->features & NETIF_F_SG) || illegal_highdma(dev, skb)) &&
1773 __skb_linearize(skb))
1776 /* If packet is not checksummed and device does not support
1777 * checksumming for this protocol, complete checksumming here.
1779 if (skb->ip_summed == CHECKSUM_PARTIAL) {
1780 skb_set_transport_header(skb, skb->csum_start -
1782 if (!dev_can_checksum(dev, skb) && skb_checksum_help(skb))
1787 /* Disable soft irqs for various locks below. Also
1788 * stops preemption for RCU.
1792 txq = dev_pick_tx(dev, skb);
1793 q = rcu_dereference(txq->qdisc);
1795 #ifdef CONFIG_NET_CLS_ACT
1796 skb->tc_verd = SET_TC_AT(skb->tc_verd,AT_EGRESS);
1799 spinlock_t *root_lock = qdisc_lock(q);
1801 spin_lock(root_lock);
1803 rc = qdisc_enqueue_root(skb, q);
1806 spin_unlock(root_lock);
1811 /* The device has no queue. Common case for software devices:
1812 loopback, all the sorts of tunnels...
1814 Really, it is unlikely that netif_tx_lock protection is necessary
1815 here. (f.e. loopback and IP tunnels are clean ignoring statistics
1817 However, it is possible, that they rely on protection
1820 Check this and shot the lock. It is not prone from deadlocks.
1821 Either shot noqueue qdisc, it is even simpler 8)
1823 if (dev->flags & IFF_UP) {
1824 int cpu = smp_processor_id(); /* ok because BHs are off */
1826 if (txq->xmit_lock_owner != cpu) {
1828 HARD_TX_LOCK(dev, txq, cpu);
1830 if (!netif_tx_queue_stopped(txq)) {
1832 if (!dev_hard_start_xmit(skb, dev, txq)) {
1833 HARD_TX_UNLOCK(dev, txq);
1837 HARD_TX_UNLOCK(dev, txq);
1838 if (net_ratelimit())
1839 printk(KERN_CRIT "Virtual device %s asks to "
1840 "queue packet!\n", dev->name);
1842 /* Recursion is detected! It is possible,
1844 if (net_ratelimit())
1845 printk(KERN_CRIT "Dead loop on virtual device "
1846 "%s, fix it urgently!\n", dev->name);
1851 rcu_read_unlock_bh();
1857 rcu_read_unlock_bh();
1862 /*=======================================================================
1864 =======================================================================*/
1866 int netdev_max_backlog __read_mostly = 1000;
1867 int netdev_budget __read_mostly = 300;
1868 int weight_p __read_mostly = 64; /* old backlog weight */
1870 DEFINE_PER_CPU(struct netif_rx_stats, netdev_rx_stat) = { 0, };
1874 * netif_rx - post buffer to the network code
1875 * @skb: buffer to post
1877 * This function receives a packet from a device driver and queues it for
1878 * the upper (protocol) levels to process. It always succeeds. The buffer
1879 * may be dropped during processing for congestion control or by the
1883 * NET_RX_SUCCESS (no congestion)
1884 * NET_RX_DROP (packet was dropped)
1888 int netif_rx(struct sk_buff *skb)
1890 struct softnet_data *queue;
1891 unsigned long flags;
1893 /* if netpoll wants it, pretend we never saw it */
1894 if (netpoll_rx(skb))
1897 if (!skb->tstamp.tv64)
1901 * The code is rearranged so that the path is the most
1902 * short when CPU is congested, but is still operating.
1904 local_irq_save(flags);
1905 queue = &__get_cpu_var(softnet_data);
1907 __get_cpu_var(netdev_rx_stat).total++;
1908 if (queue->input_pkt_queue.qlen <= netdev_max_backlog) {
1909 if (queue->input_pkt_queue.qlen) {
1911 __skb_queue_tail(&queue->input_pkt_queue, skb);
1912 local_irq_restore(flags);
1913 return NET_RX_SUCCESS;
1916 napi_schedule(&queue->backlog);
1920 __get_cpu_var(netdev_rx_stat).dropped++;
1921 local_irq_restore(flags);
1927 int netif_rx_ni(struct sk_buff *skb)
1932 err = netif_rx(skb);
1933 if (local_softirq_pending())
1940 EXPORT_SYMBOL(netif_rx_ni);
1942 static void net_tx_action(struct softirq_action *h)
1944 struct softnet_data *sd = &__get_cpu_var(softnet_data);
1946 if (sd->completion_queue) {
1947 struct sk_buff *clist;
1949 local_irq_disable();
1950 clist = sd->completion_queue;
1951 sd->completion_queue = NULL;
1955 struct sk_buff *skb = clist;
1956 clist = clist->next;
1958 WARN_ON(atomic_read(&skb->users));
1963 if (sd->output_queue) {
1966 local_irq_disable();
1967 head = sd->output_queue;
1968 sd->output_queue = NULL;
1972 struct Qdisc *q = head;
1973 spinlock_t *root_lock;
1975 head = head->next_sched;
1977 smp_mb__before_clear_bit();
1978 clear_bit(__QDISC_STATE_SCHED, &q->state);
1980 root_lock = qdisc_lock(q);
1981 if (spin_trylock(root_lock)) {
1983 spin_unlock(root_lock);
1985 __netif_schedule(q);
1991 static inline int deliver_skb(struct sk_buff *skb,
1992 struct packet_type *pt_prev,
1993 struct net_device *orig_dev)
1995 atomic_inc(&skb->users);
1996 return pt_prev->func(skb, skb->dev, pt_prev, orig_dev);
1999 #if defined(CONFIG_BRIDGE) || defined (CONFIG_BRIDGE_MODULE)
2000 /* These hooks defined here for ATM */
2002 struct net_bridge_fdb_entry *(*br_fdb_get_hook)(struct net_bridge *br,
2003 unsigned char *addr);
2004 void (*br_fdb_put_hook)(struct net_bridge_fdb_entry *ent) __read_mostly;
2007 * If bridge module is loaded call bridging hook.
2008 * returns NULL if packet was consumed.
2010 struct sk_buff *(*br_handle_frame_hook)(struct net_bridge_port *p,
2011 struct sk_buff *skb) __read_mostly;
2012 static inline struct sk_buff *handle_bridge(struct sk_buff *skb,
2013 struct packet_type **pt_prev, int *ret,
2014 struct net_device *orig_dev)
2016 struct net_bridge_port *port;
2018 if (skb->pkt_type == PACKET_LOOPBACK ||
2019 (port = rcu_dereference(skb->dev->br_port)) == NULL)
2023 *ret = deliver_skb(skb, *pt_prev, orig_dev);
2027 return br_handle_frame_hook(port, skb);
2030 #define handle_bridge(skb, pt_prev, ret, orig_dev) (skb)
2033 #if defined(CONFIG_MACVLAN) || defined(CONFIG_MACVLAN_MODULE)
2034 struct sk_buff *(*macvlan_handle_frame_hook)(struct sk_buff *skb) __read_mostly;
2035 EXPORT_SYMBOL_GPL(macvlan_handle_frame_hook);
2037 static inline struct sk_buff *handle_macvlan(struct sk_buff *skb,
2038 struct packet_type **pt_prev,
2040 struct net_device *orig_dev)
2042 if (skb->dev->macvlan_port == NULL)
2046 *ret = deliver_skb(skb, *pt_prev, orig_dev);
2049 return macvlan_handle_frame_hook(skb);
2052 #define handle_macvlan(skb, pt_prev, ret, orig_dev) (skb)
2055 #ifdef CONFIG_NET_CLS_ACT
2056 /* TODO: Maybe we should just force sch_ingress to be compiled in
2057 * when CONFIG_NET_CLS_ACT is? otherwise some useless instructions
2058 * a compare and 2 stores extra right now if we dont have it on
2059 * but have CONFIG_NET_CLS_ACT
2060 * NOTE: This doesnt stop any functionality; if you dont have
2061 * the ingress scheduler, you just cant add policies on ingress.
2064 static int ing_filter(struct sk_buff *skb)
2066 struct net_device *dev = skb->dev;
2067 u32 ttl = G_TC_RTTL(skb->tc_verd);
2068 struct netdev_queue *rxq;
2069 int result = TC_ACT_OK;
2072 if (MAX_RED_LOOP < ttl++) {
2074 "Redir loop detected Dropping packet (%d->%d)\n",
2075 skb->iif, dev->ifindex);
2079 skb->tc_verd = SET_TC_RTTL(skb->tc_verd, ttl);
2080 skb->tc_verd = SET_TC_AT(skb->tc_verd, AT_INGRESS);
2082 rxq = &dev->rx_queue;
2085 if (q != &noop_qdisc) {
2086 spin_lock(qdisc_lock(q));
2087 result = qdisc_enqueue_root(skb, q);
2088 spin_unlock(qdisc_lock(q));
2094 static inline struct sk_buff *handle_ing(struct sk_buff *skb,
2095 struct packet_type **pt_prev,
2096 int *ret, struct net_device *orig_dev)
2098 if (skb->dev->rx_queue.qdisc == &noop_qdisc)
2102 *ret = deliver_skb(skb, *pt_prev, orig_dev);
2105 /* Huh? Why does turning on AF_PACKET affect this? */
2106 skb->tc_verd = SET_TC_OK2MUNGE(skb->tc_verd);
2109 switch (ing_filter(skb)) {
2123 * netif_nit_deliver - deliver received packets to network taps
2126 * This function is used to deliver incoming packets to network
2127 * taps. It should be used when the normal netif_receive_skb path
2128 * is bypassed, for example because of VLAN acceleration.
2130 void netif_nit_deliver(struct sk_buff *skb)
2132 struct packet_type *ptype;
2134 if (list_empty(&ptype_all))
2137 skb_reset_network_header(skb);
2138 skb_reset_transport_header(skb);
2139 skb->mac_len = skb->network_header - skb->mac_header;
2142 list_for_each_entry_rcu(ptype, &ptype_all, list) {
2143 if (!ptype->dev || ptype->dev == skb->dev)
2144 deliver_skb(skb, ptype, skb->dev);
2150 * netif_receive_skb - process receive buffer from network
2151 * @skb: buffer to process
2153 * netif_receive_skb() is the main receive data processing function.
2154 * It always succeeds. The buffer may be dropped during processing
2155 * for congestion control or by the protocol layers.
2157 * This function may only be called from softirq context and interrupts
2158 * should be enabled.
2160 * Return values (usually ignored):
2161 * NET_RX_SUCCESS: no congestion
2162 * NET_RX_DROP: packet was dropped
2164 int netif_receive_skb(struct sk_buff *skb)
2166 struct packet_type *ptype, *pt_prev;
2167 struct net_device *orig_dev;
2168 struct net_device *null_or_orig;
2169 int ret = NET_RX_DROP;
2172 /* if we've gotten here through NAPI, check netpoll */
2173 if (netpoll_receive_skb(skb))
2176 if (!skb->tstamp.tv64)
2180 skb->iif = skb->dev->ifindex;
2182 null_or_orig = NULL;
2183 orig_dev = skb->dev;
2184 if (orig_dev->master) {
2185 if (skb_bond_should_drop(skb))
2186 null_or_orig = orig_dev; /* deliver only exact match */
2188 skb->dev = orig_dev->master;
2191 __get_cpu_var(netdev_rx_stat).total++;
2193 skb_reset_network_header(skb);
2194 skb_reset_transport_header(skb);
2195 skb->mac_len = skb->network_header - skb->mac_header;
2201 /* Don't receive packets in an exiting network namespace */
2202 if (!net_alive(dev_net(skb->dev)))
2205 #ifdef CONFIG_NET_CLS_ACT
2206 if (skb->tc_verd & TC_NCLS) {
2207 skb->tc_verd = CLR_TC_NCLS(skb->tc_verd);
2212 list_for_each_entry_rcu(ptype, &ptype_all, list) {
2213 if (ptype->dev == null_or_orig || ptype->dev == skb->dev) {
2215 ret = deliver_skb(skb, pt_prev, orig_dev);
2220 #ifdef CONFIG_NET_CLS_ACT
2221 skb = handle_ing(skb, &pt_prev, &ret, orig_dev);
2227 skb = handle_bridge(skb, &pt_prev, &ret, orig_dev);
2230 skb = handle_macvlan(skb, &pt_prev, &ret, orig_dev);
2234 type = skb->protocol;
2235 list_for_each_entry_rcu(ptype,
2236 &ptype_base[ntohs(type) & PTYPE_HASH_MASK], list) {
2237 if (ptype->type == type &&
2238 (ptype->dev == null_or_orig || ptype->dev == skb->dev)) {
2240 ret = deliver_skb(skb, pt_prev, orig_dev);
2246 ret = pt_prev->func(skb, skb->dev, pt_prev, orig_dev);
2249 /* Jamal, now you will not able to escape explaining
2250 * me how you were going to use this. :-)
2260 /* Network device is going away, flush any packets still pending */
2261 static void flush_backlog(void *arg)
2263 struct net_device *dev = arg;
2264 struct softnet_data *queue = &__get_cpu_var(softnet_data);
2265 struct sk_buff *skb, *tmp;
2267 skb_queue_walk_safe(&queue->input_pkt_queue, skb, tmp)
2268 if (skb->dev == dev) {
2269 __skb_unlink(skb, &queue->input_pkt_queue);
2274 static int process_backlog(struct napi_struct *napi, int quota)
2277 struct softnet_data *queue = &__get_cpu_var(softnet_data);
2278 unsigned long start_time = jiffies;
2280 napi->weight = weight_p;
2282 struct sk_buff *skb;
2284 local_irq_disable();
2285 skb = __skb_dequeue(&queue->input_pkt_queue);
2287 __napi_complete(napi);
2293 netif_receive_skb(skb);
2294 } while (++work < quota && jiffies == start_time);
2300 * __napi_schedule - schedule for receive
2301 * @n: entry to schedule
2303 * The entry's receive function will be scheduled to run
2305 void __napi_schedule(struct napi_struct *n)
2307 unsigned long flags;
2309 local_irq_save(flags);
2310 list_add_tail(&n->poll_list, &__get_cpu_var(softnet_data).poll_list);
2311 __raise_softirq_irqoff(NET_RX_SOFTIRQ);
2312 local_irq_restore(flags);
2314 EXPORT_SYMBOL(__napi_schedule);
2317 static void net_rx_action(struct softirq_action *h)
2319 struct list_head *list = &__get_cpu_var(softnet_data).poll_list;
2320 unsigned long start_time = jiffies;
2321 int budget = netdev_budget;
2324 local_irq_disable();
2326 while (!list_empty(list)) {
2327 struct napi_struct *n;
2330 /* If softirq window is exhuasted then punt.
2332 * Note that this is a slight policy change from the
2333 * previous NAPI code, which would allow up to 2
2334 * jiffies to pass before breaking out. The test
2335 * used to be "jiffies - start_time > 1".
2337 if (unlikely(budget <= 0 || jiffies != start_time))
2342 /* Even though interrupts have been re-enabled, this
2343 * access is safe because interrupts can only add new
2344 * entries to the tail of this list, and only ->poll()
2345 * calls can remove this head entry from the list.
2347 n = list_entry(list->next, struct napi_struct, poll_list);
2349 have = netpoll_poll_lock(n);
2353 /* This NAPI_STATE_SCHED test is for avoiding a race
2354 * with netpoll's poll_napi(). Only the entity which
2355 * obtains the lock and sees NAPI_STATE_SCHED set will
2356 * actually make the ->poll() call. Therefore we avoid
2357 * accidently calling ->poll() when NAPI is not scheduled.
2360 if (test_bit(NAPI_STATE_SCHED, &n->state))
2361 work = n->poll(n, weight);
2363 WARN_ON_ONCE(work > weight);
2367 local_irq_disable();
2369 /* Drivers must not modify the NAPI state if they
2370 * consume the entire weight. In such cases this code
2371 * still "owns" the NAPI instance and therefore can
2372 * move the instance around on the list at-will.
2374 if (unlikely(work == weight)) {
2375 if (unlikely(napi_disable_pending(n)))
2378 list_move_tail(&n->poll_list, list);
2381 netpoll_poll_unlock(have);
2386 #ifdef CONFIG_NET_DMA
2388 * There may not be any more sk_buffs coming right now, so push
2389 * any pending DMA copies to hardware
2391 if (!cpus_empty(net_dma.channel_mask)) {
2393 for_each_cpu_mask_nr(chan_idx, net_dma.channel_mask) {
2394 struct dma_chan *chan = net_dma.channels[chan_idx];
2396 dma_async_memcpy_issue_pending(chan);
2404 __get_cpu_var(netdev_rx_stat).time_squeeze++;
2405 __raise_softirq_irqoff(NET_RX_SOFTIRQ);
2409 static gifconf_func_t * gifconf_list [NPROTO];
2412 * register_gifconf - register a SIOCGIF handler
2413 * @family: Address family
2414 * @gifconf: Function handler
2416 * Register protocol dependent address dumping routines. The handler
2417 * that is passed must not be freed or reused until it has been replaced
2418 * by another handler.
2420 int register_gifconf(unsigned int family, gifconf_func_t * gifconf)
2422 if (family >= NPROTO)
2424 gifconf_list[family] = gifconf;
2430 * Map an interface index to its name (SIOCGIFNAME)
2434 * We need this ioctl for efficient implementation of the
2435 * if_indextoname() function required by the IPv6 API. Without
2436 * it, we would have to search all the interfaces to find a
2440 static int dev_ifname(struct net *net, struct ifreq __user *arg)
2442 struct net_device *dev;
2446 * Fetch the caller's info block.
2449 if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
2452 read_lock(&dev_base_lock);
2453 dev = __dev_get_by_index(net, ifr.ifr_ifindex);
2455 read_unlock(&dev_base_lock);
2459 strcpy(ifr.ifr_name, dev->name);
2460 read_unlock(&dev_base_lock);
2462 if (copy_to_user(arg, &ifr, sizeof(struct ifreq)))
2468 * Perform a SIOCGIFCONF call. This structure will change
2469 * size eventually, and there is nothing I can do about it.
2470 * Thus we will need a 'compatibility mode'.
2473 static int dev_ifconf(struct net *net, char __user *arg)
2476 struct net_device *dev;
2483 * Fetch the caller's info block.
2486 if (copy_from_user(&ifc, arg, sizeof(struct ifconf)))
2493 * Loop over the interfaces, and write an info block for each.
2497 for_each_netdev(net, dev) {
2498 for (i = 0; i < NPROTO; i++) {
2499 if (gifconf_list[i]) {
2502 done = gifconf_list[i](dev, NULL, 0);
2504 done = gifconf_list[i](dev, pos + total,
2514 * All done. Write the updated control block back to the caller.
2516 ifc.ifc_len = total;
2519 * Both BSD and Solaris return 0 here, so we do too.
2521 return copy_to_user(arg, &ifc, sizeof(struct ifconf)) ? -EFAULT : 0;
2524 #ifdef CONFIG_PROC_FS
2526 * This is invoked by the /proc filesystem handler to display a device
2529 void *dev_seq_start(struct seq_file *seq, loff_t *pos)
2530 __acquires(dev_base_lock)
2532 struct net *net = seq_file_net(seq);
2534 struct net_device *dev;
2536 read_lock(&dev_base_lock);
2538 return SEQ_START_TOKEN;
2541 for_each_netdev(net, dev)
2548 void *dev_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2550 struct net *net = seq_file_net(seq);
2552 return v == SEQ_START_TOKEN ?
2553 first_net_device(net) : next_net_device((struct net_device *)v);
2556 void dev_seq_stop(struct seq_file *seq, void *v)
2557 __releases(dev_base_lock)
2559 read_unlock(&dev_base_lock);
2562 static void dev_seq_printf_stats(struct seq_file *seq, struct net_device *dev)
2564 struct net_device_stats *stats = dev->get_stats(dev);
2566 seq_printf(seq, "%6s:%8lu %7lu %4lu %4lu %4lu %5lu %10lu %9lu "
2567 "%8lu %7lu %4lu %4lu %4lu %5lu %7lu %10lu\n",
2568 dev->name, stats->rx_bytes, stats->rx_packets,
2570 stats->rx_dropped + stats->rx_missed_errors,
2571 stats->rx_fifo_errors,
2572 stats->rx_length_errors + stats->rx_over_errors +
2573 stats->rx_crc_errors + stats->rx_frame_errors,
2574 stats->rx_compressed, stats->multicast,
2575 stats->tx_bytes, stats->tx_packets,
2576 stats->tx_errors, stats->tx_dropped,
2577 stats->tx_fifo_errors, stats->collisions,
2578 stats->tx_carrier_errors +
2579 stats->tx_aborted_errors +
2580 stats->tx_window_errors +
2581 stats->tx_heartbeat_errors,
2582 stats->tx_compressed);
2586 * Called from the PROCfs module. This now uses the new arbitrary sized
2587 * /proc/net interface to create /proc/net/dev
2589 static int dev_seq_show(struct seq_file *seq, void *v)
2591 if (v == SEQ_START_TOKEN)
2592 seq_puts(seq, "Inter-| Receive "
2594 " face |bytes packets errs drop fifo frame "
2595 "compressed multicast|bytes packets errs "
2596 "drop fifo colls carrier compressed\n");
2598 dev_seq_printf_stats(seq, v);
2602 static struct netif_rx_stats *softnet_get_online(loff_t *pos)
2604 struct netif_rx_stats *rc = NULL;
2606 while (*pos < nr_cpu_ids)
2607 if (cpu_online(*pos)) {
2608 rc = &per_cpu(netdev_rx_stat, *pos);
2615 static void *softnet_seq_start(struct seq_file *seq, loff_t *pos)
2617 return softnet_get_online(pos);
2620 static void *softnet_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2623 return softnet_get_online(pos);
2626 static void softnet_seq_stop(struct seq_file *seq, void *v)
2630 static int softnet_seq_show(struct seq_file *seq, void *v)
2632 struct netif_rx_stats *s = v;
2634 seq_printf(seq, "%08x %08x %08x %08x %08x %08x %08x %08x %08x\n",
2635 s->total, s->dropped, s->time_squeeze, 0,
2636 0, 0, 0, 0, /* was fastroute */
2641 static const struct seq_operations dev_seq_ops = {
2642 .start = dev_seq_start,
2643 .next = dev_seq_next,
2644 .stop = dev_seq_stop,
2645 .show = dev_seq_show,
2648 static int dev_seq_open(struct inode *inode, struct file *file)
2650 return seq_open_net(inode, file, &dev_seq_ops,
2651 sizeof(struct seq_net_private));
2654 static const struct file_operations dev_seq_fops = {
2655 .owner = THIS_MODULE,
2656 .open = dev_seq_open,
2658 .llseek = seq_lseek,
2659 .release = seq_release_net,
2662 static const struct seq_operations softnet_seq_ops = {
2663 .start = softnet_seq_start,
2664 .next = softnet_seq_next,
2665 .stop = softnet_seq_stop,
2666 .show = softnet_seq_show,
2669 static int softnet_seq_open(struct inode *inode, struct file *file)
2671 return seq_open(file, &softnet_seq_ops);
2674 static const struct file_operations softnet_seq_fops = {
2675 .owner = THIS_MODULE,
2676 .open = softnet_seq_open,
2678 .llseek = seq_lseek,
2679 .release = seq_release,
2682 static void *ptype_get_idx(loff_t pos)
2684 struct packet_type *pt = NULL;
2688 list_for_each_entry_rcu(pt, &ptype_all, list) {
2694 for (t = 0; t < PTYPE_HASH_SIZE; t++) {
2695 list_for_each_entry_rcu(pt, &ptype_base[t], list) {
2704 static void *ptype_seq_start(struct seq_file *seq, loff_t *pos)
2708 return *pos ? ptype_get_idx(*pos - 1) : SEQ_START_TOKEN;
2711 static void *ptype_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2713 struct packet_type *pt;
2714 struct list_head *nxt;
2718 if (v == SEQ_START_TOKEN)
2719 return ptype_get_idx(0);
2722 nxt = pt->list.next;
2723 if (pt->type == htons(ETH_P_ALL)) {
2724 if (nxt != &ptype_all)
2727 nxt = ptype_base[0].next;
2729 hash = ntohs(pt->type) & PTYPE_HASH_MASK;
2731 while (nxt == &ptype_base[hash]) {
2732 if (++hash >= PTYPE_HASH_SIZE)
2734 nxt = ptype_base[hash].next;
2737 return list_entry(nxt, struct packet_type, list);
2740 static void ptype_seq_stop(struct seq_file *seq, void *v)
2746 static void ptype_seq_decode(struct seq_file *seq, void *sym)
2748 #ifdef CONFIG_KALLSYMS
2749 unsigned long offset = 0, symsize;
2750 const char *symname;
2754 symname = kallsyms_lookup((unsigned long)sym, &symsize, &offset,
2761 modname = delim = "";
2762 seq_printf(seq, "%s%s%s%s+0x%lx", delim, modname, delim,
2768 seq_printf(seq, "[%p]", sym);
2771 static int ptype_seq_show(struct seq_file *seq, void *v)
2773 struct packet_type *pt = v;
2775 if (v == SEQ_START_TOKEN)
2776 seq_puts(seq, "Type Device Function\n");
2777 else if (pt->dev == NULL || dev_net(pt->dev) == seq_file_net(seq)) {
2778 if (pt->type == htons(ETH_P_ALL))
2779 seq_puts(seq, "ALL ");
2781 seq_printf(seq, "%04x", ntohs(pt->type));
2783 seq_printf(seq, " %-8s ",
2784 pt->dev ? pt->dev->name : "");
2785 ptype_seq_decode(seq, pt->func);
2786 seq_putc(seq, '\n');
2792 static const struct seq_operations ptype_seq_ops = {
2793 .start = ptype_seq_start,
2794 .next = ptype_seq_next,
2795 .stop = ptype_seq_stop,
2796 .show = ptype_seq_show,
2799 static int ptype_seq_open(struct inode *inode, struct file *file)
2801 return seq_open_net(inode, file, &ptype_seq_ops,
2802 sizeof(struct seq_net_private));
2805 static const struct file_operations ptype_seq_fops = {
2806 .owner = THIS_MODULE,
2807 .open = ptype_seq_open,
2809 .llseek = seq_lseek,
2810 .release = seq_release_net,
2814 static int __net_init dev_proc_net_init(struct net *net)
2818 if (!proc_net_fops_create(net, "dev", S_IRUGO, &dev_seq_fops))
2820 if (!proc_net_fops_create(net, "softnet_stat", S_IRUGO, &softnet_seq_fops))
2822 if (!proc_net_fops_create(net, "ptype", S_IRUGO, &ptype_seq_fops))
2825 if (wext_proc_init(net))
2831 proc_net_remove(net, "ptype");
2833 proc_net_remove(net, "softnet_stat");
2835 proc_net_remove(net, "dev");
2839 static void __net_exit dev_proc_net_exit(struct net *net)
2841 wext_proc_exit(net);
2843 proc_net_remove(net, "ptype");
2844 proc_net_remove(net, "softnet_stat");
2845 proc_net_remove(net, "dev");
2848 static struct pernet_operations __net_initdata dev_proc_ops = {
2849 .init = dev_proc_net_init,
2850 .exit = dev_proc_net_exit,
2853 static int __init dev_proc_init(void)
2855 return register_pernet_subsys(&dev_proc_ops);
2858 #define dev_proc_init() 0
2859 #endif /* CONFIG_PROC_FS */
2863 * netdev_set_master - set up master/slave pair
2864 * @slave: slave device
2865 * @master: new master device
2867 * Changes the master device of the slave. Pass %NULL to break the
2868 * bonding. The caller must hold the RTNL semaphore. On a failure
2869 * a negative errno code is returned. On success the reference counts
2870 * are adjusted, %RTM_NEWLINK is sent to the routing socket and the
2871 * function returns zero.
2873 int netdev_set_master(struct net_device *slave, struct net_device *master)
2875 struct net_device *old = slave->master;
2885 slave->master = master;
2893 slave->flags |= IFF_SLAVE;
2895 slave->flags &= ~IFF_SLAVE;
2897 rtmsg_ifinfo(RTM_NEWLINK, slave, IFF_SLAVE);
2901 static int __dev_set_promiscuity(struct net_device *dev, int inc)
2903 unsigned short old_flags = dev->flags;
2907 dev->flags |= IFF_PROMISC;
2908 dev->promiscuity += inc;
2909 if (dev->promiscuity == 0) {
2912 * If inc causes overflow, untouch promisc and return error.
2915 dev->flags &= ~IFF_PROMISC;
2917 dev->promiscuity -= inc;
2918 printk(KERN_WARNING "%s: promiscuity touches roof, "
2919 "set promiscuity failed, promiscuity feature "
2920 "of device might be broken.\n", dev->name);
2924 if (dev->flags != old_flags) {
2925 printk(KERN_INFO "device %s %s promiscuous mode\n",
2926 dev->name, (dev->flags & IFF_PROMISC) ? "entered" :
2929 audit_log(current->audit_context, GFP_ATOMIC,
2930 AUDIT_ANOM_PROMISCUOUS,
2931 "dev=%s prom=%d old_prom=%d auid=%u uid=%u gid=%u ses=%u",
2932 dev->name, (dev->flags & IFF_PROMISC),
2933 (old_flags & IFF_PROMISC),
2934 audit_get_loginuid(current),
2935 current->uid, current->gid,
2936 audit_get_sessionid(current));
2938 if (dev->change_rx_flags)
2939 dev->change_rx_flags(dev, IFF_PROMISC);
2945 * dev_set_promiscuity - update promiscuity count on a device
2949 * Add or remove promiscuity from a device. While the count in the device
2950 * remains above zero the interface remains promiscuous. Once it hits zero
2951 * the device reverts back to normal filtering operation. A negative inc
2952 * value is used to drop promiscuity on the device.
2953 * Return 0 if successful or a negative errno code on error.
2955 int dev_set_promiscuity(struct net_device *dev, int inc)
2957 unsigned short old_flags = dev->flags;
2960 err = __dev_set_promiscuity(dev, inc);
2963 if (dev->flags != old_flags)
2964 dev_set_rx_mode(dev);
2969 * dev_set_allmulti - update allmulti count on a device
2973 * Add or remove reception of all multicast frames to a device. While the
2974 * count in the device remains above zero the interface remains listening
2975 * to all interfaces. Once it hits zero the device reverts back to normal
2976 * filtering operation. A negative @inc value is used to drop the counter
2977 * when releasing a resource needing all multicasts.
2978 * Return 0 if successful or a negative errno code on error.
2981 int dev_set_allmulti(struct net_device *dev, int inc)
2983 unsigned short old_flags = dev->flags;
2987 dev->flags |= IFF_ALLMULTI;
2988 dev->allmulti += inc;
2989 if (dev->allmulti == 0) {
2992 * If inc causes overflow, untouch allmulti and return error.
2995 dev->flags &= ~IFF_ALLMULTI;
2997 dev->allmulti -= inc;
2998 printk(KERN_WARNING "%s: allmulti touches roof, "
2999 "set allmulti failed, allmulti feature of "
3000 "device might be broken.\n", dev->name);
3004 if (dev->flags ^ old_flags) {
3005 if (dev->change_rx_flags)
3006 dev->change_rx_flags(dev, IFF_ALLMULTI);
3007 dev_set_rx_mode(dev);
3013 * Upload unicast and multicast address lists to device and
3014 * configure RX filtering. When the device doesn't support unicast
3015 * filtering it is put in promiscuous mode while unicast addresses
3018 void __dev_set_rx_mode(struct net_device *dev)
3020 /* dev_open will call this function so the list will stay sane. */
3021 if (!(dev->flags&IFF_UP))
3024 if (!netif_device_present(dev))
3027 if (dev->set_rx_mode)
3028 dev->set_rx_mode(dev);
3030 /* Unicast addresses changes may only happen under the rtnl,
3031 * therefore calling __dev_set_promiscuity here is safe.
3033 if (dev->uc_count > 0 && !dev->uc_promisc) {
3034 __dev_set_promiscuity(dev, 1);
3035 dev->uc_promisc = 1;
3036 } else if (dev->uc_count == 0 && dev->uc_promisc) {
3037 __dev_set_promiscuity(dev, -1);
3038 dev->uc_promisc = 0;
3041 if (dev->set_multicast_list)
3042 dev->set_multicast_list(dev);
3046 void dev_set_rx_mode(struct net_device *dev)
3048 netif_addr_lock_bh(dev);
3049 __dev_set_rx_mode(dev);
3050 netif_addr_unlock_bh(dev);
3053 int __dev_addr_delete(struct dev_addr_list **list, int *count,
3054 void *addr, int alen, int glbl)
3056 struct dev_addr_list *da;
3058 for (; (da = *list) != NULL; list = &da->next) {
3059 if (memcmp(da->da_addr, addr, da->da_addrlen) == 0 &&
3060 alen == da->da_addrlen) {
3062 int old_glbl = da->da_gusers;
3079 int __dev_addr_add(struct dev_addr_list **list, int *count,
3080 void *addr, int alen, int glbl)
3082 struct dev_addr_list *da;
3084 for (da = *list; da != NULL; da = da->next) {
3085 if (memcmp(da->da_addr, addr, da->da_addrlen) == 0 &&
3086 da->da_addrlen == alen) {
3088 int old_glbl = da->da_gusers;
3098 da = kzalloc(sizeof(*da), GFP_ATOMIC);
3101 memcpy(da->da_addr, addr, alen);
3102 da->da_addrlen = alen;
3104 da->da_gusers = glbl ? 1 : 0;
3112 * dev_unicast_delete - Release secondary unicast address.
3114 * @addr: address to delete
3115 * @alen: length of @addr
3117 * Release reference to a secondary unicast address and remove it
3118 * from the device if the reference count drops to zero.
3120 * The caller must hold the rtnl_mutex.
3122 int dev_unicast_delete(struct net_device *dev, void *addr, int alen)
3128 netif_addr_lock_bh(dev);
3129 err = __dev_addr_delete(&dev->uc_list, &dev->uc_count, addr, alen, 0);
3131 __dev_set_rx_mode(dev);
3132 netif_addr_unlock_bh(dev);
3135 EXPORT_SYMBOL(dev_unicast_delete);
3138 * dev_unicast_add - add a secondary unicast address
3140 * @addr: address to add
3141 * @alen: length of @addr
3143 * Add a secondary unicast address to the device or increase
3144 * the reference count if it already exists.
3146 * The caller must hold the rtnl_mutex.
3148 int dev_unicast_add(struct net_device *dev, void *addr, int alen)
3154 netif_addr_lock_bh(dev);
3155 err = __dev_addr_add(&dev->uc_list, &dev->uc_count, addr, alen, 0);
3157 __dev_set_rx_mode(dev);
3158 netif_addr_unlock_bh(dev);
3161 EXPORT_SYMBOL(dev_unicast_add);
3163 int __dev_addr_sync(struct dev_addr_list **to, int *to_count,
3164 struct dev_addr_list **from, int *from_count)
3166 struct dev_addr_list *da, *next;
3170 while (da != NULL) {
3172 if (!da->da_synced) {
3173 err = __dev_addr_add(to, to_count,
3174 da->da_addr, da->da_addrlen, 0);
3179 } else if (da->da_users == 1) {
3180 __dev_addr_delete(to, to_count,
3181 da->da_addr, da->da_addrlen, 0);
3182 __dev_addr_delete(from, from_count,
3183 da->da_addr, da->da_addrlen, 0);
3190 void __dev_addr_unsync(struct dev_addr_list **to, int *to_count,
3191 struct dev_addr_list **from, int *from_count)
3193 struct dev_addr_list *da, *next;
3196 while (da != NULL) {
3198 if (da->da_synced) {
3199 __dev_addr_delete(to, to_count,
3200 da->da_addr, da->da_addrlen, 0);
3202 __dev_addr_delete(from, from_count,
3203 da->da_addr, da->da_addrlen, 0);
3210 * dev_unicast_sync - Synchronize device's unicast list to another device
3211 * @to: destination device
3212 * @from: source device
3214 * Add newly added addresses to the destination device and release
3215 * addresses that have no users left. The source device must be
3216 * locked by netif_tx_lock_bh.
3218 * This function is intended to be called from the dev->set_rx_mode
3219 * function of layered software devices.
3221 int dev_unicast_sync(struct net_device *to, struct net_device *from)
3225 netif_addr_lock_bh(to);
3226 err = __dev_addr_sync(&to->uc_list, &to->uc_count,
3227 &from->uc_list, &from->uc_count);
3229 __dev_set_rx_mode(to);
3230 netif_addr_unlock_bh(to);
3233 EXPORT_SYMBOL(dev_unicast_sync);
3236 * dev_unicast_unsync - Remove synchronized addresses from the destination device
3237 * @to: destination device
3238 * @from: source device
3240 * Remove all addresses that were added to the destination device by
3241 * dev_unicast_sync(). This function is intended to be called from the
3242 * dev->stop function of layered software devices.
3244 void dev_unicast_unsync(struct net_device *to, struct net_device *from)
3246 netif_addr_lock_bh(from);
3247 netif_addr_lock(to);
3249 __dev_addr_unsync(&to->uc_list, &to->uc_count,
3250 &from->uc_list, &from->uc_count);
3251 __dev_set_rx_mode(to);
3253 netif_addr_unlock(to);
3254 netif_addr_unlock_bh(from);
3256 EXPORT_SYMBOL(dev_unicast_unsync);
3258 static void __dev_addr_discard(struct dev_addr_list **list)
3260 struct dev_addr_list *tmp;
3262 while (*list != NULL) {
3265 if (tmp->da_users > tmp->da_gusers)
3266 printk("__dev_addr_discard: address leakage! "
3267 "da_users=%d\n", tmp->da_users);
3272 static void dev_addr_discard(struct net_device *dev)
3274 netif_addr_lock_bh(dev);
3276 __dev_addr_discard(&dev->uc_list);
3279 __dev_addr_discard(&dev->mc_list);
3282 netif_addr_unlock_bh(dev);
3285 unsigned dev_get_flags(const struct net_device *dev)
3289 flags = (dev->flags & ~(IFF_PROMISC |
3294 (dev->gflags & (IFF_PROMISC |
3297 if (netif_running(dev)) {
3298 if (netif_oper_up(dev))
3299 flags |= IFF_RUNNING;
3300 if (netif_carrier_ok(dev))
3301 flags |= IFF_LOWER_UP;
3302 if (netif_dormant(dev))
3303 flags |= IFF_DORMANT;
3309 int dev_change_flags(struct net_device *dev, unsigned flags)
3312 int old_flags = dev->flags;
3317 * Set the flags on our device.
3320 dev->flags = (flags & (IFF_DEBUG | IFF_NOTRAILERS | IFF_NOARP |
3321 IFF_DYNAMIC | IFF_MULTICAST | IFF_PORTSEL |
3323 (dev->flags & (IFF_UP | IFF_VOLATILE | IFF_PROMISC |
3327 * Load in the correct multicast list now the flags have changed.
3330 if (dev->change_rx_flags && (old_flags ^ flags) & IFF_MULTICAST)
3331 dev->change_rx_flags(dev, IFF_MULTICAST);
3333 dev_set_rx_mode(dev);
3336 * Have we downed the interface. We handle IFF_UP ourselves
3337 * according to user attempts to set it, rather than blindly
3342 if ((old_flags ^ flags) & IFF_UP) { /* Bit is different ? */
3343 ret = ((old_flags & IFF_UP) ? dev_close : dev_open)(dev);
3346 dev_set_rx_mode(dev);
3349 if (dev->flags & IFF_UP &&
3350 ((old_flags ^ dev->flags) &~ (IFF_UP | IFF_PROMISC | IFF_ALLMULTI |
3352 call_netdevice_notifiers(NETDEV_CHANGE, dev);
3354 if ((flags ^ dev->gflags) & IFF_PROMISC) {
3355 int inc = (flags & IFF_PROMISC) ? +1 : -1;
3356 dev->gflags ^= IFF_PROMISC;
3357 dev_set_promiscuity(dev, inc);
3360 /* NOTE: order of synchronization of IFF_PROMISC and IFF_ALLMULTI
3361 is important. Some (broken) drivers set IFF_PROMISC, when
3362 IFF_ALLMULTI is requested not asking us and not reporting.
3364 if ((flags ^ dev->gflags) & IFF_ALLMULTI) {
3365 int inc = (flags & IFF_ALLMULTI) ? +1 : -1;
3366 dev->gflags ^= IFF_ALLMULTI;
3367 dev_set_allmulti(dev, inc);
3370 /* Exclude state transition flags, already notified */
3371 changes = (old_flags ^ dev->flags) & ~(IFF_UP | IFF_RUNNING);
3373 rtmsg_ifinfo(RTM_NEWLINK, dev, changes);
3378 int dev_set_mtu(struct net_device *dev, int new_mtu)
3382 if (new_mtu == dev->mtu)
3385 /* MTU must be positive. */
3389 if (!netif_device_present(dev))
3393 if (dev->change_mtu)
3394 err = dev->change_mtu(dev, new_mtu);
3397 if (!err && dev->flags & IFF_UP)
3398 call_netdevice_notifiers(NETDEV_CHANGEMTU, dev);
3402 int dev_set_mac_address(struct net_device *dev, struct sockaddr *sa)
3406 if (!dev->set_mac_address)
3408 if (sa->sa_family != dev->type)
3410 if (!netif_device_present(dev))
3412 err = dev->set_mac_address(dev, sa);
3414 call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
3419 * Perform the SIOCxIFxxx calls, inside read_lock(dev_base_lock)
3421 static int dev_ifsioc_locked(struct net *net, struct ifreq *ifr, unsigned int cmd)
3424 struct net_device *dev = __dev_get_by_name(net, ifr->ifr_name);
3430 case SIOCGIFFLAGS: /* Get interface flags */
3431 ifr->ifr_flags = dev_get_flags(dev);
3434 case SIOCGIFMETRIC: /* Get the metric on the interface
3435 (currently unused) */
3436 ifr->ifr_metric = 0;
3439 case SIOCGIFMTU: /* Get the MTU of a device */
3440 ifr->ifr_mtu = dev->mtu;
3445 memset(ifr->ifr_hwaddr.sa_data, 0, sizeof ifr->ifr_hwaddr.sa_data);
3447 memcpy(ifr->ifr_hwaddr.sa_data, dev->dev_addr,
3448 min(sizeof ifr->ifr_hwaddr.sa_data, (size_t) dev->addr_len));
3449 ifr->ifr_hwaddr.sa_family = dev->type;
3457 ifr->ifr_map.mem_start = dev->mem_start;
3458 ifr->ifr_map.mem_end = dev->mem_end;
3459 ifr->ifr_map.base_addr = dev->base_addr;
3460 ifr->ifr_map.irq = dev->irq;
3461 ifr->ifr_map.dma = dev->dma;
3462 ifr->ifr_map.port = dev->if_port;
3466 ifr->ifr_ifindex = dev->ifindex;
3470 ifr->ifr_qlen = dev->tx_queue_len;
3474 /* dev_ioctl() should ensure this case
3486 * Perform the SIOCxIFxxx calls, inside rtnl_lock()
3488 static int dev_ifsioc(struct net *net, struct ifreq *ifr, unsigned int cmd)
3491 struct net_device *dev = __dev_get_by_name(net, ifr->ifr_name);
3497 case SIOCSIFFLAGS: /* Set interface flags */
3498 return dev_change_flags(dev, ifr->ifr_flags);
3500 case SIOCSIFMETRIC: /* Set the metric on the interface
3501 (currently unused) */
3504 case SIOCSIFMTU: /* Set the MTU of a device */
3505 return dev_set_mtu(dev, ifr->ifr_mtu);
3508 return dev_set_mac_address(dev, &ifr->ifr_hwaddr);
3510 case SIOCSIFHWBROADCAST:
3511 if (ifr->ifr_hwaddr.sa_family != dev->type)
3513 memcpy(dev->broadcast, ifr->ifr_hwaddr.sa_data,
3514 min(sizeof ifr->ifr_hwaddr.sa_data, (size_t) dev->addr_len));
3515 call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
3519 if (dev->set_config) {
3520 if (!netif_device_present(dev))
3522 return dev->set_config(dev, &ifr->ifr_map);
3527 if ((!dev->set_multicast_list && !dev->set_rx_mode) ||
3528 ifr->ifr_hwaddr.sa_family != AF_UNSPEC)
3530 if (!netif_device_present(dev))
3532 return dev_mc_add(dev, ifr->ifr_hwaddr.sa_data,
3536 if ((!dev->set_multicast_list && !dev->set_rx_mode) ||
3537 ifr->ifr_hwaddr.sa_family != AF_UNSPEC)
3539 if (!netif_device_present(dev))
3541 return dev_mc_delete(dev, ifr->ifr_hwaddr.sa_data,
3545 if (ifr->ifr_qlen < 0)
3547 dev->tx_queue_len = ifr->ifr_qlen;
3551 ifr->ifr_newname[IFNAMSIZ-1] = '\0';
3552 return dev_change_name(dev, ifr->ifr_newname);
3555 * Unknown or private ioctl
3559 if ((cmd >= SIOCDEVPRIVATE &&
3560 cmd <= SIOCDEVPRIVATE + 15) ||
3561 cmd == SIOCBONDENSLAVE ||
3562 cmd == SIOCBONDRELEASE ||
3563 cmd == SIOCBONDSETHWADDR ||
3564 cmd == SIOCBONDSLAVEINFOQUERY ||
3565 cmd == SIOCBONDINFOQUERY ||
3566 cmd == SIOCBONDCHANGEACTIVE ||
3567 cmd == SIOCGMIIPHY ||
3568 cmd == SIOCGMIIREG ||
3569 cmd == SIOCSMIIREG ||
3570 cmd == SIOCBRADDIF ||
3571 cmd == SIOCBRDELIF ||
3572 cmd == SIOCWANDEV) {
3574 if (dev->do_ioctl) {
3575 if (netif_device_present(dev))
3576 err = dev->do_ioctl(dev, ifr,
3589 * This function handles all "interface"-type I/O control requests. The actual
3590 * 'doing' part of this is dev_ifsioc above.
3594 * dev_ioctl - network device ioctl
3595 * @net: the applicable net namespace
3596 * @cmd: command to issue
3597 * @arg: pointer to a struct ifreq in user space
3599 * Issue ioctl functions to devices. This is normally called by the
3600 * user space syscall interfaces but can sometimes be useful for
3601 * other purposes. The return value is the return from the syscall if
3602 * positive or a negative errno code on error.
3605 int dev_ioctl(struct net *net, unsigned int cmd, void __user *arg)
3611 /* One special case: SIOCGIFCONF takes ifconf argument
3612 and requires shared lock, because it sleeps writing
3616 if (cmd == SIOCGIFCONF) {
3618 ret = dev_ifconf(net, (char __user *) arg);
3622 if (cmd == SIOCGIFNAME)
3623 return dev_ifname(net, (struct ifreq __user *)arg);
3625 if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
3628 ifr.ifr_name[IFNAMSIZ-1] = 0;
3630 colon = strchr(ifr.ifr_name, ':');
3635 * See which interface the caller is talking about.
3640 * These ioctl calls:
3641 * - can be done by all.
3642 * - atomic and do not require locking.
3653 dev_load(net, ifr.ifr_name);
3654 read_lock(&dev_base_lock);
3655 ret = dev_ifsioc_locked(net, &ifr, cmd);
3656 read_unlock(&dev_base_lock);
3660 if (copy_to_user(arg, &ifr,
3661 sizeof(struct ifreq)))
3667 dev_load(net, ifr.ifr_name);
3669 ret = dev_ethtool(net, &ifr);
3674 if (copy_to_user(arg, &ifr,
3675 sizeof(struct ifreq)))
3681 * These ioctl calls:
3682 * - require superuser power.
3683 * - require strict serialization.
3689 if (!capable(CAP_NET_ADMIN))
3691 dev_load(net, ifr.ifr_name);
3693 ret = dev_ifsioc(net, &ifr, cmd);
3698 if (copy_to_user(arg, &ifr,
3699 sizeof(struct ifreq)))
3705 * These ioctl calls:
3706 * - require superuser power.
3707 * - require strict serialization.
3708 * - do not return a value
3718 case SIOCSIFHWBROADCAST:
3721 case SIOCBONDENSLAVE:
3722 case SIOCBONDRELEASE:
3723 case SIOCBONDSETHWADDR:
3724 case SIOCBONDCHANGEACTIVE:
3727 if (!capable(CAP_NET_ADMIN))
3730 case SIOCBONDSLAVEINFOQUERY:
3731 case SIOCBONDINFOQUERY:
3732 dev_load(net, ifr.ifr_name);
3734 ret = dev_ifsioc(net, &ifr, cmd);
3739 /* Get the per device memory space. We can add this but
3740 * currently do not support it */
3742 /* Set the per device memory buffer space.
3743 * Not applicable in our case */
3748 * Unknown or private ioctl.
3751 if (cmd == SIOCWANDEV ||
3752 (cmd >= SIOCDEVPRIVATE &&
3753 cmd <= SIOCDEVPRIVATE + 15)) {
3754 dev_load(net, ifr.ifr_name);
3756 ret = dev_ifsioc(net, &ifr, cmd);
3758 if (!ret && copy_to_user(arg, &ifr,
3759 sizeof(struct ifreq)))
3763 /* Take care of Wireless Extensions */
3764 if (cmd >= SIOCIWFIRST && cmd <= SIOCIWLAST)
3765 return wext_handle_ioctl(net, &ifr, cmd, arg);
3772 * dev_new_index - allocate an ifindex
3773 * @net: the applicable net namespace
3775 * Returns a suitable unique value for a new device interface
3776 * number. The caller must hold the rtnl semaphore or the
3777 * dev_base_lock to be sure it remains unique.
3779 static int dev_new_index(struct net *net)
3785 if (!__dev_get_by_index(net, ifindex))
3790 /* Delayed registration/unregisteration */
3791 static DEFINE_SPINLOCK(net_todo_list_lock);
3792 static LIST_HEAD(net_todo_list);
3794 static void net_set_todo(struct net_device *dev)
3796 spin_lock(&net_todo_list_lock);
3797 list_add_tail(&dev->todo_list, &net_todo_list);
3798 spin_unlock(&net_todo_list_lock);
3801 static void rollback_registered(struct net_device *dev)
3803 BUG_ON(dev_boot_phase);
3806 /* Some devices call without registering for initialization unwind. */
3807 if (dev->reg_state == NETREG_UNINITIALIZED) {
3808 printk(KERN_DEBUG "unregister_netdevice: device %s/%p never "
3809 "was registered\n", dev->name, dev);
3815 BUG_ON(dev->reg_state != NETREG_REGISTERED);
3817 /* If device is running, close it first. */
3820 /* And unlink it from device chain. */
3821 unlist_netdevice(dev);
3823 dev->reg_state = NETREG_UNREGISTERING;
3827 /* Shutdown queueing discipline. */
3831 /* Notify protocols, that we are about to destroy
3832 this device. They should clean all the things.
3834 call_netdevice_notifiers(NETDEV_UNREGISTER, dev);
3837 * Flush the unicast and multicast chains
3839 dev_addr_discard(dev);
3844 /* Notifier chain MUST detach us from master device. */
3845 WARN_ON(dev->master);
3847 /* Remove entries from kobject tree */
3848 netdev_unregister_kobject(dev);
3855 static void __netdev_init_queue_locks_one(struct net_device *dev,
3856 struct netdev_queue *dev_queue,
3859 spin_lock_init(&dev_queue->_xmit_lock);
3860 netdev_set_xmit_lockdep_class(&dev_queue->_xmit_lock, dev->type);
3861 dev_queue->xmit_lock_owner = -1;
3864 static void netdev_init_queue_locks(struct net_device *dev)
3866 netdev_for_each_tx_queue(dev, __netdev_init_queue_locks_one, NULL);
3867 __netdev_init_queue_locks_one(dev, &dev->rx_queue, NULL);
3871 * register_netdevice - register a network device
3872 * @dev: device to register
3874 * Take a completed network device structure and add it to the kernel
3875 * interfaces. A %NETDEV_REGISTER message is sent to the netdev notifier
3876 * chain. 0 is returned on success. A negative errno code is returned
3877 * on a failure to set up the device, or if the name is a duplicate.
3879 * Callers must hold the rtnl semaphore. You may want
3880 * register_netdev() instead of this.
3883 * The locking appears insufficient to guarantee two parallel registers
3884 * will not get the same name.
3887 int register_netdevice(struct net_device *dev)
3889 struct hlist_head *head;
3890 struct hlist_node *p;
3894 BUG_ON(dev_boot_phase);
3899 /* When net_device's are persistent, this will be fatal. */
3900 BUG_ON(dev->reg_state != NETREG_UNINITIALIZED);
3901 BUG_ON(!dev_net(dev));
3904 spin_lock_init(&dev->addr_list_lock);
3905 netdev_set_addr_lockdep_class(dev);
3906 netdev_init_queue_locks(dev);
3910 /* Init, if this function is available */
3912 ret = dev->init(dev);
3920 if (!dev_valid_name(dev->name)) {
3925 dev->ifindex = dev_new_index(net);
3926 if (dev->iflink == -1)
3927 dev->iflink = dev->ifindex;
3929 /* Check for existence of name */
3930 head = dev_name_hash(net, dev->name);
3931 hlist_for_each(p, head) {
3932 struct net_device *d
3933 = hlist_entry(p, struct net_device, name_hlist);
3934 if (!strncmp(d->name, dev->name, IFNAMSIZ)) {
3940 /* Fix illegal checksum combinations */
3941 if ((dev->features & NETIF_F_HW_CSUM) &&
3942 (dev->features & (NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM))) {
3943 printk(KERN_NOTICE "%s: mixed HW and IP checksum settings.\n",
3945 dev->features &= ~(NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM);
3948 if ((dev->features & NETIF_F_NO_CSUM) &&
3949 (dev->features & (NETIF_F_HW_CSUM|NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM))) {
3950 printk(KERN_NOTICE "%s: mixed no checksumming and other settings.\n",
3952 dev->features &= ~(NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM|NETIF_F_HW_CSUM);
3956 /* Fix illegal SG+CSUM combinations. */
3957 if ((dev->features & NETIF_F_SG) &&
3958 !(dev->features & NETIF_F_ALL_CSUM)) {
3959 printk(KERN_NOTICE "%s: Dropping NETIF_F_SG since no checksum feature.\n",
3961 dev->features &= ~NETIF_F_SG;
3964 /* TSO requires that SG is present as well. */
3965 if ((dev->features & NETIF_F_TSO) &&
3966 !(dev->features & NETIF_F_SG)) {
3967 printk(KERN_NOTICE "%s: Dropping NETIF_F_TSO since no SG feature.\n",
3969 dev->features &= ~NETIF_F_TSO;
3971 if (dev->features & NETIF_F_UFO) {
3972 if (!(dev->features & NETIF_F_HW_CSUM)) {
3973 printk(KERN_ERR "%s: Dropping NETIF_F_UFO since no "
3974 "NETIF_F_HW_CSUM feature.\n",
3976 dev->features &= ~NETIF_F_UFO;
3978 if (!(dev->features & NETIF_F_SG)) {
3979 printk(KERN_ERR "%s: Dropping NETIF_F_UFO since no "
3980 "NETIF_F_SG feature.\n",
3982 dev->features &= ~NETIF_F_UFO;
3986 /* Enable software GSO if SG is supported. */
3987 if (dev->features & NETIF_F_SG)
3988 dev->features |= NETIF_F_GSO;
3990 netdev_initialize_kobject(dev);
3991 ret = netdev_register_kobject(dev);
3994 dev->reg_state = NETREG_REGISTERED;
3997 * Default initial state at registry is that the
3998 * device is present.
4001 set_bit(__LINK_STATE_PRESENT, &dev->state);
4003 dev_init_scheduler(dev);
4005 list_netdevice(dev);
4007 /* Notify protocols, that a new device appeared. */
4008 ret = call_netdevice_notifiers(NETDEV_REGISTER, dev);
4009 ret = notifier_to_errno(ret);
4011 rollback_registered(dev);
4012 dev->reg_state = NETREG_UNREGISTERED;
4025 * register_netdev - register a network device
4026 * @dev: device to register
4028 * Take a completed network device structure and add it to the kernel
4029 * interfaces. A %NETDEV_REGISTER message is sent to the netdev notifier
4030 * chain. 0 is returned on success. A negative errno code is returned
4031 * on a failure to set up the device, or if the name is a duplicate.
4033 * This is a wrapper around register_netdevice that takes the rtnl semaphore
4034 * and expands the device name if you passed a format string to
4037 int register_netdev(struct net_device *dev)
4044 * If the name is a format string the caller wants us to do a
4047 if (strchr(dev->name, '%')) {
4048 err = dev_alloc_name(dev, dev->name);
4053 err = register_netdevice(dev);
4058 EXPORT_SYMBOL(register_netdev);
4061 * netdev_wait_allrefs - wait until all references are gone.
4063 * This is called when unregistering network devices.
4065 * Any protocol or device that holds a reference should register
4066 * for netdevice notification, and cleanup and put back the
4067 * reference if they receive an UNREGISTER event.
4068 * We can get stuck here if buggy protocols don't correctly
4071 static void netdev_wait_allrefs(struct net_device *dev)
4073 unsigned long rebroadcast_time, warning_time;
4075 rebroadcast_time = warning_time = jiffies;
4076 while (atomic_read(&dev->refcnt) != 0) {
4077 if (time_after(jiffies, rebroadcast_time + 1 * HZ)) {
4080 /* Rebroadcast unregister notification */
4081 call_netdevice_notifiers(NETDEV_UNREGISTER, dev);
4083 if (test_bit(__LINK_STATE_LINKWATCH_PENDING,
4085 /* We must not have linkwatch events
4086 * pending on unregister. If this
4087 * happens, we simply run the queue
4088 * unscheduled, resulting in a noop
4091 linkwatch_run_queue();
4096 rebroadcast_time = jiffies;
4101 if (time_after(jiffies, warning_time + 10 * HZ)) {
4102 printk(KERN_EMERG "unregister_netdevice: "
4103 "waiting for %s to become free. Usage "
4105 dev->name, atomic_read(&dev->refcnt));
4106 warning_time = jiffies;
4115 * register_netdevice(x1);
4116 * register_netdevice(x2);
4118 * unregister_netdevice(y1);
4119 * unregister_netdevice(y2);
4125 * We are invoked by rtnl_unlock() after it drops the semaphore.
4126 * This allows us to deal with problems:
4127 * 1) We can delete sysfs objects which invoke hotplug
4128 * without deadlocking with linkwatch via keventd.
4129 * 2) Since we run with the RTNL semaphore not held, we can sleep
4130 * safely in order to wait for the netdev refcnt to drop to zero.
4132 static DEFINE_MUTEX(net_todo_run_mutex);
4133 void netdev_run_todo(void)
4135 struct list_head list;
4137 /* Need to guard against multiple cpu's getting out of order. */
4138 mutex_lock(&net_todo_run_mutex);
4140 /* Not safe to do outside the semaphore. We must not return
4141 * until all unregister events invoked by the local processor
4142 * have been completed (either by this todo run, or one on
4145 if (list_empty(&net_todo_list))
4148 /* Snapshot list, allow later requests */
4149 spin_lock(&net_todo_list_lock);
4150 list_replace_init(&net_todo_list, &list);
4151 spin_unlock(&net_todo_list_lock);
4153 while (!list_empty(&list)) {
4154 struct net_device *dev
4155 = list_entry(list.next, struct net_device, todo_list);
4156 list_del(&dev->todo_list);
4158 if (unlikely(dev->reg_state != NETREG_UNREGISTERING)) {
4159 printk(KERN_ERR "network todo '%s' but state %d\n",
4160 dev->name, dev->reg_state);
4165 dev->reg_state = NETREG_UNREGISTERED;
4167 on_each_cpu(flush_backlog, dev, 1);
4169 netdev_wait_allrefs(dev);
4172 BUG_ON(atomic_read(&dev->refcnt));
4173 WARN_ON(dev->ip_ptr);
4174 WARN_ON(dev->ip6_ptr);
4175 WARN_ON(dev->dn_ptr);
4177 if (dev->destructor)
4178 dev->destructor(dev);
4180 /* Free network device */
4181 kobject_put(&dev->dev.kobj);
4185 mutex_unlock(&net_todo_run_mutex);
4188 static struct net_device_stats *internal_stats(struct net_device *dev)
4193 static void netdev_init_one_queue(struct net_device *dev,
4194 struct netdev_queue *queue,
4200 static void netdev_init_queues(struct net_device *dev)
4202 netdev_init_one_queue(dev, &dev->rx_queue, NULL);
4203 netdev_for_each_tx_queue(dev, netdev_init_one_queue, NULL);
4204 spin_lock_init(&dev->tx_global_lock);
4208 * alloc_netdev_mq - allocate network device
4209 * @sizeof_priv: size of private data to allocate space for
4210 * @name: device name format string
4211 * @setup: callback to initialize device
4212 * @queue_count: the number of subqueues to allocate
4214 * Allocates a struct net_device with private data area for driver use
4215 * and performs basic initialization. Also allocates subquue structs
4216 * for each queue on the device at the end of the netdevice.
4218 struct net_device *alloc_netdev_mq(int sizeof_priv, const char *name,
4219 void (*setup)(struct net_device *), unsigned int queue_count)
4221 struct netdev_queue *tx;
4222 struct net_device *dev;
4226 BUG_ON(strlen(name) >= sizeof(dev->name));
4228 alloc_size = sizeof(struct net_device);
4230 /* ensure 32-byte alignment of private area */
4231 alloc_size = (alloc_size + NETDEV_ALIGN_CONST) & ~NETDEV_ALIGN_CONST;
4232 alloc_size += sizeof_priv;
4234 /* ensure 32-byte alignment of whole construct */
4235 alloc_size += NETDEV_ALIGN_CONST;
4237 p = kzalloc(alloc_size, GFP_KERNEL);
4239 printk(KERN_ERR "alloc_netdev: Unable to allocate device.\n");
4243 tx = kcalloc(queue_count, sizeof(struct netdev_queue), GFP_KERNEL);
4245 printk(KERN_ERR "alloc_netdev: Unable to allocate "
4251 dev = (struct net_device *)
4252 (((long)p + NETDEV_ALIGN_CONST) & ~NETDEV_ALIGN_CONST);
4253 dev->padded = (char *)dev - (char *)p;
4254 dev_net_set(dev, &init_net);
4257 dev->num_tx_queues = queue_count;
4258 dev->real_num_tx_queues = queue_count;
4261 dev->priv = ((char *)dev +
4262 ((sizeof(struct net_device) + NETDEV_ALIGN_CONST)
4263 & ~NETDEV_ALIGN_CONST));
4266 dev->gso_max_size = GSO_MAX_SIZE;
4268 netdev_init_queues(dev);
4270 dev->get_stats = internal_stats;
4271 netpoll_netdev_init(dev);
4273 strcpy(dev->name, name);
4276 EXPORT_SYMBOL(alloc_netdev_mq);
4279 * free_netdev - free network device
4282 * This function does the last stage of destroying an allocated device
4283 * interface. The reference to the device object is released.
4284 * If this is the last reference then it will be freed.
4286 void free_netdev(struct net_device *dev)
4288 release_net(dev_net(dev));
4292 /* Compatibility with error handling in drivers */
4293 if (dev->reg_state == NETREG_UNINITIALIZED) {
4294 kfree((char *)dev - dev->padded);
4298 BUG_ON(dev->reg_state != NETREG_UNREGISTERED);
4299 dev->reg_state = NETREG_RELEASED;
4301 /* will free via device release */
4302 put_device(&dev->dev);
4305 /* Synchronize with packet receive processing. */
4306 void synchronize_net(void)
4313 * unregister_netdevice - remove device from the kernel
4316 * This function shuts down a device interface and removes it
4317 * from the kernel tables.
4319 * Callers must hold the rtnl semaphore. You may want
4320 * unregister_netdev() instead of this.
4323 void unregister_netdevice(struct net_device *dev)
4327 rollback_registered(dev);
4328 /* Finish processing unregister after unlock */
4333 * unregister_netdev - remove device from the kernel
4336 * This function shuts down a device interface and removes it
4337 * from the kernel tables.
4339 * This is just a wrapper for unregister_netdevice that takes
4340 * the rtnl semaphore. In general you want to use this and not
4341 * unregister_netdevice.
4343 void unregister_netdev(struct net_device *dev)
4346 unregister_netdevice(dev);
4350 EXPORT_SYMBOL(unregister_netdev);
4353 * dev_change_net_namespace - move device to different nethost namespace
4355 * @net: network namespace
4356 * @pat: If not NULL name pattern to try if the current device name
4357 * is already taken in the destination network namespace.
4359 * This function shuts down a device interface and moves it
4360 * to a new network namespace. On success 0 is returned, on
4361 * a failure a netagive errno code is returned.
4363 * Callers must hold the rtnl semaphore.
4366 int dev_change_net_namespace(struct net_device *dev, struct net *net, const char *pat)
4369 const char *destname;
4374 /* Don't allow namespace local devices to be moved. */
4376 if (dev->features & NETIF_F_NETNS_LOCAL)
4379 /* Ensure the device has been registrered */
4381 if (dev->reg_state != NETREG_REGISTERED)
4384 /* Get out if there is nothing todo */
4386 if (net_eq(dev_net(dev), net))
4389 /* Pick the destination device name, and ensure
4390 * we can use it in the destination network namespace.
4393 destname = dev->name;
4394 if (__dev_get_by_name(net, destname)) {
4395 /* We get here if we can't use the current device name */
4398 if (!dev_valid_name(pat))
4400 if (strchr(pat, '%')) {
4401 if (__dev_alloc_name(net, pat, buf) < 0)
4406 if (__dev_get_by_name(net, destname))
4411 * And now a mini version of register_netdevice unregister_netdevice.
4414 /* If device is running close it first. */
4417 /* And unlink it from device chain */
4419 unlist_netdevice(dev);
4423 /* Shutdown queueing discipline. */
4426 /* Notify protocols, that we are about to destroy
4427 this device. They should clean all the things.
4429 call_netdevice_notifiers(NETDEV_UNREGISTER, dev);
4432 * Flush the unicast and multicast chains
4434 dev_addr_discard(dev);
4436 /* Actually switch the network namespace */
4437 dev_net_set(dev, net);
4439 /* Assign the new device name */
4440 if (destname != dev->name)
4441 strcpy(dev->name, destname);
4443 /* If there is an ifindex conflict assign a new one */
4444 if (__dev_get_by_index(net, dev->ifindex)) {
4445 int iflink = (dev->iflink == dev->ifindex);
4446 dev->ifindex = dev_new_index(net);
4448 dev->iflink = dev->ifindex;
4451 /* Fixup kobjects */
4452 netdev_unregister_kobject(dev);
4453 err = netdev_register_kobject(dev);
4456 /* Add the device back in the hashes */
4457 list_netdevice(dev);
4459 /* Notify protocols, that a new device appeared. */
4460 call_netdevice_notifiers(NETDEV_REGISTER, dev);
4468 static int dev_cpu_callback(struct notifier_block *nfb,
4469 unsigned long action,
4472 struct sk_buff **list_skb;
4473 struct Qdisc **list_net;
4474 struct sk_buff *skb;
4475 unsigned int cpu, oldcpu = (unsigned long)ocpu;
4476 struct softnet_data *sd, *oldsd;
4478 if (action != CPU_DEAD && action != CPU_DEAD_FROZEN)
4481 local_irq_disable();
4482 cpu = smp_processor_id();
4483 sd = &per_cpu(softnet_data, cpu);
4484 oldsd = &per_cpu(softnet_data, oldcpu);
4486 /* Find end of our completion_queue. */
4487 list_skb = &sd->completion_queue;
4489 list_skb = &(*list_skb)->next;
4490 /* Append completion queue from offline CPU. */
4491 *list_skb = oldsd->completion_queue;
4492 oldsd->completion_queue = NULL;
4494 /* Find end of our output_queue. */
4495 list_net = &sd->output_queue;
4497 list_net = &(*list_net)->next_sched;
4498 /* Append output queue from offline CPU. */
4499 *list_net = oldsd->output_queue;
4500 oldsd->output_queue = NULL;
4502 raise_softirq_irqoff(NET_TX_SOFTIRQ);
4505 /* Process offline CPU's input_pkt_queue */
4506 while ((skb = __skb_dequeue(&oldsd->input_pkt_queue)))
4512 #ifdef CONFIG_NET_DMA
4514 * net_dma_rebalance - try to maintain one DMA channel per CPU
4515 * @net_dma: DMA client and associated data (lock, channels, channel_mask)
4517 * This is called when the number of channels allocated to the net_dma client
4518 * changes. The net_dma client tries to have one DMA channel per CPU.
4521 static void net_dma_rebalance(struct net_dma *net_dma)
4523 unsigned int cpu, i, n, chan_idx;
4524 struct dma_chan *chan;
4526 if (cpus_empty(net_dma->channel_mask)) {
4527 for_each_online_cpu(cpu)
4528 rcu_assign_pointer(per_cpu(softnet_data, cpu).net_dma, NULL);
4533 cpu = first_cpu(cpu_online_map);
4535 for_each_cpu_mask_nr(chan_idx, net_dma->channel_mask) {
4536 chan = net_dma->channels[chan_idx];
4538 n = ((num_online_cpus() / cpus_weight(net_dma->channel_mask))
4539 + (i < (num_online_cpus() %
4540 cpus_weight(net_dma->channel_mask)) ? 1 : 0));
4543 per_cpu(softnet_data, cpu).net_dma = chan;
4544 cpu = next_cpu(cpu, cpu_online_map);
4552 * netdev_dma_event - event callback for the net_dma_client
4553 * @client: should always be net_dma_client
4554 * @chan: DMA channel for the event
4555 * @state: DMA state to be handled
4557 static enum dma_state_client
4558 netdev_dma_event(struct dma_client *client, struct dma_chan *chan,
4559 enum dma_state state)
4561 int i, found = 0, pos = -1;
4562 struct net_dma *net_dma =
4563 container_of(client, struct net_dma, client);
4564 enum dma_state_client ack = DMA_DUP; /* default: take no action */
4566 spin_lock(&net_dma->lock);
4568 case DMA_RESOURCE_AVAILABLE:
4569 for (i = 0; i < nr_cpu_ids; i++)
4570 if (net_dma->channels[i] == chan) {
4573 } else if (net_dma->channels[i] == NULL && pos < 0)
4576 if (!found && pos >= 0) {
4578 net_dma->channels[pos] = chan;
4579 cpu_set(pos, net_dma->channel_mask);
4580 net_dma_rebalance(net_dma);
4583 case DMA_RESOURCE_REMOVED:
4584 for (i = 0; i < nr_cpu_ids; i++)
4585 if (net_dma->channels[i] == chan) {
4593 cpu_clear(pos, net_dma->channel_mask);
4594 net_dma->channels[i] = NULL;
4595 net_dma_rebalance(net_dma);
4601 spin_unlock(&net_dma->lock);
4607 * netdev_dma_regiser - register the networking subsystem as a DMA client
4609 static int __init netdev_dma_register(void)
4611 net_dma.channels = kzalloc(nr_cpu_ids * sizeof(struct net_dma),
4613 if (unlikely(!net_dma.channels)) {
4615 "netdev_dma: no memory for net_dma.channels\n");
4618 spin_lock_init(&net_dma.lock);
4619 dma_cap_set(DMA_MEMCPY, net_dma.client.cap_mask);
4620 dma_async_client_register(&net_dma.client);
4621 dma_async_client_chan_request(&net_dma.client);
4626 static int __init netdev_dma_register(void) { return -ENODEV; }
4627 #endif /* CONFIG_NET_DMA */
4630 * netdev_compute_feature - compute conjunction of two feature sets
4631 * @all: first feature set
4632 * @one: second feature set
4634 * Computes a new feature set after adding a device with feature set
4635 * @one to the master device with current feature set @all. Returns
4636 * the new feature set.
4638 int netdev_compute_features(unsigned long all, unsigned long one)
4640 /* if device needs checksumming, downgrade to hw checksumming */
4641 if (all & NETIF_F_NO_CSUM && !(one & NETIF_F_NO_CSUM))
4642 all ^= NETIF_F_NO_CSUM | NETIF_F_HW_CSUM;
4644 /* if device can't do all checksum, downgrade to ipv4/ipv6 */
4645 if (all & NETIF_F_HW_CSUM && !(one & NETIF_F_HW_CSUM))
4646 all ^= NETIF_F_HW_CSUM
4647 | NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM;
4649 if (one & NETIF_F_GSO)
4650 one |= NETIF_F_GSO_SOFTWARE;
4653 /* If even one device supports robust GSO, enable it for all. */
4654 if (one & NETIF_F_GSO_ROBUST)
4655 all |= NETIF_F_GSO_ROBUST;
4657 all &= one | NETIF_F_LLTX;
4659 if (!(all & NETIF_F_ALL_CSUM))
4661 if (!(all & NETIF_F_SG))
4662 all &= ~NETIF_F_GSO_MASK;
4666 EXPORT_SYMBOL(netdev_compute_features);
4668 static struct hlist_head *netdev_create_hash(void)
4671 struct hlist_head *hash;
4673 hash = kmalloc(sizeof(*hash) * NETDEV_HASHENTRIES, GFP_KERNEL);
4675 for (i = 0; i < NETDEV_HASHENTRIES; i++)
4676 INIT_HLIST_HEAD(&hash[i]);
4681 /* Initialize per network namespace state */
4682 static int __net_init netdev_init(struct net *net)
4684 INIT_LIST_HEAD(&net->dev_base_head);
4686 net->dev_name_head = netdev_create_hash();
4687 if (net->dev_name_head == NULL)
4690 net->dev_index_head = netdev_create_hash();
4691 if (net->dev_index_head == NULL)
4697 kfree(net->dev_name_head);
4702 char *netdev_drivername(struct net_device *dev, char *buffer, int len)
4704 struct device_driver *driver;
4705 struct device *parent;
4707 if (len <= 0 || !buffer)
4711 parent = dev->dev.parent;
4716 driver = parent->driver;
4717 if (driver && driver->name)
4718 strlcpy(buffer, driver->name, len);
4722 static void __net_exit netdev_exit(struct net *net)
4724 kfree(net->dev_name_head);
4725 kfree(net->dev_index_head);
4728 static struct pernet_operations __net_initdata netdev_net_ops = {
4729 .init = netdev_init,
4730 .exit = netdev_exit,
4733 static void __net_exit default_device_exit(struct net *net)
4735 struct net_device *dev, *next;
4737 * Push all migratable of the network devices back to the
4738 * initial network namespace
4741 for_each_netdev_safe(net, dev, next) {
4743 char fb_name[IFNAMSIZ];
4745 /* Ignore unmoveable devices (i.e. loopback) */
4746 if (dev->features & NETIF_F_NETNS_LOCAL)
4749 /* Push remaing network devices to init_net */
4750 snprintf(fb_name, IFNAMSIZ, "dev%d", dev->ifindex);
4751 err = dev_change_net_namespace(dev, &init_net, fb_name);
4753 printk(KERN_EMERG "%s: failed to move %s to init_net: %d\n",
4754 __func__, dev->name, err);
4761 static struct pernet_operations __net_initdata default_device_ops = {
4762 .exit = default_device_exit,
4766 * Initialize the DEV module. At boot time this walks the device list and
4767 * unhooks any devices that fail to initialise (normally hardware not
4768 * present) and leaves us with a valid list of present and active devices.
4773 * This is called single threaded during boot, so no need
4774 * to take the rtnl semaphore.
4776 static int __init net_dev_init(void)
4778 int i, rc = -ENOMEM;
4780 BUG_ON(!dev_boot_phase);
4782 if (dev_proc_init())
4785 if (netdev_kobject_init())
4788 INIT_LIST_HEAD(&ptype_all);
4789 for (i = 0; i < PTYPE_HASH_SIZE; i++)
4790 INIT_LIST_HEAD(&ptype_base[i]);
4792 if (register_pernet_subsys(&netdev_net_ops))
4795 if (register_pernet_device(&default_device_ops))
4799 * Initialise the packet receive queues.
4802 for_each_possible_cpu(i) {
4803 struct softnet_data *queue;
4805 queue = &per_cpu(softnet_data, i);
4806 skb_queue_head_init(&queue->input_pkt_queue);
4807 queue->completion_queue = NULL;
4808 INIT_LIST_HEAD(&queue->poll_list);
4810 queue->backlog.poll = process_backlog;
4811 queue->backlog.weight = weight_p;
4814 netdev_dma_register();
4818 open_softirq(NET_TX_SOFTIRQ, net_tx_action);
4819 open_softirq(NET_RX_SOFTIRQ, net_rx_action);
4821 hotcpu_notifier(dev_cpu_callback, 0);
4829 subsys_initcall(net_dev_init);
4831 EXPORT_SYMBOL(__dev_get_by_index);
4832 EXPORT_SYMBOL(__dev_get_by_name);
4833 EXPORT_SYMBOL(__dev_remove_pack);
4834 EXPORT_SYMBOL(dev_valid_name);
4835 EXPORT_SYMBOL(dev_add_pack);
4836 EXPORT_SYMBOL(dev_alloc_name);
4837 EXPORT_SYMBOL(dev_close);
4838 EXPORT_SYMBOL(dev_get_by_flags);
4839 EXPORT_SYMBOL(dev_get_by_index);
4840 EXPORT_SYMBOL(dev_get_by_name);
4841 EXPORT_SYMBOL(dev_open);
4842 EXPORT_SYMBOL(dev_queue_xmit);
4843 EXPORT_SYMBOL(dev_remove_pack);
4844 EXPORT_SYMBOL(dev_set_allmulti);
4845 EXPORT_SYMBOL(dev_set_promiscuity);
4846 EXPORT_SYMBOL(dev_change_flags);
4847 EXPORT_SYMBOL(dev_set_mtu);
4848 EXPORT_SYMBOL(dev_set_mac_address);
4849 EXPORT_SYMBOL(free_netdev);
4850 EXPORT_SYMBOL(netdev_boot_setup_check);
4851 EXPORT_SYMBOL(netdev_set_master);
4852 EXPORT_SYMBOL(netdev_state_change);
4853 EXPORT_SYMBOL(netif_receive_skb);
4854 EXPORT_SYMBOL(netif_rx);
4855 EXPORT_SYMBOL(register_gifconf);
4856 EXPORT_SYMBOL(register_netdevice);
4857 EXPORT_SYMBOL(register_netdevice_notifier);
4858 EXPORT_SYMBOL(skb_checksum_help);
4859 EXPORT_SYMBOL(synchronize_net);
4860 EXPORT_SYMBOL(unregister_netdevice);
4861 EXPORT_SYMBOL(unregister_netdevice_notifier);
4862 EXPORT_SYMBOL(net_enable_timestamp);
4863 EXPORT_SYMBOL(net_disable_timestamp);
4864 EXPORT_SYMBOL(dev_get_flags);
4866 #if defined(CONFIG_BRIDGE) || defined(CONFIG_BRIDGE_MODULE)
4867 EXPORT_SYMBOL(br_handle_frame_hook);
4868 EXPORT_SYMBOL(br_fdb_get_hook);
4869 EXPORT_SYMBOL(br_fdb_put_hook);
4873 EXPORT_SYMBOL(dev_load);
4876 EXPORT_PER_CPU_SYMBOL(softnet_data);