2 * NET3 Protocol independent device support routines.
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License
6 * as published by the Free Software Foundation; either version
7 * 2 of the License, or (at your option) any later version.
9 * Derived from the non IP parts of dev.c 1.0.19
11 * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
12 * Mark Evans, <evansmp@uhura.aston.ac.uk>
15 * Florian la Roche <rzsfl@rz.uni-sb.de>
16 * Alan Cox <gw4pts@gw4pts.ampr.org>
17 * David Hinds <dahinds@users.sourceforge.net>
18 * Alexey Kuznetsov <kuznet@ms2.inr.ac.ru>
19 * Adam Sulmicki <adam@cfar.umd.edu>
20 * Pekka Riikonen <priikone@poesidon.pspt.fi>
23 * D.J. Barrow : Fixed bug where dev->refcnt gets set
24 * to 2 if register_netdev gets called
25 * before net_dev_init & also removed a
26 * few lines of code in the process.
27 * Alan Cox : device private ioctl copies fields back.
28 * Alan Cox : Transmit queue code does relevant
29 * stunts to keep the queue safe.
30 * Alan Cox : Fixed double lock.
31 * Alan Cox : Fixed promisc NULL pointer trap
32 * ???????? : Support the full private ioctl range
33 * Alan Cox : Moved ioctl permission check into
35 * Tim Kordas : SIOCADDMULTI/SIOCDELMULTI
36 * Alan Cox : 100 backlog just doesn't cut it when
37 * you start doing multicast video 8)
38 * Alan Cox : Rewrote net_bh and list manager.
39 * Alan Cox : Fix ETH_P_ALL echoback lengths.
40 * Alan Cox : Took out transmit every packet pass
41 * Saved a few bytes in the ioctl handler
42 * Alan Cox : Network driver sets packet type before
43 * calling netif_rx. Saves a function
45 * Alan Cox : Hashed net_bh()
46 * Richard Kooijman: Timestamp fixes.
47 * Alan Cox : Wrong field in SIOCGIFDSTADDR
48 * Alan Cox : Device lock protection.
49 * Alan Cox : Fixed nasty side effect of device close
51 * Rudi Cilibrasi : Pass the right thing to
53 * Dave Miller : 32bit quantity for the device lock to
54 * make it work out on a Sparc.
55 * Bjorn Ekwall : Added KERNELD hack.
56 * Alan Cox : Cleaned up the backlog initialise.
57 * Craig Metz : SIOCGIFCONF fix if space for under
59 * Thomas Bogendoerfer : Return ENODEV for dev_open, if there
60 * is no device open function.
61 * Andi Kleen : Fix error reporting for SIOCGIFCONF
62 * Michael Chastain : Fix signed/unsigned for SIOCGIFCONF
63 * Cyrus Durgin : Cleaned for KMOD
64 * Adam Sulmicki : Bug Fix : Network Device Unload
65 * A network device unload needs to purge
67 * Paul Rusty Russell : SIOCSIFNAME
68 * Pekka Riikonen : Netdev boot-time settings code
69 * Andrew Morton : Make unregister_netdevice wait
70 * indefinitely on dev->refcnt
71 * J Hadi Salim : - Backlog queue sampling
72 * - netif_rx() feedback
75 #include <asm/uaccess.h>
76 #include <asm/system.h>
77 #include <linux/bitops.h>
78 #include <linux/capability.h>
79 #include <linux/cpu.h>
80 #include <linux/types.h>
81 #include <linux/kernel.h>
82 #include <linux/sched.h>
83 #include <linux/mutex.h>
84 #include <linux/string.h>
86 #include <linux/socket.h>
87 #include <linux/sockios.h>
88 #include <linux/errno.h>
89 #include <linux/interrupt.h>
90 #include <linux/if_ether.h>
91 #include <linux/netdevice.h>
92 #include <linux/etherdevice.h>
93 #include <linux/ethtool.h>
94 #include <linux/notifier.h>
95 #include <linux/skbuff.h>
96 #include <net/net_namespace.h>
98 #include <linux/rtnetlink.h>
99 #include <linux/proc_fs.h>
100 #include <linux/seq_file.h>
101 #include <linux/stat.h>
102 #include <linux/if_bridge.h>
103 #include <linux/if_macvlan.h>
105 #include <net/pkt_sched.h>
106 #include <net/checksum.h>
107 #include <linux/highmem.h>
108 #include <linux/init.h>
109 #include <linux/kmod.h>
110 #include <linux/module.h>
111 #include <linux/kallsyms.h>
112 #include <linux/netpoll.h>
113 #include <linux/rcupdate.h>
114 #include <linux/delay.h>
115 #include <net/wext.h>
116 #include <net/iw_handler.h>
117 #include <asm/current.h>
118 #include <linux/audit.h>
119 #include <linux/dmaengine.h>
120 #include <linux/err.h>
121 #include <linux/ctype.h>
122 #include <linux/if_arp.h>
123 #include <linux/if_vlan.h>
124 #include <linux/ip.h>
125 #include <linux/ipv6.h>
126 #include <linux/in.h>
128 #include "net-sysfs.h"
131 * The list of packet types we will receive (as opposed to discard)
132 * and the routines to invoke.
134 * Why 16. Because with 16 the only overlap we get on a hash of the
135 * low nibble of the protocol value is RARP/SNAP/X.25.
137 * NOTE: That is no longer true with the addition of VLAN tags. Not
138 * sure which should go first, but I bet it won't make much
139 * difference if we are running VLANs. The good news is that
140 * this protocol won't be in the list unless compiled in, so
141 * the average user (w/out VLANs) will not be adversely affected.
158 #define PTYPE_HASH_SIZE (16)
159 #define PTYPE_HASH_MASK (PTYPE_HASH_SIZE - 1)
161 static DEFINE_SPINLOCK(ptype_lock
);
162 static struct list_head ptype_base
[PTYPE_HASH_SIZE
] __read_mostly
;
163 static struct list_head ptype_all __read_mostly
; /* Taps */
165 #ifdef CONFIG_NET_DMA
167 struct dma_client client
;
169 cpumask_t channel_mask
;
170 struct dma_chan
**channels
;
173 static enum dma_state_client
174 netdev_dma_event(struct dma_client
*client
, struct dma_chan
*chan
,
175 enum dma_state state
);
177 static struct net_dma net_dma
= {
179 .event_callback
= netdev_dma_event
,
185 * The @dev_base_head list is protected by @dev_base_lock and the rtnl
188 * Pure readers hold dev_base_lock for reading.
190 * Writers must hold the rtnl semaphore while they loop through the
191 * dev_base_head list, and hold dev_base_lock for writing when they do the
192 * actual updates. This allows pure readers to access the list even
193 * while a writer is preparing to update it.
195 * To put it another way, dev_base_lock is held for writing only to
196 * protect against pure readers; the rtnl semaphore provides the
197 * protection against other writers.
199 * See, for example usages, register_netdevice() and
200 * unregister_netdevice(), which must be called with the rtnl
203 DEFINE_RWLOCK(dev_base_lock
);
205 EXPORT_SYMBOL(dev_base_lock
);
207 #define NETDEV_HASHBITS 8
208 #define NETDEV_HASHENTRIES (1 << NETDEV_HASHBITS)
210 static inline struct hlist_head
*dev_name_hash(struct net
*net
, const char *name
)
212 unsigned hash
= full_name_hash(name
, strnlen(name
, IFNAMSIZ
));
213 return &net
->dev_name_head
[hash
& ((1 << NETDEV_HASHBITS
) - 1)];
216 static inline struct hlist_head
*dev_index_hash(struct net
*net
, int ifindex
)
218 return &net
->dev_index_head
[ifindex
& ((1 << NETDEV_HASHBITS
) - 1)];
221 /* Device list insertion */
222 static int list_netdevice(struct net_device
*dev
)
224 struct net
*net
= dev_net(dev
);
228 write_lock_bh(&dev_base_lock
);
229 list_add_tail(&dev
->dev_list
, &net
->dev_base_head
);
230 hlist_add_head(&dev
->name_hlist
, dev_name_hash(net
, dev
->name
));
231 hlist_add_head(&dev
->index_hlist
, dev_index_hash(net
, dev
->ifindex
));
232 write_unlock_bh(&dev_base_lock
);
236 /* Device list removal */
237 static void unlist_netdevice(struct net_device
*dev
)
241 /* Unlink dev from the device chain */
242 write_lock_bh(&dev_base_lock
);
243 list_del(&dev
->dev_list
);
244 hlist_del(&dev
->name_hlist
);
245 hlist_del(&dev
->index_hlist
);
246 write_unlock_bh(&dev_base_lock
);
253 static RAW_NOTIFIER_HEAD(netdev_chain
);
256 * Device drivers call our routines to queue packets here. We empty the
257 * queue in the local softnet handler.
260 DEFINE_PER_CPU(struct softnet_data
, softnet_data
);
262 #ifdef CONFIG_DEBUG_LOCK_ALLOC
264 * register_netdevice() inits txq->_xmit_lock and sets lockdep class
265 * according to dev->type
267 static const unsigned short netdev_lock_type
[] =
268 {ARPHRD_NETROM
, ARPHRD_ETHER
, ARPHRD_EETHER
, ARPHRD_AX25
,
269 ARPHRD_PRONET
, ARPHRD_CHAOS
, ARPHRD_IEEE802
, ARPHRD_ARCNET
,
270 ARPHRD_APPLETLK
, ARPHRD_DLCI
, ARPHRD_ATM
, ARPHRD_METRICOM
,
271 ARPHRD_IEEE1394
, ARPHRD_EUI64
, ARPHRD_INFINIBAND
, ARPHRD_SLIP
,
272 ARPHRD_CSLIP
, ARPHRD_SLIP6
, ARPHRD_CSLIP6
, ARPHRD_RSRVD
,
273 ARPHRD_ADAPT
, ARPHRD_ROSE
, ARPHRD_X25
, ARPHRD_HWX25
,
274 ARPHRD_PPP
, ARPHRD_CISCO
, ARPHRD_LAPB
, ARPHRD_DDCMP
,
275 ARPHRD_RAWHDLC
, ARPHRD_TUNNEL
, ARPHRD_TUNNEL6
, ARPHRD_FRAD
,
276 ARPHRD_SKIP
, ARPHRD_LOOPBACK
, ARPHRD_LOCALTLK
, ARPHRD_FDDI
,
277 ARPHRD_BIF
, ARPHRD_SIT
, ARPHRD_IPDDP
, ARPHRD_IPGRE
,
278 ARPHRD_PIMREG
, ARPHRD_HIPPI
, ARPHRD_ASH
, ARPHRD_ECONET
,
279 ARPHRD_IRDA
, ARPHRD_FCPP
, ARPHRD_FCAL
, ARPHRD_FCPL
,
280 ARPHRD_FCFABRIC
, ARPHRD_IEEE802_TR
, ARPHRD_IEEE80211
,
281 ARPHRD_IEEE80211_PRISM
, ARPHRD_IEEE80211_RADIOTAP
, ARPHRD_VOID
,
284 static const char *netdev_lock_name
[] =
285 {"_xmit_NETROM", "_xmit_ETHER", "_xmit_EETHER", "_xmit_AX25",
286 "_xmit_PRONET", "_xmit_CHAOS", "_xmit_IEEE802", "_xmit_ARCNET",
287 "_xmit_APPLETLK", "_xmit_DLCI", "_xmit_ATM", "_xmit_METRICOM",
288 "_xmit_IEEE1394", "_xmit_EUI64", "_xmit_INFINIBAND", "_xmit_SLIP",
289 "_xmit_CSLIP", "_xmit_SLIP6", "_xmit_CSLIP6", "_xmit_RSRVD",
290 "_xmit_ADAPT", "_xmit_ROSE", "_xmit_X25", "_xmit_HWX25",
291 "_xmit_PPP", "_xmit_CISCO", "_xmit_LAPB", "_xmit_DDCMP",
292 "_xmit_RAWHDLC", "_xmit_TUNNEL", "_xmit_TUNNEL6", "_xmit_FRAD",
293 "_xmit_SKIP", "_xmit_LOOPBACK", "_xmit_LOCALTLK", "_xmit_FDDI",
294 "_xmit_BIF", "_xmit_SIT", "_xmit_IPDDP", "_xmit_IPGRE",
295 "_xmit_PIMREG", "_xmit_HIPPI", "_xmit_ASH", "_xmit_ECONET",
296 "_xmit_IRDA", "_xmit_FCPP", "_xmit_FCAL", "_xmit_FCPL",
297 "_xmit_FCFABRIC", "_xmit_IEEE802_TR", "_xmit_IEEE80211",
298 "_xmit_IEEE80211_PRISM", "_xmit_IEEE80211_RADIOTAP", "_xmit_VOID",
301 static struct lock_class_key netdev_xmit_lock_key
[ARRAY_SIZE(netdev_lock_type
)];
303 static inline unsigned short netdev_lock_pos(unsigned short dev_type
)
307 for (i
= 0; i
< ARRAY_SIZE(netdev_lock_type
); i
++)
308 if (netdev_lock_type
[i
] == dev_type
)
310 /* the last key is used by default */
311 return ARRAY_SIZE(netdev_lock_type
) - 1;
314 static inline void netdev_set_lockdep_class(spinlock_t
*lock
,
315 unsigned short dev_type
)
319 i
= netdev_lock_pos(dev_type
);
320 lockdep_set_class_and_name(lock
, &netdev_xmit_lock_key
[i
],
321 netdev_lock_name
[i
]);
324 static inline void netdev_set_lockdep_class(spinlock_t
*lock
,
325 unsigned short dev_type
)
330 /*******************************************************************************
332 Protocol management and registration routines
334 *******************************************************************************/
337 * Add a protocol ID to the list. Now that the input handler is
338 * smarter we can dispense with all the messy stuff that used to be
341 * BEWARE!!! Protocol handlers, mangling input packets,
342 * MUST BE last in hash buckets and checking protocol handlers
343 * MUST start from promiscuous ptype_all chain in net_bh.
344 * It is true now, do not change it.
345 * Explanation follows: if protocol handler, mangling packet, will
346 * be the first on list, it is not able to sense, that packet
347 * is cloned and should be copied-on-write, so that it will
348 * change it and subsequent readers will get broken packet.
353 * dev_add_pack - add packet handler
354 * @pt: packet type declaration
356 * Add a protocol handler to the networking stack. The passed &packet_type
357 * is linked into kernel lists and may not be freed until it has been
358 * removed from the kernel lists.
360 * This call does not sleep therefore it can not
361 * guarantee all CPU's that are in middle of receiving packets
362 * will see the new packet type (until the next received packet).
365 void dev_add_pack(struct packet_type
*pt
)
369 spin_lock_bh(&ptype_lock
);
370 if (pt
->type
== htons(ETH_P_ALL
))
371 list_add_rcu(&pt
->list
, &ptype_all
);
373 hash
= ntohs(pt
->type
) & PTYPE_HASH_MASK
;
374 list_add_rcu(&pt
->list
, &ptype_base
[hash
]);
376 spin_unlock_bh(&ptype_lock
);
380 * __dev_remove_pack - remove packet handler
381 * @pt: packet type declaration
383 * Remove a protocol handler that was previously added to the kernel
384 * protocol handlers by dev_add_pack(). The passed &packet_type is removed
385 * from the kernel lists and can be freed or reused once this function
388 * The packet type might still be in use by receivers
389 * and must not be freed until after all the CPU's have gone
390 * through a quiescent state.
392 void __dev_remove_pack(struct packet_type
*pt
)
394 struct list_head
*head
;
395 struct packet_type
*pt1
;
397 spin_lock_bh(&ptype_lock
);
399 if (pt
->type
== htons(ETH_P_ALL
))
402 head
= &ptype_base
[ntohs(pt
->type
) & PTYPE_HASH_MASK
];
404 list_for_each_entry(pt1
, head
, list
) {
406 list_del_rcu(&pt
->list
);
411 printk(KERN_WARNING
"dev_remove_pack: %p not found.\n", pt
);
413 spin_unlock_bh(&ptype_lock
);
416 * dev_remove_pack - remove packet handler
417 * @pt: packet type declaration
419 * Remove a protocol handler that was previously added to the kernel
420 * protocol handlers by dev_add_pack(). The passed &packet_type is removed
421 * from the kernel lists and can be freed or reused once this function
424 * This call sleeps to guarantee that no CPU is looking at the packet
427 void dev_remove_pack(struct packet_type
*pt
)
429 __dev_remove_pack(pt
);
434 /******************************************************************************
436 Device Boot-time Settings Routines
438 *******************************************************************************/
440 /* Boot time configuration table */
441 static struct netdev_boot_setup dev_boot_setup
[NETDEV_BOOT_SETUP_MAX
];
444 * netdev_boot_setup_add - add new setup entry
445 * @name: name of the device
446 * @map: configured settings for the device
448 * Adds new setup entry to the dev_boot_setup list. The function
449 * returns 0 on error and 1 on success. This is a generic routine to
452 static int netdev_boot_setup_add(char *name
, struct ifmap
*map
)
454 struct netdev_boot_setup
*s
;
458 for (i
= 0; i
< NETDEV_BOOT_SETUP_MAX
; i
++) {
459 if (s
[i
].name
[0] == '\0' || s
[i
].name
[0] == ' ') {
460 memset(s
[i
].name
, 0, sizeof(s
[i
].name
));
461 strlcpy(s
[i
].name
, name
, IFNAMSIZ
);
462 memcpy(&s
[i
].map
, map
, sizeof(s
[i
].map
));
467 return i
>= NETDEV_BOOT_SETUP_MAX
? 0 : 1;
471 * netdev_boot_setup_check - check boot time settings
472 * @dev: the netdevice
474 * Check boot time settings for the device.
475 * The found settings are set for the device to be used
476 * later in the device probing.
477 * Returns 0 if no settings found, 1 if they are.
479 int netdev_boot_setup_check(struct net_device
*dev
)
481 struct netdev_boot_setup
*s
= dev_boot_setup
;
484 for (i
= 0; i
< NETDEV_BOOT_SETUP_MAX
; i
++) {
485 if (s
[i
].name
[0] != '\0' && s
[i
].name
[0] != ' ' &&
486 !strcmp(dev
->name
, s
[i
].name
)) {
487 dev
->irq
= s
[i
].map
.irq
;
488 dev
->base_addr
= s
[i
].map
.base_addr
;
489 dev
->mem_start
= s
[i
].map
.mem_start
;
490 dev
->mem_end
= s
[i
].map
.mem_end
;
499 * netdev_boot_base - get address from boot time settings
500 * @prefix: prefix for network device
501 * @unit: id for network device
503 * Check boot time settings for the base address of device.
504 * The found settings are set for the device to be used
505 * later in the device probing.
506 * Returns 0 if no settings found.
508 unsigned long netdev_boot_base(const char *prefix
, int unit
)
510 const struct netdev_boot_setup
*s
= dev_boot_setup
;
514 sprintf(name
, "%s%d", prefix
, unit
);
517 * If device already registered then return base of 1
518 * to indicate not to probe for this interface
520 if (__dev_get_by_name(&init_net
, name
))
523 for (i
= 0; i
< NETDEV_BOOT_SETUP_MAX
; i
++)
524 if (!strcmp(name
, s
[i
].name
))
525 return s
[i
].map
.base_addr
;
530 * Saves at boot time configured settings for any netdevice.
532 int __init
netdev_boot_setup(char *str
)
537 str
= get_options(str
, ARRAY_SIZE(ints
), ints
);
542 memset(&map
, 0, sizeof(map
));
546 map
.base_addr
= ints
[2];
548 map
.mem_start
= ints
[3];
550 map
.mem_end
= ints
[4];
552 /* Add new entry to the list */
553 return netdev_boot_setup_add(str
, &map
);
556 __setup("netdev=", netdev_boot_setup
);
558 /*******************************************************************************
560 Device Interface Subroutines
562 *******************************************************************************/
565 * __dev_get_by_name - find a device by its name
566 * @net: the applicable net namespace
567 * @name: name to find
569 * Find an interface by name. Must be called under RTNL semaphore
570 * or @dev_base_lock. If the name is found a pointer to the device
571 * is returned. If the name is not found then %NULL is returned. The
572 * reference counters are not incremented so the caller must be
573 * careful with locks.
576 struct net_device
*__dev_get_by_name(struct net
*net
, const char *name
)
578 struct hlist_node
*p
;
580 hlist_for_each(p
, dev_name_hash(net
, name
)) {
581 struct net_device
*dev
582 = hlist_entry(p
, struct net_device
, name_hlist
);
583 if (!strncmp(dev
->name
, name
, IFNAMSIZ
))
590 * dev_get_by_name - find a device by its name
591 * @net: the applicable net namespace
592 * @name: name to find
594 * Find an interface by name. This can be called from any
595 * context and does its own locking. The returned handle has
596 * the usage count incremented and the caller must use dev_put() to
597 * release it when it is no longer needed. %NULL is returned if no
598 * matching device is found.
601 struct net_device
*dev_get_by_name(struct net
*net
, const char *name
)
603 struct net_device
*dev
;
605 read_lock(&dev_base_lock
);
606 dev
= __dev_get_by_name(net
, name
);
609 read_unlock(&dev_base_lock
);
614 * __dev_get_by_index - find a device by its ifindex
615 * @net: the applicable net namespace
616 * @ifindex: index of device
618 * Search for an interface by index. Returns %NULL if the device
619 * is not found or a pointer to the device. The device has not
620 * had its reference counter increased so the caller must be careful
621 * about locking. The caller must hold either the RTNL semaphore
625 struct net_device
*__dev_get_by_index(struct net
*net
, int ifindex
)
627 struct hlist_node
*p
;
629 hlist_for_each(p
, dev_index_hash(net
, ifindex
)) {
630 struct net_device
*dev
631 = hlist_entry(p
, struct net_device
, index_hlist
);
632 if (dev
->ifindex
== ifindex
)
640 * dev_get_by_index - find a device by its ifindex
641 * @net: the applicable net namespace
642 * @ifindex: index of device
644 * Search for an interface by index. Returns NULL if the device
645 * is not found or a pointer to the device. The device returned has
646 * had a reference added and the pointer is safe until the user calls
647 * dev_put to indicate they have finished with it.
650 struct net_device
*dev_get_by_index(struct net
*net
, int ifindex
)
652 struct net_device
*dev
;
654 read_lock(&dev_base_lock
);
655 dev
= __dev_get_by_index(net
, ifindex
);
658 read_unlock(&dev_base_lock
);
663 * dev_getbyhwaddr - find a device by its hardware address
664 * @net: the applicable net namespace
665 * @type: media type of device
666 * @ha: hardware address
668 * Search for an interface by MAC address. Returns NULL if the device
669 * is not found or a pointer to the device. The caller must hold the
670 * rtnl semaphore. The returned device has not had its ref count increased
671 * and the caller must therefore be careful about locking
674 * If the API was consistent this would be __dev_get_by_hwaddr
677 struct net_device
*dev_getbyhwaddr(struct net
*net
, unsigned short type
, char *ha
)
679 struct net_device
*dev
;
683 for_each_netdev(net
, dev
)
684 if (dev
->type
== type
&&
685 !memcmp(dev
->dev_addr
, ha
, dev
->addr_len
))
691 EXPORT_SYMBOL(dev_getbyhwaddr
);
693 struct net_device
*__dev_getfirstbyhwtype(struct net
*net
, unsigned short type
)
695 struct net_device
*dev
;
698 for_each_netdev(net
, dev
)
699 if (dev
->type
== type
)
705 EXPORT_SYMBOL(__dev_getfirstbyhwtype
);
707 struct net_device
*dev_getfirstbyhwtype(struct net
*net
, unsigned short type
)
709 struct net_device
*dev
;
712 dev
= __dev_getfirstbyhwtype(net
, type
);
719 EXPORT_SYMBOL(dev_getfirstbyhwtype
);
722 * dev_get_by_flags - find any device with given flags
723 * @net: the applicable net namespace
724 * @if_flags: IFF_* values
725 * @mask: bitmask of bits in if_flags to check
727 * Search for any interface with the given flags. Returns NULL if a device
728 * is not found or a pointer to the device. The device returned has
729 * had a reference added and the pointer is safe until the user calls
730 * dev_put to indicate they have finished with it.
733 struct net_device
* dev_get_by_flags(struct net
*net
, unsigned short if_flags
, unsigned short mask
)
735 struct net_device
*dev
, *ret
;
738 read_lock(&dev_base_lock
);
739 for_each_netdev(net
, dev
) {
740 if (((dev
->flags
^ if_flags
) & mask
) == 0) {
746 read_unlock(&dev_base_lock
);
751 * dev_valid_name - check if name is okay for network device
754 * Network device names need to be valid file names to
755 * to allow sysfs to work. We also disallow any kind of
758 int dev_valid_name(const char *name
)
762 if (strlen(name
) >= IFNAMSIZ
)
764 if (!strcmp(name
, ".") || !strcmp(name
, ".."))
768 if (*name
== '/' || isspace(*name
))
776 * __dev_alloc_name - allocate a name for a device
777 * @net: network namespace to allocate the device name in
778 * @name: name format string
779 * @buf: scratch buffer and result name string
781 * Passed a format string - eg "lt%d" it will try and find a suitable
782 * id. It scans list of devices to build up a free map, then chooses
783 * the first empty slot. The caller must hold the dev_base or rtnl lock
784 * while allocating the name and adding the device in order to avoid
786 * Limited to bits_per_byte * page size devices (ie 32K on most platforms).
787 * Returns the number of the unit assigned or a negative errno code.
790 static int __dev_alloc_name(struct net
*net
, const char *name
, char *buf
)
794 const int max_netdevices
= 8*PAGE_SIZE
;
795 unsigned long *inuse
;
796 struct net_device
*d
;
798 p
= strnchr(name
, IFNAMSIZ
-1, '%');
801 * Verify the string as this thing may have come from
802 * the user. There must be either one "%d" and no other "%"
805 if (p
[1] != 'd' || strchr(p
+ 2, '%'))
808 /* Use one page as a bit array of possible slots */
809 inuse
= (unsigned long *) get_zeroed_page(GFP_ATOMIC
);
813 for_each_netdev(net
, d
) {
814 if (!sscanf(d
->name
, name
, &i
))
816 if (i
< 0 || i
>= max_netdevices
)
819 /* avoid cases where sscanf is not exact inverse of printf */
820 snprintf(buf
, IFNAMSIZ
, name
, i
);
821 if (!strncmp(buf
, d
->name
, IFNAMSIZ
))
825 i
= find_first_zero_bit(inuse
, max_netdevices
);
826 free_page((unsigned long) inuse
);
829 snprintf(buf
, IFNAMSIZ
, name
, i
);
830 if (!__dev_get_by_name(net
, buf
))
833 /* It is possible to run out of possible slots
834 * when the name is long and there isn't enough space left
835 * for the digits, or if all bits are used.
841 * dev_alloc_name - allocate a name for a device
843 * @name: name format string
845 * Passed a format string - eg "lt%d" it will try and find a suitable
846 * id. It scans list of devices to build up a free map, then chooses
847 * the first empty slot. The caller must hold the dev_base or rtnl lock
848 * while allocating the name and adding the device in order to avoid
850 * Limited to bits_per_byte * page size devices (ie 32K on most platforms).
851 * Returns the number of the unit assigned or a negative errno code.
854 int dev_alloc_name(struct net_device
*dev
, const char *name
)
860 BUG_ON(!dev_net(dev
));
862 ret
= __dev_alloc_name(net
, name
, buf
);
864 strlcpy(dev
->name
, buf
, IFNAMSIZ
);
870 * dev_change_name - change name of a device
872 * @newname: name (or format string) must be at least IFNAMSIZ
874 * Change name of a device, can pass format strings "eth%d".
877 int dev_change_name(struct net_device
*dev
, char *newname
)
879 char oldname
[IFNAMSIZ
];
885 BUG_ON(!dev_net(dev
));
888 if (dev
->flags
& IFF_UP
)
891 if (!dev_valid_name(newname
))
894 if (strncmp(newname
, dev
->name
, IFNAMSIZ
) == 0)
897 memcpy(oldname
, dev
->name
, IFNAMSIZ
);
899 if (strchr(newname
, '%')) {
900 err
= dev_alloc_name(dev
, newname
);
903 strcpy(newname
, dev
->name
);
905 else if (__dev_get_by_name(net
, newname
))
908 strlcpy(dev
->name
, newname
, IFNAMSIZ
);
911 err
= device_rename(&dev
->dev
, dev
->name
);
913 memcpy(dev
->name
, oldname
, IFNAMSIZ
);
917 write_lock_bh(&dev_base_lock
);
918 hlist_del(&dev
->name_hlist
);
919 hlist_add_head(&dev
->name_hlist
, dev_name_hash(net
, dev
->name
));
920 write_unlock_bh(&dev_base_lock
);
922 ret
= call_netdevice_notifiers(NETDEV_CHANGENAME
, dev
);
923 ret
= notifier_to_errno(ret
);
928 "%s: name change rollback failed: %d.\n",
932 memcpy(dev
->name
, oldname
, IFNAMSIZ
);
941 * netdev_features_change - device changes features
942 * @dev: device to cause notification
944 * Called to indicate a device has changed features.
946 void netdev_features_change(struct net_device
*dev
)
948 call_netdevice_notifiers(NETDEV_FEAT_CHANGE
, dev
);
950 EXPORT_SYMBOL(netdev_features_change
);
953 * netdev_state_change - device changes state
954 * @dev: device to cause notification
956 * Called to indicate a device has changed state. This function calls
957 * the notifier chains for netdev_chain and sends a NEWLINK message
958 * to the routing socket.
960 void netdev_state_change(struct net_device
*dev
)
962 if (dev
->flags
& IFF_UP
) {
963 call_netdevice_notifiers(NETDEV_CHANGE
, dev
);
964 rtmsg_ifinfo(RTM_NEWLINK
, dev
, 0);
968 void netdev_bonding_change(struct net_device
*dev
)
970 call_netdevice_notifiers(NETDEV_BONDING_FAILOVER
, dev
);
972 EXPORT_SYMBOL(netdev_bonding_change
);
975 * dev_load - load a network module
976 * @net: the applicable net namespace
977 * @name: name of interface
979 * If a network interface is not present and the process has suitable
980 * privileges this function loads the module. If module loading is not
981 * available in this kernel then it becomes a nop.
984 void dev_load(struct net
*net
, const char *name
)
986 struct net_device
*dev
;
988 read_lock(&dev_base_lock
);
989 dev
= __dev_get_by_name(net
, name
);
990 read_unlock(&dev_base_lock
);
992 if (!dev
&& capable(CAP_SYS_MODULE
))
993 request_module("%s", name
);
997 * dev_open - prepare an interface for use.
998 * @dev: device to open
1000 * Takes a device from down to up state. The device's private open
1001 * function is invoked and then the multicast lists are loaded. Finally
1002 * the device is moved into the up state and a %NETDEV_UP message is
1003 * sent to the netdev notifier chain.
1005 * Calling this function on an active interface is a nop. On a failure
1006 * a negative errno code is returned.
1008 int dev_open(struct net_device
*dev
)
1018 if (dev
->flags
& IFF_UP
)
1022 * Is it even present?
1024 if (!netif_device_present(dev
))
1028 * Call device private open method
1030 set_bit(__LINK_STATE_START
, &dev
->state
);
1032 if (dev
->validate_addr
)
1033 ret
= dev
->validate_addr(dev
);
1035 if (!ret
&& dev
->open
)
1036 ret
= dev
->open(dev
);
1039 * If it went open OK then:
1043 clear_bit(__LINK_STATE_START
, &dev
->state
);
1048 dev
->flags
|= IFF_UP
;
1051 * Initialize multicasting status
1053 dev_set_rx_mode(dev
);
1056 * Wakeup transmit queue engine
1061 * ... and announce new interface.
1063 call_netdevice_notifiers(NETDEV_UP
, dev
);
1070 * dev_close - shutdown an interface.
1071 * @dev: device to shutdown
1073 * This function moves an active device into down state. A
1074 * %NETDEV_GOING_DOWN is sent to the netdev notifier chain. The device
1075 * is then deactivated and finally a %NETDEV_DOWN is sent to the notifier
1078 int dev_close(struct net_device
*dev
)
1084 if (!(dev
->flags
& IFF_UP
))
1088 * Tell people we are going down, so that they can
1089 * prepare to death, when device is still operating.
1091 call_netdevice_notifiers(NETDEV_GOING_DOWN
, dev
);
1093 clear_bit(__LINK_STATE_START
, &dev
->state
);
1095 /* Synchronize to scheduled poll. We cannot touch poll list,
1096 * it can be even on different cpu. So just clear netif_running().
1098 * dev->stop() will invoke napi_disable() on all of it's
1099 * napi_struct instances on this device.
1101 smp_mb__after_clear_bit(); /* Commit netif_running(). */
1103 dev_deactivate(dev
);
1106 * Call the device specific close. This cannot fail.
1107 * Only if device is UP
1109 * We allow it to be called even after a DETACH hot-plug
1116 * Device is now down.
1119 dev
->flags
&= ~IFF_UP
;
1122 * Tell people we are down
1124 call_netdevice_notifiers(NETDEV_DOWN
, dev
);
1131 * dev_disable_lro - disable Large Receive Offload on a device
1134 * Disable Large Receive Offload (LRO) on a net device. Must be
1135 * called under RTNL. This is needed if received packets may be
1136 * forwarded to another interface.
1138 void dev_disable_lro(struct net_device
*dev
)
1140 if (dev
->ethtool_ops
&& dev
->ethtool_ops
->get_flags
&&
1141 dev
->ethtool_ops
->set_flags
) {
1142 u32 flags
= dev
->ethtool_ops
->get_flags(dev
);
1143 if (flags
& ETH_FLAG_LRO
) {
1144 flags
&= ~ETH_FLAG_LRO
;
1145 dev
->ethtool_ops
->set_flags(dev
, flags
);
1148 WARN_ON(dev
->features
& NETIF_F_LRO
);
1150 EXPORT_SYMBOL(dev_disable_lro
);
1153 static int dev_boot_phase
= 1;
1156 * Device change register/unregister. These are not inline or static
1157 * as we export them to the world.
1161 * register_netdevice_notifier - register a network notifier block
1164 * Register a notifier to be called when network device events occur.
1165 * The notifier passed is linked into the kernel structures and must
1166 * not be reused until it has been unregistered. A negative errno code
1167 * is returned on a failure.
1169 * When registered all registration and up events are replayed
1170 * to the new notifier to allow device to have a race free
1171 * view of the network device list.
1174 int register_netdevice_notifier(struct notifier_block
*nb
)
1176 struct net_device
*dev
;
1177 struct net_device
*last
;
1182 err
= raw_notifier_chain_register(&netdev_chain
, nb
);
1188 for_each_netdev(net
, dev
) {
1189 err
= nb
->notifier_call(nb
, NETDEV_REGISTER
, dev
);
1190 err
= notifier_to_errno(err
);
1194 if (!(dev
->flags
& IFF_UP
))
1197 nb
->notifier_call(nb
, NETDEV_UP
, dev
);
1208 for_each_netdev(net
, dev
) {
1212 if (dev
->flags
& IFF_UP
) {
1213 nb
->notifier_call(nb
, NETDEV_GOING_DOWN
, dev
);
1214 nb
->notifier_call(nb
, NETDEV_DOWN
, dev
);
1216 nb
->notifier_call(nb
, NETDEV_UNREGISTER
, dev
);
1220 raw_notifier_chain_unregister(&netdev_chain
, nb
);
1225 * unregister_netdevice_notifier - unregister a network notifier block
1228 * Unregister a notifier previously registered by
1229 * register_netdevice_notifier(). The notifier is unlinked into the
1230 * kernel structures and may then be reused. A negative errno code
1231 * is returned on a failure.
1234 int unregister_netdevice_notifier(struct notifier_block
*nb
)
1239 err
= raw_notifier_chain_unregister(&netdev_chain
, nb
);
1245 * call_netdevice_notifiers - call all network notifier blocks
1246 * @val: value passed unmodified to notifier function
1247 * @dev: net_device pointer passed unmodified to notifier function
1249 * Call all network notifier blocks. Parameters and return value
1250 * are as for raw_notifier_call_chain().
1253 int call_netdevice_notifiers(unsigned long val
, struct net_device
*dev
)
1255 return raw_notifier_call_chain(&netdev_chain
, val
, dev
);
1258 /* When > 0 there are consumers of rx skb time stamps */
1259 static atomic_t netstamp_needed
= ATOMIC_INIT(0);
1261 void net_enable_timestamp(void)
1263 atomic_inc(&netstamp_needed
);
1266 void net_disable_timestamp(void)
1268 atomic_dec(&netstamp_needed
);
1271 static inline void net_timestamp(struct sk_buff
*skb
)
1273 if (atomic_read(&netstamp_needed
))
1274 __net_timestamp(skb
);
1276 skb
->tstamp
.tv64
= 0;
1280 * Support routine. Sends outgoing frames to any network
1281 * taps currently in use.
1284 static void dev_queue_xmit_nit(struct sk_buff
*skb
, struct net_device
*dev
)
1286 struct packet_type
*ptype
;
1291 list_for_each_entry_rcu(ptype
, &ptype_all
, list
) {
1292 /* Never send packets back to the socket
1293 * they originated from - MvS (miquels@drinkel.ow.org)
1295 if ((ptype
->dev
== dev
|| !ptype
->dev
) &&
1296 (ptype
->af_packet_priv
== NULL
||
1297 (struct sock
*)ptype
->af_packet_priv
!= skb
->sk
)) {
1298 struct sk_buff
*skb2
= skb_clone(skb
, GFP_ATOMIC
);
1302 /* skb->nh should be correctly
1303 set by sender, so that the second statement is
1304 just protection against buggy protocols.
1306 skb_reset_mac_header(skb2
);
1308 if (skb_network_header(skb2
) < skb2
->data
||
1309 skb2
->network_header
> skb2
->tail
) {
1310 if (net_ratelimit())
1311 printk(KERN_CRIT
"protocol %04x is "
1313 skb2
->protocol
, dev
->name
);
1314 skb_reset_network_header(skb2
);
1317 skb2
->transport_header
= skb2
->network_header
;
1318 skb2
->pkt_type
= PACKET_OUTGOING
;
1319 ptype
->func(skb2
, skb
->dev
, ptype
, skb
->dev
);
1326 void __netif_schedule(struct Qdisc
*q
)
1328 BUG_ON(q
== &noop_qdisc
);
1330 if (!test_and_set_bit(__QDISC_STATE_SCHED
, &q
->state
)) {
1331 struct softnet_data
*sd
;
1332 unsigned long flags
;
1334 local_irq_save(flags
);
1335 sd
= &__get_cpu_var(softnet_data
);
1336 q
->next_sched
= sd
->output_queue
;
1337 sd
->output_queue
= q
;
1338 raise_softirq_irqoff(NET_TX_SOFTIRQ
);
1339 local_irq_restore(flags
);
1342 EXPORT_SYMBOL(__netif_schedule
);
1344 void dev_kfree_skb_irq(struct sk_buff
*skb
)
1346 if (atomic_dec_and_test(&skb
->users
)) {
1347 struct softnet_data
*sd
;
1348 unsigned long flags
;
1350 local_irq_save(flags
);
1351 sd
= &__get_cpu_var(softnet_data
);
1352 skb
->next
= sd
->completion_queue
;
1353 sd
->completion_queue
= skb
;
1354 raise_softirq_irqoff(NET_TX_SOFTIRQ
);
1355 local_irq_restore(flags
);
1358 EXPORT_SYMBOL(dev_kfree_skb_irq
);
1360 void dev_kfree_skb_any(struct sk_buff
*skb
)
1362 if (in_irq() || irqs_disabled())
1363 dev_kfree_skb_irq(skb
);
1367 EXPORT_SYMBOL(dev_kfree_skb_any
);
1371 * netif_device_detach - mark device as removed
1372 * @dev: network device
1374 * Mark device as removed from system and therefore no longer available.
1376 void netif_device_detach(struct net_device
*dev
)
1378 if (test_and_clear_bit(__LINK_STATE_PRESENT
, &dev
->state
) &&
1379 netif_running(dev
)) {
1380 netif_stop_queue(dev
);
1383 EXPORT_SYMBOL(netif_device_detach
);
1386 * netif_device_attach - mark device as attached
1387 * @dev: network device
1389 * Mark device as attached from system and restart if needed.
1391 void netif_device_attach(struct net_device
*dev
)
1393 if (!test_and_set_bit(__LINK_STATE_PRESENT
, &dev
->state
) &&
1394 netif_running(dev
)) {
1395 netif_wake_queue(dev
);
1396 __netdev_watchdog_up(dev
);
1399 EXPORT_SYMBOL(netif_device_attach
);
1401 static bool can_checksum_protocol(unsigned long features
, __be16 protocol
)
1403 return ((features
& NETIF_F_GEN_CSUM
) ||
1404 ((features
& NETIF_F_IP_CSUM
) &&
1405 protocol
== htons(ETH_P_IP
)) ||
1406 ((features
& NETIF_F_IPV6_CSUM
) &&
1407 protocol
== htons(ETH_P_IPV6
)));
1410 static bool dev_can_checksum(struct net_device
*dev
, struct sk_buff
*skb
)
1412 if (can_checksum_protocol(dev
->features
, skb
->protocol
))
1415 if (skb
->protocol
== htons(ETH_P_8021Q
)) {
1416 struct vlan_ethhdr
*veh
= (struct vlan_ethhdr
*)skb
->data
;
1417 if (can_checksum_protocol(dev
->features
& dev
->vlan_features
,
1418 veh
->h_vlan_encapsulated_proto
))
1426 * Invalidate hardware checksum when packet is to be mangled, and
1427 * complete checksum manually on outgoing path.
1429 int skb_checksum_help(struct sk_buff
*skb
)
1432 int ret
= 0, offset
;
1434 if (skb
->ip_summed
== CHECKSUM_COMPLETE
)
1435 goto out_set_summed
;
1437 if (unlikely(skb_shinfo(skb
)->gso_size
)) {
1438 /* Let GSO fix up the checksum. */
1439 goto out_set_summed
;
1442 offset
= skb
->csum_start
- skb_headroom(skb
);
1443 BUG_ON(offset
>= skb_headlen(skb
));
1444 csum
= skb_checksum(skb
, offset
, skb
->len
- offset
, 0);
1446 offset
+= skb
->csum_offset
;
1447 BUG_ON(offset
+ sizeof(__sum16
) > skb_headlen(skb
));
1449 if (skb_cloned(skb
) &&
1450 !skb_clone_writable(skb
, offset
+ sizeof(__sum16
))) {
1451 ret
= pskb_expand_head(skb
, 0, 0, GFP_ATOMIC
);
1456 *(__sum16
*)(skb
->data
+ offset
) = csum_fold(csum
);
1458 skb
->ip_summed
= CHECKSUM_NONE
;
1464 * skb_gso_segment - Perform segmentation on skb.
1465 * @skb: buffer to segment
1466 * @features: features for the output path (see dev->features)
1468 * This function segments the given skb and returns a list of segments.
1470 * It may return NULL if the skb requires no segmentation. This is
1471 * only possible when GSO is used for verifying header integrity.
1473 struct sk_buff
*skb_gso_segment(struct sk_buff
*skb
, int features
)
1475 struct sk_buff
*segs
= ERR_PTR(-EPROTONOSUPPORT
);
1476 struct packet_type
*ptype
;
1477 __be16 type
= skb
->protocol
;
1480 BUG_ON(skb_shinfo(skb
)->frag_list
);
1482 skb_reset_mac_header(skb
);
1483 skb
->mac_len
= skb
->network_header
- skb
->mac_header
;
1484 __skb_pull(skb
, skb
->mac_len
);
1486 if (WARN_ON(skb
->ip_summed
!= CHECKSUM_PARTIAL
)) {
1487 if (skb_header_cloned(skb
) &&
1488 (err
= pskb_expand_head(skb
, 0, 0, GFP_ATOMIC
)))
1489 return ERR_PTR(err
);
1493 list_for_each_entry_rcu(ptype
,
1494 &ptype_base
[ntohs(type
) & PTYPE_HASH_MASK
], list
) {
1495 if (ptype
->type
== type
&& !ptype
->dev
&& ptype
->gso_segment
) {
1496 if (unlikely(skb
->ip_summed
!= CHECKSUM_PARTIAL
)) {
1497 err
= ptype
->gso_send_check(skb
);
1498 segs
= ERR_PTR(err
);
1499 if (err
|| skb_gso_ok(skb
, features
))
1501 __skb_push(skb
, (skb
->data
-
1502 skb_network_header(skb
)));
1504 segs
= ptype
->gso_segment(skb
, features
);
1510 __skb_push(skb
, skb
->data
- skb_mac_header(skb
));
1515 EXPORT_SYMBOL(skb_gso_segment
);
1517 /* Take action when hardware reception checksum errors are detected. */
1519 void netdev_rx_csum_fault(struct net_device
*dev
)
1521 if (net_ratelimit()) {
1522 printk(KERN_ERR
"%s: hw csum failure.\n",
1523 dev
? dev
->name
: "<unknown>");
1527 EXPORT_SYMBOL(netdev_rx_csum_fault
);
1530 /* Actually, we should eliminate this check as soon as we know, that:
1531 * 1. IOMMU is present and allows to map all the memory.
1532 * 2. No high memory really exists on this machine.
1535 static inline int illegal_highdma(struct net_device
*dev
, struct sk_buff
*skb
)
1537 #ifdef CONFIG_HIGHMEM
1540 if (dev
->features
& NETIF_F_HIGHDMA
)
1543 for (i
= 0; i
< skb_shinfo(skb
)->nr_frags
; i
++)
1544 if (PageHighMem(skb_shinfo(skb
)->frags
[i
].page
))
1552 void (*destructor
)(struct sk_buff
*skb
);
1555 #define DEV_GSO_CB(skb) ((struct dev_gso_cb *)(skb)->cb)
1557 static void dev_gso_skb_destructor(struct sk_buff
*skb
)
1559 struct dev_gso_cb
*cb
;
1562 struct sk_buff
*nskb
= skb
->next
;
1564 skb
->next
= nskb
->next
;
1567 } while (skb
->next
);
1569 cb
= DEV_GSO_CB(skb
);
1571 cb
->destructor(skb
);
1575 * dev_gso_segment - Perform emulated hardware segmentation on skb.
1576 * @skb: buffer to segment
1578 * This function segments the given skb and stores the list of segments
1581 static int dev_gso_segment(struct sk_buff
*skb
)
1583 struct net_device
*dev
= skb
->dev
;
1584 struct sk_buff
*segs
;
1585 int features
= dev
->features
& ~(illegal_highdma(dev
, skb
) ?
1588 segs
= skb_gso_segment(skb
, features
);
1590 /* Verifying header integrity only. */
1595 return PTR_ERR(segs
);
1598 DEV_GSO_CB(skb
)->destructor
= skb
->destructor
;
1599 skb
->destructor
= dev_gso_skb_destructor
;
1604 int dev_hard_start_xmit(struct sk_buff
*skb
, struct net_device
*dev
,
1605 struct netdev_queue
*txq
)
1607 if (likely(!skb
->next
)) {
1608 if (!list_empty(&ptype_all
))
1609 dev_queue_xmit_nit(skb
, dev
);
1611 if (netif_needs_gso(dev
, skb
)) {
1612 if (unlikely(dev_gso_segment(skb
)))
1618 return dev
->hard_start_xmit(skb
, dev
);
1623 struct sk_buff
*nskb
= skb
->next
;
1626 skb
->next
= nskb
->next
;
1628 rc
= dev
->hard_start_xmit(nskb
, dev
);
1630 nskb
->next
= skb
->next
;
1634 if (unlikely(netif_tx_queue_stopped(txq
) && skb
->next
))
1635 return NETDEV_TX_BUSY
;
1636 } while (skb
->next
);
1638 skb
->destructor
= DEV_GSO_CB(skb
)->destructor
;
1646 * dev_queue_xmit - transmit a buffer
1647 * @skb: buffer to transmit
1649 * Queue a buffer for transmission to a network device. The caller must
1650 * have set the device and priority and built the buffer before calling
1651 * this function. The function can be called from an interrupt.
1653 * A negative errno code is returned on a failure. A success does not
1654 * guarantee the frame will be transmitted as it may be dropped due
1655 * to congestion or traffic shaping.
1657 * -----------------------------------------------------------------------------------
1658 * I notice this method can also return errors from the queue disciplines,
1659 * including NET_XMIT_DROP, which is a positive value. So, errors can also
1662 * Regardless of the return value, the skb is consumed, so it is currently
1663 * difficult to retry a send to this method. (You can bump the ref count
1664 * before sending to hold a reference for retry if you are careful.)
1666 * When calling this method, interrupts MUST be enabled. This is because
1667 * the BH enable code must have IRQs enabled so that it will not deadlock.
1671 static u16
simple_tx_hash(struct net_device
*dev
, struct sk_buff
*skb
)
1673 u32
*addr
, *ports
, hash
, ihl
;
1677 switch (skb
->protocol
) {
1678 case __constant_htons(ETH_P_IP
):
1679 ip_proto
= ip_hdr(skb
)->protocol
;
1680 addr
= &ip_hdr(skb
)->saddr
;
1681 ihl
= ip_hdr(skb
)->ihl
;
1684 case __constant_htons(ETH_P_IPV6
):
1685 ip_proto
= ipv6_hdr(skb
)->nexthdr
;
1686 addr
= &ipv6_hdr(skb
)->saddr
.s6_addr32
[0];
1694 ports
= (u32
*) (skb_network_header(skb
) + (ihl
* 4));
1707 case IPPROTO_UDPLITE
:
1715 return hash
% dev
->real_num_tx_queues
;
1718 static struct netdev_queue
*dev_pick_tx(struct net_device
*dev
,
1719 struct sk_buff
*skb
)
1721 u16 queue_index
= 0;
1723 if (dev
->select_queue
)
1724 queue_index
= dev
->select_queue(dev
, skb
);
1725 else if (dev
->real_num_tx_queues
> 1)
1726 queue_index
= simple_tx_hash(dev
, skb
);
1728 skb_set_queue_mapping(skb
, queue_index
);
1729 return netdev_get_tx_queue(dev
, queue_index
);
1732 int dev_queue_xmit(struct sk_buff
*skb
)
1734 struct net_device
*dev
= skb
->dev
;
1735 struct netdev_queue
*txq
;
1739 /* GSO will handle the following emulations directly. */
1740 if (netif_needs_gso(dev
, skb
))
1743 if (skb_shinfo(skb
)->frag_list
&&
1744 !(dev
->features
& NETIF_F_FRAGLIST
) &&
1745 __skb_linearize(skb
))
1748 /* Fragmented skb is linearized if device does not support SG,
1749 * or if at least one of fragments is in highmem and device
1750 * does not support DMA from it.
1752 if (skb_shinfo(skb
)->nr_frags
&&
1753 (!(dev
->features
& NETIF_F_SG
) || illegal_highdma(dev
, skb
)) &&
1754 __skb_linearize(skb
))
1757 /* If packet is not checksummed and device does not support
1758 * checksumming for this protocol, complete checksumming here.
1760 if (skb
->ip_summed
== CHECKSUM_PARTIAL
) {
1761 skb_set_transport_header(skb
, skb
->csum_start
-
1763 if (!dev_can_checksum(dev
, skb
) && skb_checksum_help(skb
))
1768 /* Disable soft irqs for various locks below. Also
1769 * stops preemption for RCU.
1773 txq
= dev_pick_tx(dev
, skb
);
1774 q
= rcu_dereference(txq
->qdisc
);
1776 #ifdef CONFIG_NET_CLS_ACT
1777 skb
->tc_verd
= SET_TC_AT(skb
->tc_verd
,AT_EGRESS
);
1780 spinlock_t
*root_lock
= qdisc_root_lock(q
);
1782 spin_lock(root_lock
);
1784 rc
= qdisc_enqueue_root(skb
, q
);
1787 spin_unlock(root_lock
);
1789 rc
= rc
== NET_XMIT_BYPASS
? NET_XMIT_SUCCESS
: rc
;
1793 /* The device has no queue. Common case for software devices:
1794 loopback, all the sorts of tunnels...
1796 Really, it is unlikely that netif_tx_lock protection is necessary
1797 here. (f.e. loopback and IP tunnels are clean ignoring statistics
1799 However, it is possible, that they rely on protection
1802 Check this and shot the lock. It is not prone from deadlocks.
1803 Either shot noqueue qdisc, it is even simpler 8)
1805 if (dev
->flags
& IFF_UP
) {
1806 int cpu
= smp_processor_id(); /* ok because BHs are off */
1808 if (txq
->xmit_lock_owner
!= cpu
) {
1810 HARD_TX_LOCK(dev
, txq
, cpu
);
1812 if (!netif_tx_queue_stopped(txq
)) {
1814 if (!dev_hard_start_xmit(skb
, dev
, txq
)) {
1815 HARD_TX_UNLOCK(dev
, txq
);
1819 HARD_TX_UNLOCK(dev
, txq
);
1820 if (net_ratelimit())
1821 printk(KERN_CRIT
"Virtual device %s asks to "
1822 "queue packet!\n", dev
->name
);
1824 /* Recursion is detected! It is possible,
1826 if (net_ratelimit())
1827 printk(KERN_CRIT
"Dead loop on virtual device "
1828 "%s, fix it urgently!\n", dev
->name
);
1833 rcu_read_unlock_bh();
1839 rcu_read_unlock_bh();
1844 /*=======================================================================
1846 =======================================================================*/
1848 int netdev_max_backlog __read_mostly
= 1000;
1849 int netdev_budget __read_mostly
= 300;
1850 int weight_p __read_mostly
= 64; /* old backlog weight */
1852 DEFINE_PER_CPU(struct netif_rx_stats
, netdev_rx_stat
) = { 0, };
1856 * netif_rx - post buffer to the network code
1857 * @skb: buffer to post
1859 * This function receives a packet from a device driver and queues it for
1860 * the upper (protocol) levels to process. It always succeeds. The buffer
1861 * may be dropped during processing for congestion control or by the
1865 * NET_RX_SUCCESS (no congestion)
1866 * NET_RX_DROP (packet was dropped)
1870 int netif_rx(struct sk_buff
*skb
)
1872 struct softnet_data
*queue
;
1873 unsigned long flags
;
1875 /* if netpoll wants it, pretend we never saw it */
1876 if (netpoll_rx(skb
))
1879 if (!skb
->tstamp
.tv64
)
1883 * The code is rearranged so that the path is the most
1884 * short when CPU is congested, but is still operating.
1886 local_irq_save(flags
);
1887 queue
= &__get_cpu_var(softnet_data
);
1889 __get_cpu_var(netdev_rx_stat
).total
++;
1890 if (queue
->input_pkt_queue
.qlen
<= netdev_max_backlog
) {
1891 if (queue
->input_pkt_queue
.qlen
) {
1894 __skb_queue_tail(&queue
->input_pkt_queue
, skb
);
1895 local_irq_restore(flags
);
1896 return NET_RX_SUCCESS
;
1899 napi_schedule(&queue
->backlog
);
1903 __get_cpu_var(netdev_rx_stat
).dropped
++;
1904 local_irq_restore(flags
);
1910 int netif_rx_ni(struct sk_buff
*skb
)
1915 err
= netif_rx(skb
);
1916 if (local_softirq_pending())
1923 EXPORT_SYMBOL(netif_rx_ni
);
1925 static inline struct net_device
*skb_bond(struct sk_buff
*skb
)
1927 struct net_device
*dev
= skb
->dev
;
1930 if (skb_bond_should_drop(skb
)) {
1934 skb
->dev
= dev
->master
;
1941 static void net_tx_action(struct softirq_action
*h
)
1943 struct softnet_data
*sd
= &__get_cpu_var(softnet_data
);
1945 if (sd
->completion_queue
) {
1946 struct sk_buff
*clist
;
1948 local_irq_disable();
1949 clist
= sd
->completion_queue
;
1950 sd
->completion_queue
= NULL
;
1954 struct sk_buff
*skb
= clist
;
1955 clist
= clist
->next
;
1957 BUG_TRAP(!atomic_read(&skb
->users
));
1962 if (sd
->output_queue
) {
1965 local_irq_disable();
1966 head
= sd
->output_queue
;
1967 sd
->output_queue
= NULL
;
1971 struct Qdisc
*q
= head
;
1972 spinlock_t
*root_lock
;
1974 head
= head
->next_sched
;
1976 smp_mb__before_clear_bit();
1977 clear_bit(__QDISC_STATE_SCHED
, &q
->state
);
1979 root_lock
= qdisc_root_lock(q
);
1980 if (spin_trylock(root_lock
)) {
1982 spin_unlock(root_lock
);
1984 __netif_schedule(q
);
1990 static inline int deliver_skb(struct sk_buff
*skb
,
1991 struct packet_type
*pt_prev
,
1992 struct net_device
*orig_dev
)
1994 atomic_inc(&skb
->users
);
1995 return pt_prev
->func(skb
, skb
->dev
, pt_prev
, orig_dev
);
1998 #if defined(CONFIG_BRIDGE) || defined (CONFIG_BRIDGE_MODULE)
1999 /* These hooks defined here for ATM */
2001 struct net_bridge_fdb_entry
*(*br_fdb_get_hook
)(struct net_bridge
*br
,
2002 unsigned char *addr
);
2003 void (*br_fdb_put_hook
)(struct net_bridge_fdb_entry
*ent
) __read_mostly
;
2006 * If bridge module is loaded call bridging hook.
2007 * returns NULL if packet was consumed.
2009 struct sk_buff
*(*br_handle_frame_hook
)(struct net_bridge_port
*p
,
2010 struct sk_buff
*skb
) __read_mostly
;
2011 static inline struct sk_buff
*handle_bridge(struct sk_buff
*skb
,
2012 struct packet_type
**pt_prev
, int *ret
,
2013 struct net_device
*orig_dev
)
2015 struct net_bridge_port
*port
;
2017 if (skb
->pkt_type
== PACKET_LOOPBACK
||
2018 (port
= rcu_dereference(skb
->dev
->br_port
)) == NULL
)
2022 *ret
= deliver_skb(skb
, *pt_prev
, orig_dev
);
2026 return br_handle_frame_hook(port
, skb
);
2029 #define handle_bridge(skb, pt_prev, ret, orig_dev) (skb)
2032 #if defined(CONFIG_MACVLAN) || defined(CONFIG_MACVLAN_MODULE)
2033 struct sk_buff
*(*macvlan_handle_frame_hook
)(struct sk_buff
*skb
) __read_mostly
;
2034 EXPORT_SYMBOL_GPL(macvlan_handle_frame_hook
);
2036 static inline struct sk_buff
*handle_macvlan(struct sk_buff
*skb
,
2037 struct packet_type
**pt_prev
,
2039 struct net_device
*orig_dev
)
2041 if (skb
->dev
->macvlan_port
== NULL
)
2045 *ret
= deliver_skb(skb
, *pt_prev
, orig_dev
);
2048 return macvlan_handle_frame_hook(skb
);
2051 #define handle_macvlan(skb, pt_prev, ret, orig_dev) (skb)
2054 #ifdef CONFIG_NET_CLS_ACT
2055 /* TODO: Maybe we should just force sch_ingress to be compiled in
2056 * when CONFIG_NET_CLS_ACT is? otherwise some useless instructions
2057 * a compare and 2 stores extra right now if we dont have it on
2058 * but have CONFIG_NET_CLS_ACT
2059 * NOTE: This doesnt stop any functionality; if you dont have
2060 * the ingress scheduler, you just cant add policies on ingress.
2063 static int ing_filter(struct sk_buff
*skb
)
2065 struct net_device
*dev
= skb
->dev
;
2066 u32 ttl
= G_TC_RTTL(skb
->tc_verd
);
2067 struct netdev_queue
*rxq
;
2068 int result
= TC_ACT_OK
;
2071 if (MAX_RED_LOOP
< ttl
++) {
2073 "Redir loop detected Dropping packet (%d->%d)\n",
2074 skb
->iif
, dev
->ifindex
);
2078 skb
->tc_verd
= SET_TC_RTTL(skb
->tc_verd
, ttl
);
2079 skb
->tc_verd
= SET_TC_AT(skb
->tc_verd
, AT_INGRESS
);
2081 rxq
= &dev
->rx_queue
;
2085 spin_lock(qdisc_lock(q
));
2086 result
= qdisc_enqueue_root(skb
, q
);
2087 spin_unlock(qdisc_lock(q
));
2093 static inline struct sk_buff
*handle_ing(struct sk_buff
*skb
,
2094 struct packet_type
**pt_prev
,
2095 int *ret
, struct net_device
*orig_dev
)
2097 if (!skb
->dev
->rx_queue
.qdisc
)
2101 *ret
= deliver_skb(skb
, *pt_prev
, orig_dev
);
2104 /* Huh? Why does turning on AF_PACKET affect this? */
2105 skb
->tc_verd
= SET_TC_OK2MUNGE(skb
->tc_verd
);
2108 switch (ing_filter(skb
)) {
2122 * netif_nit_deliver - deliver received packets to network taps
2125 * This function is used to deliver incoming packets to network
2126 * taps. It should be used when the normal netif_receive_skb path
2127 * is bypassed, for example because of VLAN acceleration.
2129 void netif_nit_deliver(struct sk_buff
*skb
)
2131 struct packet_type
*ptype
;
2133 if (list_empty(&ptype_all
))
2136 skb_reset_network_header(skb
);
2137 skb_reset_transport_header(skb
);
2138 skb
->mac_len
= skb
->network_header
- skb
->mac_header
;
2141 list_for_each_entry_rcu(ptype
, &ptype_all
, list
) {
2142 if (!ptype
->dev
|| ptype
->dev
== skb
->dev
)
2143 deliver_skb(skb
, ptype
, skb
->dev
);
2149 * netif_receive_skb - process receive buffer from network
2150 * @skb: buffer to process
2152 * netif_receive_skb() is the main receive data processing function.
2153 * It always succeeds. The buffer may be dropped during processing
2154 * for congestion control or by the protocol layers.
2156 * This function may only be called from softirq context and interrupts
2157 * should be enabled.
2159 * Return values (usually ignored):
2160 * NET_RX_SUCCESS: no congestion
2161 * NET_RX_DROP: packet was dropped
2163 int netif_receive_skb(struct sk_buff
*skb
)
2165 struct packet_type
*ptype
, *pt_prev
;
2166 struct net_device
*orig_dev
;
2167 int ret
= NET_RX_DROP
;
2170 /* if we've gotten here through NAPI, check netpoll */
2171 if (netpoll_receive_skb(skb
))
2174 if (!skb
->tstamp
.tv64
)
2178 skb
->iif
= skb
->dev
->ifindex
;
2180 orig_dev
= skb_bond(skb
);
2185 __get_cpu_var(netdev_rx_stat
).total
++;
2187 skb_reset_network_header(skb
);
2188 skb_reset_transport_header(skb
);
2189 skb
->mac_len
= skb
->network_header
- skb
->mac_header
;
2195 /* Don't receive packets in an exiting network namespace */
2196 if (!net_alive(dev_net(skb
->dev
)))
2199 #ifdef CONFIG_NET_CLS_ACT
2200 if (skb
->tc_verd
& TC_NCLS
) {
2201 skb
->tc_verd
= CLR_TC_NCLS(skb
->tc_verd
);
2206 list_for_each_entry_rcu(ptype
, &ptype_all
, list
) {
2207 if (!ptype
->dev
|| ptype
->dev
== skb
->dev
) {
2209 ret
= deliver_skb(skb
, pt_prev
, orig_dev
);
2214 #ifdef CONFIG_NET_CLS_ACT
2215 skb
= handle_ing(skb
, &pt_prev
, &ret
, orig_dev
);
2221 skb
= handle_bridge(skb
, &pt_prev
, &ret
, orig_dev
);
2224 skb
= handle_macvlan(skb
, &pt_prev
, &ret
, orig_dev
);
2228 type
= skb
->protocol
;
2229 list_for_each_entry_rcu(ptype
,
2230 &ptype_base
[ntohs(type
) & PTYPE_HASH_MASK
], list
) {
2231 if (ptype
->type
== type
&&
2232 (!ptype
->dev
|| ptype
->dev
== skb
->dev
)) {
2234 ret
= deliver_skb(skb
, pt_prev
, orig_dev
);
2240 ret
= pt_prev
->func(skb
, skb
->dev
, pt_prev
, orig_dev
);
2243 /* Jamal, now you will not able to escape explaining
2244 * me how you were going to use this. :-)
2254 static int process_backlog(struct napi_struct
*napi
, int quota
)
2257 struct softnet_data
*queue
= &__get_cpu_var(softnet_data
);
2258 unsigned long start_time
= jiffies
;
2260 napi
->weight
= weight_p
;
2262 struct sk_buff
*skb
;
2263 struct net_device
*dev
;
2265 local_irq_disable();
2266 skb
= __skb_dequeue(&queue
->input_pkt_queue
);
2268 __napi_complete(napi
);
2277 netif_receive_skb(skb
);
2280 } while (++work
< quota
&& jiffies
== start_time
);
2286 * __napi_schedule - schedule for receive
2287 * @n: entry to schedule
2289 * The entry's receive function will be scheduled to run
2291 void __napi_schedule(struct napi_struct
*n
)
2293 unsigned long flags
;
2295 local_irq_save(flags
);
2296 list_add_tail(&n
->poll_list
, &__get_cpu_var(softnet_data
).poll_list
);
2297 __raise_softirq_irqoff(NET_RX_SOFTIRQ
);
2298 local_irq_restore(flags
);
2300 EXPORT_SYMBOL(__napi_schedule
);
2303 static void net_rx_action(struct softirq_action
*h
)
2305 struct list_head
*list
= &__get_cpu_var(softnet_data
).poll_list
;
2306 unsigned long start_time
= jiffies
;
2307 int budget
= netdev_budget
;
2310 local_irq_disable();
2312 while (!list_empty(list
)) {
2313 struct napi_struct
*n
;
2316 /* If softirq window is exhuasted then punt.
2318 * Note that this is a slight policy change from the
2319 * previous NAPI code, which would allow up to 2
2320 * jiffies to pass before breaking out. The test
2321 * used to be "jiffies - start_time > 1".
2323 if (unlikely(budget
<= 0 || jiffies
!= start_time
))
2328 /* Even though interrupts have been re-enabled, this
2329 * access is safe because interrupts can only add new
2330 * entries to the tail of this list, and only ->poll()
2331 * calls can remove this head entry from the list.
2333 n
= list_entry(list
->next
, struct napi_struct
, poll_list
);
2335 have
= netpoll_poll_lock(n
);
2339 /* This NAPI_STATE_SCHED test is for avoiding a race
2340 * with netpoll's poll_napi(). Only the entity which
2341 * obtains the lock and sees NAPI_STATE_SCHED set will
2342 * actually make the ->poll() call. Therefore we avoid
2343 * accidently calling ->poll() when NAPI is not scheduled.
2346 if (test_bit(NAPI_STATE_SCHED
, &n
->state
))
2347 work
= n
->poll(n
, weight
);
2349 WARN_ON_ONCE(work
> weight
);
2353 local_irq_disable();
2355 /* Drivers must not modify the NAPI state if they
2356 * consume the entire weight. In such cases this code
2357 * still "owns" the NAPI instance and therefore can
2358 * move the instance around on the list at-will.
2360 if (unlikely(work
== weight
)) {
2361 if (unlikely(napi_disable_pending(n
)))
2364 list_move_tail(&n
->poll_list
, list
);
2367 netpoll_poll_unlock(have
);
2372 #ifdef CONFIG_NET_DMA
2374 * There may not be any more sk_buffs coming right now, so push
2375 * any pending DMA copies to hardware
2377 if (!cpus_empty(net_dma
.channel_mask
)) {
2379 for_each_cpu_mask_nr(chan_idx
, net_dma
.channel_mask
) {
2380 struct dma_chan
*chan
= net_dma
.channels
[chan_idx
];
2382 dma_async_memcpy_issue_pending(chan
);
2390 __get_cpu_var(netdev_rx_stat
).time_squeeze
++;
2391 __raise_softirq_irqoff(NET_RX_SOFTIRQ
);
2395 static gifconf_func_t
* gifconf_list
[NPROTO
];
2398 * register_gifconf - register a SIOCGIF handler
2399 * @family: Address family
2400 * @gifconf: Function handler
2402 * Register protocol dependent address dumping routines. The handler
2403 * that is passed must not be freed or reused until it has been replaced
2404 * by another handler.
2406 int register_gifconf(unsigned int family
, gifconf_func_t
* gifconf
)
2408 if (family
>= NPROTO
)
2410 gifconf_list
[family
] = gifconf
;
2416 * Map an interface index to its name (SIOCGIFNAME)
2420 * We need this ioctl for efficient implementation of the
2421 * if_indextoname() function required by the IPv6 API. Without
2422 * it, we would have to search all the interfaces to find a
2426 static int dev_ifname(struct net
*net
, struct ifreq __user
*arg
)
2428 struct net_device
*dev
;
2432 * Fetch the caller's info block.
2435 if (copy_from_user(&ifr
, arg
, sizeof(struct ifreq
)))
2438 read_lock(&dev_base_lock
);
2439 dev
= __dev_get_by_index(net
, ifr
.ifr_ifindex
);
2441 read_unlock(&dev_base_lock
);
2445 strcpy(ifr
.ifr_name
, dev
->name
);
2446 read_unlock(&dev_base_lock
);
2448 if (copy_to_user(arg
, &ifr
, sizeof(struct ifreq
)))
2454 * Perform a SIOCGIFCONF call. This structure will change
2455 * size eventually, and there is nothing I can do about it.
2456 * Thus we will need a 'compatibility mode'.
2459 static int dev_ifconf(struct net
*net
, char __user
*arg
)
2462 struct net_device
*dev
;
2469 * Fetch the caller's info block.
2472 if (copy_from_user(&ifc
, arg
, sizeof(struct ifconf
)))
2479 * Loop over the interfaces, and write an info block for each.
2483 for_each_netdev(net
, dev
) {
2484 for (i
= 0; i
< NPROTO
; i
++) {
2485 if (gifconf_list
[i
]) {
2488 done
= gifconf_list
[i
](dev
, NULL
, 0);
2490 done
= gifconf_list
[i
](dev
, pos
+ total
,
2500 * All done. Write the updated control block back to the caller.
2502 ifc
.ifc_len
= total
;
2505 * Both BSD and Solaris return 0 here, so we do too.
2507 return copy_to_user(arg
, &ifc
, sizeof(struct ifconf
)) ? -EFAULT
: 0;
2510 #ifdef CONFIG_PROC_FS
2512 * This is invoked by the /proc filesystem handler to display a device
2515 void *dev_seq_start(struct seq_file
*seq
, loff_t
*pos
)
2516 __acquires(dev_base_lock
)
2518 struct net
*net
= seq_file_net(seq
);
2520 struct net_device
*dev
;
2522 read_lock(&dev_base_lock
);
2524 return SEQ_START_TOKEN
;
2527 for_each_netdev(net
, dev
)
2534 void *dev_seq_next(struct seq_file
*seq
, void *v
, loff_t
*pos
)
2536 struct net
*net
= seq_file_net(seq
);
2538 return v
== SEQ_START_TOKEN
?
2539 first_net_device(net
) : next_net_device((struct net_device
*)v
);
2542 void dev_seq_stop(struct seq_file
*seq
, void *v
)
2543 __releases(dev_base_lock
)
2545 read_unlock(&dev_base_lock
);
2548 static void dev_seq_printf_stats(struct seq_file
*seq
, struct net_device
*dev
)
2550 struct net_device_stats
*stats
= dev
->get_stats(dev
);
2552 seq_printf(seq
, "%6s:%8lu %7lu %4lu %4lu %4lu %5lu %10lu %9lu "
2553 "%8lu %7lu %4lu %4lu %4lu %5lu %7lu %10lu\n",
2554 dev
->name
, stats
->rx_bytes
, stats
->rx_packets
,
2556 stats
->rx_dropped
+ stats
->rx_missed_errors
,
2557 stats
->rx_fifo_errors
,
2558 stats
->rx_length_errors
+ stats
->rx_over_errors
+
2559 stats
->rx_crc_errors
+ stats
->rx_frame_errors
,
2560 stats
->rx_compressed
, stats
->multicast
,
2561 stats
->tx_bytes
, stats
->tx_packets
,
2562 stats
->tx_errors
, stats
->tx_dropped
,
2563 stats
->tx_fifo_errors
, stats
->collisions
,
2564 stats
->tx_carrier_errors
+
2565 stats
->tx_aborted_errors
+
2566 stats
->tx_window_errors
+
2567 stats
->tx_heartbeat_errors
,
2568 stats
->tx_compressed
);
2572 * Called from the PROCfs module. This now uses the new arbitrary sized
2573 * /proc/net interface to create /proc/net/dev
2575 static int dev_seq_show(struct seq_file
*seq
, void *v
)
2577 if (v
== SEQ_START_TOKEN
)
2578 seq_puts(seq
, "Inter-| Receive "
2580 " face |bytes packets errs drop fifo frame "
2581 "compressed multicast|bytes packets errs "
2582 "drop fifo colls carrier compressed\n");
2584 dev_seq_printf_stats(seq
, v
);
2588 static struct netif_rx_stats
*softnet_get_online(loff_t
*pos
)
2590 struct netif_rx_stats
*rc
= NULL
;
2592 while (*pos
< nr_cpu_ids
)
2593 if (cpu_online(*pos
)) {
2594 rc
= &per_cpu(netdev_rx_stat
, *pos
);
2601 static void *softnet_seq_start(struct seq_file
*seq
, loff_t
*pos
)
2603 return softnet_get_online(pos
);
2606 static void *softnet_seq_next(struct seq_file
*seq
, void *v
, loff_t
*pos
)
2609 return softnet_get_online(pos
);
2612 static void softnet_seq_stop(struct seq_file
*seq
, void *v
)
2616 static int softnet_seq_show(struct seq_file
*seq
, void *v
)
2618 struct netif_rx_stats
*s
= v
;
2620 seq_printf(seq
, "%08x %08x %08x %08x %08x %08x %08x %08x %08x\n",
2621 s
->total
, s
->dropped
, s
->time_squeeze
, 0,
2622 0, 0, 0, 0, /* was fastroute */
2627 static const struct seq_operations dev_seq_ops
= {
2628 .start
= dev_seq_start
,
2629 .next
= dev_seq_next
,
2630 .stop
= dev_seq_stop
,
2631 .show
= dev_seq_show
,
2634 static int dev_seq_open(struct inode
*inode
, struct file
*file
)
2636 return seq_open_net(inode
, file
, &dev_seq_ops
,
2637 sizeof(struct seq_net_private
));
2640 static const struct file_operations dev_seq_fops
= {
2641 .owner
= THIS_MODULE
,
2642 .open
= dev_seq_open
,
2644 .llseek
= seq_lseek
,
2645 .release
= seq_release_net
,
2648 static const struct seq_operations softnet_seq_ops
= {
2649 .start
= softnet_seq_start
,
2650 .next
= softnet_seq_next
,
2651 .stop
= softnet_seq_stop
,
2652 .show
= softnet_seq_show
,
2655 static int softnet_seq_open(struct inode
*inode
, struct file
*file
)
2657 return seq_open(file
, &softnet_seq_ops
);
2660 static const struct file_operations softnet_seq_fops
= {
2661 .owner
= THIS_MODULE
,
2662 .open
= softnet_seq_open
,
2664 .llseek
= seq_lseek
,
2665 .release
= seq_release
,
2668 static void *ptype_get_idx(loff_t pos
)
2670 struct packet_type
*pt
= NULL
;
2674 list_for_each_entry_rcu(pt
, &ptype_all
, list
) {
2680 for (t
= 0; t
< PTYPE_HASH_SIZE
; t
++) {
2681 list_for_each_entry_rcu(pt
, &ptype_base
[t
], list
) {
2690 static void *ptype_seq_start(struct seq_file
*seq
, loff_t
*pos
)
2694 return *pos
? ptype_get_idx(*pos
- 1) : SEQ_START_TOKEN
;
2697 static void *ptype_seq_next(struct seq_file
*seq
, void *v
, loff_t
*pos
)
2699 struct packet_type
*pt
;
2700 struct list_head
*nxt
;
2704 if (v
== SEQ_START_TOKEN
)
2705 return ptype_get_idx(0);
2708 nxt
= pt
->list
.next
;
2709 if (pt
->type
== htons(ETH_P_ALL
)) {
2710 if (nxt
!= &ptype_all
)
2713 nxt
= ptype_base
[0].next
;
2715 hash
= ntohs(pt
->type
) & PTYPE_HASH_MASK
;
2717 while (nxt
== &ptype_base
[hash
]) {
2718 if (++hash
>= PTYPE_HASH_SIZE
)
2720 nxt
= ptype_base
[hash
].next
;
2723 return list_entry(nxt
, struct packet_type
, list
);
2726 static void ptype_seq_stop(struct seq_file
*seq
, void *v
)
2732 static void ptype_seq_decode(struct seq_file
*seq
, void *sym
)
2734 #ifdef CONFIG_KALLSYMS
2735 unsigned long offset
= 0, symsize
;
2736 const char *symname
;
2740 symname
= kallsyms_lookup((unsigned long)sym
, &symsize
, &offset
,
2747 modname
= delim
= "";
2748 seq_printf(seq
, "%s%s%s%s+0x%lx", delim
, modname
, delim
,
2754 seq_printf(seq
, "[%p]", sym
);
2757 static int ptype_seq_show(struct seq_file
*seq
, void *v
)
2759 struct packet_type
*pt
= v
;
2761 if (v
== SEQ_START_TOKEN
)
2762 seq_puts(seq
, "Type Device Function\n");
2763 else if (pt
->dev
== NULL
|| dev_net(pt
->dev
) == seq_file_net(seq
)) {
2764 if (pt
->type
== htons(ETH_P_ALL
))
2765 seq_puts(seq
, "ALL ");
2767 seq_printf(seq
, "%04x", ntohs(pt
->type
));
2769 seq_printf(seq
, " %-8s ",
2770 pt
->dev
? pt
->dev
->name
: "");
2771 ptype_seq_decode(seq
, pt
->func
);
2772 seq_putc(seq
, '\n');
2778 static const struct seq_operations ptype_seq_ops
= {
2779 .start
= ptype_seq_start
,
2780 .next
= ptype_seq_next
,
2781 .stop
= ptype_seq_stop
,
2782 .show
= ptype_seq_show
,
2785 static int ptype_seq_open(struct inode
*inode
, struct file
*file
)
2787 return seq_open_net(inode
, file
, &ptype_seq_ops
,
2788 sizeof(struct seq_net_private
));
2791 static const struct file_operations ptype_seq_fops
= {
2792 .owner
= THIS_MODULE
,
2793 .open
= ptype_seq_open
,
2795 .llseek
= seq_lseek
,
2796 .release
= seq_release_net
,
2800 static int __net_init
dev_proc_net_init(struct net
*net
)
2804 if (!proc_net_fops_create(net
, "dev", S_IRUGO
, &dev_seq_fops
))
2806 if (!proc_net_fops_create(net
, "softnet_stat", S_IRUGO
, &softnet_seq_fops
))
2808 if (!proc_net_fops_create(net
, "ptype", S_IRUGO
, &ptype_seq_fops
))
2811 if (wext_proc_init(net
))
2817 proc_net_remove(net
, "ptype");
2819 proc_net_remove(net
, "softnet_stat");
2821 proc_net_remove(net
, "dev");
2825 static void __net_exit
dev_proc_net_exit(struct net
*net
)
2827 wext_proc_exit(net
);
2829 proc_net_remove(net
, "ptype");
2830 proc_net_remove(net
, "softnet_stat");
2831 proc_net_remove(net
, "dev");
2834 static struct pernet_operations __net_initdata dev_proc_ops
= {
2835 .init
= dev_proc_net_init
,
2836 .exit
= dev_proc_net_exit
,
2839 static int __init
dev_proc_init(void)
2841 return register_pernet_subsys(&dev_proc_ops
);
2844 #define dev_proc_init() 0
2845 #endif /* CONFIG_PROC_FS */
2849 * netdev_set_master - set up master/slave pair
2850 * @slave: slave device
2851 * @master: new master device
2853 * Changes the master device of the slave. Pass %NULL to break the
2854 * bonding. The caller must hold the RTNL semaphore. On a failure
2855 * a negative errno code is returned. On success the reference counts
2856 * are adjusted, %RTM_NEWLINK is sent to the routing socket and the
2857 * function returns zero.
2859 int netdev_set_master(struct net_device
*slave
, struct net_device
*master
)
2861 struct net_device
*old
= slave
->master
;
2871 slave
->master
= master
;
2879 slave
->flags
|= IFF_SLAVE
;
2881 slave
->flags
&= ~IFF_SLAVE
;
2883 rtmsg_ifinfo(RTM_NEWLINK
, slave
, IFF_SLAVE
);
2887 static int __dev_set_promiscuity(struct net_device
*dev
, int inc
)
2889 unsigned short old_flags
= dev
->flags
;
2893 dev
->flags
|= IFF_PROMISC
;
2894 dev
->promiscuity
+= inc
;
2895 if (dev
->promiscuity
== 0) {
2898 * If inc causes overflow, untouch promisc and return error.
2901 dev
->flags
&= ~IFF_PROMISC
;
2903 dev
->promiscuity
-= inc
;
2904 printk(KERN_WARNING
"%s: promiscuity touches roof, "
2905 "set promiscuity failed, promiscuity feature "
2906 "of device might be broken.\n", dev
->name
);
2910 if (dev
->flags
!= old_flags
) {
2911 printk(KERN_INFO
"device %s %s promiscuous mode\n",
2912 dev
->name
, (dev
->flags
& IFF_PROMISC
) ? "entered" :
2915 audit_log(current
->audit_context
, GFP_ATOMIC
,
2916 AUDIT_ANOM_PROMISCUOUS
,
2917 "dev=%s prom=%d old_prom=%d auid=%u uid=%u gid=%u ses=%u",
2918 dev
->name
, (dev
->flags
& IFF_PROMISC
),
2919 (old_flags
& IFF_PROMISC
),
2920 audit_get_loginuid(current
),
2921 current
->uid
, current
->gid
,
2922 audit_get_sessionid(current
));
2924 if (dev
->change_rx_flags
)
2925 dev
->change_rx_flags(dev
, IFF_PROMISC
);
2931 * dev_set_promiscuity - update promiscuity count on a device
2935 * Add or remove promiscuity from a device. While the count in the device
2936 * remains above zero the interface remains promiscuous. Once it hits zero
2937 * the device reverts back to normal filtering operation. A negative inc
2938 * value is used to drop promiscuity on the device.
2939 * Return 0 if successful or a negative errno code on error.
2941 int dev_set_promiscuity(struct net_device
*dev
, int inc
)
2943 unsigned short old_flags
= dev
->flags
;
2946 err
= __dev_set_promiscuity(dev
, inc
);
2949 if (dev
->flags
!= old_flags
)
2950 dev_set_rx_mode(dev
);
2955 * dev_set_allmulti - update allmulti count on a device
2959 * Add or remove reception of all multicast frames to a device. While the
2960 * count in the device remains above zero the interface remains listening
2961 * to all interfaces. Once it hits zero the device reverts back to normal
2962 * filtering operation. A negative @inc value is used to drop the counter
2963 * when releasing a resource needing all multicasts.
2964 * Return 0 if successful or a negative errno code on error.
2967 int dev_set_allmulti(struct net_device
*dev
, int inc
)
2969 unsigned short old_flags
= dev
->flags
;
2973 dev
->flags
|= IFF_ALLMULTI
;
2974 dev
->allmulti
+= inc
;
2975 if (dev
->allmulti
== 0) {
2978 * If inc causes overflow, untouch allmulti and return error.
2981 dev
->flags
&= ~IFF_ALLMULTI
;
2983 dev
->allmulti
-= inc
;
2984 printk(KERN_WARNING
"%s: allmulti touches roof, "
2985 "set allmulti failed, allmulti feature of "
2986 "device might be broken.\n", dev
->name
);
2990 if (dev
->flags
^ old_flags
) {
2991 if (dev
->change_rx_flags
)
2992 dev
->change_rx_flags(dev
, IFF_ALLMULTI
);
2993 dev_set_rx_mode(dev
);
2999 * Upload unicast and multicast address lists to device and
3000 * configure RX filtering. When the device doesn't support unicast
3001 * filtering it is put in promiscuous mode while unicast addresses
3004 void __dev_set_rx_mode(struct net_device
*dev
)
3006 /* dev_open will call this function so the list will stay sane. */
3007 if (!(dev
->flags
&IFF_UP
))
3010 if (!netif_device_present(dev
))
3013 if (dev
->set_rx_mode
)
3014 dev
->set_rx_mode(dev
);
3016 /* Unicast addresses changes may only happen under the rtnl,
3017 * therefore calling __dev_set_promiscuity here is safe.
3019 if (dev
->uc_count
> 0 && !dev
->uc_promisc
) {
3020 __dev_set_promiscuity(dev
, 1);
3021 dev
->uc_promisc
= 1;
3022 } else if (dev
->uc_count
== 0 && dev
->uc_promisc
) {
3023 __dev_set_promiscuity(dev
, -1);
3024 dev
->uc_promisc
= 0;
3027 if (dev
->set_multicast_list
)
3028 dev
->set_multicast_list(dev
);
3032 void dev_set_rx_mode(struct net_device
*dev
)
3034 netif_addr_lock_bh(dev
);
3035 __dev_set_rx_mode(dev
);
3036 netif_addr_unlock_bh(dev
);
3039 int __dev_addr_delete(struct dev_addr_list
**list
, int *count
,
3040 void *addr
, int alen
, int glbl
)
3042 struct dev_addr_list
*da
;
3044 for (; (da
= *list
) != NULL
; list
= &da
->next
) {
3045 if (memcmp(da
->da_addr
, addr
, da
->da_addrlen
) == 0 &&
3046 alen
== da
->da_addrlen
) {
3048 int old_glbl
= da
->da_gusers
;
3065 int __dev_addr_add(struct dev_addr_list
**list
, int *count
,
3066 void *addr
, int alen
, int glbl
)
3068 struct dev_addr_list
*da
;
3070 for (da
= *list
; da
!= NULL
; da
= da
->next
) {
3071 if (memcmp(da
->da_addr
, addr
, da
->da_addrlen
) == 0 &&
3072 da
->da_addrlen
== alen
) {
3074 int old_glbl
= da
->da_gusers
;
3084 da
= kzalloc(sizeof(*da
), GFP_ATOMIC
);
3087 memcpy(da
->da_addr
, addr
, alen
);
3088 da
->da_addrlen
= alen
;
3090 da
->da_gusers
= glbl
? 1 : 0;
3098 * dev_unicast_delete - Release secondary unicast address.
3100 * @addr: address to delete
3101 * @alen: length of @addr
3103 * Release reference to a secondary unicast address and remove it
3104 * from the device if the reference count drops to zero.
3106 * The caller must hold the rtnl_mutex.
3108 int dev_unicast_delete(struct net_device
*dev
, void *addr
, int alen
)
3114 netif_addr_lock_bh(dev
);
3115 err
= __dev_addr_delete(&dev
->uc_list
, &dev
->uc_count
, addr
, alen
, 0);
3117 __dev_set_rx_mode(dev
);
3118 netif_addr_unlock_bh(dev
);
3121 EXPORT_SYMBOL(dev_unicast_delete
);
3124 * dev_unicast_add - add a secondary unicast address
3126 * @addr: address to add
3127 * @alen: length of @addr
3129 * Add a secondary unicast address to the device or increase
3130 * the reference count if it already exists.
3132 * The caller must hold the rtnl_mutex.
3134 int dev_unicast_add(struct net_device
*dev
, void *addr
, int alen
)
3140 netif_addr_lock_bh(dev
);
3141 err
= __dev_addr_add(&dev
->uc_list
, &dev
->uc_count
, addr
, alen
, 0);
3143 __dev_set_rx_mode(dev
);
3144 netif_addr_unlock_bh(dev
);
3147 EXPORT_SYMBOL(dev_unicast_add
);
3149 int __dev_addr_sync(struct dev_addr_list
**to
, int *to_count
,
3150 struct dev_addr_list
**from
, int *from_count
)
3152 struct dev_addr_list
*da
, *next
;
3156 while (da
!= NULL
) {
3158 if (!da
->da_synced
) {
3159 err
= __dev_addr_add(to
, to_count
,
3160 da
->da_addr
, da
->da_addrlen
, 0);
3165 } else if (da
->da_users
== 1) {
3166 __dev_addr_delete(to
, to_count
,
3167 da
->da_addr
, da
->da_addrlen
, 0);
3168 __dev_addr_delete(from
, from_count
,
3169 da
->da_addr
, da
->da_addrlen
, 0);
3176 void __dev_addr_unsync(struct dev_addr_list
**to
, int *to_count
,
3177 struct dev_addr_list
**from
, int *from_count
)
3179 struct dev_addr_list
*da
, *next
;
3182 while (da
!= NULL
) {
3184 if (da
->da_synced
) {
3185 __dev_addr_delete(to
, to_count
,
3186 da
->da_addr
, da
->da_addrlen
, 0);
3188 __dev_addr_delete(from
, from_count
,
3189 da
->da_addr
, da
->da_addrlen
, 0);
3196 * dev_unicast_sync - Synchronize device's unicast list to another device
3197 * @to: destination device
3198 * @from: source device
3200 * Add newly added addresses to the destination device and release
3201 * addresses that have no users left. The source device must be
3202 * locked by netif_tx_lock_bh.
3204 * This function is intended to be called from the dev->set_rx_mode
3205 * function of layered software devices.
3207 int dev_unicast_sync(struct net_device
*to
, struct net_device
*from
)
3211 netif_addr_lock_bh(to
);
3212 err
= __dev_addr_sync(&to
->uc_list
, &to
->uc_count
,
3213 &from
->uc_list
, &from
->uc_count
);
3215 __dev_set_rx_mode(to
);
3216 netif_addr_unlock_bh(to
);
3219 EXPORT_SYMBOL(dev_unicast_sync
);
3222 * dev_unicast_unsync - Remove synchronized addresses from the destination device
3223 * @to: destination device
3224 * @from: source device
3226 * Remove all addresses that were added to the destination device by
3227 * dev_unicast_sync(). This function is intended to be called from the
3228 * dev->stop function of layered software devices.
3230 void dev_unicast_unsync(struct net_device
*to
, struct net_device
*from
)
3232 netif_addr_lock_bh(from
);
3233 netif_addr_lock(to
);
3235 __dev_addr_unsync(&to
->uc_list
, &to
->uc_count
,
3236 &from
->uc_list
, &from
->uc_count
);
3237 __dev_set_rx_mode(to
);
3239 netif_addr_unlock(to
);
3240 netif_addr_unlock_bh(from
);
3242 EXPORT_SYMBOL(dev_unicast_unsync
);
3244 static void __dev_addr_discard(struct dev_addr_list
**list
)
3246 struct dev_addr_list
*tmp
;
3248 while (*list
!= NULL
) {
3251 if (tmp
->da_users
> tmp
->da_gusers
)
3252 printk("__dev_addr_discard: address leakage! "
3253 "da_users=%d\n", tmp
->da_users
);
3258 static void dev_addr_discard(struct net_device
*dev
)
3260 netif_addr_lock_bh(dev
);
3262 __dev_addr_discard(&dev
->uc_list
);
3265 __dev_addr_discard(&dev
->mc_list
);
3268 netif_addr_unlock_bh(dev
);
3271 unsigned dev_get_flags(const struct net_device
*dev
)
3275 flags
= (dev
->flags
& ~(IFF_PROMISC
|
3280 (dev
->gflags
& (IFF_PROMISC
|
3283 if (netif_running(dev
)) {
3284 if (netif_oper_up(dev
))
3285 flags
|= IFF_RUNNING
;
3286 if (netif_carrier_ok(dev
))
3287 flags
|= IFF_LOWER_UP
;
3288 if (netif_dormant(dev
))
3289 flags
|= IFF_DORMANT
;
3295 int dev_change_flags(struct net_device
*dev
, unsigned flags
)
3298 int old_flags
= dev
->flags
;
3303 * Set the flags on our device.
3306 dev
->flags
= (flags
& (IFF_DEBUG
| IFF_NOTRAILERS
| IFF_NOARP
|
3307 IFF_DYNAMIC
| IFF_MULTICAST
| IFF_PORTSEL
|
3309 (dev
->flags
& (IFF_UP
| IFF_VOLATILE
| IFF_PROMISC
|
3313 * Load in the correct multicast list now the flags have changed.
3316 if (dev
->change_rx_flags
&& (old_flags
^ flags
) & IFF_MULTICAST
)
3317 dev
->change_rx_flags(dev
, IFF_MULTICAST
);
3319 dev_set_rx_mode(dev
);
3322 * Have we downed the interface. We handle IFF_UP ourselves
3323 * according to user attempts to set it, rather than blindly
3328 if ((old_flags
^ flags
) & IFF_UP
) { /* Bit is different ? */
3329 ret
= ((old_flags
& IFF_UP
) ? dev_close
: dev_open
)(dev
);
3332 dev_set_rx_mode(dev
);
3335 if (dev
->flags
& IFF_UP
&&
3336 ((old_flags
^ dev
->flags
) &~ (IFF_UP
| IFF_PROMISC
| IFF_ALLMULTI
|
3338 call_netdevice_notifiers(NETDEV_CHANGE
, dev
);
3340 if ((flags
^ dev
->gflags
) & IFF_PROMISC
) {
3341 int inc
= (flags
& IFF_PROMISC
) ? +1 : -1;
3342 dev
->gflags
^= IFF_PROMISC
;
3343 dev_set_promiscuity(dev
, inc
);
3346 /* NOTE: order of synchronization of IFF_PROMISC and IFF_ALLMULTI
3347 is important. Some (broken) drivers set IFF_PROMISC, when
3348 IFF_ALLMULTI is requested not asking us and not reporting.
3350 if ((flags
^ dev
->gflags
) & IFF_ALLMULTI
) {
3351 int inc
= (flags
& IFF_ALLMULTI
) ? +1 : -1;
3352 dev
->gflags
^= IFF_ALLMULTI
;
3353 dev_set_allmulti(dev
, inc
);
3356 /* Exclude state transition flags, already notified */
3357 changes
= (old_flags
^ dev
->flags
) & ~(IFF_UP
| IFF_RUNNING
);
3359 rtmsg_ifinfo(RTM_NEWLINK
, dev
, changes
);
3364 int dev_set_mtu(struct net_device
*dev
, int new_mtu
)
3368 if (new_mtu
== dev
->mtu
)
3371 /* MTU must be positive. */
3375 if (!netif_device_present(dev
))
3379 if (dev
->change_mtu
)
3380 err
= dev
->change_mtu(dev
, new_mtu
);
3383 if (!err
&& dev
->flags
& IFF_UP
)
3384 call_netdevice_notifiers(NETDEV_CHANGEMTU
, dev
);
3388 int dev_set_mac_address(struct net_device
*dev
, struct sockaddr
*sa
)
3392 if (!dev
->set_mac_address
)
3394 if (sa
->sa_family
!= dev
->type
)
3396 if (!netif_device_present(dev
))
3398 err
= dev
->set_mac_address(dev
, sa
);
3400 call_netdevice_notifiers(NETDEV_CHANGEADDR
, dev
);
3405 * Perform the SIOCxIFxxx calls, inside read_lock(dev_base_lock)
3407 static int dev_ifsioc_locked(struct net
*net
, struct ifreq
*ifr
, unsigned int cmd
)
3410 struct net_device
*dev
= __dev_get_by_name(net
, ifr
->ifr_name
);
3416 case SIOCGIFFLAGS
: /* Get interface flags */
3417 ifr
->ifr_flags
= dev_get_flags(dev
);
3420 case SIOCGIFMETRIC
: /* Get the metric on the interface
3421 (currently unused) */
3422 ifr
->ifr_metric
= 0;
3425 case SIOCGIFMTU
: /* Get the MTU of a device */
3426 ifr
->ifr_mtu
= dev
->mtu
;
3431 memset(ifr
->ifr_hwaddr
.sa_data
, 0, sizeof ifr
->ifr_hwaddr
.sa_data
);
3433 memcpy(ifr
->ifr_hwaddr
.sa_data
, dev
->dev_addr
,
3434 min(sizeof ifr
->ifr_hwaddr
.sa_data
, (size_t) dev
->addr_len
));
3435 ifr
->ifr_hwaddr
.sa_family
= dev
->type
;
3443 ifr
->ifr_map
.mem_start
= dev
->mem_start
;
3444 ifr
->ifr_map
.mem_end
= dev
->mem_end
;
3445 ifr
->ifr_map
.base_addr
= dev
->base_addr
;
3446 ifr
->ifr_map
.irq
= dev
->irq
;
3447 ifr
->ifr_map
.dma
= dev
->dma
;
3448 ifr
->ifr_map
.port
= dev
->if_port
;
3452 ifr
->ifr_ifindex
= dev
->ifindex
;
3456 ifr
->ifr_qlen
= dev
->tx_queue_len
;
3460 /* dev_ioctl() should ensure this case
3472 * Perform the SIOCxIFxxx calls, inside rtnl_lock()
3474 static int dev_ifsioc(struct net
*net
, struct ifreq
*ifr
, unsigned int cmd
)
3477 struct net_device
*dev
= __dev_get_by_name(net
, ifr
->ifr_name
);
3483 case SIOCSIFFLAGS
: /* Set interface flags */
3484 return dev_change_flags(dev
, ifr
->ifr_flags
);
3486 case SIOCSIFMETRIC
: /* Set the metric on the interface
3487 (currently unused) */
3490 case SIOCSIFMTU
: /* Set the MTU of a device */
3491 return dev_set_mtu(dev
, ifr
->ifr_mtu
);
3494 return dev_set_mac_address(dev
, &ifr
->ifr_hwaddr
);
3496 case SIOCSIFHWBROADCAST
:
3497 if (ifr
->ifr_hwaddr
.sa_family
!= dev
->type
)
3499 memcpy(dev
->broadcast
, ifr
->ifr_hwaddr
.sa_data
,
3500 min(sizeof ifr
->ifr_hwaddr
.sa_data
, (size_t) dev
->addr_len
));
3501 call_netdevice_notifiers(NETDEV_CHANGEADDR
, dev
);
3505 if (dev
->set_config
) {
3506 if (!netif_device_present(dev
))
3508 return dev
->set_config(dev
, &ifr
->ifr_map
);
3513 if ((!dev
->set_multicast_list
&& !dev
->set_rx_mode
) ||
3514 ifr
->ifr_hwaddr
.sa_family
!= AF_UNSPEC
)
3516 if (!netif_device_present(dev
))
3518 return dev_mc_add(dev
, ifr
->ifr_hwaddr
.sa_data
,
3522 if ((!dev
->set_multicast_list
&& !dev
->set_rx_mode
) ||
3523 ifr
->ifr_hwaddr
.sa_family
!= AF_UNSPEC
)
3525 if (!netif_device_present(dev
))
3527 return dev_mc_delete(dev
, ifr
->ifr_hwaddr
.sa_data
,
3531 if (ifr
->ifr_qlen
< 0)
3533 dev
->tx_queue_len
= ifr
->ifr_qlen
;
3537 ifr
->ifr_newname
[IFNAMSIZ
-1] = '\0';
3538 return dev_change_name(dev
, ifr
->ifr_newname
);
3541 * Unknown or private ioctl
3545 if ((cmd
>= SIOCDEVPRIVATE
&&
3546 cmd
<= SIOCDEVPRIVATE
+ 15) ||
3547 cmd
== SIOCBONDENSLAVE
||
3548 cmd
== SIOCBONDRELEASE
||
3549 cmd
== SIOCBONDSETHWADDR
||
3550 cmd
== SIOCBONDSLAVEINFOQUERY
||
3551 cmd
== SIOCBONDINFOQUERY
||
3552 cmd
== SIOCBONDCHANGEACTIVE
||
3553 cmd
== SIOCGMIIPHY
||
3554 cmd
== SIOCGMIIREG
||
3555 cmd
== SIOCSMIIREG
||
3556 cmd
== SIOCBRADDIF
||
3557 cmd
== SIOCBRDELIF
||
3558 cmd
== SIOCWANDEV
) {
3560 if (dev
->do_ioctl
) {
3561 if (netif_device_present(dev
))
3562 err
= dev
->do_ioctl(dev
, ifr
,
3575 * This function handles all "interface"-type I/O control requests. The actual
3576 * 'doing' part of this is dev_ifsioc above.
3580 * dev_ioctl - network device ioctl
3581 * @net: the applicable net namespace
3582 * @cmd: command to issue
3583 * @arg: pointer to a struct ifreq in user space
3585 * Issue ioctl functions to devices. This is normally called by the
3586 * user space syscall interfaces but can sometimes be useful for
3587 * other purposes. The return value is the return from the syscall if
3588 * positive or a negative errno code on error.
3591 int dev_ioctl(struct net
*net
, unsigned int cmd
, void __user
*arg
)
3597 /* One special case: SIOCGIFCONF takes ifconf argument
3598 and requires shared lock, because it sleeps writing
3602 if (cmd
== SIOCGIFCONF
) {
3604 ret
= dev_ifconf(net
, (char __user
*) arg
);
3608 if (cmd
== SIOCGIFNAME
)
3609 return dev_ifname(net
, (struct ifreq __user
*)arg
);
3611 if (copy_from_user(&ifr
, arg
, sizeof(struct ifreq
)))
3614 ifr
.ifr_name
[IFNAMSIZ
-1] = 0;
3616 colon
= strchr(ifr
.ifr_name
, ':');
3621 * See which interface the caller is talking about.
3626 * These ioctl calls:
3627 * - can be done by all.
3628 * - atomic and do not require locking.
3639 dev_load(net
, ifr
.ifr_name
);
3640 read_lock(&dev_base_lock
);
3641 ret
= dev_ifsioc_locked(net
, &ifr
, cmd
);
3642 read_unlock(&dev_base_lock
);
3646 if (copy_to_user(arg
, &ifr
,
3647 sizeof(struct ifreq
)))
3653 dev_load(net
, ifr
.ifr_name
);
3655 ret
= dev_ethtool(net
, &ifr
);
3660 if (copy_to_user(arg
, &ifr
,
3661 sizeof(struct ifreq
)))
3667 * These ioctl calls:
3668 * - require superuser power.
3669 * - require strict serialization.
3675 if (!capable(CAP_NET_ADMIN
))
3677 dev_load(net
, ifr
.ifr_name
);
3679 ret
= dev_ifsioc(net
, &ifr
, cmd
);
3684 if (copy_to_user(arg
, &ifr
,
3685 sizeof(struct ifreq
)))
3691 * These ioctl calls:
3692 * - require superuser power.
3693 * - require strict serialization.
3694 * - do not return a value
3704 case SIOCSIFHWBROADCAST
:
3707 case SIOCBONDENSLAVE
:
3708 case SIOCBONDRELEASE
:
3709 case SIOCBONDSETHWADDR
:
3710 case SIOCBONDCHANGEACTIVE
:
3713 if (!capable(CAP_NET_ADMIN
))
3716 case SIOCBONDSLAVEINFOQUERY
:
3717 case SIOCBONDINFOQUERY
:
3718 dev_load(net
, ifr
.ifr_name
);
3720 ret
= dev_ifsioc(net
, &ifr
, cmd
);
3725 /* Get the per device memory space. We can add this but
3726 * currently do not support it */
3728 /* Set the per device memory buffer space.
3729 * Not applicable in our case */
3734 * Unknown or private ioctl.
3737 if (cmd
== SIOCWANDEV
||
3738 (cmd
>= SIOCDEVPRIVATE
&&
3739 cmd
<= SIOCDEVPRIVATE
+ 15)) {
3740 dev_load(net
, ifr
.ifr_name
);
3742 ret
= dev_ifsioc(net
, &ifr
, cmd
);
3744 if (!ret
&& copy_to_user(arg
, &ifr
,
3745 sizeof(struct ifreq
)))
3749 /* Take care of Wireless Extensions */
3750 if (cmd
>= SIOCIWFIRST
&& cmd
<= SIOCIWLAST
)
3751 return wext_handle_ioctl(net
, &ifr
, cmd
, arg
);
3758 * dev_new_index - allocate an ifindex
3759 * @net: the applicable net namespace
3761 * Returns a suitable unique value for a new device interface
3762 * number. The caller must hold the rtnl semaphore or the
3763 * dev_base_lock to be sure it remains unique.
3765 static int dev_new_index(struct net
*net
)
3771 if (!__dev_get_by_index(net
, ifindex
))
3776 /* Delayed registration/unregisteration */
3777 static DEFINE_SPINLOCK(net_todo_list_lock
);
3778 static LIST_HEAD(net_todo_list
);
3780 static void net_set_todo(struct net_device
*dev
)
3782 spin_lock(&net_todo_list_lock
);
3783 list_add_tail(&dev
->todo_list
, &net_todo_list
);
3784 spin_unlock(&net_todo_list_lock
);
3787 static void rollback_registered(struct net_device
*dev
)
3789 BUG_ON(dev_boot_phase
);
3792 /* Some devices call without registering for initialization unwind. */
3793 if (dev
->reg_state
== NETREG_UNINITIALIZED
) {
3794 printk(KERN_DEBUG
"unregister_netdevice: device %s/%p never "
3795 "was registered\n", dev
->name
, dev
);
3801 BUG_ON(dev
->reg_state
!= NETREG_REGISTERED
);
3803 /* If device is running, close it first. */
3806 /* And unlink it from device chain. */
3807 unlist_netdevice(dev
);
3809 dev
->reg_state
= NETREG_UNREGISTERING
;
3813 /* Shutdown queueing discipline. */
3817 /* Notify protocols, that we are about to destroy
3818 this device. They should clean all the things.
3820 call_netdevice_notifiers(NETDEV_UNREGISTER
, dev
);
3823 * Flush the unicast and multicast chains
3825 dev_addr_discard(dev
);
3830 /* Notifier chain MUST detach us from master device. */
3831 BUG_TRAP(!dev
->master
);
3833 /* Remove entries from kobject tree */
3834 netdev_unregister_kobject(dev
);
3841 static void __netdev_init_queue_locks_one(struct net_device
*dev
,
3842 struct netdev_queue
*dev_queue
,
3845 spin_lock_init(&dev_queue
->_xmit_lock
);
3846 netdev_set_lockdep_class(&dev_queue
->_xmit_lock
, dev
->type
);
3847 dev_queue
->xmit_lock_owner
= -1;
3850 static void netdev_init_queue_locks(struct net_device
*dev
)
3852 netdev_for_each_tx_queue(dev
, __netdev_init_queue_locks_one
, NULL
);
3853 __netdev_init_queue_locks_one(dev
, &dev
->rx_queue
, NULL
);
3857 * register_netdevice - register a network device
3858 * @dev: device to register
3860 * Take a completed network device structure and add it to the kernel
3861 * interfaces. A %NETDEV_REGISTER message is sent to the netdev notifier
3862 * chain. 0 is returned on success. A negative errno code is returned
3863 * on a failure to set up the device, or if the name is a duplicate.
3865 * Callers must hold the rtnl semaphore. You may want
3866 * register_netdev() instead of this.
3869 * The locking appears insufficient to guarantee two parallel registers
3870 * will not get the same name.
3873 int register_netdevice(struct net_device
*dev
)
3875 struct hlist_head
*head
;
3876 struct hlist_node
*p
;
3880 BUG_ON(dev_boot_phase
);
3885 /* When net_device's are persistent, this will be fatal. */
3886 BUG_ON(dev
->reg_state
!= NETREG_UNINITIALIZED
);
3887 BUG_ON(!dev_net(dev
));
3890 spin_lock_init(&dev
->addr_list_lock
);
3891 netdev_init_queue_locks(dev
);
3895 /* Init, if this function is available */
3897 ret
= dev
->init(dev
);
3905 if (!dev_valid_name(dev
->name
)) {
3910 dev
->ifindex
= dev_new_index(net
);
3911 if (dev
->iflink
== -1)
3912 dev
->iflink
= dev
->ifindex
;
3914 /* Check for existence of name */
3915 head
= dev_name_hash(net
, dev
->name
);
3916 hlist_for_each(p
, head
) {
3917 struct net_device
*d
3918 = hlist_entry(p
, struct net_device
, name_hlist
);
3919 if (!strncmp(d
->name
, dev
->name
, IFNAMSIZ
)) {
3925 /* Fix illegal checksum combinations */
3926 if ((dev
->features
& NETIF_F_HW_CSUM
) &&
3927 (dev
->features
& (NETIF_F_IP_CSUM
|NETIF_F_IPV6_CSUM
))) {
3928 printk(KERN_NOTICE
"%s: mixed HW and IP checksum settings.\n",
3930 dev
->features
&= ~(NETIF_F_IP_CSUM
|NETIF_F_IPV6_CSUM
);
3933 if ((dev
->features
& NETIF_F_NO_CSUM
) &&
3934 (dev
->features
& (NETIF_F_HW_CSUM
|NETIF_F_IP_CSUM
|NETIF_F_IPV6_CSUM
))) {
3935 printk(KERN_NOTICE
"%s: mixed no checksumming and other settings.\n",
3937 dev
->features
&= ~(NETIF_F_IP_CSUM
|NETIF_F_IPV6_CSUM
|NETIF_F_HW_CSUM
);
3941 /* Fix illegal SG+CSUM combinations. */
3942 if ((dev
->features
& NETIF_F_SG
) &&
3943 !(dev
->features
& NETIF_F_ALL_CSUM
)) {
3944 printk(KERN_NOTICE
"%s: Dropping NETIF_F_SG since no checksum feature.\n",
3946 dev
->features
&= ~NETIF_F_SG
;
3949 /* TSO requires that SG is present as well. */
3950 if ((dev
->features
& NETIF_F_TSO
) &&
3951 !(dev
->features
& NETIF_F_SG
)) {
3952 printk(KERN_NOTICE
"%s: Dropping NETIF_F_TSO since no SG feature.\n",
3954 dev
->features
&= ~NETIF_F_TSO
;
3956 if (dev
->features
& NETIF_F_UFO
) {
3957 if (!(dev
->features
& NETIF_F_HW_CSUM
)) {
3958 printk(KERN_ERR
"%s: Dropping NETIF_F_UFO since no "
3959 "NETIF_F_HW_CSUM feature.\n",
3961 dev
->features
&= ~NETIF_F_UFO
;
3963 if (!(dev
->features
& NETIF_F_SG
)) {
3964 printk(KERN_ERR
"%s: Dropping NETIF_F_UFO since no "
3965 "NETIF_F_SG feature.\n",
3967 dev
->features
&= ~NETIF_F_UFO
;
3971 netdev_initialize_kobject(dev
);
3972 ret
= netdev_register_kobject(dev
);
3975 dev
->reg_state
= NETREG_REGISTERED
;
3978 * Default initial state at registry is that the
3979 * device is present.
3982 set_bit(__LINK_STATE_PRESENT
, &dev
->state
);
3984 dev_init_scheduler(dev
);
3986 list_netdevice(dev
);
3988 /* Notify protocols, that a new device appeared. */
3989 ret
= call_netdevice_notifiers(NETDEV_REGISTER
, dev
);
3990 ret
= notifier_to_errno(ret
);
3992 rollback_registered(dev
);
3993 dev
->reg_state
= NETREG_UNREGISTERED
;
4006 * register_netdev - register a network device
4007 * @dev: device to register
4009 * Take a completed network device structure and add it to the kernel
4010 * interfaces. A %NETDEV_REGISTER message is sent to the netdev notifier
4011 * chain. 0 is returned on success. A negative errno code is returned
4012 * on a failure to set up the device, or if the name is a duplicate.
4014 * This is a wrapper around register_netdevice that takes the rtnl semaphore
4015 * and expands the device name if you passed a format string to
4018 int register_netdev(struct net_device
*dev
)
4025 * If the name is a format string the caller wants us to do a
4028 if (strchr(dev
->name
, '%')) {
4029 err
= dev_alloc_name(dev
, dev
->name
);
4034 err
= register_netdevice(dev
);
4039 EXPORT_SYMBOL(register_netdev
);
4042 * netdev_wait_allrefs - wait until all references are gone.
4044 * This is called when unregistering network devices.
4046 * Any protocol or device that holds a reference should register
4047 * for netdevice notification, and cleanup and put back the
4048 * reference if they receive an UNREGISTER event.
4049 * We can get stuck here if buggy protocols don't correctly
4052 static void netdev_wait_allrefs(struct net_device
*dev
)
4054 unsigned long rebroadcast_time
, warning_time
;
4056 rebroadcast_time
= warning_time
= jiffies
;
4057 while (atomic_read(&dev
->refcnt
) != 0) {
4058 if (time_after(jiffies
, rebroadcast_time
+ 1 * HZ
)) {
4061 /* Rebroadcast unregister notification */
4062 call_netdevice_notifiers(NETDEV_UNREGISTER
, dev
);
4064 if (test_bit(__LINK_STATE_LINKWATCH_PENDING
,
4066 /* We must not have linkwatch events
4067 * pending on unregister. If this
4068 * happens, we simply run the queue
4069 * unscheduled, resulting in a noop
4072 linkwatch_run_queue();
4077 rebroadcast_time
= jiffies
;
4082 if (time_after(jiffies
, warning_time
+ 10 * HZ
)) {
4083 printk(KERN_EMERG
"unregister_netdevice: "
4084 "waiting for %s to become free. Usage "
4086 dev
->name
, atomic_read(&dev
->refcnt
));
4087 warning_time
= jiffies
;
4096 * register_netdevice(x1);
4097 * register_netdevice(x2);
4099 * unregister_netdevice(y1);
4100 * unregister_netdevice(y2);
4106 * We are invoked by rtnl_unlock() after it drops the semaphore.
4107 * This allows us to deal with problems:
4108 * 1) We can delete sysfs objects which invoke hotplug
4109 * without deadlocking with linkwatch via keventd.
4110 * 2) Since we run with the RTNL semaphore not held, we can sleep
4111 * safely in order to wait for the netdev refcnt to drop to zero.
4113 static DEFINE_MUTEX(net_todo_run_mutex
);
4114 void netdev_run_todo(void)
4116 struct list_head list
;
4118 /* Need to guard against multiple cpu's getting out of order. */
4119 mutex_lock(&net_todo_run_mutex
);
4121 /* Not safe to do outside the semaphore. We must not return
4122 * until all unregister events invoked by the local processor
4123 * have been completed (either by this todo run, or one on
4126 if (list_empty(&net_todo_list
))
4129 /* Snapshot list, allow later requests */
4130 spin_lock(&net_todo_list_lock
);
4131 list_replace_init(&net_todo_list
, &list
);
4132 spin_unlock(&net_todo_list_lock
);
4134 while (!list_empty(&list
)) {
4135 struct net_device
*dev
4136 = list_entry(list
.next
, struct net_device
, todo_list
);
4137 list_del(&dev
->todo_list
);
4139 if (unlikely(dev
->reg_state
!= NETREG_UNREGISTERING
)) {
4140 printk(KERN_ERR
"network todo '%s' but state %d\n",
4141 dev
->name
, dev
->reg_state
);
4146 dev
->reg_state
= NETREG_UNREGISTERED
;
4148 netdev_wait_allrefs(dev
);
4151 BUG_ON(atomic_read(&dev
->refcnt
));
4152 BUG_TRAP(!dev
->ip_ptr
);
4153 BUG_TRAP(!dev
->ip6_ptr
);
4154 BUG_TRAP(!dev
->dn_ptr
);
4156 if (dev
->destructor
)
4157 dev
->destructor(dev
);
4159 /* Free network device */
4160 kobject_put(&dev
->dev
.kobj
);
4164 mutex_unlock(&net_todo_run_mutex
);
4167 static struct net_device_stats
*internal_stats(struct net_device
*dev
)
4172 static void netdev_init_one_queue(struct net_device
*dev
,
4173 struct netdev_queue
*queue
,
4179 static void netdev_init_queues(struct net_device
*dev
)
4181 netdev_init_one_queue(dev
, &dev
->rx_queue
, NULL
);
4182 netdev_for_each_tx_queue(dev
, netdev_init_one_queue
, NULL
);
4186 * alloc_netdev_mq - allocate network device
4187 * @sizeof_priv: size of private data to allocate space for
4188 * @name: device name format string
4189 * @setup: callback to initialize device
4190 * @queue_count: the number of subqueues to allocate
4192 * Allocates a struct net_device with private data area for driver use
4193 * and performs basic initialization. Also allocates subquue structs
4194 * for each queue on the device at the end of the netdevice.
4196 struct net_device
*alloc_netdev_mq(int sizeof_priv
, const char *name
,
4197 void (*setup
)(struct net_device
*), unsigned int queue_count
)
4199 struct netdev_queue
*tx
;
4200 struct net_device
*dev
;
4204 BUG_ON(strlen(name
) >= sizeof(dev
->name
));
4206 alloc_size
= sizeof(struct net_device
);
4208 /* ensure 32-byte alignment of private area */
4209 alloc_size
= (alloc_size
+ NETDEV_ALIGN_CONST
) & ~NETDEV_ALIGN_CONST
;
4210 alloc_size
+= sizeof_priv
;
4212 /* ensure 32-byte alignment of whole construct */
4213 alloc_size
+= NETDEV_ALIGN_CONST
;
4215 p
= kzalloc(alloc_size
, GFP_KERNEL
);
4217 printk(KERN_ERR
"alloc_netdev: Unable to allocate device.\n");
4221 tx
= kzalloc(sizeof(struct netdev_queue
) * queue_count
, GFP_KERNEL
);
4223 printk(KERN_ERR
"alloc_netdev: Unable to allocate "
4229 dev
= (struct net_device
*)
4230 (((long)p
+ NETDEV_ALIGN_CONST
) & ~NETDEV_ALIGN_CONST
);
4231 dev
->padded
= (char *)dev
- (char *)p
;
4232 dev_net_set(dev
, &init_net
);
4235 dev
->num_tx_queues
= queue_count
;
4236 dev
->real_num_tx_queues
= queue_count
;
4239 dev
->priv
= ((char *)dev
+
4240 ((sizeof(struct net_device
) + NETDEV_ALIGN_CONST
)
4241 & ~NETDEV_ALIGN_CONST
));
4244 dev
->gso_max_size
= GSO_MAX_SIZE
;
4246 netdev_init_queues(dev
);
4248 dev
->get_stats
= internal_stats
;
4249 netpoll_netdev_init(dev
);
4251 strcpy(dev
->name
, name
);
4254 EXPORT_SYMBOL(alloc_netdev_mq
);
4257 * free_netdev - free network device
4260 * This function does the last stage of destroying an allocated device
4261 * interface. The reference to the device object is released.
4262 * If this is the last reference then it will be freed.
4264 void free_netdev(struct net_device
*dev
)
4266 release_net(dev_net(dev
));
4270 /* Compatibility with error handling in drivers */
4271 if (dev
->reg_state
== NETREG_UNINITIALIZED
) {
4272 kfree((char *)dev
- dev
->padded
);
4276 BUG_ON(dev
->reg_state
!= NETREG_UNREGISTERED
);
4277 dev
->reg_state
= NETREG_RELEASED
;
4279 /* will free via device release */
4280 put_device(&dev
->dev
);
4283 /* Synchronize with packet receive processing. */
4284 void synchronize_net(void)
4291 * unregister_netdevice - remove device from the kernel
4294 * This function shuts down a device interface and removes it
4295 * from the kernel tables.
4297 * Callers must hold the rtnl semaphore. You may want
4298 * unregister_netdev() instead of this.
4301 void unregister_netdevice(struct net_device
*dev
)
4305 rollback_registered(dev
);
4306 /* Finish processing unregister after unlock */
4311 * unregister_netdev - remove device from the kernel
4314 * This function shuts down a device interface and removes it
4315 * from the kernel tables.
4317 * This is just a wrapper for unregister_netdevice that takes
4318 * the rtnl semaphore. In general you want to use this and not
4319 * unregister_netdevice.
4321 void unregister_netdev(struct net_device
*dev
)
4324 unregister_netdevice(dev
);
4328 EXPORT_SYMBOL(unregister_netdev
);
4331 * dev_change_net_namespace - move device to different nethost namespace
4333 * @net: network namespace
4334 * @pat: If not NULL name pattern to try if the current device name
4335 * is already taken in the destination network namespace.
4337 * This function shuts down a device interface and moves it
4338 * to a new network namespace. On success 0 is returned, on
4339 * a failure a netagive errno code is returned.
4341 * Callers must hold the rtnl semaphore.
4344 int dev_change_net_namespace(struct net_device
*dev
, struct net
*net
, const char *pat
)
4347 const char *destname
;
4352 /* Don't allow namespace local devices to be moved. */
4354 if (dev
->features
& NETIF_F_NETNS_LOCAL
)
4357 /* Ensure the device has been registrered */
4359 if (dev
->reg_state
!= NETREG_REGISTERED
)
4362 /* Get out if there is nothing todo */
4364 if (net_eq(dev_net(dev
), net
))
4367 /* Pick the destination device name, and ensure
4368 * we can use it in the destination network namespace.
4371 destname
= dev
->name
;
4372 if (__dev_get_by_name(net
, destname
)) {
4373 /* We get here if we can't use the current device name */
4376 if (!dev_valid_name(pat
))
4378 if (strchr(pat
, '%')) {
4379 if (__dev_alloc_name(net
, pat
, buf
) < 0)
4384 if (__dev_get_by_name(net
, destname
))
4389 * And now a mini version of register_netdevice unregister_netdevice.
4392 /* If device is running close it first. */
4395 /* And unlink it from device chain */
4397 unlist_netdevice(dev
);
4401 /* Shutdown queueing discipline. */
4404 /* Notify protocols, that we are about to destroy
4405 this device. They should clean all the things.
4407 call_netdevice_notifiers(NETDEV_UNREGISTER
, dev
);
4410 * Flush the unicast and multicast chains
4412 dev_addr_discard(dev
);
4414 /* Actually switch the network namespace */
4415 dev_net_set(dev
, net
);
4417 /* Assign the new device name */
4418 if (destname
!= dev
->name
)
4419 strcpy(dev
->name
, destname
);
4421 /* If there is an ifindex conflict assign a new one */
4422 if (__dev_get_by_index(net
, dev
->ifindex
)) {
4423 int iflink
= (dev
->iflink
== dev
->ifindex
);
4424 dev
->ifindex
= dev_new_index(net
);
4426 dev
->iflink
= dev
->ifindex
;
4429 /* Fixup kobjects */
4430 netdev_unregister_kobject(dev
);
4431 err
= netdev_register_kobject(dev
);
4434 /* Add the device back in the hashes */
4435 list_netdevice(dev
);
4437 /* Notify protocols, that a new device appeared. */
4438 call_netdevice_notifiers(NETDEV_REGISTER
, dev
);
4446 static int dev_cpu_callback(struct notifier_block
*nfb
,
4447 unsigned long action
,
4450 struct sk_buff
**list_skb
;
4451 struct Qdisc
**list_net
;
4452 struct sk_buff
*skb
;
4453 unsigned int cpu
, oldcpu
= (unsigned long)ocpu
;
4454 struct softnet_data
*sd
, *oldsd
;
4456 if (action
!= CPU_DEAD
&& action
!= CPU_DEAD_FROZEN
)
4459 local_irq_disable();
4460 cpu
= smp_processor_id();
4461 sd
= &per_cpu(softnet_data
, cpu
);
4462 oldsd
= &per_cpu(softnet_data
, oldcpu
);
4464 /* Find end of our completion_queue. */
4465 list_skb
= &sd
->completion_queue
;
4467 list_skb
= &(*list_skb
)->next
;
4468 /* Append completion queue from offline CPU. */
4469 *list_skb
= oldsd
->completion_queue
;
4470 oldsd
->completion_queue
= NULL
;
4472 /* Find end of our output_queue. */
4473 list_net
= &sd
->output_queue
;
4475 list_net
= &(*list_net
)->next_sched
;
4476 /* Append output queue from offline CPU. */
4477 *list_net
= oldsd
->output_queue
;
4478 oldsd
->output_queue
= NULL
;
4480 raise_softirq_irqoff(NET_TX_SOFTIRQ
);
4483 /* Process offline CPU's input_pkt_queue */
4484 while ((skb
= __skb_dequeue(&oldsd
->input_pkt_queue
)))
4490 #ifdef CONFIG_NET_DMA
4492 * net_dma_rebalance - try to maintain one DMA channel per CPU
4493 * @net_dma: DMA client and associated data (lock, channels, channel_mask)
4495 * This is called when the number of channels allocated to the net_dma client
4496 * changes. The net_dma client tries to have one DMA channel per CPU.
4499 static void net_dma_rebalance(struct net_dma
*net_dma
)
4501 unsigned int cpu
, i
, n
, chan_idx
;
4502 struct dma_chan
*chan
;
4504 if (cpus_empty(net_dma
->channel_mask
)) {
4505 for_each_online_cpu(cpu
)
4506 rcu_assign_pointer(per_cpu(softnet_data
, cpu
).net_dma
, NULL
);
4511 cpu
= first_cpu(cpu_online_map
);
4513 for_each_cpu_mask_nr(chan_idx
, net_dma
->channel_mask
) {
4514 chan
= net_dma
->channels
[chan_idx
];
4516 n
= ((num_online_cpus() / cpus_weight(net_dma
->channel_mask
))
4517 + (i
< (num_online_cpus() %
4518 cpus_weight(net_dma
->channel_mask
)) ? 1 : 0));
4521 per_cpu(softnet_data
, cpu
).net_dma
= chan
;
4522 cpu
= next_cpu(cpu
, cpu_online_map
);
4530 * netdev_dma_event - event callback for the net_dma_client
4531 * @client: should always be net_dma_client
4532 * @chan: DMA channel for the event
4533 * @state: DMA state to be handled
4535 static enum dma_state_client
4536 netdev_dma_event(struct dma_client
*client
, struct dma_chan
*chan
,
4537 enum dma_state state
)
4539 int i
, found
= 0, pos
= -1;
4540 struct net_dma
*net_dma
=
4541 container_of(client
, struct net_dma
, client
);
4542 enum dma_state_client ack
= DMA_DUP
; /* default: take no action */
4544 spin_lock(&net_dma
->lock
);
4546 case DMA_RESOURCE_AVAILABLE
:
4547 for (i
= 0; i
< nr_cpu_ids
; i
++)
4548 if (net_dma
->channels
[i
] == chan
) {
4551 } else if (net_dma
->channels
[i
] == NULL
&& pos
< 0)
4554 if (!found
&& pos
>= 0) {
4556 net_dma
->channels
[pos
] = chan
;
4557 cpu_set(pos
, net_dma
->channel_mask
);
4558 net_dma_rebalance(net_dma
);
4561 case DMA_RESOURCE_REMOVED
:
4562 for (i
= 0; i
< nr_cpu_ids
; i
++)
4563 if (net_dma
->channels
[i
] == chan
) {
4571 cpu_clear(pos
, net_dma
->channel_mask
);
4572 net_dma
->channels
[i
] = NULL
;
4573 net_dma_rebalance(net_dma
);
4579 spin_unlock(&net_dma
->lock
);
4585 * netdev_dma_regiser - register the networking subsystem as a DMA client
4587 static int __init
netdev_dma_register(void)
4589 net_dma
.channels
= kzalloc(nr_cpu_ids
* sizeof(struct net_dma
),
4591 if (unlikely(!net_dma
.channels
)) {
4593 "netdev_dma: no memory for net_dma.channels\n");
4596 spin_lock_init(&net_dma
.lock
);
4597 dma_cap_set(DMA_MEMCPY
, net_dma
.client
.cap_mask
);
4598 dma_async_client_register(&net_dma
.client
);
4599 dma_async_client_chan_request(&net_dma
.client
);
4604 static int __init
netdev_dma_register(void) { return -ENODEV
; }
4605 #endif /* CONFIG_NET_DMA */
4608 * netdev_compute_feature - compute conjunction of two feature sets
4609 * @all: first feature set
4610 * @one: second feature set
4612 * Computes a new feature set after adding a device with feature set
4613 * @one to the master device with current feature set @all. Returns
4614 * the new feature set.
4616 int netdev_compute_features(unsigned long all
, unsigned long one
)
4618 /* if device needs checksumming, downgrade to hw checksumming */
4619 if (all
& NETIF_F_NO_CSUM
&& !(one
& NETIF_F_NO_CSUM
))
4620 all
^= NETIF_F_NO_CSUM
| NETIF_F_HW_CSUM
;
4622 /* if device can't do all checksum, downgrade to ipv4/ipv6 */
4623 if (all
& NETIF_F_HW_CSUM
&& !(one
& NETIF_F_HW_CSUM
))
4624 all
^= NETIF_F_HW_CSUM
4625 | NETIF_F_IP_CSUM
| NETIF_F_IPV6_CSUM
;
4627 if (one
& NETIF_F_GSO
)
4628 one
|= NETIF_F_GSO_SOFTWARE
;
4631 /* If even one device supports robust GSO, enable it for all. */
4632 if (one
& NETIF_F_GSO_ROBUST
)
4633 all
|= NETIF_F_GSO_ROBUST
;
4635 all
&= one
| NETIF_F_LLTX
;
4637 if (!(all
& NETIF_F_ALL_CSUM
))
4639 if (!(all
& NETIF_F_SG
))
4640 all
&= ~NETIF_F_GSO_MASK
;
4644 EXPORT_SYMBOL(netdev_compute_features
);
4646 static struct hlist_head
*netdev_create_hash(void)
4649 struct hlist_head
*hash
;
4651 hash
= kmalloc(sizeof(*hash
) * NETDEV_HASHENTRIES
, GFP_KERNEL
);
4653 for (i
= 0; i
< NETDEV_HASHENTRIES
; i
++)
4654 INIT_HLIST_HEAD(&hash
[i
]);
4659 /* Initialize per network namespace state */
4660 static int __net_init
netdev_init(struct net
*net
)
4662 INIT_LIST_HEAD(&net
->dev_base_head
);
4664 net
->dev_name_head
= netdev_create_hash();
4665 if (net
->dev_name_head
== NULL
)
4668 net
->dev_index_head
= netdev_create_hash();
4669 if (net
->dev_index_head
== NULL
)
4675 kfree(net
->dev_name_head
);
4680 static void __net_exit
netdev_exit(struct net
*net
)
4682 kfree(net
->dev_name_head
);
4683 kfree(net
->dev_index_head
);
4686 static struct pernet_operations __net_initdata netdev_net_ops
= {
4687 .init
= netdev_init
,
4688 .exit
= netdev_exit
,
4691 static void __net_exit
default_device_exit(struct net
*net
)
4693 struct net_device
*dev
, *next
;
4695 * Push all migratable of the network devices back to the
4696 * initial network namespace
4699 for_each_netdev_safe(net
, dev
, next
) {
4701 char fb_name
[IFNAMSIZ
];
4703 /* Ignore unmoveable devices (i.e. loopback) */
4704 if (dev
->features
& NETIF_F_NETNS_LOCAL
)
4707 /* Push remaing network devices to init_net */
4708 snprintf(fb_name
, IFNAMSIZ
, "dev%d", dev
->ifindex
);
4709 err
= dev_change_net_namespace(dev
, &init_net
, fb_name
);
4711 printk(KERN_EMERG
"%s: failed to move %s to init_net: %d\n",
4712 __func__
, dev
->name
, err
);
4719 static struct pernet_operations __net_initdata default_device_ops
= {
4720 .exit
= default_device_exit
,
4724 * Initialize the DEV module. At boot time this walks the device list and
4725 * unhooks any devices that fail to initialise (normally hardware not
4726 * present) and leaves us with a valid list of present and active devices.
4731 * This is called single threaded during boot, so no need
4732 * to take the rtnl semaphore.
4734 static int __init
net_dev_init(void)
4736 int i
, rc
= -ENOMEM
;
4738 BUG_ON(!dev_boot_phase
);
4740 if (dev_proc_init())
4743 if (netdev_kobject_init())
4746 INIT_LIST_HEAD(&ptype_all
);
4747 for (i
= 0; i
< PTYPE_HASH_SIZE
; i
++)
4748 INIT_LIST_HEAD(&ptype_base
[i
]);
4750 if (register_pernet_subsys(&netdev_net_ops
))
4753 if (register_pernet_device(&default_device_ops
))
4757 * Initialise the packet receive queues.
4760 for_each_possible_cpu(i
) {
4761 struct softnet_data
*queue
;
4763 queue
= &per_cpu(softnet_data
, i
);
4764 skb_queue_head_init(&queue
->input_pkt_queue
);
4765 queue
->completion_queue
= NULL
;
4766 INIT_LIST_HEAD(&queue
->poll_list
);
4768 queue
->backlog
.poll
= process_backlog
;
4769 queue
->backlog
.weight
= weight_p
;
4772 netdev_dma_register();
4776 open_softirq(NET_TX_SOFTIRQ
, net_tx_action
);
4777 open_softirq(NET_RX_SOFTIRQ
, net_rx_action
);
4779 hotcpu_notifier(dev_cpu_callback
, 0);
4787 subsys_initcall(net_dev_init
);
4789 EXPORT_SYMBOL(__dev_get_by_index
);
4790 EXPORT_SYMBOL(__dev_get_by_name
);
4791 EXPORT_SYMBOL(__dev_remove_pack
);
4792 EXPORT_SYMBOL(dev_valid_name
);
4793 EXPORT_SYMBOL(dev_add_pack
);
4794 EXPORT_SYMBOL(dev_alloc_name
);
4795 EXPORT_SYMBOL(dev_close
);
4796 EXPORT_SYMBOL(dev_get_by_flags
);
4797 EXPORT_SYMBOL(dev_get_by_index
);
4798 EXPORT_SYMBOL(dev_get_by_name
);
4799 EXPORT_SYMBOL(dev_open
);
4800 EXPORT_SYMBOL(dev_queue_xmit
);
4801 EXPORT_SYMBOL(dev_remove_pack
);
4802 EXPORT_SYMBOL(dev_set_allmulti
);
4803 EXPORT_SYMBOL(dev_set_promiscuity
);
4804 EXPORT_SYMBOL(dev_change_flags
);
4805 EXPORT_SYMBOL(dev_set_mtu
);
4806 EXPORT_SYMBOL(dev_set_mac_address
);
4807 EXPORT_SYMBOL(free_netdev
);
4808 EXPORT_SYMBOL(netdev_boot_setup_check
);
4809 EXPORT_SYMBOL(netdev_set_master
);
4810 EXPORT_SYMBOL(netdev_state_change
);
4811 EXPORT_SYMBOL(netif_receive_skb
);
4812 EXPORT_SYMBOL(netif_rx
);
4813 EXPORT_SYMBOL(register_gifconf
);
4814 EXPORT_SYMBOL(register_netdevice
);
4815 EXPORT_SYMBOL(register_netdevice_notifier
);
4816 EXPORT_SYMBOL(skb_checksum_help
);
4817 EXPORT_SYMBOL(synchronize_net
);
4818 EXPORT_SYMBOL(unregister_netdevice
);
4819 EXPORT_SYMBOL(unregister_netdevice_notifier
);
4820 EXPORT_SYMBOL(net_enable_timestamp
);
4821 EXPORT_SYMBOL(net_disable_timestamp
);
4822 EXPORT_SYMBOL(dev_get_flags
);
4824 #if defined(CONFIG_BRIDGE) || defined(CONFIG_BRIDGE_MODULE)
4825 EXPORT_SYMBOL(br_handle_frame_hook
);
4826 EXPORT_SYMBOL(br_fdb_get_hook
);
4827 EXPORT_SYMBOL(br_fdb_put_hook
);
4831 EXPORT_SYMBOL(dev_load
);
4834 EXPORT_PER_CPU_SYMBOL(softnet_data
);