lockd: dont return EAGAIN for a permanent error
[linux-2.6/linux-loongson.git] / net / core / dev.c
blob53af7841018a73573bfb89819b392bcd92434b42
1 /*
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
10 * Authors: Ross Biro
11 * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
12 * Mark Evans, <evansmp@uhura.aston.ac.uk>
14 * Additional Authors:
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>
22 * Changes:
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
34 * drivers
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
44 * call a packet.
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
50 * changes.
51 * Rudi Cilibrasi : Pass the right thing to
52 * set_mac_address()
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
58 * 1 device.
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
66 * the backlog queue.
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>
85 #include <linux/mm.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>
97 #include <net/sock.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>
104 #include <net/dst.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.
144 * --BLG
146 * 0800 IP
147 * 8100 802.1Q VLAN
148 * 0001 802.3
149 * 0002 AX.25
150 * 0004 802.2
151 * 8035 RARP
152 * 0005 SNAP
153 * 0805 X.25
154 * 0806 ARP
155 * 8137 IPX
156 * 0009 Localtalk
157 * 86DD IPv6
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
168 struct net_dma {
169 struct dma_client client;
170 spinlock_t lock;
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 = {
180 .client = {
181 .event_callback = netdev_dma_event,
184 #endif
187 * The @dev_base_head list is protected by @dev_base_lock and the rtnl
188 * semaphore.
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
203 * semaphore held.
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);
228 ASSERT_RTNL();
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);
235 return 0;
238 /* Device list removal */
239 static void unlist_netdevice(struct net_device *dev)
241 ASSERT_RTNL();
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);
252 * Our notifier list
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,
284 ARPHRD_NONE};
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",
301 "_xmit_NONE"};
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)
308 int i;
310 for (i = 0; i < ARRAY_SIZE(netdev_lock_type); i++)
311 if (netdev_lock_type[i] == dev_type)
312 return i;
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)
320 int i;
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)
329 int i;
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]);
336 #else
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)
344 #endif
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
355 * here.
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.
365 * --ANK (980803)
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)
383 int hash;
385 spin_lock_bh(&ptype_lock);
386 if (pt->type == htons(ETH_P_ALL))
387 list_add_rcu(&pt->list, &ptype_all);
388 else {
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
402 * returns.
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))
416 head = &ptype_all;
417 else
418 head = &ptype_base[ntohs(pt->type) & PTYPE_HASH_MASK];
420 list_for_each_entry(pt1, head, list) {
421 if (pt == pt1) {
422 list_del_rcu(&pt->list);
423 goto out;
427 printk(KERN_WARNING "dev_remove_pack: %p not found.\n", pt);
428 out:
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
438 * returns.
440 * This call sleeps to guarantee that no CPU is looking at the packet
441 * type after return.
443 void dev_remove_pack(struct packet_type *pt)
445 __dev_remove_pack(pt);
447 synchronize_net();
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
466 * all netdevices.
468 static int netdev_boot_setup_add(char *name, struct ifmap *map)
470 struct netdev_boot_setup *s;
471 int i;
473 s = dev_boot_setup;
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));
479 break;
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;
498 int i;
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;
507 return 1;
510 return 0;
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;
527 char name[IFNAMSIZ];
528 int i;
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))
537 return 1;
539 for (i = 0; i < NETDEV_BOOT_SETUP_MAX; i++)
540 if (!strcmp(name, s[i].name))
541 return s[i].map.base_addr;
542 return 0;
546 * Saves at boot time configured settings for any netdevice.
548 int __init netdev_boot_setup(char *str)
550 int ints[5];
551 struct ifmap map;
553 str = get_options(str, ARRAY_SIZE(ints), ints);
554 if (!str || !*str)
555 return 0;
557 /* Save settings */
558 memset(&map, 0, sizeof(map));
559 if (ints[0] > 0)
560 map.irq = ints[1];
561 if (ints[0] > 1)
562 map.base_addr = ints[2];
563 if (ints[0] > 2)
564 map.mem_start = ints[3];
565 if (ints[0] > 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))
600 return dev;
602 return NULL;
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);
623 if (dev)
624 dev_hold(dev);
625 read_unlock(&dev_base_lock);
626 return dev;
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
638 * or @dev_base_lock.
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)
649 return dev;
651 return NULL;
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);
672 if (dev)
673 dev_hold(dev);
674 read_unlock(&dev_base_lock);
675 return dev;
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
689 * BUGS:
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;
697 ASSERT_RTNL();
699 for_each_netdev(net, dev)
700 if (dev->type == type &&
701 !memcmp(dev->dev_addr, ha, dev->addr_len))
702 return dev;
704 return NULL;
707 EXPORT_SYMBOL(dev_getbyhwaddr);
709 struct net_device *__dev_getfirstbyhwtype(struct net *net, unsigned short type)
711 struct net_device *dev;
713 ASSERT_RTNL();
714 for_each_netdev(net, dev)
715 if (dev->type == type)
716 return dev;
718 return NULL;
721 EXPORT_SYMBOL(__dev_getfirstbyhwtype);
723 struct net_device *dev_getfirstbyhwtype(struct net *net, unsigned short type)
725 struct net_device *dev;
727 rtnl_lock();
728 dev = __dev_getfirstbyhwtype(net, type);
729 if (dev)
730 dev_hold(dev);
731 rtnl_unlock();
732 return dev;
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;
753 ret = NULL;
754 read_lock(&dev_base_lock);
755 for_each_netdev(net, dev) {
756 if (((dev->flags ^ if_flags) & mask) == 0) {
757 dev_hold(dev);
758 ret = dev;
759 break;
762 read_unlock(&dev_base_lock);
763 return ret;
767 * dev_valid_name - check if name is okay for network device
768 * @name: name string
770 * Network device names need to be valid file names to
771 * to allow sysfs to work. We also disallow any kind of
772 * whitespace.
774 int dev_valid_name(const char *name)
776 if (*name == '\0')
777 return 0;
778 if (strlen(name) >= IFNAMSIZ)
779 return 0;
780 if (!strcmp(name, ".") || !strcmp(name, ".."))
781 return 0;
783 while (*name) {
784 if (*name == '/' || isspace(*name))
785 return 0;
786 name++;
788 return 1;
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
801 * duplicates.
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)
808 int i = 0;
809 const char *p;
810 const int max_netdevices = 8*PAGE_SIZE;
811 unsigned long *inuse;
812 struct net_device *d;
814 p = strnchr(name, IFNAMSIZ-1, '%');
815 if (p) {
817 * Verify the string as this thing may have come from
818 * the user. There must be either one "%d" and no other "%"
819 * characters.
821 if (p[1] != 'd' || strchr(p + 2, '%'))
822 return -EINVAL;
824 /* Use one page as a bit array of possible slots */
825 inuse = (unsigned long *) get_zeroed_page(GFP_ATOMIC);
826 if (!inuse)
827 return -ENOMEM;
829 for_each_netdev(net, d) {
830 if (!sscanf(d->name, name, &i))
831 continue;
832 if (i < 0 || i >= max_netdevices)
833 continue;
835 /* avoid cases where sscanf is not exact inverse of printf */
836 snprintf(buf, IFNAMSIZ, name, i);
837 if (!strncmp(buf, d->name, IFNAMSIZ))
838 set_bit(i, inuse);
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))
847 return i;
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.
853 return -ENFILE;
857 * dev_alloc_name - allocate a name for a device
858 * @dev: 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
865 * duplicates.
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)
872 char buf[IFNAMSIZ];
873 struct net *net;
874 int ret;
876 BUG_ON(!dev_net(dev));
877 net = dev_net(dev);
878 ret = __dev_alloc_name(net, name, buf);
879 if (ret >= 0)
880 strlcpy(dev->name, buf, IFNAMSIZ);
881 return ret;
886 * dev_change_name - change name of a device
887 * @dev: device
888 * @newname: name (or format string) must be at least IFNAMSIZ
890 * Change name of a device, can pass format strings "eth%d".
891 * for wildcarding.
893 int dev_change_name(struct net_device *dev, char *newname)
895 char oldname[IFNAMSIZ];
896 int err = 0;
897 int ret;
898 struct net *net;
900 ASSERT_RTNL();
901 BUG_ON(!dev_net(dev));
903 net = dev_net(dev);
904 if (dev->flags & IFF_UP)
905 return -EBUSY;
907 if (!dev_valid_name(newname))
908 return -EINVAL;
910 if (strncmp(newname, dev->name, IFNAMSIZ) == 0)
911 return 0;
913 memcpy(oldname, dev->name, IFNAMSIZ);
915 if (strchr(newname, '%')) {
916 err = dev_alloc_name(dev, newname);
917 if (err < 0)
918 return err;
919 strcpy(newname, dev->name);
921 else if (__dev_get_by_name(net, newname))
922 return -EEXIST;
923 else
924 strlcpy(dev->name, newname, IFNAMSIZ);
926 rollback:
927 err = device_rename(&dev->dev, dev->name);
928 if (err) {
929 memcpy(dev->name, oldname, IFNAMSIZ);
930 return err;
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);
941 if (ret) {
942 if (err) {
943 printk(KERN_ERR
944 "%s: name change rollback failed: %d.\n",
945 dev->name, ret);
946 } else {
947 err = ret;
948 memcpy(dev->name, oldname, IFNAMSIZ);
949 goto rollback;
953 return err;
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)
1026 int ret = 0;
1028 ASSERT_RTNL();
1031 * Is it already up?
1034 if (dev->flags & IFF_UP)
1035 return 0;
1038 * Is it even present?
1040 if (!netif_device_present(dev))
1041 return -ENODEV;
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:
1058 if (ret)
1059 clear_bit(__LINK_STATE_START, &dev->state);
1060 else {
1062 * Set the flags.
1064 dev->flags |= IFF_UP;
1067 * Initialize multicasting status
1069 dev_set_rx_mode(dev);
1072 * Wakeup transmit queue engine
1074 dev_activate(dev);
1077 * ... and announce new interface.
1079 call_netdevice_notifiers(NETDEV_UP, dev);
1082 return ret;
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
1092 * chain.
1094 int dev_close(struct net_device *dev)
1096 ASSERT_RTNL();
1098 might_sleep();
1100 if (!(dev->flags & IFF_UP))
1101 return 0;
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
1126 * event.
1128 if (dev->stop)
1129 dev->stop(dev);
1132 * Device is now down.
1135 dev->flags &= ~IFF_UP;
1138 * Tell people we are down
1140 call_netdevice_notifiers(NETDEV_DOWN, dev);
1142 return 0;
1147 * dev_disable_lro - disable Large Receive Offload on a device
1148 * @dev: 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
1178 * @nb: notifier
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;
1194 struct net *net;
1195 int err;
1197 rtnl_lock();
1198 err = raw_notifier_chain_register(&netdev_chain, nb);
1199 if (err)
1200 goto unlock;
1201 if (dev_boot_phase)
1202 goto unlock;
1203 for_each_net(net) {
1204 for_each_netdev(net, dev) {
1205 err = nb->notifier_call(nb, NETDEV_REGISTER, dev);
1206 err = notifier_to_errno(err);
1207 if (err)
1208 goto rollback;
1210 if (!(dev->flags & IFF_UP))
1211 continue;
1213 nb->notifier_call(nb, NETDEV_UP, dev);
1217 unlock:
1218 rtnl_unlock();
1219 return err;
1221 rollback:
1222 last = dev;
1223 for_each_net(net) {
1224 for_each_netdev(net, dev) {
1225 if (dev == last)
1226 break;
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);
1237 goto unlock;
1241 * unregister_netdevice_notifier - unregister a network notifier block
1242 * @nb: notifier
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)
1252 int err;
1254 rtnl_lock();
1255 err = raw_notifier_chain_unregister(&netdev_chain, nb);
1256 rtnl_unlock();
1257 return err;
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);
1291 else
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;
1304 net_timestamp(skb);
1306 rcu_read_lock();
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);
1315 if (!skb2)
1316 break;
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 "
1328 "buggy, dev %s\n",
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);
1338 rcu_read_unlock();
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);
1378 else
1379 dev_kfree_skb(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))
1427 return true;
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))
1433 return true;
1436 return false;
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)
1445 __wsum csum;
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);
1466 if (ret)
1467 goto out;
1470 *(__sum16 *)(skb->data + offset) = csum_fold(csum);
1471 out_set_summed:
1472 skb->ip_summed = CHECKSUM_NONE;
1473 out:
1474 return ret;
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;
1492 int err;
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);
1506 rcu_read_lock();
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))
1514 break;
1515 __skb_push(skb, (skb->data -
1516 skb_network_header(skb)));
1518 segs = ptype->gso_segment(skb, features);
1519 break;
1522 rcu_read_unlock();
1524 __skb_push(skb, skb->data - skb_mac_header(skb));
1526 return segs;
1529 EXPORT_SYMBOL(skb_gso_segment);
1531 /* Take action when hardware reception checksum errors are detected. */
1532 #ifdef CONFIG_BUG
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>");
1538 dump_stack();
1541 EXPORT_SYMBOL(netdev_rx_csum_fault);
1542 #endif
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
1552 int i;
1554 if (dev->features & NETIF_F_HIGHDMA)
1555 return 0;
1557 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++)
1558 if (PageHighMem(skb_shinfo(skb)->frags[i].page))
1559 return 1;
1561 #endif
1562 return 0;
1565 struct dev_gso_cb {
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;
1575 do {
1576 struct sk_buff *nskb = skb->next;
1578 skb->next = nskb->next;
1579 nskb->next = NULL;
1580 kfree_skb(nskb);
1581 } while (skb->next);
1583 cb = DEV_GSO_CB(skb);
1584 if (cb->destructor)
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
1593 * in skb->next.
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) ?
1600 NETIF_F_SG : 0);
1602 segs = skb_gso_segment(skb, features);
1604 /* Verifying header integrity only. */
1605 if (!segs)
1606 return 0;
1608 if (IS_ERR(segs))
1609 return PTR_ERR(segs);
1611 skb->next = segs;
1612 DEV_GSO_CB(skb)->destructor = skb->destructor;
1613 skb->destructor = dev_gso_skb_destructor;
1615 return 0;
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)))
1627 goto out_kfree_skb;
1628 if (skb->next)
1629 goto gso;
1632 return dev->hard_start_xmit(skb, dev);
1635 gso:
1636 do {
1637 struct sk_buff *nskb = skb->next;
1638 int rc;
1640 skb->next = nskb->next;
1641 nskb->next = NULL;
1642 rc = dev->hard_start_xmit(nskb, dev);
1643 if (unlikely(rc)) {
1644 nskb->next = skb->next;
1645 skb->next = nskb;
1646 return rc;
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;
1654 out_kfree_skb:
1655 kfree_skb(skb);
1656 return 0;
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;
1665 u32 hash, ihl;
1666 u8 ip_proto;
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;
1679 break;
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];
1684 ihl = (40 >> 2);
1685 break;
1686 default:
1687 return 0;
1691 switch (ip_proto) {
1692 case IPPROTO_TCP:
1693 case IPPROTO_UDP:
1694 case IPPROTO_DCCP:
1695 case IPPROTO_ESP:
1696 case IPPROTO_AH:
1697 case IPPROTO_SCTP:
1698 case IPPROTO_UDPLITE:
1699 ports = *((u32 *) (skb_network_header(skb) + (ihl * 4)));
1700 break;
1702 default:
1703 ports = 0;
1704 break;
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
1741 * be positive.
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.
1749 * --BLG
1751 int dev_queue_xmit(struct sk_buff *skb)
1753 struct net_device *dev = skb->dev;
1754 struct netdev_queue *txq;
1755 struct Qdisc *q;
1756 int rc = -ENOMEM;
1758 /* GSO will handle the following emulations directly. */
1759 if (netif_needs_gso(dev, skb))
1760 goto gso;
1762 if (skb_shinfo(skb)->frag_list &&
1763 !(dev->features & NETIF_F_FRAGLIST) &&
1764 __skb_linearize(skb))
1765 goto out_kfree_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))
1774 goto out_kfree_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 -
1781 skb_headroom(skb));
1782 if (!dev_can_checksum(dev, skb) && skb_checksum_help(skb))
1783 goto out_kfree_skb;
1786 gso:
1787 /* Disable soft irqs for various locks below. Also
1788 * stops preemption for RCU.
1790 rcu_read_lock_bh();
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);
1797 #endif
1798 if (q->enqueue) {
1799 spinlock_t *root_lock = qdisc_root_lock(q);
1801 spin_lock(root_lock);
1803 rc = qdisc_enqueue_root(skb, q);
1804 qdisc_run(q);
1806 spin_unlock(root_lock);
1808 rc = rc == NET_XMIT_BYPASS ? NET_XMIT_SUCCESS : rc;
1809 goto out;
1812 /* The device has no queue. Common case for software devices:
1813 loopback, all the sorts of tunnels...
1815 Really, it is unlikely that netif_tx_lock protection is necessary
1816 here. (f.e. loopback and IP tunnels are clean ignoring statistics
1817 counters.)
1818 However, it is possible, that they rely on protection
1819 made by us here.
1821 Check this and shot the lock. It is not prone from deadlocks.
1822 Either shot noqueue qdisc, it is even simpler 8)
1824 if (dev->flags & IFF_UP) {
1825 int cpu = smp_processor_id(); /* ok because BHs are off */
1827 if (txq->xmit_lock_owner != cpu) {
1829 HARD_TX_LOCK(dev, txq, cpu);
1831 if (!netif_tx_queue_stopped(txq)) {
1832 rc = 0;
1833 if (!dev_hard_start_xmit(skb, dev, txq)) {
1834 HARD_TX_UNLOCK(dev, txq);
1835 goto out;
1838 HARD_TX_UNLOCK(dev, txq);
1839 if (net_ratelimit())
1840 printk(KERN_CRIT "Virtual device %s asks to "
1841 "queue packet!\n", dev->name);
1842 } else {
1843 /* Recursion is detected! It is possible,
1844 * unfortunately */
1845 if (net_ratelimit())
1846 printk(KERN_CRIT "Dead loop on virtual device "
1847 "%s, fix it urgently!\n", dev->name);
1851 rc = -ENETDOWN;
1852 rcu_read_unlock_bh();
1854 out_kfree_skb:
1855 kfree_skb(skb);
1856 return rc;
1857 out:
1858 rcu_read_unlock_bh();
1859 return rc;
1863 /*=======================================================================
1864 Receiver routines
1865 =======================================================================*/
1867 int netdev_max_backlog __read_mostly = 1000;
1868 int netdev_budget __read_mostly = 300;
1869 int weight_p __read_mostly = 64; /* old backlog weight */
1871 DEFINE_PER_CPU(struct netif_rx_stats, netdev_rx_stat) = { 0, };
1875 * netif_rx - post buffer to the network code
1876 * @skb: buffer to post
1878 * This function receives a packet from a device driver and queues it for
1879 * the upper (protocol) levels to process. It always succeeds. The buffer
1880 * may be dropped during processing for congestion control or by the
1881 * protocol layers.
1883 * return values:
1884 * NET_RX_SUCCESS (no congestion)
1885 * NET_RX_DROP (packet was dropped)
1889 int netif_rx(struct sk_buff *skb)
1891 struct softnet_data *queue;
1892 unsigned long flags;
1894 /* if netpoll wants it, pretend we never saw it */
1895 if (netpoll_rx(skb))
1896 return NET_RX_DROP;
1898 if (!skb->tstamp.tv64)
1899 net_timestamp(skb);
1902 * The code is rearranged so that the path is the most
1903 * short when CPU is congested, but is still operating.
1905 local_irq_save(flags);
1906 queue = &__get_cpu_var(softnet_data);
1908 __get_cpu_var(netdev_rx_stat).total++;
1909 if (queue->input_pkt_queue.qlen <= netdev_max_backlog) {
1910 if (queue->input_pkt_queue.qlen) {
1911 enqueue:
1912 dev_hold(skb->dev);
1913 __skb_queue_tail(&queue->input_pkt_queue, skb);
1914 local_irq_restore(flags);
1915 return NET_RX_SUCCESS;
1918 napi_schedule(&queue->backlog);
1919 goto enqueue;
1922 __get_cpu_var(netdev_rx_stat).dropped++;
1923 local_irq_restore(flags);
1925 kfree_skb(skb);
1926 return NET_RX_DROP;
1929 int netif_rx_ni(struct sk_buff *skb)
1931 int err;
1933 preempt_disable();
1934 err = netif_rx(skb);
1935 if (local_softirq_pending())
1936 do_softirq();
1937 preempt_enable();
1939 return err;
1942 EXPORT_SYMBOL(netif_rx_ni);
1944 static inline struct net_device *skb_bond(struct sk_buff *skb)
1946 struct net_device *dev = skb->dev;
1948 if (dev->master) {
1949 if (skb_bond_should_drop(skb)) {
1950 kfree_skb(skb);
1951 return NULL;
1953 skb->dev = dev->master;
1956 return dev;
1960 static void net_tx_action(struct softirq_action *h)
1962 struct softnet_data *sd = &__get_cpu_var(softnet_data);
1964 if (sd->completion_queue) {
1965 struct sk_buff *clist;
1967 local_irq_disable();
1968 clist = sd->completion_queue;
1969 sd->completion_queue = NULL;
1970 local_irq_enable();
1972 while (clist) {
1973 struct sk_buff *skb = clist;
1974 clist = clist->next;
1976 BUG_TRAP(!atomic_read(&skb->users));
1977 __kfree_skb(skb);
1981 if (sd->output_queue) {
1982 struct Qdisc *head;
1984 local_irq_disable();
1985 head = sd->output_queue;
1986 sd->output_queue = NULL;
1987 local_irq_enable();
1989 while (head) {
1990 struct Qdisc *q = head;
1991 spinlock_t *root_lock;
1993 head = head->next_sched;
1995 smp_mb__before_clear_bit();
1996 clear_bit(__QDISC_STATE_SCHED, &q->state);
1998 root_lock = qdisc_root_lock(q);
1999 if (spin_trylock(root_lock)) {
2000 qdisc_run(q);
2001 spin_unlock(root_lock);
2002 } else {
2003 __netif_schedule(q);
2009 static inline int deliver_skb(struct sk_buff *skb,
2010 struct packet_type *pt_prev,
2011 struct net_device *orig_dev)
2013 atomic_inc(&skb->users);
2014 return pt_prev->func(skb, skb->dev, pt_prev, orig_dev);
2017 #if defined(CONFIG_BRIDGE) || defined (CONFIG_BRIDGE_MODULE)
2018 /* These hooks defined here for ATM */
2019 struct net_bridge;
2020 struct net_bridge_fdb_entry *(*br_fdb_get_hook)(struct net_bridge *br,
2021 unsigned char *addr);
2022 void (*br_fdb_put_hook)(struct net_bridge_fdb_entry *ent) __read_mostly;
2025 * If bridge module is loaded call bridging hook.
2026 * returns NULL if packet was consumed.
2028 struct sk_buff *(*br_handle_frame_hook)(struct net_bridge_port *p,
2029 struct sk_buff *skb) __read_mostly;
2030 static inline struct sk_buff *handle_bridge(struct sk_buff *skb,
2031 struct packet_type **pt_prev, int *ret,
2032 struct net_device *orig_dev)
2034 struct net_bridge_port *port;
2036 if (skb->pkt_type == PACKET_LOOPBACK ||
2037 (port = rcu_dereference(skb->dev->br_port)) == NULL)
2038 return skb;
2040 if (*pt_prev) {
2041 *ret = deliver_skb(skb, *pt_prev, orig_dev);
2042 *pt_prev = NULL;
2045 return br_handle_frame_hook(port, skb);
2047 #else
2048 #define handle_bridge(skb, pt_prev, ret, orig_dev) (skb)
2049 #endif
2051 #if defined(CONFIG_MACVLAN) || defined(CONFIG_MACVLAN_MODULE)
2052 struct sk_buff *(*macvlan_handle_frame_hook)(struct sk_buff *skb) __read_mostly;
2053 EXPORT_SYMBOL_GPL(macvlan_handle_frame_hook);
2055 static inline struct sk_buff *handle_macvlan(struct sk_buff *skb,
2056 struct packet_type **pt_prev,
2057 int *ret,
2058 struct net_device *orig_dev)
2060 if (skb->dev->macvlan_port == NULL)
2061 return skb;
2063 if (*pt_prev) {
2064 *ret = deliver_skb(skb, *pt_prev, orig_dev);
2065 *pt_prev = NULL;
2067 return macvlan_handle_frame_hook(skb);
2069 #else
2070 #define handle_macvlan(skb, pt_prev, ret, orig_dev) (skb)
2071 #endif
2073 #ifdef CONFIG_NET_CLS_ACT
2074 /* TODO: Maybe we should just force sch_ingress to be compiled in
2075 * when CONFIG_NET_CLS_ACT is? otherwise some useless instructions
2076 * a compare and 2 stores extra right now if we dont have it on
2077 * but have CONFIG_NET_CLS_ACT
2078 * NOTE: This doesnt stop any functionality; if you dont have
2079 * the ingress scheduler, you just cant add policies on ingress.
2082 static int ing_filter(struct sk_buff *skb)
2084 struct net_device *dev = skb->dev;
2085 u32 ttl = G_TC_RTTL(skb->tc_verd);
2086 struct netdev_queue *rxq;
2087 int result = TC_ACT_OK;
2088 struct Qdisc *q;
2090 if (MAX_RED_LOOP < ttl++) {
2091 printk(KERN_WARNING
2092 "Redir loop detected Dropping packet (%d->%d)\n",
2093 skb->iif, dev->ifindex);
2094 return TC_ACT_SHOT;
2097 skb->tc_verd = SET_TC_RTTL(skb->tc_verd, ttl);
2098 skb->tc_verd = SET_TC_AT(skb->tc_verd, AT_INGRESS);
2100 rxq = &dev->rx_queue;
2102 q = rxq->qdisc;
2103 if (q) {
2104 spin_lock(qdisc_lock(q));
2105 result = qdisc_enqueue_root(skb, q);
2106 spin_unlock(qdisc_lock(q));
2109 return result;
2112 static inline struct sk_buff *handle_ing(struct sk_buff *skb,
2113 struct packet_type **pt_prev,
2114 int *ret, struct net_device *orig_dev)
2116 if (!skb->dev->rx_queue.qdisc)
2117 goto out;
2119 if (*pt_prev) {
2120 *ret = deliver_skb(skb, *pt_prev, orig_dev);
2121 *pt_prev = NULL;
2122 } else {
2123 /* Huh? Why does turning on AF_PACKET affect this? */
2124 skb->tc_verd = SET_TC_OK2MUNGE(skb->tc_verd);
2127 switch (ing_filter(skb)) {
2128 case TC_ACT_SHOT:
2129 case TC_ACT_STOLEN:
2130 kfree_skb(skb);
2131 return NULL;
2134 out:
2135 skb->tc_verd = 0;
2136 return skb;
2138 #endif
2141 * netif_nit_deliver - deliver received packets to network taps
2142 * @skb: buffer
2144 * This function is used to deliver incoming packets to network
2145 * taps. It should be used when the normal netif_receive_skb path
2146 * is bypassed, for example because of VLAN acceleration.
2148 void netif_nit_deliver(struct sk_buff *skb)
2150 struct packet_type *ptype;
2152 if (list_empty(&ptype_all))
2153 return;
2155 skb_reset_network_header(skb);
2156 skb_reset_transport_header(skb);
2157 skb->mac_len = skb->network_header - skb->mac_header;
2159 rcu_read_lock();
2160 list_for_each_entry_rcu(ptype, &ptype_all, list) {
2161 if (!ptype->dev || ptype->dev == skb->dev)
2162 deliver_skb(skb, ptype, skb->dev);
2164 rcu_read_unlock();
2168 * netif_receive_skb - process receive buffer from network
2169 * @skb: buffer to process
2171 * netif_receive_skb() is the main receive data processing function.
2172 * It always succeeds. The buffer may be dropped during processing
2173 * for congestion control or by the protocol layers.
2175 * This function may only be called from softirq context and interrupts
2176 * should be enabled.
2178 * Return values (usually ignored):
2179 * NET_RX_SUCCESS: no congestion
2180 * NET_RX_DROP: packet was dropped
2182 int netif_receive_skb(struct sk_buff *skb)
2184 struct packet_type *ptype, *pt_prev;
2185 struct net_device *orig_dev;
2186 int ret = NET_RX_DROP;
2187 __be16 type;
2189 /* if we've gotten here through NAPI, check netpoll */
2190 if (netpoll_receive_skb(skb))
2191 return NET_RX_DROP;
2193 if (!skb->tstamp.tv64)
2194 net_timestamp(skb);
2196 if (!skb->iif)
2197 skb->iif = skb->dev->ifindex;
2199 orig_dev = skb_bond(skb);
2201 if (!orig_dev)
2202 return NET_RX_DROP;
2204 __get_cpu_var(netdev_rx_stat).total++;
2206 skb_reset_network_header(skb);
2207 skb_reset_transport_header(skb);
2208 skb->mac_len = skb->network_header - skb->mac_header;
2210 pt_prev = NULL;
2212 rcu_read_lock();
2214 /* Don't receive packets in an exiting network namespace */
2215 if (!net_alive(dev_net(skb->dev)))
2216 goto out;
2218 #ifdef CONFIG_NET_CLS_ACT
2219 if (skb->tc_verd & TC_NCLS) {
2220 skb->tc_verd = CLR_TC_NCLS(skb->tc_verd);
2221 goto ncls;
2223 #endif
2225 list_for_each_entry_rcu(ptype, &ptype_all, list) {
2226 if (!ptype->dev || ptype->dev == skb->dev) {
2227 if (pt_prev)
2228 ret = deliver_skb(skb, pt_prev, orig_dev);
2229 pt_prev = ptype;
2233 #ifdef CONFIG_NET_CLS_ACT
2234 skb = handle_ing(skb, &pt_prev, &ret, orig_dev);
2235 if (!skb)
2236 goto out;
2237 ncls:
2238 #endif
2240 skb = handle_bridge(skb, &pt_prev, &ret, orig_dev);
2241 if (!skb)
2242 goto out;
2243 skb = handle_macvlan(skb, &pt_prev, &ret, orig_dev);
2244 if (!skb)
2245 goto out;
2247 type = skb->protocol;
2248 list_for_each_entry_rcu(ptype,
2249 &ptype_base[ntohs(type) & PTYPE_HASH_MASK], list) {
2250 if (ptype->type == type &&
2251 (!ptype->dev || ptype->dev == skb->dev)) {
2252 if (pt_prev)
2253 ret = deliver_skb(skb, pt_prev, orig_dev);
2254 pt_prev = ptype;
2258 if (pt_prev) {
2259 ret = pt_prev->func(skb, skb->dev, pt_prev, orig_dev);
2260 } else {
2261 kfree_skb(skb);
2262 /* Jamal, now you will not able to escape explaining
2263 * me how you were going to use this. :-)
2265 ret = NET_RX_DROP;
2268 out:
2269 rcu_read_unlock();
2270 return ret;
2273 static int process_backlog(struct napi_struct *napi, int quota)
2275 int work = 0;
2276 struct softnet_data *queue = &__get_cpu_var(softnet_data);
2277 unsigned long start_time = jiffies;
2279 napi->weight = weight_p;
2280 do {
2281 struct sk_buff *skb;
2282 struct net_device *dev;
2284 local_irq_disable();
2285 skb = __skb_dequeue(&queue->input_pkt_queue);
2286 if (!skb) {
2287 __napi_complete(napi);
2288 local_irq_enable();
2289 break;
2292 local_irq_enable();
2294 dev = skb->dev;
2296 netif_receive_skb(skb);
2298 dev_put(dev);
2299 } while (++work < quota && jiffies == start_time);
2301 return work;
2305 * __napi_schedule - schedule for receive
2306 * @n: entry to schedule
2308 * The entry's receive function will be scheduled to run
2310 void __napi_schedule(struct napi_struct *n)
2312 unsigned long flags;
2314 local_irq_save(flags);
2315 list_add_tail(&n->poll_list, &__get_cpu_var(softnet_data).poll_list);
2316 __raise_softirq_irqoff(NET_RX_SOFTIRQ);
2317 local_irq_restore(flags);
2319 EXPORT_SYMBOL(__napi_schedule);
2322 static void net_rx_action(struct softirq_action *h)
2324 struct list_head *list = &__get_cpu_var(softnet_data).poll_list;
2325 unsigned long start_time = jiffies;
2326 int budget = netdev_budget;
2327 void *have;
2329 local_irq_disable();
2331 while (!list_empty(list)) {
2332 struct napi_struct *n;
2333 int work, weight;
2335 /* If softirq window is exhuasted then punt.
2337 * Note that this is a slight policy change from the
2338 * previous NAPI code, which would allow up to 2
2339 * jiffies to pass before breaking out. The test
2340 * used to be "jiffies - start_time > 1".
2342 if (unlikely(budget <= 0 || jiffies != start_time))
2343 goto softnet_break;
2345 local_irq_enable();
2347 /* Even though interrupts have been re-enabled, this
2348 * access is safe because interrupts can only add new
2349 * entries to the tail of this list, and only ->poll()
2350 * calls can remove this head entry from the list.
2352 n = list_entry(list->next, struct napi_struct, poll_list);
2354 have = netpoll_poll_lock(n);
2356 weight = n->weight;
2358 /* This NAPI_STATE_SCHED test is for avoiding a race
2359 * with netpoll's poll_napi(). Only the entity which
2360 * obtains the lock and sees NAPI_STATE_SCHED set will
2361 * actually make the ->poll() call. Therefore we avoid
2362 * accidently calling ->poll() when NAPI is not scheduled.
2364 work = 0;
2365 if (test_bit(NAPI_STATE_SCHED, &n->state))
2366 work = n->poll(n, weight);
2368 WARN_ON_ONCE(work > weight);
2370 budget -= work;
2372 local_irq_disable();
2374 /* Drivers must not modify the NAPI state if they
2375 * consume the entire weight. In such cases this code
2376 * still "owns" the NAPI instance and therefore can
2377 * move the instance around on the list at-will.
2379 if (unlikely(work == weight)) {
2380 if (unlikely(napi_disable_pending(n)))
2381 __napi_complete(n);
2382 else
2383 list_move_tail(&n->poll_list, list);
2386 netpoll_poll_unlock(have);
2388 out:
2389 local_irq_enable();
2391 #ifdef CONFIG_NET_DMA
2393 * There may not be any more sk_buffs coming right now, so push
2394 * any pending DMA copies to hardware
2396 if (!cpus_empty(net_dma.channel_mask)) {
2397 int chan_idx;
2398 for_each_cpu_mask_nr(chan_idx, net_dma.channel_mask) {
2399 struct dma_chan *chan = net_dma.channels[chan_idx];
2400 if (chan)
2401 dma_async_memcpy_issue_pending(chan);
2404 #endif
2406 return;
2408 softnet_break:
2409 __get_cpu_var(netdev_rx_stat).time_squeeze++;
2410 __raise_softirq_irqoff(NET_RX_SOFTIRQ);
2411 goto out;
2414 static gifconf_func_t * gifconf_list [NPROTO];
2417 * register_gifconf - register a SIOCGIF handler
2418 * @family: Address family
2419 * @gifconf: Function handler
2421 * Register protocol dependent address dumping routines. The handler
2422 * that is passed must not be freed or reused until it has been replaced
2423 * by another handler.
2425 int register_gifconf(unsigned int family, gifconf_func_t * gifconf)
2427 if (family >= NPROTO)
2428 return -EINVAL;
2429 gifconf_list[family] = gifconf;
2430 return 0;
2435 * Map an interface index to its name (SIOCGIFNAME)
2439 * We need this ioctl for efficient implementation of the
2440 * if_indextoname() function required by the IPv6 API. Without
2441 * it, we would have to search all the interfaces to find a
2442 * match. --pb
2445 static int dev_ifname(struct net *net, struct ifreq __user *arg)
2447 struct net_device *dev;
2448 struct ifreq ifr;
2451 * Fetch the caller's info block.
2454 if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
2455 return -EFAULT;
2457 read_lock(&dev_base_lock);
2458 dev = __dev_get_by_index(net, ifr.ifr_ifindex);
2459 if (!dev) {
2460 read_unlock(&dev_base_lock);
2461 return -ENODEV;
2464 strcpy(ifr.ifr_name, dev->name);
2465 read_unlock(&dev_base_lock);
2467 if (copy_to_user(arg, &ifr, sizeof(struct ifreq)))
2468 return -EFAULT;
2469 return 0;
2473 * Perform a SIOCGIFCONF call. This structure will change
2474 * size eventually, and there is nothing I can do about it.
2475 * Thus we will need a 'compatibility mode'.
2478 static int dev_ifconf(struct net *net, char __user *arg)
2480 struct ifconf ifc;
2481 struct net_device *dev;
2482 char __user *pos;
2483 int len;
2484 int total;
2485 int i;
2488 * Fetch the caller's info block.
2491 if (copy_from_user(&ifc, arg, sizeof(struct ifconf)))
2492 return -EFAULT;
2494 pos = ifc.ifc_buf;
2495 len = ifc.ifc_len;
2498 * Loop over the interfaces, and write an info block for each.
2501 total = 0;
2502 for_each_netdev(net, dev) {
2503 for (i = 0; i < NPROTO; i++) {
2504 if (gifconf_list[i]) {
2505 int done;
2506 if (!pos)
2507 done = gifconf_list[i](dev, NULL, 0);
2508 else
2509 done = gifconf_list[i](dev, pos + total,
2510 len - total);
2511 if (done < 0)
2512 return -EFAULT;
2513 total += done;
2519 * All done. Write the updated control block back to the caller.
2521 ifc.ifc_len = total;
2524 * Both BSD and Solaris return 0 here, so we do too.
2526 return copy_to_user(arg, &ifc, sizeof(struct ifconf)) ? -EFAULT : 0;
2529 #ifdef CONFIG_PROC_FS
2531 * This is invoked by the /proc filesystem handler to display a device
2532 * in detail.
2534 void *dev_seq_start(struct seq_file *seq, loff_t *pos)
2535 __acquires(dev_base_lock)
2537 struct net *net = seq_file_net(seq);
2538 loff_t off;
2539 struct net_device *dev;
2541 read_lock(&dev_base_lock);
2542 if (!*pos)
2543 return SEQ_START_TOKEN;
2545 off = 1;
2546 for_each_netdev(net, dev)
2547 if (off++ == *pos)
2548 return dev;
2550 return NULL;
2553 void *dev_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2555 struct net *net = seq_file_net(seq);
2556 ++*pos;
2557 return v == SEQ_START_TOKEN ?
2558 first_net_device(net) : next_net_device((struct net_device *)v);
2561 void dev_seq_stop(struct seq_file *seq, void *v)
2562 __releases(dev_base_lock)
2564 read_unlock(&dev_base_lock);
2567 static void dev_seq_printf_stats(struct seq_file *seq, struct net_device *dev)
2569 struct net_device_stats *stats = dev->get_stats(dev);
2571 seq_printf(seq, "%6s:%8lu %7lu %4lu %4lu %4lu %5lu %10lu %9lu "
2572 "%8lu %7lu %4lu %4lu %4lu %5lu %7lu %10lu\n",
2573 dev->name, stats->rx_bytes, stats->rx_packets,
2574 stats->rx_errors,
2575 stats->rx_dropped + stats->rx_missed_errors,
2576 stats->rx_fifo_errors,
2577 stats->rx_length_errors + stats->rx_over_errors +
2578 stats->rx_crc_errors + stats->rx_frame_errors,
2579 stats->rx_compressed, stats->multicast,
2580 stats->tx_bytes, stats->tx_packets,
2581 stats->tx_errors, stats->tx_dropped,
2582 stats->tx_fifo_errors, stats->collisions,
2583 stats->tx_carrier_errors +
2584 stats->tx_aborted_errors +
2585 stats->tx_window_errors +
2586 stats->tx_heartbeat_errors,
2587 stats->tx_compressed);
2591 * Called from the PROCfs module. This now uses the new arbitrary sized
2592 * /proc/net interface to create /proc/net/dev
2594 static int dev_seq_show(struct seq_file *seq, void *v)
2596 if (v == SEQ_START_TOKEN)
2597 seq_puts(seq, "Inter-| Receive "
2598 " | Transmit\n"
2599 " face |bytes packets errs drop fifo frame "
2600 "compressed multicast|bytes packets errs "
2601 "drop fifo colls carrier compressed\n");
2602 else
2603 dev_seq_printf_stats(seq, v);
2604 return 0;
2607 static struct netif_rx_stats *softnet_get_online(loff_t *pos)
2609 struct netif_rx_stats *rc = NULL;
2611 while (*pos < nr_cpu_ids)
2612 if (cpu_online(*pos)) {
2613 rc = &per_cpu(netdev_rx_stat, *pos);
2614 break;
2615 } else
2616 ++*pos;
2617 return rc;
2620 static void *softnet_seq_start(struct seq_file *seq, loff_t *pos)
2622 return softnet_get_online(pos);
2625 static void *softnet_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2627 ++*pos;
2628 return softnet_get_online(pos);
2631 static void softnet_seq_stop(struct seq_file *seq, void *v)
2635 static int softnet_seq_show(struct seq_file *seq, void *v)
2637 struct netif_rx_stats *s = v;
2639 seq_printf(seq, "%08x %08x %08x %08x %08x %08x %08x %08x %08x\n",
2640 s->total, s->dropped, s->time_squeeze, 0,
2641 0, 0, 0, 0, /* was fastroute */
2642 s->cpu_collision );
2643 return 0;
2646 static const struct seq_operations dev_seq_ops = {
2647 .start = dev_seq_start,
2648 .next = dev_seq_next,
2649 .stop = dev_seq_stop,
2650 .show = dev_seq_show,
2653 static int dev_seq_open(struct inode *inode, struct file *file)
2655 return seq_open_net(inode, file, &dev_seq_ops,
2656 sizeof(struct seq_net_private));
2659 static const struct file_operations dev_seq_fops = {
2660 .owner = THIS_MODULE,
2661 .open = dev_seq_open,
2662 .read = seq_read,
2663 .llseek = seq_lseek,
2664 .release = seq_release_net,
2667 static const struct seq_operations softnet_seq_ops = {
2668 .start = softnet_seq_start,
2669 .next = softnet_seq_next,
2670 .stop = softnet_seq_stop,
2671 .show = softnet_seq_show,
2674 static int softnet_seq_open(struct inode *inode, struct file *file)
2676 return seq_open(file, &softnet_seq_ops);
2679 static const struct file_operations softnet_seq_fops = {
2680 .owner = THIS_MODULE,
2681 .open = softnet_seq_open,
2682 .read = seq_read,
2683 .llseek = seq_lseek,
2684 .release = seq_release,
2687 static void *ptype_get_idx(loff_t pos)
2689 struct packet_type *pt = NULL;
2690 loff_t i = 0;
2691 int t;
2693 list_for_each_entry_rcu(pt, &ptype_all, list) {
2694 if (i == pos)
2695 return pt;
2696 ++i;
2699 for (t = 0; t < PTYPE_HASH_SIZE; t++) {
2700 list_for_each_entry_rcu(pt, &ptype_base[t], list) {
2701 if (i == pos)
2702 return pt;
2703 ++i;
2706 return NULL;
2709 static void *ptype_seq_start(struct seq_file *seq, loff_t *pos)
2710 __acquires(RCU)
2712 rcu_read_lock();
2713 return *pos ? ptype_get_idx(*pos - 1) : SEQ_START_TOKEN;
2716 static void *ptype_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2718 struct packet_type *pt;
2719 struct list_head *nxt;
2720 int hash;
2722 ++*pos;
2723 if (v == SEQ_START_TOKEN)
2724 return ptype_get_idx(0);
2726 pt = v;
2727 nxt = pt->list.next;
2728 if (pt->type == htons(ETH_P_ALL)) {
2729 if (nxt != &ptype_all)
2730 goto found;
2731 hash = 0;
2732 nxt = ptype_base[0].next;
2733 } else
2734 hash = ntohs(pt->type) & PTYPE_HASH_MASK;
2736 while (nxt == &ptype_base[hash]) {
2737 if (++hash >= PTYPE_HASH_SIZE)
2738 return NULL;
2739 nxt = ptype_base[hash].next;
2741 found:
2742 return list_entry(nxt, struct packet_type, list);
2745 static void ptype_seq_stop(struct seq_file *seq, void *v)
2746 __releases(RCU)
2748 rcu_read_unlock();
2751 static void ptype_seq_decode(struct seq_file *seq, void *sym)
2753 #ifdef CONFIG_KALLSYMS
2754 unsigned long offset = 0, symsize;
2755 const char *symname;
2756 char *modname;
2757 char namebuf[128];
2759 symname = kallsyms_lookup((unsigned long)sym, &symsize, &offset,
2760 &modname, namebuf);
2762 if (symname) {
2763 char *delim = ":";
2765 if (!modname)
2766 modname = delim = "";
2767 seq_printf(seq, "%s%s%s%s+0x%lx", delim, modname, delim,
2768 symname, offset);
2769 return;
2771 #endif
2773 seq_printf(seq, "[%p]", sym);
2776 static int ptype_seq_show(struct seq_file *seq, void *v)
2778 struct packet_type *pt = v;
2780 if (v == SEQ_START_TOKEN)
2781 seq_puts(seq, "Type Device Function\n");
2782 else if (pt->dev == NULL || dev_net(pt->dev) == seq_file_net(seq)) {
2783 if (pt->type == htons(ETH_P_ALL))
2784 seq_puts(seq, "ALL ");
2785 else
2786 seq_printf(seq, "%04x", ntohs(pt->type));
2788 seq_printf(seq, " %-8s ",
2789 pt->dev ? pt->dev->name : "");
2790 ptype_seq_decode(seq, pt->func);
2791 seq_putc(seq, '\n');
2794 return 0;
2797 static const struct seq_operations ptype_seq_ops = {
2798 .start = ptype_seq_start,
2799 .next = ptype_seq_next,
2800 .stop = ptype_seq_stop,
2801 .show = ptype_seq_show,
2804 static int ptype_seq_open(struct inode *inode, struct file *file)
2806 return seq_open_net(inode, file, &ptype_seq_ops,
2807 sizeof(struct seq_net_private));
2810 static const struct file_operations ptype_seq_fops = {
2811 .owner = THIS_MODULE,
2812 .open = ptype_seq_open,
2813 .read = seq_read,
2814 .llseek = seq_lseek,
2815 .release = seq_release_net,
2819 static int __net_init dev_proc_net_init(struct net *net)
2821 int rc = -ENOMEM;
2823 if (!proc_net_fops_create(net, "dev", S_IRUGO, &dev_seq_fops))
2824 goto out;
2825 if (!proc_net_fops_create(net, "softnet_stat", S_IRUGO, &softnet_seq_fops))
2826 goto out_dev;
2827 if (!proc_net_fops_create(net, "ptype", S_IRUGO, &ptype_seq_fops))
2828 goto out_softnet;
2830 if (wext_proc_init(net))
2831 goto out_ptype;
2832 rc = 0;
2833 out:
2834 return rc;
2835 out_ptype:
2836 proc_net_remove(net, "ptype");
2837 out_softnet:
2838 proc_net_remove(net, "softnet_stat");
2839 out_dev:
2840 proc_net_remove(net, "dev");
2841 goto out;
2844 static void __net_exit dev_proc_net_exit(struct net *net)
2846 wext_proc_exit(net);
2848 proc_net_remove(net, "ptype");
2849 proc_net_remove(net, "softnet_stat");
2850 proc_net_remove(net, "dev");
2853 static struct pernet_operations __net_initdata dev_proc_ops = {
2854 .init = dev_proc_net_init,
2855 .exit = dev_proc_net_exit,
2858 static int __init dev_proc_init(void)
2860 return register_pernet_subsys(&dev_proc_ops);
2862 #else
2863 #define dev_proc_init() 0
2864 #endif /* CONFIG_PROC_FS */
2868 * netdev_set_master - set up master/slave pair
2869 * @slave: slave device
2870 * @master: new master device
2872 * Changes the master device of the slave. Pass %NULL to break the
2873 * bonding. The caller must hold the RTNL semaphore. On a failure
2874 * a negative errno code is returned. On success the reference counts
2875 * are adjusted, %RTM_NEWLINK is sent to the routing socket and the
2876 * function returns zero.
2878 int netdev_set_master(struct net_device *slave, struct net_device *master)
2880 struct net_device *old = slave->master;
2882 ASSERT_RTNL();
2884 if (master) {
2885 if (old)
2886 return -EBUSY;
2887 dev_hold(master);
2890 slave->master = master;
2892 synchronize_net();
2894 if (old)
2895 dev_put(old);
2897 if (master)
2898 slave->flags |= IFF_SLAVE;
2899 else
2900 slave->flags &= ~IFF_SLAVE;
2902 rtmsg_ifinfo(RTM_NEWLINK, slave, IFF_SLAVE);
2903 return 0;
2906 static int __dev_set_promiscuity(struct net_device *dev, int inc)
2908 unsigned short old_flags = dev->flags;
2910 ASSERT_RTNL();
2912 dev->flags |= IFF_PROMISC;
2913 dev->promiscuity += inc;
2914 if (dev->promiscuity == 0) {
2916 * Avoid overflow.
2917 * If inc causes overflow, untouch promisc and return error.
2919 if (inc < 0)
2920 dev->flags &= ~IFF_PROMISC;
2921 else {
2922 dev->promiscuity -= inc;
2923 printk(KERN_WARNING "%s: promiscuity touches roof, "
2924 "set promiscuity failed, promiscuity feature "
2925 "of device might be broken.\n", dev->name);
2926 return -EOVERFLOW;
2929 if (dev->flags != old_flags) {
2930 printk(KERN_INFO "device %s %s promiscuous mode\n",
2931 dev->name, (dev->flags & IFF_PROMISC) ? "entered" :
2932 "left");
2933 if (audit_enabled)
2934 audit_log(current->audit_context, GFP_ATOMIC,
2935 AUDIT_ANOM_PROMISCUOUS,
2936 "dev=%s prom=%d old_prom=%d auid=%u uid=%u gid=%u ses=%u",
2937 dev->name, (dev->flags & IFF_PROMISC),
2938 (old_flags & IFF_PROMISC),
2939 audit_get_loginuid(current),
2940 current->uid, current->gid,
2941 audit_get_sessionid(current));
2943 if (dev->change_rx_flags)
2944 dev->change_rx_flags(dev, IFF_PROMISC);
2946 return 0;
2950 * dev_set_promiscuity - update promiscuity count on a device
2951 * @dev: device
2952 * @inc: modifier
2954 * Add or remove promiscuity from a device. While the count in the device
2955 * remains above zero the interface remains promiscuous. Once it hits zero
2956 * the device reverts back to normal filtering operation. A negative inc
2957 * value is used to drop promiscuity on the device.
2958 * Return 0 if successful or a negative errno code on error.
2960 int dev_set_promiscuity(struct net_device *dev, int inc)
2962 unsigned short old_flags = dev->flags;
2963 int err;
2965 err = __dev_set_promiscuity(dev, inc);
2966 if (err < 0)
2967 return err;
2968 if (dev->flags != old_flags)
2969 dev_set_rx_mode(dev);
2970 return err;
2974 * dev_set_allmulti - update allmulti count on a device
2975 * @dev: device
2976 * @inc: modifier
2978 * Add or remove reception of all multicast frames to a device. While the
2979 * count in the device remains above zero the interface remains listening
2980 * to all interfaces. Once it hits zero the device reverts back to normal
2981 * filtering operation. A negative @inc value is used to drop the counter
2982 * when releasing a resource needing all multicasts.
2983 * Return 0 if successful or a negative errno code on error.
2986 int dev_set_allmulti(struct net_device *dev, int inc)
2988 unsigned short old_flags = dev->flags;
2990 ASSERT_RTNL();
2992 dev->flags |= IFF_ALLMULTI;
2993 dev->allmulti += inc;
2994 if (dev->allmulti == 0) {
2996 * Avoid overflow.
2997 * If inc causes overflow, untouch allmulti and return error.
2999 if (inc < 0)
3000 dev->flags &= ~IFF_ALLMULTI;
3001 else {
3002 dev->allmulti -= inc;
3003 printk(KERN_WARNING "%s: allmulti touches roof, "
3004 "set allmulti failed, allmulti feature of "
3005 "device might be broken.\n", dev->name);
3006 return -EOVERFLOW;
3009 if (dev->flags ^ old_flags) {
3010 if (dev->change_rx_flags)
3011 dev->change_rx_flags(dev, IFF_ALLMULTI);
3012 dev_set_rx_mode(dev);
3014 return 0;
3018 * Upload unicast and multicast address lists to device and
3019 * configure RX filtering. When the device doesn't support unicast
3020 * filtering it is put in promiscuous mode while unicast addresses
3021 * are present.
3023 void __dev_set_rx_mode(struct net_device *dev)
3025 /* dev_open will call this function so the list will stay sane. */
3026 if (!(dev->flags&IFF_UP))
3027 return;
3029 if (!netif_device_present(dev))
3030 return;
3032 if (dev->set_rx_mode)
3033 dev->set_rx_mode(dev);
3034 else {
3035 /* Unicast addresses changes may only happen under the rtnl,
3036 * therefore calling __dev_set_promiscuity here is safe.
3038 if (dev->uc_count > 0 && !dev->uc_promisc) {
3039 __dev_set_promiscuity(dev, 1);
3040 dev->uc_promisc = 1;
3041 } else if (dev->uc_count == 0 && dev->uc_promisc) {
3042 __dev_set_promiscuity(dev, -1);
3043 dev->uc_promisc = 0;
3046 if (dev->set_multicast_list)
3047 dev->set_multicast_list(dev);
3051 void dev_set_rx_mode(struct net_device *dev)
3053 netif_addr_lock_bh(dev);
3054 __dev_set_rx_mode(dev);
3055 netif_addr_unlock_bh(dev);
3058 int __dev_addr_delete(struct dev_addr_list **list, int *count,
3059 void *addr, int alen, int glbl)
3061 struct dev_addr_list *da;
3063 for (; (da = *list) != NULL; list = &da->next) {
3064 if (memcmp(da->da_addr, addr, da->da_addrlen) == 0 &&
3065 alen == da->da_addrlen) {
3066 if (glbl) {
3067 int old_glbl = da->da_gusers;
3068 da->da_gusers = 0;
3069 if (old_glbl == 0)
3070 break;
3072 if (--da->da_users)
3073 return 0;
3075 *list = da->next;
3076 kfree(da);
3077 (*count)--;
3078 return 0;
3081 return -ENOENT;
3084 int __dev_addr_add(struct dev_addr_list **list, int *count,
3085 void *addr, int alen, int glbl)
3087 struct dev_addr_list *da;
3089 for (da = *list; da != NULL; da = da->next) {
3090 if (memcmp(da->da_addr, addr, da->da_addrlen) == 0 &&
3091 da->da_addrlen == alen) {
3092 if (glbl) {
3093 int old_glbl = da->da_gusers;
3094 da->da_gusers = 1;
3095 if (old_glbl)
3096 return 0;
3098 da->da_users++;
3099 return 0;
3103 da = kzalloc(sizeof(*da), GFP_ATOMIC);
3104 if (da == NULL)
3105 return -ENOMEM;
3106 memcpy(da->da_addr, addr, alen);
3107 da->da_addrlen = alen;
3108 da->da_users = 1;
3109 da->da_gusers = glbl ? 1 : 0;
3110 da->next = *list;
3111 *list = da;
3112 (*count)++;
3113 return 0;
3117 * dev_unicast_delete - Release secondary unicast address.
3118 * @dev: device
3119 * @addr: address to delete
3120 * @alen: length of @addr
3122 * Release reference to a secondary unicast address and remove it
3123 * from the device if the reference count drops to zero.
3125 * The caller must hold the rtnl_mutex.
3127 int dev_unicast_delete(struct net_device *dev, void *addr, int alen)
3129 int err;
3131 ASSERT_RTNL();
3133 netif_addr_lock_bh(dev);
3134 err = __dev_addr_delete(&dev->uc_list, &dev->uc_count, addr, alen, 0);
3135 if (!err)
3136 __dev_set_rx_mode(dev);
3137 netif_addr_unlock_bh(dev);
3138 return err;
3140 EXPORT_SYMBOL(dev_unicast_delete);
3143 * dev_unicast_add - add a secondary unicast address
3144 * @dev: device
3145 * @addr: address to add
3146 * @alen: length of @addr
3148 * Add a secondary unicast address to the device or increase
3149 * the reference count if it already exists.
3151 * The caller must hold the rtnl_mutex.
3153 int dev_unicast_add(struct net_device *dev, void *addr, int alen)
3155 int err;
3157 ASSERT_RTNL();
3159 netif_addr_lock_bh(dev);
3160 err = __dev_addr_add(&dev->uc_list, &dev->uc_count, addr, alen, 0);
3161 if (!err)
3162 __dev_set_rx_mode(dev);
3163 netif_addr_unlock_bh(dev);
3164 return err;
3166 EXPORT_SYMBOL(dev_unicast_add);
3168 int __dev_addr_sync(struct dev_addr_list **to, int *to_count,
3169 struct dev_addr_list **from, int *from_count)
3171 struct dev_addr_list *da, *next;
3172 int err = 0;
3174 da = *from;
3175 while (da != NULL) {
3176 next = da->next;
3177 if (!da->da_synced) {
3178 err = __dev_addr_add(to, to_count,
3179 da->da_addr, da->da_addrlen, 0);
3180 if (err < 0)
3181 break;
3182 da->da_synced = 1;
3183 da->da_users++;
3184 } else if (da->da_users == 1) {
3185 __dev_addr_delete(to, to_count,
3186 da->da_addr, da->da_addrlen, 0);
3187 __dev_addr_delete(from, from_count,
3188 da->da_addr, da->da_addrlen, 0);
3190 da = next;
3192 return err;
3195 void __dev_addr_unsync(struct dev_addr_list **to, int *to_count,
3196 struct dev_addr_list **from, int *from_count)
3198 struct dev_addr_list *da, *next;
3200 da = *from;
3201 while (da != NULL) {
3202 next = da->next;
3203 if (da->da_synced) {
3204 __dev_addr_delete(to, to_count,
3205 da->da_addr, da->da_addrlen, 0);
3206 da->da_synced = 0;
3207 __dev_addr_delete(from, from_count,
3208 da->da_addr, da->da_addrlen, 0);
3210 da = next;
3215 * dev_unicast_sync - Synchronize device's unicast list to another device
3216 * @to: destination device
3217 * @from: source device
3219 * Add newly added addresses to the destination device and release
3220 * addresses that have no users left. The source device must be
3221 * locked by netif_tx_lock_bh.
3223 * This function is intended to be called from the dev->set_rx_mode
3224 * function of layered software devices.
3226 int dev_unicast_sync(struct net_device *to, struct net_device *from)
3228 int err = 0;
3230 netif_addr_lock_bh(to);
3231 err = __dev_addr_sync(&to->uc_list, &to->uc_count,
3232 &from->uc_list, &from->uc_count);
3233 if (!err)
3234 __dev_set_rx_mode(to);
3235 netif_addr_unlock_bh(to);
3236 return err;
3238 EXPORT_SYMBOL(dev_unicast_sync);
3241 * dev_unicast_unsync - Remove synchronized addresses from the destination device
3242 * @to: destination device
3243 * @from: source device
3245 * Remove all addresses that were added to the destination device by
3246 * dev_unicast_sync(). This function is intended to be called from the
3247 * dev->stop function of layered software devices.
3249 void dev_unicast_unsync(struct net_device *to, struct net_device *from)
3251 netif_addr_lock_bh(from);
3252 netif_addr_lock(to);
3254 __dev_addr_unsync(&to->uc_list, &to->uc_count,
3255 &from->uc_list, &from->uc_count);
3256 __dev_set_rx_mode(to);
3258 netif_addr_unlock(to);
3259 netif_addr_unlock_bh(from);
3261 EXPORT_SYMBOL(dev_unicast_unsync);
3263 static void __dev_addr_discard(struct dev_addr_list **list)
3265 struct dev_addr_list *tmp;
3267 while (*list != NULL) {
3268 tmp = *list;
3269 *list = tmp->next;
3270 if (tmp->da_users > tmp->da_gusers)
3271 printk("__dev_addr_discard: address leakage! "
3272 "da_users=%d\n", tmp->da_users);
3273 kfree(tmp);
3277 static void dev_addr_discard(struct net_device *dev)
3279 netif_addr_lock_bh(dev);
3281 __dev_addr_discard(&dev->uc_list);
3282 dev->uc_count = 0;
3284 __dev_addr_discard(&dev->mc_list);
3285 dev->mc_count = 0;
3287 netif_addr_unlock_bh(dev);
3290 unsigned dev_get_flags(const struct net_device *dev)
3292 unsigned flags;
3294 flags = (dev->flags & ~(IFF_PROMISC |
3295 IFF_ALLMULTI |
3296 IFF_RUNNING |
3297 IFF_LOWER_UP |
3298 IFF_DORMANT)) |
3299 (dev->gflags & (IFF_PROMISC |
3300 IFF_ALLMULTI));
3302 if (netif_running(dev)) {
3303 if (netif_oper_up(dev))
3304 flags |= IFF_RUNNING;
3305 if (netif_carrier_ok(dev))
3306 flags |= IFF_LOWER_UP;
3307 if (netif_dormant(dev))
3308 flags |= IFF_DORMANT;
3311 return flags;
3314 int dev_change_flags(struct net_device *dev, unsigned flags)
3316 int ret, changes;
3317 int old_flags = dev->flags;
3319 ASSERT_RTNL();
3322 * Set the flags on our device.
3325 dev->flags = (flags & (IFF_DEBUG | IFF_NOTRAILERS | IFF_NOARP |
3326 IFF_DYNAMIC | IFF_MULTICAST | IFF_PORTSEL |
3327 IFF_AUTOMEDIA)) |
3328 (dev->flags & (IFF_UP | IFF_VOLATILE | IFF_PROMISC |
3329 IFF_ALLMULTI));
3332 * Load in the correct multicast list now the flags have changed.
3335 if (dev->change_rx_flags && (old_flags ^ flags) & IFF_MULTICAST)
3336 dev->change_rx_flags(dev, IFF_MULTICAST);
3338 dev_set_rx_mode(dev);
3341 * Have we downed the interface. We handle IFF_UP ourselves
3342 * according to user attempts to set it, rather than blindly
3343 * setting it.
3346 ret = 0;
3347 if ((old_flags ^ flags) & IFF_UP) { /* Bit is different ? */
3348 ret = ((old_flags & IFF_UP) ? dev_close : dev_open)(dev);
3350 if (!ret)
3351 dev_set_rx_mode(dev);
3354 if (dev->flags & IFF_UP &&
3355 ((old_flags ^ dev->flags) &~ (IFF_UP | IFF_PROMISC | IFF_ALLMULTI |
3356 IFF_VOLATILE)))
3357 call_netdevice_notifiers(NETDEV_CHANGE, dev);
3359 if ((flags ^ dev->gflags) & IFF_PROMISC) {
3360 int inc = (flags & IFF_PROMISC) ? +1 : -1;
3361 dev->gflags ^= IFF_PROMISC;
3362 dev_set_promiscuity(dev, inc);
3365 /* NOTE: order of synchronization of IFF_PROMISC and IFF_ALLMULTI
3366 is important. Some (broken) drivers set IFF_PROMISC, when
3367 IFF_ALLMULTI is requested not asking us and not reporting.
3369 if ((flags ^ dev->gflags) & IFF_ALLMULTI) {
3370 int inc = (flags & IFF_ALLMULTI) ? +1 : -1;
3371 dev->gflags ^= IFF_ALLMULTI;
3372 dev_set_allmulti(dev, inc);
3375 /* Exclude state transition flags, already notified */
3376 changes = (old_flags ^ dev->flags) & ~(IFF_UP | IFF_RUNNING);
3377 if (changes)
3378 rtmsg_ifinfo(RTM_NEWLINK, dev, changes);
3380 return ret;
3383 int dev_set_mtu(struct net_device *dev, int new_mtu)
3385 int err;
3387 if (new_mtu == dev->mtu)
3388 return 0;
3390 /* MTU must be positive. */
3391 if (new_mtu < 0)
3392 return -EINVAL;
3394 if (!netif_device_present(dev))
3395 return -ENODEV;
3397 err = 0;
3398 if (dev->change_mtu)
3399 err = dev->change_mtu(dev, new_mtu);
3400 else
3401 dev->mtu = new_mtu;
3402 if (!err && dev->flags & IFF_UP)
3403 call_netdevice_notifiers(NETDEV_CHANGEMTU, dev);
3404 return err;
3407 int dev_set_mac_address(struct net_device *dev, struct sockaddr *sa)
3409 int err;
3411 if (!dev->set_mac_address)
3412 return -EOPNOTSUPP;
3413 if (sa->sa_family != dev->type)
3414 return -EINVAL;
3415 if (!netif_device_present(dev))
3416 return -ENODEV;
3417 err = dev->set_mac_address(dev, sa);
3418 if (!err)
3419 call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
3420 return err;
3424 * Perform the SIOCxIFxxx calls, inside read_lock(dev_base_lock)
3426 static int dev_ifsioc_locked(struct net *net, struct ifreq *ifr, unsigned int cmd)
3428 int err;
3429 struct net_device *dev = __dev_get_by_name(net, ifr->ifr_name);
3431 if (!dev)
3432 return -ENODEV;
3434 switch (cmd) {
3435 case SIOCGIFFLAGS: /* Get interface flags */
3436 ifr->ifr_flags = dev_get_flags(dev);
3437 return 0;
3439 case SIOCGIFMETRIC: /* Get the metric on the interface
3440 (currently unused) */
3441 ifr->ifr_metric = 0;
3442 return 0;
3444 case SIOCGIFMTU: /* Get the MTU of a device */
3445 ifr->ifr_mtu = dev->mtu;
3446 return 0;
3448 case SIOCGIFHWADDR:
3449 if (!dev->addr_len)
3450 memset(ifr->ifr_hwaddr.sa_data, 0, sizeof ifr->ifr_hwaddr.sa_data);
3451 else
3452 memcpy(ifr->ifr_hwaddr.sa_data, dev->dev_addr,
3453 min(sizeof ifr->ifr_hwaddr.sa_data, (size_t) dev->addr_len));
3454 ifr->ifr_hwaddr.sa_family = dev->type;
3455 return 0;
3457 case SIOCGIFSLAVE:
3458 err = -EINVAL;
3459 break;
3461 case SIOCGIFMAP:
3462 ifr->ifr_map.mem_start = dev->mem_start;
3463 ifr->ifr_map.mem_end = dev->mem_end;
3464 ifr->ifr_map.base_addr = dev->base_addr;
3465 ifr->ifr_map.irq = dev->irq;
3466 ifr->ifr_map.dma = dev->dma;
3467 ifr->ifr_map.port = dev->if_port;
3468 return 0;
3470 case SIOCGIFINDEX:
3471 ifr->ifr_ifindex = dev->ifindex;
3472 return 0;
3474 case SIOCGIFTXQLEN:
3475 ifr->ifr_qlen = dev->tx_queue_len;
3476 return 0;
3478 default:
3479 /* dev_ioctl() should ensure this case
3480 * is never reached
3482 WARN_ON(1);
3483 err = -EINVAL;
3484 break;
3487 return err;
3491 * Perform the SIOCxIFxxx calls, inside rtnl_lock()
3493 static int dev_ifsioc(struct net *net, struct ifreq *ifr, unsigned int cmd)
3495 int err;
3496 struct net_device *dev = __dev_get_by_name(net, ifr->ifr_name);
3498 if (!dev)
3499 return -ENODEV;
3501 switch (cmd) {
3502 case SIOCSIFFLAGS: /* Set interface flags */
3503 return dev_change_flags(dev, ifr->ifr_flags);
3505 case SIOCSIFMETRIC: /* Set the metric on the interface
3506 (currently unused) */
3507 return -EOPNOTSUPP;
3509 case SIOCSIFMTU: /* Set the MTU of a device */
3510 return dev_set_mtu(dev, ifr->ifr_mtu);
3512 case SIOCSIFHWADDR:
3513 return dev_set_mac_address(dev, &ifr->ifr_hwaddr);
3515 case SIOCSIFHWBROADCAST:
3516 if (ifr->ifr_hwaddr.sa_family != dev->type)
3517 return -EINVAL;
3518 memcpy(dev->broadcast, ifr->ifr_hwaddr.sa_data,
3519 min(sizeof ifr->ifr_hwaddr.sa_data, (size_t) dev->addr_len));
3520 call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
3521 return 0;
3523 case SIOCSIFMAP:
3524 if (dev->set_config) {
3525 if (!netif_device_present(dev))
3526 return -ENODEV;
3527 return dev->set_config(dev, &ifr->ifr_map);
3529 return -EOPNOTSUPP;
3531 case SIOCADDMULTI:
3532 if ((!dev->set_multicast_list && !dev->set_rx_mode) ||
3533 ifr->ifr_hwaddr.sa_family != AF_UNSPEC)
3534 return -EINVAL;
3535 if (!netif_device_present(dev))
3536 return -ENODEV;
3537 return dev_mc_add(dev, ifr->ifr_hwaddr.sa_data,
3538 dev->addr_len, 1);
3540 case SIOCDELMULTI:
3541 if ((!dev->set_multicast_list && !dev->set_rx_mode) ||
3542 ifr->ifr_hwaddr.sa_family != AF_UNSPEC)
3543 return -EINVAL;
3544 if (!netif_device_present(dev))
3545 return -ENODEV;
3546 return dev_mc_delete(dev, ifr->ifr_hwaddr.sa_data,
3547 dev->addr_len, 1);
3549 case SIOCSIFTXQLEN:
3550 if (ifr->ifr_qlen < 0)
3551 return -EINVAL;
3552 dev->tx_queue_len = ifr->ifr_qlen;
3553 return 0;
3555 case SIOCSIFNAME:
3556 ifr->ifr_newname[IFNAMSIZ-1] = '\0';
3557 return dev_change_name(dev, ifr->ifr_newname);
3560 * Unknown or private ioctl
3563 default:
3564 if ((cmd >= SIOCDEVPRIVATE &&
3565 cmd <= SIOCDEVPRIVATE + 15) ||
3566 cmd == SIOCBONDENSLAVE ||
3567 cmd == SIOCBONDRELEASE ||
3568 cmd == SIOCBONDSETHWADDR ||
3569 cmd == SIOCBONDSLAVEINFOQUERY ||
3570 cmd == SIOCBONDINFOQUERY ||
3571 cmd == SIOCBONDCHANGEACTIVE ||
3572 cmd == SIOCGMIIPHY ||
3573 cmd == SIOCGMIIREG ||
3574 cmd == SIOCSMIIREG ||
3575 cmd == SIOCBRADDIF ||
3576 cmd == SIOCBRDELIF ||
3577 cmd == SIOCWANDEV) {
3578 err = -EOPNOTSUPP;
3579 if (dev->do_ioctl) {
3580 if (netif_device_present(dev))
3581 err = dev->do_ioctl(dev, ifr,
3582 cmd);
3583 else
3584 err = -ENODEV;
3586 } else
3587 err = -EINVAL;
3590 return err;
3594 * This function handles all "interface"-type I/O control requests. The actual
3595 * 'doing' part of this is dev_ifsioc above.
3599 * dev_ioctl - network device ioctl
3600 * @net: the applicable net namespace
3601 * @cmd: command to issue
3602 * @arg: pointer to a struct ifreq in user space
3604 * Issue ioctl functions to devices. This is normally called by the
3605 * user space syscall interfaces but can sometimes be useful for
3606 * other purposes. The return value is the return from the syscall if
3607 * positive or a negative errno code on error.
3610 int dev_ioctl(struct net *net, unsigned int cmd, void __user *arg)
3612 struct ifreq ifr;
3613 int ret;
3614 char *colon;
3616 /* One special case: SIOCGIFCONF takes ifconf argument
3617 and requires shared lock, because it sleeps writing
3618 to user space.
3621 if (cmd == SIOCGIFCONF) {
3622 rtnl_lock();
3623 ret = dev_ifconf(net, (char __user *) arg);
3624 rtnl_unlock();
3625 return ret;
3627 if (cmd == SIOCGIFNAME)
3628 return dev_ifname(net, (struct ifreq __user *)arg);
3630 if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
3631 return -EFAULT;
3633 ifr.ifr_name[IFNAMSIZ-1] = 0;
3635 colon = strchr(ifr.ifr_name, ':');
3636 if (colon)
3637 *colon = 0;
3640 * See which interface the caller is talking about.
3643 switch (cmd) {
3645 * These ioctl calls:
3646 * - can be done by all.
3647 * - atomic and do not require locking.
3648 * - return a value
3650 case SIOCGIFFLAGS:
3651 case SIOCGIFMETRIC:
3652 case SIOCGIFMTU:
3653 case SIOCGIFHWADDR:
3654 case SIOCGIFSLAVE:
3655 case SIOCGIFMAP:
3656 case SIOCGIFINDEX:
3657 case SIOCGIFTXQLEN:
3658 dev_load(net, ifr.ifr_name);
3659 read_lock(&dev_base_lock);
3660 ret = dev_ifsioc_locked(net, &ifr, cmd);
3661 read_unlock(&dev_base_lock);
3662 if (!ret) {
3663 if (colon)
3664 *colon = ':';
3665 if (copy_to_user(arg, &ifr,
3666 sizeof(struct ifreq)))
3667 ret = -EFAULT;
3669 return ret;
3671 case SIOCETHTOOL:
3672 dev_load(net, ifr.ifr_name);
3673 rtnl_lock();
3674 ret = dev_ethtool(net, &ifr);
3675 rtnl_unlock();
3676 if (!ret) {
3677 if (colon)
3678 *colon = ':';
3679 if (copy_to_user(arg, &ifr,
3680 sizeof(struct ifreq)))
3681 ret = -EFAULT;
3683 return ret;
3686 * These ioctl calls:
3687 * - require superuser power.
3688 * - require strict serialization.
3689 * - return a value
3691 case SIOCGMIIPHY:
3692 case SIOCGMIIREG:
3693 case SIOCSIFNAME:
3694 if (!capable(CAP_NET_ADMIN))
3695 return -EPERM;
3696 dev_load(net, ifr.ifr_name);
3697 rtnl_lock();
3698 ret = dev_ifsioc(net, &ifr, cmd);
3699 rtnl_unlock();
3700 if (!ret) {
3701 if (colon)
3702 *colon = ':';
3703 if (copy_to_user(arg, &ifr,
3704 sizeof(struct ifreq)))
3705 ret = -EFAULT;
3707 return ret;
3710 * These ioctl calls:
3711 * - require superuser power.
3712 * - require strict serialization.
3713 * - do not return a value
3715 case SIOCSIFFLAGS:
3716 case SIOCSIFMETRIC:
3717 case SIOCSIFMTU:
3718 case SIOCSIFMAP:
3719 case SIOCSIFHWADDR:
3720 case SIOCSIFSLAVE:
3721 case SIOCADDMULTI:
3722 case SIOCDELMULTI:
3723 case SIOCSIFHWBROADCAST:
3724 case SIOCSIFTXQLEN:
3725 case SIOCSMIIREG:
3726 case SIOCBONDENSLAVE:
3727 case SIOCBONDRELEASE:
3728 case SIOCBONDSETHWADDR:
3729 case SIOCBONDCHANGEACTIVE:
3730 case SIOCBRADDIF:
3731 case SIOCBRDELIF:
3732 if (!capable(CAP_NET_ADMIN))
3733 return -EPERM;
3734 /* fall through */
3735 case SIOCBONDSLAVEINFOQUERY:
3736 case SIOCBONDINFOQUERY:
3737 dev_load(net, ifr.ifr_name);
3738 rtnl_lock();
3739 ret = dev_ifsioc(net, &ifr, cmd);
3740 rtnl_unlock();
3741 return ret;
3743 case SIOCGIFMEM:
3744 /* Get the per device memory space. We can add this but
3745 * currently do not support it */
3746 case SIOCSIFMEM:
3747 /* Set the per device memory buffer space.
3748 * Not applicable in our case */
3749 case SIOCSIFLINK:
3750 return -EINVAL;
3753 * Unknown or private ioctl.
3755 default:
3756 if (cmd == SIOCWANDEV ||
3757 (cmd >= SIOCDEVPRIVATE &&
3758 cmd <= SIOCDEVPRIVATE + 15)) {
3759 dev_load(net, ifr.ifr_name);
3760 rtnl_lock();
3761 ret = dev_ifsioc(net, &ifr, cmd);
3762 rtnl_unlock();
3763 if (!ret && copy_to_user(arg, &ifr,
3764 sizeof(struct ifreq)))
3765 ret = -EFAULT;
3766 return ret;
3768 /* Take care of Wireless Extensions */
3769 if (cmd >= SIOCIWFIRST && cmd <= SIOCIWLAST)
3770 return wext_handle_ioctl(net, &ifr, cmd, arg);
3771 return -EINVAL;
3777 * dev_new_index - allocate an ifindex
3778 * @net: the applicable net namespace
3780 * Returns a suitable unique value for a new device interface
3781 * number. The caller must hold the rtnl semaphore or the
3782 * dev_base_lock to be sure it remains unique.
3784 static int dev_new_index(struct net *net)
3786 static int ifindex;
3787 for (;;) {
3788 if (++ifindex <= 0)
3789 ifindex = 1;
3790 if (!__dev_get_by_index(net, ifindex))
3791 return ifindex;
3795 /* Delayed registration/unregisteration */
3796 static DEFINE_SPINLOCK(net_todo_list_lock);
3797 static LIST_HEAD(net_todo_list);
3799 static void net_set_todo(struct net_device *dev)
3801 spin_lock(&net_todo_list_lock);
3802 list_add_tail(&dev->todo_list, &net_todo_list);
3803 spin_unlock(&net_todo_list_lock);
3806 static void rollback_registered(struct net_device *dev)
3808 BUG_ON(dev_boot_phase);
3809 ASSERT_RTNL();
3811 /* Some devices call without registering for initialization unwind. */
3812 if (dev->reg_state == NETREG_UNINITIALIZED) {
3813 printk(KERN_DEBUG "unregister_netdevice: device %s/%p never "
3814 "was registered\n", dev->name, dev);
3816 WARN_ON(1);
3817 return;
3820 BUG_ON(dev->reg_state != NETREG_REGISTERED);
3822 /* If device is running, close it first. */
3823 dev_close(dev);
3825 /* And unlink it from device chain. */
3826 unlist_netdevice(dev);
3828 dev->reg_state = NETREG_UNREGISTERING;
3830 synchronize_net();
3832 /* Shutdown queueing discipline. */
3833 dev_shutdown(dev);
3836 /* Notify protocols, that we are about to destroy
3837 this device. They should clean all the things.
3839 call_netdevice_notifiers(NETDEV_UNREGISTER, dev);
3842 * Flush the unicast and multicast chains
3844 dev_addr_discard(dev);
3846 if (dev->uninit)
3847 dev->uninit(dev);
3849 /* Notifier chain MUST detach us from master device. */
3850 BUG_TRAP(!dev->master);
3852 /* Remove entries from kobject tree */
3853 netdev_unregister_kobject(dev);
3855 synchronize_net();
3857 dev_put(dev);
3860 static void __netdev_init_queue_locks_one(struct net_device *dev,
3861 struct netdev_queue *dev_queue,
3862 void *_unused)
3864 spin_lock_init(&dev_queue->_xmit_lock);
3865 netdev_set_xmit_lockdep_class(&dev_queue->_xmit_lock, dev->type);
3866 dev_queue->xmit_lock_owner = -1;
3869 static void netdev_init_queue_locks(struct net_device *dev)
3871 netdev_for_each_tx_queue(dev, __netdev_init_queue_locks_one, NULL);
3872 __netdev_init_queue_locks_one(dev, &dev->rx_queue, NULL);
3876 * register_netdevice - register a network device
3877 * @dev: device to register
3879 * Take a completed network device structure and add it to the kernel
3880 * interfaces. A %NETDEV_REGISTER message is sent to the netdev notifier
3881 * chain. 0 is returned on success. A negative errno code is returned
3882 * on a failure to set up the device, or if the name is a duplicate.
3884 * Callers must hold the rtnl semaphore. You may want
3885 * register_netdev() instead of this.
3887 * BUGS:
3888 * The locking appears insufficient to guarantee two parallel registers
3889 * will not get the same name.
3892 int register_netdevice(struct net_device *dev)
3894 struct hlist_head *head;
3895 struct hlist_node *p;
3896 int ret;
3897 struct net *net;
3899 BUG_ON(dev_boot_phase);
3900 ASSERT_RTNL();
3902 might_sleep();
3904 /* When net_device's are persistent, this will be fatal. */
3905 BUG_ON(dev->reg_state != NETREG_UNINITIALIZED);
3906 BUG_ON(!dev_net(dev));
3907 net = dev_net(dev);
3909 spin_lock_init(&dev->addr_list_lock);
3910 netdev_set_addr_lockdep_class(dev);
3911 netdev_init_queue_locks(dev);
3913 dev->iflink = -1;
3915 /* Init, if this function is available */
3916 if (dev->init) {
3917 ret = dev->init(dev);
3918 if (ret) {
3919 if (ret > 0)
3920 ret = -EIO;
3921 goto out;
3925 if (!dev_valid_name(dev->name)) {
3926 ret = -EINVAL;
3927 goto err_uninit;
3930 dev->ifindex = dev_new_index(net);
3931 if (dev->iflink == -1)
3932 dev->iflink = dev->ifindex;
3934 /* Check for existence of name */
3935 head = dev_name_hash(net, dev->name);
3936 hlist_for_each(p, head) {
3937 struct net_device *d
3938 = hlist_entry(p, struct net_device, name_hlist);
3939 if (!strncmp(d->name, dev->name, IFNAMSIZ)) {
3940 ret = -EEXIST;
3941 goto err_uninit;
3945 /* Fix illegal checksum combinations */
3946 if ((dev->features & NETIF_F_HW_CSUM) &&
3947 (dev->features & (NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM))) {
3948 printk(KERN_NOTICE "%s: mixed HW and IP checksum settings.\n",
3949 dev->name);
3950 dev->features &= ~(NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM);
3953 if ((dev->features & NETIF_F_NO_CSUM) &&
3954 (dev->features & (NETIF_F_HW_CSUM|NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM))) {
3955 printk(KERN_NOTICE "%s: mixed no checksumming and other settings.\n",
3956 dev->name);
3957 dev->features &= ~(NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM|NETIF_F_HW_CSUM);
3961 /* Fix illegal SG+CSUM combinations. */
3962 if ((dev->features & NETIF_F_SG) &&
3963 !(dev->features & NETIF_F_ALL_CSUM)) {
3964 printk(KERN_NOTICE "%s: Dropping NETIF_F_SG since no checksum feature.\n",
3965 dev->name);
3966 dev->features &= ~NETIF_F_SG;
3969 /* TSO requires that SG is present as well. */
3970 if ((dev->features & NETIF_F_TSO) &&
3971 !(dev->features & NETIF_F_SG)) {
3972 printk(KERN_NOTICE "%s: Dropping NETIF_F_TSO since no SG feature.\n",
3973 dev->name);
3974 dev->features &= ~NETIF_F_TSO;
3976 if (dev->features & NETIF_F_UFO) {
3977 if (!(dev->features & NETIF_F_HW_CSUM)) {
3978 printk(KERN_ERR "%s: Dropping NETIF_F_UFO since no "
3979 "NETIF_F_HW_CSUM feature.\n",
3980 dev->name);
3981 dev->features &= ~NETIF_F_UFO;
3983 if (!(dev->features & NETIF_F_SG)) {
3984 printk(KERN_ERR "%s: Dropping NETIF_F_UFO since no "
3985 "NETIF_F_SG feature.\n",
3986 dev->name);
3987 dev->features &= ~NETIF_F_UFO;
3991 netdev_initialize_kobject(dev);
3992 ret = netdev_register_kobject(dev);
3993 if (ret)
3994 goto err_uninit;
3995 dev->reg_state = NETREG_REGISTERED;
3998 * Default initial state at registry is that the
3999 * device is present.
4002 set_bit(__LINK_STATE_PRESENT, &dev->state);
4004 dev_init_scheduler(dev);
4005 dev_hold(dev);
4006 list_netdevice(dev);
4008 /* Notify protocols, that a new device appeared. */
4009 ret = call_netdevice_notifiers(NETDEV_REGISTER, dev);
4010 ret = notifier_to_errno(ret);
4011 if (ret) {
4012 rollback_registered(dev);
4013 dev->reg_state = NETREG_UNREGISTERED;
4016 out:
4017 return ret;
4019 err_uninit:
4020 if (dev->uninit)
4021 dev->uninit(dev);
4022 goto out;
4026 * register_netdev - register a network device
4027 * @dev: device to register
4029 * Take a completed network device structure and add it to the kernel
4030 * interfaces. A %NETDEV_REGISTER message is sent to the netdev notifier
4031 * chain. 0 is returned on success. A negative errno code is returned
4032 * on a failure to set up the device, or if the name is a duplicate.
4034 * This is a wrapper around register_netdevice that takes the rtnl semaphore
4035 * and expands the device name if you passed a format string to
4036 * alloc_netdev.
4038 int register_netdev(struct net_device *dev)
4040 int err;
4042 rtnl_lock();
4045 * If the name is a format string the caller wants us to do a
4046 * name allocation.
4048 if (strchr(dev->name, '%')) {
4049 err = dev_alloc_name(dev, dev->name);
4050 if (err < 0)
4051 goto out;
4054 err = register_netdevice(dev);
4055 out:
4056 rtnl_unlock();
4057 return err;
4059 EXPORT_SYMBOL(register_netdev);
4062 * netdev_wait_allrefs - wait until all references are gone.
4064 * This is called when unregistering network devices.
4066 * Any protocol or device that holds a reference should register
4067 * for netdevice notification, and cleanup and put back the
4068 * reference if they receive an UNREGISTER event.
4069 * We can get stuck here if buggy protocols don't correctly
4070 * call dev_put.
4072 static void netdev_wait_allrefs(struct net_device *dev)
4074 unsigned long rebroadcast_time, warning_time;
4076 rebroadcast_time = warning_time = jiffies;
4077 while (atomic_read(&dev->refcnt) != 0) {
4078 if (time_after(jiffies, rebroadcast_time + 1 * HZ)) {
4079 rtnl_lock();
4081 /* Rebroadcast unregister notification */
4082 call_netdevice_notifiers(NETDEV_UNREGISTER, dev);
4084 if (test_bit(__LINK_STATE_LINKWATCH_PENDING,
4085 &dev->state)) {
4086 /* We must not have linkwatch events
4087 * pending on unregister. If this
4088 * happens, we simply run the queue
4089 * unscheduled, resulting in a noop
4090 * for this device.
4092 linkwatch_run_queue();
4095 __rtnl_unlock();
4097 rebroadcast_time = jiffies;
4100 msleep(250);
4102 if (time_after(jiffies, warning_time + 10 * HZ)) {
4103 printk(KERN_EMERG "unregister_netdevice: "
4104 "waiting for %s to become free. Usage "
4105 "count = %d\n",
4106 dev->name, atomic_read(&dev->refcnt));
4107 warning_time = jiffies;
4112 /* The sequence is:
4114 * rtnl_lock();
4115 * ...
4116 * register_netdevice(x1);
4117 * register_netdevice(x2);
4118 * ...
4119 * unregister_netdevice(y1);
4120 * unregister_netdevice(y2);
4121 * ...
4122 * rtnl_unlock();
4123 * free_netdev(y1);
4124 * free_netdev(y2);
4126 * We are invoked by rtnl_unlock() after it drops the semaphore.
4127 * This allows us to deal with problems:
4128 * 1) We can delete sysfs objects which invoke hotplug
4129 * without deadlocking with linkwatch via keventd.
4130 * 2) Since we run with the RTNL semaphore not held, we can sleep
4131 * safely in order to wait for the netdev refcnt to drop to zero.
4133 static DEFINE_MUTEX(net_todo_run_mutex);
4134 void netdev_run_todo(void)
4136 struct list_head list;
4138 /* Need to guard against multiple cpu's getting out of order. */
4139 mutex_lock(&net_todo_run_mutex);
4141 /* Not safe to do outside the semaphore. We must not return
4142 * until all unregister events invoked by the local processor
4143 * have been completed (either by this todo run, or one on
4144 * another cpu).
4146 if (list_empty(&net_todo_list))
4147 goto out;
4149 /* Snapshot list, allow later requests */
4150 spin_lock(&net_todo_list_lock);
4151 list_replace_init(&net_todo_list, &list);
4152 spin_unlock(&net_todo_list_lock);
4154 while (!list_empty(&list)) {
4155 struct net_device *dev
4156 = list_entry(list.next, struct net_device, todo_list);
4157 list_del(&dev->todo_list);
4159 if (unlikely(dev->reg_state != NETREG_UNREGISTERING)) {
4160 printk(KERN_ERR "network todo '%s' but state %d\n",
4161 dev->name, dev->reg_state);
4162 dump_stack();
4163 continue;
4166 dev->reg_state = NETREG_UNREGISTERED;
4168 netdev_wait_allrefs(dev);
4170 /* paranoia */
4171 BUG_ON(atomic_read(&dev->refcnt));
4172 BUG_TRAP(!dev->ip_ptr);
4173 BUG_TRAP(!dev->ip6_ptr);
4174 BUG_TRAP(!dev->dn_ptr);
4176 if (dev->destructor)
4177 dev->destructor(dev);
4179 /* Free network device */
4180 kobject_put(&dev->dev.kobj);
4183 out:
4184 mutex_unlock(&net_todo_run_mutex);
4187 static struct net_device_stats *internal_stats(struct net_device *dev)
4189 return &dev->stats;
4192 static void netdev_init_one_queue(struct net_device *dev,
4193 struct netdev_queue *queue,
4194 void *_unused)
4196 queue->dev = dev;
4199 static void netdev_init_queues(struct net_device *dev)
4201 netdev_init_one_queue(dev, &dev->rx_queue, NULL);
4202 netdev_for_each_tx_queue(dev, netdev_init_one_queue, NULL);
4206 * alloc_netdev_mq - allocate network device
4207 * @sizeof_priv: size of private data to allocate space for
4208 * @name: device name format string
4209 * @setup: callback to initialize device
4210 * @queue_count: the number of subqueues to allocate
4212 * Allocates a struct net_device with private data area for driver use
4213 * and performs basic initialization. Also allocates subquue structs
4214 * for each queue on the device at the end of the netdevice.
4216 struct net_device *alloc_netdev_mq(int sizeof_priv, const char *name,
4217 void (*setup)(struct net_device *), unsigned int queue_count)
4219 struct netdev_queue *tx;
4220 struct net_device *dev;
4221 size_t alloc_size;
4222 void *p;
4224 BUG_ON(strlen(name) >= sizeof(dev->name));
4226 alloc_size = sizeof(struct net_device);
4227 if (sizeof_priv) {
4228 /* ensure 32-byte alignment of private area */
4229 alloc_size = (alloc_size + NETDEV_ALIGN_CONST) & ~NETDEV_ALIGN_CONST;
4230 alloc_size += sizeof_priv;
4232 /* ensure 32-byte alignment of whole construct */
4233 alloc_size += NETDEV_ALIGN_CONST;
4235 p = kzalloc(alloc_size, GFP_KERNEL);
4236 if (!p) {
4237 printk(KERN_ERR "alloc_netdev: Unable to allocate device.\n");
4238 return NULL;
4241 tx = kcalloc(queue_count, sizeof(struct netdev_queue), GFP_KERNEL);
4242 if (!tx) {
4243 printk(KERN_ERR "alloc_netdev: Unable to allocate "
4244 "tx qdiscs.\n");
4245 kfree(p);
4246 return NULL;
4249 dev = (struct net_device *)
4250 (((long)p + NETDEV_ALIGN_CONST) & ~NETDEV_ALIGN_CONST);
4251 dev->padded = (char *)dev - (char *)p;
4252 dev_net_set(dev, &init_net);
4254 dev->_tx = tx;
4255 dev->num_tx_queues = queue_count;
4256 dev->real_num_tx_queues = queue_count;
4258 if (sizeof_priv) {
4259 dev->priv = ((char *)dev +
4260 ((sizeof(struct net_device) + NETDEV_ALIGN_CONST)
4261 & ~NETDEV_ALIGN_CONST));
4264 dev->gso_max_size = GSO_MAX_SIZE;
4266 netdev_init_queues(dev);
4268 dev->get_stats = internal_stats;
4269 netpoll_netdev_init(dev);
4270 setup(dev);
4271 strcpy(dev->name, name);
4272 return dev;
4274 EXPORT_SYMBOL(alloc_netdev_mq);
4277 * free_netdev - free network device
4278 * @dev: device
4280 * This function does the last stage of destroying an allocated device
4281 * interface. The reference to the device object is released.
4282 * If this is the last reference then it will be freed.
4284 void free_netdev(struct net_device *dev)
4286 release_net(dev_net(dev));
4288 kfree(dev->_tx);
4290 /* Compatibility with error handling in drivers */
4291 if (dev->reg_state == NETREG_UNINITIALIZED) {
4292 kfree((char *)dev - dev->padded);
4293 return;
4296 BUG_ON(dev->reg_state != NETREG_UNREGISTERED);
4297 dev->reg_state = NETREG_RELEASED;
4299 /* will free via device release */
4300 put_device(&dev->dev);
4303 /* Synchronize with packet receive processing. */
4304 void synchronize_net(void)
4306 might_sleep();
4307 synchronize_rcu();
4311 * unregister_netdevice - remove device from the kernel
4312 * @dev: device
4314 * This function shuts down a device interface and removes it
4315 * from the kernel tables.
4317 * Callers must hold the rtnl semaphore. You may want
4318 * unregister_netdev() instead of this.
4321 void unregister_netdevice(struct net_device *dev)
4323 ASSERT_RTNL();
4325 rollback_registered(dev);
4326 /* Finish processing unregister after unlock */
4327 net_set_todo(dev);
4331 * unregister_netdev - remove device from the kernel
4332 * @dev: device
4334 * This function shuts down a device interface and removes it
4335 * from the kernel tables.
4337 * This is just a wrapper for unregister_netdevice that takes
4338 * the rtnl semaphore. In general you want to use this and not
4339 * unregister_netdevice.
4341 void unregister_netdev(struct net_device *dev)
4343 rtnl_lock();
4344 unregister_netdevice(dev);
4345 rtnl_unlock();
4348 EXPORT_SYMBOL(unregister_netdev);
4351 * dev_change_net_namespace - move device to different nethost namespace
4352 * @dev: device
4353 * @net: network namespace
4354 * @pat: If not NULL name pattern to try if the current device name
4355 * is already taken in the destination network namespace.
4357 * This function shuts down a device interface and moves it
4358 * to a new network namespace. On success 0 is returned, on
4359 * a failure a netagive errno code is returned.
4361 * Callers must hold the rtnl semaphore.
4364 int dev_change_net_namespace(struct net_device *dev, struct net *net, const char *pat)
4366 char buf[IFNAMSIZ];
4367 const char *destname;
4368 int err;
4370 ASSERT_RTNL();
4372 /* Don't allow namespace local devices to be moved. */
4373 err = -EINVAL;
4374 if (dev->features & NETIF_F_NETNS_LOCAL)
4375 goto out;
4377 /* Ensure the device has been registrered */
4378 err = -EINVAL;
4379 if (dev->reg_state != NETREG_REGISTERED)
4380 goto out;
4382 /* Get out if there is nothing todo */
4383 err = 0;
4384 if (net_eq(dev_net(dev), net))
4385 goto out;
4387 /* Pick the destination device name, and ensure
4388 * we can use it in the destination network namespace.
4390 err = -EEXIST;
4391 destname = dev->name;
4392 if (__dev_get_by_name(net, destname)) {
4393 /* We get here if we can't use the current device name */
4394 if (!pat)
4395 goto out;
4396 if (!dev_valid_name(pat))
4397 goto out;
4398 if (strchr(pat, '%')) {
4399 if (__dev_alloc_name(net, pat, buf) < 0)
4400 goto out;
4401 destname = buf;
4402 } else
4403 destname = pat;
4404 if (__dev_get_by_name(net, destname))
4405 goto out;
4409 * And now a mini version of register_netdevice unregister_netdevice.
4412 /* If device is running close it first. */
4413 dev_close(dev);
4415 /* And unlink it from device chain */
4416 err = -ENODEV;
4417 unlist_netdevice(dev);
4419 synchronize_net();
4421 /* Shutdown queueing discipline. */
4422 dev_shutdown(dev);
4424 /* Notify protocols, that we are about to destroy
4425 this device. They should clean all the things.
4427 call_netdevice_notifiers(NETDEV_UNREGISTER, dev);
4430 * Flush the unicast and multicast chains
4432 dev_addr_discard(dev);
4434 /* Actually switch the network namespace */
4435 dev_net_set(dev, net);
4437 /* Assign the new device name */
4438 if (destname != dev->name)
4439 strcpy(dev->name, destname);
4441 /* If there is an ifindex conflict assign a new one */
4442 if (__dev_get_by_index(net, dev->ifindex)) {
4443 int iflink = (dev->iflink == dev->ifindex);
4444 dev->ifindex = dev_new_index(net);
4445 if (iflink)
4446 dev->iflink = dev->ifindex;
4449 /* Fixup kobjects */
4450 netdev_unregister_kobject(dev);
4451 err = netdev_register_kobject(dev);
4452 WARN_ON(err);
4454 /* Add the device back in the hashes */
4455 list_netdevice(dev);
4457 /* Notify protocols, that a new device appeared. */
4458 call_netdevice_notifiers(NETDEV_REGISTER, dev);
4460 synchronize_net();
4461 err = 0;
4462 out:
4463 return err;
4466 static int dev_cpu_callback(struct notifier_block *nfb,
4467 unsigned long action,
4468 void *ocpu)
4470 struct sk_buff **list_skb;
4471 struct Qdisc **list_net;
4472 struct sk_buff *skb;
4473 unsigned int cpu, oldcpu = (unsigned long)ocpu;
4474 struct softnet_data *sd, *oldsd;
4476 if (action != CPU_DEAD && action != CPU_DEAD_FROZEN)
4477 return NOTIFY_OK;
4479 local_irq_disable();
4480 cpu = smp_processor_id();
4481 sd = &per_cpu(softnet_data, cpu);
4482 oldsd = &per_cpu(softnet_data, oldcpu);
4484 /* Find end of our completion_queue. */
4485 list_skb = &sd->completion_queue;
4486 while (*list_skb)
4487 list_skb = &(*list_skb)->next;
4488 /* Append completion queue from offline CPU. */
4489 *list_skb = oldsd->completion_queue;
4490 oldsd->completion_queue = NULL;
4492 /* Find end of our output_queue. */
4493 list_net = &sd->output_queue;
4494 while (*list_net)
4495 list_net = &(*list_net)->next_sched;
4496 /* Append output queue from offline CPU. */
4497 *list_net = oldsd->output_queue;
4498 oldsd->output_queue = NULL;
4500 raise_softirq_irqoff(NET_TX_SOFTIRQ);
4501 local_irq_enable();
4503 /* Process offline CPU's input_pkt_queue */
4504 while ((skb = __skb_dequeue(&oldsd->input_pkt_queue)))
4505 netif_rx(skb);
4507 return NOTIFY_OK;
4510 #ifdef CONFIG_NET_DMA
4512 * net_dma_rebalance - try to maintain one DMA channel per CPU
4513 * @net_dma: DMA client and associated data (lock, channels, channel_mask)
4515 * This is called when the number of channels allocated to the net_dma client
4516 * changes. The net_dma client tries to have one DMA channel per CPU.
4519 static void net_dma_rebalance(struct net_dma *net_dma)
4521 unsigned int cpu, i, n, chan_idx;
4522 struct dma_chan *chan;
4524 if (cpus_empty(net_dma->channel_mask)) {
4525 for_each_online_cpu(cpu)
4526 rcu_assign_pointer(per_cpu(softnet_data, cpu).net_dma, NULL);
4527 return;
4530 i = 0;
4531 cpu = first_cpu(cpu_online_map);
4533 for_each_cpu_mask_nr(chan_idx, net_dma->channel_mask) {
4534 chan = net_dma->channels[chan_idx];
4536 n = ((num_online_cpus() / cpus_weight(net_dma->channel_mask))
4537 + (i < (num_online_cpus() %
4538 cpus_weight(net_dma->channel_mask)) ? 1 : 0));
4540 while(n) {
4541 per_cpu(softnet_data, cpu).net_dma = chan;
4542 cpu = next_cpu(cpu, cpu_online_map);
4543 n--;
4545 i++;
4550 * netdev_dma_event - event callback for the net_dma_client
4551 * @client: should always be net_dma_client
4552 * @chan: DMA channel for the event
4553 * @state: DMA state to be handled
4555 static enum dma_state_client
4556 netdev_dma_event(struct dma_client *client, struct dma_chan *chan,
4557 enum dma_state state)
4559 int i, found = 0, pos = -1;
4560 struct net_dma *net_dma =
4561 container_of(client, struct net_dma, client);
4562 enum dma_state_client ack = DMA_DUP; /* default: take no action */
4564 spin_lock(&net_dma->lock);
4565 switch (state) {
4566 case DMA_RESOURCE_AVAILABLE:
4567 for (i = 0; i < nr_cpu_ids; i++)
4568 if (net_dma->channels[i] == chan) {
4569 found = 1;
4570 break;
4571 } else if (net_dma->channels[i] == NULL && pos < 0)
4572 pos = i;
4574 if (!found && pos >= 0) {
4575 ack = DMA_ACK;
4576 net_dma->channels[pos] = chan;
4577 cpu_set(pos, net_dma->channel_mask);
4578 net_dma_rebalance(net_dma);
4580 break;
4581 case DMA_RESOURCE_REMOVED:
4582 for (i = 0; i < nr_cpu_ids; i++)
4583 if (net_dma->channels[i] == chan) {
4584 found = 1;
4585 pos = i;
4586 break;
4589 if (found) {
4590 ack = DMA_ACK;
4591 cpu_clear(pos, net_dma->channel_mask);
4592 net_dma->channels[i] = NULL;
4593 net_dma_rebalance(net_dma);
4595 break;
4596 default:
4597 break;
4599 spin_unlock(&net_dma->lock);
4601 return ack;
4605 * netdev_dma_regiser - register the networking subsystem as a DMA client
4607 static int __init netdev_dma_register(void)
4609 net_dma.channels = kzalloc(nr_cpu_ids * sizeof(struct net_dma),
4610 GFP_KERNEL);
4611 if (unlikely(!net_dma.channels)) {
4612 printk(KERN_NOTICE
4613 "netdev_dma: no memory for net_dma.channels\n");
4614 return -ENOMEM;
4616 spin_lock_init(&net_dma.lock);
4617 dma_cap_set(DMA_MEMCPY, net_dma.client.cap_mask);
4618 dma_async_client_register(&net_dma.client);
4619 dma_async_client_chan_request(&net_dma.client);
4620 return 0;
4623 #else
4624 static int __init netdev_dma_register(void) { return -ENODEV; }
4625 #endif /* CONFIG_NET_DMA */
4628 * netdev_compute_feature - compute conjunction of two feature sets
4629 * @all: first feature set
4630 * @one: second feature set
4632 * Computes a new feature set after adding a device with feature set
4633 * @one to the master device with current feature set @all. Returns
4634 * the new feature set.
4636 int netdev_compute_features(unsigned long all, unsigned long one)
4638 /* if device needs checksumming, downgrade to hw checksumming */
4639 if (all & NETIF_F_NO_CSUM && !(one & NETIF_F_NO_CSUM))
4640 all ^= NETIF_F_NO_CSUM | NETIF_F_HW_CSUM;
4642 /* if device can't do all checksum, downgrade to ipv4/ipv6 */
4643 if (all & NETIF_F_HW_CSUM && !(one & NETIF_F_HW_CSUM))
4644 all ^= NETIF_F_HW_CSUM
4645 | NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM;
4647 if (one & NETIF_F_GSO)
4648 one |= NETIF_F_GSO_SOFTWARE;
4649 one |= NETIF_F_GSO;
4651 /* If even one device supports robust GSO, enable it for all. */
4652 if (one & NETIF_F_GSO_ROBUST)
4653 all |= NETIF_F_GSO_ROBUST;
4655 all &= one | NETIF_F_LLTX;
4657 if (!(all & NETIF_F_ALL_CSUM))
4658 all &= ~NETIF_F_SG;
4659 if (!(all & NETIF_F_SG))
4660 all &= ~NETIF_F_GSO_MASK;
4662 return all;
4664 EXPORT_SYMBOL(netdev_compute_features);
4666 static struct hlist_head *netdev_create_hash(void)
4668 int i;
4669 struct hlist_head *hash;
4671 hash = kmalloc(sizeof(*hash) * NETDEV_HASHENTRIES, GFP_KERNEL);
4672 if (hash != NULL)
4673 for (i = 0; i < NETDEV_HASHENTRIES; i++)
4674 INIT_HLIST_HEAD(&hash[i]);
4676 return hash;
4679 /* Initialize per network namespace state */
4680 static int __net_init netdev_init(struct net *net)
4682 INIT_LIST_HEAD(&net->dev_base_head);
4684 net->dev_name_head = netdev_create_hash();
4685 if (net->dev_name_head == NULL)
4686 goto err_name;
4688 net->dev_index_head = netdev_create_hash();
4689 if (net->dev_index_head == NULL)
4690 goto err_idx;
4692 return 0;
4694 err_idx:
4695 kfree(net->dev_name_head);
4696 err_name:
4697 return -ENOMEM;
4700 char *netdev_drivername(struct net_device *dev, char *buffer, int len)
4702 struct device_driver *driver;
4703 struct device *parent;
4705 if (len <= 0 || !buffer)
4706 return buffer;
4707 buffer[0] = 0;
4709 parent = dev->dev.parent;
4711 if (!parent)
4712 return buffer;
4714 driver = parent->driver;
4715 if (driver && driver->name)
4716 strlcpy(buffer, driver->name, len);
4717 return buffer;
4720 static void __net_exit netdev_exit(struct net *net)
4722 kfree(net->dev_name_head);
4723 kfree(net->dev_index_head);
4726 static struct pernet_operations __net_initdata netdev_net_ops = {
4727 .init = netdev_init,
4728 .exit = netdev_exit,
4731 static void __net_exit default_device_exit(struct net *net)
4733 struct net_device *dev, *next;
4735 * Push all migratable of the network devices back to the
4736 * initial network namespace
4738 rtnl_lock();
4739 for_each_netdev_safe(net, dev, next) {
4740 int err;
4741 char fb_name[IFNAMSIZ];
4743 /* Ignore unmoveable devices (i.e. loopback) */
4744 if (dev->features & NETIF_F_NETNS_LOCAL)
4745 continue;
4747 /* Push remaing network devices to init_net */
4748 snprintf(fb_name, IFNAMSIZ, "dev%d", dev->ifindex);
4749 err = dev_change_net_namespace(dev, &init_net, fb_name);
4750 if (err) {
4751 printk(KERN_EMERG "%s: failed to move %s to init_net: %d\n",
4752 __func__, dev->name, err);
4753 BUG();
4756 rtnl_unlock();
4759 static struct pernet_operations __net_initdata default_device_ops = {
4760 .exit = default_device_exit,
4764 * Initialize the DEV module. At boot time this walks the device list and
4765 * unhooks any devices that fail to initialise (normally hardware not
4766 * present) and leaves us with a valid list of present and active devices.
4771 * This is called single threaded during boot, so no need
4772 * to take the rtnl semaphore.
4774 static int __init net_dev_init(void)
4776 int i, rc = -ENOMEM;
4778 BUG_ON(!dev_boot_phase);
4780 if (dev_proc_init())
4781 goto out;
4783 if (netdev_kobject_init())
4784 goto out;
4786 INIT_LIST_HEAD(&ptype_all);
4787 for (i = 0; i < PTYPE_HASH_SIZE; i++)
4788 INIT_LIST_HEAD(&ptype_base[i]);
4790 if (register_pernet_subsys(&netdev_net_ops))
4791 goto out;
4793 if (register_pernet_device(&default_device_ops))
4794 goto out;
4797 * Initialise the packet receive queues.
4800 for_each_possible_cpu(i) {
4801 struct softnet_data *queue;
4803 queue = &per_cpu(softnet_data, i);
4804 skb_queue_head_init(&queue->input_pkt_queue);
4805 queue->completion_queue = NULL;
4806 INIT_LIST_HEAD(&queue->poll_list);
4808 queue->backlog.poll = process_backlog;
4809 queue->backlog.weight = weight_p;
4812 netdev_dma_register();
4814 dev_boot_phase = 0;
4816 open_softirq(NET_TX_SOFTIRQ, net_tx_action);
4817 open_softirq(NET_RX_SOFTIRQ, net_rx_action);
4819 hotcpu_notifier(dev_cpu_callback, 0);
4820 dst_init();
4821 dev_mcast_init();
4822 rc = 0;
4823 out:
4824 return rc;
4827 subsys_initcall(net_dev_init);
4829 EXPORT_SYMBOL(__dev_get_by_index);
4830 EXPORT_SYMBOL(__dev_get_by_name);
4831 EXPORT_SYMBOL(__dev_remove_pack);
4832 EXPORT_SYMBOL(dev_valid_name);
4833 EXPORT_SYMBOL(dev_add_pack);
4834 EXPORT_SYMBOL(dev_alloc_name);
4835 EXPORT_SYMBOL(dev_close);
4836 EXPORT_SYMBOL(dev_get_by_flags);
4837 EXPORT_SYMBOL(dev_get_by_index);
4838 EXPORT_SYMBOL(dev_get_by_name);
4839 EXPORT_SYMBOL(dev_open);
4840 EXPORT_SYMBOL(dev_queue_xmit);
4841 EXPORT_SYMBOL(dev_remove_pack);
4842 EXPORT_SYMBOL(dev_set_allmulti);
4843 EXPORT_SYMBOL(dev_set_promiscuity);
4844 EXPORT_SYMBOL(dev_change_flags);
4845 EXPORT_SYMBOL(dev_set_mtu);
4846 EXPORT_SYMBOL(dev_set_mac_address);
4847 EXPORT_SYMBOL(free_netdev);
4848 EXPORT_SYMBOL(netdev_boot_setup_check);
4849 EXPORT_SYMBOL(netdev_set_master);
4850 EXPORT_SYMBOL(netdev_state_change);
4851 EXPORT_SYMBOL(netif_receive_skb);
4852 EXPORT_SYMBOL(netif_rx);
4853 EXPORT_SYMBOL(register_gifconf);
4854 EXPORT_SYMBOL(register_netdevice);
4855 EXPORT_SYMBOL(register_netdevice_notifier);
4856 EXPORT_SYMBOL(skb_checksum_help);
4857 EXPORT_SYMBOL(synchronize_net);
4858 EXPORT_SYMBOL(unregister_netdevice);
4859 EXPORT_SYMBOL(unregister_netdevice_notifier);
4860 EXPORT_SYMBOL(net_enable_timestamp);
4861 EXPORT_SYMBOL(net_disable_timestamp);
4862 EXPORT_SYMBOL(dev_get_flags);
4864 #if defined(CONFIG_BRIDGE) || defined(CONFIG_BRIDGE_MODULE)
4865 EXPORT_SYMBOL(br_handle_frame_hook);
4866 EXPORT_SYMBOL(br_fdb_get_hook);
4867 EXPORT_SYMBOL(br_fdb_put_hook);
4868 #endif
4870 #ifdef CONFIG_KMOD
4871 EXPORT_SYMBOL(dev_load);
4872 #endif
4874 EXPORT_PER_CPU_SYMBOL(softnet_data);